diff --git a/ScoreboardExt/Classes/ClassicStyle.uc b/ScoreboardExt/Classes/ClassicStyle.uc
index 81f6fe3..7a49a9a 100644
--- a/ScoreboardExt/Classes/ClassicStyle.uc
+++ b/ScoreboardExt/Classes/ClassicStyle.uc
@@ -2,405 +2,405 @@ 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;
+	local int XS,YS,TitleHeight;
+	local float XL, YL, FontScale;
 
-    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);
-    }
+	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;
+	local int XS,YS;
 
-    // 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);
+	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;
+	local int i;
+	local float X,Y,XS,YS,TX,TY,TS,DefFontHeight;
 
-    Canvas.Font = PickFont(TS);
+	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;
+	// 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;
 
-    X = TT.CompPos[0];
-    Y = TT.CompPos[1]+24.f;
+	// Give some borders.
+	TX += TOOLTIP_BORDER*2;
+	TY += TOOLTIP_BORDER*2;
 
-    // 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);
+	X = TT.CompPos[0];
+	Y = TT.CompPos[1]+24.f;
 
-    // Reset clipping.
-    Canvas.SetOrigin(0,0);
-    Canvas.SetClip(TT.Owner.ScreenSize.X,TT.Owner.ScreenSize.Y);
+	// 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;
 
-    // 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;
+	if( TT.CurrentAlpha<255 )
+		TT.CurrentAlpha = Min(TT.CurrentAlpha+25,255);
 
-    // 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;
-    }
+	// 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;
+	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);
+	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;
+	Canvas.SetPos(0.f, 0.f);
+	Canvas.DrawTileStretched(BorderTextures[`BOX_INNERBORDER],S.CompPos[2],S.CompPos[3],0,0,128,128);
 
-    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);
-    }
+	if( S.bDisabled )
+		return;
 
-    A = float(S.CurrentScroll) / float(S.MaxRange);
-    S.ButtonOffset = A*(S.CompPos[i]-S.SliderScale);
+	if( S.bVertical )
+		i = 3;
+	else i = 2;
 
-    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);
+	S.SliderScale = FMax(S.PageStep * (S.CompPos[i] - 32.f) / (S.MaxRange + S.PageStep),S.CalcButtonScale);
 
-    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);
-    }
+	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]);
+	local Texture CheckMark;
 
-    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());
-    }
+	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.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);
 
-    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();
-    }
+	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);
+	local float X,Y,YL,YP,Edge;
+	local int i;
+	local bool bCheckMouse;
 
-    // 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;
+	// 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);
 
-    YP = Edge;
-    C.CurrentRow = -1;
+	// While rendering, figure out mouse focus row.
+	X = C.Owner.MousePosition.X - Canvas.OrgX;
+	Y = C.Owner.MousePosition.Y - Canvas.OrgY;
 
-    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;
+	bCheckMouse = (X>0.f && X<C.CompPos[2] && Y>0.f && Y<C.CompPos[3]);
 
-        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);
-    }
+	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);
+	local float X,Y,XL,YL,YP,Edge,TextScale;
+	local int i;
+	local bool bCheckMouse;
+	local string S;
 
-    // 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);
+	// Draw background.
+	Edge = C.EdgeSize;
+	DrawOutlinedBox(0.f,0.f,C.CompPos[2],C.CompPos[3],Edge,C.BoxColor,C.OutlineColor);
 
-    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);
-        }
+	// While rendering, figure out mouse focus row.
+	X = C.Owner.MousePosition.X - Canvas.OrgX;
+	Y = C.Owner.MousePosition.Y - Canvas.OrgY;
 
-        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);
-    }
+	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;
+	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);
+	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];
 
-        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);
-            }
-        }
-    }
+		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
diff --git a/ScoreboardExt/Classes/GUIStyleBase.uc b/ScoreboardExt/Classes/GUIStyleBase.uc
index c161dae..e014538 100644
--- a/ScoreboardExt/Classes/GUIStyleBase.uc
+++ b/ScoreboardExt/Classes/GUIStyleBase.uc
@@ -1,5 +1,5 @@
 Class GUIStyleBase extends Object
-    abstract;
+	abstract;
 
 var Texture2D ItemTex;
 var array<Texture2D> BorderTextures, ArrowTextures, ButtonTextures, TabTextures, ItemBoxTextures, PerkBox, CheckBoxTextures, ProgressBarTextures, SliderTextures;
@@ -18,114 +18,114 @@ var Color BlurColor, BlurColor2;
 
 struct FColorInfo
 {
-    var name Code;
-    var Color Color;
+	var name Code;
+	var Color Color;
 };
 var array<FColorInfo> ColorCodes;
 
 struct FTexturePreCache
 {
-    var string Path;
-    var Texture2D Tex;
+	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);
+	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 );
@@ -141,725 +141,726 @@ 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;
+	Scaler = GetFontScaler();
+
+	if( bNumbersOnly )
+		return NumberFont;
+	else if( bInfinite )
+		return InfiniteFont;
+
+	return MainFont;
 }
 
 function PickDefaultFontSize( float YRes )
 {
-    local int XL,YL;
-    local string S;
+	local int XL,YL;
+	local string S;
 
-    S="ABC";
-    PickFont(YRes).GetStringHeightAndWidth(S,YL,XL);
-    
-    DefaultHeight=float(YL)*YRes;
+	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 );
+	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);
+	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);
+	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;
+	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);
+	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;
+	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");
+	local float XL,YL;
+	local int i, Index;
+	local array<string> SArray;
+	local string T, PrevT;
+	local Color TextColor;
 
-        PrevT = Left(S,InStr(S, "\\c"));
-        if( Len(PrevT) > 0 )
-        {
-            Canvas.TextSize(PrevT,XL,YL,Scale,Scale);
+	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");
 
-            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);
-            }
+		PrevT = Left(S,InStr(S, "\\c"));
+		if( Len(PrevT) > 0 )
+		{
+			Canvas.TextSize(PrevT,XL,YL,Scale,Scale);
 
-            X += XL;
-        }
-    }
+			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);
+	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);
+	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);
+	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);
+	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;
+	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;
-    }
+	Path = S;
+	i = InStr(Path,"<Icon>");
+	if( i == INDEX_NONE )
+		return None;
 
-    Cache.Path = Path;
-    Cache.Tex = Texture2D(DynamicLoadObject(Path, class'Texture2D'));
-    PrecachedTextures.AddItem(Cache);
-    
-    return Cache.Tex;
+	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>"));
-    }
+	local int i, j;
 
-    return StripColorTags(S);
+	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;
+	local int Minutes, Hours;
+	local string Time;
 
-    if( Seconds > 3600 )
-    {
-        Hours = Seconds / 3600;
-        Seconds -= Hours * 3600;
+	if( Seconds > 3600 )
+	{
+		Hours = Seconds / 3600;
+		Seconds -= Hours * 3600;
 
-        Time = Hours$":";
-    }
-    Minutes = Seconds / 60;
-    Seconds -= Minutes * 60;
+		Time = Hours$":";
+	}
+	Minutes = Seconds / 60;
+	Seconds -= Minutes * 60;
 
-    if( Minutes >= 10 )
-        Time = Time $ Minutes $ ":";
-    else Time = Time $ "0" $ Minutes $ ":";
+	if( Minutes >= 10 )
+		Time = Time $ Minutes $ ":";
+	else Time = Time $ "0" $ Minutes $ ":";
 
-    if( Seconds >= 10 )
-        Time = Time $ Seconds;
-    else Time = Time $ "0" $ Seconds;
+	if( Seconds >= 10 )
+		Time = Time $ Seconds;
+	else Time = Time $ "0" $ Seconds;
 
-    return Time;
+	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);
-    }
+	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);
-    }
+	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);
+	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);
+	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.
 
-    // 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);
+	Canvas.PreOptimizeDrawTiles(Extrav==0 ? 7 : 6, ItemTex);
 
-            // 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);
-    }
+	// 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.PreOptimizeDrawTiles(4, ItemTex);
 
-    Canvas.SetPos(X + Thickness, Y);
-    DrawWhiteBox(Width - Thickness * 2, Thickness);
+	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 + Thickness, Y+Height-Thickness);
+	DrawWhiteBox(Width - Thickness * 2, Thickness);
 
-    Canvas.SetPos(X, Y);
-    DrawWhiteBox(Thickness, Height);
+	Canvas.SetPos(X, Y);
+	DrawWhiteBox(Thickness, Height);
 
-    Canvas.SetPos(X + Width - Thickness, 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);
+	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);
+	// 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);
+	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;
+	Canvas.DrawColor = BoxColor;
 
-    if( BorderSize <= 0 )
-    {
-        Canvas.SetPos(X, Y);
-        DrawWhiteBox(W, H);
-        return;
-    }
-    
-    Canvas.PreOptimizeDrawTiles(7, ItemTex);
+	if( BorderSize <= 0 )
+	{
+		Canvas.SetPos(X, Y);
+		DrawWhiteBox(W, H);
+		return;
+	}
 
-    BorderSize = Min(FMin(BorderSize,(W)*0.5),(H)*0.5);
+	Canvas.PreOptimizeDrawTiles(7, ItemTex);
 
-    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);
+	BorderSize = Min(FMin(BorderSize,(W)*0.5),(H)*0.5);
 
-    DrawBoxCorners(BorderSize, X, Y, W, H, TopLeft, TopRight, BottomLeft, BottomRight);
+	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);
+	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.PreOptimizeDrawTiles(8, ItemTex);
 
-    Canvas.DrawColor = BoxColor;
+	BorderSize = Min(FMin(BorderSize,(W)*0.5),(H)*0.5);
 
-    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);
+	Canvas.DrawColor = BoxColor;
 
-    DrawBoxCorners(BorderSize, X, Y, W, H, TopLeft, TopRight, BottomLeft, BottomRight);
+	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);
+	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);
+	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);
+	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;
+	local float mW,mH,MidX,MidY,SmallTileW,SmallTileH,fX,fY;
+	local int OptimizeTiles;
  
-    if( Tex==None ) Tex = Texture2D'EngineMaterials.DefaultDiffuse';
+	if( Tex==None ) Tex = Texture2D'EngineMaterials.DefaultDiffuse';
  
-    // Get the size of the image
-    mW = Tex.GetSurfaceWidth();
-    mH = Tex.GetSurfaceHeight();
+	// 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);
+	// 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);
+	// 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;
+	// Draw the spans first
+	// Top and Bottom
+	if (mW<XS)
+	{
+		fX = MidX;
  
-        if (mH>YS)
-            fY = YS/2;
-        else
-            fY = MidY;
+		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;
+		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;
+	// 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;
+		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);
-    }
+	// 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);
+	// 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);
+	local float XL, YL;
+	local float CurY, CurX;
 
-    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.TextSize(S, XL, YL, XS, YS);
 
-    Canvas.SetPos(CurX, CurY);
-    Canvas.DrawText(S,,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);
+	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;
+	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;
+	while (Right(S, 1) == " ")
+		S = Left(S, Len(S) - 1);
+	return S;
 }
 
 static final function string Trim(coerce string S)
 {
-    return LTrim(RTrim(S));
+	return LTrim(RTrim(S));
 }
 
 defaultproperties
 {
-    MainFont=Font'KFScoreboardExt_Assets.Font.KFMainFont'
-    NumberFont=Font'UI_Canvas_Fonts.Font_General'
-    InfiniteFont=Font'KFScoreboardExt_Assets.Font.KFInfiniteFont'
+	// Font'UI_Canvas_Fonts.Font_Main'
+	MainFont=Font'KFScoreboardExt_Assets.Font.KFMainFont'
+	NumberFont=Font'UI_Canvas_Fonts.Font_General'
+	InfiniteFont=Font'KFScoreboardExt_Assets.Font.KFInfiniteFont'
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KF2GUIController.uc b/ScoreboardExt/Classes/KF2GUIController.uc
index 94d38fb..13445d8 100644
--- a/ScoreboardExt/Classes/KF2GUIController.uc
+++ b/ScoreboardExt/Classes/KF2GUIController.uc
@@ -1,5 +1,5 @@
 Class KF2GUIController extends Info
-    transient;
+	transient;
 
 var() class<GUIStyleBase> DefaultStyle;
 
@@ -37,956 +37,956 @@ var bool bMouseWasIdle,bIsInMenuState,bAbsorbInput,bIsInvalid,bFinishedReplicati
 
 static function KF2GUIController GetGUIController( PlayerController PC )
 {
-    local KF2GUIController G;
+	local KF2GUIController G;
 
-    if( PC.Player==None )
-    {
-        return None;
-    }
-        
-    foreach PC.ChildActors(class'ScoreboardExt.KF2GUIController',G)
-    {
-        if( !G.bIsInvalid )
-        {
-            break;
-        }
-    }
-    
-    if( G==None )
-    {
-        G = PC.Spawn(class'ScoreboardExt.KF2GUIController',PC);
-    }
-        
-    return G;
+	if( PC.Player==None )
+	{
+		return None;
+	}
+
+	foreach PC.ChildActors(class'ScoreboardExt.KF2GUIController',G)
+	{
+		if( !G.bIsInvalid )
+		{
+			break;
+		}
+	}
+
+	if( G==None )
+	{
+		G = PC.Spawn(class'ScoreboardExt.KF2GUIController',PC);
+	}
+
+	return G;
 }
 
 simulated function PostBeginPlay()
 {
-    PlayerOwner = PlayerController(Owner);
-    ClientViewport = LocalPlayer(PlayerOwner.Player).ViewportClient;
-    HUDOwner = ScoreboardExtHUD(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');
+	PlayerOwner = PlayerController(Owner);
+	ClientViewport = LocalPlayer(PlayerOwner.Player).ViewportClient;
+	HUDOwner = ScoreboardExtHUD(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;
+	if( CursorFlash == 255 )
+		CursorFlash = 0;
+	else CursorFlash = 255;
 }
 
 simulated function SetupStyleTextures()
 {
-    local ObjectReferencer RepObject;
+	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]);
+	RepObject = HUDOwner.RepObject;
+	if( RepObject != None )
+	{
+		CurrentStyle.MainFont = Font(RepObject.ReferencedObjects[104]);
+		CurrentStyle.InfiniteFont = Font(RepObject.ReferencedObjects[155]);
 
-        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');
-    }
+		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);
+	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);
+	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;
-    }
+	Super.Tick(DT);
 
-    FastCursorFade += 8192 * DT * FastCursorStep;
-    if( FastCursorFade<=0 )
-    {
-        FastCursorFade = 0;
-        FastCursorStep = 1;
-    }
-    else if( FastCursorFade>=255 )
-    {
-        FastCursorFade = 255;
-        FastCursorStep = -1;
-    }
+	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);
+	if( PlayerOwner!=None )
+		SetMenuState(false);
 }
 
 simulated function HandleDrawMenu()
 {
-    if( HackConsole==None )
-    {
-        HackConsole = new(ClientViewport)class'ScoreboardExt.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.
-        if( bIsInMenuState ) PlayerOwner.PlayerInput = CustomInput;
-    }
+	if( HackConsole==None )
+	{
+		HackConsole = new(ClientViewport)class'ScoreboardExt.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.
+		if( bIsInMenuState ) PlayerOwner.PlayerInput = CustomInput;
+	}
 }
 simulated function RenderMenu( Canvas C )
 {
-    local int i;
-    local float OrgX,OrgY,ClipX,ClipY;
-    
-    if( !bFinishedReplication )
-        return;
+	local int i;
+	local float OrgX,OrgY,ClipX,ClipY;
 
-    ClientViewport.ViewportConsole = OrgConsole;
+	if( !bFinishedReplication )
+		return;
 
-    OrgX = C.OrgX;
-    OrgY = C.OrgY;
-    ClipX = C.ClipX;
-    ClipY = C.ClipY;
-    
-    ScreenSize.X = C.SizeX;
-    ScreenSize.Y = C.SizeY;
-    CurrentStyle.Canvas = C;
-    CurrentStyle.PickDefaultFontSize(C.SizeY);
-    
-    if( !KFPlayerController(PlayerOwner).MyGFxManager.bMenusActive )
-    {
-        HUDOwner.Canvas = C;
-        
-        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);
+	ClientViewport.ViewportConsole = OrgConsole;
 
-        if (!bHideCursor)
-        {
-            DrawCursor(C, MousePosition.X, MousePosition.Y);
-        }
-    }
-    
-    if( OrgConsole!=None )
-        OrgConsole.PostRender_Console(C);
-    OrgConsole = None;
+	OrgX = C.OrgX;
+	OrgY = C.OrgY;
+	ClipX = C.ClipX;
+	ClipY = C.ClipY;
+
+	ScreenSize.X = C.SizeX;
+	ScreenSize.Y = C.SizeY;
+	CurrentStyle.Canvas = C;
+	CurrentStyle.PickDefaultFontSize(C.SizeY);
+
+	if( !KFPlayerController(PlayerOwner).MyGFxManager.bMenusActive )
+	{
+		HUDOwner.Canvas = C;
+
+		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);
+	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);
-    }
+	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( PlayerOwner.PlayerInput==None )
+	{
+		NotifyLevelChange();
+		bActive = false;
+	}
 
-    if( bIsInMenuState==bActive )
-        return;
-    bIsInMenuState = bActive;
-    bHideCursor = !bActive;
+	if( bIsInMenuState==bActive )
+		return;
+	bIsInMenuState = bActive;
+	bHideCursor = !bActive;
 
-    if( bActive )
-    {
-        if( CustomInput==None )
-        {
-            CustomInput = new (KFPlayerController(PlayerOwner)) class'ScoreboardExt.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( bActive )
+	{
+		if( CustomInput==None )
+		{
+			CustomInput = new (KFPlayerController(PlayerOwner)) class'ScoreboardExt.KF2GUIInput';
+			CustomInput.ControllerOwner = Self;
+			CustomInput.OnReceivedNativeInputKey = ReceivedInputKey;
+			CustomInput.BaseInput = PlayerOwner.PlayerInput;
+			BackupInput = PlayerOwner.PlayerInput;
+			PlayerOwner.Interactions.AddItem(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();
-    }
+		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;
+	local int i;
 
-    if( bIsInvalid )
-        return;
-    bIsInvalid = true;
+	if( bIsInvalid )
+		return;
+	bIsInvalid = true;
 
-    if( InputFocus!=None )
-    {
-        InputFocus.LostInputFocus();
-        InputFocus = None;
-    }
+	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();
+	for( i=(ActiveMenus.Length-1); i>=0; --i )
+		ActiveMenus[i].NotifyLevelChange();
+	for( i=(PersistentMenus.Length-1); i>=0; --i )
+		PersistentMenus[i].NotifyLevelChange();
 
-    SetMenuState(false);
+	SetMenuState(false);
 }
 
 simulated function MenuInput(float DeltaTime)
 {
-    local int i;
-    local vector2D V;
+	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( PlayerOwner.PlayerInput==None )
+	{
+		NotifyLevelChange();
+		return;
+	}
+	if( InputFocus!=None )
+		InputFocus.MenuTick(DeltaTime);
+	for( i=0; i<ActiveMenus.Length; ++i )
+		ActiveMenus[i].MenuTick(DeltaTime);
 
-    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();
+	// 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;
+	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;
-    }
+	// 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;
+	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;
+	local KFGUI_Base Widget;
 
-    if( Widget==None )
-        return None;
-        
-    HUDOwner.HUDWidgets.AddItem(Widget);
-        
-    Widget.Owner = Self;
-    Widget.HUDOwner = HUDOwner;
-    Widget.InitMenu();
-    Widget.ShowMenu();
-    Widget.bIsHUDWidget = true;
-    
-    return 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;
+	local int i;
+	local KFGUI_Page M;
 
-    if( KeyboardFocus!=None )
-        GrabInputFocus(None);
-    if( InputFocus!=None )
-    {
-        InputFocus.LostInputFocus();
-        InputFocus = None;
-    }
+	if( MenuClass==None )
+		return 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( KeyboardFocus!=None )
+		GrabInputFocus(None);
+	if( InputFocus!=None )
+	{
+		InputFocus.LostInputFocus();
+		InputFocus = None;
+	}
 
-    if( M==None ) // Probably abstract class.
-        return None;
-    
-    i = GetFreeIndex(M.bAlwaysTop);
-    ActiveMenus[i] = M;
-    M.Owner = Self;
-    M.InitMenu();
-    M.ShowMenu();
-    return M;
+	// 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;
+	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);
-    }
+	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;
+	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);
+	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.
+	local int i;
 
-    // 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;
+	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;
+	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( Comp==KeyboardFocus && !bForce )
+		return;
 
-    if( KeyboardFocus!=None )
-        KeyboardFocus.LostKeyFocus();
+	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;
+	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;
+	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);
-    }
+	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;
+	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;
-            }
-        }
-    }
+	local KFPlayerInput KFInput;
+	local KeyBind BoundKey;
 
-    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;
+	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);
+	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);
+	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;
+	return false;
 }
 simulated Delegate bool OnReceivedInputAxis( int ControllerId, name Key, float Delta, float DeltaTime, bool bGamepad )
 {
-    return false;
+	return false;
 }
 simulated Delegate bool OnReceivedInputChar( int ControllerId, string Unicode )
 {
-    return false;
+	return false;
 }
 simulated Delegate bool InternalInputKey( int ControllerId, name Key, EInputEvent Event, optional float AmountDepressed=1.f, optional bool bGamepad )
 {
-    return false;
+	return false;
 }
 simulated Delegate bool InternalReceivedInputChar( int ControllerId, string Unicode )
 {
-    return false;
+	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=true
-    bAlwaysTick=true
-    bHideCursor=true
+	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=true
+	bAlwaysTick=true
+	bHideCursor=true
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KF2GUIInput.uc b/ScoreboardExt/Classes/KF2GUIInput.uc
index 7a1afb9..40eb1e4 100644
--- a/ScoreboardExt/Classes/KF2GUIInput.uc
+++ b/ScoreboardExt/Classes/KF2GUIInput.uc
@@ -6,55 +6,55 @@ var PlayerInput BaseInput;
 
 function DrawHUD( HUD H )
 {
-    //ControllerOwner.RenderMenu(H.Canvas);
+	//ControllerOwner.RenderMenu(H.Canvas);
 }
 function PostRender( Canvas Canvas )
 {
-    if( ControllerOwner.bIsInMenuState )
-        ControllerOwner.HandleDrawMenu();
-        //ControllerOwner.RenderMenu(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;
-    }
+	// 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!
+	`Log("PreClientTravel"@PendingURL@TravelType@bIsSeamlessTravel);
+	ControllerOwner.BackupInput.PreClientTravel(PendingURL,TravelType,bIsSeamlessTravel); // Let original mod do stuff too!
+	ControllerOwner.NotifyLevelChange(); // Close menu NOW!
 }
 
 defaultproperties
diff --git a/ScoreboardExt/Classes/KF2Style.uc b/ScoreboardExt/Classes/KF2Style.uc
index 3cb9bdc..3bc549b 100644
--- a/ScoreboardExt/Classes/KF2Style.uc
+++ b/ScoreboardExt/Classes/KF2Style.uc
@@ -5,448 +5,448 @@ const TOOLTIP_BORDER=4;
 
 function InitStyle()
 {
-    local byte i;
+	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';
-    }
+	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;
+	local int XS,YS,CornerSlope,TitleHeight;
 
-    // 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);
-    }
+	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;
+	local int XS,YS,CornerSlope;
 
