author | sheepluva |
Sun, 15 May 2016 13:18:34 +0200 | |
changeset 11826 | d8844d4c67de |
parent 11781 | f2031643fe98 |
child 11840 | 8f7e28428f3e |
permissions | -rw-r--r-- |
942 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
11046 | 3 |
* Copyright (c) 2004-2015 Andrey Korotaev <unC0Rr@gmail.com> |
942 | 4 |
* |
5 |
* This program is free software; you can redistribute it and/or modify |
|
6 |
* it under the terms of the GNU General Public License as published by |
|
7 |
* the Free Software Foundation; version 2 of the License |
|
8 |
* |
|
9 |
* This program is distributed in the hope that it will be useful, |
|
10 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
12 |
* GNU General Public License for more details. |
|
13 |
* |
|
14 |
* You should have received a copy of the GNU General Public License |
|
15 |
* along with this program; if not, write to the Free Software |
|
10108
c68cf030eded
update FSF address. note: two sdl include files (by Sam Lantinga) still have the old FSF address in their copyright - but I ain't gonna touch their copyright headers
sheepluva
parents:
10104
diff
changeset
|
16 |
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
942 | 17 |
*) |
18 |
||
2630 | 19 |
{$INCLUDE "options.inc"} |
20 |
||
942 | 21 |
unit uChat; |
22 |
||
23 |
interface |
|
9699
fab319c85a39
Accept SDL_TEXTINPUT events for chat (why first and only first chat invocation receives event for 't' key?)
unc0rr
parents:
9697
diff
changeset
|
24 |
uses SDLh; |
942 | 25 |
|
3038 | 26 |
procedure initModule; |
27 |
procedure freeModule; |
|
6379 | 28 |
procedure ReloadLines; |
8738 | 29 |
procedure CleanupInput; |
942 | 30 |
procedure AddChatString(s: shortstring); |
31 |
procedure DrawChat; |
|
11356 | 32 |
procedure KeyPressChat(keysym: TSDL_Keysym); |
9669 | 33 |
procedure SendHogSpeech(s: shortstring); |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
34 |
procedure CopyToClipboard(var newContent: shortstring); |
9699
fab319c85a39
Accept SDL_TEXTINPUT events for chat (why first and only first chat invocation receives event for 't' key?)
unc0rr
parents:
9697
diff
changeset
|
35 |
procedure TextInput(var event: TSDL_TextInputEvent); |
fab319c85a39
Accept SDL_TEXTINPUT events for chat (why first and only first chat invocation receives event for 't' key?)
unc0rr
parents:
9697
diff
changeset
|
36 |
|
942 | 37 |
implementation |
11342 | 38 |
uses uInputHandler, uTypes, uVariables, uCommands, uUtils, uTextures, uRender, uIO, uScript, uRenderUtils; |
942 | 39 |
|
990
dfa6a6fe1542
Implement history for chat (27 entries), no key binding yet
unc0rr
parents:
988
diff
changeset
|
40 |
const MaxStrIndex = 27; |
10921 | 41 |
MaxInputStrLen = 200; |
942 | 42 |
|
946 | 43 |
type TChatLine = record |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
44 |
Tex: PTexture; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
45 |
Time: Longword; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
46 |
Width: LongInt; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
47 |
s: shortstring; |
10303 | 48 |
Color: TSDL_Color; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
49 |
end; |
9954 | 50 |
TChatCmd = (ccQuit, ccPause, ccFinish, ccShowHistory, ccFullScreen); |
942 | 51 |
|
946 | 52 |
var Strs: array[0 .. MaxStrIndex] of TChatLine; |
3539 | 53 |
MStrs: array[0 .. MaxStrIndex] of shortstring; |
8740
3eb1891f81ef
use a local storage for chat history which prevents mix ups in netgame and simplifies code
koda
parents:
8739
diff
changeset
|
54 |
LocalStrs: array[0 .. MaxStrIndex] of shortstring; |
3539 | 55 |
missedCount: LongWord; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
56 |
lastStr: LongWord; |
9145 | 57 |
localLastStr: LongInt; |
58 |
history: LongInt; |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
59 |
visibleCount: LongWord; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
60 |
InputStr: TChatLine; |
4814
e19791f08443
smaller rearrangement of (non stereo related) variables
koda
parents:
4467
diff
changeset
|
61 |
ChatReady: boolean; |
e19791f08443
smaller rearrangement of (non stereo related) variables
koda
parents:
4467
diff
changeset
|
62 |
showAll: boolean; |
10312 | 63 |
liveLua: boolean; |
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
64 |
ChatHidden: boolean; |
10842
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
65 |
firstDraw: boolean; |
10852
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
66 |
InputLinePrefix: TChatLine; |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
67 |
// cursor |
10836 | 68 |
cursorPos, cursorX, selectedPos, selectionDx: LongInt; |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
69 |
LastKeyPressTick: LongWord; |
942 | 70 |
|
71 |
||
8152 | 72 |
const |
11781 | 73 |
colors: array[#0..#12] of TSDL_Color = ( |
11022 | 74 |
(r:$FF; g:$FF; b:$FF; a:$FF), // #0 unused, feel free to take it for anything |
75 |
(r:$FF; g:$FF; b:$FF; a:$FF), // #1 chat message [White] |
|
76 |
(r:$FF; g:$00; b:$FF; a:$FF), // #2 action message [Purple] |
|
77 |
(r:$90; g:$FF; b:$90; a:$FF), // #3 join/leave message [Lime] |
|
78 |
(r:$FF; g:$FF; b:$A0; a:$FF), // #4 team message [Light Yellow] |
|
79 |
(r:$FF; g:$00; b:$00; a:$FF), // #5 error messages [Red] |
|
80 |
(r:$00; g:$FF; b:$FF; a:$FF), // #6 input line [Light Blue] |
|
81 |
(r:$FF; g:$80; b:$80; a:$FF), // #7 team gone [Light Red] |
|
82 |
(r:$FF; g:$D0; b:$80; a:$FF), // #8 team back [Light Orange] |
|
11781 | 83 |
(r:$DF; g:$DF; b:$DF; a:$FF), // #9 hog speech [Light Gray] |
84 |
(r:$FF; g:$00; b:$FF; a:$AF), // #10 music credits [Purple] |
|
85 |
(r:$00; g:$FF; b:$FF; a:$AF), // #11 map credits [Light Blue] |
|
86 |
(r:$FF; g:$D0; b:$80; a:$AF) // #12 theme credits [Light Orange] |
|
8152 | 87 |
); |
88 |
ChatCommandz: array [TChatCmd] of record |
|
89 |
ChatCmd: string[31]; |
|
90 |
ProcedureCallChatCmd: string[31]; |
|
91 |
end = ( |
|
92 |
(ChatCmd: '/quit'; ProcedureCallChatCmd: 'halt'), |
|
93 |
(ChatCmd: '/pause'; ProcedureCallChatCmd: 'pause'), |
|
94 |
(ChatCmd: '/finish'; ProcedureCallChatCmd: 'finish'), |
|
9569 | 95 |
(ChatCmd: '/history'; ProcedureCallChatCmd: 'history'), |
8152 | 96 |
(ChatCmd: '/fullscreen'; ProcedureCallChatCmd: 'fullscr') |
97 |
); |
|
2396 | 98 |
|
10303 | 99 |
|
100 |
const Padding = 2; |
|
101 |
ClHeight = 2 * Padding + 16; // font height |
|
102 |
||
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
103 |
// relevant for UTF-8 handling |
10921 | 104 |
function IsFirstCharByte(c: char): boolean; inline; |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
105 |
begin |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
106 |
// based on https://en.wikipedia.org/wiki/UTF-8#Description |
10921 | 107 |
IsFirstCharByte:= (byte(c) and $C0) <> $80; |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
108 |
end; |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
109 |
|
10866 | 110 |
function charIsForHogSpeech(c: char): boolean; |
111 |
begin |
|
112 |
exit((c = '"') or (c = '''') or (c = '-')); |
|
113 |
end; |
|
114 |
||
10836 | 115 |
procedure ResetSelection(); |
942 | 116 |
begin |
10836 | 117 |
selectedPos:= -1; |
118 |
end; |
|
119 |
||
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
120 |
procedure UpdateCursorCoords(); |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
121 |
var font: THWFont; |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
122 |
str : shortstring; |
10836 | 123 |
coff, soff: LongInt; |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
124 |
begin |
10836 | 125 |
if cursorPos = selectedPos then |
126 |
ResetSelection(); |
|
2396 | 127 |
|
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
128 |
// calculate cursor offset |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
129 |
|
10852
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
130 |
str:= InputStr.s; |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
131 |
font:= CheckCJKFont(ansistring(str), fnt16); |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
132 |
|
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
133 |
// get only substring before cursor to determine length |
10852
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
134 |
// SetLength(str, cursorPos); // makes pas2c unhappy |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
135 |
str[0]:= char(cursorPos); |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
136 |
// get render size of text |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
137 |
TTF_SizeUTF8(Fontz[font].Handle, Str2PChar(str), @coff, nil); |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
138 |
|
10842
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
139 |
cursorX:= 2 + coff; |
990
dfa6a6fe1542
Implement history for chat (27 entries), no key binding yet
unc0rr
parents:
988
diff
changeset
|
140 |
|
10836 | 141 |
// calculate selection width on screen |
142 |
if selectedPos >= 0 then |
|
143 |
begin |
|
144 |
if selectedPos > cursorPos then |
|
10852
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
145 |
str:= InputStr.s; |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
146 |
// SetLength(str, selectedPos); // makes pas2c unhappy |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
147 |
str[0]:= char(selectedPos); |
10836 | 148 |
TTF_SizeUTF8(Fontz[font].Handle, Str2PChar(str), @soff, nil); |
149 |
selectionDx:= soff - coff; |
|
150 |
end |
|
151 |
else |
|
152 |
selectionDx:= 0; |
|
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
153 |
end; |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
154 |
|
10836 | 155 |
|
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
156 |
procedure ResetCursor(); |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
157 |
begin |
10836 | 158 |
ResetSelection(); |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
159 |
cursorPos:= 0; |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
160 |
UpdateCursorCoords(); |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
161 |
end; |
2396 | 162 |
|
10985
c5348fe9077c
fix chat lines losing color information on texture reload
sheepluva
parents:
10926
diff
changeset
|
163 |
(* This procedure [re]renders a texture showing str for the chat line cl. |
c5348fe9077c
fix chat lines losing color information on texture reload
sheepluva
parents:
10926
diff
changeset
|
164 |
* It will use the color stored in cl and update width |
c5348fe9077c
fix chat lines losing color information on texture reload
sheepluva
parents:
10926
diff
changeset
|
165 |
*) |
10303 | 166 |
procedure RenderChatLineTex(var cl: TChatLine; var str: shortstring); |
167 |
var strSurface, |
|
168 |
resSurface: PSDL_Surface; |
|
169 |
dstrect : TSDL_Rect; // destination rectangle for blitting |
|
170 |
font : THWFont; |
|
171 |
const |
|
172 |
shadowint = $80 shl AShift; |
|
173 |
begin |
|
174 |
||
10985
c5348fe9077c
fix chat lines losing color information on texture reload
sheepluva
parents:
10926
diff
changeset
|
175 |
FreeAndNilTexture(cl.Tex); |
c5348fe9077c
fix chat lines losing color information on texture reload
sheepluva
parents:
10926
diff
changeset
|
176 |
|
10303 | 177 |
font:= CheckCJKFont(ansistring(str), fnt16); |
178 |
||
179 |
// get render size of text |
|
180 |
TTF_SizeUTF8(Fontz[font].Handle, Str2PChar(str), @cl.Width, nil); |
|
945
4ead9cde4e14
- Start chat implementation: chat strings are on the screen
unc0rr
parents:
942
diff
changeset
|
181 |
|
10303 | 182 |
// calculate and save size |
183 |
cl.Width := cl.Width + 2 * Padding; |
|
184 |
||
185 |
// create surface to draw on |
|
186 |
resSurface:= SDL_CreateRGBSurface( |
|
187 |
0, toPowerOf2(cl.Width), toPowerOf2(ClHeight), |
|
188 |
32, RMask, GMask, BMask, AMask); |
|
945
4ead9cde4e14
- Start chat implementation: chat strings are on the screen
unc0rr
parents:
942
diff
changeset
|
189 |
|
10303 | 190 |
// define area we want to draw in |
191 |
dstrect.x:= 0; |
|
192 |
dstrect.y:= 0; |
|
193 |
dstrect.w:= cl.Width; |
|
194 |
dstrect.h:= ClHeight; |
|
195 |
||
196 |
// draw background |
|
197 |
SDL_FillRect(resSurface, @dstrect, shadowint); |
|
198 |
||
199 |
// create and blit text |
|
10370 | 200 |
strSurface:= TTF_RenderUTF8_Blended(Fontz[font].Handle, Str2PChar(str), cl.color); |
10737 | 201 |
//SDL_UpperBlit(strSurface, nil, resSurface, @dstrect); |
11481 | 202 |
if strSurface <> nil then copyToXY(strSurface, resSurface, Padding, Padding); |
1118 | 203 |
SDL_FreeSurface(strSurface); |
204 |
||
2290
bf87ca44782e
Selectively enable clamping - seeing if this helps avoid weird flake problems while still fixing vertical lines in waves and sky
nemo
parents:
2161
diff
changeset
|
205 |
cl.Tex:= Surface2Tex(resSurface, false); |
1431 | 206 |
|
1118 | 207 |
SDL_FreeSurface(resSurface) |
946 | 208 |
end; |
209 |
||
10303 | 210 |
const ClDisplayDuration = 12500; |
11781 | 211 |
CreditsDisplayDur = 2500; |
2396 | 212 |
|
990
dfa6a6fe1542
Implement history for chat (27 entries), no key binding yet
unc0rr
parents:
988
diff
changeset
|
213 |
procedure SetLine(var cl: TChatLine; str: shortstring; isInput: boolean); |
10303 | 214 |
var color : TSDL_Color; |
11781 | 215 |
credits: boolean; |
942 | 216 |
begin |
11781 | 217 |
credits:= false; |
2396 | 218 |
if isInput then |
6379 | 219 |
begin |
10303 | 220 |
cl.s:= str; |
5392 | 221 |
color:= colors[#6]; |
10852
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
222 |
str:= str + ' '; |
6379 | 223 |
end |
2664
949c189ba568
powerpc and gameserver compilation disabled temporarily
koda
parents:
2630
diff
changeset
|
224 |
else |
6379 | 225 |
begin |
10863
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
226 |
if str[1] <= High(colors) then |
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
227 |
begin |
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
228 |
color:= colors[str[1]]; |
11781 | 229 |
credits:= (str[1] >= #10) and (str[1] <= #12); |
10863
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
230 |
delete(str, 1, 1); |
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
231 |
end |
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
232 |
// fallback if invalid color |
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
233 |
else |
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
234 |
color:= colors[Low(colors)]; |
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
235 |
|
10303 | 236 |
cl.s:= str; |
6379 | 237 |
end; |
2396 | 238 |
|
10303 | 239 |
cl.color:= color; |
945
4ead9cde4e14
- Start chat implementation: chat strings are on the screen
unc0rr
parents:
942
diff
changeset
|
240 |
|
10303 | 241 |
// set texture, note: variables cl.s and str will be different here if isInput |
242 |
RenderChatLineTex(cl, str); |
|
1118 | 243 |
|
11781 | 244 |
if credits then |
245 |
cl.Time:= RealTicks + CreditsDisplayDur |
|
246 |
else |
|
247 |
cl.Time:= RealTicks + ClDisplayDuration; |
|
946 | 248 |
end; |
249 |
||
6379 | 250 |
// For uStore texture recreation |
251 |
procedure ReloadLines; |
|
10985
c5348fe9077c
fix chat lines losing color information on texture reload
sheepluva
parents:
10926
diff
changeset
|
252 |
var i: LongWord; |
6379 | 253 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
254 |
if InputStr.s <> '' then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
255 |
SetLine(InputStr, InputStr.s, true); |
6381 | 256 |
for i:= 0 to MaxStrIndex do |
257 |
if Strs[i].s <> '' then |
|
258 |
begin |
|
10985
c5348fe9077c
fix chat lines losing color information on texture reload
sheepluva
parents:
10926
diff
changeset
|
259 |
RenderChatLineTex(Strs[i], Strs[i].s); |
6381 | 260 |
end; |
6379 | 261 |
end; |
262 |
||
946 | 263 |
procedure AddChatString(s: shortstring); |
264 |
begin |
|
3539 | 265 |
if not ChatReady then |
266 |
begin |
|
267 |
if MissedCount < MaxStrIndex - 1 then |
|
268 |
MStrs[MissedCount]:= s |
|
269 |
else if MissedCount < MaxStrIndex then |
|
270 |
MStrs[MissedCount]:= #5 + '[...]'; |
|
271 |
inc(MissedCount); |
|
272 |
exit |
|
273 |
end; |
|
274 |
||
946 | 275 |
lastStr:= (lastStr + 1) mod (MaxStrIndex + 1); |
276 |
||
990
dfa6a6fe1542
Implement history for chat (27 entries), no key binding yet
unc0rr
parents:
988
diff
changeset
|
277 |
SetLine(Strs[lastStr], s, false); |
945
4ead9cde4e14
- Start chat implementation: chat strings are on the screen
unc0rr
parents:
942
diff
changeset
|
278 |
|
4ead9cde4e14
- Start chat implementation: chat strings are on the screen
unc0rr
parents:
942
diff
changeset
|
279 |
inc(visibleCount) |
942 | 280 |
end; |
281 |
||
10852
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
282 |
procedure UpdateInputLinePrefix(); |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
283 |
begin |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
284 |
if liveLua then |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
285 |
begin |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
286 |
InputLinePrefix.color:= colors[#1]; |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
287 |
InputLinePrefix.s:= '[Lua] >'; |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
288 |
end |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
289 |
else |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
290 |
begin |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
291 |
InputLinePrefix.color:= colors[#6]; |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
292 |
InputLinePrefix.s:= UserNick + '>'; |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
293 |
end; |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
294 |
|
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
295 |
FreeAndNilTexture(InputLinePrefix.Tex); |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
296 |
end; |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
297 |
|
942 | 298 |
procedure DrawChat; |
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
299 |
var i, t, left, top, cnt: LongInt; |
10836 | 300 |
selRect: TSDL_Rect; |
10866 | 301 |
c: char; |
942 | 302 |
begin |
3539 | 303 |
ChatReady:= true; // maybe move to somewhere else? |
1431 | 304 |
|
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
305 |
if ChatHidden and (not showAll) then |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
306 |
visibleCount:= 0; |
1431 | 307 |
|
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
308 |
// draw chat lines with some distance from screen border |
10303 | 309 |
left:= 4 - cScreenWidth div 2; |
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
310 |
top := 10 + visibleCount * ClHeight; // we start with input line (if any) |
1431 | 311 |
|
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
312 |
// draw chat input line first and under all other lines |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
313 |
if (GameState = gsChat) and (InputStr.Tex <> nil) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
314 |
begin |
10850
c76ea22ea249
copy to/paste from system clipboard (via frontend)
sheepluva
parents:
10849
diff
changeset
|
315 |
|
10852
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
316 |
if InputLinePrefix.Tex = nil then |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
317 |
RenderChatLineTex(InputLinePrefix, InputLinePrefix.s); |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
318 |
|
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
319 |
DrawTexture(left, top, InputLinePrefix.Tex); |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
320 |
inc(left, InputLinePrefix.Width); |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
321 |
DrawTexture(left, top, InputStr.Tex); |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
322 |
|
10842
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
323 |
if firstDraw then |
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
324 |
begin |
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
325 |
UpdateCursorCoords(); |
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
326 |
firstDraw:= false; |
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
327 |
end; |
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
328 |
|
10836 | 329 |
if selectedPos < 0 then |
330 |
begin |
|
331 |
// draw cursor |
|
332 |
if ((RealTicks - LastKeyPressTick) and 512) < 256 then |
|
10839
aa0ceb47da1d
make sure cursor drawing position does not get messed up by screen resize
sheepluva
parents:
10837
diff
changeset
|
333 |
DrawLineOnScreen(left + cursorX, top + 2, left + cursorX, top + ClHeight - 2, 2.0, $00, $FF, $FF, $FF); |
10836 | 334 |
end |
335 |
else // draw selection |
|
336 |
begin |
|
337 |
selRect.y:= top + 2; |
|
338 |
selRect.h:= clHeight - 4; |
|
339 |
if selectionDx < 0 then |
|
340 |
begin |
|
10839
aa0ceb47da1d
make sure cursor drawing position does not get messed up by screen resize
sheepluva
parents:
10837
diff
changeset
|
341 |
selRect.x:= left + cursorX + selectionDx; |
10836 | 342 |
selRect.w:= -selectionDx; |
343 |
end |
|
344 |
else |
|
345 |
begin |
|
10839
aa0ceb47da1d
make sure cursor drawing position does not get messed up by screen resize
sheepluva
parents:
10837
diff
changeset
|
346 |
selRect.x:= left + cursorX; |
10836 | 347 |
selRect.w:= selectionDx; |
348 |
end; |
|
1431 | 349 |
|
10836 | 350 |
DrawRect(selRect, $FF, $FF, $FF, $40, true); |
351 |
end; |
|
10852
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
352 |
|
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
353 |
dec(left, InputLinePrefix.Width); |
10866 | 354 |
|
1431 | 355 |
|
10866 | 356 |
if (Length(InputStr.s) > 0) and ((CursorPos = 1) or (CursorPos = 2)) then |
357 |
begin |
|
358 |
c:= InputStr.s[1]; |
|
359 |
if charIsForHogSpeech(c) then |
|
360 |
begin |
|
10868
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
361 |
SpeechHogNumber:= 0; |
10866 | 362 |
if Length(InputStr.s) > 1 then |
363 |
begin |
|
364 |
c:= InputStr.s[2]; |
|
365 |
if (c > '0') and (c < '9') then |
|
366 |
SpeechHogNumber:= byte(c) - 48; |
|
367 |
end; |
|
10868
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
368 |
// default to current hedgehog (if own) or first hedgehog |
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
369 |
if SpeechHogNumber = 0 then |
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
370 |
begin |
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
371 |
if not CurrentTeam^.ExtDriven then |
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
372 |
SpeechHogNumber:= CurrentTeam^.CurrHedgehog + 1 |
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
373 |
else |
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
374 |
SpeechHogNumber:= 1; |
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
375 |
end; |
10866 | 376 |
end; |
377 |
end |
|
378 |
else |
|
10868
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
379 |
SpeechHogNumber:= -1; |
10866 | 380 |
end |
381 |
else |
|
10868
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
382 |
SpeechHogNumber:= -1; |
1431 | 383 |
|
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
384 |
// draw chat lines |
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
385 |
if ((not ChatHidden) or showAll) and (UIDisplay <> uiNone) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
386 |
begin |
10375 | 387 |
if MissedCount <> 0 then // there are chat strings we missed, so print them now |
388 |
begin |
|
389 |
for i:= 0 to MissedCount - 1 do |
|
390 |
AddChatString(MStrs[i]); |
|
391 |
MissedCount:= 0; |
|
392 |
end; |
|
393 |
i:= lastStr; |
|
10303 | 394 |
|
10375 | 395 |
cnt:= 0; // count of lines displayed |
396 |
t := 1; // # of current line processed |
|
2376 | 397 |
|
10375 | 398 |
// draw lines in reverse order |
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
399 |
while (((t < 7) and (Strs[i].Time > RealTicks)) or ((t <= MaxStrIndex + 1) and showAll)) |
10375 | 400 |
and (Strs[i].Tex <> nil) do |
401 |
begin |
|
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
402 |
top:= top - ClHeight; |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
403 |
// draw chatline only if not offscreen |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
404 |
if top > 0 then |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
405 |
DrawTexture(left, top, Strs[i].Tex); |
8745 | 406 |
|
10375 | 407 |
if i = 0 then |
408 |
i:= MaxStrIndex |
|
409 |
else |
|
410 |
dec(i); |
|
411 |
||
412 |
inc(cnt); |
|
413 |
inc(t) |
|
414 |
end; |
|
415 |
||
416 |
visibleCount:= cnt; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
417 |
end; |
942 | 418 |
end; |
419 |
||
4467 | 420 |
procedure SendHogSpeech(s: shortstring); |
421 |
begin |
|
422 |
SendIPC('h' + s); |
|
423 |
ParseCommand('/hogsay '+s, true) |
|
424 |
end; |
|
425 |
||
10392 | 426 |
procedure SendConsoleCommand(s: shortstring); |
427 |
begin |
|
428 |
Delete(s, 1, 1); |
|
429 |
SendIPC('~' + s) |
|
430 |
end; |
|
431 |
||
1033 | 432 |
procedure AcceptChatString(s: shortstring); |
1035 | 433 |
var i: TWave; |
8152 | 434 |
j: TChatCmd; |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4404
diff
changeset
|
435 |
c, t: LongInt; |
4467 | 436 |
x: byte; |
1033 | 437 |
begin |
10513
58fa783e0cfd
fixes to chat input history: remember all inputs, don not remember duplicates
sheepluva
parents:
10396
diff
changeset
|
438 |
if s <> LocalStrs[localLastStr] then |
58fa783e0cfd
fixes to chat input history: remember all inputs, don not remember duplicates
sheepluva
parents:
10396
diff
changeset
|
439 |
begin |
58fa783e0cfd
fixes to chat input history: remember all inputs, don not remember duplicates
sheepluva
parents:
10396
diff
changeset
|
440 |
// put in input history |
58fa783e0cfd
fixes to chat input history: remember all inputs, don not remember duplicates
sheepluva
parents:
10396
diff
changeset
|
441 |
localLastStr:= (localLastStr + 1) mod MaxStrIndex; |
58fa783e0cfd
fixes to chat input history: remember all inputs, don not remember duplicates
sheepluva
parents:
10396
diff
changeset
|
442 |
LocalStrs[localLastStr]:= s; |
58fa783e0cfd
fixes to chat input history: remember all inputs, don not remember duplicates
sheepluva
parents:
10396
diff
changeset
|
443 |
end; |
58fa783e0cfd
fixes to chat input history: remember all inputs, don not remember duplicates
sheepluva
parents:
10396
diff
changeset
|
444 |
|
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4404
diff
changeset
|
445 |
t:= LocalTeam; |
4467 | 446 |
x:= 0; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
447 |
if (s[1] = '"') and (s[Length(s)] = '"') |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
448 |
then x:= 1 |
8745 | 449 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
450 |
else if (s[1] = '''') and (s[Length(s)] = '''') then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
451 |
x:= 2 |
8745 | 452 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
453 |
else if (s[1] = '-') and (s[Length(s)] = '-') then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
454 |
x:= 3; |
8745 | 455 |
|
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7722
diff
changeset
|
456 |
if (not CurrentTeam^.ExtDriven) and (x <> 0) then |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4404
diff
changeset
|
457 |
for c:= 0 to Pred(TeamsCount) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
458 |
if (TeamsArray[c] = CurrentTeam) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
459 |
t:= c; |
4467 | 460 |
|
461 |
if x <> 0 then |
|
2017 | 462 |
begin |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4404
diff
changeset
|
463 |
if t = -1 then |
2111 | 464 |
ParseCommand('/say ' + copy(s, 2, Length(s)-2), true) |
465 |
else |
|
4467 | 466 |
SendHogSpeech(char(x) + char(t) + copy(s, 2, Length(s)-2)); |
2017 | 467 |
exit |
468 |
end; |
|
4467 | 469 |
|
9669 | 470 |
if (s[1] = '/') then |
2017 | 471 |
begin |
9676 | 472 |
// These 3 are same as above, only are to make the hedgehog say it on next attack |
10304
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
473 |
if (copy(s, 2, 4) = 'hsa ') then |
9669 | 474 |
begin |
475 |
if CurrentTeam^.ExtDriven then |
|
476 |
ParseCommand('/say ' + copy(s, 6, Length(s)-5), true) |
|
477 |
else |
|
478 |
SendHogSpeech(#4 + copy(s, 6, Length(s)-5)); |
|
479 |
exit |
|
480 |
end; |
|
481 |
||
10304
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
482 |
if (copy(s, 2, 4) = 'hta ') then |
9669 | 483 |
begin |
484 |
if CurrentTeam^.ExtDriven then |
|
485 |
ParseCommand('/say ' + copy(s, 6, Length(s)-5), true) |
|
486 |
else |
|
487 |
SendHogSpeech(#5 + copy(s, 6, Length(s)-5)); |
|
488 |
exit |
|
489 |
end; |
|
490 |
||
10304
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
491 |
if (copy(s, 2, 4) = 'hya ') then |
9669 | 492 |
begin |
493 |
if CurrentTeam^.ExtDriven then |
|
494 |
ParseCommand('/say ' + copy(s, 6, Length(s)-5), true) |
|
495 |
else |
|
496 |
SendHogSpeech(#6 + copy(s, 6, Length(s)-5)); |
|
497 |
exit |
|
498 |
end; |
|
2111 | 499 |
|
10304
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
500 |
if (copy(s, 2, 5) = 'team ') and (length(s) > 6) then |
9669 | 501 |
begin |
502 |
ParseCommand(s, true); |
|
503 |
exit |
|
504 |
end; |
|
505 |
||
10304
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
506 |
if (copy(s, 2, 3) = 'me ') then |
9669 | 507 |
begin |
9680 | 508 |
ParseCommand('/say ' + s, true); |
509 |
exit |
|
510 |
end; |
|
2376 | 511 |
|
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
512 |
if (copy(s, 2, 10) = 'togglechat') then |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
513 |
begin |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
514 |
ChatHidden:= (not ChatHidden); |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
515 |
if ChatHidden then |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
516 |
showAll:= false; |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
517 |
exit |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
518 |
end; |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
519 |
|
10304
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
520 |
// debugging commands |
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
521 |
if (copy(s, 2, 7) = 'debugvl') then |
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
522 |
begin |
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
523 |
cViewLimitsDebug:= (not cViewLimitsDebug); |
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
524 |
UpdateViewLimits(); |
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
525 |
exit |
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
526 |
end; |
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
527 |
|
10312 | 528 |
if (copy(s, 2, 3) = 'lua') then |
529 |
begin |
|
530 |
AddFileLog('/lua issued'); |
|
531 |
if gameType <> gmtNet then |
|
532 |
begin |
|
533 |
liveLua:= (not liveLua); |
|
534 |
if liveLua then |
|
535 |
begin |
|
536 |
AddFileLog('[Lua] chat input string parsing enabled'); |
|
537 |
AddChatString(#3 + 'Lua parsing: ON'); |
|
538 |
end |
|
539 |
else |
|
540 |
begin |
|
541 |
AddFileLog('[Lua] chat input string parsing disabled'); |
|
542 |
AddChatString(#3 + 'Lua parsing: OFF'); |
|
543 |
end; |
|
10852
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
544 |
UpdateInputLinePrefix(); |
10312 | 545 |
end; |
546 |
exit |
|
547 |
end; |
|
548 |
||
549 |
// hedghog animations/taunts and engine commands |
|
9680 | 550 |
if (not CurrentTeam^.ExtDriven) and (CurrentTeam^.Hedgehogs[0].BotLevel = 0) then |
551 |
begin |
|
9669 | 552 |
for i:= Low(TWave) to High(TWave) do |
553 |
if (s = Wavez[i].cmd) then |
|
554 |
begin |
|
555 |
ParseCommand('/taunt ' + char(i), true); |
|
556 |
exit |
|
557 |
end; |
|
10588
6189bb1c903d
don't forbid running regular chat commands during turns of other teams. that was probably only meant for emotes to begin with
sheepluva
parents:
10514
diff
changeset
|
558 |
end; |
8152 | 559 |
|
10588
6189bb1c903d
don't forbid running regular chat commands during turns of other teams. that was probably only meant for emotes to begin with
sheepluva
parents:
10514
diff
changeset
|
560 |
for j:= Low(TChatCmd) to High(TChatCmd) do |
6189bb1c903d
don't forbid running regular chat commands during turns of other teams. that was probably only meant for emotes to begin with
sheepluva
parents:
10514
diff
changeset
|
561 |
if (s = ChatCommandz[j].ChatCmd) then |
6189bb1c903d
don't forbid running regular chat commands during turns of other teams. that was probably only meant for emotes to begin with
sheepluva
parents:
10514
diff
changeset
|
562 |
begin |
6189bb1c903d
don't forbid running regular chat commands during turns of other teams. that was probably only meant for emotes to begin with
sheepluva
parents:
10514
diff
changeset
|
563 |
ParseCommand(ChatCommandz[j].ProcedureCallChatCmd, true); |
6189bb1c903d
don't forbid running regular chat commands during turns of other teams. that was probably only meant for emotes to begin with
sheepluva
parents:
10514
diff
changeset
|
564 |
exit |
6189bb1c903d
don't forbid running regular chat commands during turns of other teams. that was probably only meant for emotes to begin with
sheepluva
parents:
10514
diff
changeset
|
565 |
end; |
10392 | 566 |
|
567 |
if (gameType = gmtNet) then |
|
568 |
SendConsoleCommand(s) |
|
2017 | 569 |
end |
10312 | 570 |
else |
571 |
begin |
|
572 |
if liveLua then |
|
573 |
LuaParseString(s) |
|
9676 | 574 |
else |
575 |
ParseCommand('/say ' + s, true); |
|
2017 | 576 |
end; |
1033 | 577 |
end; |
578 |
||
8738 | 579 |
procedure CleanupInput; |
580 |
begin |
|
581 |
FreezeEnterKey; |
|
582 |
history:= 0; |
|
9697 | 583 |
SDL_StopTextInput(); |
11356 | 584 |
//SDL_EnableKeyRepeat(0,0); |
8738 | 585 |
GameState:= gsGame; |
586 |
ResetKbd; |
|
587 |
end; |
|
588 |
||
10836 | 589 |
procedure DelBytesFromInputStrBack(endIdx: integer; count: byte); |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
590 |
var startIdx: integer; |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
591 |
begin |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
592 |
// nothing to do if count is 0 |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
593 |
if count = 0 then |
4121 | 594 |
exit; |
2376 | 595 |
|
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
596 |
// first byte to delete |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
597 |
startIdx:= endIdx - (count - 1); |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
598 |
|
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
599 |
// delete bytes from string |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
600 |
Delete(InputStr.s, startIdx, count); |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
601 |
|
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
602 |
SetLine(InputStr, InputStr.s, true); |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
603 |
end; |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
604 |
|
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
605 |
procedure MoveCursorToPreviousChar(); |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
606 |
begin |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
607 |
if cursorPos > 0 then |
10926
43612076e989
chat: simplify some code and fix bugs I noticed during testing
sheepluva
parents:
10921
diff
changeset
|
608 |
repeat |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
609 |
dec(cursorPos); |
10926
43612076e989
chat: simplify some code and fix bugs I noticed during testing
sheepluva
parents:
10921
diff
changeset
|
610 |
until ((cursorPos = 0) or IsFirstCharByte(InputStr.s[cursorPos + 1])); |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
611 |
end; |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
612 |
|
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
613 |
procedure MoveCursorToNextChar(); |
10926
43612076e989
chat: simplify some code and fix bugs I noticed during testing
sheepluva
parents:
10921
diff
changeset
|
614 |
var len: integer; |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
615 |
begin |
10926
43612076e989
chat: simplify some code and fix bugs I noticed during testing
sheepluva
parents:
10921
diff
changeset
|
616 |
len:= Length(InputStr.s); |
43612076e989
chat: simplify some code and fix bugs I noticed during testing
sheepluva
parents:
10921
diff
changeset
|
617 |
if cursorPos < len then |
43612076e989
chat: simplify some code and fix bugs I noticed during testing
sheepluva
parents:
10921
diff
changeset
|
618 |
repeat |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
619 |
inc(cursorPos); |
10926
43612076e989
chat: simplify some code and fix bugs I noticed during testing
sheepluva
parents:
10921
diff
changeset
|
620 |
until ((cursorPos = len) or IsFirstCharByte(InputStr.s[cursorPos + 1])); |
10836 | 621 |
end; |
622 |
||
10921 | 623 |
procedure DeleteLastUTF8CharFromStr(var s: shortstring); |
624 |
var l: byte; |
|
625 |
begin |
|
626 |
l:= Length(s); |
|
627 |
||
628 |
while (l > 1) and (not IsFirstCharByte(s[l])) do |
|
629 |
begin |
|
630 |
dec(l); |
|
631 |
end; |
|
632 |
||
633 |
if l > 0 then |
|
634 |
dec(l); |
|
635 |
||
636 |
s[0]:= char(l); |
|
637 |
end; |
|
638 |
||
10836 | 639 |
procedure DeleteSelected(); |
640 |
begin |
|
641 |
if (selectedPos >= 0) and (cursorPos <> selectedPos) then |
|
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
642 |
begin |
10836 | 643 |
DelBytesFromInputStrBack(max(cursorPos, selectedPos), abs(selectedPos-cursorPos)); |
644 |
cursorPos:= min(cursorPos, selectedPos); |
|
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
645 |
end; |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
646 |
ResetSelection(); |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
647 |
UpdateCursorCoords(); |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
648 |
end; |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
649 |
|
10836 | 650 |
procedure HandleSelection(enabled: boolean); |
651 |
begin |
|
652 |
if enabled then |
|
653 |
begin |
|
654 |
if selectedPos < 0 then |
|
655 |
selectedPos:= cursorPos; |
|
2017 | 656 |
end |
10836 | 657 |
else |
658 |
ResetSelection(); |
|
659 |
end; |
|
660 |
||
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
661 |
type TCharSkip = ( none, wspace, numalpha, special ); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
662 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
663 |
function GetInputCharSkipClass(index: LongInt): TCharSkip; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
664 |
var c: char; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
665 |
begin |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
666 |
c:= InputStr.s[index]; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
667 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
668 |
// non-ascii counts as letter |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
669 |
if c > #127 then |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
670 |
exit(numalpha); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
671 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
672 |
// low-ascii whitespaces and DEL |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
673 |
if (c < #33) or (c = #127) then |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
674 |
exit(wspace); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
675 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
676 |
// low-ascii special chars |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
677 |
if c < #48 then |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
678 |
exit(special); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
679 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
680 |
// digits |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
681 |
if c < #58 then |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
682 |
exit(numalpha); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
683 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
684 |
// make c upper-case |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
685 |
if c > #96 then |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
686 |
c:= char(byte(c) - 32); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
687 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
688 |
// letters |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
689 |
if (c > #64) and (c < #90) then |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
690 |
exit(numalpha); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
691 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
692 |
// remaining ascii are special chars |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
693 |
exit(special); |
1033 | 694 |
end; |
695 |
||
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
696 |
// skip from word to word, similar to Qt |
10845
1dbd50690951
quick word deletion while holding ctrl (qt style)
sheepluva
parents:
10844
diff
changeset
|
697 |
procedure SkipInputChars(skip: TCharSkip; backwards: boolean); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
698 |
begin |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
699 |
if backwards then |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
700 |
begin |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
701 |
// skip trailing whitespace, similar to Qt |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
702 |
while (skip = wspace) and (cursorPos > 0) do |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
703 |
begin |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
704 |
skip:= GetInputCharSkipClass(cursorPos); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
705 |
if skip = wspace then |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
706 |
MoveCursorToPreviousChar(); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
707 |
end; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
708 |
// skip same-type chars |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
709 |
while (cursorPos > 0) and (GetInputCharSkipClass(cursorPos) = skip) do |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
710 |
MoveCursorToPreviousChar(); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
711 |
end |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
712 |
else |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
713 |
begin |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
714 |
// skip same-type chars |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
715 |
while cursorPos < Length(InputStr.s) do |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
716 |
begin |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
717 |
MoveCursorToNextChar(); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
718 |
if (GetInputCharSkipClass(cursorPos) <> skip) then |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
719 |
begin |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
720 |
MoveCursorToPreviousChar(); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
721 |
break; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
722 |
end; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
723 |
end; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
724 |
// skip trailing whitespace, similar to Qt |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
725 |
while cursorPos < Length(InputStr.s) do |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
726 |
begin |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
727 |
MoveCursorToNextChar(); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
728 |
if (GetInputCharSkipClass(cursorPos) <> wspace) then |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
729 |
begin |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
730 |
MoveCursorToPreviousChar(); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
731 |
break; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
732 |
end; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
733 |
end; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
734 |
end; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
735 |
end; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
736 |
|
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
737 |
procedure CopyToClipboard(var newContent: shortstring); |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
738 |
begin |
11344 | 739 |
// SDL2 clipboard |
740 |
SDL_SetClipboardText(Str2PChar(newContent)); |
|
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
741 |
end; |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
742 |
|
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
743 |
procedure CopySelectionToClipboard(); |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
744 |
var selection: shortstring; |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
745 |
begin |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
746 |
if selectedPos >= 0 then |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
747 |
begin |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
748 |
selection:= copy(InputStr.s, min(CursorPos, selectedPos) + 1, abs(CursorPos - selectedPos)); |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
749 |
CopyToClipboard(selection); |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
750 |
end; |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
751 |
end; |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
752 |
|
10853 | 753 |
procedure InsertIntoInputStr(s: shortstring); |
10921 | 754 |
var limit: integer; |
946 | 755 |
begin |
10921 | 756 |
// we check limit for trailing stuff before insertion limit for a reason |
757 |
// (possible remaining space after too long UTF8-insertion has been shortened) |
|
758 |
||
759 |
// length limit for stuff to that will trail the insertion |
|
760 |
limit:= max(cursorPos, MaxInputStrLen-Length(s)); |
|
761 |
||
762 |
while Length(InputStr.s) > limit do |
|
763 |
begin |
|
764 |
DeleteLastUTF8CharFromStr(InputStr.s); |
|
765 |
end; |
|
766 |
||
767 |
// length limit for stuff to insert |
|
768 |
limit:= max(0, MaxInputStrLen-cursorPos); |
|
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
769 |
|
10921 | 770 |
if limit = 0 then |
771 |
s:= '' |
|
772 |
else while Length(s) > limit do |
|
773 |
begin |
|
774 |
DeleteLastUTF8CharFromStr(s); |
|
775 |
end; |
|
10851
f25dad9c3136
chat/copypaste: some adjustments and sanity checks
sheepluva
parents:
10850
diff
changeset
|
776 |
|
10921 | 777 |
if Length(s) > 0 then |
778 |
begin |
|
779 |
// insert string truncated to safe length |
|
780 |
Insert(s, InputStr.s, cursorPos + 1); |
|
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
781 |
|
10921 | 782 |
if Length(InputStr.s) > MaxInputStrLen then |
783 |
InputStr.s[0]:= char(MaxInputStrLen); |
|
784 |
||
785 |
SetLine(InputStr, InputStr.s, true); |
|
786 |
||
787 |
// move cursor to end of inserted string |
|
788 |
inc(cursorPos, Length(s)); |
|
789 |
UpdateCursorCoords(); |
|
790 |
end; |
|
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
791 |
end; |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
792 |
|
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
793 |
procedure PasteFromClipboard(); |
11343 | 794 |
var clip: PChar; |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
795 |
begin |
11343 | 796 |
// use SDL2 clipboard functions |
797 |
if SDL_HasClipboardText() then |
|
10850
c76ea22ea249
copy to/paste from system clipboard (via frontend)
sheepluva
parents:
10849
diff
changeset
|
798 |
begin |
11343 | 799 |
clip:= SDL_GetClipboardText(); |
800 |
// returns NULL if not enough memory for a copy of clipboard content |
|
801 |
if clip <> nil then |
|
802 |
begin |
|
803 |
InsertIntoInputStr(shortstring(clip)); |
|
804 |
SDL_free(Pointer(clip)); |
|
805 |
end; |
|
10850
c76ea22ea249
copy to/paste from system clipboard (via frontend)
sheepluva
parents:
10849
diff
changeset
|
806 |
end; |
9699
fab319c85a39
Accept SDL_TEXTINPUT events for chat (why first and only first chat invocation receives event for 't' key?)
unc0rr
parents:
9697
diff
changeset
|
807 |
end; |
fab319c85a39
Accept SDL_TEXTINPUT events for chat (why first and only first chat invocation receives event for 't' key?)
unc0rr
parents:
9697
diff
changeset
|
808 |
|
11356 | 809 |
procedure KeyPressChat(keysym: TSDL_Keysym); |
11377 | 810 |
const nonStateMask = (not (KMOD_NUM or KMOD_CAPS)); |
811 |
var i, index: integer; |
|
812 |
selMode, ctrl, ctrlonly: boolean; |
|
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
813 |
skip: TCharSkip; |
11356 | 814 |
Scancode: TSDL_Scancode; |
815 |
Modifier: Word; |
|
946 | 816 |
begin |
11356 | 817 |
Scancode:= keysym.scancode; |
818 |
Modifier:= keysym.modifier; |
|
819 |
||
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
820 |
LastKeyPressTick:= RealTicks; |
10836 | 821 |
|
822 |
selMode:= (modifier and (KMOD_LSHIFT or KMOD_RSHIFT)) <> 0; |
|
823 |
ctrl:= (modifier and (KMOD_LCTRL or KMOD_RCTRL)) <> 0; |
|
11004
bd62cdbea391
chat: make sure that CTRL is the /only/ modifier key pressed when detecting ctrl+a etc
sheepluva
parents:
10985
diff
changeset
|
824 |
ctrlonly:= ctrl and ((modifier and nonStateMask and (not (KMOD_LCTRL or KMOD_RCTRL))) = 0); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
825 |
skip:= none; |
10836 | 826 |
|
11356 | 827 |
case Scancode of |
828 |
SDL_SCANCODE_BACKSPACE: |
|
8743 | 829 |
begin |
10836 | 830 |
if selectedPos < 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
831 |
begin |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
832 |
HandleSelection(true); |
10845
1dbd50690951
quick word deletion while holding ctrl (qt style)
sheepluva
parents:
10844
diff
changeset
|
833 |
|
1dbd50690951
quick word deletion while holding ctrl (qt style)
sheepluva
parents:
10844
diff
changeset
|
834 |
// delete more if ctrl is held |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
835 |
if ctrl then |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
836 |
SkipInputChars(GetInputCharSkipClass(cursorPos), true) |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
837 |
else |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
838 |
MoveCursorToPreviousChar(); |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
839 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
840 |
end; |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
841 |
|
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
842 |
DeleteSelected(); |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
843 |
UpdateCursorCoords(); |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
844 |
end; |
11356 | 845 |
SDL_SCANCODE_DELETE: |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
846 |
begin |
10836 | 847 |
if selectedPos < 0 then |
5100 | 848 |
begin |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
849 |
HandleSelection(true); |
10845
1dbd50690951
quick word deletion while holding ctrl (qt style)
sheepluva
parents:
10844
diff
changeset
|
850 |
|
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
851 |
// delete more if ctrl is held |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
852 |
if ctrl then |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
853 |
SkipInputChars(GetInputCharSkipClass(cursorPos), false) |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
854 |
else |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
855 |
MoveCursorToNextChar(); |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
856 |
|
5100 | 857 |
end; |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
858 |
|
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
859 |
DeleteSelected(); |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
860 |
UpdateCursorCoords(); |
8743 | 861 |
end; |
11356 | 862 |
SDL_SCANCODE_ESCAPE: |
8743 | 863 |
begin |
8745 | 864 |
if Length(InputStr.s) > 0 then |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
865 |
begin |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
866 |
SetLine(InputStr, '', true); |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
867 |
ResetCursor(); |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
868 |
end |
8743 | 869 |
else CleanupInput |
870 |
end; |
|
11356 | 871 |
SDL_SCANCODE_RETURN, SDL_SCANCODE_KP_ENTER: |
8743 | 872 |
begin |
873 |
if Length(InputStr.s) > 0 then |
|
8742
b7b8bd398c1b
Key returned 0 for arrows under linux. Sym works, clearer anyway.
nemo
parents:
8741
diff
changeset
|
874 |
begin |
8743 | 875 |
AcceptChatString(InputStr.s); |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
876 |
SetLine(InputStr, '', false); |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
877 |
ResetCursor(); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
878 |
end; |
8743 | 879 |
CleanupInput |
880 |
end; |
|
11356 | 881 |
SDL_SCANCODE_UP, SDL_SCANCODE_DOWN: |
8743 | 882 |
begin |
11356 | 883 |
if (Scancode = SDL_SCANCODE_UP) and (history < localLastStr) then inc(history); |
884 |
if (Scancode = SDL_SCANCODE_DOWN) and (history > 0) then dec(history); |
|
8743 | 885 |
index:= localLastStr - history + 1; |
886 |
if (index > localLastStr) then |
|
10835
8ac09cd322b7
fix chat input history not restoring utf8-related info
sheepluva
parents:
10834
diff
changeset
|
887 |
begin |
8ac09cd322b7
fix chat input history not restoring utf8-related info
sheepluva
parents:
10834
diff
changeset
|
888 |
SetLine(InputStr, '', true); |
8ac09cd322b7
fix chat input history not restoring utf8-related info
sheepluva
parents:
10834
diff
changeset
|
889 |
end |
8ac09cd322b7
fix chat input history not restoring utf8-related info
sheepluva
parents:
10834
diff
changeset
|
890 |
else |
8ac09cd322b7
fix chat input history not restoring utf8-related info
sheepluva
parents:
10834
diff
changeset
|
891 |
begin |
8ac09cd322b7
fix chat input history not restoring utf8-related info
sheepluva
parents:
10834
diff
changeset
|
892 |
SetLine(InputStr, LocalStrs[index], true); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
893 |
end; |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
894 |
cursorPos:= Length(InputStr.s); |
10836 | 895 |
ResetSelection(); |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
896 |
UpdateCursorCoords(); |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
897 |
end; |
11356 | 898 |
SDL_SCANCODE_HOME: |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
899 |
begin |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
900 |
if cursorPos > 0 then |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
901 |
begin |
10836 | 902 |
HandleSelection(selMode); |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
903 |
cursorPos:= 0; |
10846
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
904 |
end |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
905 |
else if (not selMode) then |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
906 |
ResetSelection(); |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
907 |
|
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
908 |
UpdateCursorCoords(); |
8745 | 909 |
end; |
11356 | 910 |
SDL_SCANCODE_END: |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
911 |
begin |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
912 |
i:= Length(InputStr.s); |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
913 |
if cursorPos < i then |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
914 |
begin |
10836 | 915 |
HandleSelection(selMode); |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
916 |
cursorPos:= i; |
10846
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
917 |
end |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
918 |
else if (not selMode) then |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
919 |
ResetSelection(); |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
920 |
|
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
921 |
UpdateCursorCoords(); |
8745 | 922 |
end; |
11356 | 923 |
SDL_SCANCODE_LEFT: |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
924 |
begin |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
925 |
if cursorPos > 0 then |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
926 |
begin |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
927 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
928 |
if ctrl then |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
929 |
skip:= GetInputCharSkipClass(cursorPos); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
930 |
|
10836 | 931 |
if selMode or (selectedPos < 0) then |
932 |
begin |
|
933 |
HandleSelection(selMode); |
|
934 |
// go to end of previous utf8-char |
|
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
935 |
MoveCursorToPreviousChar(); |
10836 | 936 |
end |
937 |
else // if we're leaving selection mode, jump to its left end |
|
938 |
begin |
|
939 |
cursorPos:= min(cursorPos, selectedPos); |
|
940 |
ResetSelection(); |
|
941 |
end; |
|
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
942 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
943 |
if ctrl then |
10845
1dbd50690951
quick word deletion while holding ctrl (qt style)
sheepluva
parents:
10844
diff
changeset
|
944 |
SkipInputChars(skip, true); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
945 |
|
10846
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
946 |
end |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
947 |
else if (not selMode) then |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
948 |
ResetSelection(); |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
949 |
|
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
950 |
UpdateCursorCoords(); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
951 |
end; |
11356 | 952 |
SDL_SCANCODE_RIGHT: |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
953 |
begin |
10836 | 954 |
if cursorPos < Length(InputStr.s) then |
955 |
begin |
|
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
956 |
|
10836 | 957 |
if selMode or (selectedPos < 0) then |
958 |
begin |
|
959 |
HandleSelection(selMode); |
|
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
960 |
MoveCursorToNextChar(); |
10836 | 961 |
end |
962 |
else // if we're leaving selection mode, jump to its right end |
|
963 |
begin |
|
964 |
cursorPos:= max(cursorPos, selectedPos); |
|
965 |
ResetSelection(); |
|
966 |
end; |
|
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
967 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
968 |
if ctrl then |
10845
1dbd50690951
quick word deletion while holding ctrl (qt style)
sheepluva
parents:
10844
diff
changeset
|
969 |
SkipInputChars(GetInputCharSkipClass(cursorPos), false); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
970 |
|
10846
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
971 |
end |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
972 |
else if (not selMode) then |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
973 |
ResetSelection(); |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
974 |
|
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
975 |
UpdateCursorCoords(); |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
976 |
end; |
11356 | 977 |
SDL_SCANCODE_PAGEUP, SDL_SCANCODE_PAGEDOWN: |
8745 | 978 |
begin |
979 |
// ignore me!!! |
|
980 |
end; |
|
11356 | 981 |
// TODO: figure out how to determine those keys better |
982 |
SDL_SCANCODE_a: |
|
10836 | 983 |
begin |
984 |
// select all |
|
11004
bd62cdbea391
chat: make sure that CTRL is the /only/ modifier key pressed when detecting ctrl+a etc
sheepluva
parents:
10985
diff
changeset
|
985 |
if ctrlonly then |
10836 | 986 |
begin |
987 |
ResetSelection(); |
|
10846
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
988 |
cursorPos:= 0; |
10836 | 989 |
HandleSelection(true); |
10846
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
990 |
cursorPos:= Length(InputStr.s); |
10836 | 991 |
UpdateCursorCoords(); |
992 |
end |
|
993 |
end; |
|
11356 | 994 |
SDL_SCANCODE_c: |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
995 |
begin |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
996 |
// copy |
11004
bd62cdbea391
chat: make sure that CTRL is the /only/ modifier key pressed when detecting ctrl+a etc
sheepluva
parents:
10985
diff
changeset
|
997 |
if ctrlonly then |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
998 |
CopySelectionToClipboard() |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
999 |
end; |
11356 | 1000 |
SDL_SCANCODE_v: |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1001 |
begin |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1002 |
// paste |
11004
bd62cdbea391
chat: make sure that CTRL is the /only/ modifier key pressed when detecting ctrl+a etc
sheepluva
parents:
10985
diff
changeset
|
1003 |
if ctrlonly then |
10921 | 1004 |
begin |
1005 |
DeleteSelected(); |
|
1006 |
PasteFromClipboard(); |
|
1007 |
end |
|
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1008 |
end; |
11356 | 1009 |
SDL_SCANCODE_x: |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1010 |
begin |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1011 |
// cut |
11004
bd62cdbea391
chat: make sure that CTRL is the /only/ modifier key pressed when detecting ctrl+a etc
sheepluva
parents:
10985
diff
changeset
|
1012 |
if ctrlonly then |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1013 |
begin |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1014 |
CopySelectionToClipboard(); |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1015 |
DeleteSelected(); |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1016 |
end |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1017 |
end; |
8742
b7b8bd398c1b
Key returned 0 for arrows under linux. Sym works, clearer anyway.
nemo
parents:
8741
diff
changeset
|
1018 |
end; |
946 | 1019 |
end; |
1020 |
||
11356 | 1021 |
procedure TextInput(var event: TSDL_TextInputEvent); |
1022 |
var s: shortstring; |
|
1023 |
l: byte; |
|
11702
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1024 |
isl: integer; |
11356 | 1025 |
begin |
1026 |
DeleteSelected(); |
|
1027 |
||
1028 |
l:= 0; |
|
11702
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1029 |
// fetch all bytes of character/input |
11356 | 1030 |
while event.text[l] <> #0 do |
1031 |
begin |
|
1032 |
s[l + 1]:= event.text[l]; |
|
1033 |
inc(l) |
|
1034 |
end; |
|
1035 |
||
1036 |
if l > 0 then |
|
1037 |
begin |
|
11702
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1038 |
isl:= Length(InputStr.s); |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1039 |
// check if user is typing a redundant closing hog-speech quotation mark |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1040 |
if (l = 1) and (isl >= 2) and (cursorPos = isl - 1) and charIsForHogSpeech(s[1]) |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1041 |
and (s[1] = InputStr.s[1]) and (s[1] = InputStr.s[isl]) then |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1042 |
begin |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1043 |
MoveCursorToNextChar(); |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1044 |
UpdateCursorCoords(); |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1045 |
end |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1046 |
else |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1047 |
begin |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1048 |
// don't add input that doesn't fit |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1049 |
if isl + l > MaxInputStrLen then exit; |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1050 |
s[0]:= char(l); |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1051 |
InsertIntoInputStr(s); |
11701
fa4bc078e509
restore closing hog speech quotation marks being added automatically (lost in SDL2 transition... I think)
sheepluva
parents:
11481
diff
changeset
|
1052 |
|
11702
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1053 |
// add closing hog speech quotation marks automagically |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1054 |
if (l = 1) and (Length(InputStr.s) = 1) and charIsForHogSpeech(s[1]) then |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1055 |
begin |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1056 |
InsertIntoInputStr(s); |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1057 |
MoveCursorToPreviousChar(); |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1058 |
UpdateCursorCoords(); |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11701
diff
changeset
|
1059 |
end; |
11701
fa4bc078e509
restore closing hog speech quotation marks being added automatically (lost in SDL2 transition... I think)
sheepluva
parents:
11481
diff
changeset
|
1060 |
end; |
fa4bc078e509
restore closing hog speech quotation marks being added automatically (lost in SDL2 transition... I think)
sheepluva
parents:
11481
diff
changeset
|
1061 |
|
11356 | 1062 |
end |
1063 |
end; |
|
1064 |
||
1065 |
||
4404 | 1066 |
procedure chChatMessage(var s: shortstring); |
1067 |
begin |
|
1068 |
AddChatString(s) |
|
1069 |
end; |
|
1070 |
||
4402 | 1071 |
procedure chSay(var s: shortstring); |
1072 |
begin |
|
1073 |
SendIPC('s' + s); |
|
1074 |
||
1075 |
if copy(s, 1, 4) = '/me ' then |
|
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6381
diff
changeset
|
1076 |
s:= #2 + '* ' + UserNick + ' ' + copy(s, 5, Length(s) - 4) |
4402 | 1077 |
else |
1078 |
s:= #1 + UserNick + ': ' + s; |
|
1079 |
||
1080 |
AddChatString(s) |
|
1081 |
end; |
|
1082 |
||
1083 |
procedure chTeamSay(var s: shortstring); |
|
1084 |
begin |
|
1085 |
SendIPC('b' + s); |
|
1086 |
||
1087 |
s:= #4 + '[Team] ' + UserNick + ': ' + s; |
|
1088 |
||
1089 |
AddChatString(s) |
|
1090 |
end; |
|
1091 |
||
1092 |
procedure chHistory(var s: shortstring); |
|
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1093 |
var i: LongInt; |
4402 | 1094 |
begin |
1095 |
s:= s; // avoid compiler hint |
|
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1096 |
showAll:= not showAll; |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1097 |
// immediatly recount |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1098 |
visibleCount:= 0; |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1099 |
if showAll or (not ChatHidden) then |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1100 |
for i:= 0 to MaxStrIndex do |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1101 |
begin |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1102 |
if (Strs[i].Tex <> nil) and (showAll or (Strs[i].Time > RealTicks)) then |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1103 |
inc(visibleCount); |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1104 |
end; |
4402 | 1105 |
end; |
1106 |
||
1107 |
procedure chChat(var s: shortstring); |
|
1108 |
begin |
|
1109 |
s:= s; // avoid compiler hint |
|
1110 |
GameState:= gsChat; |
|
11356 | 1111 |
SDL_StopTextInput(); |
9697 | 1112 |
SDL_StartTextInput(); |
11356 | 1113 |
//SDL_EnableKeyRepeat(200,45); |
4402 | 1114 |
if length(s) = 0 then |
5100 | 1115 |
SetLine(InputStr, '', true) |
4402 | 1116 |
else |
1117 |
begin |
|
10843 | 1118 |
SetLine(InputStr, '/team ', true); |
10841 | 1119 |
cursorPos:= 6; |
1120 |
UpdateCursorCoords(); |
|
1121 |
end; |
|
4402 | 1122 |
end; |
1123 |
||
3038 | 1124 |
procedure initModule; |
4925 | 1125 |
var i: ShortInt; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1126 |
begin |
6898 | 1127 |
RegisterVariable('chatmsg', @chChatMessage, true); |
1128 |
RegisterVariable('say', @chSay, true); |
|
1129 |
RegisterVariable('team', @chTeamSay, true); |
|
1130 |
RegisterVariable('history', @chHistory, true ); |
|
1131 |
RegisterVariable('chat', @chChat, true ); |
|
4402 | 1132 |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1133 |
lastStr:= 0; |
8740
3eb1891f81ef
use a local storage for chat history which prevents mix ups in netgame and simplifies code
koda
parents:
8739
diff
changeset
|
1134 |
localLastStr:= 0; |
8737
0d56265dd60a
implement up and down keys to navigate in the chat history, needs testing over network
koda
parents:
8736
diff
changeset
|
1135 |
history:= 0; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1136 |
visibleCount:= 0; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1137 |
showAll:= false; |
3539 | 1138 |
ChatReady:= false; |
1139 |
missedCount:= 0; |
|
10312 | 1140 |
liveLua:= false; |
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1141 |
ChatHidden:= false; |
10842
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
1142 |
firstDraw:= true; |
4925 | 1143 |
|
10852
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
1144 |
InputLinePrefix.Tex:= nil; |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
1145 |
UpdateInputLinePrefix(); |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
1146 |
inputStr.s:= ''; |
4925 | 1147 |
inputStr.Tex := nil; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
1148 |
for i:= 0 to MaxStrIndex do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
1149 |
Strs[i].Tex := nil; |
10834
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
1150 |
|
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
1151 |
LastKeyPressTick:= 0; |
2e83f33dfe5b
engine: moveable chat cursor. note: discovered bug that utf8 char info is lost/corrupted when input history is used
sheepluva
parents:
10737
diff
changeset
|
1152 |
ResetCursor(); |
11356 | 1153 |
SDL_StopTextInput(); |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1154 |
end; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1155 |
|
3038 | 1156 |
procedure freeModule; |
4901 | 1157 |
var i: ShortInt; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1158 |
begin |
10852
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
1159 |
FreeAndNilTexture(InputLinePrefix.Tex); |
10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10588
diff
changeset
|
1160 |
FreeAndNilTexture(InputStr.Tex); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
1161 |
for i:= 0 to MaxStrIndex do |
10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10588
diff
changeset
|
1162 |
FreeAndNilTexture(Strs[i].Tex); |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1163 |
end; |
946 | 1164 |
|
942 | 1165 |
end. |