KillingFloor2/KF2-YetAnotherScoreboard
KillingFloor2/KF2-YetAnotherScoreboard
1
0
Fork 0
Code Releases 7 Activity

improve scoreboard and replace spaces with tabs

Browse Source
This commit is contained in:
GenZmeY 2021-05-16 12:40:02 +03:00
parent 04262cb27b
commit 6af64d1f51
44 changed files with 6055 additions and 6037 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

604
ScoreboardExt/Classes/ClassicStyle.uc
View File

@ -2,405 +2,405 @@ Class ClassicStyle extends KF2Style;
function RenderFramedWindow( KFGUI_FloatingWindow P )
{
local int XS,YS,TitleHeight;
local float XL, YL, FontScale;
local int XS,YS,TitleHeight;
local float XL, YL, FontScale;
XS = Canvas.ClipX-Canvas.OrgX;
YS = Canvas.ClipY-Canvas.OrgY;
TitleHeight = DefaultHeight;
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);
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 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);
// 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);
}
// 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;
local int XS,YS;
XS = Canvas.ClipX-Canvas.OrgX;
YS = Canvas.ClipY-Canvas.OrgY;
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);
// 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);
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;
// 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;
// Give some borders.
TX += TOOLTIP_BORDER*2;
TY += TOOLTIP_BORDER*2;
X = TT.CompPos[0];
Y = TT.CompPos[1]+24.f;
X = TT.CompPos[0];
Y = TT.CompPos[1]+24.f;
// Then check if too close to window edge, then move it to another pivot.
if( (X+TX)>TT.Owner.ScreenSize.X )
X = TT.Owner.ScreenSize.X-TX;
if( (Y+TY)>TT.Owner.ScreenSize.Y )
Y = TT.CompPos[1]-TY;
// 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);
if( TT.CurrentAlpha<255 )
TT.CurrentAlpha = Min(TT.CurrentAlpha+25,255);
// Reset clipping.
Canvas.SetOrigin(0,0);
Canvas.SetClip(TT.Owner.ScreenSize.X,TT.Owner.ScreenSize.Y);
// 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);
// 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;
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;
}
// 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);
Canvas.SetPos(0.f, 0.f);
Canvas.DrawTileStretched(BorderTextures[`BOX_INNERBORDER],S.CompPos[2],S.CompPos[3],0,0,128,128);
if( S.bDisabled )
return;
if( S.bDisabled )
return;
if( S.bVertical )
i = 3;
else i = 2;
if( S.bVertical )
i = 3;
else i = 2;
S.SliderScale = FMax(S.PageStep * (S.CompPos[i] - 32.f) / (S.MaxRange + S.PageStep),S.CalcButtonScale);
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;
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 /= ((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);
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.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);
}
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;
local Texture CheckMark;
DrawTileStretched(ItemBoxTextures[`ITEMBOX_DISABLED],0.f,0.f,C.CompPos[2],C.CompPos[3]);
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];
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());
}
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);
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);
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);
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();
}
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;
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);
// Draw background.
Edge = C.Combo.BorderSize;
Canvas.SetPos(0.f, 0.f);
Canvas.DrawTileStretched(BorderTextures[`BOX_SMALL_SLIGHTTRANSPARENT],C.CompPos[2],C.CompPos[3],0,0,128,128);
// While rendering, figure out mouse focus row.
X = C.Owner.MousePosition.X - Canvas.OrgX;
Y = C.Owner.MousePosition.Y - Canvas.OrgY;
// 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]);
bCheckMouse = (X>0.f && X<C.CompPos[2] && Y>0.f && Y<C.CompPos[3]);
Canvas.Font = C.Combo.TextFont;
YL = C.Combo.TextHeight;
Canvas.Font = C.Combo.TextFont;
YL = C.Combo.TextHeight;
YP = Edge;
C.CurrentRow = -1;
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);
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;
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);
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);
}
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;
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);
// Draw background.
Edge = C.EdgeSize;
DrawOutlinedBox(0.f,0.f,C.CompPos[2],C.CompPos[3],Edge,C.BoxColor,C.OutlineColor);
// While rendering, figure out mouse focus row.
X = C.Owner.MousePosition.X - Canvas.OrgX;
Y = C.Owner.MousePosition.Y - Canvas.OrgY;
// 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]);
bCheckMouse = (X>0.f && X<C.CompPos[2] && Y>0.f && Y<C.CompPos[3]);
PickFont(TextScale);
PickFont(TextScale);
YP = Edge*2;
C.CurrentRow = -1;
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.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);
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);
}
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);
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);
}
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];
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);
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.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;
if( B.ButtonText!="" )
{
Canvas.Font = MainFont;
GamepadTexSize = B.CompPos[3] / 1.25;
GamepadTexSize = B.CompPos[3] / 1.25;
TS = GetFontScaler();
TS *= B.FontScale;
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;
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;
}
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);
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;
}
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;
}
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(Canvas.CurX-(GamepadTexSize*1.25),(B.CompPos[3]-GamepadTexSize)*0.5);
Canvas.DrawRect(GamepadTexSize,GamepadTexSize,ButtonTex);
}
}
}
}
defaultproperties

1125
ScoreboardExt/Classes/GUIStyleBase.uc
View File

File diff suppressed because it is too large Load Diff

1452
ScoreboardExt/Classes/KF2GUIController.uc
View File

File diff suppressed because it is too large Load Diff

72
ScoreboardExt/Classes/KF2GUIInput.uc
View File

@ -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);
// 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;
}
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

700
ScoreboardExt/Classes/KF2Style.uc
View File

@ -5,448 +5,448 @@ const TOOLTIP_BORDER=4;
function InitStyle()
{
local byte i;
local byte i;
Super.InitStyle();
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';
}
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;
local int XS,YS,CornerSlope,TitleHeight;
XS = Canvas.ClipX-Canvas.OrgX;
YS = Canvas.ClipY-Canvas.OrgY;
CornerSlope = DefaultHeight*0.4;
TitleHeight = DefaultHeight;
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);
// 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);
// 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);
// 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);
// 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);
}
// 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;
local int XS,YS,CornerSlope;
XS = Canvas.ClipX-Canvas.OrgX;
YS = Canvas.ClipY-Canvas.OrgY;
CornerSlope = DefaultHeight*0.4;
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);
// 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));
// 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;
// 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;
// Give some borders.
TX += TOOLTIP_BORDER*2;
TY += TOOLTIP_BORDER*2;
X = TT.CompPos[0];
Y = TT.CompPos[1]+24.f;
X = TT.CompPos[0];
Y = TT.CompPos[1]+24.f;
// Then check if too close to window edge, then move it to another pivot.
if( (X+TX)>TT.Owner.ScreenSize.X )
X = TT.Owner.ScreenSize.X-TX;
if( (Y+TY)>TT.Owner.ScreenSize.Y )
Y = TT.CompPos[1]-TY;
// 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);
if( TT.CurrentAlpha<255 )
TT.CurrentAlpha = Min(TT.CurrentAlpha+25,255);
// Reset clipping.
Canvas.SetOrigin(0,0);
Canvas.SetClip(TT.Owner.ScreenSize.X,TT.Owner.ScreenSize.Y);
// 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);
// 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;
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;
}
// 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);
DrawRectBox (0.f, 0.f, S.CompPos[2], S.CompPos[3], 4);
if( S.bDisabled )
return;
if( S.bDisabled )
return;
if( S.bVertical )
i = 3;
else i = 2;
if( S.bVertical )
i = 3;
else i = 2;
S.SliderScale = FMax(S.PageStep * (S.CompPos[i] - 32.f) / (S.MaxRange + S.PageStep),S.CalcButtonScale);
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;
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 /= ((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);
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.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);
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);
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);
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);
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());
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());
}
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);
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]);
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();
}
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;
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));
// Draw background.
Edge = C.Combo.BorderSize;
Canvas.SetPos(0.f,0.f);
Canvas.SetDrawColor(128,4,4,255);
DrawWhiteBox(C.CompPos[2],C.CompPos[3]);
Canvas.SetPos(Edge,Edge);
Canvas.SetDrawColor(64,4,4,255);
DrawWhiteBox(C.CompPos[2]-(Edge*2.f),C.CompPos[3]-(Edge*2.f));
// While rendering, figure out mouse focus row.
X = C.Owner.MousePosition.X - Canvas.OrgX;
Y = C.Owner.MousePosition.Y - Canvas.OrgY;
// 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]);
bCheckMouse = (X>0.f && X<C.CompPos[2] && Y>0.f && Y<C.CompPos[3]);
Canvas.Font = C.Combo.TextFont;
YL = C.Combo.TextHeight;
Canvas.Font = C.Combo.TextFont;
YL = C.Combo.TextHeight;
YP = Edge;
C.CurrentRow = -1;
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);
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;
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);
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);
}
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;
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));
// Draw background.
Edge = C.EdgeSize;
Canvas.SetDrawColor(148,4,4,255);
DrawBoxHollow(0.f,0.f,C.CompPos[2],C.CompPos[3],Edge);
Canvas.SetPos(Edge,Edge);
Canvas.SetDrawColor(64,4,4,200);
DrawWhiteBox(C.CompPos[2]-(Edge*2.f),C.CompPos[3]-(Edge*2.f));
// While rendering, figure out mouse focus row.
X = C.Owner.MousePosition.X - Canvas.OrgX;
Y = C.Owner.MousePosition.Y - Canvas.OrgY;
// 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]);
bCheckMouse = (X>0.f && X<C.CompPos[2] && Y>0.f && Y<C.CompPos[3]);
Canvas.Font = PickFont(TextScale);
Canvas.Font = PickFont(TextScale);
YP = Edge;
C.CurrentRow = -1;
YP = Edge;
C.CurrentRow = -1;
TexDefHieght = DefaultHeight;
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.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);
}
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+=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.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.bIsHighlighted )
{
Canvas.DrawColor.R = Min(Canvas.DrawColor.R+25,255);
Canvas.DrawColor.G = Min(Canvas.DrawColor.G+25,255);
Canvas.DrawColor.B = Min(Canvas.DrawColor.B+25,255);
}
Canvas.SetPos(0.f,0.f);
if( B.ExtravDir==255 )
DrawWhiteBox(B.CompPos[2],B.CompPos[3]);
else DrawRectBox(0,0,B.CompPos[2],B.CompPos[3],Min(B.CompPos[2],B.CompPos[3])*0.2,B.ExtravDir);
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);
}
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
}

176
ScoreboardExt/Classes/KFColorHelper.uc
View File

@ -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;
RGB.R += Min;
RGB.G += Min;
RGB.B += Min;
RGB.A = HSV.A;
return RGB;
return RGB;
}
static final function Color LinearColorToColor(const LinearColor RGB)
{
local Color TrueRGB;
local Color TrueRGB;
TrueRGB.R = RGB.R * 255;
TrueRGB.G = RGB.G * 255;
TrueRGB.B = RGB.B * 255;
TrueRGB.A = RGB.A * 255;
TrueRGB.R = RGB.R * 255;
TrueRGB.G = RGB.G * 255;
TrueRGB.B = RGB.B * 255;
TrueRGB.A = RGB.A * 255;
return TrueRGB;
return TrueRGB;
}

2
ScoreboardExt/Classes/KFGUIConsoleHack.uc
View File

@ -5,5 +5,5 @@ var KF2GUIController OutputObject;
function PostRender_Console(Canvas Canvas)
{
OutputObject.RenderMenu(Canvas);
OutputObject.RenderMenu(Canvas);
}

316
ScoreboardExt/Classes/KFGUI_Base.uc
View File

@ -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;
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();
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( InRate <= 0.f )
{
ClearTimer(inTimerFunc);
return;
}
if( TimerNames.Find(inTimerFunc) == INDEX_NONE )
{
TimerNames.AddItem(inTimerFunc);
}
if( TimerNames.Find(inTimerFunc) == INDEX_NONE )
{
TimerNames.AddItem(inTimerFunc);
}
`TimerHelper.SetTimer( InRate, inbLoop, inTimerFunc, self );
`TimerHelper.SetTimer( InRate, inbLoop, inTimerFunc, self );
}
final function ClearTimer(optional Name inTimerFunc='Timer')
{
if( TimerNames.Find(inTimerFunc) != INDEX_NONE )
{
TimerNames.RemoveItem(inTimerFunc);
}
if( TimerNames.Find(inTimerFunc) != INDEX_NONE )
{
TimerNames.RemoveItem(inTimerFunc);
}
`TimerHelper.ClearTimer( inTimerFunc, self );
`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;
local KFGUI_Base M;
for( M=Self; M.MouseArea!=None; M=M.MouseArea )
{}
return 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;
local int i;
for( i=0; i<TimerNames.Length; i++ )
{
ClearTimer(TimerNames[i]);
}
for( i=0; i<TimerNames.Length; i++ )
{
ClearTimer(TimerNames[i]);
}
if( ParentComponent!=None )
ParentComponent.DoClose();
else Owner.PopCloseMenu(Self);
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;
local KFGUI_Base M;
for( M=Self; M.ParentComponent!=None; M=M.ParentComponent )
{}
return KFGUI_Page(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;
}
}
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;
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;
local SoundCue S;
local KFGameEngine Engine;
Engine = KFGameEngine(class'Engine'.static.GetEngine());
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;
}
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);
}
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;
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;
// 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
}

20
ScoreboardExt/Classes/KFGUI_Button.uc
View File

@ -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
}

108
ScoreboardExt/Classes/KFGUI_CategoryButton.uc
View File

@ -6,73 +6,73 @@ var Color IconColor;
function DrawMenu()
{
local float XL,YL,TS,TextX,TextY;
local Texture2D Mat;
local bool bDrawOverride;
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];
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);
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( 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;
if( ButtonText!="" )
{
Canvas.Font = Owner.CurrentStyle.MainFont;
TS = Owner.CurrentStyle.GetFontScaler();
TS *= FontScale;
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;
while( true )
{
Canvas.TextSize(ButtonText,XL,YL,TS,TS);
if( XL<(CompPos[2]*0.9) && YL<(CompPos[3]*0.9) )
break;
TS -= 0.001;
}
TS -= 0.001;
}
TextX = (CompPos[2]-XL)*0.5;
TextY = (CompPos[3]-YL)*0.5;
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);
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;
if( Icon != None )
{
Canvas.DrawColor = IconColor;
Canvas.SetPos(TextX-CompPos[3], 0.f);
Canvas.DrawRect(CompPos[3], CompPos[3], Icon);
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.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]);
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

110
ScoreboardExt/Classes/KFGUI_CategoryList.uc
View File

@ -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;
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;
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;
local FCategoryItems CatItem;
local KFGUI_Base G;
G = CreateComponent(Item);
G.ID = CatID;
G.Owner = Owner;
G.ParentComponent = Self;
G = CreateComponent(Item);
G.ID = CatID;
G.Owner = Owner;
G.ParentComponent = Self;
CatItem.ID = CatID;
CatItem.Item = G;
CategoryItems.AddItem(CatItem);
CatItem.ID = CatID;
CatItem.Item = G;
CategoryItems.AddItem(CatItem);
return G;
return G;
}
function SelectedCategory(KFGUI_Button Sender)
{
local int i, j, Index;
local KFGUI_CategoryButton CatB;
local int i, j, Index;
local KFGUI_CategoryButton CatB;
CatB = KFGUI_CategoryButton(Sender);
if( CatB == None )
return;
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);
}
}
}
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;
local int i;
for( i=0; i<ItemComponents.Length; i++ )
{
if( KFGUI_CategoryButton(ItemComponents[i]) == None )
ItemComponents.Remove(i, 1);
}
CategoryItems.Length = 0;
for( i=0; i<ItemComponents.Length; i++ )
{
if( KFGUI_CategoryButton(ItemComponents[i]) == None )
ItemComponents.Remove(i, 1);
}
CategoryItems.Length = 0;
}
defaultproperties

16
ScoreboardExt/Classes/KFGUI_CheckBox.uc
View File

@ -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
}

96
ScoreboardExt/Classes/KFGUI_Clickable.uc
View File

@ -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
}

156
ScoreboardExt/Classes/KFGUI_ColorSlider.uc
View File

@ -9,114 +9,114 @@ var string CaptionText;
function InitMenu()
{
Super.InitMenu();
Super.InitMenu();
SettingsBox = KFGUI_ComponentList(FindComponentID('SettingsBox'));
SettingsBox = KFGUI_ComponentList(FindComponentID('SettingsBox'));
TextLable = KFGUI_TextLable(FindComponentID('CaptionText'));
TextLable.SetText(CaptionText);
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);
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);
SetDefaultColor(DefaultColor);
}
function SetDefaultColor(Color Def)
{
RSlider.SetValue(Def.R);
RSlider.UpdateListVis();
RSlider.SetValue(Def.R);
RSlider.UpdateListVis();
GSlider.SetValue(Def.G);
GSlider.UpdateListVis();
GSlider.SetValue(Def.G);
GSlider.UpdateListVis();
BSlider.SetValue(Def.B);
BSlider.UpdateListVis();
BSlider.SetValue(Def.B);
BSlider.UpdateListVis();
ASlider.SetValue(Def.A);
ASlider.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;
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;
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;
}
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);
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_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_TextLable Name=CaptionLabel
XSize=1
YSize=0.125
AlignX=1
AlignY=1
ID="CaptionText"
End Object
Components.Add(CaptionLabel)
}

650
ScoreboardExt/Classes/KFGUI_ColumnList.uc
View File

@ -3,12 +3,12 @@ Class KFGUI_ColumnList extends KFGUI_List;
struct FColumnItem
{
var() string Text;
var() float Width;
var() bool bOnlyTextures;
var() string Text;
var() float Width;
var() bool bOnlyTextures;
var transient bool bHidden;
var transient int X,XSize;
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;
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;
// 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);
// Setup column text value.
N.SetValue(Value,iValue,SortValue);
// Insert into list.
if( bShouldSortList && Index==-1 )
{
N.Temp = N.GetSortStr(LastSortedColumn);
// 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();
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;
return N;
}
final function RemoveLine( KFGUI_ListItem I )
{
local KFGUI_ListItem N;
local KFGUI_ListItem N;
if( I.Index==-1 )
return;
if( I.Index==-1 )
return;
// Update selected row info.
if( SelectedRowIndex==I.Index )
SelectedRowIndex = -1;
else if( SelectedRowIndex>I.Index )
--SelectedRowIndex;
// 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;
}
}
// 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;
// Add to unused list.
I.Next = UnusedItem;
UnusedItem = I;
I.Index = -1;
UpdateListSize();
UpdateListSize();
}
final function EmptyList()
{
local KFGUI_ListItem N,I;
local KFGUI_ListItem N,I;
for( I=FirstItem; I!=None; I=N )
{
N = I.Next;
for( I=FirstItem; I!=None; I=N )
{
N = I.Next;
// Add to unused list.
I.Next = UnusedItem;
UnusedItem = I;
I.Index = -1;
}
// Add to unused list.
I.Next = UnusedItem;
UnusedItem = I;
I.Index = -1;
}
FirstItem = None;
UpdateListSize();
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;
local array<KFGUI_ListItem> List;
local KFGUI_ListItem Sel,N,P;
local int i;
if( !bCanSortColumn || Column<0 || Column>=Columns.Length )
return;
if( !bCanSortColumn || Column<0 || Column>=Columns.Length )
return;
LastSortedColumn = Column;
bLastSortedReverse = bReverse;
bShouldSortList = true;
LastSortedColumn = Column;
bLastSortedReverse = bReverse;
bShouldSortList = true;
// Allocate memory space first.
List.Length = ListCount;
List.Length = 0;
// Allocate memory space first.
List.Length = ListCount;
List.Length = 0;
// Grab current selected line.
Sel = GetFromIndex(SelectedRowIndex);
SelectedRowIndex = -1;
// 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);
// 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;
}
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;
}
// 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;
local KFGUI_ListItem N;
ListCount = 0;
for( N=FirstItem; N!=None; N=N.Next )
N.Index = ListCount++;
bListSizeDirty = true;
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);
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];
// Mouse focused item check.
bCheckMouse = bClickable && bFocused;
FocusMouseItem = -1;
if( bCheckMouse )
MouseYHit = Owner.MousePosition.Y - CompPos[1];
n = ScrollBar.CurrentScroll;
i = 0;
for( C=FirstItem; C!=None; C=C.Next )
if( (i++)==n )
break;
Y = 0.f;
TextY = (ItemHeight-TextHeight)*0.5f;
XOffset = TextY*0.75;
Canvas.SetDrawColor(250,250,250,255);
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;
}
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 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;
}
// 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;
local byte j;
local float XS,SpaceX;
if( !bVisible )
return;
if( !bVisible )
return;
ComputeCoords();
ComputeCoords();
// Check font to use.
Canvas.Font = Owner.CurrentStyle.PickFont(TextScaler);
TextScaler *= FontSize;
Canvas.TextSize("ABC",XS,TextHeight,TextScaler,TextScaler);
// 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];
}
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];
// 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();
// 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];
// 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();
}
// 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 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();
// 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];
// 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)
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)
LineFontInfo=(bClipText=true,bEnableShadow=false)
}

298
ScoreboardExt/Classes/KFGUI_ColumnTop.uc
View File

@ -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];
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]);
// Scale column
if( bScaleColumn )
{
MouseX = Owner.MousePosition.X - CompPos[0];
for( i=0; i<ScalingColumn; ++i )
MouseX-=(ListOwner.Columns[i].Width * CompPos[2]);
ListOwner.Columns[ScalingColumn].Width = MouseX / CompPos[2];
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.
// Make sure no column is scrolled off screen.
X = 0;
for( i=0; i<(ListOwner.Columns.Length-1); ++i )
{
if( ListOwner.Columns[i].Width<MinSize )
ListOwner.Columns[i].Width = MinSize;
X+=ListOwner.Columns[i].Width;
if( X>=(1.f-MinSize) )
{
MouseX = X-(1.f-MinSize); // Grab overshoot.
// Then push back!
for( j=i; j>=0; --j )
{
if( (ListOwner.Columns[j].Width-MouseX)>MinSize ) // This column has enough space to retract.
{
ListOwner.Columns[j].Width-=MouseX;
MouseX = 0;
break;
}
else if( ListOwner.Columns[j].Width>MinSize ) // This column has limited space to retract.
{
MouseX-=(ListOwner.Columns[j].Width-MinSize);
ListOwner.Columns[j].Width = MinSize;
}
}
X = (1.f-MinSize); // Continue at maximum size.
}
}
}
// 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;
}
// Init mouse check.
MouseColumn = -1;
bCheckMouse = (bClickable && bFocused);
if( bCheckMouse )
{
GrabWidth = CompPos[3]*0.175;
MouseX = Owner.MousePosition.X - CompPos[0] - GrabWidth;
GrabWidth *= -2.f;
}
// Draw the columns and compute the scalings.
X = 0;
j = (ListOwner.bShouldSortList ? ListOwner.LastSortedColumn : -1);
for( i=0; i<ListOwner.Columns.Length; ++i )
{
if( ListOwner.Columns[i].Width<MinSize )
ListOwner.Columns[i].Width = MinSize;
// Draw the columns and compute the scalings.
X = 0;
j = (ListOwner.bShouldSortList ? ListOwner.LastSortedColumn : -1);
for( i=0; i<ListOwner.Columns.Length; ++i )
{
if( ListOwner.Columns[i].Width<MinSize )
ListOwner.Columns[i].Width = MinSize;
Wd = ListOwner.Columns[i].Width * CompPos[2];
if( i==(ListOwner.Columns.Length-1) ) // Final column, give infinitive width.
{
Wd = (CompPos[2]-X);
}
if( Wd<=0 ) // Impossible.
{
ListOwner.Columns[i].bHidden = true;
continue;
}
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;
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( 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]);
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 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);
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;
}
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( !ListOwner.bDisabled && bClickable )
{
PressedDown[byte(bRight)] = 1;
bPressedDown = true;
if( !bRight && bMouseScaler )
{
PlayMenuSound(MN_ClickButton);
bScaleColumn = true;
ScalingColumn = MouseColumn;
GetInputFocus();
}
}
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( 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( 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
}

62
ScoreboardExt/Classes/KFGUI_ComboBox.uc
View File

@ -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;
local int i;
i = Values.Find(S);
if( i==-1 )
return false;
SelectedIndex = i;
return true;
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
}

22
ScoreboardExt/Classes/KFGUI_ComboSelector.uc
View File

@ -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
}

252
ScoreboardExt/Classes/KFGUI_ComponentList.uc
View File

@ -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;
local KFGUI_Base G;
G = new(Self)CompClass;
if( G==None )
return None;
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;
G.XPosition = (1.f - XS) * 0.5f;
G.YPosition = (1.f - YS) * 0.5f;
G.XSize = XS;
G.YSize = YS;
return G;
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;
local KFGUI_Base G;
G = CreateComponent(CompClass, XS, YS);
G.Owner = Owner;
G.ParentComponent = Self;
ItemComponents.InsertItem(i, G);
G = CreateComponent(CompClass, XS, YS);
G.Owner = Owner;
G.ParentComponent = Self;
ItemComponents.InsertItem(i, G);
return 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;
local int i;
local byte j;
if( !bVisible )
return;
if( !bVisible )
return;
ComputeCoords();
ComputeCoords();
// Update list size
i = ItemComponents.Length / NumColumns;
if( i!=NumColumns )
{
ListCount = i;
UpdateListVis();
}
// 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();
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();
}
// 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;
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();
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;
}
}
}
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;
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;
}
}
}
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();
return Super.CaptureMouse();
}
function CloseMenu()
{
local int i;
local int i;
for( i=0; i<ItemComponents.Length; ++i )
ItemComponents[i].CloseMenu();
Super.CloseMenu();
for( i=0; i<ItemComponents.Length; ++i )
ItemComponents[i].CloseMenu();
Super.CloseMenu();
}
function NotifyLevelChange()
{
local int i;
local int i;
for( i=0; i<ItemComponents.Length; ++i )
ItemComponents[i].NotifyLevelChange();
Super.NotifyLevelChange();
for( i=0; i<ItemComponents.Length; ++i )
ItemComponents[i].NotifyLevelChange();
Super.NotifyLevelChange();
}
function InventoryChanged(optional KFWeapon Wep, optional bool bRemove)
{
local int i;
local int i;
for( i=0; i<ItemComponents.Length; ++i )
ItemComponents[i].InventoryChanged(Wep,bRemove);
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
}

624
ScoreboardExt/Classes/KFGUI_EditBox.uc
View File

@ -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( UniCode!="" )
S = Unicode;
else S = Chr(Key);
if( Asc(S) == 13 || Asc(S) == 8 || Asc(S) == 27 )
return false;
if( Asc(S) == 13 || Asc(S) == 8 || Asc(S) == 27 )
return false;
if( bCtrl )
return false;
if( bCtrl )
return false;
if(bAllSelected)
{
TextStr="";
CaretPos=0;
bAllSelected=false;
}
if(bAllSelected)
{
TextStr="";
CaretPos=0;
bAllSelected=false;
}
if ( (AllowedCharSet=="") || ( (bIncludeSign) && ( (S=="-") || (S=="+") ) && (TextStr=="") ) || (InStr(AllowedCharSet,S)>=0) )
{
if ( (MaxWidth==0) || (Len(TextStr)<MaxWidth) )
{
if ( (bConvertSpaces) && ((S==" ") || (S=="?") || (S=="\\")) )
S = "_";
if ( (AllowedCharSet=="") || ( (bIncludeSign) && ( (S=="-") || (S=="+") ) && (TextStr=="") ) || (InStr(AllowedCharSet,S)>=0) )
{
if ( (MaxWidth==0) || (Len(TextStr)<MaxWidth) )
{
if ( (bConvertSpaces) && ((S==" ") || (S=="?") || (S=="\\")) )
S = "_";
if ( (TextStr=="") || ( CaretPos==Len(TextStr) ) )
{
TextStr = TextStr$S;
CaretPos=Len(TextStr);
}
else
{
Temp = Left(TextStr,CaretPos)$S$Mid(TextStr,CaretPos);
TextStr = Temp;
CaretPos++;
}
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;
}
}
TextChanged();
return true;
}
}
return false;
return false;
}
function SetInputText(string S)
{
switch(TextCase)
{
case TXTC_Upper:
S = Caps(S);
break;
case TXTC_Lower:
S = Locs(S);
break;
}
switch(TextCase)
{
case TXTC_Upper:
S = Caps(S);
break;
case TXTC_Lower:
S = Locs(S);
break;
}
TextStr = S;
TextChanged();
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;
local string Temp;
if( bReadOnly )
{
return false;
}
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;
}
}
if (ProcessControlKey(Key, Event))
{
return false;
}
else if( Key == 'Escape' && Event == IE_Pressed )
{
if( TextStr!="" )
{
SetInputText("");
CaretPos = 0;
return true;
}
else
{
if( ParentComponent != None )
{
ParentComponent.UserPressedEsc();
return true;
}
}
}
else if( Key=='Enter' && Event == IE_Released )
{
if( TextStr!="" )
{
Temp = TextStr;
OnTextFinished(self, Temp);
if( !bNoClearOnEnter )
{
SetInputText("");
CaretPos = 0;
}
}
return true;
}
else if ( Key=='Home' )
{
CaretPos = 0;
return true;
}
else if ( Key=='End' )
{
CaretPos = Len(TextStr);
return true;
}
else if( Event == IE_Pressed || Event == IE_Repeat )
{
if( Key=='Backspace' || Key=='Delete' )
{
if( bAllSelected )
{
SetInputText("");
CaretPos = 0;
}
else if( CaretPos>0 )
{
SetInputText(Left(TextStr,CaretPos-1) $ Right(TextStr, Len(TextStr) - CaretPos));
CaretPos -= 1;
}
return true;
}
else if ( Key=='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;
}
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;
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;
local string Storage,FinalDraw,TmpString;
local int MaskIndex,StorageLength;
local float XL,YL,BoxWidth,FontScale,CursorY,BorderSize;
local FontRenderInfo FRI;
Super.DrawMenu();
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());
}
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);
BorderSize = Owner.CurrentStyle.ScreenScale(4.f);
FRI.bClipText = true;
FRI.bEnableShadow = true;
FRI.bClipText = true;
FRI.bEnableShadow = true;
Storage = TextStr;
Storage = TextStr;
if ( bMaskText && Len(Storage)>0 )
{
StorageLength = Len(Storage);
if ( bMaskText && Len(Storage)>0 )
{
StorageLength = Len(Storage);
Storage = "";
for(MaskIndex=1; MaskIndex <= StorageLength; MaskIndex++ )
{
Storage $= "*";
}
}
Storage = "";
for(MaskIndex=1; MaskIndex <= StorageLength; MaskIndex++ )
{
Storage $= "*";
}
}
Canvas.Font = Owner.CurrentStyle.PickFont(FontScale);
FontScale *= TextScale;
Canvas.Font = Owner.CurrentStyle.PickFont(FontScale);
FontScale *= TextScale;
BoxWidth=CompPos[2]*0.9875;
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);
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);
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;
}
if (bReadOnly)
{
FirstVis = 0;
}
FinalDraw = Mid(Storage, FirstVis, Len(Storage)-FirstVis);
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);
}
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);
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() );
}
}
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);
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();
}
if( Owner.KeyboardFocus != self )
{
GrabKeyFocus();
}
CaretPos = Len(TextStr);
bAllSelected = !bAllSelected;
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
FontColor=(R=255,G=255,B=255,A=255)
MaxWidth=768
TextScale=1
TextCase=TXTC_None
LastCaret=-1
LastLength=-1
YSize=0.06
YSize=0.06
}

126
ScoreboardExt/Classes/KFGUI_EditControl.uc
View File

@ -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);
Canvas.Font = Owner.CurrentStyle.PickFont(TextScale);
TextScale *= FontScale;
TextFont = Canvas.Font;
TextScale *= FontScale;
TextFont = Canvas.Font;
Canvas.TextSize("ABC",XS,TextHeight,TextScale,TextScale);
Canvas.TextSize("ABC",XS,TextHeight,TextScale,TextScale);
UpdateSizes();
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();
}
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;
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);
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
}

124
ScoreboardExt/Classes/KFGUI_FloatingWindow.uc
View File

@ -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();
Super.ShowMenu();
OpenStartTime = GetPlayer().WorldInfo.RealTimeSeconds;
OpenEndTime = GetPlayer().WorldInfo.RealTimeSeconds + OpenAnimSpeed;
OpenStartTime = GetPlayer().WorldInfo.RealTimeSeconds;
OpenEndTime = GetPlayer().WorldInfo.RealTimeSeconds + OpenAnimSpeed;
}
function DrawMenu()
{
local float TempSize;
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( bUseAnimation )
{
TempSize = `TimeSinceEx(GetPlayer(), OpenStartTime);
if ( WindowFadeInTime - TempSize > 0 && FrameOpacity != default.FrameOpacity )
FrameOpacity = (1.f - ((WindowFadeInTime - TempSize) / WindowFadeInTime)) * default.FrameOpacity;
}
Owner.CurrentStyle.RenderFramedWindow(Self);
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.
}
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;
local int i;
if( bDragWindow && HeaderComp!=None ) // Always keep focus on window frame now!
{
MouseArea = HeaderComp;
return true;
}
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;
}
}
for( i=0; i<Components.Length; i++ )
{
if( Components[i].CaptureMouse() )
{
MouseArea = Components[i];
return true;
}
}
MouseArea = None;
MouseArea = None;
return Super(KFGUI_Base).CaptureMouse();
return Super(KFGUI_Base).CaptureMouse();
}
function PreDraw()
{
local float Frac, CenterX, CenterY;
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);
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);
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);
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];
}
}
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();
Super.PreDraw();
}
defaultproperties
{
bUseAnimation=true
OpenAnimSpeed=0.05f
WindowFadeInTime=0.2f
bUseAnimation=true
OpenAnimSpeed=0.05f
WindowFadeInTime=0.2f
}

