Parsed on add and display
-------------------------
............
Parsed only on display
----------------------
>
<
&
Planned improvements
--------------------
item 1
item 2...
...
Bugs
----
The parsing is pretty slack!
*/
// default styles
var Color TextColor;
var Color BGColor;
var Color LinkColor;
var Color ALinkColor;
var float LastBlinkTime;
var bool bShowBlink;
var bool bReleased;
function SetHTML(string HTML)
{
Clear();
ReplaceText(HTML, Chr(13)$Chr(10), " ");
ReplaceText(HTML, Chr(13), " ");
ReplaceText(HTML, Chr(10), " ");
AddText(HTML);
}
function BeforePaint(Canvas C, float X, float Y)
{
Super.BeforePaint(C, X, Y);
Cursor = Root.NormalCursor;
}
function Paint(Canvas C, float X, float Y)
{
C.DrawColor = BGColor;
DrawStretchedTexture(C, 0, 0, WinWidth, WinHeight, Texture'WhiteTexture');
Super.Paint(C, X, Y);
bReleased = False;
}
function Click(float X, float Y)
{
Super.Click(X, Y);
bReleased = True;
}
function ProcessURL(string URL)
{
Log("Clicked Link: >>"$URL$"<<");
if( Left(URL, 7) ~= "mailto:" )
GetPlayerOwner().ConsoleCommand("start "$URL);
if( Left(URL, 7) ~= "http://" )
GetPlayerOwner().ConsoleCommand("start "$URL);
if( Left(URL, 6) ~= "ftp://" )
GetPlayerOwner().ConsoleCommand("start "$URL);
if( Left(URL, 9) ~= "telnet://" )
GetPlayerOwner().ConsoleCommand("start "$URL);
if( Left(URL, 9) ~= "gopher://" )
GetPlayerOwner().ConsoleCommand("start "$URL);
if( Left(URL, 4) ~= "www." )
GetPlayerOwner().ConsoleCommand("start http://"$URL);
if( Left(URL, 4) ~= "ftp." )
GetPlayerOwner().ConsoleCommand("start ftp://"$URL);
else
if( Left(URL, 9) ~= "unreal://" )
LaunchUnrealURL(URL);
}
function OverURL(string URL)
{
}
function LaunchUnrealURL(string URL)
{
GetPlayerOwner().ClientTravel(URL, TRAVEL_Absolute, false);
}
function TextAreaTextSize(Canvas C, string Text, out float W, out float H)
{
ReplaceText(Text, " ", " ");
ReplaceText(Text, ">", ">");
ReplaceText(Text, "<", "<");
ReplaceText(Text, "&", "&");
TextSize(C, Text, W, H);
}
function TextAreaClipText(Canvas C, float DrawX, float DrawY, coerce string Text, optional bool bCheckHotkey)
{
ReplaceText(Text, " ", " ");
ReplaceText(Text, ">", ">");
ReplaceText(Text, "<", "<");
ReplaceText(Text, "&", "&");
ClipText(C, DrawX, DrawY, Text, bCheckHotKey);
}
///////////////////////////////////////////////////////
// Overloaded functions from UWindowDynamicTextArea
///////////////////////////////////////////////////////
function WrapRow(Canvas C, UWindowDynamicTextRow L)
{
local HTMLStyle CurrentStyle;
local UWindowHTMLTextRow R;
local string Input, LeftText, HTML, RightText;
Super.WrapRow(C, L);
// Generate the DisplayString and StyleString lines for each row
R = UWindowHTMLTextRow(L);
while(R != None && (R == L || R.WrapParent == L))
{
R.DisplayString = "";
R.StyleString = "";
CurrentStyle = R.StartStyle;
Input = R.Text;
while(Input != "")
{
ParseHTML(Input, LeftText, HTML, RightText);
if(LeftText != "" || R.DisplayString == "")
{
R.DisplayString = R.DisplayString $ LeftText;
R.StyleString = R.StyleString $ WriteStyleText(CurrentStyle, Len(LeftText));
}
ProcessInlineHTML(HTML, CurrentStyle);
SetCanvasStyle(C, CurrentStyle);
Input = RightText;
}
R = UWindowHTMLTextRow(R.Next);
}
}
function float DrawTextLine(Canvas C, UWindowDynamicTextRow L, float Y)
{
local float X, W, H, MouseX, MouseY;
local HTMLStyle CurrentStyle;
local float RowHeight;
local Color OldColor;
local int StylePos, DisplayPos, i;
local string S;
RowHeight = 0;
CurrentStyle = UWindowHTMLTextRow(L).StartStyle;
if(CurrentStyle.bCenter)
{
W = CalcHTMLTextWidth(C, L.Text, CurrentStyle);
if(VertSB.bWindowVisible)
X = int(((WinWidth - VertSB.WinWidth) - W) / 2);
else
X = int((WinWidth - W) / 2);
}
else
X = 2;
if(GetEntryLevel().TimeSeconds > LastBlinkTime + 0.5)
{
bShowBlink = !bShowBlink;
LastBlinkTime = GetEntryLevel().TimeSeconds;
}
if(UWindowHTMLTextRow(L).DisplayString == "")
SetCanvasStyle(C, CurrentStyle);
else
{
while(DisplayPos < Len(UWindowHTMLTextRow(L).DisplayString))
{
i = ReadStyleText(UWindowHTMLTextRow(L).StyleString, StylePos, CurrentStyle);
S = Mid(UWindowHTMLTextRow(L).DisplayString, DisplayPos, i);
DisplayPos += i;
SetCanvasStyle(C, CurrentStyle);
TextAreaTextSize(C, S, W, H);
if(H > RowHeight)
RowHeight = H;
if(CurrentStyle.bLink)
{
GetMouseXY(MouseX, MouseY);
if(X < MouseX && X + W > MouseX && Y < MouseY && Y + H > MouseY)
{
Cursor = Root.HandCursor;
OverURL(CurrentStyle.LinkDestination);
if(bMouseDown || bReleased)
{
if(bReleased)
{
ProcessURL(CurrentStyle.LinkDestination);
bReleased = False;
}
else
C.DrawColor = ALinkColor;
}
}
}
if(CurrentStyle.BGColor != BGColor)
{
OldColor = C.DrawColor;
C.DrawColor = CurrentStyle.BGColor;
DrawStretchedTexture(C, X, Y, W, H, Texture'WhiteTexture');
C.DrawColor = OldColor;
}
if(!CurrentStyle.bBlink || bShowBlink)
TextAreaClipText(C, X, Y, S);
if(CurrentStyle.bLink || CurrentStyle.bUnderline)
DrawStretchedTexture(C, X, Y+H-1, W, 1, Texture'WhiteTexture');
X += W;
}
}
if(RowHeight == 0)
TextAreaTextSize(C, "A", W, RowHeight);
return RowHeight;
}
function UWindowDynamicTextRow SplitRowAt(UWindowDynamicTextRow L, int SplitPos)
{
local UWindowDynamicTextRow N;
local HTMLStyle CurrentStyle;
N = Super.SplitRowAt(L, SplitPos);
// update the style by processing from the start of L to the split position.
UWindowHTMLTextRow(N).EndStyle = UWindowHTMLTextRow(L).EndStyle;
CurrentStyle = UWindowHTMLTextRow(L).StartStyle;
HTMLUpdateStyle(L.Text, CurrentStyle);
UWindowHTMLTextRow(L).EndStyle = CurrentStyle;
UWindowHTMLTextRow(N).StartStyle = CurrentStyle;
return N;
}
function RemoveWrap(UWindowDynamicTextRow L)
{
local UWindowDynamicTextRow N;
// copy final endstyle to current row
N = UWindowDynamicTextRow(L.Next);
while(N != None && N.WrapParent == L)
{
UWindowHTMLTextRow(L).EndStyle = UWindowHTMLTextRow(N).EndStyle;
N = UWindowDynamicTextRow(N.Next);
}
Super.RemoveWrap(L);
}
function int GetWrapPos(Canvas C, UWindowDynamicTextRow L, float MaxWidth)
{
local float W, LineWidth, NextWordWidth;
local string Input, NextWord;
local int WordsThisRow, WrapPos;
local HTMLStyle CurrentStyle;
CurrentStyle = UWindowHTMLTextRow(L).StartStyle;
// quick check
if(CalcHTMLTextWidth(C, L.Text, CurrentStyle) <= MaxWidth)
return -1;
Input = L.Text;
WordsThisRow = 0;
LineWidth = 0;
WrapPos = 0;
NextWord = "";
CurrentStyle = UWindowHTMLTextRow(L).StartStyle;
while(Input != "" || NextWord != "")
{
if(NextWord == "")
{
RemoveNextWord(Input, NextWord);
NextWordWidth = CalcHTMLTextWidth(C, NextWord, CurrentStyle);
}
if(WordsThisRow > 0 && LineWidth + NextWordWidth > MaxWidth)
{
return WrapPos;
}
else
{
WrapPos += Len(NextWord);
LineWidth += NextWordWidth;
NextWord = "";
WordsThisRow++;
}
}
return -1;
}
// Find the next word - but don't split up HTML tags.
function RemoveNextWord(out string Text, out string NextWord)
{
local int i;
local bool bInsideTag;
local string Ch;
bInsideTag = False;
for(i=0;i")
bInsideTag = False;
if(Ch == "<")
bInsideTag = True;
if(Ch == " " && !bInsideTag)
break;
}
while(Mid(Text, i, 1) == " ")
i++;
NextWord = Left(Text, i);
Text = Mid(Text, i);
}
function UWindowDynamicTextRow AddText(string NewLine)
{
local string Input, Output, LeftText, RightText, HTML, Temp;
local int i;
local UWindowDynamicTextRow L;
local HTMLStyle CurrentStyle, StartStyle;
if(List.Last == List)
{
CurrentStyle.BulletLevel = 0;
CurrentStyle.LinkDestination = "";
CurrentStyle.TextColor = TextColor;
CurrentStyle.BGColor = BGColor;
CurrentStyle.bCenter = bHCenter;
CurrentStyle.bLink = False;
CurrentStyle.bUnderline = False;
CurrentStyle.bNoBR = False;
CurrentStyle.bHeading = False;
CurrentStyle.bBold = False;
CurrentStyle.bBlink = False;
}
else
CurrentStyle = UWindowHTMLTextRow(List.Last).EndStyle;
StartStyle = CurrentStyle;
// convert \\n's -> 's
i = InStr(NewLine, "\\n");
while(i != -1)
{
NewLine = Left(NewLine, i) $ " " $ Mid(NewLine, i + 2);
i = InStr(NewLine, "\\n");
}
Input = NewLine;
Output = "";
while(Input != "")
{
ParseHTML(Input, LeftText, HTML, RightText);
switch(GetTag(HTML))
{
// multiline HTML tags
case "P":
if((Output $ LeftText) != "")
{
L = Super.AddText(Output $ LeftText);
Output = "";
UWindowHTMLTextRow(L).StartStyle = StartStyle;
UWindowHTMLTextRow(L).EndStyle = CurrentStyle;
}
StartStyle = CurrentStyle;
L = Super.AddText("");
UWindowHTMLTextRow(L).StartStyle = StartStyle;
UWindowHTMLTextRow(L).EndStyle = CurrentStyle;
break;
case "BR":
L = Super.AddText(Output $ LeftText);
Output = "";
UWindowHTMLTextRow(L).StartStyle = StartStyle;
UWindowHTMLTextRow(L).EndStyle = CurrentStyle;
StartStyle = CurrentStyle;
break;
case "BODY":
Temp = GetOption(HTML, "BGCOLOR=");
if(Temp != "")
{
BGColor = ParseColor(Temp);
CurrentStyle.BGColor = BGColor;
StartStyle.BGColor = BGColor;
}
Temp = GetOption(HTML, "LINK=");
if(Temp != "")
LinkColor = ParseColor(Temp);
Temp = GetOption(HTML, "ALINK=");
if(Temp != "")
ALinkColor = ParseColor(Temp);
Temp = GetOption(HTML, "TEXT=");
if(Temp != "")
{
TextColor = ParseColor(Temp);
CurrentStyle.TextColor = TextColor;
}
Output = Output $ LeftText;
break;
case "CENTER":
if((Output $ LeftText) != "")
{
L = Super.AddText(Output $ LeftText);
Output = "";
UWindowHTMLTextRow(L).StartStyle = StartStyle;
UWindowHTMLTextRow(L).EndStyle = CurrentStyle;
}
CurrentStyle.bCenter = True;
StartStyle = CurrentStyle;
break;
case "/CENTER":
L = Super.AddText(Output $ LeftText);
Output = "";
UWindowHTMLTextRow(L).StartStyle = StartStyle;
UWindowHTMLTextRow(L).EndStyle = CurrentStyle;
CurrentStyle.bCenter = False;
StartStyle = CurrentStyle;
break;
// Inline HTML tags
case "H1":
if((Output $ LeftText) != "")
{
L = Super.AddText(Output $ LeftText);
Output = "";
UWindowHTMLTextRow(L).StartStyle = StartStyle;
UWindowHTMLTextRow(L).EndStyle = CurrentStyle;
}
CurrentStyle.bHeading = True;
StartStyle = CurrentStyle;
break;
case "/H1":
L = Super.AddText(Output $ LeftText);
Output = "";
UWindowHTMLTextRow(L).StartStyle = StartStyle;
UWindowHTMLTextRow(L).EndStyle = CurrentStyle;
CurrentStyle.bHeading = False;
StartStyle = CurrentStyle;
break;
case "FONT":
Output = Output $ LeftText $ HTML;
Temp = GetOption(HTML, "COLOR=");
if(Temp != "")
CurrentStyle.TextColor = ParseColor(Temp);
Temp = GetOption(HTML, "BGCOLOR=");
if(Temp != "")
CurrentStyle.BGColor = ParseColor(Temp);
break;
case "/FONT":
Output = Output $ LeftText $ HTML;
CurrentStyle.TextColor = TextColor;
CurrentStyle.BGColor = BGColor;
break;
case "B":
Output = Output $ LeftText $ HTML;
CurrentStyle.bBold = True;
break;
case "/B":
Output = Output $ LeftText $ HTML;
CurrentStyle.bBold = False;
break;
case "U":
Output = Output $ LeftText $ HTML;
CurrentStyle.bUnderline = True;
break;
case "/U":
Output = Output $ LeftText $ HTML;
CurrentStyle.bUnderline = False;
break;
case "A":
Output = Output $ LeftText $ HTML;
CurrentStyle.bLink = True;
CurrentStyle.LinkDestination = GetOption(HTML, "HREF=");
break;
case "/A":
Output = Output $ LeftText $ HTML;
CurrentStyle.bLink = False;
CurrentStyle.LinkDestination = "";
break;
case "NOBR":
Output = Output $ LeftText $ HTML;
CurrentStyle.bNoBR = True;
break;
case "/NOBR":
Output = Output $ LeftText $ HTML;
CurrentStyle.bNoBR = False;
break;
case "BLINK":
Output = Output $ LeftText $ HTML;
CurrentStyle.bBlink = True;
break;
case "/BLINK":
Output = Output $ LeftText $ HTML;
CurrentStyle.bBlink = False;
break;
default:
Output = Output $ LeftText;
break;
}
Input = RightText;
}
L = Super.AddText(Output);
UWindowHTMLTextRow(L).StartStyle = StartStyle;
UWindowHTMLTextRow(L).EndStyle = CurrentStyle;
return L;
}
///////////////////////////////////////////////////
// HTML Text Processing
///////////////////////////////////////////////////
// Get the next HTML tag, the text before it and everthing after it.
function ParseHTML(string Input, out string LeftText, out string HTML, out string RightText)
{
local int i;
i = InStr(Input, "<");
if(i == -1)
{
LeftText = Input;
HTML = "";
RightText = "";
return;
}
LeftText = Left(Input, i);
HTML = Mid(Input, i);
i = InStr(HTML, ">");
if(i == -1)
{
RightText = "";
return;
}
RightText = Mid(HTML, i+1);
HTML = Left(HTML, i+1);
}
function float CalcHTMLTextWidth(Canvas C, string Text, out HTMLStyle CurrentStyle)
{
local string Input, LeftText, HTML, RightText;
local float W, H, Width;
Width = 0;
Input = Text;
while(Input != "")
{
ParseHTML(Input, LeftText, HTML, RightText);
SetCanvasStyle(C, CurrentStyle);
TextAreaTextSize(C, LeftText, W, H);
Width += W;
ProcessInlineHTML(HTML, CurrentStyle);
Input = RightText;
}
return Width;
}
// Update CurrentStyle based on the contents of the HTML tag provided
function ProcessInlineHTML(string HTML, out HTMLStyle CurrentStyle)
{
local string Temp;
if(HTML == "")
return;
switch(GetTag(HTML))
{
case "H1":
CurrentStyle.bHeading = True;
break;
case "/H1":
CurrentStyle.bHeading = False;
break;
case "FONT":
Temp = GetOption(HTML, "COLOR=");
if(Temp != "")
CurrentStyle.TextColor = ParseColor(Temp);
Temp = GetOption(HTML, "BGCOLOR=");
if(Temp != "")
CurrentStyle.BGColor = ParseColor(Temp);
break;
case "/FONT":
CurrentStyle.TextColor = TextColor;
CurrentStyle.BGColor = BGColor;
break;
case "B":
CurrentStyle.bBold = True;
break;
case "/B":
CurrentStyle.bBold = False;
break;
case "U":
CurrentStyle.bUnderline = True;
break;
case "/U":
CurrentStyle.bUnderline = False;
break;
case "A":
CurrentStyle.bLink = True;
CurrentStyle.LinkDestination = GetOption(HTML, "HREF=");
break;
case "/A":
CurrentStyle.bLink = False;
CurrentStyle.LinkDestination = "";
break;
case "NOBR":
CurrentStyle.bNoBR = True;
break;
case "/NOBR":
CurrentStyle.bNoBR = False;
break;
case "BLINK":
CurrentStyle.bBlink = True;
break;
case "/BLINK":
CurrentStyle.bBlink = False;
break;
}
}
// update the current style based on some text input
function HTMLUpdateStyle(string Input, out HTMLStyle CurrentStyle)
{
local string LeftText, HTML, RightText;
while(Input != "")
{
ParseHTML(Input, LeftText, HTML, RightText);
ProcessInlineHTML(HTML, CurrentStyle);
Input = RightText;
}
}
function string GetOption(string HTML, string Option)
{
local int i, j;
local string s;
i = InStr(Caps(HTML), Caps(Option));
if(i == 1 || Mid(HTML, i-1, 1) == " ")
{
s = Mid(HTML, i+Len(Option));
j = FirstMatching(InStr(s, ">"), InStr(s, " "));
s = Left(s, j);
if(Left(s, 1) == "\"")
s = Mid(s, 1);
if(Right(s, 1) == "\"")
s = Left(s, Len(s) - 1);
return s;
}
return "";
}
function string GetTag(string HTML)
{
local int i;
if(HTML == "")
return "";
HTML = Mid(HTML, 1); // lose <
i = FirstMatching(InStr(HTML, ">"), InStr(HTML, " "));
if(i == -1)
return Caps(HTML);
else
return Caps(Left(HTML, i));
}
function Color ParseColor(string S)
{
local Color C;
if(Left(S, 1) == "#")
S = Mid(S, 1);
C.R = 16 * GetHexDigit(Mid(S, 0, 1)) + GetHexDigit(Mid(S, 1, 1));
C.G = 16 * GetHexDigit(Mid(S, 2, 1)) + GetHexDigit(Mid(S, 3, 1));
C.B = 16 * GetHexDigit(Mid(S, 4, 1)) + GetHexDigit(Mid(S, 5, 1));
return C;
}
function int GetHexDigit(string D)
{
switch(caps(D))
{
case "0": return 0;
case "1": return 1;
case "2": return 2;
case "3": return 3;
case "4": return 4;
case "5": return 5;
case "6": return 6;
case "7": return 7;
case "8": return 8;
case "9": return 9;
case "A": return 10;
case "B": return 11;
case "C": return 12;
case "D": return 13;
case "E": return 14;
case "F": return 15;
}
return 0;
}
function int FirstMatching(int i, int j)
{
if(i == -1)
return j;
if(j == -1)
return i;
else
return Min(i, j);
}
function SetCanvasStyle(Canvas C, HTMLStyle CurrentStyle)
{
if(CurrentStyle.bLink)
C.DrawColor = LinkColor;
else
C.DrawColor = CurrentStyle.TextColor;
if(CurrentStyle.bHeading)
C.Font = Root.Fonts[F_LargeBold];
else
if(CurrentStyle.bBold)
C.Font = Root.Fonts[F_Bold];
else
C.Font = Root.Fonts[F_Normal];
}
function string WriteStyleText(HTMLStyle CurrentStyle, int CharCount)
{
local string Pad;
local string Temp;
local string Output;
Pad = "0000";
Temp = string(CharCount);
Output = Left(Pad, 4 - Len(Temp)) $ Temp;
Temp = string(Len(CurrentStyle.LinkDestination));
Output = Output $ Left(Pad, 4 - Len(Temp)) $ Temp $ CurrentStyle.LinkDestination;
Temp = string(CurrentStyle.TextColor.R);
Output = Output $ Left(Pad, 3 - Len(Temp)) $ Temp;
Temp = string(CurrentStyle.TextColor.G);
Output = Output $ Left(Pad, 3 - Len(Temp)) $ Temp;
Temp = string(CurrentStyle.TextColor.B);
Output = Output $ Left(Pad, 3 - Len(Temp)) $ Temp;
Temp = string(CurrentStyle.BGColor.R);
Output = Output $ Left(Pad, 3 - Len(Temp)) $ Temp;
Temp = string(CurrentStyle.BGColor.G);
Output = Output $ Left(Pad, 3 - Len(Temp)) $ Temp;
Temp = string(CurrentStyle.BGColor.B);
Output = Output $ Left(Pad, 3 - Len(Temp)) $ Temp;
if(CurrentStyle.bCenter)
Output = Output $ "T";
else
Output = Output $ "F";
if(CurrentStyle.bLink)
Output = Output $ "T";
else
Output = Output $ "F";
if(CurrentStyle.bUnderline)
Output = Output $ "T";
else
Output = Output $ "F";
if(CurrentStyle.bNoBR)
Output = Output $ "T";
else
Output = Output $ "F";
if(CurrentStyle.bHeading)
Output = Output $ "T";
else
Output = Output $ "F";
if(CurrentStyle.bBold)
Output = Output $ "T";
else
Output = Output $ "F";
if(CurrentStyle.bBlink)
Output = Output $ "T";
else
Output = Output $ "F";
return Output;
}
function int ReadStyleText(string StyleString, out int StylePos, out HTMLStyle CurrentStyle)
{
local string Temp;
local int CharCount;
local int i;
CharCount = Int(Mid(StyleString, StylePos, 4));
StylePos += 4;
i = Int(Mid(StyleString, StylePos, 4));
StylePos += 4;
CurrentStyle.LinkDestination = Mid(StyleString, StylePos, i);
StylePos += i;
CurrentStyle.TextColor.R = Int(Mid(StyleString, StylePos, 3));
StylePos += 3;
CurrentStyle.TextColor.G = Int(Mid(StyleString, StylePos, 3));
StylePos += 3;
CurrentStyle.TextColor.B = Int(Mid(StyleString, StylePos, 3));
StylePos += 3;
CurrentStyle.BGColor.R = Int(Mid(StyleString, StylePos, 3));
StylePos += 3;
CurrentStyle.BGColor.G = Int(Mid(StyleString, StylePos, 3));
StylePos += 3;
CurrentStyle.BGColor.B = Int(Mid(StyleString, StylePos, 3));
StylePos += 3;
CurrentStyle.bCenter = Mid(StyleString, StylePos++, 1) == "T";
CurrentStyle.bLink = Mid(StyleString, StylePos++, 1) == "T";
CurrentStyle.bUnderline = Mid(StyleString, StylePos++, 1) == "T";
CurrentStyle.bNoBR = Mid(StyleString, StylePos++, 1) == "T";
CurrentStyle.bHeading = Mid(StyleString, StylePos++, 1) == "T";
CurrentStyle.bBold = Mid(StyleString, StylePos++, 1) == "T";
CurrentStyle.bBlink = Mid(StyleString, StylePos++, 1) == "T";
return CharCount;
}
y @3I%m PA3 Hmay zZ x x x o x o x o `˛ `˛ p$ p$ p$ p$ p$ p$ p$ p$ p$ p$ p$ p$ p$ p$ p$ p$ p$ p$ `˛ `˛ p$ `˛ `˛ p$ p$ `˛ p$ p$ p$ `˛ p$ p$ p$ `˛ ˏ p$ p$ p$ p$ o x x x x p$ p$ p$ p$ p$ p$ p$ p$ p$ p$ p$ >
Y >
Y >
Y >
Y >
Y >
Y >
Y >
Y x o S* K * J * l M O fE ~~ F3 ~~S }2 Wn b k W W c W ?f!?6 c W c ?R W c ]?6 c?6
c W c -t' W c I k W c O k W c T k W c Q k W c Rc W c KS W c Gc W c Jc ~ [!//=============================================================================
// UWindowHSplitter - a horizontal splitter component
//=============================================================================
class UWindowHSplitter extends UWindowWindow;
var UWindowWindow LeftClientWindow;
var UWindowWindow RightClientWindow;
var bool bSizing;
var float SplitPos;
var float MinWinWidth;
var float OldWinWidth;
var float MaxSplitPos;
var bool bRightGrow;
var bool bSizable;
function Created()
{
Super.Created();
bAlwaysBehind = True;
SplitPos = WinWidth / 2;
MinWinWidth = 24;
OldWinWidth = WinWidth;
}
function Paint(Canvas C, float X, float Y)
{
local Texture T;
T = GetLookAndFeelTexture();
DrawUpBevel(C, SplitPos, 0, 7, WinHeight, T);
}
function BeforePaint(Canvas C, float X, float Y)
{
local float NewW, NewH;
// Make Left panel resize
if(OldWinWidth != WinWidth && !bRightGrow)
{
SplitPos = SplitPos + WinWidth - OldWinWidth;
}
SplitPos = FClamp(SplitPos, MinWinWidth, WinWidth - 7 - MinWinWidth);
if(MaxSplitPos != 0)
SplitPos = FClamp(SplitPos, 0, MaxSplitPos);
NewW = SplitPos;
NewH = WinHeight;
if(NewH != LeftClientWindow.WinHeight || NewW != LeftClientWindow.WinWidth)
{
LeftClientWindow.SetSize(NewW, NewH);
}
LeftClientWindow.WinTop = 0;
LeftClientWindow.WinLeft = 0;
NewW = WinWidth - SplitPos - 7;
if(NewH != RightClientWindow.WinHeight || NewW != RightClientWindow.WinWidth)
{
RightClientWindow.SetSize(NewW, NewH);
}
RightClientWindow.WinTop = 0;
RightClientWindow.WinLeft = SplitPos + 7;
OldWinWidth = WinWidth;
}
function LMouseDown(float X, float Y)
{
Super.LMouseDown(X, Y);
if(bSizable && (X >= SplitPos) && (X <= SplitPos + 7))
{
bSizing = True;
Root.CaptureMouse();
}
}
function MouseMove(float X, float Y)
{
if(bSizable && (X >= SplitPos) && (X <= SplitPos + 7))
Cursor = Root.HSplitCursor;
else
Cursor = Root.NormalCursor;
if(bSizing && bMouseDown)
{
SplitPos = X;
} else bSizing = False;
}
~ k ~~ ~~T C3 Kg 6 _6 c6 _6
z
6 _D K ?6 c6 n K -@6
_D K ?6
z
6
Y 6
_D K ?6
z
6
t _ ~ H' ~~ _ ~~NO' C i C f,6 C $6 C $6 C $ * C?6 , @K?6
, @v?6 , @K?6 , @M?6
, @v?6
, @S ? ? v6 C $ 6 C $ 6 C =, W
?6 , @K& W
?&6 , @KU?6 , @K?6 , @M?,?,d O?,D?6 , @M W
?& * C W
?6
, @v& O?6
, @v?6
, @S?& ? ? v W
?,&6 C =,6 C =,6 C =, ~O G3 ff M I?, I f ?, H?, H?,$ I?, H?, I?, H?,$ I f ?, H?,* I f ?, H?,$D I?, H f ?,* I?, H f ?,$ I f ?, H f ?,$ H?,$ H f ?,$ I?,$ I f ?,$$
D3X2G L3 ` .'l o o o .'l .'l .'l .'l .'l .'l .'l .'l .'l .'lV ~~ H9class UWindowHSliderControl extends UWindowDialogControl;
var float MinValue;
var float MaxValue;
var float Value;
var int Step; // 0 = continuous
var float SliderWidth;
var float SliderDrawX, SliderDrawY;
var float TrackStart;
var float TrackWidth;
var bool bSliding;
var bool bNoSlidingNotify;
function Created()
{
Super.Created();
SliderWidth = WinWidth / 2;
TrackWidth = 4;
}
function SetRange(float Min, float Max, int NewStep)
{
MinValue = Min;
MaxValue = Max;
Step = NewStep;
Value = CheckValue(Value);
}
function float GetValue()
{
return Value;
}
function SetValue(float NewValue, optional bool bNoNotify)
{
local float OldValue;
OldValue = Value;
Value = CheckValue(NewValue);
if(Value != OldValue && !bNoNotify)
{
// Notify
Notify(DE_Change);
}
}
function float CheckValue(float Test)
{
local float TempF;
local float NewValue;
NewValue = Test;
if(Step != 0)
{
TempF = NewValue / Step;
NewValue = Int(TempF + 0.5) * Step;
}
if(NewValue < MinValue) NewValue = MinValue;
if(NewValue > MaxValue) NewValue = MaxValue;
return NewValue;
}
function BeforePaint(Canvas C, float X, float Y)
{
local float W, H;
Super.BeforePaint(C, X, Y);
TextSize(C, Text, W, H);
WinHeight = H+1;
switch(Align)
{
case TA_Left:
SliderDrawX = WinWidth - SliderWidth;
TextX = 0;
break;
case TA_Right:
SliderDrawX = 0;
TextX = WinWidth - W;
break;
case TA_Center:
SliderDrawX = (WinWidth - SliderWidth) / 2;
TextX = (WinWidth - W) / 2;
break;
}
SliderDrawY = (WinHeight - 2) / 2;
TextY = (WinHeight - H) / 2;
TrackStart = SliderDrawX + (SliderWidth - TrackWidth) * ((Value - MinValue)/(MaxValue - MinValue));
}
function Paint(Canvas C, float X, float Y)
{
local Texture T;
local Region R;
T = GetLookAndFeelTexture();
if(Text != "")
{
C.DrawColor = TextColor;
ClipText(C, TextX, TextY, Text);
C.DrawColor.R = 255;
C.DrawColor.G = 255;
C.DrawColor.B = 255;
}
R = LookAndFeel.HLine;
DrawStretchedTextureSegment( C, SliderDrawX, SliderDrawY, SliderWidth, R.H, R.X, R.Y, R.W, R.H, T);
DrawUpBevel(C, TrackStart, SliderDrawY-4, TrackWidth, 10, T);
}
function LMouseUp(float X, float Y)
{
Super.LMouseUp(X, Y);
if(bNoSlidingNotify)
Notify(DE_Change);
}
function LMouseDown(float X, float Y)
{
Super.LMouseDown(X, Y);
if((X >= TrackStart) && (X <= TrackStart + TrackWidth)) {
bSliding = True;
Root.CaptureMouse();
}
if(X < TrackStart && X > SliderDrawX)
{
if(Step != 0)
SetValue(Value - Step);
else
SetValue(Value - 1);
}
if(X > TrackStart + TrackWidth && X < SliderDrawX + SliderWidth)
{
if(Step != 0)
SetValue(Value + Step);
else
SetValue(Value + 1);
}
}
function MouseMove(float X, float Y)
{
Super.MouseMove(X, Y);
if(bSliding && bMouseDown)
{
SetValue((((X - SliderDrawX) / (SliderWidth - TrackWidth)) * (MaxValue - MinValue)) + MinValue, bNoSlidingNotify);
}
else
bSliding = False;
}
function KeyDown(int Key, float X, float Y)
{
local PlayerPawn P;
P = GetPlayerOwner();
switch (Key)
{
case P.EInputKey.IK_Left:
if(Step != 0)
SetValue(Value - Step);
else
SetValue(Value - 1);
break;
case P.EInputKey.IK_Right:
if(Step != 0)
SetValue(Value + Step);
else
SetValue(Value + 1);
break;
case P.EInputKey.IK_Home:
SetValue(MinValue);
break;
case P.EInputKey.IK_End:
SetValue(MaxValue);
break;
default:
Super.KeyDown(Key, X, Y);
break;
}
}
& M3O$D N3 |[$& ) >
Y >
Y >
Y >
Y o x x x x Ԍ~~ ~s ~M K3 kl A k6 X N k k T ~ b ~~ n ~~J P3 $m p n $ h $ (? $# o n $ ] h x $ @A?6
,v?6
,S $ b
$ $ @ $ $ f $ n
.$ $ @ $ n $ h
$ $ @ $ $ f?, $ n $ h?,
$ z $ ?,?, $ P $ x?, $ T $ @?6 ,K $ T ?6
,v $ i ?6 i4 $ -w $ T $ f?6 ,K?6 ,M?6 i?6 r?6 g $ T $ ?6
,v?6
,S $ i $ ?6 i?6 ,M?6 r?6 g $ i $ T $ B $ ?6 ,M?6 r?6 g $ B $ T $ D $ ?6 ,M?6 g $ D $ T $ B ?6 r $ B ?6
r $ D ?6 g $ D ?6
g? $ T $ f?6 ,K?6 ,M?6 i $ T $ ?6
,v?6
,S $ i $ ?6 i?6 ,M $ i $ T $ i $ T ~ |E//=============================================================================
// UWindowHScrollBar - A horizontal scrollbar
//=============================================================================
class UWindowHScrollBar extends UWindowWindow;
var UWindowSBLeftButton LeftButton;
var UWindowSBRightButton RightButton;
var bool bDisabled;
var float MinPos;
var float MaxPos;
var float MaxVisible;
var float Pos; // offset to WinTop
var float ThumbStart, ThumbWidth;
var float NextClickTime;
var float DragX;
var bool bDragging;
var float ScrollAmount;
function Show(float P)
{
if(P < 0) return;
if(P > MaxPos + MaxVisible) return;
while(P < Pos)
if(!Scroll(-1))
break;
while(P - Pos > MaxVisible - 1)
if(!Scroll(1))
break;
}
function bool Scroll(float Delta)
{
local float OldPos;
OldPos = Pos;
Pos = Pos + Delta;
CheckRange();
return Pos == OldPos + Delta;
}
function SetRange(float NewMinPos, float NewMaxPos, float NewMaxVisible, optional float NewScrollAmount)
{
if(NewScrollAmount == 0)
NewScrollAmount = 1;
ScrollAmount = NewScrollAmount;
MinPos = NewMinPos;
MaxPos = NewMaxPos - NewMaxVisible;
MaxVisible = NewMaxVisible;
CheckRange();
}
function CheckRange()
{
if(Pos < MinPos)
{
Pos = MinPos;
}
else
{
if(Pos > MaxPos) Pos = MaxPos;
}
bDisabled = (MaxPos <= MinPos);
LeftButton.bDisabled = bDisabled;
RightButton.bDisabled = bDisabled;
if(bDisabled)
{
Pos = 0;
}
else
{
ThumbStart = ((Pos - MinPos) * (WinWidth - (2*LookAndFeel.Size_ScrollbarButtonHeight))) / (MaxPos + MaxVisible - MinPos);
ThumbWidth = (MaxVisible * (WinWidth - (2*LookAndFeel.Size_ScrollbarButtonHeight))) / (MaxPos + MaxVisible - MinPos);
if(ThumbWidth < LookAndFeel.Size_MinScrollbarHeight)
ThumbWidth = LookAndFeel.Size_MinScrollbarHeight;
if(ThumbWidth + ThumbStart > WinWidth - 2*LookAndFeel.Size_ScrollbarButtonHeight)
{
ThumbStart = WinWidth - 2*LookAndFeel.Size_ScrollbarButtonHeight - ThumbWidth;
}
ThumbStart = ThumbStart + LookAndFeel.Size_ScrollbarButtonHeight;
}
}
function Created()
{
Super.Created();
LeftButton = UWindowSBLeftButton(CreateWindow(class'UWindowSBLeftButton', 0, 0, 10, 12));
RightButton = UWindowSBRightButton(CreateWindow(class'UWindowSBRightButton', WinWidth-10, 0, 10, 12));
}
function BeforePaint(Canvas C, float X, float Y)
{
LeftButton.WinTop = 0;
LeftButton.WinLeft = 0;
LeftButton.WinWidth = LookAndFeel.Size_ScrollbarButtonHeight;
LeftButton.WinHeight = LookAndFeel.Size_ScrollbarWidth;
RightButton.WinTop = 0;
RightButton.WinLeft = WinWidth - LookAndFeel.Size_ScrollbarButtonHeight;
RightButton.WinWidth = LookAndFeel.Size_ScrollbarButtonHeight;
RightButton.WinHeight = LookAndFeel.Size_ScrollbarWidth;
CheckRange();
}
function Paint(Canvas C, float X, float Y)
{
LookAndFeel.SB_HDraw(Self, C);
}
function LMouseDown(float X, float Y)
{
Super.LMouseDown(X, Y);
if(bDisabled) return;
if(X < ThumbStart)
{
Scroll(-(MaxVisible-1));
NextClickTime = GetLevel().TimeSeconds + 0.5;
return;
}
if(X > ThumbStart + ThumbWidth)
{
Scroll(MaxVisible-1);
NextClickTime = GetLevel().TimeSeconds + 0.5;
return;
}
if((X >= ThumbStart) && (X <= ThumbStart + ThumbWidth))
{
DragX = X - ThumbStart;
bDragging = True;
Root.CaptureMouse();
return;
}
}
function Tick(float Delta)
{
local bool bLeft, bRight;
local float X, Y;
if(bDragging) return;
bLeft = False;
bRight = False;
if(bMouseDown)
{
GetMouseXY(X, Y);
bLeft = (X < ThumbStart);
bRight = (X > ThumbStart + ThumbWidth);
}
if(bMouseDown && (NextClickTime > 0) && (NextClickTime < GetLevel().TimeSeconds) && bLeft)
{
Scroll(-(MaxVisible-1));
NextClickTime = GetLevel().TimeSeconds + 0.1;
}
if(bMouseDown && (NextClickTime > 0) && (NextClickTime < GetLevel().TimeSeconds) && bRight)
{
Scroll(MaxVisible-1);
NextClickTime = GetLevel().TimeSeconds + 0.1;
}
if(!bMouseDown || (!bLeft && !bRight))
{
NextClickTime = 0;
}
}
function MouseMove(float X, float Y)
{
if(bDragging && bMouseDown && !bDisabled)
{
while(X < (ThumbStart+DragX) && Pos > MinPos)
{
Scroll(-1);
}
while(X > (ThumbStart+DragX) && Pos < MaxPos)
{
Scroll(1);
}
}
else
bDragging = False;
}
~ Q3 ~~uW3 T T h (? o T Q] b jn b?,P j?, -2n?&P?& ~ @ Ri i R h (? o R Q] f qg f?,
f?,
~I S3 mq% # mA i ^ m @ m f m f, { m ] ^ m j m5 ^ m n m P m ]6 ^ =,6 ^ =,6 ^ =, ~ ]class UWindowHotkeyWindowList extends UWindowList;
var UWindowWindow Window;
function UWindowHotkeyWindowList FindWindow(UWindowWindow W)
{
local UWindowHotkeyWindowList l;
l = UWindowHotkeyWindowList(Next);
while(l != None)
{
if(l.Window == W) return l;
l = UWindowHotkeyWindowList(l.Next);
}
return None;
}
~ Y N(/ =
] N ~A X3 tP3 K$ t i v Y t2 X v @ t ?, @ ^ t( i v t ?, ] t( i v t ?, Z t@ X v @ t ?, t ?, @ \ t6 i v t ?, t ?, X t2 X v @ @ t ?, _ t@ X v t ?, @ @ t ?, [ t@ X v @ @ t ?, t ?, b ~ h9//=============================================================================
// UWindowGridColumn - a grid column
//=============================================================================
class UWindowGridColumn extends UWindowWindow;
var UWindowGridColumn NextColumn;
var UWindowGridColumn PrevColumn;
var bool bSizing;
var string ColumnHeading;
var int ColumnNum;
function Created() {
Super.Created();
}
function BeforePaint(Canvas C, float X, float Y)
{
Super.BeforePaint(C, X, Y);
if(WinWidth < 1) WinWidth = 1;
}
function LMouseDown(float X, float Y)
{
Super.LMouseDown(X, Y);
if(X > Min(WinWidth - 5, ParentWindow.WinWidth - WinLeft - 5) && Y < 12)
{
bSizing = True;
UWindowGrid(ParentWindow.ParentWindow).bSizingColumn = True;
Root.CaptureMouse();
}
}
function LMouseUp(float X, float Y)
{
Super.LMouseUp(X, Y);
UWindowGrid(ParentWindow.ParentWindow).bSizingColumn = False;
}
function MouseMove(float X, float Y)
{
if(X > Min(WinWidth - 5, ParentWindow.WinWidth - WinLeft - 5) && Y < 12)
{
Cursor = Root.HSplitCursor;
}
else
{
Cursor = Root.NormalCursor;
}
if(bSizing && bMouseDown)
{
WinWidth = X;
if(WinWidth < 1) WinWidth = 1;
if(WinWidth > ParentWindow.WinWidth - WinLeft - 1) WinWidth = ParentWindow.WinWidth - WinLeft - 1;
}
else
{
bSizing = False;
UWindowGrid(ParentWindow.ParentWindow).bSizingColumn = False;
}
}
function Paint(Canvas C, float X, float Y)
{
local Region R;
local Texture T;
local Color FC;
UWindowGrid(ParentWindow.ParentWindow).PaintColumn(C, Self, X, Y);
if(IsActive())
{
T = LookAndFeel.Active;
FC = LookAndFeel.HeadingActiveTitleColor;
}
else
{
T = LookAndFeel.InActive;
FC = LookAndFeel.HeadingInactiveTitleColor;
}
C.DrawColor.r = 255;
C.DrawColor.g = 255;
C.DrawColor.b = 255;
DrawUpBevel( C, 0, 0, WinWidth, LookAndFeel.ColumnHeadingHeight, T);
C.DrawColor = FC;
ClipText( C, 2, 1, ColumnHeading);
C.DrawColor.r = 255;
C.DrawColor.g = 255;
C.DrawColor.b = 255;
}
function Click(float X, float Y)
{
local int Row;
if(Y < 12)
{
if(X <= Min(WinWidth - 5, ParentWindow.WinWidth - WinLeft - 5))
{
UWindowGrid(ParentWindow.ParentWindow).SortColumn(Self);
}
}
else
{
Row = ((Y - 12) / UWindowGrid(ParentWindow.ParentWindow).RowHeight) + UWindowGrid(ParentWindow.ParentWindow).TopRow;
UWindowGrid(ParentWindow.ParentWindow).SelectRow(Row);
}
}
function RMouseDown(float X, float Y)
{
local int Row;
Super.RMouseDown(X, Y);
if(Y > 12)
{
Row = ((Y - 12) / UWindowGrid(ParentWindow.ParentWindow).RowHeight) + UWindowGrid(ParentWindow.ParentWindow).TopRow;
UWindowGrid(ParentWindow.ParentWindow).SelectRow(Row);
UWindowGrid(ParentWindow.ParentWindow).RightClickRowDown(Row, X+WinLeft, Y+WinTop);
}
}
function RMouseUp(float X, float Y)
{
local int Row;
Super.RMouseUp(X, Y);
if(Y > 12)
{
Row = ((Y - 12) / UWindowGrid(ParentWindow.ParentWindow).RowHeight) + UWindowGrid(ParentWindow.ParentWindow).TopRow;
UWindowGrid(ParentWindow.ParentWindow).SelectRow(Row);
UWindowGrid(ParentWindow.ParentWindow).RightClickRow(Row, X+WinLeft, Y+WinTop);
}
}
function DoubleClick(float X, float Y)
{
local int Row;
if(Y < 12)
{
Click(X, Y);
}
else
{
Row = ((Y - 12) / UWindowGrid(ParentWindow.ParentWindow).RowHeight) + UWindowGrid(ParentWindow.ParentWindow).TopRow;
UWindowGrid(ParentWindow.ParentWindow).DoubleClickRow(Row);
}
}
function MouseLeave()
{
Super.MouseLeave();
UWindowGrid(ParentWindow.ParentWindow).MouseLeaveColumn(Self);
}
~ a//=============================================================================
// UWindowGridClient - The client area on a grid.
//=============================================================================
class UWindowGridClient extends UWindowWindow;
function Created() {
}
~@ [3 bKC ' B 6 [ =,6 [ =,6 [ =, - M b$ X [ } B ~ K W6 [ $ 6 [ $ 6 [ $ 6 [ $ 6 [ $ 6 [ $ b5 [ }? b d?, B?, J ~ ~~ [R//=============================================================================
// UWindowGrid - a grid with sizable columns and clickable column headings.
//=============================================================================
class UWindowGrid extends UWindowWindow;
var UWindowGridColumn FirstColumn;
var UWindowGridColumn LastColumn;
var UWindowGridClient ClientArea;
var int TopRow;
var float RowHeight;
var UWindowVScrollbar VertSB;
var UWindowHScrollbar HorizSB;
var bool bShowHorizSB;
var bool bSizingColumn;
var bool bNoKeyboard;
function Created()
{
ClientArea = UWindowGridClient(CreateWindow(class'UWindowGridClient', 0, 0, WinWidth - 12, WinHeight));
VertSB = UWindowVScrollbar(CreateWindow(class'UWindowVScrollbar', WinWidth-12, 0, 12, WinHeight));
VertSB.bAlwaysOnTop = True;
HorizSB = UWindowHScrollbar(CreateWindow(class'UWindowHScrollbar', 0, WinHeight-12, WinWidth, 12));
HorizSB.bAlwaysOnTop = True;
HorizSB.HideWindow();
bShowHorizSB = False;
if(!bNoKeyboard)
SetAcceptsFocus();
Super.Created();
}
function BeforePaint(Canvas C, float X, float Y)
{
Super.BeforePaint(C, X, Y);
Resized();
}
function Resized()
{
local float Offset;
local UWindowGridColumn colColumn;
local float TotalWidth;
TotalWidth = 0;
colColumn = FirstColumn;
while(colColumn != None)
{
TotalWidth = TotalWidth + colColumn.WinWidth;
colColumn = colColumn.NextColumn;
}
if(!bSizingColumn)
HorizSB.SetRange(0, TotalWidth, WinWidth - LookAndFeel.Size_ScrollbarWidth, 10);
if(!HorizSB.bDisabled)
{
// Need a horizontal scrollbar
HorizSB.ShowWindow();
bShowHorizSB = True;
}
else
{
HorizSB.HideWindow();
bShowHorizSB = False;
HorizSB.Pos = 0;
}
ClientArea.WinTop = 0;
ClientArea.WinLeft = 0;
ClientArea.WinWidth = WinWidth - LookAndFeel.Size_ScrollbarWidth;
if(bShowHorizSB)
ClientArea.WinHeight = WinHeight - LookAndFeel.Size_ScrollbarWidth;
else
ClientArea.WinHeight = WinHeight;
if(bShowHorizSB)
{
HorizSB.WinTop = WinHeight-LookAndFeel.Size_ScrollbarWidth;
HorizSB.WinLeft = 0;
HorizSB.WinWidth = WinWidth - LookAndFeel.Size_ScrollbarWidth;
HorizSB.WinHeight = LookAndFeel.Size_ScrollbarWidth;
}
VertSB.WinTop = 0;
VertSB.WinLeft = WinWidth-LookAndFeel.Size_ScrollbarWidth;
VertSB.WinWidth = LookAndFeel.Size_ScrollbarWidth;
if(bShowHorizSB)
VertSB.WinHeight = WinHeight - LookAndFeel.Size_ScrollbarWidth;
else
VertSB.WinHeight = WinHeight;
if(bShowHorizSB)
Offset = 1 - HorizSB.Pos;
else
Offset = 1;
colColumn = FirstColumn;
while(colColumn != None)
{
colColumn.WinLeft = Offset ;
colColumn.WinTop = 0;
colColumn.WinHeight = WinHeight;
Offset = Offset + colColumn.WinWidth;
colColumn = colColumn.NextColumn;
}
}
function UWindowGridColumn AddColumn(string ColumnHeading, float DefaultWidth)
{
local UWindowGridColumn NewColumn;
local UWindowGridColumn OldLastColumn;
OldLastColumn = LastColumn;
if(LastColumn == None)
{
NewColumn = UWindowGridColumn(ClientArea.CreateWindow(class'UWindowGridColumn', 0, 0, DefaultWidth, WinHeight));
FirstColumn = NewColumn;
NewColumn.ColumnNum = 0;
}
else
{
NewColumn = UWindowGridColumn(ClientArea.CreateWindow(class'UWindowGridColumn', LastColumn.WinLeft + LastColumn.WinWidth, 0, DefaultWidth, WinHeight));
LastColumn.NextColumn = NewColumn;
NewColumn.ColumnNum = LastColumn.ColumnNum + 1;
}
LastColumn = NewColumn;
NewColumn.NextColumn = None;
NewColumn.PrevColumn = OldLastColumn;
NewColumn.ColumnHeading = ColumnHeading;
return NewColumn;
}
function Paint(Canvas C, float MouseX, float MouseY)
{
local float X;
local Texture T;
local Region R;
X = LastColumn.WinWidth + LastColumn.WinLeft;
T = GetLookAndFeelTexture();
DrawUpBevel( C, X, 0, WinWidth-X, LookAndFeel.ColumnHeadingHeight, T);
if(bShowHorizSB)
{
// R = LookAndFeel.SBBackground;
DrawStretchedTextureSegment( C, WinWidth-LookAndFeel.Size_ScrollbarWidth,
WinHeight-LookAndFeel.Size_ScrollbarWidth,
LookAndFeel.Size_ScrollbarWidth,
LookAndFeel.Size_ScrollbarWidth,
R.X, R.Y, R.W, R.H, T);
}
}
function PaintColumn(Canvas C, UWindowGridColumn Column, float MouseX, float MouseY)
{
// defined in subclass
}
function SortColumn(UWindowGridColumn Column)
{
// defined in subclass
}
function SelectRow(int Row)
{
// defined in subclass
}
function RightClickRow(int Row, float X, float Y)
{
// defined in subclass
}
function RightClickRowDown(int Row, float X, float Y)
{
// defined in subclass
}
function DoubleClickRow(int Row)
{
// defined in subclass
}
function MouseLeaveColumn(UWindowGridColumn Column)
{
// defined in subclass
}
function KeyDown(int Key, float X, float Y)
{
switch(Key) {
case 0x26: // IK_Up
case 0xEC: // IK_MouseWheelUp
VertSB.Scroll(-1);
break;
case 0x28: // IK_Down
case 0xED: // IK_MouseWheelDown
VertSB.Scroll(1);
break;
case 0x21: // IK_PageUp
VertSB.Scroll(-(VertSB.MaxVisible-1));
break;
case 0x22: // IK_PageDown
VertSB.Scroll(VertSB.MaxVisible-1);
break;
}
}
~bb3 _3) w -2
P
?% P
6 .
.
l P
6 = -2P
~5r3 s b 5 s r -O .
.
l P
6 ? ~@ ~L4 Sev C -nj S6 w* -q'T S ~ u
~ L5" "
" " * "` ~ @ ~E ^3 Zw\ l) : Z# o O Z ] ] \ Z ?D \?&, Z b
$ Z p Z ?, Z n 3
$ Z p Z n Z ]3
0$ Z p Z ?,?, Z n Z ]?,3
Z H Z ?,?, Z P Z \?, Z -d Z I W Z O W Z T W Z Q S28 Z I N Z O N Z T N Z Q T2 ~ YV//=============================================================================
// UWindowFramedWindow - a Windows95 style framed window
//=============================================================================
class UWindowFramedWindow extends UWindowWindow;
var class ClientClass;
var UWindowWindow ClientArea;
var localized string WindowTitle;
var string StatusBarText;
var float MoveX, MoveY; // co-ordinates where the move was requested
var float MinWinWidth, MinWinHeight;
var bool bTLSizing;
var bool bTSizing;
var bool bTRSizing;
var bool bLSizing;
var bool bRSizing;
var bool bBLSizing;
var bool bBSizing;
var bool bBRSizing;
var bool bMoving;
var bool bSizable;
var bool bStatusBar;
var UWindowFrameCloseBox CloseBox;
function Created()
{
Super.Created();
MinWinWidth = 50;
MinWinHeight = 50;
ClientArea = CreateWindow(ClientClass, 4, 16, WinWidth - 8, WinHeight - 20, OwnerWindow);
CloseBox = UWindowFrameCloseBox(CreateWindow(Class'UWindowFrameCloseBox', WinWidth-20, WinHeight-20, 11, 10));
}
function Texture GetLookAndFeelTexture()
{
return LookAndFeel.GetTexture(Self);
}
function bool IsActive()
{
return ParentWindow.ActiveWindow == Self;
}
function BeforePaint(Canvas C, float X, float Y)
{
Super.BeforePaint(C, X, Y);
Resized();
LookAndFeel.FW_SetupFrameButtons(Self, C);
}
function Paint(Canvas C, float X, float Y)
{
LookAndFeel.FW_DrawWindowFrame(Self, C);
}
function LMouseDown(float X, float Y)
{
local FrameHitTest H;
H = LookAndFeel.FW_HitTest(Self, X, Y);
Super.LMouseDown(X, Y);
if(H == HT_TitleBar)
{
MoveX = X;
MoveY = Y;
bMoving = True;
Root.CaptureMouse();
return;
}
if(bSizable)
{
switch(H)
{
case HT_NW:
bTLSizing = True;
Root.CaptureMouse();
return;
case HT_NE:
bTRSizing = True;
Root.CaptureMouse();
return;
case HT_SW:
bBLSizing = True;
Root.CaptureMouse();
return;
case HT_SE:
bBRSizing = True;
Root.CaptureMouse();
return;
case HT_N:
bTSizing = True;
Root.CaptureMouse();
return;
case HT_S:
bBSizing = True;
Root.CaptureMouse();
return;
case HT_W:
bLSizing = True;
Root.CaptureMouse();
return;
case HT_E:
bRSizing = True;
Root.CaptureMouse();
return;
}
}
}
function Resized()
{
local Region R;
if(ClientArea == None)
{
Log("Client Area is None for "$Self);
return;
}
R = LookAndFeel.FW_GetClientArea(Self);
ClientArea.WinLeft = R.X;
ClientArea.WinTop = R.Y;
if((R.W != ClientArea.WinWidth) || (R.H != ClientArea.WinHeight))
{
ClientArea.SetSize(R.W, R.H);
}
}
function MouseMove(float X, float Y)
{
local float OldW, OldH;
local FrameHitTest H;
H = LookAndFeel.FW_HitTest(Self, X, Y);
if(bMoving && bMouseDown)
{
WinLeft = Int(WinLeft + X - MoveX);
WinTop = Int(WinTop + Y - MoveY);
}
else
bMoving = False;
Cursor = Root.NormalCursor;
if(bSizable && !bMoving)
{
switch(H)
{
case HT_NW:
case HT_SE:
Cursor = Root.DiagCursor1;
break;
case HT_NE:
case HT_SW:
Cursor = Root.DiagCursor2;
break;
case HT_W:
case HT_E:
Cursor = Root.WECursor;
break;
case HT_N:
case HT_S:
Cursor = Root.NSCursor;
break;
}
}
// Top Left
if(bTLSizing && bMouseDown)
{
Cursor = Root.DiagCursor1;
OldW = WinWidth;
OldH = WinHeight;
SetSize(Max(MinWinWidth, WinWidth - X), Max(MinWinHeight, WinHeight - Y));
WinLeft = Int(WinLeft + OldW - WinWidth);
WinTop = Int(WinTop + OldH - WinHeight);
}
else
bTLSizing = False;
// Top
if(bTSizing && bMouseDown)
{
Cursor = Root.NSCursor;
OldH = WinHeight;
SetSize(WinWidth, Max(MinWinHeight, WinHeight - Y));
WinTop = Int(WinTop + OldH - WinHeight);
}
else
bTSizing = False;
// Top Right
if(bTRSizing && bMouseDown)
{
Cursor = Root.DiagCursor2;
OldH = WinHeight;
SetSize(Max(MinWinWidth, X), Max(MinWinHeight, WinHeight - Y));
WinTop = Int(WinTop + OldH - WinHeight);
}
else
bTRSizing = False;
// Left
if(bLSizing && bMouseDown)
{
Cursor = Root.WECursor;
OldW = WinWidth;
SetSize(Max(MinWinWidth, WinWidth - X), WinHeight);
WinLeft = Int(WinLeft + OldW - WinWidth);
}
else
bLSizing = False;
// Right
if(bRSizing && bMouseDown)
{
Cursor = Root.WECursor;
SetSize(Max(MinWinWidth, X), WinHeight);
}
else
bRSizing = False;
// Bottom Left
if(bBLSizing && bMouseDown)
{
Cursor = Root.DiagCursor2;
OldW = WinWidth;
SetSize(Max(MinWinWidth, WinWidth - X), Max(MinWinHeight, Y));
WinLeft = Int(WinLeft + OldW - WinWidth);
}
else
bBLSizing = False;
// Bottom
if(bBSizing && bMouseDown)
{
Cursor = Root.NSCursor;
SetSize(WinWidth, Max(MinWinHeight, Y));
}
else
bBSizing = False;
// Bottom Right
if(bBRSizing && bMouseDown)
{
Cursor = Root.DiagCursor1;
SetSize(Max(MinWinWidth, X), Max(MinWinHeight, Y));
}
else
bBRSizing = False;
}
function ToolTip(string strTip)
{
StatusBarText = strTip;
}
function WindowEvent(WinMessage Msg, Canvas C, float X, float Y, int Key)
{
if(Msg == WM_Paint || !WaitModal())
Super.WindowEvent(Msg, C, X, Y, Key);
}
function WindowHidden()
{
Super.WindowHidden();
LookAndFeel.PlayMenuSound(Self, MS_WindowClose);
}
~ j' kZ! K u
. 8 u
q u
F k u
~ ~~ j3 ~~F g3 `p , o ` ` -t' ` I o ` O o ` T o ` Q o ` Ri ` Kt ` Gi ` Js ~ Hclass UWindowFrameCloseBox extends UWindowButton;
function Created()
{
bNoKeyboard = True;
Super.Created();
}
function Click(float X, float Y)
{
ParentWindow.Close();
}
// No keyboard support
function KeyDown(int Key, float X, float Y)
{
}
P5" "
" " * "=l ~a @
~| l3 ML h. uG H M h M (? M# o H M ] Z G M @A?6
uv?6
uS M b
$ M J M M U M n
?$ M J M n M Z
$ M J M M U ?, M n M Z?,
M p M ?,?, M P M G?, M l M J ?6 uK M l ?6
uv M l M U ?6 uK?6 uM M l M ?6
uv?6
uS ~ qclass UWindowEditControl extends UWindowDialogControl;
var float EditBoxWidth;
var float EditAreaDrawX, EditAreaDrawY;
var UWindowEditBox EditBox;
function Created()
{
local Color C;
Super.Created();
EditBox = UWindowEditBox(CreateWindow(class'UWindowEditBox', 0, 0, WinWidth, WinHeight));
EditBox.NotifyOwner = Self;
EditBox.bSelectOnFocus = True;
EditBoxWidth = WinWidth / 2;
SetEditTextColor(LookAndFeel.EditBoxTextColor);
}
function SetNumericOnly(bool bNumericOnly)
{
EditBox.bNumericOnly = bNumericOnly;
}
function SetNumericFloat(bool bNumericFloat)
{
EditBox.bNumericFloat = bNumericFloat;
}
function SetFont(int NewFont)
{
Super.SetFont(NewFont);
EditBox.SetFont(NewFont);
}
function SetHistory(bool bInHistory)
{
EditBox.SetHistory(bInHistory);
}
function SetEditTextColor(Color NewColor)
{
EditBox.SetTextColor(NewColor);
}
function Clear()
{
EditBox.Clear();
}
function string GetValue()
{
return EditBox.GetValue();
}
function SetValue(string NewValue)
{
EditBox.SetValue(NewValue);
}
function SetMaxLength(int MaxLength)
{
EditBox.MaxLength = MaxLength;
}
function Paint(Canvas C, float X, float Y)
{
LookAndFeel.Editbox_Draw(Self, C);
Super.Paint(C, X, Y);
}
function BeforePaint(Canvas C, float X, float Y)
{
Super.BeforePaint(C, X, Y);
LookAndFeel.Editbox_SetupSizes(Self, C);
}
function SetDelayedNotify(bool bDelayedNotify)
{
Editbox.bDelayedNotify = bDelayedNotify;
}
~ k3 ~~us3 q3 I ~VP
4 -m' V ~ Nclass UWindowEditBoxHistory expands UWindowList;
var string HistoryText;
~z o3 _J 1 _D i [ _ J _ U _ fG{ _ ] [ _ j _5 [ _ n _ P _ ]6 [ =,6 [ =,6 [ =, ~ H// UWindowEditBox - simple edit box, for use in other controls such as
// UWindowComboxBoxControl, UWindowEditBoxControl etc.
class UWindowEditBox extends UWindowDialogControl;
var string Value;
var string Value2;
var int CaretOffset;
var int MaxLength;
var float LastDrawTime;
var bool bShowCaret;
var float Offset;
var UWindowDialogControl NotifyOwner;
var bool bNumericOnly;
var bool bNumericFloat;
var bool bCanEdit;
var bool bAllSelected;
var bool bSelectOnFocus;
var bool bDelayedNotify;
var bool bChangePending;
var bool bControlDown;
var bool bShiftDown;
var bool bHistory;
var bool bKeyDown;
var UWindowEditBoxHistory HistoryList;
var UWindowEditBoxHistory CurrentHistory;
function Created()
{
Super.Created();
bCanEdit = True;
bControlDown = False;
bShiftDown = False;
MaxLength = 255;
CaretOffset = 0;
Offset = 0;
LastDrawTime = GetLevel().TimeSeconds;
}
function SetHistory(bool bInHistory)
{
bHistory = bInHistory;
if(bHistory && HistoryList==None)
{
HistoryList = new(None) class'UWindowEditBoxHistory';
HistoryList.SetupSentinel();
CurrentHistory = None;
}
else
if(!bHistory && HistoryList!=None)
{
HistoryList = None;
CurrentHistory = None;
}
}
function SetEditable(bool bEditable)
{
bCanEdit = bEditable;
}
function SetValue(string NewValue, optional string NewValue2)
{
Value = NewValue;
Value2 = NewValue2;
if(CaretOffset > Len(Value))
CaretOffset = Len(Value);
Notify(DE_Change);
}
function Clear()
{
CaretOffset = 0;
Value="";
Value2="";
bAllSelected = False;
if(bDelayedNotify)
bChangePending = True;
else
Notify(DE_Change);
}
function SelectAll()
{
if(bCanEdit && Value != "")
{
CaretOffset = Len(Value);
bAllSelected = True;
}
}
function string GetValue()
{
return Value;
}
function string GetValue2()
{
return Value2;
}
function Notify(byte E)
{
if(NotifyOwner != None)
{
NotifyOwner.Notify(E);
} else {
Super.Notify(E);
}
}
function InsertText(string Text)
{
local int i;
for(i=0;i MaxLength)
return False;
CaretOffset++;
Value = NewValue;
if(bDelayedNotify)
bChangePending = True;
else
Notify(DE_Change);
return True;
}
function bool Backspace()
{
local string NewValue;
if(CaretOffset == 0) return False;
NewValue = Left(Value, CaretOffset - 1) $ Mid(Value, CaretOffset);
CaretOffset--;
Value = NewValue;
if(bDelayedNotify)
bChangePending = True;
else
Notify(DE_Change);
return True;
}
function bool Delete()
{
local string NewValue;
if(CaretOffset == Len(Value)) return False;
NewValue = Left(Value, CaretOffset) $ Mid(Value, CaretOffset + 1);
Value = NewValue;
Notify(DE_Change);
return True;
}
function bool WordLeft()
{
while(CaretOffset > 0 && Mid(Value, CaretOffset - 1, 1) == " ")
CaretOffset--;
while(CaretOffset > 0 && Mid(Value, CaretOffset - 1, 1) != " ")
CaretOffset--;
LastDrawTime = GetLevel().TimeSeconds;
bShowCaret = True;
return True;
}
function bool MoveLeft()
{
if(CaretOffset == 0) return False;
CaretOffset--;
LastDrawTime = GetLevel().TimeSeconds;
bShowCaret = True;
return True;
}
function bool MoveRight()
{
if(CaretOffset == Len(Value)) return False;
CaretOffset++;
LastDrawTime = GetLevel().TimeSeconds;
bShowCaret = True;
return True;
}
function bool WordRight()
{
while(CaretOffset < Len(Value) && Mid(Value, CaretOffset, 1) != " ")
CaretOffset++;
while(CaretOffset < Len(Value) && Mid(Value, CaretOffset, 1) == " ")
CaretOffset++;
LastDrawTime = GetLevel().TimeSeconds;
bShowCaret = True;
return True;
}
function bool MoveHome()
{
CaretOffset = 0;
LastDrawTime = GetLevel().TimeSeconds;
bShowCaret = True;
return True;
}
function bool MoveEnd()
{
CaretOffset = Len(Value);
LastDrawTime = GetLevel().TimeSeconds;
bShowCaret = True;
return True;
}
function EditCopy()
{
if(bAllSelected || !bCanEdit)
GetPlayerOwner().CopyToClipboard(Value);
}
function EditPaste()
{
if(bCanEdit)
{
if(bAllSelected)
Clear();
InsertText(GetPlayerOwner().PasteFromClipboard());
}
}
function EditCut()
{
if(bCanEdit)
{
if(bAllSelected)
{
GetPlayerOwner().CopyToClipboard(Value);
bAllSelected = False;
Clear();
}
}
else
EditCopy();
}
function KeyType( int Key, float MouseX, float MouseY )
{
if(bCanEdit && bKeyDown)
{
if( !bControlDown )
{
if(bAllSelected)
Clear();
bAllSelected = False;
if(bNumericOnly)
{
if( Key>=0x30 && Key<=0x39 )
{
Insert(Key);
}
}
else
{
if( Key>=0x20 && Key<0x80 )
{
Insert(Key);
}
}
}
}
}
function KeyUp(int Key, float X, float Y)
{
local PlayerPawn P;
bKeyDown = False;
P = GetPlayerOwner();
switch (Key)
{
case P.EInputKey.IK_Ctrl:
bControlDown = False;
break;
case P.EInputKey.IK_Shift:
bShiftDown = False;
break;
}
}
function KeyDown(int Key, float X, float Y)
{
local PlayerPawn P;
bKeyDown = True;
P = GetPlayerOwner();
switch (Key)
{
case P.EInputKey.IK_Ctrl:
bControlDown = True;
break;
case P.EInputKey.IK_Shift:
bShiftDown = True;
break;
case P.EInputKey.IK_Escape:
break;
case P.EInputKey.IK_Enter:
if(bCanEdit)
{
if(bHistory)
{
if(Value != "")
{
CurrentHistory = UWindowEditBoxHistory(HistoryList.Insert(class'UWindowEditBoxHistory'));
CurrentHistory.HistoryText = Value;
}
CurrentHistory = HistoryList;
}
Notify(DE_EnterPressed);
}
break;
case P.EInputKey.IK_MouseWheelUp:
if(bCanEdit)
Notify(DE_WheelUpPressed);
break;
case P.EInputKey.IK_MouseWheelDown:
if(bCanEdit)
Notify(DE_WheelDownPressed);
break;
case P.EInputKey.IK_Right:
if(bCanEdit)
{
if(bControlDown)
WordRight();
else
MoveRight();
}
bAllSelected = False;
break;
case P.EInputKey.IK_Left:
if(bCanEdit)
{
if(bControlDown)
WordLeft();
else
MoveLeft();
}
bAllSelected = False;
break;
case P.EInputKey.IK_Up:
if(bCanEdit && bHistory)
{
bAllSelected = False;
if(CurrentHistory != None && CurrentHistory.Next != None)
{
CurrentHistory = UWindowEditBoxHistory(CurrentHistory.Next);
SetValue(CurrentHistory.HistoryText);
MoveEnd();
}
}
break;
case P.EInputKey.IK_Down:
if(bCanEdit && bHistory)
{
bAllSelected = False;
if(CurrentHistory != None && CurrentHistory.Prev != None)
{
CurrentHistory = UWindowEditBoxHistory(CurrentHistory.Prev);
SetValue(CurrentHistory.HistoryText);
MoveEnd();
}
}
break;
case P.EInputKey.IK_Home:
if(bCanEdit)
MoveHome();
bAllSelected = False;
break;
case P.EInputKey.IK_End:
if(bCanEdit)
MoveEnd();
bAllSelected = False;
break;
case P.EInputKey.IK_Backspace:
if(bCanEdit)
{
if(bAllSelected)
Clear();
else
Backspace();
}
bAllSelected = False;
break;
case P.EInputKey.IK_Delete:
if(bCanEdit)
{
if(bAllSelected)
Clear();
else
Delete();
}
bAllSelected = False;
break;
case P.EInputKey.IK_Period:
case P.EInputKey.IK_NumPadPeriod:
if (bNumericFloat)
Insert(Asc("."));
break;
default:
if( bControlDown )
{
if( Key == Asc("c") || Key == Asc("C"))
EditCopy();
if( Key == Asc("v") || Key == Asc("V"))
EditPaste();
if( Key == Asc("x") || Key == Asc("X"))
EditCut();
}
else
{
if(NotifyOwner != None)
NotifyOwner.KeyDown(Key, X, Y);
else
Super.KeyDown(Key, X, Y);
}
break;
}
}
function Click(float X, float Y)
{
Notify(DE_Click);
}
function LMouseDown(float X, float Y)
{
Super.LMouseDown(X, Y);
Notify(DE_LMouseDown);
}
function Paint(Canvas C, float X, float Y)
{
local float W, H;
local float TextY;
C.Font = Root.Fonts[Font];
TextSize(C, "A", W, H);
TextY = (WinHeight - H) / 2;
TextSize(C, Left(Value, CaretOffset), W, H);
C.DrawColor.R = 255;
C.DrawColor.G = 255;
C.DrawColor.B = 255;
if(W + Offset < 0)
Offset = -W;
if(W + Offset > (WinWidth - 2))
{
Offset = (WinWidth - 2) - W;
if(Offset > 0) Offset = 0;
}
C.DrawColor = TextColor;
if(bAllSelected)
{
DrawStretchedTexture(C, Offset + 1, TextY, W, H, Texture'UWindow.WhiteTexture');
// Invert Colors
C.DrawColor.R = 255 ^ C.DrawColor.R;
C.DrawColor.G = 255 ^ C.DrawColor.G;
C.DrawColor.B = 255 ^ C.DrawColor.B;
}
ClipText(C, Offset + 1, TextY, Value);
if((!bHasKeyboardFocus) || (!bCanEdit))
bShowCaret = False;
else
{
if((GetLevel().TimeSeconds > LastDrawTime + 0.3) || (GetLevel().TimeSeconds < LastDrawTime))
{
LastDrawTime = GetLevel().TimeSeconds;
bShowCaret = !bShowCaret;
}
}
if(bShowCaret)
ClipText(C, Offset + W - 1, TextY, "|");
}
function Close(optional bool bByParent)
{
if(bChangePending)
{
bChangePending = False;
Notify(DE_Change);
}
bKeyDown = False;
Super.Close(bByParent);
}
function FocusOtherWindow(UWindowWindow W)
{
if(bChangePending)
{
bChangePending = False;
Notify(DE_Change);
}
if(NotifyOwner != None)
NotifyOwner.FocusOtherWindow(W);
else
Super.FocusOtherWindow(W);
}
function KeyFocusEnter()
{
if(bSelectOnFocus && !bHasKeyboardFocus)
SelectAll();
Super.KeyFocusEnter();
}
function DoubleClick(float X, float Y)
{
Super.DoubleClick(X, Y);
SelectAll();
}
function KeyFocusExit()
{
bAllSelected = False;
Super.KeyFocusExit();
}
^ " "
" " *0 "۫p ~ @ ~q u3 |h 3 ( 6 v =,6 v =,6 v =, { | - M 4O |\ * v Z Y?6 4?6
4?6 4?6 4?6 4?6
4 { 4U |} * v Z?6 O Y Y?6 O?6 A?6
4?6 4?6 4?6 4?6
4 { 4A |p * v Z Y?6 4 Y?6 4?6
4?6 4?6 4?6 4?6
4 { v | & | (?6 v $ 6 v $ 6 v $ - I | o v
W
A |3 v Z Y W
?, Y?,
'& 4M |\ * v Z Y?6 4?6
4?6 4?6 4?6 4?6
4 { 4S |} * v Z?6 M Y Y?6 M?6 J?6
4?6 4?6 4?6 4?6
4 { 4J |p * v Z Y?6 4 Y?6 4?6
4?6 4?6 4?6 4?6
4 { v | % | (?6 v $ 6 v $ 6 v $ &- I | o v
W
A |3 v Z Y W
?, Y?,
' ~ Cclass UWindowDynamicTextRow expands UWindowList;
var string Text;
var UWindowDynamicTextRow WrapParent;
var bool bRowDirty;
~ o|class UWindowDynamicTextArea expands UWindowDialogControl;
var config int MaxLines;
var bool bTopCentric;
var float DefaultTextHeight;
var bool bScrollOnResize;
var bool bVCenter;
var bool bHCenter;
var bool bAutoScrollbar;
var bool bVariableRowHeight; // Assumes !bTopCentric, !bScrollOnResize
var float WrapWidth;
// private
var UWindowDynamicTextRow List;
var UWindowVScrollBar VertSB;
var float OldW, OldH;
var bool bDirty;
var int Count;
var int VisibleRows;
var int Font;
var Font AbsoluteFont;
var color TextColor;
var class RowClass;
function Created()
{
Super.Created();
VertSB = UWindowVScrollbar(CreateWindow(class'UWindowVScrollbar', WinWidth-12, 0, 12, WinHeight));
VertSB.bAlwaysOnTop = True;
Clear();
}
function Clear()
{
bDirty = True;
if(List != None)
{
if(List.Next == None)
return;
List.DestroyList();
}
List = new RowClass;
List.SetupSentinel();
}
function SetAbsoluteFont(Font F)
{
AbsoluteFont = F;
}
function SetFont(int F)
{
Font = F;
}
function SetTextColor(Color C)
{
TextColor = C;
}
function TextAreaClipText(Canvas C, float DrawX, float DrawY, coerce string S, optional bool bCheckHotkey)
{
ClipText(C, DrawX, DrawY, S, bCheckHotkey);
}
function TextAreaTextSize(Canvas C, string Text, out float W, out float H)
{
TextSize(C, Text, W, H);
}
function BeforePaint( Canvas C, float X, float Y )
{
Super.BeforePaint(C, X, Y);
VertSB.WinTop = 0;
VertSB.WinHeight = WinHeight;
VertSB.WinWidth = LookAndFeel.Size_ScrollbarWidth;
VertSB.WinLeft = WinWidth - LookAndFeel.Size_ScrollbarWidth;
}
function Paint( Canvas C, float MouseX, float MouseY )
{
local UWindowDynamicTextRow L;
local int SkipCount, DrawCount;
local int i;
local float Y, Junk;
local bool bWrapped;
C.DrawColor = TextColor;
if(AbsoluteFont != None)
C.Font = AbsoluteFont;
else
C.Font = Root.Fonts[Font];
if(OldW != WinWidth || OldH != WinHeight)
{
WordWrap(C, True);
OldW = WinWidth;
OldH = WinHeight;
bWrapped = True;
}
else
if(bDirty)
{
WordWrap(C, False);
bWrapped = True;
}
if(bWrapped)
{
TextAreaTextSize(C, "A", Junk, DefaultTextHeight);
VisibleRows = WinHeight / DefaultTextHeight;
Count = List.Count();
VertSB.SetRange(0, Count, VisibleRows);
if(bScrollOnResize)
{
if(bTopCentric)
VertSB.Pos = 0;
else
VertSB.Pos = VertSB.MaxPos;
}
if(bAutoScrollbar && !bVariableRowHeight)
{
if(Count <= VisibleRows)
VertSB.HideWindow();
else
VertSB.ShowWindow();
}
}
if(bTopCentric)
{
SkipCount = VertSB.Pos;
L = UWindowDynamicTextRow(List.Next);
for(i=0; i < SkipCount && (L != None) ; i++)
L = UWindowDynamicTextRow(L.Next);
if(bVCenter && Count <= VisibleRows)
Y = int((WinHeight - (Count * DefaultTextHeight)) / 2);
else
Y = 1;
DrawCount = 0;
while(Y < WinHeight)
{
DrawCount++;
if(L != None)
{
Y += DrawTextLine(C, L, Y);
L = UWindowDynamicTextRow(L.Next);
}
else
Y += DefaultTextHeight;
}
if(bVariableRowHeight)
{
VisibleRows = DrawCount - 1;
while(VertSB.Pos + VisibleRows > Count)
VisibleRows--;
VertSB.SetRange(0, Count, VisibleRows);
if(bAutoScrollbar)
{
if(Count <= VisibleRows)
VertSB.HideWindow();
else
VertSB.ShowWindow();
}
}
}
else
{
SkipCount = Max(0, Count - (VisibleRows + VertSB.Pos));
L = UWindowDynamicTextRow(List.Last);
for(i=0; i < SkipCount && (L != List) ; i++)
L = UWindowDynamicTextRow(L.Prev);
Y = WinHeight - DefaultTextHeight;
while(L != List && L != None && Y > -DefaultTextHeight)
{
DrawTextLine(C, L, Y);
Y = Y - DefaultTextHeight;
L = UWindowDynamicTextRow(L.Prev);
}
}
}
function UWindowDynamicTextRow AddText(string NewLine)
{
local UWindowDynamicTextRow L;
local string Temp;
local int i;
bDirty = True;
i = InStr(NewLine, "\\n");
if(i != -1)
{
Temp = Mid(NewLine, i+2);
NewLine = Left(NewLine, i);
}
else
Temp = "";
// reuse a row if possible
L = CheckMaxRows();
if(L != None)
List.AppendItem(L);
else
L = UWindowDynamicTextRow(List.Append(RowClass));
L.Text = NewLine;
L.WrapParent = None;
L.bRowDirty = True;
if(Temp != "")
AddText(Temp);
return L;
}
function UWindowDynamicTextRow CheckMaxRows()
{
local UWindowDynamicTextRow L;
L = None;
while(MaxLines > 0 && List.Count() > MaxLines - 1 && List.Next != None)
{
L = UWindowDynamicTextRow(List.Next);
RemoveWrap(L);
L.Remove();
}
return L;
}
function WordWrap(Canvas C, bool bForce)
{
local UWindowDynamicTextRow L;
for(L = UWindowDynamicTextRow(List.Next); L != None; L = UWindowDynamicTextRow(L.Next))
if(L.WrapParent == None && (L.bRowDirty || bForce))
WrapRow(C, L);
bDirty = False;
}
function WrapRow(Canvas C, UWindowDynamicTextRow L)
{
local UWindowDynamicTextRow CurrentRow, N;
local float MaxWidth;
local int WrapPos;
if(WrapWidth == 0)
{
if(VertSB.bWindowVisible || bAutoScrollbar)
MaxWidth = WinWidth - VertSB.WinWidth;
else
MaxWidth = WinWidth;
}
else
MaxWidth = WrapWidth;
L.bRowDirty = False;
// fast check - single line?
N = UWindowDynamicTextRow(L.Next);
if(N == None || N.WrapParent != L)
{
if(GetWrapPos(C, L, MaxWidth) == -1)
return;
}
RemoveWrap(L);
CurrentRow = L;
while(True)
{
WrapPos = GetWrapPos(C, CurrentRow, MaxWidth);
if(WrapPos == -1)
break;
CurrentRow = SplitRowAt(CurrentRow, WrapPos);
}
}
///////////////////////////////////////////////////////
// Functions to override to change format/layout
///////////////////////////////////////////////////////
function float DrawTextLine(Canvas C, UWindowDynamicTextRow L, float Y)
{
local float X, W, H;
if(bHCenter)
{
TextAreaTextSize(C, L.Text, W, H);
if(VertSB.bWindowVisible)
X = int(((WinWidth - VertSB.WinWidth) - W) / 2);
else
X = int((WinWidth - W) / 2);
}
else
X = 2;
TextAreaClipText(C, X, Y, L.Text);
return DefaultTextHeight;
}
// find where to break the line
function int GetWrapPos(Canvas C, UWindowDynamicTextRow L, float MaxWidth)
{
local float W, H, LineWidth, NextWordWidth;
local string Input, NextWord;
local int WordsThisRow, WrapPos;
// quick check
TextAreaTextSize(C, L.Text, W, H);
if(W <= MaxWidth)
return -1;
Input = L.Text;
WordsThisRow = 0;
LineWidth = 0;
WrapPos = 0;
NextWord = "";
while(Input != "" || NextWord != "")
{
if(NextWord == "")
{
RemoveNextWord(Input, NextWord);
TextAreaTextSize(C, NextWord, NextWordWidth, H);
}
if(WordsThisRow > 0 && LineWidth + NextWordWidth > MaxWidth)
{
return WrapPos;
}
else
{
WrapPos += Len(NextWord);
LineWidth += NextWordWidth;
NextWord = "";
WordsThisRow++;
}
}
return -1;
}
function UWindowDynamicTextRow SplitRowAt(UWindowDynamicTextRow L, int SplitPos)
{
local UWindowDynamicTextRow N;
N = UWindowDynamicTextRow(L.InsertAfter(RowClass));
if(L.WrapParent == None)
N.WrapParent = L;
else
N.WrapParent = L.WrapParent;
N.Text = Mid(L.Text, SplitPos);
L.Text = Left(L.Text, SplitPos);
return N;
}
function RemoveNextWord(out string Text, out string NextWord)
{
local int i;
i = InStr(Text, " ");
if(i == -1)
{
NextWord = Text;
Text = "";
}
else
{
while(Mid(Text, i, 1) == " ")
i++;
NextWord = Left(Text, i);
Text = Mid(Text, i);
}
}
function RemoveWrap(UWindowDynamicTextRow L)
{
local UWindowDynamicTextRow N;
// Remove previous word-wrapping
N = UWindowDynamicTextRow(L.Next);
while(N != None && N.WrapParent == L)
{
L.Text = L.Text $ N.Text;
N.Remove();
N = UWindowDynamicTextRow(L.Next);
}
}
T5" "
" " *D "'As ~
@ ~ Z ~~ x+//=============================================================================
// UWindowDialogControl - a control which notifies a dialog control group
//=============================================================================
class UWindowDialogControl extends UWindowWindow;
var UWindowDialogClientWindow NotifyWindow;
var string Text;
var int Font;
var color TextColor;
var TextAlign Align;
var float TextX, TextY; // changed by BeforePaint functions
var bool bHasKeyboardFocus;
var bool bNoKeyboard;
var bool bAcceptExternalDragDrop;
var string HelpText;
var float MinWidth, MinHeight; // minimum heights for layout control
var UWindowDialogControl TabNext;
var UWindowDialogControl TabPrev;
function Created()
{
if(!bNoKeyboard)
SetAcceptsFocus();
}
function KeyFocusEnter()
{
Super.KeyFocusEnter();
bHasKeyboardFocus = True;
}
function KeyFocusExit()
{
Super.KeyFocusExit();
bHasKeyboardFocus = False;
}
function SetHelpText(string NewHelpText)
{
HelpText = NewHelpText;
}
function SetText(string NewText)
{
Text = NewText;
}
function BeforePaint(Canvas C, float X, float Y)
{
Super.BeforePaint(C, X, Y);
C.Font = Root.Fonts[Font];
}
function SetFont(int NewFont)
{
Font = NewFont;
}
function SetTextColor(color NewColor)
{
TextColor = NewColor;
}
function Register(UWindowDialogClientWindow W)
{
NotifyWindow = W;
Notify(DE_Created);
}
function Notify(byte E)
{
if(NotifyWindow != None)
{
NotifyWindow.Notify(Self, E);
}
}
function bool ExternalDragOver(UWindowDialogControl ExternalControl, float X, float Y)
{
return False;
}
function UWindowDialogControl CheckExternalDrag(float X, float Y)
{
local float RootX, RootY;
local float ExtX, ExtY;
local UWindowWindow W;
local UWindowDialogControl C;
WindowToGlobal(X, Y, RootX, RootY);
W = Root.FindWindowUnder(RootX, RootY);
C = UWindowDialogControl(W);
if(W != Self && C != None && C.bAcceptExternalDragDrop)
{
W.GlobalToWindow(RootX, RootY, ExtX, ExtY);
if(C.ExternalDragOver(Self, ExtX, ExtY))
return C;
}
return None;
}
function KeyDown(int Key, float X, float Y)
{
local PlayerPawn P;
local UWindowDialogControl N;
P = Root.GetPlayerOwner();
switch (Key)
{
case P.EInputKey.IK_Tab:
if(TabNext != None)
{
N = TabNext;
while(N != Self && !N.bWindowVisible)
N = N.TabNext;
N.ActivateWindow(0, False);
}
break;
default:
Super.KeyDown(Key, X, Y);
break;
}
}
function MouseMove(float X, float Y)
{
Super.MouseMove(X, Y);
Notify(DE_MouseMove);
}
function MouseEnter()
{
Super.MouseEnter();
Notify(DE_MouseEnter);
}
function MouseLeave()
{
Super.MouseLeave();
Notify(DE_MouseLeave);
}
~ Pclass UWindowDialogClientWindow extends UWindowClientWindow;
// Used for scrolling
var float DesiredWidth;
var float DesiredHeight;
var UWindowDialogControl TabLast;
function OKPressed()
{
}
function Notify(UWindowDialogControl C, byte E)
{
// Handle this notification in a subclass.
}
function UWindowDialogControl CreateControl(class ControlClass, float X, float Y, float W, float H, optional UWindowWindow OwnerWindow)
{
local UWindowDialogControl C;
C = UWindowDialogControl(CreateWindow(ControlClass, X, Y, W, H, OwnerWindow));
C.Register(Self);
C.Notify(C.DE_Created);
if(TabLast == None)
{
TabLast = C;
C.TabNext = C;
C.TabPrev = C;
}
else
{
C.TabNext = TabLast.TabNext;
C.TabPrev = TabLast;
TabLast.TabNext.TabPrev = C;
TabLast.TabNext = C;
TabLast = C;
}
return C;
}
function Paint(Canvas C, float X, float Y)
{
Super.Paint(C, X, Y);
LookAndFeel.DrawClientArea(Self, C);
}
function GetDesiredDimensions(out float W, out float H)
{
W = DesiredWidth;
H = DesiredHeight;
}
T5" "
" " *D "tu ~ @ ~
~~R1
" F q' Rb,
~ Z4 ~~ class UWindowControlFrame expands UWindowWindow;
var UWindowWindow Framed;
function SetFrame(UWindowWindow W)
{
Framed = W;
W.SetParent(Self);
}
function BeforePaint(Canvas C, float X, float Y)
{
if(Framed != None)
LookAndFeel.ControlFrame_SetupSizes(Self, C);
}
function Paint(Canvas C, float X, float Y)
{
LookAndFeel.ControlFrame_Draw(Self, C);
}
~ ~~bF4 D4) u -2
O
?% O
6 .%
.%
h
O
6 = -2O
~5V4 u ` 5 u t -O .%
.%
h
O
6 ? ~y x3 eI 9 ~ e e -t' e I ~ e O ~ e T ~ e Q ~ e RL e K_ e GL e JY ~ @class UWindowConsoleWindow extends UWindowFramedWindow;
var float OldParentWidth, OldParentHeight;
function Created()
{
Super.Created();
bSizable = True;
bStatusBar = True;
bLeaveOnScreen = True;
OldParentWidth = ParentWindow.WinWidth;
OldParentHeight = ParentWindow.WinHeight;
SetDimensions();
SetAcceptsFocus();
}
function ShowWindow()
{
Super.ShowWindow();
if(ParentWindow.WinWidth != OldParentWidth || ParentWindow.WinHeight != OldParentHeight)
{
SetDimensions();
OldParentWidth = ParentWindow.WinWidth;
OldParentHeight = ParentWindow.WinHeight;
}
}
function ResolutionChanged(float W, float H)
{
SetDimensions();
}
function SetDimensions()
{
if (ParentWindow.WinWidth < 500)
{
SetSize(200, 150);
} else {
SetSize(410, 310);
}
WinLeft = ParentWindow.WinWidth/2 - WinWidth/2;
WinTop = ParentWindow.WinHeight/2 - WinHeight/2;
}
function Close(optional bool bByParent)
{
ClientArea.Close(True);
Root.Console.HideConsole();
}
~ ~~x G4 kS : @
k k -t' k I @
k O @
k T @
k Q @
k RZ k KV k GZ k JU ~ Hclass UWindowConsoleTextAreaControl extends UWindowDynamicTextArea;
~B M)o , 8) M* w* c M ~v J4 pB4 9< B
p p -t' p I B
p O B
p T B
p Q B
p Rr p K\ p Gr p J] ~ Kclass UWindowConsoleClientWindow extends UWindowDialogClientWindow;
var UWindowConsoleTextAreaControl TextArea;
var UWindowEditControl EditControl;
function Created()
{
TextArea = UWindowConsoleTextAreaControl(CreateWindow(class'UWindowConsoleTextAreaControl', 0, 0, WinWidth, WinHeight));
EditControl = UWindowEditControl(CreateControl(class'UWindowEditControl', 0, WinHeight-16, WinWidth, 16));
EditControl.SetFont(F_Normal);
EditControl.SetNumericOnly(False);
EditControl.SetMaxLength(400);
EditControl.SetHistory(True);
}
function Notify(UWindowDialogControl C, byte E)
{
local string s;
Super.Notify(C, E);
switch(E)
{
case DE_EnterPressed:
switch(C)
{
case EditControl:
if(EditControl.GetValue() != "")
{
s = EditControl.GetValue();
Root.Console.Message( None, "> "$s, 'Console' );
EditControl.Clear();
if( !Root.Console.ConsoleCommand( s ) )
Root.Console.Message( None, Localize("Errors","Exec","Core"), 'Console' );
}
break;
}
break;
case DE_WheelUpPressed:
switch(C)
{
case EditControl:
TextArea.VertSB.Scroll(-1);
break;
}
break;
case DE_WheelDownPressed:
switch(C)
{
case EditControl:
TextArea.VertSB.Scroll(1);
break;
}
break;
}
}
function BeforePaint(Canvas C, float X, float Y)
{
Super.BeforePaint(C, X, Y);
EditControl.SetSize(WinWidth, 17);
EditControl.WinLeft = 0;
EditControl.WinTop = WinHeight - EditControl.WinHeight;
EditControl.EditBoxWidth = WinWidth;
TextArea.SetSize(WinWidth, WinHeight - EditControl.WinHeight);
}
function Paint(Canvas C, float X, float Y)
{
DrawStretchedTexture(C, 0, 0, WinWidth, WinHeight, Texture'BlackTexture');
}
~o
G' D , h D o
D i H ~C M4 uAG = A
u u -t' u I A
u O A
u T A
u Q A
u Rg u K_ u Gg u J` ~ Zclass UWindowComboRightButton extends UWindowButton;
function BeforePaint(Canvas C, float X, float Y)
{
LookAndFeel.Combo_SetupRightButton(Self);
}
function LMouseDown(float X, float Y)
{
local int i;
Super.LMouseDown(X, Y);
if(!bDisabled)
{
i = UWindowComboControl(OwnerWindow).GetSelectedIndex();
i++;
if(i >= UWindowComboControl(OwnerWindow).List.Items.Count())
i = 0;
UWindowComboControl(OwnerWindow).SetSelectedIndex(i);
}
}
~ I4 ~~t P4 _z[ ? N _ E
E _b * D _ _ ?6 E
?6 E
?6 E
?6
E
N _ -u _6 e D _ z- _ W N ~ S class UWindowComboListItem extends UWindowList;
var string Value;
var string Value2; // A second, non-displayed value
var int SortWeight;
var float ItemTop;
function int Compare(UWindowList T, UWindowList B)
{
local UWindowComboListItem TI, BI;
local string TS, BS;
TI = UWindowComboListItem(T);
BI = UWindowComboListItem(B);
if(TI.SortWeight == BI.SortWeight)
{
TS = caps(TI.Value);
BS = caps(BI.Value);
if(TS == BS)
return 0;
if(TS < BS)
return -1;
return 1;
}
else
return TI.SortWeight - BI.SortWeight;
}
~ R4 ~~uW4 U4 A ~VO
= -m' V ~r S4 Xyk d@ K X F
E Xb * U X X ?6 F
?6 F
?6 F
?6
F
K X -j X6 e U X E X P- K ~ zfclass UWindowComboList extends UWindowListControl;
var UWindowComboControl Owner;
var UWindowVScrollBar VertSB;
var UWindowComboListItem Selected;
var int ItemHeight;
var int VBorder;
var int HBorder;
var int TextBorder;
var int MaxVisible;
function Sort()
{
Items.Sort();
}
function WindowShown()
{
Super.WindowShown();
FocusWindow();
}
function Clear()
{
Items.Clear();
}
function Texture GetLookAndFeelTexture()
{
return LookAndFeel.Active;
}
function Setup()
{
VertSB = UWindowVScrollBar(CreateWindow(class'UWindowVScrollBar', 0, WinWidth - 16, 16, WinHeight));
}
function Created()
{
ListClass = class'UWindowComboListItem';
bAlwaysOnTop = True;
bTransient = True;
Super.Created();
ItemHeight = 15;
VBorder = 3;
HBorder = 3;
TextBorder = 9;
Super.Created();
}
function int FindItemIndex(string Value, optional bool bIgnoreCase)
{
local UWindowComboListItem I;
local int Count;
I = UWindowComboListItem(Items.Next);
Count = 0;
while(I != None)
{
if(bIgnoreCase && I.Value ~= Value) return Count;
if(I.Value == Value) return Count;
Count++;
I = UWindowComboListItem(I.Next);
}
return -1;
}
function int FindItemIndex2(string Value2, optional bool bIgnoreCase)
{
local UWindowComboListItem I;
local int Count;
I = UWindowComboListItem(Items.Next);
Count = 0;
while(I != None)
{
if(bIgnoreCase && I.Value2 ~= Value2) return Count;
if(I.Value2 == Value2) return Count;
Count++;
I = UWindowComboListItem(I.Next);
}
return -1;
}
function string GetItemValue(int Index)
{
local UWindowComboListItem I;
local int Count;
I = UWindowComboListItem(Items.Next);
Count = 0;
while(I != None)
{
if(Count == Index) return I.Value;
Count++;
I = UWindowComboListItem(I.Next);
}
return "";
}
function RemoveItem(int Index)
{
local UWindowComboListItem I;
local int Count;
if(Index == -1)
return;
I = UWindowComboListItem(Items.Next);
Count = 0;
while(I != None)
{
if(Count == Index)
{
I.Remove();
return;
}
Count++;
I = UWindowComboListItem(I.Next);
}
}
function string GetItemValue2(int Index)
{
local UWindowComboListItem I;
local int Count;
I = UWindowComboListItem(Items.Next);
Count = 0;
while(I != None)
{
if(Count == Index) return I.Value2;
Count++;
I = UWindowComboListItem(I.Next);
}
return "";
}
function AddItem(string Value, optional string Value2, optional int SortWeight)
{
local UWindowComboListItem I;
I = UWindowComboListItem(Items.Append(class'UWindowComboListItem'));
I.Value = Value;
I.Value2 = Value2;
I.SortWeight = SortWeight;
}
function InsertItem(string Value, optional string Value2, optional int SortWeight)
{
local UWindowComboListItem I;
I = UWindowComboListItem(Items.Insert(class'UWindowComboListItem'));
I.Value = Value;
I.Value2 = Value2;
I.SortWeight = SortWeight;
}
function SetSelected(float X, float Y)
{
local UWindowComboListItem NewSelected, Item;
local int i, Count;
Count = 0;
for( Item = UWindowComboListItem(Items.Next);Item != None; Item = UWindowComboListItem(Item.Next) )
Count++;
i = (Y - VBorder) / ItemHeight + VertSB.Pos;
if(i < 0)
i = 0;
if(i >= VertSB.Pos + Min(Count, MaxVisible))
i = VertSB.Pos + Min(Count, MaxVisible) - 1;
NewSelected = UWindowComboListItem(Items.FindEntry(i));
if(NewSelected != Selected)
{
if(NewSelected == None)
Selected = None;
else
Selected = NewSelected;
}
}
function MouseMove(float X, float Y)
{
Super.MouseMove(X, Y);
if(Y > WinHeight) VertSB.Scroll(1);
if(Y < 0) VertSB.Scroll(-1);
SetSelected(X, Y);
FocusWindow();
}
function LMouseUp(float X, float Y)
{
If(Y >= 0 && Y <= WinHeight && Selected != None)
{
ExecuteItem(Selected);
}
Super.LMouseUp(X, Y);
}
function LMouseDown(float X, float Y)
{
Root.CaptureMouse();
}
function BeforePaint(Canvas C, float X, float Y)
{
local float W, H, MaxWidth;
local int Count;
local UWindowComboListItem I;
local float ListX, ListY;
local float ExtraWidth;
C.Font = Root.Fonts[F_Normal];
C.SetPos(0, 0);
MaxWidth = Owner.EditBoxWidth;
ExtraWidth = ((HBorder + TextBorder) * 2);
Count = Items.Count();
if(Count > MaxVisible)
{
ExtraWidth += LookAndFeel.Size_ScrollbarWidth;
WinHeight = (ItemHeight * MaxVisible) + (VBorder * 2);
}
else
{
VertSB.Pos = 0;
WinHeight = (ItemHeight * Count) + (VBorder * 2);
}
for( I = UWindowComboListItem(Items.Next);I != None; I = UWindowComboListItem(I.Next) )
{
TextSize(C, RemoveAmpersand(I.Value), W, H);
if(W + ExtraWidth > MaxWidth)
MaxWidth = W + ExtraWidth;
}
WinWidth = MaxWidth;
ListX = Owner.EditAreaDrawX + Owner.EditBoxWidth - WinWidth;
ListY = Owner.Button.WinTop + Owner.Button.WinHeight;
if(Count > MaxVisible)
{
VertSB.ShowWindow();
VertSB.SetRange(0, Count, MaxVisible);
VertSB.WinLeft = WinWidth - LookAndFeel.Size_ScrollbarWidth - HBorder;
VertSB.WinTop = HBorder;
VertSB.WinWidth = LookAndFeel.Size_ScrollbarWidth;
VertSB.WinHeight = WinHeight - 2*VBorder;
}
else
{
VertSB.HideWindow();
}
Owner.WindowToGlobal(ListX, ListY, WinLeft, WinTop);
}
function Paint(Canvas C, float X, float Y)
{
local int Count;
local UWindowComboListItem I;
DrawMenuBackground(C);
Count = 0;
for( I = UWindowComboListItem(Items.Next);I != None; I = UWindowComboListItem(I.Next) )
{
if(VertSB.bWindowVisible)
{
if(Count >= VertSB.Pos)
DrawItem(C, I, HBorder, VBorder + (ItemHeight * (Count - VertSB.Pos)), WinWidth - (2 * HBorder) - VertSB.WinWidth, ItemHeight);
}
else
DrawItem(C, I, HBorder, VBorder + (ItemHeight * Count), WinWidth - (2 * HBorder), ItemHeight);
Count++;
}
}
function DrawMenuBackground(Canvas C)
{
LookAndFeel.ComboList_DrawBackground(Self, C);
}
function DrawItem(Canvas C, UWindowList Item, float X, float Y, float W, float H)
{
LookAndFeel.ComboList_DrawItem(Self, C, X, Y, W, H, UWindowComboListItem(Item).Value, Selected == Item);
}
function ExecuteItem(UWindowComboListItem I)
{
Owner.SetValue(I.Value, I.Value2);
CloseUp();
}
function CloseUp()
{
Owner.CloseUp();
}
function FocusOtherWindow(UWindowWindow W)
{
Super.FocusOtherWindow(W);
if(bWindowVisible && W.ParentWindow.ParentWindow != Self && W.ParentWindow != Self && W.ParentWindow != Owner)
CloseUp();
}
~ ~~ ~~be4 [4) w -2
R ?% R 6 .%
.%
h
R 6 = -2R ~j X4 hvz A O G
h h S h - h a h h h
?, h h -t' h I G
h O G
h T G
h Q G
h Rr h K\ h Gr h J] ~ [class UWindowComboLeftButton extends UWindowButton;
function BeforePaint(Canvas C, float X, float Y)
{
LookAndFeel.Combo_SetupLeftButton(Self);
}
function LMouseDown(float X, float Y)
{
local int i;
Super.LMouseDown(X, Y);
if(!bDisabled)
{
i = UWindowComboControl(OwnerWindow).GetSelectedIndex();
i--;
if(i < 0)
i = UWindowComboControl(OwnerWindow).List.Items.Count() - 1;
UWindowComboControl(OwnerWindow).SetSelectedIndex(i);
}
}
~ g4 tW + %-u() wO*O ~j]4 _h C J H
_ _ S _ - _ a _ _ _
_ _ -t' _ I H
_ O H
_ T H
_ Q H
_ Rg _ K_ _ Gg _ J` ~ l@class UWindowComboControl extends UWindowDialogControl;
var float EditBoxWidth;
var float EditAreaDrawX, EditAreaDrawY;
var UWindowEditBox EditBox;
var UWindowComboButton Button;
var UWindowComboLeftButton LeftButton;
var UWindowComboRightButton RightButton;
var class ListClass;
var UWindowComboList List;
var bool bListVisible;
var bool bCanEdit;
var bool bButtons;
function Created()
{
Super.Created();
EditBox = UWindowEditBox(CreateWindow(class'UWindowEditBox', 0, 0, WinWidth-12, WinHeight));
EditBox.NotifyOwner = Self;
EditBoxWidth = WinWidth / 2;
EditBox.bTransient = True;
Button = UWindowComboButton(CreateWindow(class'UWindowComboButton', WinWidth-12, 0, 12, 10));
Button.Owner = Self;
List = UWindowComboList(Root.CreateWindow(ListClass, 0, 0, 100, 100));
List.LookAndFeel = LookAndFeel;
List.Owner = Self;
List.Setup();
List.HideWindow();
bListVisible = False;
SetEditTextColor(LookAndFeel.EditBoxTextColor);
}
function SetButtons(bool bInButtons)
{
bButtons = bInButtons;
if(bInButtons)
{
LeftButton = UWindowComboLeftButton(CreateWindow(class'UWindowComboLeftButton', WinWidth-12, 0, 12, 10));
RightButton = UWindowComboRightButton(CreateWindow(class'UWindowComboRightButton', WinWidth-12, 0, 12, 10));
}
else
{
LeftButton = None;
RightButton = None;
}
}
function Notify(byte E)
{
Super.Notify(E);
if(E == DE_LMouseDown)
{
if(!bListVisible)
{
if(!bCanEdit)
{
DropDown();
Root.CaptureMouse(List);
}
}
else
CloseUp();
}
}
function int FindItemIndex(string V, optional bool bIgnoreCase)
{
return List.FindItemIndex(V, bIgnoreCase);
}
function RemoveItem(int Index)
{
List.RemoveItem(Index);
}
function int FindItemIndex2(string V2, optional bool bIgnoreCase)
{
return List.FindItemIndex2(V2, bIgnoreCase);
}
function Close(optional bool bByParent)
{
if(bByParent && bListVisible)
CloseUp();
Super.Close(bByParent);
}
function SetNumericOnly(bool bNumericOnly)
{
EditBox.bNumericOnly = bNumericOnly;
}
function SetNumericFloat(bool bNumericFloat)
{
EditBox.bNumericFloat = bNumericFloat;
}
function SetFont(int NewFont)
{
Super.SetFont(NewFont);
EditBox.SetFont(NewFont);
}
function SetEditTextColor(Color NewColor)
{
EditBox.SetTextColor(NewColor);
}
function SetEditable(bool bNewCanEdit)
{
bCanEdit = bNewCanEdit;
EditBox.SetEditable(bCanEdit);
}
function int GetSelectedIndex()
{
return List.FindItemIndex(GetValue());
}
function SetSelectedIndex(int Index)
{
SetValue(List.GetItemValue(Index), List.GetItemValue2(Index));
}
function string GetValue()
{
return EditBox.GetValue();
}
function string GetValue2()
{
return EditBox.GetValue2();
}
function SetValue(string NewValue, optional string NewValue2)
{
EditBox.SetValue(NewValue, NewValue2);
}
function SetMaxLength(int MaxLength)
{
EditBox.MaxLength = MaxLength;
}
function Paint(Canvas C, float X, float Y)
{
LookAndFeel.Combo_Draw(Self, C);
Super.Paint(C, X, Y);
}
function AddItem(string S, optional string S2, optional int SortWeight)
{
List.AddItem(S, S2, SortWeight);
}
function InsertItem(string S, optional string S2, optional int SortWeight)
{
List.InsertItem(S, S2, SortWeight);
}
function BeforePaint(Canvas C, float X, float Y)
{
Super.BeforePaint(C, X, Y);
LookAndFeel.Combo_SetupSizes(Self, C);
List.bLeaveOnscreen = bListVisible && bLeaveOnscreen;
}
function CloseUp()
{
bListVisible = False;
EditBox.SetEditable(bCanEdit);
EditBox.SelectAll();
List.HideWindow();
}
function DropDown()
{
bListVisible = True;
EditBox.SetEditable(False);
List.ShowWindow();
}
function Sort()
{
List.Sort();
}
function ClearValue()
{
EditBox.Clear();
}
function Clear()
{
List.Clear();
EditBox.Clear();
}
function FocusOtherWindow(UWindowWindow W)
{
Super.FocusOtherWindow(W);
if(bListVisible && W.ParentWindow != Self && W != List && W.ParentWindow != List)
CloseUp();
}
~CH2 S @
K z C S v. z _. S _ y . S [R S j y . S _ y . z [ y z ~i`4 U
g E H @ H U
z ?6
U6
S?, H^ ] U
?, U
U
z ?6
U6
S?, ~ y' 11 ~5q4 z b 5 z w -O .%
.%
h
R 6 ? ~i c4 K
a G R K
G e G a K
K
a K
~ k eP " -u' -~ O ~ z ~~ ~A~m f4 Gi H s p G % G (? G o p F s Y E sU D Y ~ ~~ k4 ~~db4 x { S |. x w |* r | F x . x _. | _ |. | d x ~ p y ~ B ~~ l4 ~~us4 p4 B ~A!j4 O| H = O2 X ~ A O ?, A ` ~VR
: -m' V ~ i w a ~h r4 gQ I M r g 1 [ g i V I
? W2 g% i V I
\?& ? Z2 g- X V I
?& ? \?, A Y2 V % g (?6 V $ 6 V $ 6 V $ g9 V I
? g b, @ [ {' ~ u
class UWindowComboButton extends UWindowButton;
var UWindowComboControl Owner;
function BeforePaint(Canvas C, float X, float Y)
{
LookAndFeel.Combo_GetButtonBitmaps(Self);
bMouseDown = Owner.bListVisible;
}
function LMouseDown(float X, float Y)
{
if(!bDisabled)
{
if(Owner.bListVisible)
Owner.CloseUp();
else
{
Owner.DropDown();
Root.CaptureMouse(Owner.List);
}
}
}
function Click(float X, float Y)
{
}
function FocusOtherWindow(UWindowWindow W)
{
Super.FocusOtherWindow(W);
if(Owner.bListVisible && W.ParentWindow != Owner && W.ParentWindow != Owner.List && W.ParentWindow.ParentWindow != Owner.List)
Owner.CloseUp();
}
~5o/ e r 5 e } -O .
.
l U
E ? ~p[ j* 2 [R
~ \ ~~ ~~ V ~~ k//=============================================================================
// UWindowClientWindow - a blanked client-area window.
//=============================================================================
class UWindowClientWindow extends UWindowWindow;
#exec TEXTURE IMPORT NAME=Background FILE=Textures\Background.pcx GROUP="Icons" MIPS=OFF
function Close(optional bool bByParent)
{
if(!bByParent)
ParentWindow.Close(bByParent);
Super.Close(bByParent);
}
~du4 y^ XK y i ^ Y y2 X ^ @ y ?, @ ^ y( i ^ y ?, ] y( i ^ y ?, Z y@ X ^ @ y ?, y ?, @ \ y6 i ^ y ?, y ?, X y2 X ^ @ @ y ?, _ y@ X ^ y ?, @ @ y ?, [ y@ X ^ @ @ y ?, y ?, b ~ R
//=============================================================================
// UWindowCheckbox - a checkbox
//=============================================================================
class UWindowCheckbox extends UWindowButton;
var bool bChecked;
function BeforePaint(Canvas C, float X, float Y)
{
LookAndFeel.Checkbox_SetupSizes(Self, C);
Super.BeforePaint(C, X, Y);
}
function Paint(Canvas C, float X, float Y)
{
LookAndFeel.Checkbox_Draw(Self, C);
Super.Paint(C, X, Y);
}
function LMouseUp(float X, float Y)
{
if(!bDisabled)
{
bChecked = !bChecked;
Notify(DE_Change);
}
Super.LMouseUp(X, Y);
}
~ h C;
local Object O;
i = InStr(Text, ",");
if(i == -1)
{
ObjectClass=Text;
Text="";
}
else
{
ObjectClass=Left(Text, i);
Text=Mid(Text, i+1);
}
//Log("Class: "$ObjectClass);
C = class