-    // 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));
+	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;
+	local int i;
+	local float X,Y,XS,YS,TX,TY,TS,DefFontHeight;
 
-    Canvas.Font = PickFont(TS);
+	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;
+	// 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;
 
-    X = TT.CompPos[0];
-    Y = TT.CompPos[1]+24.f;
+	// Give some borders.
+	TX += TOOLTIP_BORDER*2;
+	TY += TOOLTIP_BORDER*2;
 
-    // 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);
+	X = TT.CompPos[0];
+	Y = TT.CompPos[1]+24.f;
 
-    // Reset clipping.
-    Canvas.SetOrigin(0,0);
-    Canvas.SetClip(TT.Owner.ScreenSize.X,TT.Owner.ScreenSize.Y);
+	// 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;
 
-    // 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;
+	if( TT.CurrentAlpha<255 )
+		TT.CurrentAlpha = Min(TT.CurrentAlpha+25,255);
 
-    // 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;
-    }
+	// 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;
+	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);
+	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;
+	DrawRectBox (0.f, 0.f, S.CompPos[2], S.CompPos[3], 4);
 
-    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);
-    }
+	if( S.bDisabled )
+		return;
 
-    A = float(S.CurrentScroll) / float(S.MaxRange);
-    S.ButtonOffset = A*(S.CompPos[i]-S.SliderScale);
+	if( S.bVertical )
+		i = 3;
+	else i = 2;
 
-    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);
+	S.SliderScale = FMax(S.PageStep * (S.CompPos[i] - 32.f) / (S.MaxRange + S.PageStep),S.CalcButtonScale);
 
-    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);
+	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;
+	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);
+	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);
+	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.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);
 
-    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());
-    }
+	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.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);
 
-    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();
-    }
+	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));
+	local float X,Y,YL,YP,Edge;
+	local int i;
+	local bool bCheckMouse;
 
-    // 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;
+	// 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));
 
-    YP = Edge;
-    C.CurrentRow = -1;
+	// While rendering, figure out mouse focus row.
+	X = C.Owner.MousePosition.X - Canvas.OrgX;
+	Y = C.Owner.MousePosition.Y - Canvas.OrgY;
 
-    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;
+	bCheckMouse = (X>0.f && X<C.CompPos[2] && Y>0.f && Y<C.CompPos[3]);
 
-        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);
-    }
+	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));
+	local float X,Y,YP,Edge,TextScale,TexDefHieght;
+	local int i;
+	local bool bCheckMouse;
 
-    // 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);
+	// 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));
 
-    YP = Edge;
-    C.CurrentRow = -1;
+	// While rendering, figure out mouse focus row.
+	X = C.Owner.MousePosition.X - Canvas.OrgX;
+	Y = C.Owner.MousePosition.Y - Canvas.OrgY;
 
-    TexDefHieght = DefaultHeight;
+	bCheckMouse = (X>0.f && X<C.CompPos[2] && Y>0.f && Y<C.CompPos[3]);
 
-    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.Font = PickFont(TextScale);
 
-        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);
-    }
+	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;
+	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);
-    }
+	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);
 
-    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.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);
+	}
 
-    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);
-    }
+	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
+	MaxFontScale=5
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFColorHelper.uc b/ScoreboardExt/Classes/KFColorHelper.uc
index 5196cdc..1de97db 100644
--- a/ScoreboardExt/Classes/KFColorHelper.uc
+++ b/ScoreboardExt/Classes/KFColorHelper.uc
@@ -1,120 +1,120 @@
 //All code here was done by Mr Evil.
 class KFColorHelper extends Object
-    transient;
+	transient;
 
 struct HSVColour
 {
-    var() float H, S, V, A;
+	var() float H, S, V, A;
 
-    structdefaultproperties
-    {
-        A=1.0
-    }
+	structdefaultproperties
+	{
+		A=1.0
+	}
 };
 
 static final function HSVColour RGBToHSV(const LinearColor RGB)
 {
-    local float Max;
-    local float Min;
-    local float Chroma;
-    local HSVColour HSV;
+	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;
+	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 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;
-        }
+			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.H *= 60.0;
+		HSV.S = Chroma / Max;
+	}
 
-    HSV.V = Max;
-    HSV.A = RGB.A;
+	HSV.V = Max;
+	HSV.A = RGB.A;
 
-    return HSV;
+	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;
+	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));
+	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;
-    }
+	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;
+	Min = HSV.V - Chroma;
 
-    RGB.R += Min;
-    RGB.G += Min;
-    RGB.B += Min;
-    RGB.A = HSV.A;
-    
-    return RGB;
+	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;
+	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;
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUIConsoleHack.uc b/ScoreboardExt/Classes/KFGUIConsoleHack.uc
index f1279f6..8d111cb 100644
--- a/ScoreboardExt/Classes/KFGUIConsoleHack.uc
+++ b/ScoreboardExt/Classes/KFGUIConsoleHack.uc
@@ -5,5 +5,5 @@ var KF2GUIController OutputObject;
 
 function PostRender_Console(Canvas Canvas)
 {
-    OutputObject.RenderMenu(Canvas);
+	OutputObject.RenderMenu(Canvas);
 }