12
ScoreboardExt/Classes/KFGUI_FloatingWindowHeader.uc
View File

@ -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
}

166
ScoreboardExt/Classes/KFGUI_Frame.uc
View File

@ -8,121 +8,121 @@ var() float FontScale;
function InitMenu()
{
Super(KFGUI_Page).InitMenu();
Super(KFGUI_Page).InitMenu();
}
function DrawMenu()
{
local float TempSize;
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( 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]);
}
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;
local float T,XL,YL,HeaderH;
local FontRenderInfo FRI;
if( FrameTex == None )
{
return;
}
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());
}
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;
if( bDrawHeader && WindowTitle!="" )
{
FRI.bClipText = true;
FRI.bEnableShadow = true;
C.Font = Owner.CurrentStyle.MainFont;
T = Owner.CurrentStyle.ScreenScale(FontScale);
C.Font = Owner.CurrentStyle.MainFont;
T = Owner.CurrentStyle.ScreenScale(FontScale);
C.SetDrawColor(250,250,250,FrameOpacity);
C.TextSize(WindowTitle, XL, YL, T, T);
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));
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);
}
C.DrawText(WindowTitle,,T,T,FRI);
}
}
function PreDraw()
{
local int i;
local byte j;
local float Frac, CenterX, CenterY;
local int i;
local byte j;
local float Frac, CenterX, CenterY;
if( !bVisible )
return;
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);
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);
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);
}
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();
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();
}
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
bUseAnimation=false
bDrawHeader=true
bUseLegacyDrawTile=true
bDrawBackground=true
FontScale=0.35f
FrameOpacity=255
FontScale=0.35f
FrameOpacity=255
HeaderSize(0)=26.f
HeaderSize(1)=8.f
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
}

208
ScoreboardExt/Classes/KFGUI_Image.uc
View File

@ -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;
local float X, Y, XL, YL;
if( Image == None )
return;
if( Image == None )
return;
DrawBackground(Canvas, CompPos[2], CompPos[3]);
DrawBackground(Canvas, CompPos[2], CompPos[3]);
Canvas.DrawColor = ImageColor;
Canvas.DrawColor = ImageColor;
switch (ImageStyle)
{
case ISTY_Normal:
if( X1 != -1 )
X = X1;
else X = 0;
switch (ImageStyle)
{
case ISTY_Normal:
if( X1 != -1 )
X = X1;
else X = 0;
if( Y1 != -1 )
Y = Y1;
else Y = 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( 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( 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());
}
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;
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( 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( 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( 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());
}
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;
}
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
}

278
ScoreboardExt/Classes/KFGUI_List.uc
View File

@ -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;
local int i;
local byte j;
if( !bVisible )
return;
if( !bVisible )
return;
ComputeCoords();
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();
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 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();
}
}
// 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)
}

290
ScoreboardExt/Classes/KFGUI_ListHorz.uc
View File

@ -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;
local int i;
local byte j;
if( !bVisible )
return;
if( !bVisible )
return;
ComputeCoords();
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();
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 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();
}
}
// 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)
}