diff --git a/ScoreboardExt/Classes/KFGUI_Base.uc b/ScoreboardExt/Classes/KFGUI_Base.uc
index cd1260c..2fd3f4e 100644
--- a/ScoreboardExt/Classes/KFGUI_Base.uc
+++ b/ScoreboardExt/Classes/KFGUI_Base.uc
@@ -1,6 +1,6 @@
 // Menu system written by Marco.
 Class KFGUI_Base extends Object
-    abstract;
+	abstract;
 
 var KF2GUIController Owner;
 var ScoreboardExtHUD HUDOwner;
@@ -9,14 +9,14 @@ var transient Canvas Canvas;
 
 enum EMenuSound
 {
-    MN_Focus,
-    MN_LostFocus,
-    MN_FocusHover,
-    MN_ClickButton,
-    MN_ClickCheckboxOn,
-    MN_ClickCheckboxOff,
-    MN_Dropdown,
-    MN_DropdownChange,
+	MN_Focus,
+	MN_LostFocus,
+	MN_FocusHover,
+	MN_ClickButton,
+	MN_ClickCheckboxOn,
+	MN_ClickCheckboxOff,
+	MN_Dropdown,
+	MN_DropdownChange,
 };
 
 var() float XPosition,YPosition,XSize,YSize;