36
ScoreboardExt/Classes/KFGUI_ListItem.uc
View File

@ -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;
}

176
ScoreboardExt/Classes/KFGUI_MultiComponent.uc
View File

@ -4,144 +4,144 @@ var() export editinline array<KFGUI_Base> Components;
function InitMenu()
{
local int i;
local int i;
for( i=0; i<Components.Length; ++i )
{
Components[i].Owner = Owner;
Components[i].ParentComponent = Self;
Components[i].InitMenu();
}
for( i=0; i<Components.Length; ++i )
{
Components[i].Owner = Owner;
Components[i].ParentComponent = Self;
Components[i].InitMenu();
}
}
function ShowMenu()
{
local int i;
local int i;
for( i=0; i<Components.Length; ++i )
Components[i].ShowMenu();
for( i=0; i<Components.Length; ++i )
Components[i].ShowMenu();
}
function PreDraw()
{
local int i;
local byte j;
local int i;
local byte j;
if( !bVisible )
return;
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();
}
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;
local int i;
for( i=0; i<Components.Length; ++i )
Components[i].InventoryChanged(Wep,bRemove);
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;
local int i;
for( i=0; i<Components.Length; ++i )
Components[i].CloseMenu();
for( i=0; i<Components.Length; ++i )
Components[i].CloseMenu();
}
function bool CaptureMouse()
{
local int i;
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.
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;
local int i;
for( i=Components.Length - 1; i>=0; i-- )
{
if( Components[i].ReceievedControllerInput(ControllerId, Key, Event) )
{
return true;
}
}
for( i=Components.Length - 1; i>=0; i-- )
{
if( Components[i].ReceievedControllerInput(ControllerId, Key, Event) )
{
return true;
}
}
return Super.ReceievedControllerInput(ControllerId, Key, Event);
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;
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);
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;
local int i;
for( i=0; i<Components.Length; ++i )
Components[i].NotifyLevelChange();
for( i=0; i<Components.Length; ++i )
Components[i].NotifyLevelChange();
}

24
ScoreboardExt/Classes/KFGUI_Page.uc
View File

@ -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
}

160
ScoreboardExt/Classes/KFGUI_ProgressBar.uc
View File

@ -23,112 +23,112 @@ var byte BorderSize;
function DrawMenu()
{
local float Left, Top, Width, Height;
local float W, Sc;
local string S;
local float Left, Top, Width, Height;
local float W, Sc;
local string S;
Super.DrawMenu();
Super.DrawMenu();
Left = 0.f;
Top = 0.f;
Width = CompPos[2];
Height = CompPos[3];
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);
// Select the right font in the Canvas
Canvas.Font = Owner.CurrentStyle.PickFont(Sc);
if (CaptionWidth > 0.0 && Width > 0 && Len(Caption) > 0)
{
W = CaptionWidth;
if (CaptionWidth > 0.0 && Width > 0 && Len(Caption) > 0)
{
W = CaptionWidth;
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;
}
// Draw the label
Owner.CurrentStyle.DrawTextJustified(CaptionAlign, Left, Top, Left + W, Top + Height, Caption, Sc, Sc);
Left += W;
Width -= W;
}
if ( (bShowHigh || bShowValue) && ValueRightWidth > 0.0 && Width > 0.0)
{
W = ValueRightWidth;
if ( (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;
}
if( bShowValue && bShowHigh )
{
S = int(Value)$"/"$int(High);
}
else if (bShowValue)
{
S = string(int(Value));
}
else
{
S = string(int(High));
}
if( bShowValue && bShowHigh )
{
S = int(Value)$"/"$int(High);
}
else if (bShowValue)
{
S = string(int(Value));
}
else
{
S = string(int(High));
}
Owner.CurrentStyle.DrawTextJustified(ValueRightAlign, Left + Width - W, Top, Left + Width, Top + Height, S, Sc, Sc);
Owner.CurrentStyle.DrawTextJustified(ValueRightAlign, Left + Width - W, Top, Left + Width, Top + Height, S, Sc, Sc);
Width -= W;
}
Width -= W;
}
if (Width > GraphicMargin)
{
Width -= GraphicMargin;
Left += GraphicMargin / 2;
}
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);
}
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));
}
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
}

198
ScoreboardExt/Classes/KFGUI_RightClickMenu.uc
View File

@ -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;
local float XS,YS,XL,YL,Scalar;
local int i;
local string S;
if( OldSizeX == Owner.ScreenSize.X )
return;
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;
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);
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;
XS = FMax(XS,XL);
YS += YL;
}
}
XSize = (XS+(EdgeSize*12)) / Owner.ScreenSize.X;
YSize = (YS+(EdgeSize*4)) / Owner.ScreenSize.Y;
ComputePosition();
ComputePosition();
OldSizeX = Owner.ScreenSize.X;
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;
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;
}
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);
Owner.CurrentStyle.RenderRightClickMenu(Self);
if( bDrawToolTip )
{
if( OldRow != CurrentRow )
bDrawToolTip = false;
DrawToolTip();
}
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;
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));
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);
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;
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;
}
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));
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);
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);
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)
}

126
ScoreboardExt/Classes/KFGUI_ScrollBarBase.uc
View File

@ -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( 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( 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
}

2
ScoreboardExt/Classes/KFGUI_ScrollBarH.uc
View File

@ -2,5 +2,5 @@ Class KFGUI_ScrollBarH extends KFGUI_ScrollBarBase;
defaultproperties
{
bVertical=false
bVertical=false
}

2
ScoreboardExt/Classes/KFGUI_ScrollBarV.uc
View File

@ -2,5 +2,5 @@ Class KFGUI_ScrollBarV extends KFGUI_ScrollBarBase;
defaultproperties
{
bVertical=true
bVertical=true
}

32
ScoreboardExt/Classes/KFGUI_Slider.uc
View File

@ -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)
}