@@ -36,14 +36,14 @@ 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();
+	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.
@@ -52,211 +52,211 @@ 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 );
+	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 );
+	if( TimerNames.Find(inTimerFunc) != INDEX_NONE )
+	{
+		TimerNames.RemoveItem(inTimerFunc);
+	}
+
+	`TimerHelper.ClearTimer( inTimerFunc, self );
 }
 function Timer();
 
 function MouseEnter()
 {
-    bFocused = true;
-    OnFocus(Self,True);
+	bFocused = true;
+	OnFocus(Self,True);
 }
 function MouseLeave()
 {
-    bFocused = false;
-    OnFocus(Self,False);
+	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);
+	MouseClick(bRight);
 }
 
 function ScrollMouseWheel( bool bUp );
 
 function bool ReceievedControllerInput(int ControllerId, name Key, EInputEvent Event)
 {
-    return false;
+	return false;
 }
 
 final function PlayerController GetPlayer()
 {
-    return Owner.PlayerOwner;
+	return Owner.PlayerOwner;
 }
 
 function SetDisabled( bool bDisable )
 {
-    bDisabled = 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];
+	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]) );
+	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;
+	local KFGUI_Base M;
+
+	for( M=Self; M.MouseArea!=None; M=M.MouseArea )
+	{}
+	return M;
 }
 
 function SetVisibility(bool Visible)
 {
-    bVisible = 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);
+	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);
+	return (bClickable ? `PEN_BLACK : `PEN_WHITE);
 }
 
 function UserPressedEsc() // user pressed escape while this menu was active.
 {
-    if( ParentComponent!=None )
-        ParentComponent.UserPressedEsc();
-    else DoClose();
+	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.
+	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]);
+	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);
+	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;
+	if( ID==InID )
+		return Self;
+	return None;
 }
 function FindAllComponentID( name InID, out array<KFGUI_Base> Res )
 {
-    if( ID==InID )
-        Res[Res.Length] = Self;
+	if( ID==InID )
+		Res[Res.Length] = Self;
 }
 function RemoveComponent( KFGUI_Base B );
 
 function GetInputFocus()
 {
-    if( Owner.InputFocus!=None )
-        Owner.InputFocus.LostInputFocus();
-    Owner.InputFocus = Self;
+	if( Owner.InputFocus!=None )
+		Owner.InputFocus.LostInputFocus();
+	Owner.InputFocus = Self;
 }
 function DropInputFocus()
 {
-    if( Owner.InputFocus==Self )
-    {
-        Owner.InputFocus.LostInputFocus();
-        Owner.InputFocus = None;
-    }
+	if( Owner.InputFocus==Self )
+	{
+		Owner.InputFocus.LostInputFocus();
+		Owner.InputFocus = None;
+	}
 }
 function LostInputFocus();
 
 // Obtain keyboard focus.
 final function GrabKeyFocus()
 {
-    Owner.GrabInputFocus(Self);
+	Owner.GrabInputFocus(Self);
 }
 final function ReleaseKeyFocus()
 {
-    if( Owner.KeyboardFocus==Self )
-        Owner.GrabInputFocus(None);
+	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;
+	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;
+	return false;
 }
 function bool NotifyInputChar( int ControllerId, string Unicode )
 {
-    return false;
+	return false;
 }
 
 // While on input focus mode, notify that mouse just moved over the threshold.
@@ -267,48 +267,48 @@ 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];
+	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];
+	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);
-    }
+	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.
@@ -316,29 +316,29 @@ function NotifyLevelChange();
 
 final function SetPosition( float X, float Y, float XS, float YS )
 {
-    XPosition = X;
-    YPosition = Y;
-    XSize = XS;
-    YSize = 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;
+	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
+	XSize=1
+	YSize=1
+	bCanFocus=true
+	bVisible=true
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_Button.uc b/ScoreboardExt/Classes/KFGUI_Button.uc
index 939b1af..a69eeb9 100644
--- a/ScoreboardExt/Classes/KFGUI_Button.uc
+++ b/ScoreboardExt/Classes/KFGUI_Button.uc
@@ -9,19 +9,19 @@ var bool bIsHighlighted;
 
 function DrawMenu()
 {
-    Owner.CurrentStyle.RenderButton(Self);
+	Owner.CurrentStyle.RenderButton(Self);
 }
 
 function bool GetUsingGamepad()
 {
-    return Owner.bUsingGamepad && GamepadButtonName != "";
+	return Owner.bUsingGamepad && GamepadButtonName != "";
 }
 
 function HandleMouseClick( bool bRight )
 {
-    if( bRight )
-        OnClickRight(Self);
-    else OnClickLeft(Self);
+	if( bRight )
+		OnClickRight(Self);
+	else OnClickLeft(Self);
 }
 
 Delegate OnClickLeft( KFGUI_Button Sender );
@@ -29,13 +29,13 @@ Delegate OnClickRight( KFGUI_Button Sender );
 
 Delegate bool DrawOverride(Canvas C, KFGUI_Button B)
 {
-    return false;
+	return false;
 }
 
 defaultproperties
 {
-    ButtonText="Button!"
-    TextColor=(R=0,G=0,B=0,A=255)
-    TextFontInfo=(bClipText=true,bEnableShadow=true)
-    FontScale=1
+	ButtonText="Button!"
+	TextColor=(R=0,G=0,B=0,A=255)
+	TextFontInfo=(bClipText=true,bEnableShadow=true)
+	FontScale=1
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_CategoryButton.uc b/ScoreboardExt/Classes/KFGUI_CategoryButton.uc
index 2e69fc0..c7d3336 100644
--- a/ScoreboardExt/Classes/KFGUI_CategoryButton.uc
+++ b/ScoreboardExt/Classes/KFGUI_CategoryButton.uc
@@ -6,73 +6,73 @@ 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);
+	local float XL,YL,TS,TextX,TextY;
+	local Texture2D Mat;
+	local bool bDrawOverride;
 
-        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]);
+	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
diff --git a/ScoreboardExt/Classes/KFGUI_CategoryList.uc b/ScoreboardExt/Classes/KFGUI_CategoryList.uc
index db97e35..8438ae7 100644
--- a/ScoreboardExt/Classes/KFGUI_CategoryList.uc
+++ b/ScoreboardExt/Classes/KFGUI_CategoryList.uc
@@ -3,85 +3,85 @@ 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 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;
+	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;
+	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);
-            }
-        }
-    }
+	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;
+	local int i;
+
+	for( i=0; i<ItemComponents.Length; i++ )
+	{
+		if( KFGUI_CategoryButton(ItemComponents[i]) == None )
+			ItemComponents.Remove(i, 1);
+	}
+	CategoryItems.Length = 0;
 }
 
 defaultproperties
diff --git a/ScoreboardExt/Classes/KFGUI_CheckBox.uc b/ScoreboardExt/Classes/KFGUI_CheckBox.uc
index 435eed9..e4d1b8a 100644
--- a/ScoreboardExt/Classes/KFGUI_CheckBox.uc
+++ b/ScoreboardExt/Classes/KFGUI_CheckBox.uc
@@ -5,26 +5,26 @@ var() bool bForceUniform,bChecked;
 
 function UpdateSizes()
 {
-    Super.UpdateSizes();
-    if( bForceUniform )
-        XSize = (YSize*InputPos[3]) / InputPos[2];
+	Super.UpdateSizes();
+	if( bForceUniform )
+		XSize = (YSize*InputPos[3]) / InputPos[2];
 }
 
 function DrawMenu()
 {
-    Owner.CurrentStyle.RenderCheckbox(Self);
+	Owner.CurrentStyle.RenderCheckbox(Self);
 }
 
 function HandleMouseClick( bool bRight )
 {
-    bChecked = !bChecked;
-    OnCheckChange(Self);
+	bChecked = !bChecked;
+	OnCheckChange(Self);
 }
 
 Delegate OnCheckChange( KFGUI_CheckBox Sender );
 
 defaultproperties
 {
-    bForceUniform=true
-    LableWidth=0.85
+	bForceUniform=true
+	LableWidth=0.85
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_Clickable.uc b/ScoreboardExt/Classes/KFGUI_Clickable.uc
index 5b070b2..a974f22 100644
--- a/ScoreboardExt/Classes/KFGUI_Clickable.uc
+++ b/ScoreboardExt/Classes/KFGUI_Clickable.uc
@@ -1,5 +1,5 @@
 Class KFGUI_Clickable extends KFGUI_Base
-    abstract;
+	abstract;
 
 var() int IntIndex; // More user variables.
 var() string ToolTip;
@@ -13,83 +13,83 @@ var bool bHoverSound;
 
 function InitMenu()
 {
-    Super.InitMenu();
-    bClickable = !bDisabled;
+	Super.InitMenu();
+	bClickable = !bDisabled;
 }
 function MouseClick( bool bRight )
 {
-    if( !bDisabled )
-    {
-        PressedDown[byte(bRight)] = 1;
-        bPressedDown = true;
-    }
+	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);
-    }
+	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;
+	Super.MouseLeave();
+	PressedDown[0] = 0;
+	PressedDown[1] = 0;
+	bPressedDown = false;
 }
 function MouseEnter()
 {
-    Super.MouseEnter();
-    if( !bDisabled && bHoverSound )
-        PlayMenuSound(MN_FocusHover);
+	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;
+	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();
-    }
+	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;
+	if( ToolTipItem!=None )
+		ToolTipItem.SetText(S);
+	else ToolTip = S;
 }
 function SetVisibility(bool Visible)
 {
-    Super.SetVisibility(Visible);
-    SetDisabled(!Visible);
+	Super.SetVisibility(Visible);
+	SetDisabled(!Visible);
 }
 
 function HandleMouseClick( bool bRight );
 
 defaultproperties
 {
-    bHoverSound=true
+	bHoverSound=true
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_ColorSlider.uc b/ScoreboardExt/Classes/KFGUI_ColorSlider.uc
index f28d3dd..a739187 100644
--- a/ScoreboardExt/Classes/KFGUI_ColorSlider.uc
+++ b/ScoreboardExt/Classes/KFGUI_ColorSlider.uc
@@ -9,114 +9,114 @@ 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);
+	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();
+	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;
+	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);
+	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]);
+	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)
+	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)
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_ColumnList.uc b/ScoreboardExt/Classes/KFGUI_ColumnList.uc
index 06d6707..08d33c6 100644
--- a/ScoreboardExt/Classes/KFGUI_ColumnList.uc
+++ b/ScoreboardExt/Classes/KFGUI_ColumnList.uc
@@ -3,12 +3,12 @@ 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() 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;
@@ -35,411 +35,411 @@ delegate OnSelectedRow( KFGUI_ListItem Item, int Row, bool bRight, bool bDblClic
 
 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);
+	local KFGUI_ListItem N,O;
+	local int i;
 
-    // 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;
+	// 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;
+	local KFGUI_ListItem N;
 
-    // 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;
+	if( I.Index==-1 )
+		return;
 
-    UpdateListSize();
+	// 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;
+	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;
-    }
+	for( I=FirstItem; I!=None; I=N )
+	{
+		N = I.Next;
 
-    FirstItem = None;
-    UpdateListSize();
+		// 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;
+	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;
+	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;
+	local array<KFGUI_ListItem> List;
+	local KFGUI_ListItem Sel,N,P;
+	local int i;
 
-    LastSortedColumn = Column;
-    bLastSortedReverse = bReverse;
-    bShouldSortList = true;
+	if( !bCanSortColumn || Column<0 || Column>=Columns.Length )
+		return;
 
-    // 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);
+	LastSortedColumn = Column;
+	bLastSortedReverse = bReverse;
+	bShouldSortList = true;
 
-        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;
-    }
+	// 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;
+	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'));
+	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();
+	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;
+	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];
+	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);
 
-    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);
+	// Mouse focused item check.
+	bCheckMouse = bClickable && bFocused;
+	FocusMouseItem = -1;
+	if( bCheckMouse )
+		MouseYHit = Owner.MousePosition.Y - CompPos[1];
 
-    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;
-    }
+	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;
+	local byte j;
+	local float XS,SpaceX;
 
-    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];
+	if( !bVisible )
+		return;
 
-    // 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];
+	ComputeCoords();
 
-    // 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();
-    }
+	// Check font to use.
+	Canvas.Font = Owner.CurrentStyle.PickFont(TextScaler);
+	TextScaler *= FontSize;
+	Canvas.TextSize("ABC",XS,TextHeight,TextScaler,TextScaler);
 
-    // 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];
+	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);
+	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);
+	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
+	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)
+	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)
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_ColumnTop.uc b/ScoreboardExt/Classes/KFGUI_ColumnTop.uc
index 32dcd58..a5cd190 100644
--- a/ScoreboardExt/Classes/KFGUI_ColumnTop.uc
+++ b/ScoreboardExt/Classes/KFGUI_ColumnTop.uc
@@ -10,197 +10,197 @@ var transient bool bPressedDown,bScaleColumn,bMouseScaler;
 
 function InitMenu()
 {
-    Super.InitMenu();
-    ListOwner = KFGUI_ColumnList(ParentComponent);
+	Super.InitMenu();
+	ListOwner = KFGUI_ColumnList(ParentComponent);
 }
 
 function DrawMenu()
 {
-    local int i,j;
-    local float X,XS,MouseX,GrabWidth,MinSize,Wd;
-    local bool bCheckMouse;
+	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]);
+	bClickable = ListOwner.bClickable;
+	MinSize = ColumnMinSize / 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.
+	// Scale column
+	if( bScaleColumn )
+	{
+		MouseX = Owner.MousePosition.X - CompPos[0];
+		for( i=0; i<ScalingColumn; ++i )
+			MouseX-=(ListOwner.Columns[i].Width * CompPos[2]);
 
-                // 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;
-    }
+		ListOwner.Columns[ScalingColumn].Width = MouseX / CompPos[2];
 
-    // 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;
+		// 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.
 
-        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;
-        }
+				// 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.
+			}
+		}
+	}
 
-        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);
-        }
+	// 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;
+	}
 
-        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);
+	// 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;
 
-            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;
-    }
+		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();
-        }
-    }
+	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;
-        }
-    }
+	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;
+	if( bClickable )
+		return (bMouseScaler ? 2 : 1);
+	return 0;
 }
 function MouseLeave()
 {
-    Super.MouseLeave();
-    if( !bScaleColumn )
-    {
-        PressedDown[0] = 0;
-        PressedDown[1] = 0;
-        bPressedDown = false;
-    }
+	Super.MouseLeave();
+	if( !bScaleColumn )
+	{
+		PressedDown[0] = 0;
+		PressedDown[1] = 0;
+		bPressedDown = false;
+	}
 }
 function MouseEnter()
 {
-    Super.MouseEnter();
+	Super.MouseEnter();
 }
 
 function LostInputFocus()
 {
-    bScaleColumn = false;
-    PressedDown[0] = 0;
-    PressedDown[1] = 0;
-    bPressedDown = false;
+	bScaleColumn = false;
+	PressedDown[0] = 0;
+	PressedDown[1] = 0;
+	bPressedDown = false;
 }
 
 defaultproperties
 {
-    bClickable=true
-    ColumnMinSize=8
+	bClickable=true
+	ColumnMinSize=8
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_ComboBox.uc b/ScoreboardExt/Classes/KFGUI_ComboBox.uc
index 5752943..a7464b7 100644
--- a/ScoreboardExt/Classes/KFGUI_ComboBox.uc
+++ b/ScoreboardExt/Classes/KFGUI_ComboBox.uc
@@ -10,55 +10,55 @@ var() bool bButtonStretched;
 
 function UpdateSizes()
 {
-    // Update height.
-    if( bScaleByFontSize )
-        YSize = (TextHeight + (BorderSize*2)) / InputPos[3];
+	// Update height.
+	if( bScaleByFontSize )
+		YSize = (TextHeight + (BorderSize*2)) / InputPos[3];
 }
 
 function DrawMenu()
 {
-    Owner.CurrentStyle.RenderComboBox(Self);
+	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();
+	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 "";
+	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;
+	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
+	SelectedTextColor=(R=255,G=128,B=128,A=255)
+	TextColor=(R=255,G=255,B=255,A=255)
+	BorderSize=4
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_ComboSelector.uc b/ScoreboardExt/Classes/KFGUI_ComboSelector.uc
index 72e45e6..002db34 100644
--- a/ScoreboardExt/Classes/KFGUI_ComboSelector.uc
+++ b/ScoreboardExt/Classes/KFGUI_ComboSelector.uc
@@ -5,23 +5,23 @@ var int CurrentRow,OldRow;
 
 function DrawMenu()
 {
-    Owner.CurrentStyle.RenderComboList(Self);
+	Owner.CurrentStyle.RenderComboList(Self);
 }
 
 function HandleMouseClick( bool bRight )
 {
-    PlayMenuSound(MN_ClickButton);
-    DropInputFocus();
-    if( CurrentRow>=0 )
-    {
-        Combo.SelectedIndex = CurrentRow;
-        Combo.OnComboChanged(Combo);
-    }
+	PlayMenuSound(MN_ClickButton);
+	DropInputFocus();
+	if( CurrentRow>=0 )
+	{
+		Combo.SelectedIndex = CurrentRow;
+		Combo.OnComboChanged(Combo);
+	}
 }
 
 defaultproperties
 {
-    CurrentRow=-1
-    OldRow=-1
-    bFocusedPostDrawItem=true
+	CurrentRow=-1
+	OldRow=-1
+	bFocusedPostDrawItem=true
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_ComponentList.uc b/ScoreboardExt/Classes/KFGUI_ComponentList.uc
index 358178a..3509003 100644
--- a/ScoreboardExt/Classes/KFGUI_ComponentList.uc
+++ b/ScoreboardExt/Classes/KFGUI_ComponentList.uc
@@ -8,146 +8,146 @@ 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);
+	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;
+	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);
+	AddItemAtIndex(ItemComponents.Length, Item);
 }
 
 final function AddItemAtIndex( int i, KFGUI_Base Item )
 {
-    ItemComponents.InsertItem(i, 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;
+	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;
+	ItemComponents.Length = 0;
 }
 
 function InitMenu()
 {
-    Super.InitMenu();
-    ListCount = 0;
-    NumColumns = Max(NumColumns,1);
+	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);
-    }
+	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;
+	local int i;
+	local byte j;
 
-    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();
-    }
+	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();
+	local int i,XNum,r;
+	local float XS,YS;
 
-        if( ++XNum==NumColumns )
-        {
-            XNum = 0;
-            if( ++r==ListItemsPerPage )
-            {
-                VisRange[1] = i+1;
-                break;
-            }
-        }
-    }
+	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 );
@@ -156,67 +156,67 @@ function MouseClick( bool bRight );
 function MouseRelease( bool bRight );
 function MouseLeave()
 {
-    Super(KFGUI_Base).MouseLeave();
+	Super(KFGUI_Base).MouseLeave();
 }
 function MouseEnter()
 {
-    Super(KFGUI_Base).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();
+	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();
+	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();
+	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);
+	local int i;
+
+	for( i=0; i<ItemComponents.Length; ++i )
+		ItemComponents[i].InventoryChanged(Wep,bRemove);
 }
 function MenuTick( float DeltaTime )
 {
-    local int i;
+	local int i;
 
-    Super.MenuTick(DeltaTime);
-    for( i=0; i<ItemComponents.Length; ++i )
-        ItemComponents[i].MenuTick(DeltaTime);
+	Super.MenuTick(DeltaTime);
+	for( i=0; i<ItemComponents.Length; ++i )
+		ItemComponents[i].MenuTick(DeltaTime);
 }
 
 defaultproperties
 {
-    ListCount=0
-    NumColumns=1
-    bClickable=true
-    bDrawBackground=false
+	ListCount=0
+	NumColumns=1
+	bClickable=true
+	bDrawBackground=false
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_EditBox.uc b/ScoreboardExt/Classes/KFGUI_EditBox.uc
index b774736..40f6ce3 100644
--- a/ScoreboardExt/Classes/KFGUI_EditBox.uc
+++ b/ScoreboardExt/Classes/KFGUI_EditBox.uc
@@ -2,9 +2,9 @@ Class KFGUI_EditBox extends KFGUI_Clickable;
 
 var enum eTextCase
 {
-    TXTC_None,
-    TXTC_Upper,
-    TXTC_Lower,
+	TXTC_None,
+	TXTC_Upper,
+	TXTC_Lower,
 } TextCase;
 
 var Color FontColor;
@@ -18,398 +18,398 @@ var float TextScale;
 
 function InitMenu()
 {
-    Super.InitMenu();
+	Super.InitMenu();
 
-    if ( bIntOnly || bFloatOnly )
-    {
-        AllowedCharSet = "0123456789";
+	if ( bIntOnly || bFloatOnly )
+	{
+		AllowedCharSet = "0123456789";
 
-        if (bFloatOnly)
-            AllowedCharSet $= ".";
-    }
+		if (bFloatOnly)
+			AllowedCharSet $= ".";
+	}
 
-    bAllSelected = true;
+	bAllSelected = true;
 }
 
 function SetText(string NewText, optional bool bIgnoreDelegate)
 {
-    local bool bChanged;
+	local bool bChanged;
 
-    bChanged = bAlwaysNotify || TextStr != NewText;
-    TextStr = NewText;
-    CaretPos = Len(TextStr);
+	bChanged = bAlwaysNotify || TextStr != NewText;
+	TextStr = NewText;
+	CaretPos = Len(TextStr);
 
-    if (bChanged && !bIgnoreDelegate)
-        TextChanged();
+	if (bChanged && !bIgnoreDelegate)
+		TextChanged();
 
-    bAllSelected=true;
+	bAllSelected=true;
 }
 
 function bool NotifyInputChar(int Key, string Unicode)
 {
-    local string Temp,S;
+	local string Temp,S;
 
-    if (bReadOnly)
-        return false;
+	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( UniCode!="" )
+		S = Unicode;
+	else S = Chr(Key);
 
-    if(bAllSelected)
-    {
-        TextStr="";
-        CaretPos=0;
-        bAllSelected=false;
-    }
+	if( Asc(S) == 13 || Asc(S) == 8 || Asc(S) == 27 )
+		return false;
 
-    if ( (AllowedCharSet=="") || ( (bIncludeSign) && ( (S=="-") || (S=="+") ) && (TextStr=="") ) || (InStr(AllowedCharSet,S)>=0) )
-    {
-        if ( (MaxWidth==0) || (Len(TextStr)<MaxWidth) )
-        {
-            if ( (bConvertSpaces) && ((S==" ") || (S=="?") || (S=="\\")) )
-                S = "_";
+	if( bCtrl )
+		return false;
 
-            if ( (TextStr=="") || ( CaretPos==Len(TextStr) ) )
-            {
-                TextStr = TextStr$S;
-                CaretPos=Len(TextStr);
-            }
-            else
-            {
-                Temp = Left(TextStr,CaretPos)$S$Mid(TextStr,CaretPos);
-                TextStr = Temp;
-                CaretPos++;
-            }
+	if(bAllSelected)
+	{
+		TextStr="";
+		CaretPos=0;
+		bAllSelected=false;
+	}
 
-            TextChanged();
-            return true;
-        }
-    }
+	if ( (AllowedCharSet=="") || ( (bIncludeSign) && ( (S=="-") || (S=="+") ) && (TextStr=="") ) || (InStr(AllowedCharSet,S)>=0) )
+	{
+		if ( (MaxWidth==0) || (Len(TextStr)<MaxWidth) )
+		{
+			if ( (bConvertSpaces) && ((S==" ") || (S=="?") || (S=="\\")) )
+				S = "_";
 
-    return false;
+			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();
+	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;
+	local int Character;
 
-    while (Len(Text) > 0)
-    {
-        Character = Asc(Left(Text, 1));
-        Text = Mid(Text, 1);
+	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;
-        }
-    }
+		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;
-        }
+	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 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;
+	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;
-            }
-        }
+	local string Temp;
 
-        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;
-            }
+	if( bReadOnly )
+	{
+		return false;
+	}
 
-            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;
-        }
-    }
+	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;
+		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;
+	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++;
-    }
+	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);
+	if (MaxWidth > 0)
+		return Left(Retval,MaxWidth);
 
-    return Retval;
+	return Retval;
 }
 
 function string GetText()
 {
-    return TextStr;
+	return TextStr;
 }
 
 function TextChanged()
 {
-    OnChange(Self);
+	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;
+	local string Storage,FinalDraw,TmpString;
+	local int MaskIndex,StorageLength;
+	local float XL,YL,BoxWidth,FontScale,CursorY,BorderSize;
+	local FontRenderInfo FRI;
 
-    Storage = TextStr;
+	Super.DrawMenu();
 
-    if ( bMaskText && Len(Storage)>0 )
-    {
-        StorageLength = Len(Storage);
-        
-        Storage = "";
-        for(MaskIndex=1; MaskIndex <= StorageLength; MaskIndex++ )
-        {
-            Storage $= "*";
-        }
-    }
-    
-    Canvas.Font = Owner.CurrentStyle.PickFont(FontScale);
-    FontScale *= TextScale;
+	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());
+	}
 
-    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);
+	BorderSize = Owner.CurrentStyle.ScreenScale(4.f);
 
-            while ( (XL>=BoxWidth) && (FirstVis<Len(Storage)) )
-            {
-                FirstVis++;
-                FinalDraw = Mid(Storage, FirstVis, CaretPos-FirstVis);
-                Canvas.TextSize(FinalDraw, XL, YL, FontScale, FontScale);
-            }
-        }
-    }
-    LastLength = Len(Storage);
+	FRI.bClipText = true;
+	FRI.bEnableShadow = true;
 
-    if (bReadOnly)
-    {
-        FirstVis = 0;
-    }
+	Storage = TextStr;
 
-    FinalDraw = Mid(Storage, FirstVis, Len(Storage)-FirstVis);
+	if ( bMaskText && Len(Storage)>0 )
+	{
+		StorageLength = Len(Storage);
 
-    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);
-        }
+		Storage = "";
+		for(MaskIndex=1; MaskIndex <= StorageLength; MaskIndex++ )
+		{
+			Storage $= "*";
+		}
+	}
 
-        CursorY = (CompPos[3]/2) - ((YL-Owner.HUDOwner.ScaledBorderSize)/2);
+	Canvas.Font = Owner.CurrentStyle.PickFont(FontScale);
+	FontScale *= TextScale;
 
-        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);
+	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;
+	if( Owner.KeyboardFocus != self )
+	{
+		GrabKeyFocus();
+	}
+
+	CaretPos = Len(TextStr);
+	bAllSelected = !bAllSelected;
 }
 
 Delegate OnChange(KFGUI_EditBox Sender);
@@ -417,12 +417,12 @@ 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
+	FontColor=(R=255,G=255,B=255,A=255)
+	MaxWidth=768
+	TextScale=1
+	TextCase=TXTC_None
+	LastCaret=-1
+	LastLength=-1
+
+	YSize=0.06
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_EditControl.uc b/ScoreboardExt/Classes/KFGUI_EditControl.uc
index 61e84fd..7267321 100644
--- a/ScoreboardExt/Classes/KFGUI_EditControl.uc
+++ b/ScoreboardExt/Classes/KFGUI_EditControl.uc
@@ -13,90 +13,90 @@ 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;
+	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];
+	// Update height.
+	if( bScaleByFontSize )
+		YSize = ((TextHeight*1.05) + 6) / InputPos[3];
 }
 
 function PreDraw()
 {
-    local float XS;
-    local byte i;
+	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();
+	Canvas.Font = Owner.CurrentStyle.PickFont(TextScale);
 
-    Super.PreDraw();
-    if( TextLable!=None )
-    {
-        TextLable.YSize = YSize;
-        TextLable.Canvas = Canvas;
-        for( i=0; i<4; ++i )
-            TextLable.InputPos[i] = InputPos[i];
-        TextLable.PreDraw();
-    }
+	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);
+	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)
+	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
+	Begin Object Class=KFGUI_TextLable Name=MyBoxLableText
+		AlignX=0
+		AlignY=1
+		TextFontInfo=(bClipText=true,bEnableShadow=true)
+	End Object
+	TextLable=MyBoxLableText
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_FloatingWindow.uc b/ScoreboardExt/Classes/KFGUI_FloatingWindow.uc
index a7e7535..7285b00 100644
--- a/ScoreboardExt/Classes/KFGUI_FloatingWindow.uc
+++ b/ScoreboardExt/Classes/KFGUI_FloatingWindow.uc
@@ -1,5 +1,5 @@
 Class KFGUI_FloatingWindow extends KFGUI_Page
-    abstract;
+	abstract;
 
 var() string WindowTitle; // Title of this window.
 var float DragOffset[2], OpenAnimSpeed;
@@ -11,97 +11,97 @@ var transient float OpenStartTime,OpenEndTime;
 
 function InitMenu()
 {
-    Super.InitMenu();
-    HeaderComp = new (Self) class'KFGUI_FloatingWindowHeader';
-    AddComponent(HeaderComp);
+	Super.InitMenu();
+	HeaderComp = new (Self) class'KFGUI_FloatingWindowHeader';
+	AddComponent(HeaderComp);
 }
 function ShowMenu()
 {
-    Super.ShowMenu();
-    
-    OpenStartTime = GetPlayer().WorldInfo.RealTimeSeconds;
-    OpenEndTime = GetPlayer().WorldInfo.RealTimeSeconds + OpenAnimSpeed;
+	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.
-    }
+	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];
-    }
+	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();
+	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();
+	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
+	bUseAnimation=true
+	OpenAnimSpeed=0.05f
+	WindowFadeInTime=0.2f
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_FloatingWindowHeader.uc b/ScoreboardExt/Classes/KFGUI_FloatingWindowHeader.uc
index 8c232df..e2d0c6f 100644
--- a/ScoreboardExt/Classes/KFGUI_FloatingWindowHeader.uc
+++ b/ScoreboardExt/Classes/KFGUI_FloatingWindowHeader.uc
@@ -4,20 +4,20 @@ var bool bDragWindow;
 
 function PreDraw()
 {
-    ComputeCoords();
+	ComputeCoords();
 }
 function MouseClick( bool bRight )
 {
-    if( !bRight )
-        KFGUI_FloatingWindow(ParentComponent).SetWindowDrag(true);
+	if( !bRight )
+		KFGUI_FloatingWindow(ParentComponent).SetWindowDrag(true);
 }
 function MouseRelease( bool bRight )
 {
-    if( !bRight )
-        KFGUI_FloatingWindow(ParentComponent).SetWindowDrag(false);
+	if( !bRight )
+		KFGUI_FloatingWindow(ParentComponent).SetWindowDrag(false);
 }
 
 defaultproperties
 {
-    bClickable=true
+	bClickable=true
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_Frame.uc b/ScoreboardExt/Classes/KFGUI_Frame.uc
index d15ea87..c9b35ab 100644
--- a/ScoreboardExt/Classes/KFGUI_Frame.uc
+++ b/ScoreboardExt/Classes/KFGUI_Frame.uc
@@ -8,121 +8,121 @@ var() float FontScale;
  
 function InitMenu()
 {
-    Super(KFGUI_Page).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]);
-    }
+	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());
-    }
+	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);
-    }
+	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);
-    }
+	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();
-    }
+	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
+	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
+	EdgeSize(0)=20
+	EdgeSize(1)=35
+	EdgeSize(2)=-40
+	EdgeSize(3)=-50
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_Image.uc b/ScoreboardExt/Classes/KFGUI_Image.uc
index 0ad4460..f38b8bf 100644
--- a/ScoreboardExt/Classes/KFGUI_Image.uc
+++ b/ScoreboardExt/Classes/KFGUI_Image.uc
@@ -2,14 +2,14 @@ Class KFGUI_Image extends KFGUI_Base;
 
 var enum eImageStyle
 {
-    ISTY_Normal,
-    ISTY_Stretched
+	ISTY_Normal,
+	ISTY_Stretched
 } ImageStyle;
 
 var enum eScaleStyle
 {
-    ISTY_Height,
-    ISTY_Width
+	ISTY_Height,
+	ISTY_Width
 } ScaleStyle;
 
 var Color ImageColor;
@@ -20,124 +20,124 @@ 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;
+	local float X, Y, XL, YL;
 
-            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( Image == None )
+		return;
 
-                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;
+	DrawBackground(Canvas, CompPos[2], CompPos[3]);
 
-                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);
+	Canvas.DrawColor = ImageColor;
 
-                    if( X2 == -1 )
-                        XL = FMin(CompPos[2], Image.GetSurfaceWidth());
-                    else XL = (X2-X1);
-                }
+	switch (ImageStyle)
+	{
+		case ISTY_Normal:
+			if( X1 != -1 )
+				X = X1;
+			else X = 0;
 
-                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;
-    }
+			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
+	ImageColor=(R=255,G=255,B=255,A=255)
+	ImageStyle=ISTY_Normal
+	X1=-1
+	X2=-1
+	Y1=-1
+	Y2=-1
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_List.uc b/ScoreboardExt/Classes/KFGUI_List.uc
index ca3c9be..7137ed8 100644
--- a/ScoreboardExt/Classes/KFGUI_List.uc
+++ b/ScoreboardExt/Classes/KFGUI_List.uc
@@ -21,199 +21,199 @@ delegate OnDblClickedItem( int Index, bool bRight, int MouseX, int MouseY );
 
 function InitMenu()
 {
-    Super.InitMenu();
-    ScrollBar = KFGUI_ScrollBarV(FindComponentID('Scrollbar'));
-    ScrollBar.bHideScrollbar = bHideScrollbar;
-    UpdateListVis();
+	Super.InitMenu();
+	ScrollBar = KFGUI_ScrollBarV(FindComponentID('Scrollbar'));
+	ScrollBar.bHideScrollbar = bHideScrollbar;
+	UpdateListVis();
 }
 
 function DrawMenu()
 {
-    local int i,n;
-    local float Y;
-    local bool bCheckMouse;
+	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);
-    }
+	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];
+	// 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);
-        }
-    }
+	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;
+	local int i;
+	local byte j;
 
-    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();
-        }
-    }
+	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);
-    }
+	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();
+	if( ListCount==NewSize )
+		return;
+	ListCount = NewSize;
+	UpdateListVis();
 }
 final function int GetListSize()
 {
-    return ListCount;
+	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);
-    }
+	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;
-    }
+	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);
-    }
+	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;
+	Super.MouseLeave();
+	PressedDown[0] = 0;
+	PressedDown[1] = 0;
+	bPressedDown = false;
 }
 function MouseEnter()
 {
-    Super.MouseEnter();
-    LastFocusItem = -1;
+	Super.MouseEnter();
+	LastFocusItem = -1;
 }
 
 function ScrollMouseWheel( bool bUp )
 {
-    if( !ScrollBar.bDisabled )
-        ScrollBar.ScrollMouseWheel(bUp);
+	if( !ScrollBar.bDisabled )
+		ScrollBar.ScrollMouseWheel(bUp);
 }
 
 function NotifyMousePaused()
 {
-    if( Owner.InputFocus==None && FocusMouseItem>=0 )
-        OnMouseRest(FocusMouseItem);
+	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
+	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)
+	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)
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_ListHorz.uc b/ScoreboardExt/Classes/KFGUI_ListHorz.uc
index 8bc56ac..0949cab 100644
--- a/ScoreboardExt/Classes/KFGUI_ListHorz.uc
+++ b/ScoreboardExt/Classes/KFGUI_ListHorz.uc
@@ -21,205 +21,205 @@ 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();
+	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;
+	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);
-    }
+	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];
+	// 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);
-        }
-    }
+	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;
+	local int i;
+	local byte j;
 
-    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();
-        }
-    }
+	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);
-    }
+	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();
+	if( ListCount==NewSize )
+		return;
+	ListCount = NewSize;
+	UpdateListVis();
 }
 final function int GetListSize()
 {
-    return ListCount;
+	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]);
-    }
+	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;
-    }
+	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]);
-    }
+	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;
+	Super.MouseLeave();
+	PressedDown[0] = 0;
+	PressedDown[1] = 0;
+	bPressedDown = false;
 }
 function MouseEnter()
 {
-    Super.MouseEnter();
-    LastFocusItem = -1;
-    if( !bDisabled && bClickable && bUseFocusSound )
-        PlayMenuSound(MN_FocusHover);
+	Super.MouseEnter();
+	LastFocusItem = -1;
+	if( !bDisabled && bClickable && bUseFocusSound )
+		PlayMenuSound(MN_FocusHover);
 }
 
 function ScrollMouseWheel( bool bUp )
 {
-    if( !ScrollBar.bDisabled )
-        ScrollBar.ScrollMouseWheel(bUp);
+	if( !ScrollBar.bDisabled )
+		ScrollBar.ScrollMouseWheel(bUp);
 }
 
 function NotifyMousePaused()
 {
-    if( Owner.InputFocus==None && FocusMouseItem>=0 )
-        OnMouseRest(FocusMouseItem);
+	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
+	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)
+	Begin Object Class=KFGUI_ScrollBarH Name=ListScroller
+		XPosition=0
+		YPosition=0.96
+		XSize=1
+		YSize=0.04
+		ID="Scrollbar"
+	End Object
+	Components.Add(ListScroller)
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_ListItem.uc b/ScoreboardExt/Classes/KFGUI_ListItem.uc
index 4a71bba..5b20a26 100644
--- a/ScoreboardExt/Classes/KFGUI_ListItem.uc
+++ b/ScoreboardExt/Classes/KFGUI_ListItem.uc
@@ -1,5 +1,5 @@
 Class KFGUI_ListItem extends Object
-    transient;
+	transient;
 
 var KFGUI_ListItem Next;
 var array<string> Columns,SortColumns;
@@ -9,36 +9,36 @@ 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;
+	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 "";
+	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 "";
+	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;
+	Columns.Length = 0;
 }
diff --git a/ScoreboardExt/Classes/KFGUI_MultiComponent.uc b/ScoreboardExt/Classes/KFGUI_MultiComponent.uc
index 848420c..4ed96e7 100644
--- a/ScoreboardExt/Classes/KFGUI_MultiComponent.uc
+++ b/ScoreboardExt/Classes/KFGUI_MultiComponent.uc
@@ -4,144 +4,144 @@ 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();
-    }
+	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();
+	local int i;
+
+	for( i=0; i<Components.Length; ++i )
+		Components[i].ShowMenu();
 }
 function PreDraw()
 {
-    local int i;
-    local byte j;
-    
-    if( !bVisible )
-        return;
+	local int i;
+	local byte j;
 
-    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();
-    }
+	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);
+	local int i;
+
+	for( i=0; i<Components.Length; ++i )
+		Components[i].InventoryChanged(Wep,bRemove);
 }
 function MenuTick( float DeltaTime )
 {
-    local int i;
+	local int i;
 
-    Super.MenuTick(DeltaTime);
-    for( i=0; i<Components.Length; ++i )
-        Components[i].MenuTick(DeltaTime);
+	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();
+	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();
+	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.
+	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);
+	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;
+	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;
+	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;
+	local int i;
 
-    if( ID==InID )
-        Res[Res.Length] = Self;
-    for( i=0; i<Components.Length; ++i )
-        Components[i].FindAllComponentID(InID,Res);
+	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);
+	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();
+	local int i;
+
+	for( i=0; i<Components.Length; ++i )
+		Components[i].NotifyLevelChange();
 }
diff --git a/ScoreboardExt/Classes/KFGUI_Page.uc b/ScoreboardExt/Classes/KFGUI_Page.uc
index ff47365..1bf6071 100644
--- a/ScoreboardExt/Classes/KFGUI_Page.uc
+++ b/ScoreboardExt/Classes/KFGUI_Page.uc
@@ -1,26 +1,26 @@
 Class KFGUI_Page extends KFGUI_MultiComponent
-    abstract;
+	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.
+			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);
-    }
+	if( !bNoBackground )
+	{
+		Owner.CurrentStyle.RenderWindow(Self);
+	}
 }
 
 defaultproperties
 {
-    bUnique=true
-    bPersistant=true
-    FrameOpacity=175
+	bUnique=true
+	bPersistant=true
+	FrameOpacity=175
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_ProgressBar.uc b/ScoreboardExt/Classes/KFGUI_ProgressBar.uc
index 40cf858..bf0e5e1 100644
--- a/ScoreboardExt/Classes/KFGUI_ProgressBar.uc
+++ b/ScoreboardExt/Classes/KFGUI_ProgressBar.uc
@@ -23,112 +23,112 @@ var byte BorderSize;
 
 function DrawMenu()
 {
-    local float Left, Top, Width, Height;
-    local float W, Sc;
-    local string S;
-    
-    Super.DrawMenu();
+	local float Left, Top, Width, Height;
+	local float W, Sc;
+	local string S;
 
-    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;
+	Super.DrawMenu();
 
-        if( W < 1.0 )
-        {
-            W *= Width;
-        }
+	Left = 0.f;
+	Top = 0.f;
+	Width = CompPos[2];
+	Height = CompPos[3];
 
-        if( W > Width )
-        {
-            W = Width;
-        }
+	// Select the right font in the Canvas
+	Canvas.Font = Owner.CurrentStyle.PickFont(Sc); 
 
-        // Draw the label
-        Owner.CurrentStyle.DrawTextJustified(CaptionAlign, Left, Top, Left + W, Top + Height, Caption, Sc, Sc);
-        Left += W;
-        Width -= W;
-    }
+	if (CaptionWidth > 0.0 && Width > 0 && Len(Caption) > 0)
+	{
+		W = CaptionWidth;
 
-    if ( (bShowHigh || bShowValue) && ValueRightWidth > 0.0 && Width > 0.0)
-    {
-        W = ValueRightWidth;
+		if( W < 1.0 )
+		{
+			W *= Width;
+		}
 
-        if( W < 1.0 )
-        {
-            W *= Width;
-        }
+		if( W > Width )
+		{
+			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( bShowValue && bShowHigh )
-        {
-            S = int(Value)$"/"$int(High);
-        }
-        else if (bShowValue)
-        {
-            S = string(int(Value));
-        }
-        else 
-        {
-            S = string(int(High));
-        }
+	if ( (bShowHigh || bShowValue) && ValueRightWidth > 0.0 && Width > 0.0)
+	{
+		W = ValueRightWidth;
 
-        Owner.CurrentStyle.DrawTextJustified(ValueRightAlign, Left + Width - W, Top, Left + Width, Top + Height, S, Sc, Sc);
+		if( W < 1.0 )
+		{
+			W *= Width;
+		}
 
-        Width -= W;
-    }
-    
-    if (Width > GraphicMargin)
-    {
-        Width -= GraphicMargin;
-        Left += GraphicMargin / 2;
-    }
+		if( W > Width )
+		{
+			W = Width;
+		}
 
-    Canvas.SetDrawColor(255, 255, 255, 255);
-    if( Width > 0.0 && BarBack != None )
-    {
-        Owner.CurrentStyle.DrawTileStretched(BarBack, Left, Top, Width, Height);
-    }
+		if( bShowValue && bShowHigh )
+		{
+			S = int(Value)$"/"$int(High);
+		}
+		else if (bShowValue)
+		{
+			S = string(int(Value));
+		}
+		else 
+		{
+			S = string(int(High));
+		}
 
-    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));
-    }
+		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;
+	Value=val;
 }
 
 function float GetValue()
 {
-    return Value;
+	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
+	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
 }
diff --git a/ScoreboardExt/Classes/KFGUI_RightClickMenu.uc b/ScoreboardExt/Classes/KFGUI_RightClickMenu.uc
index 9ff777f..2aae210 100644
--- a/ScoreboardExt/Classes/KFGUI_RightClickMenu.uc
+++ b/ScoreboardExt/Classes/KFGUI_RightClickMenu.uc
@@ -2,8 +2,8 @@ Class KFGUI_RightClickMenu extends KFGUI_Clickable;
 
 struct FRowItem
 {
-    var string Text,ToolTip;
-    var bool bSplitter,bDisabled;
+	var string Text,ToolTip;
+	var bool bSplitter,bDisabled;
 };
 var array<FRowItem> ItemRows;
 var int CurrentRow,OldRow;
@@ -14,138 +14,138 @@ var Color BoxColor,OutlineColor;
 
 function OpenMenu( KFGUI_Base Menu )
 {
-    Owner = Menu.Owner;
-    InitMenu();
-    PlayMenuSound(MN_Dropdown);
-    GetInputFocus();
-    OldSizeX = 0;
+	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;
+	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;
+	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.
+	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;
-    }
+	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();
+	ComputeSize();
+	Super.PreDraw();
 }
 function DrawMenu()
 {   
-    Owner.CurrentStyle.RenderRightClickMenu(Self);
-    
-    if( bDrawToolTip )
-    {
-        if( OldRow != CurrentRow )
-            bDrawToolTip = false;
-        DrawToolTip();
-    }
+	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);
+	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();
+	if( CurrentRow>=0 && (ItemRows[CurrentRow].bSplitter || ItemRows[CurrentRow].bDisabled) )
+		return;
+	OnSelectedItem(CurrentRow);
+	PlayMenuSound(MN_ClickButton);
+	DropInputFocus();
 }
 function LostInputFocus()
 {
-    OnBecameHidden(Self);
-    OldRow = -1;
-    CurrentRow = -1;
+	OnBecameHidden(Self);
+	OldRow = -1;
+	CurrentRow = -1;
 }
 function NotifyMousePaused()
 {
-    if(CurrentRow != -1 && ItemRows[CurrentRow].ToolTip != "")
-        bDrawToolTip = true;
+	if(CurrentRow != -1 && ItemRows[CurrentRow].ToolTip != "")
+		bDrawToolTip = true;
 }
 
 Delegate OnSelectedItem( int Index );
@@ -153,11 +153,11 @@ 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)
+	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)
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_ScrollBarBase.uc b/ScoreboardExt/Classes/KFGUI_ScrollBarBase.uc
index c3d26a1..78488e9 100644
--- a/ScoreboardExt/Classes/KFGUI_ScrollBarBase.uc
+++ b/ScoreboardExt/Classes/KFGUI_ScrollBarBase.uc
@@ -1,5 +1,5 @@
 Class KFGUI_ScrollBarBase extends KFGUI_Clickable
-    abstract;
+	abstract;
 
 var() int MinRange,MaxRange,ScrollStride,PageStep;
 var() float ButtonScale; // Button width (scaled by default font height).
@@ -14,110 +14,110 @@ 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);
+	MaxRange = MxRange;
+	MinRange = MnRange;
+	ScrollStride = Stride;
+	PageStep = StepStride;
+	SetValue(Current);
 }
 final function AddValue( int V )
 {
-    SetValue(CurrentScroll+V);
+	SetValue(CurrentScroll+V);
 }
 final function SetValue( int V )
 {
-    CurrentScroll = Clamp((V / ScrollStride) * ScrollStride,MinRange,MaxRange);
-    OnScrollChange(Self,CurrentScroll);
+	CurrentScroll = Clamp((V / ScrollStride) * ScrollStride,MinRange,MaxRange);
+	OnScrollChange(Self,CurrentScroll);
 }
 final function int GetValue()
 {
-    return CurrentScroll;
+	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]);
+	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();
+	// 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);
-    }
+	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);
-    }
+	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();
+	if( !bRight )
+		DropInputFocus();
 }
 
 function LostInputFocus()
 {
-    bGrabbedScroller = false;
-    bPressedDown = false;
+	bGrabbedScroller = false;
+	bPressedDown = false;
 }
 
 function ScrollMouseWheel( bool bUp )
 {
-    if( bDisabled )
-        return;
-    if( bUp )
-        AddValue(-ScrollStride);
-    else AddValue(ScrollStride);
+	if( bDisabled )
+		return;
+	if( bUp )
+		AddValue(-ScrollStride);
+	else AddValue(ScrollStride);
 }
 
 function SetVisibility(bool Visible)
 {
-    bHideScrollbar = Visible;
+	bHideScrollbar = Visible;
 }
 
 defaultproperties
 {
-    MaxRange=100
-    ScrollStride=1
-    PageStep=10
-    ButtonScale=1
+	MaxRange=100
+	ScrollStride=1
+	PageStep=10
+	ButtonScale=1
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_ScrollBarH.uc b/ScoreboardExt/Classes/KFGUI_ScrollBarH.uc
index d7a9e19..eed8e45 100644
--- a/ScoreboardExt/Classes/KFGUI_ScrollBarH.uc
+++ b/ScoreboardExt/Classes/KFGUI_ScrollBarH.uc
@@ -2,5 +2,5 @@ Class KFGUI_ScrollBarH extends KFGUI_ScrollBarBase;
 
 defaultproperties
 {
-    bVertical=false
+	bVertical=false
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_ScrollBarV.uc b/ScoreboardExt/Classes/KFGUI_ScrollBarV.uc
index e840c9c..54364ff 100644
--- a/ScoreboardExt/Classes/KFGUI_ScrollBarV.uc
+++ b/ScoreboardExt/Classes/KFGUI_ScrollBarV.uc
@@ -2,5 +2,5 @@ Class KFGUI_ScrollBarV extends KFGUI_ScrollBarBase;
 
 defaultproperties
 {
-    bVertical=true
+	bVertical=true
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_Slider.uc b/ScoreboardExt/Classes/KFGUI_Slider.uc
index bbb8aab..cd94b32 100644
--- a/ScoreboardExt/Classes/KFGUI_Slider.uc
+++ b/ScoreboardExt/Classes/KFGUI_Slider.uc
@@ -9,44 +9,44 @@ delegate OnValueChanged(KFGUI_Slider Sender, int Value);
 
 function InitMenu()
 {
-    Super.InitMenu();
-    ScrollBar = KFGUI_ScrollBarH(FindComponentID('Scrollbar'));
-    ScrollBar.OnScrollChange = ValueChanged;
+	Super.InitMenu();
+	ScrollBar = KFGUI_ScrollBarH(FindComponentID('Scrollbar'));
+	ScrollBar.OnScrollChange = ValueChanged;
 }
 
 function int GetValue()
 {
-    return CurrentValue;
+	return CurrentValue;
 }
 
 function SetValue(int Value)
 {
-    CurrentValue = Clamp(Value, MinValue, MaxValue);
-    OnValueChanged(self, CurrentValue);
+	CurrentValue = Clamp(Value, MinValue, MaxValue);
+	OnValueChanged(self, CurrentValue);
 }
 
 function ValueChanged(KFGUI_ScrollBarBase Sender, int Value)
 {
-    SetValue(Value);
+	SetValue(Value);
 }
 
 function UpdateListVis()
 {
-    ScrollBar.UpdateScrollSize(CurrentValue,MaxValue,1,1,MinValue);
+	ScrollBar.UpdateScrollSize(CurrentValue,MaxValue,1,1,MinValue);
 }
 
 function ScrollMouseWheel( bool bUp )
 {
-    if( !ScrollBar.bDisabled )
-        ScrollBar.ScrollMouseWheel(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)
+	Begin Object Class=KFGUI_ScrollBarH Name=SliderScroll
+		XSize=1
+		YSize=0.5
+		ID="Scrollbar"
+	End Object
+	Components.Add(SliderScroll)
 }
diff --git a/ScoreboardExt/Classes/KFGUI_SwitchMenuBar.uc b/ScoreboardExt/Classes/KFGUI_SwitchMenuBar.uc
index 66587b0..e09421b 100644
--- a/ScoreboardExt/Classes/KFGUI_SwitchMenuBar.uc
+++ b/ScoreboardExt/Classes/KFGUI_SwitchMenuBar.uc
@@ -11,155 +11,155 @@ var array<KFGUI_Button> PageButtons;
 
 function ShowMenu()
 {
-    GrabKeyFocus();
-    Super.ShowMenu();
+	GrabKeyFocus();
+	Super.ShowMenu();
 }
 
 function CloseMenu()
 {
-    ReleaseKeyFocus();
-    Super.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);
+	local KFGUI_Base P;
+	local KFGUI_Button B;
 
-    // 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;
+	// Add page.
+	P = new (Self) PageClass;
+	P.Owner = Owner;
+	P.ParentComponent = Self;
+	SubPages.AddItem(P);
 
-        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;
-    }
+	// 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;
 
-    ++NumButtons;
-    PageButtons.AddItem(B);
-    AddComponent(B);
-    Button = B;
-    return P;
+	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);
+	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]);
-    }
+	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;
+	local int i;
+	local byte j;
 
-    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();
-    }
+	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;
+	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
+	PagePadding=1.0
+	BorderWidth=0.05
+	ButtonAxisSize=0.08
+	CurrentPageNum=-1
+	PageComponentIndex=-1
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_TextField.uc b/ScoreboardExt/Classes/KFGUI_TextField.uc
index ec8cb93..7a43195 100644
--- a/ScoreboardExt/Classes/KFGUI_TextField.uc
+++ b/ScoreboardExt/Classes/KFGUI_TextField.uc
@@ -2,27 +2,27 @@ Class KFGUI_TextField extends KFGUI_MultiComponent;
 
 enum ETextFieldStyles
 {
-    TEXT_FIELD_NONE,
-    TEXT_FIELD_HSV,
-    TEXT_FIELD_SCAN,
-    TEXT_FIELD_FLASH
+	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
-    }
+	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 array<FTextPart> Text;
+	var float Y;
 };
 var KFGUI_ScrollBarV ScrollBar;
 
@@ -40,451 +40,451 @@ 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;
+	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;
+	Text $= S;
+	OldSize[0] = -1;
+	Lines.Length = 0;
+	OrgLines.Length = 0;
+	bTextParsed = false;
 }
 final function string GetText()
 {
-    return Text;
+	return Text;
 }
 
 final function ParseTextLines()
 {
-    local array<string> SA;
-    local int i,j,z;
-    local string S;
-    local color C;
-    local ETextFieldStyles TextType;
+	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;
+	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 = 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.
+		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;
+	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;
+	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;
+	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;
+	if( Canvas == None )
+		return;
 
-    InitFont = Owner.CurrentStyle.PickFont(InitFontScale);
-    InitFontScale *= FontScale;
-    
-    // Compute Y-offsets of each line.
-    Canvas.Font = InitFont;
-    Canvas.TextSize("ABC",XS,TextHeight,InitFontScale,InitFontScale);
+	OldSize[0] = CompPos[2];
+	OldSize[1] = CompPos[3];
+	if( !bTextParsed )
+	{
+		ParseTextLines();
+		bTextParsed = true;
+	}
+	else Lines = OrgLines;
 
-    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];
+	InitFont = Owner.CurrentStyle.PickFont(InitFontScale);
+	InitFontScale *= FontScale;
 
-        ScrollBar.ComputeCoords();
+	// Compute Y-offsets of each line.
+	Canvas.Font = InitFont;
+	Canvas.TextSize("ABC",XS,TextHeight,InitFontScale,InitFontScale);
 
-        // Recompute line sizes because we now have a scrollbar.
-        Lines = OrgLines;
-        ParseLines((CompPos[2]-ScrollWidth) / InitFontScale);
+	ParseLines(CompPos[2] / InitFontScale);
+	MaxHeight = (Lines.Length * TextHeight);
+	bShowScrollbar = (MaxHeight>=CompPos[3]);
+	bClickable = bShowScrollbar;
+	bCanFocus = bShowScrollbar;
 
-        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);
+	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;
+	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);
+	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);
 
-                // 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;
-        }
-    }
+			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;
+	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;
+	if( Left(S,1)==" " )
+		S = Mid(S,1);
+	return S;
 }
 
 function byte GetCursorStyle()
 {
-    return `PEN_WHITE;
+	return `PEN_WHITE;
 }
 
 function DrawMenu()
 {
-    local int i,j,Index;
-    local float Y;
+	local int i,j,Index;
+	local float Y;
 
-    if( Text=="" || !bVisible )
-        return;
+	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)));
-        }
-    }
+	// Need to figure out best fitting font.
+	if( OldSize[0]!=CompPos[2] || OldSize[1]!=CompPos[3] )
+		InitSize();
 
-    Canvas.Font = InitFont;
+	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)));
+		}
+	}
 
-    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);
-                }
-            }
-        }
-    }
+	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;
-    }
+	local float TempSize;
+	local int FadeAlpha;
+	local Color MainColor;
 
-    if( bUseOutlineText )
-    {
-        Owner.CurrentStyle.DrawTextShadow(S,X,Y,OutlineSize,InitFontScale);
-    }
-    else
-    {
-        Canvas.SetPos(X,Y);
-        Canvas.DrawText(S,,InitFontScale,InitFontScale,TextFontInfo);
-    }
+	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;
+	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.
+	return (bShowScrollbar ? Super.CaptureMouse() : false); // Nope.
 }
 
 function ScrollMouseWheel( bool bUp )
 {
-    if( bShowScrollbar )
-        ScrollBar.ScrollMouseWheel(bUp);
+	if( bShowScrollbar )
+		ScrollBar.ScrollMouseWheel(bUp);
 }
 
 function SetVisibility(bool Visible)
 {
-    Super.SetVisibility(Visible);
-    
-    if( ScrollBar != None )
-    {
-        ScrollBar.SetVisibility(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
+	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
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_TextLable.uc b/ScoreboardExt/Classes/KFGUI_TextLable.uc
index cce0948..825dfc1 100644
--- a/ScoreboardExt/Classes/KFGUI_TextLable.uc
+++ b/ScoreboardExt/Classes/KFGUI_TextLable.uc
@@ -13,108 +13,108 @@ var transient float OldSize[2],InitOffset[2],InitFontScale;
 
 function InitSize()
 {
-    local float XL,YL,TS;
+	local float XL,YL,TS;
 
-    OldSize[0] = CompPos[2];
-    OldSize[1] = CompPos[3];
+	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;
-    }
+	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.
+	if( Text==S )
+		return;
+	Text = S;
+	OldSize[0] = -1; // Force to refresh.
 }
 final function string GetText()
 {
-    return Text;
+	return Text;
 }
 
 function DrawMenu()
 {
-    if( Text=="" )
-        return;
+	if( Text=="" )
+		return;
 
-    // Need to figure out best fitting font.
-    if( OldSize[0]!=CompPos[2] || OldSize[1]!=CompPos[3] )
-        InitSize();
+	// 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);
-    }
+	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;
+	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
+	Text="Label"
+	TextColor=(R=255,G=255,B=255,A=255)
+	TextFontInfo=(bClipText=false,bEnableShadow=true)
+	FontScale=1.f
+	OutlineSize=1
+	bCanFocus=false
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_TextScroll.uc b/ScoreboardExt/Classes/KFGUI_TextScroll.uc
index 26735a2..9561ee9 100644
--- a/ScoreboardExt/Classes/KFGUI_TextScroll.uc
+++ b/ScoreboardExt/Classes/KFGUI_TextScroll.uc
@@ -9,177 +9,177 @@ 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;
+	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;
+	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;
+	if( bScrollCompleted )
+	{
+		Super.DrawMenu();
+		return;
+	}
 
-    // Need to figure out best fitting font.
-    if( OldSize[0]!=CompPos[2] || OldSize[1]!=CompPos[3] )
-        InitSize();
+	if( Text=="" )
+		return;
 
-    Canvas.Font = InitFont;
+	// Need to figure out best fitting font.
+	if( OldSize[0]!=CompPos[2] || OldSize[1]!=CompPos[3] )
+		InitSize();
 
-    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);
+	Canvas.Font = InitFont;
 
-                    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;
-                        }
-                    }
-                }
-            }
-        }
-    }
+	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();
+	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);
+	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
+	ScrollSpeed=0.01
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFGUI_Tooltip.uc b/ScoreboardExt/Classes/KFGUI_Tooltip.uc
index 178f9f9..bbc137d 100644
--- a/ScoreboardExt/Classes/KFGUI_Tooltip.uc
+++ b/ScoreboardExt/Classes/KFGUI_Tooltip.uc
@@ -6,37 +6,37 @@ var byte CurrentAlpha;
 
 function InputMouseMoved()
 {
-    DropInputFocus();
+	DropInputFocus();
 }
 function MouseClick( bool bRight )
 {
-    DropInputFocus();
+	DropInputFocus();
 }
 function MouseRelease( bool bRight )
 {
-    DropInputFocus();
+	DropInputFocus();
 }
 function ShowMenu()
 {
-    CurrentAlpha = 1;
+	CurrentAlpha = 1;
 }
 
 final function SetText( string S )
 {
-    ParseStringIntoArray(S,Lines,"<SEPERATOR>",false);
+	ParseStringIntoArray(S,Lines,"<SEPERATOR>",false);
 }
 
 function PreDraw()
 {
-    if( !bVisible )
-        return;
-        
-    Owner.CurrentStyle.RenderToolTip(Self);
+	if( !bVisible )
+		return;
+
+	Owner.CurrentStyle.RenderToolTip(Self);
 }
 
 defaultproperties
 {
-    TextFontInfo=(bClipText=true,bEnableShadow=true)
-    bCanFocus=false
-    bFocusedPostDrawItem=true
+	TextFontInfo=(bClipText=true,bEnableShadow=true)
+	bCanFocus=false
+	bFocusedPostDrawItem=true
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/KFScoreBoard.uc b/ScoreboardExt/Classes/KFScoreBoard.uc
index d9f718f..e17d4cc 100644
--- a/ScoreboardExt/Classes/KFScoreBoard.uc
+++ b/ScoreboardExt/Classes/KFScoreBoard.uc
@@ -1,6 +1,7 @@
 class KFScoreBoard extends KFGUI_Page;
 
-var transient float PerkXPos, PlayerXPos, StateXPos, TimeXPos, HealXPos, KillsXPos, AssistXPos, CashXPos, DeathXPos, PingXPos;
+var transient float StatusXPos, PerkXPos, PlayerXPos, HealthXPos, TimeXPos, KillsXPos, AssistXPos, CashXPos, DeathXPos, PingXPos;
+var transient float StatusWBox, PlayerWBox, PerkWBox, CashWBox, KillsWBox, AssistWBox, HealthWBox, PingWBox;
 var transient float NextScoreboardRefresh;
 
 var int PlayerIndex;
@@ -17,269 +18,294 @@ var float PingBars,IdealPing,MaxPing;
 
 function InitMenu()
 {
-    Super.InitMenu();
-    PlayersList = KFGUI_List(FindComponentID('PlayerList'));
-    OwnerPC = KFPlayerController(GetPlayer());
+	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;
-    }
+	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;
+	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;
+	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;
-                }
-            }
-        }
-    }
+	PC = GetPlayer();
+	if( KFGRI==None )
+	{
+		KFGRI = KFGameReplicationInfo(PC.WorldInfo.GRI);
+		if( KFGRI==None )
+			return;
+	}
 
-    // 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;
-        }
-    }
+	// Sort player list.
+	if( NextScoreboardRefresh < PC.WorldInfo.TimeSeconds )
+	{
+		NextScoreboardRefresh = PC.WorldInfo.TimeSeconds + 0.1;
 
-    // Header font info.
-    Canvas.Font = Owner.CurrentStyle.PickFont(FontScalar);
-    YL = Owner.CurrentStyle.DefaultHeight;
-    DefFontHeight = YL;
+		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;
+				}
+			}
+		}
+	}
 
-    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) * 0.5f), YPos + ((DefFontHeight-YL) * 0.5f), 1, FontScalar);
+	// 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;
+	}
 
-    // Deficulty | Wave | MapName
+	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;
+		}
+	}
 
-    XPos = XPosCenter;
-    YPos += DefFontHeight+Owner.HUDOwner.ScaledBorderSize;
+	// Header font info.
+	Canvas.Font = Owner.CurrentStyle.PickFont(FontScalar);
+	YL = Owner.CurrentStyle.DefaultHeight;
+	DefFontHeight = YL;
 
-    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) * 0.5f), YPos + ((DefFontHeight-YL) * 0.5f), 1, FontScalar);
-    
-    // Players | Spectators | Alive | Time
+	XPosCenter = (Canvas.ClipX * 0.5);
 
-    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) * 0.5f), YPos + ((DefFontHeight-YL) * 0.5f), 1, FontScalar);
-    
-    Width = Canvas.ClipX * 0.625;
+	// Server Name
 
-    XPos = (Canvas.ClipX - Width) * 0.5;
-    YPos += DefFontHeight * 2.0;
-    
-    Canvas.SetDrawColor (10, 10, 10, 200);
-    Owner.CurrentStyle.DrawRectBox(XPos, YPos, Width, DefFontHeight, 4);
+	XPos = XPosCenter;
+	YPos += DefFontHeight;
 
-    Canvas.SetDrawColor(250, 250, 250, 255);
+	S = KFGRI.ServerName;
+	Canvas.TextSize(S, XL, YL, FontScalar, FontScalar);
 
-    // 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;
+	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);
 
-    // Header texts
-    Canvas.SetPos (XPos + PerkXPos, YPos);
-    Canvas.DrawText (class'KFGFxMenu_Inventory'.default.PerkFilterString, , FontScalar, FontScalar);
+	Owner.CurrentStyle.DrawTextShadow(S, BoxX + ((BoxW-XL) * 0.5f), YPos + ((DefFontHeight-YL) * 0.5f), 1, FontScalar);
 
-    Canvas.SetPos (XPos + KillsXPos, YPos);
-    Canvas.DrawText (class'KFGFxHUD_ScoreboardWidget'.default.KillsString, , FontScalar, FontScalar);
+	// Deficulty | Wave | MapName
 
-    Canvas.SetPos (XPos + AssistXPos, YPos);
-    Canvas.DrawText (class'KFGFxHUD_ScoreboardWidget'.default.AssistsString, , FontScalar, FontScalar);
+	XPos = XPosCenter;
+	YPos += DefFontHeight+Owner.HUDOwner.ScaledBorderSize;
 
-    Canvas.SetPos (XPos + CashXPos, YPos);
-    Canvas.DrawText (class'KFGFxHUD_ScoreboardWidget'.default.DoshString, , FontScalar, FontScalar);
+	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);
 
-    Canvas.SetPos (XPos + StateXPos, YPos);
-    Canvas.DrawText ("STATE", , FontScalar, FontScalar);
-    
-    Canvas.SetPos (XPos + PlayerXPos, YPos);
-    Canvas.DrawText (class'KFGFxHUD_ScoreboardWidget'.default.PlayerString, , 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);
 
-    Canvas.SetPos (XPos + PingXPos, YPos);
-    Canvas.DrawText (class'KFGFxHUD_ScoreboardWidget'.default.PingString, , FontScalar, FontScalar);
+	Owner.CurrentStyle.DrawTextShadow(S, BoxX + ((BoxW-XL) * 0.5f), YPos + ((DefFontHeight-YL) * 0.5f), 1, 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);
+	// 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) * 0.5f), YPos + ((DefFontHeight-YL) * 0.5f), 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
+	StatusXPos = Width * 0.01;
+	PlayerXPos = Width * 0.20;
+	PerkXPos   = Width * 0.40;
+	CashXPos   = Width * 0.57;
+	KillsXPos  = Width * 0.66;
+	AssistXPos = Width * 0.75;
+	HealthXPos = Width * 0.84;
+	PingXPos   = Width * 0.93;
+
+	StatusWBox = PlayerXPos - StatusXPos;
+	PlayerWBox = PerkXPos   - PlayerXPos;
+	PerkWBox   = CashXPos   - PerkXPos;
+	CashWBox   = KillsXPos  - CashXPos;
+	KillsWBox  = AssistXPos - KillsXPos;
+	AssistWBox = HealthXPos - AssistXPos;
+	HealthWBox = PingXPos   - HealthXPos;
+	PingWBox   = Width	    - PingXPos;
+
+	// Header texts
+	DrawTextWLeft("STATUS", XPos + StatusXPos, YPos, FontScalar);
+	DrawTextWLeft(class'KFGFxHUD_ScoreboardWidget'.default.PlayerString, XPos + PlayerXPos, YPos, FontScalar);
+	DrawTextWLeft(class'KFGFxMenu_Inventory'.default.PerkFilterString, XPos + PerkXPos, YPos, FontScalar);
+	DrawTextWCenter(class'KFGFxHUD_ScoreboardWidget'.default.KillsString, XPos + KillsXPos, YPos, KillsWBox, FontScalar);
+	DrawTextWCenter(class'KFGFxHUD_ScoreboardWidget'.default.AssistsString, XPos + AssistXPos, YPos, AssistWBox, FontScalar);
+	DrawTextWCenter(class'KFGFxHUD_ScoreboardWidget'.default.DoshString, XPos + CashXPos, YPos, CashWBox, FontScalar);
+	DrawTextWCenter("HEALTH", XPos + HealthXPos, YPos, HealthWBox, FontScalar);
+	DrawTextWCenter(class'KFGFxHUD_ScoreboardWidget'.default.PingString, XPos + PingXPos, YPos, PingWBox, 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 DrawTextWCenter(string Str, float XPos, float YPos, float BoxWidth, float FontScalar)
+{
+	local float TextWidth;
+	local float TextHeight;
+
+	Canvas.TextSize(Str, TextWidth, TextHeight, FontScalar, FontScalar);
+
+	Canvas.SetPos(XPos + (BoxWidth - TextWidth)/2 , YPos);
+	Canvas.DrawText(Str, , FontScalar, FontScalar);
+}
+
+function DrawTextWLeft(string Str, float XPos, float YPos, float FontScalar)
+{
+	Canvas.SetPos(XPos, YPos);
+	Canvas.DrawText(Str, , FontScalar, FontScalar);
 }
 
 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 * 0.5f) - (Owner.CurrentStyle.DefaultHeight * 0.5f);
-    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);
+	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;
 
-    // Perk
-    if( bIsZED )
-    {
-        C.SetDrawColor(255,0,0,255);
-        C.SetPos (PerkXPos, YOffset - ((Height-5) * 0.5f));
-        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 )
-        {
+	YOffset *= 1.05;
+	KFPRI = KFPRIArray[Index];
+
+	if( KFGRI.bVersusGame )
+		bIsZED = KFTeamInfo_Zeds(KFPRI.Team) != None;
+
+	C.Font = Owner.CurrentStyle.PickFont(FontScalar);
+
+	TextYOffset = YOffset + (Height * 0.5f) - (Owner.CurrentStyle.DefaultHeight * 0.5f);
+	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);
+
+	// Status
+	if (KFPRI.bAdmin)
+	{
+		S = "Admin";
+	}
+	else
+	{
+		S = "Player";
+	}
+	DrawTextWLeft(S, StatusXPos, TextYOffset, FontScalar);
+
+	// Perk
+	if( bIsZED )
+	{
+		C.SetDrawColor(255,0,0,255);
+		C.SetPos (PerkXPos, YOffset - ((Height-5) * 0.5f));
+		C.DrawRect (Height-5, Height-5, Texture2D'UI_Widgets.MenuBarWidget_SWF_IF');
+
+		S = "ZED";
+		DrawTextWLeft(S, PerkXPos + Height, TextYOffset, 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;
+
+			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);
 			}
@@ -288,204 +314,195 @@ function DrawPlayerEntry( Canvas C, int Index, float YOffset, float Height, floa
 				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 * 0.5f) - ((Height - 6) * 0.5f));
-        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 * 0.5f) - ((Height - 6) * 0.5f), Height - 6, Height - 6, 1);
-    } 
-    else if( !KFPRI.bBot )
-        CheckAvatar(KFPRI, OwnerPC);
+			S = Level@KFPRI.CurrentPerkClass.default.PerkName;
+			DrawTextWLeft(S, PerkIconPosX + PerkIconSize + (Owner.HUDOwner.ScaledBorderSize*2), TextYOffset, FontScalar);
+		}
+		else
+		{
+			C.SetDrawColor(250,250,250,255);
+			S = "No Perk";
+			DrawTextWLeft(S, PerkXPos + Height, TextYOffset, FontScalar);
+		}
+	}
 
-    // 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);
+	// Avatar
+	if( KFPRI.Avatar != None )
+	{
+		if( KFPRI.Avatar == default.DefaultAvatar )
+			CheckAvatar(KFPRI, OwnerPC);
 
-    // Kill
-    C.SetPos (KillsXPos, TextYOffset);
-    C.DrawText (string (KFPRI.Kills), , FontScalar, FontScalar);
+		C.SetDrawColor(255,255,255,255);
+		C.SetPos(PlayerXPos - (Height * 1.075), YOffset + (Height * 0.5f) - ((Height - 6) * 0.5f));
+		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 * 0.5f) - ((Height - 6) * 0.5f), Height - 6, Height - 6, 1);
+	}
+	else if( !KFPRI.bBot )
+		CheckAvatar(KFPRI, OwnerPC);
 
-    // Assist
-    C.SetPos (AssistXPos, TextYOffset);
-    C.DrawText (string (KFPRI.Assists), , FontScalar, FontScalar);
+	// Player
+	if( Len(KFPRI.PlayerName) > 25 )
+		S = Left(KFPRI.PlayerName, 25);
+	else S = KFPRI.PlayerName;
+	DrawTextWLeft(S, PlayerXPos, TextYOffset, 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);
+	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";
-    }
+	// Kill
+	DrawTextWCenter(string (KFPRI.Kills), KillsXPos, TextYOffset, KillsWBox, FontScalar);
 
-    C.SetPos (StateXPos, TextYOffset);
-    C.DrawText (S, , FontScalar, FontScalar);
-    
-    C.SetDrawColor(250,250,250,255);
+	// Assist
+	DrawTextWCenter(string (KFPRI.Assists), AssistXPos, TextYOffset, AssistWBox, FontScalar);
 
-    // 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));
+	// Cash
+	if( bIsZED )
+	{
+		C.SetDrawColor(250, 0, 0, 255);
+		StrValue = "Brains!";
+	}
+	else
+	{
+		C.SetDrawColor(250, 250, 100, 255);
+		StrValue = GetNiceSize(int(KFPRI.Score));
+	}
+	DrawTextWCenter(StrValue, CashXPos, TextYOffset, CashWBox, FontScalar);
+
+	C.SetDrawColor(255,255,255,255);
+
+	// Health
+	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";
+	}
+	DrawTextWCenter(S, HealthXPos, TextYOffset, HealthWBox, 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);
+
+	DrawTextWLeft(S, PingXPos, TextYOffset, 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;
+	local float PingMul, BarW, BarH, BaseH, XPos, YPos;
+	local byte i;
 
-    PingColor.R = (1.f - PingMul) * 255;
-    PingColor.G = PingMul * 255;
+	PingMul = 1.f - FClamp(FMax(Ping - IdealPing, 1.f) / MaxPing, 0.f, 1.f);
+	BarW = W / PingBars;
+	BaseH = H / PingBars;
 
-    for(i=1; i<PingBars; i++)
-    {
-        BarH = BaseH * i;
-        XPos = XOffset + ((i - 1) * BarW);
-        YPos = YOffset + (H - BarH);
+	PingColor.R = (1.f - PingMul) * 255;
+	PingColor.G = PingMul * 255;
 
-        C.SetPos(XPos,YPos);
-        C.SetDrawColor(20, 20, 20, 255);
-        Owner.CurrentStyle.DrawWhiteBox(BarW,BarH);
+	for(i=1; i<PingBars; i++)
+	{
+		BarH = BaseH * i;
+		XPos = XOffset + ((i - 1) * BarW);
+		YPos = YOffset + (H - BarH);
 
-        if( PingMul >= (i / PingBars) )
-        {
-            C.SetPos(XPos,YPos);
-            C.DrawColor = PingColor;
-            Owner.CurrentStyle.DrawWhiteBox(BarW,BarH);
-        }
+		C.SetPos(XPos,YPos);
+		C.SetDrawColor(20, 20, 20, 255);
+		Owner.CurrentStyle.DrawWhiteBox(BarW,BarH);
 
-        C.SetDrawColor(80, 80, 80, 255);
-        Owner.CurrentStyle.DrawBoxHollow(XPos,YPos,BarW,BarH,1);
-    }
+		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'));
+	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";
+	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";
+	return (Num / 1000000000) $ "B";
 }
 
 function ScrollMouseWheel( bool bUp )
 {
-    PlayersList.ScrollMouseWheel(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'
+	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'
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/ScoreboardExtHUD.uc b/ScoreboardExt/Classes/ScoreboardExtHUD.uc
index d382170..d00dba4 100644
--- a/ScoreboardExt/Classes/ScoreboardExtHUD.uc
+++ b/ScoreboardExt/Classes/ScoreboardExtHUD.uc
@@ -1,5 +1,5 @@
 class ScoreboardExtHUD extends KFGFxHudWrapper
-    config(ScoreboardExtMut);
+	config(ScoreboardExtMut);
 
 const HUDBorderSize = 3;
 
@@ -16,99 +16,99 @@ var transient GUIStyleBase GUIStyle;
 
 simulated function PostBeginPlay()
 {
-    Super.PostBeginPlay();
-    
-    PlayerOwner.PlayerInput.OnReceivedNativeInputKey = NotifyInputKey;
-    PlayerOwner.PlayerInput.OnReceivedNativeInputAxis = NotifyInputAxis;
-    PlayerOwner.PlayerInput.OnReceivedNativeInputChar = NotifyInputChar;
-    
-    RemoveMovies();
-    CreateHUDMovie();
+	Super.PostBeginPlay();
+
+	PlayerOwner.PlayerInput.OnReceivedNativeInputKey = NotifyInputKey;
+	PlayerOwner.PlayerInput.OnReceivedNativeInputAxis = NotifyInputAxis;
+	PlayerOwner.PlayerInput.OnReceivedNativeInputChar = NotifyInputChar;
+
+	RemoveMovies();
+	CreateHUDMovie();
 }
 
 function PostRender()
 {
-    if( KFGRI == None )
-        KFGRI = KFGameReplicationInfo(WorldInfo.GRI);
-    
-    if( GUIController!=None && PlayerOwner.PlayerInput==None )
-        GUIController.NotifyLevelChange();
-        
-    if( GUIController==None || GUIController.bIsInvalid )
-    {
-        GUIController = Class'ScoreboardExt.KF2GUIController'.Static.GetGUIController(PlayerOwner);
-        if( GUIController!=None )
-        {
-            GUIStyle = GUIController.CurrentStyle;
-            GUIStyle.HUDOwner = self;
-            LaunchHUDMenus();
-        }
-    }
-    GUIStyle.Canvas = Canvas;
-    GUIStyle.PickDefaultFontSize(Canvas.ClipY);
-    
-    if( !GUIController.bIsInMenuState )
-        GUIController.HandleDrawMenu();
-    
+	if( KFGRI == None )
+		KFGRI = KFGameReplicationInfo(WorldInfo.GRI);
+
+	if( GUIController!=None && PlayerOwner.PlayerInput==None )
+		GUIController.NotifyLevelChange();
+
+	if( GUIController==None || GUIController.bIsInvalid )
+	{
+		GUIController = Class'ScoreboardExt.KF2GUIController'.Static.GetGUIController(PlayerOwner);
+		if( GUIController!=None )
+		{
+			GUIStyle = GUIController.CurrentStyle;
+			GUIStyle.HUDOwner = self;
+			LaunchHUDMenus();
+		}
+	}
+	GUIStyle.Canvas = Canvas;
+	GUIStyle.PickDefaultFontSize(Canvas.ClipY);
+
+	if( !GUIController.bIsInMenuState )
+		GUIController.HandleDrawMenu();
+
 	ScaledBorderSize = FMax(GUIStyle.ScreenScale(HUDBorderSize), 1.f);
-	
-    Super.PostRender();
+
+	Super.PostRender();
 }
 
 function LaunchHUDMenus()
 {
-    Scoreboard = KFScoreBoard(GUIController.InitializeHUDWidget(ScoreboardClass));
-    Scoreboard.SetVisibility(false);
+	Scoreboard = KFScoreBoard(GUIController.InitializeHUDWidget(ScoreboardClass));
+	Scoreboard.SetVisibility(false);
 }
 
 function bool NotifyInputKey(int ControllerId, Name Key, EInputEvent Event, float AmountDepressed, bool bGamepad)
 {
-    local int i;
-    
-    for( i=(HUDWidgets.Length-1); i>=0; --i )
-    {
-        if( HUDWidgets[i].bVisible && HUDWidgets[i].NotifyInputKey(ControllerId, Key, Event, AmountDepressed, bGamepad) )
-            return true;
-    }
-    
-    return false;
+	local int i;
+
+	for( i=(HUDWidgets.Length-1); i>=0; --i )
+	{
+		if( HUDWidgets[i].bVisible && HUDWidgets[i].NotifyInputKey(ControllerId, Key, Event, AmountDepressed, bGamepad) )
+			return true;
+	}
+
+	return false;
 }
 
 function bool NotifyInputAxis(int ControllerId, name Key, float Delta, float DeltaTime, optional bool bGamepad)
 {
-    local int i;
-    
-    for( i=(HUDWidgets.Length-1); i>=0; --i )
-    {
-        if( HUDWidgets[i].bVisible && HUDWidgets[i].NotifyInputAxis(ControllerId, Key, Delta, DeltaTime, bGamepad) )
-            return true;
-    }
-    
-    return false;
+	local int i;
+
+	for( i=(HUDWidgets.Length-1); i>=0; --i )
+	{
+		if( HUDWidgets[i].bVisible && HUDWidgets[i].NotifyInputAxis(ControllerId, Key, Delta, DeltaTime, bGamepad) )
+			return true;
+	}
+
+	return false;
 }
 
 function bool NotifyInputChar(int ControllerId, string Unicode)
 {
-    local int i;
-    
-    for( i=(HUDWidgets.Length-1); i>=0; --i )
-    {
-        if( HUDWidgets[i].bVisible && HUDWidgets[i].NotifyInputChar(ControllerId, Unicode) )
-            return true;
-    }
-    
-    return false;
+	local int i;
+
+	for( i=(HUDWidgets.Length-1); i>=0; --i )
+	{
+		if( HUDWidgets[i].bVisible && HUDWidgets[i].NotifyInputChar(ControllerId, Unicode) )
+			return true;
+	}
+
+	return false;
 }
 
 exec function SetShowScores(bool bNewValue)
 {
-    if (Scoreboard != None)
-        Scoreboard.SetVisibility(bNewValue);
+	if (Scoreboard != None)
+		Scoreboard.SetVisibility(bNewValue);
 	else Super.SetShowScores(bNewValue);
 }
 
 defaultproperties
 {
-    ScoreboardClass=class'KFScoreBoard'
+	ScoreboardClass=class'KFScoreBoard'
 	RepObject=ObjectReferencer'KFScoreboardExt_Assets.ObjectRef.MainObj_List'
 }
\ No newline at end of file
diff --git a/ScoreboardExt/Classes/ScoreboardExtMut.uc b/ScoreboardExt/Classes/ScoreboardExtMut.uc
index 8ed102b..1e0a0f4 100644
--- a/ScoreboardExt/Classes/ScoreboardExtMut.uc
+++ b/ScoreboardExt/Classes/ScoreboardExtMut.uc
@@ -2,8 +2,8 @@ class ScoreboardExtMut extends KFMutator;
 
 function PostBeginPlay()
 {
-    Super.PostBeginPlay();
-    WorldInfo.Game.HUDType = class'ScoreboardExtHUD'; 
+	Super.PostBeginPlay();
+	WorldInfo.Game.HUDType = class'ScoreboardExtHUD'; 
 }
 
 defaultproperties