222
ScoreboardExt/Classes/KFGUI_SwitchMenuBar.uc
View File

@ -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;
local KFGUI_Base P;
local KFGUI_Button B;
// Add page.
P = new (Self) PageClass;
P.Owner = Owner;
P.ParentComponent = Self;
SubPages.AddItem(P);
// Add page.
P = new (Self) PageClass;
P.Owner = Owner;
P.ParentComponent = Self;
SubPages.AddItem(P);
// Add page switch button.
B = new (Self) class'KFGUI_Button';
B.ButtonText = Caption;
B.ToolTip = Hint;
B.OnClickLeft = PageSwitched;
B.OnClickRight = PageSwitched;
B.IDValue = NumButtons;
// Add page switch button.
B = new (Self) class'KFGUI_Button';
B.ButtonText = Caption;
B.ToolTip = Hint;
B.OnClickLeft = PageSwitched;
B.OnClickRight = PageSwitched;
B.IDValue = NumButtons;
if( ButtonPosition<2 )
{
B.XPosition = NumButtons*ButtonAxisSize;
B.XSize = ButtonAxisSize*0.99;
if( ButtonPosition<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( 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;
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;
}
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;
++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);
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]);
}
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;
local int i;
local byte j;
if( !bVisible )
return;
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();
}
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;
}
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;
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
}

704
ScoreboardExt/Classes/KFGUI_TextField.uc
View File

@ -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;
var string S;
var ETextFieldStyles TextType;
var Color C;
var float X;
structdefaultproperties
{
TextType=TEXT_FIELD_NONE
}
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;
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;
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;
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;
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.
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;
local byte n;
n = (HexToInt(Asc(Left(S,1)))<<4) | HexToInt(Asc(Right(S,1)));
S = Mid(S,2);
return 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;
if( Canvas == None )
return;
OldSize[0] = CompPos[2];
OldSize[1] = CompPos[3];
if( !bTextParsed )
{
ParseTextLines();
bTextParsed = true;
}
else Lines = OrgLines;
OldSize[0] = CompPos[2];
OldSize[1] = CompPos[3];
if( !bTextParsed )
{
ParseTextLines();
bTextParsed = true;
}
else Lines = OrgLines;
InitFont = Owner.CurrentStyle.PickFont(InitFontScale);
InitFontScale *= FontScale;
InitFont = Owner.CurrentStyle.PickFont(InitFontScale);
InitFontScale *= FontScale;
// Compute Y-offsets of each line.
Canvas.Font = InitFont;
Canvas.TextSize("ABC",XS,TextHeight,InitFontScale,InitFontScale);
// Compute Y-offsets of each line.
Canvas.Font = InitFont;
Canvas.TextSize("ABC",XS,TextHeight,InitFontScale,InitFontScale);
ParseLines(CompPos[2] / InitFontScale);
MaxHeight = (Lines.Length * TextHeight);
bShowScrollbar = (MaxHeight>=CompPos[3]);
bClickable = bShowScrollbar;
bCanFocus = bShowScrollbar;
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);
}
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];
// 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();
ScrollBar.ComputeCoords();
// Recompute line sizes because we now have a scrollbar.
Lines = OrgLines;
ParseLines((CompPos[2]-ScrollWidth) / InitFontScale);
// 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);
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);
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);
if( (X+XS)>ClipX )
{
z = FindSplitPoint(Lines[i].Text[j].S,X,ClipX);
// Add new line.
Lines.Insert(i+1,1);
// 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]);
// 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);
// 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);
// 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);
// 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;
}
}
// 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;
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;
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();
// 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)));
}
}
if( MaxHistory != 0 )
{
if( Lines.Length >= MaxHistory )
{
Index = InStr(Text, LineSplitter);
if( Index == INDEX_NONE )
Lines.Remove(0, 1);
else SetText(Mid(Text, Index+Len(LineSplitter)));
}
}
Canvas.Font = InitFont;
Canvas.Font = InitFont;
if( bShowScrollbar )
{
Canvas.SetClip(CompPos[0]+(CompPos[2]-ScrollWidth),CompPos[1]+CompPos[3]);
i = ScrollBar.GetValue();
}
else i = 0;
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;
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);
}
}
}
}
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;
local float TempSize;
local int FadeAlpha;
local Color MainColor;
MainColor = C;
if( MainColor.A==0 )
MainColor = TextColor;
MainColor = C;
if( MainColor.A==0 )
MainColor = TextColor;
Canvas.DrawColor = GetColorFromStyle(MainColor, TextStyle);
Canvas.DrawColor = GetColorFromStyle(MainColor, TextStyle);
if( bFadeInOut )
{
TempSize = `TimeSinceEx(GetPlayer(), FadeStartTime);
if ( TempSize > MessageDisplayTime )
{
return;
}
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;
}
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;
}
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);
}
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;
local float ColorHUE,Value;
local HSVColour HSV;
if( TextStyle == TEXT_FIELD_HSV )
{
ColorHUE = Abs(Sin(GetPlayer().WorldInfo.TimeSeconds * 0.9) * 335);
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;
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));
}
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 class'KFColorHelper'.static.LinearColorToColor(class'KFColorHelper'.static.HSVToRGB(HSV));
}
return MainColor;
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);
Super.SetVisibility(Visible);
if( ScrollBar != None )
{
ScrollBar.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
}

160
ScoreboardExt/Classes/KFGUI_TextLable.uc
View File

@ -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;
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;
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;
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;
}
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
}

258
ScoreboardExt/Classes/KFGUI_TextScroll.uc
View File

@ -9,177 +9,177 @@ var transient int MaxIndex, RowsDropped;
function SetText( string S )
{
Super.SetText(S);
Super.SetText(S);
MaxIndex = 0;
RowsCompleted.Length = 0;
RowsDropped = 0;
MaxIndex = 0;
RowsCompleted.Length = 0;
RowsDropped = 0;
bScrollCompleted = false;
bTextDirty = true;
CharStartTime = GetPlayer().WorldInfo.TimeSeconds;
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( bScrollCompleted )
{
Super.DrawMenu();
return;
}
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.Font = InitFont;
if( bShowScrollbar )
{
Canvas.SetClip(CompPos[0]+(CompPos[2]-ScrollWidth),CompPos[1]+CompPos[3]);
i = ScrollBar.GetValue();
}
else i = 0;
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( 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;
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);
//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);
return;
}
else if( MaxIndex != 0 && RowsCompleted[MaxIndex] )
{
MaxIndex = 0;
ScrollBar.AddValue(1);
RowsDropped++;
RowsDropped++;
i = ScrollBar.GetValue();
}
}
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;
}
}
}
}
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;
}
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;
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;
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);
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;
CurrentIndex = 0;
for( k=0; k<=SLen; ++k )
{
CharTime += ScrollSpeed;
Canvas.TextSize(Mid(MainString, 0, k), XL, YL, InitFontScale, InitFontScale);
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());
}
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;
}
continue;
}
Canvas.DrawColor = GetColorFromStyle(MainTextColor, TextStyle);
Canvas.SetPos(MainX+XL,MainY);
Canvas.DrawText(Mid(MainString, k, 1),,InitFontScale,InitFontScale,TextFontInfo);
Canvas.DrawColor = GetColorFromStyle(MainTextColor, TextStyle);
Canvas.SetPos(MainX+XL,MainY);
Canvas.DrawText(Mid(MainString, k, 1),,InitFontScale,InitFontScale,TextFontInfo);
CurrentIndex = k+1;
CurrentIndex = k+1;
if( k >= SLen )
{
RowsCompleted[i] = true;
}
}
}
}
}
}
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( bScrollCompleted )
return;
if( ScrollBar != None )
ScrollBar.bDisabled = false;
if( ScrollBar != None )
ScrollBar.bDisabled = false;
bScrollCompleted = true;
bScrollCompleted = true;
//Temp fix! The last line in the string seems to be skipped
AddText(LineSplitter);
//Temp fix! The last line in the string seems to be skipped
AddText(LineSplitter);
}
defaultproperties
{
ScrollSpeed=0.01
ScrollSpeed=0.01
}

22
ScoreboardExt/Classes/KFGUI_Tooltip.uc
View File

@ -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;
if( !bVisible )
return;
Owner.CurrentStyle.RenderToolTip(Self);
Owner.CurrentStyle.RenderToolTip(Self);
}
defaultproperties
{
TextFontInfo=(bClipText=true,bEnableShadow=true)
bCanFocus=false
bFocusedPostDrawItem=true
TextFontInfo=(bClipText=true,bEnableShadow=true)
bCanFocus=false
bFocusedPostDrawItem=true
}

689
ScoreboardExt/Classes/KFScoreBoard.uc
View File

@ -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,255 +18,280 @@ 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;
local Texture2D Avatar;
if( KFPRI.Avatar == None || KFPRI.Avatar == default.DefaultAvatar )
{
Avatar = FindAvatar(PC, KFPRI.UniqueId);
if( Avatar == None )
Avatar = default.DefaultAvatar;
if( KFPRI.Avatar == None || KFPRI.Avatar == default.DefaultAvatar )
{
Avatar = FindAvatar(PC, KFPRI.UniqueId);
if( Avatar == None )
Avatar = default.DefaultAvatar;
KFPRI.Avatar = Avatar;
}
KFPRI.Avatar = Avatar;
}
}
delegate bool InOrder( KFPlayerReplicationInfo P1, KFPlayerReplicationInfo P2 )
{
if( P1 == None || P2 == None )
return true;
if( P1 == None || P2 == None )
return true;
if( P1.GetTeamNum() < P2.GetTeamNum() )
return false;
if( P1.GetTeamNum() < P2.GetTeamNum() )
return false;
if( P1.Kills == P2.Kills )
{
if( P1.Assists == P2.Assists )
return true;
if( P1.Kills == P2.Kills )
{
if( P1.Assists == P2.Assists )
return true;
return P1.Assists < P2.Assists;
}
return P1.Assists < P2.Assists;
}
return P1.Kills < P2.Kills;
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;
}
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;
// 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;
}
}
}
}
for( i=(KFGRI.PRIArray.Length-1); i>0; --i )
{
for( j=i-1; j>=0; --j )
{
if( !InOrder(KFPlayerReplicationInfo(KFGRI.PRIArray[i]),KFPlayerReplicationInfo(KFGRI.PRIArray[j])) )
{
PRI = KFGRI.PRIArray[i];
KFGRI.PRIArray[i] = KFGRI.PRIArray[j];
KFGRI.PRIArray[j] = PRI;
}
}
}
}
// Check players.
PlayerIndex = -1;
NumPlayer = 0;
for( i=(KFGRI.PRIArray.Length-1); i>=0; --i )
{
KFPRI = KFPlayerReplicationInfo(KFGRI.PRIArray[i]);
if( KFPRI==None )
continue;
if( KFPRI.bOnlySpectator )
{
++NumSpec;
continue;
}
if( KFPRI.PlayerHealth>0 && KFPRI.PlayerHealthPercent>0 && KFPRI.GetTeamNum()==0 )
++NumAlivePlayer;
++NumPlayer;
}
// 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;
}
}
KFPRIArray.Length = NumPlayer;
j = KFPRIArray.Length;
for( i=(KFGRI.PRIArray.Length-1); i>=0; --i )
{
KFPRI = KFPlayerReplicationInfo(KFGRI.PRIArray[i]);
if( KFPRI!=None && !KFPRI.bOnlySpectator )
{
KFPRIArray[--j] = KFPRI;
if( KFPRI==PC.PlayerReplicationInfo )
PlayerIndex = j;
}
}
// Header font info.
Canvas.Font = Owner.CurrentStyle.PickFont(FontScalar);
YL = Owner.CurrentStyle.DefaultHeight;
DefFontHeight = YL;
// Header font info.
Canvas.Font = Owner.CurrentStyle.PickFont(FontScalar);
YL = Owner.CurrentStyle.DefaultHeight;
DefFontHeight = YL;
XPosCenter = (Canvas.ClipX * 0.5);
XPosCenter = (Canvas.ClipX * 0.5);
// Server Name
// Server Name
XPos = XPosCenter;
YPos += DefFontHeight;
XPos = XPosCenter;
YPos += DefFontHeight;
S = KFGRI.ServerName;
Canvas.TextSize(S, XL, YL, FontScalar, FontScalar);
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);
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);
Owner.CurrentStyle.DrawTextShadow(S, BoxX + ((BoxW-XL) * 0.5f), YPos + ((DefFontHeight-YL) * 0.5f), 1, FontScalar);
// Deficulty | Wave | MapName
// Deficulty | Wave | MapName
XPos = XPosCenter;
YPos += DefFontHeight+Owner.HUDOwner.ScaledBorderSize;
XPos = XPosCenter;
YPos += DefFontHeight+Owner.HUDOwner.ScaledBorderSize;
S = Class'KFCommon_LocalizedStrings'.Static.GetDifficultyString (KFGRI.GameDifficulty) $" | "$class'KFGFxHUD_ScoreboardMapInfoContainer'.default.WaveString@KFGRI.WaveNum $" | " $class'KFCommon_LocalizedStrings'.static.GetFriendlyMapName(PC.WorldInfo.GetMapName(true));
Canvas.TextSize(S, XL, YL, FontScalar, FontScalar);
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);
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);
Owner.CurrentStyle.DrawTextShadow(S, BoxX + ((BoxW-XL) * 0.5f), YPos + ((DefFontHeight-YL) * 0.5f), 1, FontScalar);
// Players | Spectators | Alive | Time
// Players | Spectators | Alive | Time
XPos = XPosCenter;
YPos += DefFontHeight+Owner.HUDOwner.ScaledBorderSize;
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);
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);
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);
Owner.CurrentStyle.DrawTextShadow(S, BoxX + ((BoxW-XL) * 0.5f), YPos + ((DefFontHeight-YL) * 0.5f), 1, FontScalar);
Width = Canvas.ClipX * 0.625;
Width = Canvas.ClipX * 0.625;
XPos = (Canvas.ClipX - Width) * 0.5;
YPos += DefFontHeight * 2.0;
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 (10, 10, 10, 200);
Owner.CurrentStyle.DrawRectBox(XPos, YPos, Width, DefFontHeight, 4);
Canvas.SetDrawColor(250, 250, 250, 255);
Canvas.SetDrawColor(250, 250, 250, 255);
// Calc X offsets
PerkXPos = Width * 0.01;
PlayerXPos = Width * 0.2;
KillsXPos = Width * 0.5;
AssistXPos = Width * 0.6;
CashXPos = Width * 0.7;
StateXPos = Width * 0.8;
PingXPos = Width * 0.92;
// 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;
// Header texts
Canvas.SetPos (XPos + PerkXPos, YPos);
Canvas.DrawText (class'KFGFxMenu_Inventory'.default.PerkFilterString, , FontScalar, FontScalar);
StatusWBox = PlayerXPos - StatusXPos;
PlayerWBox = PerkXPos - PlayerXPos;
PerkWBox = CashXPos - PerkXPos;
CashWBox = KillsXPos - CashXPos;
KillsWBox = AssistXPos - KillsXPos;
AssistWBox = HealthXPos - AssistXPos;
HealthWBox = PingXPos - HealthXPos;
PingWBox = Width - PingXPos;
Canvas.SetPos (XPos + KillsXPos, YPos);
Canvas.DrawText (class'KFGFxHUD_ScoreboardWidget'.default.KillsString, , FontScalar, FontScalar);
// 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);
Canvas.SetPos (XPos + AssistXPos, YPos);
Canvas.DrawText (class'KFGFxHUD_ScoreboardWidget'.default.AssistsString, , FontScalar, FontScalar);
PlayersList.XPosition = ((Canvas.ClipX - Width) * 0.5) / InputPos[2];
PlayersList.YPosition = (YPos + (YL + 4)) / InputPos[3];
PlayersList.YSize = (1.f - PlayersList.YPosition) - 0.15;
Canvas.SetPos (XPos + CashXPos, YPos);
Canvas.DrawText (class'KFGFxHUD_ScoreboardWidget'.default.DoshString, , FontScalar, FontScalar);
PlayersList.ChangeListSize(KFPRIArray.Length);
}
Canvas.SetPos (XPos + StateXPos, YPos);
Canvas.DrawText ("STATE", , FontScalar, FontScalar);
function DrawTextWCenter(string Str, float XPos, float YPos, float BoxWidth, float FontScalar)
{
local float TextWidth;
local float TextHeight;
Canvas.SetPos (XPos + PlayerXPos, YPos);
Canvas.DrawText (class'KFGFxHUD_ScoreboardWidget'.default.PlayerString, , FontScalar, FontScalar);
Canvas.TextSize(Str, TextWidth, TextHeight, FontScalar, FontScalar);
Canvas.SetPos (XPos + PingXPos, YPos);
Canvas.DrawText (class'KFGFxHUD_ScoreboardWidget'.default.PingString, , FontScalar, FontScalar);
Canvas.SetPos(XPos + (BoxWidth - TextWidth)/2 , YPos);
Canvas.DrawText(Str, , FontScalar, FontScalar);
}
PlayersList.XPosition = ((Canvas.ClipX - Width) * 0.5) / InputPos[2];
PlayersList.YPosition = (YPos + (YL + 4)) / InputPos[3];
PlayersList.YSize = (1.f - PlayersList.YPosition) - 0.15;
PlayersList.ChangeListSize(KFPRIArray.Length);
function 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;
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];
YOffset *= 1.05;
KFPRI = KFPRIArray[Index];
if( KFGRI.bVersusGame )
bIsZED = KFTeamInfo_Zeds(KFPRI.Team) != None;
if( KFGRI.bVersusGame )
bIsZED = KFTeamInfo_Zeds(KFPRI.Team) != None;
C.Font = Owner.CurrentStyle.PickFont(FontScalar);
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);
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);
Owner.CurrentStyle.DrawRectBox(0.f, YOffset, Width, Height, 4);
C.SetDrawColor(250,250,250,255);
C.SetDrawColor(250,250,250,255);
// 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');
// Status
if (KFPRI.bAdmin)
{
S = "Admin";
}
else
{
S = "Player";
}
DrawTextWLeft(S, StatusXPos, TextYOffset, FontScalar);
S = "ZED";
C.SetPos (PerkXPos + Height, TextYOffset);
C.DrawText (S, , FontScalar, FontScalar);
}
else
{
if( KFPRI.CurrentPerkClass!=None )
{
// 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();
@ -274,7 +300,7 @@ function DrawPlayerEntry( Canvas C, int Index, float YOffset, float Height, floa
PerkIconSize = Height-(Owner.HUDOwner.ScaledBorderSize * 4);
PrestigeIconScale = 0.6625f;
C.DrawColor = HUDOwner.WhiteColor;
C.DrawColor = HUDOwner.WhiteColor;
if (PrestigeLevel > 0)
{
C.SetPos(PerkIconPosX, PerkIconPosY);
@ -290,202 +316,193 @@ function DrawPlayerEntry( Canvas C, int Index, float YOffset, float Height, floa
}
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);
}
}
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);
}
}
// Avatar
if( KFPRI.Avatar != None )
{
if( KFPRI.Avatar == default.DefaultAvatar )
CheckAvatar(KFPRI, OwnerPC);
// 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);
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);
// Player
C.SetPos (PlayerXPos, TextYOffset);
// Player
if( Len(KFPRI.PlayerName) > 25 )
S = Left(KFPRI.PlayerName, 25);
else S = KFPRI.PlayerName;
DrawTextWLeft(S, PlayerXPos, TextYOffset, FontScalar);
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);
C.SetDrawColor(255,255,255,255);
// Kill
DrawTextWCenter(string (KFPRI.Kills), KillsXPos, TextYOffset, KillsWBox, FontScalar);
// Kill
C.SetPos (KillsXPos, TextYOffset);
C.DrawText (string (KFPRI.Kills), , FontScalar, FontScalar);
// Assist
DrawTextWCenter(string (KFPRI.Assists), AssistXPos, TextYOffset, AssistWBox, FontScalar);
// Assist
C.SetPos (AssistXPos, TextYOffset);
C.DrawText (string (KFPRI.Assists), , FontScalar, FontScalar);
// 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);
// 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);
// 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);
// 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";
}
DrawTextWCenter(S, HealthXPos, TextYOffset, HealthWBox, FontScalar);
S = string (KFPRI.PlayerHealth) @"HP";
}
C.SetDrawColor(250,250,250,255);
C.SetPos (StateXPos, TextYOffset);
C.DrawText (S, , FontScalar, FontScalar);
// Ping
if (KFPRI.bBot)
S = "-";
else
{
Ping = int(KFPRI.Ping * `PING_SCALE);
C.SetDrawColor(250,250,250,255);
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);
// Ping
if (KFPRI.bBot)
S = "-";
else
{
Ping = int(KFPRI.Ping * `PING_SCALE);
S = string(Ping);
}
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);
C.TextSize(MaxPing, XL, YL, FontScalar, FontScalar);
S = string(Ping);
}
DrawTextWLeft(S, PingXPos, TextYOffset, FontScalar);
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));
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;
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;
PingMul = 1.f - FClamp(FMax(Ping - IdealPing, 1.f) / MaxPing, 0.f, 1.f);
BarW = W / PingBars;
BaseH = H / PingBars;
PingColor.R = (1.f - PingMul) * 255;
PingColor.G = PingMul * 255;
PingColor.R = (1.f - PingMul) * 255;
PingColor.G = PingMul * 255;
for(i=1; i<PingBars; i++)
{
BarH = BaseH * i;
XPos = XOffset + ((i - 1) * BarW);
YPos = YOffset + (H - BarH);
for(i=1; i<PingBars; i++)
{
BarH = BaseH * i;
XPos = XOffset + ((i - 1) * BarW);
YPos = YOffset + (H - BarH);
C.SetPos(XPos,YPos);
C.SetDrawColor(20, 20, 20, 255);
Owner.CurrentStyle.DrawWhiteBox(BarW,BarH);
C.SetPos(XPos,YPos);
C.SetDrawColor(20, 20, 20, 255);
Owner.CurrentStyle.DrawWhiteBox(BarW,BarH);
if( PingMul >= (i / PingBars) )
{
C.SetPos(XPos,YPos);
C.DrawColor = PingColor;
Owner.CurrentStyle.DrawWhiteBox(BarW,BarH);
}
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);
}
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;
local string S;
S = PC.GetSteamAvatar(ClientID);
if( S=="" )
return None;
return Texture2D(PC.FindObject(S,class'Texture2D'));
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
bEnableInputs=true
PingColor=(R=255,G=255,B=60,A=255)
IdealPing=50.0
MaxPing=200.0
PingBars=5.0
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)
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'
DefaultAvatar=Texture2D'UI_HUD.ScoreBoard_Standard_SWF_I26'
}

104
ScoreboardExt/Classes/ScoreboardExtHUD.uc
View File

@ -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();
Super.PostBeginPlay();
PlayerOwner.PlayerInput.OnReceivedNativeInputKey = NotifyInputKey;
PlayerOwner.PlayerInput.OnReceivedNativeInputAxis = NotifyInputAxis;
PlayerOwner.PlayerInput.OnReceivedNativeInputChar = NotifyInputChar;
PlayerOwner.PlayerInput.OnReceivedNativeInputKey = NotifyInputKey;
PlayerOwner.PlayerInput.OnReceivedNativeInputAxis = NotifyInputAxis;
PlayerOwner.PlayerInput.OnReceivedNativeInputChar = NotifyInputChar;
RemoveMovies();
CreateHUDMovie();
RemoveMovies();
CreateHUDMovie();
}
function PostRender()
{
if( KFGRI == None )
KFGRI = KFGameReplicationInfo(WorldInfo.GRI);
if( KFGRI == None )
KFGRI = KFGameReplicationInfo(WorldInfo.GRI);
if( GUIController!=None && PlayerOwner.PlayerInput==None )
GUIController.NotifyLevelChange();
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==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( !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;
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;
}
for( i=(HUDWidgets.Length-1); i>=0; --i )
{
if( HUDWidgets[i].bVisible && HUDWidgets[i].NotifyInputKey(ControllerId, Key, Event, AmountDepressed, bGamepad) )
return true;
}
return false;
return false;
}
function bool NotifyInputAxis(int ControllerId, name Key, float Delta, float DeltaTime, optional bool bGamepad)
{
local int i;
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;
}
for( i=(HUDWidgets.Length-1); i>=0; --i )
{
if( HUDWidgets[i].bVisible && HUDWidgets[i].NotifyInputAxis(ControllerId, Key, Delta, DeltaTime, bGamepad) )
return true;
}
return false;
return false;
}
function bool NotifyInputChar(int ControllerId, string Unicode)
{
local int i;
local int i;
for( i=(HUDWidgets.Length-1); i>=0; --i )
{
if( HUDWidgets[i].bVisible && HUDWidgets[i].NotifyInputChar(ControllerId, Unicode) )
return true;
}
for( i=(HUDWidgets.Length-1); i>=0; --i )
{
if( HUDWidgets[i].bVisible && HUDWidgets[i].NotifyInputChar(ControllerId, Unicode) )
return true;
}
return false;
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'
}

4
ScoreboardExt/Classes/ScoreboardExtMut.uc
View File

@ -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