author | Wuzzy <Wuzzy2@mail.ru> |
Sun, 15 Sep 2019 15:12:48 +0200 | |
changeset 15421 | 06524f2e9a74 |
parent 15288 | 22f2fd8a3d2c |
child 15304 | c4fd2813b127 |
child 15610 | 96a02e385d54 |
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; |
|
11365 | 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 |
15288
22f2fd8a3d2c
VideoRec: Stop prerecording when /lua activates
Wuzzy <Wuzzy2@mail.ru>
parents:
14799
diff
changeset
|
38 |
uses uInputHandler, uTypes, uVariables, uCommands, uUtils, uTextures, uRender, uIO, uScript, uRenderUtils, uLocale |
22f2fd8a3d2c
VideoRec: Stop prerecording when /lua activates
Wuzzy <Wuzzy2@mail.ru>
parents:
14799
diff
changeset
|
39 |
{$IFDEF USE_VIDEO_RECORDING}, uVideoRec{$ENDIF}; |
942 | 40 |
|
990
dfa6a6fe1542
Implement history for chat (27 entries), no key binding yet
unc0rr
parents:
988
diff
changeset
|
41 |
const MaxStrIndex = 27; |
10921 | 42 |
MaxInputStrLen = 200; |
942 | 43 |
|
946 | 44 |
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
|
45 |
Tex: PTexture; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
46 |
Time: Longword; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
47 |
Width: LongInt; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
48 |
s: shortstring; |
10303 | 49 |
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
|
50 |
end; |
12410
8b971d8944d6
Remove the buggy /finish chat command
Wuzzy <almikes@aol.com>
parents:
12102
diff
changeset
|
51 |
TChatCmd = (ccQuit, ccPause, ccShowHistory, ccFullScreen); |
942 | 52 |
|
946 | 53 |
var Strs: array[0 .. MaxStrIndex] of TChatLine; |
3539 | 54 |
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
|
55 |
LocalStrs: array[0 .. MaxStrIndex] of shortstring; |
3539 | 56 |
missedCount: LongWord; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
57 |
lastStr: LongWord; |
9145 | 58 |
localLastStr: LongInt; |
59 |
history: LongInt; |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
60 |
visibleCount: LongWord; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
61 |
InputStr: TChatLine; |
4814
e19791f08443
smaller rearrangement of (non stereo related) variables
koda
parents:
4467
diff
changeset
|
62 |
ChatReady: boolean; |
e19791f08443
smaller rearrangement of (non stereo related) variables
koda
parents:
4467
diff
changeset
|
63 |
showAll: boolean; |
10312 | 64 |
liveLua: boolean; |
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
65 |
ChatHidden: boolean; |
10842
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
66 |
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
|
67 |
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
|
68 |
// cursor |
10836 | 69 |
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
|
70 |
LastKeyPressTick: LongWord; |
942 | 71 |
|
72 |
||
8152 | 73 |
const |
11835 | 74 |
colors: array[#0..#9] of TSDL_Color = ( |
13744
cb2857f55130
Change chat text color for Lua warnings to yellow
Wuzzy <Wuzzy2@mail.ru>
parents:
13674
diff
changeset
|
75 |
(r:$FF; g:$FF; b:$00; a:$FF), // #0 warning message [Yellow] |
11022 | 76 |
(r:$FF; g:$FF; b:$FF; a:$FF), // #1 chat message [White] |
77 |
(r:$FF; g:$00; b:$FF; a:$FF), // #2 action message [Purple] |
|
78 |
(r:$90; g:$FF; b:$90; a:$FF), // #3 join/leave message [Lime] |
|
79 |
(r:$FF; g:$FF; b:$A0; a:$FF), // #4 team message [Light Yellow] |
|
80 |
(r:$FF; g:$00; b:$00; a:$FF), // #5 error messages [Red] |
|
81 |
(r:$00; g:$FF; b:$FF; a:$FF), // #6 input line [Light Blue] |
|
82 |
(r:$FF; g:$80; b:$80; a:$FF), // #7 team gone [Light Red] |
|
83 |
(r:$FF; g:$D0; b:$80; a:$FF), // #8 team back [Light Orange] |
|
11835 | 84 |
(r:$DF; g:$DF; b:$DF; a:$FF) // #9 hog speech [Light Gray] |
8152 | 85 |
); |
86 |
ChatCommandz: array [TChatCmd] of record |
|
87 |
ChatCmd: string[31]; |
|
88 |
ProcedureCallChatCmd: string[31]; |
|
89 |
end = ( |
|
90 |
(ChatCmd: '/quit'; ProcedureCallChatCmd: 'halt'), |
|
91 |
(ChatCmd: '/pause'; ProcedureCallChatCmd: 'pause'), |
|
9569 | 92 |
(ChatCmd: '/history'; ProcedureCallChatCmd: 'history'), |
8152 | 93 |
(ChatCmd: '/fullscreen'; ProcedureCallChatCmd: 'fullscr') |
94 |
); |
|
2396 | 95 |
|
10303 | 96 |
|
97 |
const Padding = 2; |
|
98 |
ClHeight = 2 * Padding + 16; // font height |
|
99 |
||
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
100 |
// relevant for UTF-8 handling |
10921 | 101 |
function IsFirstCharByte(c: char): boolean; inline; |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
102 |
begin |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
103 |
// based on https://en.wikipedia.org/wiki/UTF-8#Description |
10921 | 104 |
IsFirstCharByte:= (byte(c) and $C0) <> $80; |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
105 |
end; |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
106 |
|
10866 | 107 |
function charIsForHogSpeech(c: char): boolean; |
108 |
begin |
|
109 |
exit((c = '"') or (c = '''') or (c = '-')); |
|
110 |
end; |
|
111 |
||
10836 | 112 |
procedure ResetSelection(); |
942 | 113 |
begin |
10836 | 114 |
selectedPos:= -1; |
115 |
end; |
|
116 |
||
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
|
117 |
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
|
118 |
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
|
119 |
str : shortstring; |
10836 | 120 |
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
|
121 |
begin |
10836 | 122 |
if cursorPos = selectedPos then |
123 |
ResetSelection(); |
|
2396 | 124 |
|
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
|
125 |
// 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
|
126 |
|
10852
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
127 |
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
|
128 |
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
|
129 |
|
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
|
130 |
// 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
|
131 |
// 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
|
132 |
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
|
133 |
// 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
|
134 |
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
|
135 |
|
10842
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
136 |
cursorX:= 2 + coff; |
990
dfa6a6fe1542
Implement history for chat (27 entries), no key binding yet
unc0rr
parents:
988
diff
changeset
|
137 |
|
10836 | 138 |
// calculate selection width on screen |
139 |
if selectedPos >= 0 then |
|
140 |
begin |
|
141 |
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
|
142 |
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
|
143 |
// 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
|
144 |
str[0]:= char(selectedPos); |
10836 | 145 |
TTF_SizeUTF8(Fontz[font].Handle, Str2PChar(str), @soff, nil); |
146 |
selectionDx:= soff - coff; |
|
147 |
end |
|
148 |
else |
|
149 |
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
|
150 |
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
|
151 |
|
10836 | 152 |
|
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 |
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
|
154 |
begin |
10836 | 155 |
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
|
156 |
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
|
157 |
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
|
158 |
end; |
2396 | 159 |
|
10985
c5348fe9077c
fix chat lines losing color information on texture reload
sheepluva
parents:
10926
diff
changeset
|
160 |
(* 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
|
161 |
* 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
|
162 |
*) |
10303 | 163 |
procedure RenderChatLineTex(var cl: TChatLine; var str: shortstring); |
12102
51596d30a724
fix chat SDL surfaces being in wrong color format (didn't play well with copyToXY's new quick pixel copies)
sheepluva
parents:
11835
diff
changeset
|
164 |
var strSurface, tmpSurface, |
10303 | 165 |
resSurface: PSDL_Surface; |
166 |
dstrect : TSDL_Rect; // destination rectangle for blitting |
|
167 |
font : THWFont; |
|
168 |
const |
|
169 |
shadowint = $80 shl AShift; |
|
170 |
begin |
|
171 |
||
10985
c5348fe9077c
fix chat lines losing color information on texture reload
sheepluva
parents:
10926
diff
changeset
|
172 |
FreeAndNilTexture(cl.Tex); |
c5348fe9077c
fix chat lines losing color information on texture reload
sheepluva
parents:
10926
diff
changeset
|
173 |
|
10303 | 174 |
font:= CheckCJKFont(ansistring(str), fnt16); |
175 |
||
176 |
// get render size of text |
|
177 |
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
|
178 |
|
10303 | 179 |
// calculate and save size |
180 |
cl.Width := cl.Width + 2 * Padding; |
|
181 |
||
182 |
// create surface to draw on |
|
183 |
resSurface:= SDL_CreateRGBSurface( |
|
184 |
0, toPowerOf2(cl.Width), toPowerOf2(ClHeight), |
|
185 |
32, RMask, GMask, BMask, AMask); |
|
945
4ead9cde4e14
- Start chat implementation: chat strings are on the screen
unc0rr
parents:
942
diff
changeset
|
186 |
|
10303 | 187 |
// define area we want to draw in |
188 |
dstrect.x:= 0; |
|
189 |
dstrect.y:= 0; |
|
190 |
dstrect.w:= cl.Width; |
|
191 |
dstrect.h:= ClHeight; |
|
192 |
||
193 |
// draw background |
|
194 |
SDL_FillRect(resSurface, @dstrect, shadowint); |
|
195 |
||
196 |
// create and blit text |
|
12102
51596d30a724
fix chat SDL surfaces being in wrong color format (didn't play well with copyToXY's new quick pixel copies)
sheepluva
parents:
11835
diff
changeset
|
197 |
tmpSurface:= nil; |
10370 | 198 |
strSurface:= TTF_RenderUTF8_Blended(Fontz[font].Handle, Str2PChar(str), cl.color); |
12102
51596d30a724
fix chat SDL surfaces being in wrong color format (didn't play well with copyToXY's new quick pixel copies)
sheepluva
parents:
11835
diff
changeset
|
199 |
// fix format |
51596d30a724
fix chat SDL surfaces being in wrong color format (didn't play well with copyToXY's new quick pixel copies)
sheepluva
parents:
11835
diff
changeset
|
200 |
if strSurface <> nil then tmpSurface:= SDL_ConvertSurface(strSurface, resSurface^.format, 0); |
51596d30a724
fix chat SDL surfaces being in wrong color format (didn't play well with copyToXY's new quick pixel copies)
sheepluva
parents:
11835
diff
changeset
|
201 |
SDL_FreeSurface(strSurface); |
10737 | 202 |
//SDL_UpperBlit(strSurface, nil, resSurface, @dstrect); |
12102
51596d30a724
fix chat SDL surfaces being in wrong color format (didn't play well with copyToXY's new quick pixel copies)
sheepluva
parents:
11835
diff
changeset
|
203 |
if tmpSurface <> nil then copyToXY(tmpSurface, resSurface, Padding, Padding); |
51596d30a724
fix chat SDL surfaces being in wrong color format (didn't play well with copyToXY's new quick pixel copies)
sheepluva
parents:
11835
diff
changeset
|
204 |
SDL_FreeSurface(tmpSurface); |
1118 | 205 |
|
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
|
206 |
cl.Tex:= Surface2Tex(resSurface, false); |
1431 | 207 |
|
1118 | 208 |
SDL_FreeSurface(resSurface) |
946 | 209 |
end; |
210 |
||
10303 | 211 |
const ClDisplayDuration = 12500; |
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; |
942 | 215 |
begin |
2396 | 216 |
if isInput then |
6379 | 217 |
begin |
10303 | 218 |
cl.s:= str; |
5392 | 219 |
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
|
220 |
str:= str + ' '; |
6379 | 221 |
end |
2664
949c189ba568
powerpc and gameserver compilation disabled temporarily
koda
parents:
2630
diff
changeset
|
222 |
else |
6379 | 223 |
begin |
10863
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
224 |
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
|
225 |
begin |
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
226 |
color:= colors[str[1]]; |
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
227 |
delete(str, 1, 1); |
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
228 |
end |
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
229 |
// fallback if invalid color |
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
230 |
else |
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
231 |
color:= colors[Low(colors)]; |
9d3e1123bd43
fallback to first color in colors array if there is no valid color specified
sheepluva
parents:
10853
diff
changeset
|
232 |
|
10303 | 233 |
cl.s:= str; |
6379 | 234 |
end; |
2396 | 235 |
|
10303 | 236 |
cl.color:= color; |
945
4ead9cde4e14
- Start chat implementation: chat strings are on the screen
unc0rr
parents:
942
diff
changeset
|
237 |
|
10303 | 238 |
// set texture, note: variables cl.s and str will be different here if isInput |
239 |
RenderChatLineTex(cl, str); |
|
1118 | 240 |
|
11835 | 241 |
cl.Time:= RealTicks + ClDisplayDuration; |
946 | 242 |
end; |
243 |
||
6379 | 244 |
// For uStore texture recreation |
245 |
procedure ReloadLines; |
|
10985
c5348fe9077c
fix chat lines losing color information on texture reload
sheepluva
parents:
10926
diff
changeset
|
246 |
var i: LongWord; |
6379 | 247 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
248 |
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
|
249 |
SetLine(InputStr, InputStr.s, true); |
6381 | 250 |
for i:= 0 to MaxStrIndex do |
251 |
if Strs[i].s <> '' then |
|
252 |
begin |
|
10985
c5348fe9077c
fix chat lines losing color information on texture reload
sheepluva
parents:
10926
diff
changeset
|
253 |
RenderChatLineTex(Strs[i], Strs[i].s); |
6381 | 254 |
end; |
6379 | 255 |
end; |
256 |
||
946 | 257 |
procedure AddChatString(s: shortstring); |
258 |
begin |
|
3539 | 259 |
if not ChatReady then |
260 |
begin |
|
261 |
if MissedCount < MaxStrIndex - 1 then |
|
262 |
MStrs[MissedCount]:= s |
|
263 |
else if MissedCount < MaxStrIndex then |
|
264 |
MStrs[MissedCount]:= #5 + '[...]'; |
|
265 |
inc(MissedCount); |
|
266 |
exit |
|
267 |
end; |
|
268 |
||
946 | 269 |
lastStr:= (lastStr + 1) mod (MaxStrIndex + 1); |
270 |
||
990
dfa6a6fe1542
Implement history for chat (27 entries), no key binding yet
unc0rr
parents:
988
diff
changeset
|
271 |
SetLine(Strs[lastStr], s, false); |
945
4ead9cde4e14
- Start chat implementation: chat strings are on the screen
unc0rr
parents:
942
diff
changeset
|
272 |
|
4ead9cde4e14
- Start chat implementation: chat strings are on the screen
unc0rr
parents:
942
diff
changeset
|
273 |
inc(visibleCount) |
942 | 274 |
end; |
275 |
||
10852
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
276 |
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
|
277 |
begin |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
278 |
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
|
279 |
begin |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
280 |
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
|
281 |
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
|
282 |
end |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
283 |
else |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
284 |
begin |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
285 |
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
|
286 |
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
|
287 |
end; |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
288 |
|
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
289 |
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
|
290 |
end; |
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
291 |
|
942 | 292 |
procedure DrawChat; |
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
293 |
var i, t, left, top, cnt: LongInt; |
10836 | 294 |
selRect: TSDL_Rect; |
10866 | 295 |
c: char; |
942 | 296 |
begin |
3539 | 297 |
ChatReady:= true; // maybe move to somewhere else? |
1431 | 298 |
|
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
299 |
if ChatHidden and (not showAll) then |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
300 |
visibleCount:= 0; |
1431 | 301 |
|
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
302 |
// draw chat lines with some distance from screen border |
14321
79e07510b8e3
Touch: Fix chat rendered on top of turn timer
Wuzzy <Wuzzy2@mail.ru>
parents:
13898
diff
changeset
|
303 |
{$IFDEF USE_TOUCH_INTERFACE} |
79e07510b8e3
Touch: Fix chat rendered on top of turn timer
Wuzzy <Wuzzy2@mail.ru>
parents:
13898
diff
changeset
|
304 |
left:= 4 - cScreenWidth div 2; |
79e07510b8e3
Touch: Fix chat rendered on top of turn timer
Wuzzy <Wuzzy2@mail.ru>
parents:
13898
diff
changeset
|
305 |
top := 55 + visibleCount * ClHeight; // we start with input line (if any) |
79e07510b8e3
Touch: Fix chat rendered on top of turn timer
Wuzzy <Wuzzy2@mail.ru>
parents:
13898
diff
changeset
|
306 |
{$ELSE} |
10303 | 307 |
left:= 4 - cScreenWidth div 2; |
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
308 |
top := 10 + visibleCount * ClHeight; // we start with input line (if any) |
14321
79e07510b8e3
Touch: Fix chat rendered on top of turn timer
Wuzzy <Wuzzy2@mail.ru>
parents:
13898
diff
changeset
|
309 |
{$ENDIF} |
1431 | 310 |
|
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
311 |
// draw chat input line first and under all other lines |
13077 | 312 |
if isInChatMode and (InputStr.Tex <> nil) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
313 |
begin |
10850
c76ea22ea249
copy to/paste from system clipboard (via frontend)
sheepluva
parents:
10849
diff
changeset
|
314 |
|
10852
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
315 |
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
|
316 |
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
|
317 |
|
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
318 |
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
|
319 |
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
|
320 |
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
|
321 |
|
10842
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
322 |
if firstDraw then |
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
323 |
begin |
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
324 |
UpdateCursorCoords(); |
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
325 |
firstDraw:= false; |
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
326 |
end; |
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
327 |
|
10836 | 328 |
if selectedPos < 0 then |
329 |
begin |
|
330 |
// draw cursor |
|
331 |
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
|
332 |
DrawLineOnScreen(left + cursorX, top + 2, left + cursorX, top + ClHeight - 2, 2.0, $00, $FF, $FF, $FF); |
10836 | 333 |
end |
334 |
else // draw selection |
|
335 |
begin |
|
336 |
selRect.y:= top + 2; |
|
337 |
selRect.h:= clHeight - 4; |
|
338 |
if selectionDx < 0 then |
|
339 |
begin |
|
10839
aa0ceb47da1d
make sure cursor drawing position does not get messed up by screen resize
sheepluva
parents:
10837
diff
changeset
|
340 |
selRect.x:= left + cursorX + selectionDx; |
10836 | 341 |
selRect.w:= -selectionDx; |
342 |
end |
|
343 |
else |
|
344 |
begin |
|
10839
aa0ceb47da1d
make sure cursor drawing position does not get messed up by screen resize
sheepluva
parents:
10837
diff
changeset
|
345 |
selRect.x:= left + cursorX; |
10836 | 346 |
selRect.w:= selectionDx; |
347 |
end; |
|
1431 | 348 |
|
10836 | 349 |
DrawRect(selRect, $FF, $FF, $FF, $40, true); |
350 |
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
|
351 |
|
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
352 |
dec(left, InputLinePrefix.Width); |
10866 | 353 |
|
1431 | 354 |
|
10866 | 355 |
if (Length(InputStr.s) > 0) and ((CursorPos = 1) or (CursorPos = 2)) then |
356 |
begin |
|
357 |
c:= InputStr.s[1]; |
|
358 |
if charIsForHogSpeech(c) then |
|
359 |
begin |
|
10868
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
360 |
SpeechHogNumber:= 0; |
10866 | 361 |
if Length(InputStr.s) > 1 then |
362 |
begin |
|
363 |
c:= InputStr.s[2]; |
|
364 |
if (c > '0') and (c < '9') then |
|
365 |
SpeechHogNumber:= byte(c) - 48; |
|
366 |
end; |
|
10868
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
367 |
// default to current hedgehog (if own) or first hedgehog |
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
368 |
if SpeechHogNumber = 0 then |
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
369 |
begin |
14799
bbec6b28d072
Fix bugs when entering speech bubble commands during hog placement phase
Wuzzy <Wuzzy2@mail.ru>
parents:
14399
diff
changeset
|
370 |
if (not CurrentTeam^.ExtDriven) and (not CurrentHedgehog^.Unplaced) then |
10868
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
371 |
SpeechHogNumber:= CurrentTeam^.CurrHedgehog + 1 |
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
372 |
else |
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
373 |
SpeechHogNumber:= 1; |
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
374 |
end; |
10866 | 375 |
end; |
376 |
end |
|
377 |
else |
|
10868
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
378 |
SpeechHogNumber:= -1; |
10866 | 379 |
end |
380 |
else |
|
10868
acb03a9712c3
show correct default if current team is local team
sheepluva
parents:
10866
diff
changeset
|
381 |
SpeechHogNumber:= -1; |
1431 | 382 |
|
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
|
383 |
// draw chat lines |
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
384 |
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
|
385 |
begin |
10375 | 386 |
if MissedCount <> 0 then // there are chat strings we missed, so print them now |
387 |
begin |
|
388 |
for i:= 0 to MissedCount - 1 do |
|
389 |
AddChatString(MStrs[i]); |
|
390 |
MissedCount:= 0; |
|
391 |
end; |
|
392 |
i:= lastStr; |
|
10303 | 393 |
|
10375 | 394 |
cnt:= 0; // count of lines displayed |
395 |
t := 1; // # of current line processed |
|
2376 | 396 |
|
10375 | 397 |
// draw lines in reverse order |
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
398 |
while (((t < 7) and (Strs[i].Time > RealTicks)) or ((t <= MaxStrIndex + 1) and showAll)) |
10375 | 399 |
and (Strs[i].Tex <> nil) do |
400 |
begin |
|
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
401 |
top:= top - ClHeight; |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
402 |
// draw chatline only if not offscreen |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
403 |
if top > 0 then |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
404 |
DrawTexture(left, top, Strs[i].Tex); |
8745 | 405 |
|
10375 | 406 |
if i = 0 then |
407 |
i:= MaxStrIndex |
|
408 |
else |
|
409 |
dec(i); |
|
410 |
||
411 |
inc(cnt); |
|
412 |
inc(t) |
|
413 |
end; |
|
414 |
||
415 |
visibleCount:= cnt; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
416 |
end; |
942 | 417 |
end; |
418 |
||
4467 | 419 |
procedure SendHogSpeech(s: shortstring); |
420 |
begin |
|
421 |
SendIPC('h' + s); |
|
422 |
ParseCommand('/hogsay '+s, true) |
|
423 |
end; |
|
424 |
||
10392 | 425 |
procedure SendConsoleCommand(s: shortstring); |
426 |
begin |
|
427 |
Delete(s, 1, 1); |
|
428 |
SendIPC('~' + s) |
|
429 |
end; |
|
430 |
||
1033 | 431 |
procedure AcceptChatString(s: shortstring); |
1035 | 432 |
var i: TWave; |
8152 | 433 |
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
|
434 |
c, t: LongInt; |
4467 | 435 |
x: byte; |
1033 | 436 |
begin |
10513
58fa783e0cfd
fixes to chat input history: remember all inputs, don not remember duplicates
sheepluva
parents:
10396
diff
changeset
|
437 |
if s <> LocalStrs[localLastStr] then |
58fa783e0cfd
fixes to chat input history: remember all inputs, don not remember duplicates
sheepluva
parents:
10396
diff
changeset
|
438 |
begin |
58fa783e0cfd
fixes to chat input history: remember all inputs, don not remember duplicates
sheepluva
parents:
10396
diff
changeset
|
439 |
// put in input history |
58fa783e0cfd
fixes to chat input history: remember all inputs, don not remember duplicates
sheepluva
parents:
10396
diff
changeset
|
440 |
localLastStr:= (localLastStr + 1) mod MaxStrIndex; |
58fa783e0cfd
fixes to chat input history: remember all inputs, don not remember duplicates
sheepluva
parents:
10396
diff
changeset
|
441 |
LocalStrs[localLastStr]:= s; |
58fa783e0cfd
fixes to chat input history: remember all inputs, don not remember duplicates
sheepluva
parents:
10396
diff
changeset
|
442 |
end; |
58fa783e0cfd
fixes to chat input history: remember all inputs, don not remember duplicates
sheepluva
parents:
10396
diff
changeset
|
443 |
|
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
|
444 |
t:= LocalTeam; |
4467 | 445 |
x:= 0; |
13853
d1f7a8a11526
Ignore message-type chat commands (/hsa, /clan, etc.) w/ empty arg list
Wuzzy <Wuzzy2@mail.ru>
parents:
13852
diff
changeset
|
446 |
// speech bubble |
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 |
|
13853
d1f7a8a11526
Ignore message-type chat commands (/hsa, /clan, etc.) w/ empty arg list
Wuzzy <Wuzzy2@mail.ru>
parents:
13852
diff
changeset
|
450 |
// thinking bubble |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
451 |
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
|
452 |
x:= 2 |
8745 | 453 |
|
13853
d1f7a8a11526
Ignore message-type chat commands (/hsa, /clan, etc.) w/ empty arg list
Wuzzy <Wuzzy2@mail.ru>
parents:
13852
diff
changeset
|
454 |
// yelling bubble |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6453
diff
changeset
|
455 |
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
|
456 |
x:= 3; |
8745 | 457 |
|
13861
2b6702777c8c
Backed out changeset 6e4e745f42bb. Devs are hating it for ... reasons
Wuzzy <Wuzzy2@mail.ru>
parents:
13860
diff
changeset
|
458 |
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
|
459 |
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
|
460 |
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
|
461 |
t:= c; |
4467 | 462 |
|
463 |
if x <> 0 then |
|
2017 | 464 |
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
|
465 |
if t = -1 then |
2111 | 466 |
ParseCommand('/say ' + copy(s, 2, Length(s)-2), true) |
467 |
else |
|
4467 | 468 |
SendHogSpeech(char(x) + char(t) + copy(s, 2, Length(s)-2)); |
2017 | 469 |
exit |
470 |
end; |
|
4467 | 471 |
|
9669 | 472 |
if (s[1] = '/') then |
2017 | 473 |
begin |
13865
184584b82c4c
Catch empty chat commands in engine and frontend
Wuzzy <Wuzzy2@mail.ru>
parents:
13861
diff
changeset
|
474 |
if (Length(s) <= 1) then |
184584b82c4c
Catch empty chat commands in engine and frontend
Wuzzy <Wuzzy2@mail.ru>
parents:
13861
diff
changeset
|
475 |
begin |
184584b82c4c
Catch empty chat commands in engine and frontend
Wuzzy <Wuzzy2@mail.ru>
parents:
13861
diff
changeset
|
476 |
// empty chat command |
13898 | 477 |
AddChatString(#0 + shortstring(trcmd[sidCmdUnknown])); |
13865
184584b82c4c
Catch empty chat commands in engine and frontend
Wuzzy <Wuzzy2@mail.ru>
parents:
13861
diff
changeset
|
478 |
exit; |
184584b82c4c
Catch empty chat commands in engine and frontend
Wuzzy <Wuzzy2@mail.ru>
parents:
13861
diff
changeset
|
479 |
end; |
13853
d1f7a8a11526
Ignore message-type chat commands (/hsa, /clan, etc.) w/ empty arg list
Wuzzy <Wuzzy2@mail.ru>
parents:
13852
diff
changeset
|
480 |
|
d1f7a8a11526
Ignore message-type chat commands (/hsa, /clan, etc.) w/ empty arg list
Wuzzy <Wuzzy2@mail.ru>
parents:
13852
diff
changeset
|
481 |
// Ignore message-type commands with empty argument list |
d1f7a8a11526
Ignore message-type chat commands (/hsa, /clan, etc.) w/ empty arg list
Wuzzy <Wuzzy2@mail.ru>
parents:
13852
diff
changeset
|
482 |
if (copy(s, 2, 2) = 'me') and (Length(s) = 3) then |
d1f7a8a11526
Ignore message-type chat commands (/hsa, /clan, etc.) w/ empty arg list
Wuzzy <Wuzzy2@mail.ru>
parents:
13852
diff
changeset
|
483 |
exit; |
d1f7a8a11526
Ignore message-type chat commands (/hsa, /clan, etc.) w/ empty arg list
Wuzzy <Wuzzy2@mail.ru>
parents:
13852
diff
changeset
|
484 |
if ((copy(s, 2, 3) = 'hsa') or (copy(s, 2, 3) = 'hta') or (copy(s, 2, 3) = 'hya')) and (Length(s) = 4) then |
d1f7a8a11526
Ignore message-type chat commands (/hsa, /clan, etc.) w/ empty arg list
Wuzzy <Wuzzy2@mail.ru>
parents:
13852
diff
changeset
|
485 |
exit; |
d1f7a8a11526
Ignore message-type chat commands (/hsa, /clan, etc.) w/ empty arg list
Wuzzy <Wuzzy2@mail.ru>
parents:
13852
diff
changeset
|
486 |
if ((copy(s, 2, 4) = 'team') or (copy(s, 2, 4) = 'clan')) and (Length(s) = 5) then |
d1f7a8a11526
Ignore message-type chat commands (/hsa, /clan, etc.) w/ empty arg list
Wuzzy <Wuzzy2@mail.ru>
parents:
13852
diff
changeset
|
487 |
exit; |
d1f7a8a11526
Ignore message-type chat commands (/hsa, /clan, etc.) w/ empty arg list
Wuzzy <Wuzzy2@mail.ru>
parents:
13852
diff
changeset
|
488 |
|
d1f7a8a11526
Ignore message-type chat commands (/hsa, /clan, etc.) w/ empty arg list
Wuzzy <Wuzzy2@mail.ru>
parents:
13852
diff
changeset
|
489 |
// Speech bubble, but on next attack |
10304
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
490 |
if (copy(s, 2, 4) = 'hsa ') then |
9669 | 491 |
begin |
13861
2b6702777c8c
Backed out changeset 6e4e745f42bb. Devs are hating it for ... reasons
Wuzzy <Wuzzy2@mail.ru>
parents:
13860
diff
changeset
|
492 |
if CurrentTeam^.ExtDriven then |
9669 | 493 |
ParseCommand('/say ' + copy(s, 6, Length(s)-5), true) |
494 |
else |
|
495 |
SendHogSpeech(#4 + copy(s, 6, Length(s)-5)); |
|
496 |
exit |
|
497 |
end; |
|
498 |
||
13853
d1f7a8a11526
Ignore message-type chat commands (/hsa, /clan, etc.) w/ empty arg list
Wuzzy <Wuzzy2@mail.ru>
parents:
13852
diff
changeset
|
499 |
// Thinking bubble, but on next attack |
10304
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
500 |
if (copy(s, 2, 4) = 'hta ') then |
9669 | 501 |
begin |
13861
2b6702777c8c
Backed out changeset 6e4e745f42bb. Devs are hating it for ... reasons
Wuzzy <Wuzzy2@mail.ru>
parents:
13860
diff
changeset
|
502 |
if CurrentTeam^.ExtDriven then |
9669 | 503 |
ParseCommand('/say ' + copy(s, 6, Length(s)-5), true) |
504 |
else |
|
505 |
SendHogSpeech(#5 + copy(s, 6, Length(s)-5)); |
|
506 |
exit |
|
507 |
end; |
|
508 |
||
13853
d1f7a8a11526
Ignore message-type chat commands (/hsa, /clan, etc.) w/ empty arg list
Wuzzy <Wuzzy2@mail.ru>
parents:
13852
diff
changeset
|
509 |
// Yelling bubble, but on next attack |
10304
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
510 |
if (copy(s, 2, 4) = 'hya ') then |
9669 | 511 |
begin |
13861
2b6702777c8c
Backed out changeset 6e4e745f42bb. Devs are hating it for ... reasons
Wuzzy <Wuzzy2@mail.ru>
parents:
13860
diff
changeset
|
512 |
if CurrentTeam^.ExtDriven then |
9669 | 513 |
ParseCommand('/say ' + copy(s, 6, Length(s)-5), true) |
514 |
else |
|
515 |
SendHogSpeech(#6 + copy(s, 6, Length(s)-5)); |
|
516 |
exit |
|
517 |
end; |
|
2111 | 518 |
|
14387
2ab312c47dc3
make pas2c function without haskell aborting if locale is C
nemo
parents:
14321
diff
changeset
|
519 |
// "/clan" or "/team" ("/team" is an alias for "/clan") |
13893
65fe3933b19d
No-op when entering /clan command with no argument
Wuzzy <Wuzzy2@mail.ru>
parents:
13865
diff
changeset
|
520 |
if ((copy(s, 2, 5) = 'clan ') or (copy(s, 2, 5) = 'team ')) then |
9669 | 521 |
begin |
13893
65fe3933b19d
No-op when entering /clan command with no argument
Wuzzy <Wuzzy2@mail.ru>
parents:
13865
diff
changeset
|
522 |
if (Length(s) > 6) then |
65fe3933b19d
No-op when entering /clan command with no argument
Wuzzy <Wuzzy2@mail.ru>
parents:
13865
diff
changeset
|
523 |
ParseCommand('team ' + copy(s, 7, Length(s) - 6), true); |
9669 | 524 |
exit |
525 |
end; |
|
526 |
||
10304
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
527 |
if (copy(s, 2, 3) = 'me ') then |
9669 | 528 |
begin |
9680 | 529 |
ParseCommand('/say ' + s, true); |
530 |
exit |
|
531 |
end; |
|
2376 | 532 |
|
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
533 |
if (copy(s, 2, 10) = 'togglechat') then |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
534 |
begin |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
535 |
ChatHidden:= (not ChatHidden); |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
536 |
if ChatHidden then |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
537 |
showAll:= false; |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
538 |
exit |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
539 |
end; |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
540 |
|
10304
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
541 |
// debugging commands |
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
542 |
if (copy(s, 2, 7) = 'debugvl') then |
13463 | 543 |
// This command intentionally not documented in /help |
10304
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
544 |
begin |
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
545 |
cViewLimitsDebug:= (not cViewLimitsDebug); |
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
546 |
UpdateViewLimits(); |
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
547 |
exit |
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
548 |
end; |
7e40820b7ed6
fix gl2 build, further rendering cleanup WIP, also new chat command: /debugvl
sheepluva
parents:
10303
diff
changeset
|
549 |
|
10312 | 550 |
if (copy(s, 2, 3) = 'lua') then |
551 |
begin |
|
15288
22f2fd8a3d2c
VideoRec: Stop prerecording when /lua activates
Wuzzy <Wuzzy2@mail.ru>
parents:
14799
diff
changeset
|
552 |
LuaCmdUsed:= true; |
10312 | 553 |
AddFileLog('/lua issued'); |
15288
22f2fd8a3d2c
VideoRec: Stop prerecording when /lua activates
Wuzzy <Wuzzy2@mail.ru>
parents:
14799
diff
changeset
|
554 |
{$IFDEF USE_VIDEO_RECORDING} |
22f2fd8a3d2c
VideoRec: Stop prerecording when /lua activates
Wuzzy <Wuzzy2@mail.ru>
parents:
14799
diff
changeset
|
555 |
if flagPrerecording then |
22f2fd8a3d2c
VideoRec: Stop prerecording when /lua activates
Wuzzy <Wuzzy2@mail.ru>
parents:
14799
diff
changeset
|
556 |
begin |
22f2fd8a3d2c
VideoRec: Stop prerecording when /lua activates
Wuzzy <Wuzzy2@mail.ru>
parents:
14799
diff
changeset
|
557 |
AddFileLog('Force-stopping prerecording! Lua commands can not be recorded'); |
22f2fd8a3d2c
VideoRec: Stop prerecording when /lua activates
Wuzzy <Wuzzy2@mail.ru>
parents:
14799
diff
changeset
|
558 |
StopPreRecording; |
22f2fd8a3d2c
VideoRec: Stop prerecording when /lua activates
Wuzzy <Wuzzy2@mail.ru>
parents:
14799
diff
changeset
|
559 |
end; |
22f2fd8a3d2c
VideoRec: Stop prerecording when /lua activates
Wuzzy <Wuzzy2@mail.ru>
parents:
14799
diff
changeset
|
560 |
{$ENDIF} |
10312 | 561 |
if gameType <> gmtNet then |
562 |
begin |
|
563 |
liveLua:= (not liveLua); |
|
564 |
if liveLua then |
|
565 |
begin |
|
566 |
AddFileLog('[Lua] chat input string parsing enabled'); |
|
13898 | 567 |
AddChatString(#3 + shortstring(trmsg[sidLuaParsingOn])); |
10312 | 568 |
end |
569 |
else |
|
570 |
begin |
|
571 |
AddFileLog('[Lua] chat input string parsing disabled'); |
|
13898 | 572 |
AddChatString(#3 + shortstring(trmsg[sidLuaParsingOff])); |
10312 | 573 |
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
|
574 |
UpdateInputLinePrefix(); |
13464
32032120435c
Tweak chat command replies for /lua command
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset
|
575 |
end |
32032120435c
Tweak chat command replies for /lua command
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset
|
576 |
else |
13898 | 577 |
AddChatString(#5 + shortstring(trmsg[sidLuaParsingDenied])); |
10312 | 578 |
exit |
579 |
end; |
|
580 |
||
13463 | 581 |
// Help commands |
582 |
if (copy(s, 2, 11) = 'help taunts') then |
|
583 |
begin |
|
13898 | 584 |
AddChatString(#3 + shortstring(trcmd[sidCmdHeaderTaunts])); |
585 |
AddChatString(#3 + shortstring(trcmd[sidCmdSpeech])); |
|
586 |
AddChatString(#3 + shortstring(trcmd[sidCmdThink])); |
|
587 |
AddChatString(#3 + shortstring(trcmd[sidCmdYell])); |
|
588 |
AddChatString(#3 + shortstring(trcmd[sidCmdSpeechNumberHint])); |
|
589 |
AddChatString(#3 + shortstring(trcmd[sidCmdHsa])); |
|
590 |
AddChatString(#3 + shortstring(trcmd[sidCmdHta])); |
|
591 |
AddChatString(#3 + shortstring(trcmd[sidCmdHya])); |
|
592 |
AddChatString(#3 + shortstring(trcmd[sidCmdHurrah])); |
|
593 |
AddChatString(#3 + shortstring(trcmd[sidCmdIlovelotsoflemonade])); |
|
594 |
AddChatString(#3 + shortstring(trcmd[sidCmdJuggle])); |
|
595 |
AddChatString(#3 + shortstring(trcmd[sidCmdRollup])); |
|
596 |
AddChatString(#3 + shortstring(trcmd[sidCmdShrug])); |
|
597 |
AddChatString(#3 + shortstring(trcmd[sidCmdWave])); |
|
13463 | 598 |
exit |
599 |
end; |
|
600 |
||
14399
4edc73fc722c
Add chat command "/help room" to show room help in game
Wuzzy <Wuzzy2@mail.ru>
parents:
14387
diff
changeset
|
601 |
if (copy(s, 2, 9) = 'help room') then |
4edc73fc722c
Add chat command "/help room" to show room help in game
Wuzzy <Wuzzy2@mail.ru>
parents:
14387
diff
changeset
|
602 |
begin |
4edc73fc722c
Add chat command "/help room" to show room help in game
Wuzzy <Wuzzy2@mail.ru>
parents:
14387
diff
changeset
|
603 |
if (gameType = gmtNet) then |
4edc73fc722c
Add chat command "/help room" to show room help in game
Wuzzy <Wuzzy2@mail.ru>
parents:
14387
diff
changeset
|
604 |
SendConsoleCommand('/help') |
4edc73fc722c
Add chat command "/help room" to show room help in game
Wuzzy <Wuzzy2@mail.ru>
parents:
14387
diff
changeset
|
605 |
else |
4edc73fc722c
Add chat command "/help room" to show room help in game
Wuzzy <Wuzzy2@mail.ru>
parents:
14387
diff
changeset
|
606 |
AddChatString(#0 + shortstring(trcmd[sidCmdHelpRoomFail])); |
4edc73fc722c
Add chat command "/help room" to show room help in game
Wuzzy <Wuzzy2@mail.ru>
parents:
14387
diff
changeset
|
607 |
exit; |
4edc73fc722c
Add chat command "/help room" to show room help in game
Wuzzy <Wuzzy2@mail.ru>
parents:
14387
diff
changeset
|
608 |
end; |
4edc73fc722c
Add chat command "/help room" to show room help in game
Wuzzy <Wuzzy2@mail.ru>
parents:
14387
diff
changeset
|
609 |
|
13463 | 610 |
if (copy(s, 2, 4) = 'help') then |
611 |
begin |
|
13898 | 612 |
AddChatString(#3 + shortstring(trcmd[sidCmdHeaderBasic])); |
13463 | 613 |
if gameType = gmtNet then |
13898 | 614 |
AddChatString(#3 + shortstring(trcmd[sidCmdPauseNet])) |
13463 | 615 |
else |
13898 | 616 |
AddChatString(#3 + shortstring(trcmd[sidCmdPause])); |
617 |
AddChatString(#3 + shortstring(trcmd[sidCmdFullscreen])); |
|
618 |
AddChatString(#3 + shortstring(trcmd[sidCmdQuit])); |
|
13463 | 619 |
if gameType <> gmtNet then |
13898 | 620 |
AddChatString(#3 + shortstring(trcmd[sidLua])); |
13463 | 621 |
// history and help commands needs to be close to the end because they are always visible |
622 |
// with a short chat history length. |
|
13898 | 623 |
AddChatString(#3 + shortstring(trcmd[sidCmdTeam])); |
624 |
AddChatString(#3 + shortstring(trcmd[sidCmdMe])); |
|
625 |
AddChatString(#3 + shortstring(trcmd[sidCmdTogglechat])); |
|
626 |
AddChatString(#3 + shortstring(trcmd[sidCmdHistory])); |
|
627 |
AddChatString(#3 + shortstring(trcmd[sidCmdHelp])); |
|
628 |
AddChatString(#3 + shortstring(trcmd[sidCmdHelpTaunts])); |
|
14399
4edc73fc722c
Add chat command "/help room" to show room help in game
Wuzzy <Wuzzy2@mail.ru>
parents:
14387
diff
changeset
|
629 |
if gameType = gmtNet then |
4edc73fc722c
Add chat command "/help room" to show room help in game
Wuzzy <Wuzzy2@mail.ru>
parents:
14387
diff
changeset
|
630 |
AddChatString(#3 + shortstring(trcmd[sidCmdHelpRoom])); |
13463 | 631 |
exit |
632 |
end; |
|
633 |
||
10312 | 634 |
// hedghog animations/taunts and engine commands |
9680 | 635 |
if (not CurrentTeam^.ExtDriven) and (CurrentTeam^.Hedgehogs[0].BotLevel = 0) then |
636 |
begin |
|
9669 | 637 |
for i:= Low(TWave) to High(TWave) do |
638 |
if (s = Wavez[i].cmd) then |
|
639 |
begin |
|
640 |
ParseCommand('/taunt ' + char(i), true); |
|
641 |
exit |
|
642 |
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
|
643 |
end; |
8152 | 644 |
|
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
|
645 |
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
|
646 |
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
|
647 |
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
|
648 |
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
|
649 |
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
|
650 |
end; |
10392 | 651 |
|
652 |
if (gameType = gmtNet) then |
|
653 |
SendConsoleCommand(s) |
|
13847
93aa09004d36
Display error when entering invalid chat command in offline game
Wuzzy <Wuzzy2@mail.ru>
parents:
13744
diff
changeset
|
654 |
else |
13898 | 655 |
AddChatString(#0 + shortstring(trcmd[sidCmdUnknown])); |
2017 | 656 |
end |
10312 | 657 |
else |
658 |
begin |
|
659 |
if liveLua then |
|
660 |
LuaParseString(s) |
|
9676 | 661 |
else |
662 |
ParseCommand('/say ' + s, true); |
|
2017 | 663 |
end; |
1033 | 664 |
end; |
665 |
||
8738 | 666 |
procedure CleanupInput; |
667 |
begin |
|
668 |
FreezeEnterKey; |
|
669 |
history:= 0; |
|
9697 | 670 |
SDL_StopTextInput(); |
11365 | 671 |
//SDL_EnableKeyRepeat(0,0); |
13077 | 672 |
isInChatMode:= false; |
8738 | 673 |
ResetKbd; |
674 |
end; |
|
675 |
||
10836 | 676 |
procedure DelBytesFromInputStrBack(endIdx: integer; count: byte); |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
677 |
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
|
678 |
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
|
679 |
// 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
|
680 |
if count = 0 then |
4121 | 681 |
exit; |
2376 | 682 |
|
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
|
683 |
// 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
|
684 |
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
|
685 |
|
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
|
686 |
// 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
|
687 |
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
|
688 |
|
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
|
689 |
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
|
690 |
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
|
691 |
|
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
692 |
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
|
693 |
begin |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
694 |
if cursorPos > 0 then |
10926
43612076e989
chat: simplify some code and fix bugs I noticed during testing
sheepluva
parents:
10921
diff
changeset
|
695 |
repeat |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
696 |
dec(cursorPos); |
10926
43612076e989
chat: simplify some code and fix bugs I noticed during testing
sheepluva
parents:
10921
diff
changeset
|
697 |
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
|
698 |
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
|
699 |
|
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
700 |
procedure MoveCursorToNextChar(); |
10926
43612076e989
chat: simplify some code and fix bugs I noticed during testing
sheepluva
parents:
10921
diff
changeset
|
701 |
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
|
702 |
begin |
10926
43612076e989
chat: simplify some code and fix bugs I noticed during testing
sheepluva
parents:
10921
diff
changeset
|
703 |
len:= Length(InputStr.s); |
43612076e989
chat: simplify some code and fix bugs I noticed during testing
sheepluva
parents:
10921
diff
changeset
|
704 |
if cursorPos < len then |
43612076e989
chat: simplify some code and fix bugs I noticed during testing
sheepluva
parents:
10921
diff
changeset
|
705 |
repeat |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
706 |
inc(cursorPos); |
10926
43612076e989
chat: simplify some code and fix bugs I noticed during testing
sheepluva
parents:
10921
diff
changeset
|
707 |
until ((cursorPos = len) or IsFirstCharByte(InputStr.s[cursorPos + 1])); |
10836 | 708 |
end; |
709 |
||
10921 | 710 |
procedure DeleteLastUTF8CharFromStr(var s: shortstring); |
711 |
var l: byte; |
|
712 |
begin |
|
713 |
l:= Length(s); |
|
714 |
||
715 |
while (l > 1) and (not IsFirstCharByte(s[l])) do |
|
716 |
begin |
|
717 |
dec(l); |
|
718 |
end; |
|
719 |
||
720 |
if l > 0 then |
|
721 |
dec(l); |
|
722 |
||
723 |
s[0]:= char(l); |
|
724 |
end; |
|
725 |
||
10836 | 726 |
procedure DeleteSelected(); |
727 |
begin |
|
728 |
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
|
729 |
begin |
10836 | 730 |
DelBytesFromInputStrBack(max(cursorPos, selectedPos), abs(selectedPos-cursorPos)); |
731 |
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
|
732 |
end; |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
733 |
ResetSelection(); |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
734 |
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
|
735 |
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
|
736 |
|
10836 | 737 |
procedure HandleSelection(enabled: boolean); |
738 |
begin |
|
739 |
if enabled then |
|
740 |
begin |
|
741 |
if selectedPos < 0 then |
|
742 |
selectedPos:= cursorPos; |
|
2017 | 743 |
end |
10836 | 744 |
else |
745 |
ResetSelection(); |
|
746 |
end; |
|
747 |
||
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
748 |
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
|
749 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
750 |
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
|
751 |
var c: char; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
752 |
begin |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
753 |
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
|
754 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
755 |
// 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
|
756 |
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
|
757 |
exit(numalpha); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
758 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
759 |
// 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
|
760 |
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
|
761 |
exit(wspace); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
762 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
763 |
// 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
|
764 |
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
|
765 |
exit(special); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
766 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
767 |
// digits |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
768 |
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
|
769 |
exit(numalpha); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
770 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
771 |
// 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
|
772 |
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
|
773 |
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
|
774 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
775 |
// letters |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
776 |
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
|
777 |
exit(numalpha); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
778 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
779 |
// 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
|
780 |
exit(special); |
1033 | 781 |
end; |
782 |
||
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
783 |
// skip from word to word, similar to Qt |
10845
1dbd50690951
quick word deletion while holding ctrl (qt style)
sheepluva
parents:
10844
diff
changeset
|
784 |
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
|
785 |
begin |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
786 |
if backwards then |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
787 |
begin |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
788 |
// 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
|
789 |
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
|
790 |
begin |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
791 |
skip:= GetInputCharSkipClass(cursorPos); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
792 |
if skip = wspace then |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
793 |
MoveCursorToPreviousChar(); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
794 |
end; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
795 |
// 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
|
796 |
while (cursorPos > 0) and (GetInputCharSkipClass(cursorPos) = skip) do |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
797 |
MoveCursorToPreviousChar(); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
798 |
end |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
799 |
else |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
800 |
begin |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
801 |
// 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
|
802 |
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
|
803 |
begin |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
804 |
MoveCursorToNextChar(); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
805 |
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
|
806 |
begin |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
807 |
MoveCursorToPreviousChar(); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
808 |
break; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
809 |
end; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
810 |
end; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
811 |
// 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
|
812 |
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
|
813 |
begin |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
814 |
MoveCursorToNextChar(); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
815 |
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
|
816 |
begin |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
817 |
MoveCursorToPreviousChar(); |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
818 |
break; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
819 |
end; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
820 |
end; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
821 |
end; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
822 |
end; |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
823 |
|
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
824 |
procedure CopyToClipboard(var newContent: shortstring); |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
825 |
begin |
11364 | 826 |
// SDL2 clipboard |
827 |
SDL_SetClipboardText(Str2PChar(newContent)); |
|
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
828 |
end; |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
829 |
|
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
830 |
procedure CopySelectionToClipboard(); |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
831 |
var selection: shortstring; |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
832 |
begin |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
833 |
if selectedPos >= 0 then |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
834 |
begin |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
835 |
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
|
836 |
CopyToClipboard(selection); |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
837 |
end; |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
838 |
end; |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
839 |
|
10853 | 840 |
procedure InsertIntoInputStr(s: shortstring); |
10921 | 841 |
var limit: integer; |
946 | 842 |
begin |
10921 | 843 |
// we check limit for trailing stuff before insertion limit for a reason |
844 |
// (possible remaining space after too long UTF8-insertion has been shortened) |
|
845 |
||
846 |
// length limit for stuff to that will trail the insertion |
|
847 |
limit:= max(cursorPos, MaxInputStrLen-Length(s)); |
|
848 |
||
849 |
while Length(InputStr.s) > limit do |
|
850 |
begin |
|
851 |
DeleteLastUTF8CharFromStr(InputStr.s); |
|
852 |
end; |
|
853 |
||
854 |
// length limit for stuff to insert |
|
855 |
limit:= max(0, MaxInputStrLen-cursorPos); |
|
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
856 |
|
10921 | 857 |
if limit = 0 then |
858 |
s:= '' |
|
859 |
else while Length(s) > limit do |
|
860 |
begin |
|
861 |
DeleteLastUTF8CharFromStr(s); |
|
862 |
end; |
|
10851
f25dad9c3136
chat/copypaste: some adjustments and sanity checks
sheepluva
parents:
10850
diff
changeset
|
863 |
|
10921 | 864 |
if Length(s) > 0 then |
865 |
begin |
|
866 |
// insert string truncated to safe length |
|
867 |
Insert(s, InputStr.s, cursorPos + 1); |
|
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
868 |
|
10921 | 869 |
if Length(InputStr.s) > MaxInputStrLen then |
870 |
InputStr.s[0]:= char(MaxInputStrLen); |
|
871 |
||
872 |
SetLine(InputStr, InputStr.s, true); |
|
873 |
||
874 |
// move cursor to end of inserted string |
|
875 |
inc(cursorPos, Length(s)); |
|
876 |
UpdateCursorCoords(); |
|
877 |
end; |
|
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
878 |
end; |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
879 |
|
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
880 |
procedure PasteFromClipboard(); |
11363 | 881 |
var clip: PChar; |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
882 |
begin |
11363 | 883 |
// use SDL2 clipboard functions |
884 |
if SDL_HasClipboardText() then |
|
10850
c76ea22ea249
copy to/paste from system clipboard (via frontend)
sheepluva
parents:
10849
diff
changeset
|
885 |
begin |
11363 | 886 |
clip:= SDL_GetClipboardText(); |
887 |
// returns NULL if not enough memory for a copy of clipboard content |
|
888 |
if clip <> nil then |
|
889 |
begin |
|
890 |
InsertIntoInputStr(shortstring(clip)); |
|
891 |
SDL_free(Pointer(clip)); |
|
892 |
end; |
|
10850
c76ea22ea249
copy to/paste from system clipboard (via frontend)
sheepluva
parents:
10849
diff
changeset
|
893 |
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
|
894 |
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
|
895 |
|
11365 | 896 |
procedure KeyPressChat(keysym: TSDL_Keysym); |
11372 | 897 |
const nonStateMask = (not (KMOD_NUM or KMOD_CAPS)); |
898 |
var i, index: integer; |
|
899 |
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
|
900 |
skip: TCharSkip; |
11365 | 901 |
Scancode: TSDL_Scancode; |
902 |
Modifier: Word; |
|
946 | 903 |
begin |
11365 | 904 |
Scancode:= keysym.scancode; |
905 |
Modifier:= keysym.modifier; |
|
906 |
||
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
|
907 |
LastKeyPressTick:= RealTicks; |
10836 | 908 |
|
909 |
selMode:= (modifier and (KMOD_LSHIFT or KMOD_RSHIFT)) <> 0; |
|
910 |
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
|
911 |
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
|
912 |
skip:= none; |
10836 | 913 |
|
11365 | 914 |
case Scancode of |
915 |
SDL_SCANCODE_BACKSPACE: |
|
8743 | 916 |
begin |
10836 | 917 |
if selectedPos < 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
918 |
begin |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
919 |
HandleSelection(true); |
10845
1dbd50690951
quick word deletion while holding ctrl (qt style)
sheepluva
parents:
10844
diff
changeset
|
920 |
|
1dbd50690951
quick word deletion while holding ctrl (qt style)
sheepluva
parents:
10844
diff
changeset
|
921 |
// delete more if ctrl is held |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
922 |
if ctrl then |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
923 |
SkipInputChars(GetInputCharSkipClass(cursorPos), true) |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
924 |
else |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
925 |
MoveCursorToPreviousChar(); |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
926 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
927 |
end; |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
928 |
|
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
929 |
DeleteSelected(); |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
930 |
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
|
931 |
end; |
11365 | 932 |
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
|
933 |
begin |
10836 | 934 |
if selectedPos < 0 then |
5100 | 935 |
begin |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
936 |
HandleSelection(true); |
10845
1dbd50690951
quick word deletion while holding ctrl (qt style)
sheepluva
parents:
10844
diff
changeset
|
937 |
|
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
938 |
// delete more if ctrl is held |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
939 |
if ctrl then |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
940 |
SkipInputChars(GetInputCharSkipClass(cursorPos), false) |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
941 |
else |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
942 |
MoveCursorToNextChar(); |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
943 |
|
5100 | 944 |
end; |
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
945 |
|
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
946 |
DeleteSelected(); |
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
947 |
UpdateCursorCoords(); |
8743 | 948 |
end; |
11365 | 949 |
SDL_SCANCODE_ESCAPE: |
8743 | 950 |
begin |
8745 | 951 |
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
|
952 |
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
|
953 |
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
|
954 |
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
|
955 |
end |
8743 | 956 |
else CleanupInput |
957 |
end; |
|
11365 | 958 |
SDL_SCANCODE_RETURN, SDL_SCANCODE_KP_ENTER: |
8743 | 959 |
begin |
960 |
if Length(InputStr.s) > 0 then |
|
8742
b7b8bd398c1b
Key returned 0 for arrows under linux. Sym works, clearer anyway.
nemo
parents:
8741
diff
changeset
|
961 |
begin |
8743 | 962 |
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
|
963 |
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
|
964 |
ResetCursor(); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
965 |
end; |
8743 | 966 |
CleanupInput |
967 |
end; |
|
11365 | 968 |
SDL_SCANCODE_UP, SDL_SCANCODE_DOWN: |
8743 | 969 |
begin |
11365 | 970 |
if (Scancode = SDL_SCANCODE_UP) and (history < localLastStr) then inc(history); |
971 |
if (Scancode = SDL_SCANCODE_DOWN) and (history > 0) then dec(history); |
|
8743 | 972 |
index:= localLastStr - history + 1; |
973 |
if (index > localLastStr) then |
|
10835
8ac09cd322b7
fix chat input history not restoring utf8-related info
sheepluva
parents:
10834
diff
changeset
|
974 |
begin |
8ac09cd322b7
fix chat input history not restoring utf8-related info
sheepluva
parents:
10834
diff
changeset
|
975 |
SetLine(InputStr, '', true); |
8ac09cd322b7
fix chat input history not restoring utf8-related info
sheepluva
parents:
10834
diff
changeset
|
976 |
end |
8ac09cd322b7
fix chat input history not restoring utf8-related info
sheepluva
parents:
10834
diff
changeset
|
977 |
else |
8ac09cd322b7
fix chat input history not restoring utf8-related info
sheepluva
parents:
10834
diff
changeset
|
978 |
begin |
8ac09cd322b7
fix chat input history not restoring utf8-related info
sheepluva
parents:
10834
diff
changeset
|
979 |
SetLine(InputStr, LocalStrs[index], true); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
980 |
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
|
981 |
cursorPos:= Length(InputStr.s); |
10836 | 982 |
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
|
983 |
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
|
984 |
end; |
11365 | 985 |
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
|
986 |
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
|
987 |
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
|
988 |
begin |
10836 | 989 |
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
|
990 |
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
|
991 |
end |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
992 |
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
|
993 |
ResetSelection(); |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
994 |
|
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
995 |
UpdateCursorCoords(); |
8745 | 996 |
end; |
11365 | 997 |
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
|
998 |
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
|
999 |
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
|
1000 |
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
|
1001 |
begin |
10836 | 1002 |
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
|
1003 |
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
|
1004 |
end |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
1005 |
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
|
1006 |
ResetSelection(); |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
1007 |
|
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
1008 |
UpdateCursorCoords(); |
8745 | 1009 |
end; |
11365 | 1010 |
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
|
1011 |
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
|
1012 |
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
|
1013 |
begin |
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
1014 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
1015 |
if ctrl then |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
1016 |
skip:= GetInputCharSkipClass(cursorPos); |
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
1017 |
|
10836 | 1018 |
if selMode or (selectedPos < 0) then |
1019 |
begin |
|
1020 |
HandleSelection(selMode); |
|
1021 |
// go to end of previous utf8-char |
|
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
1022 |
MoveCursorToPreviousChar(); |
10836 | 1023 |
end |
1024 |
else // if we're leaving selection mode, jump to its left end |
|
1025 |
begin |
|
1026 |
cursorPos:= min(cursorPos, selectedPos); |
|
1027 |
ResetSelection(); |
|
1028 |
end; |
|
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
1029 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
1030 |
if ctrl then |
10845
1dbd50690951
quick word deletion while holding ctrl (qt style)
sheepluva
parents:
10844
diff
changeset
|
1031 |
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
|
1032 |
|
10846
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
1033 |
end |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
1034 |
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
|
1035 |
ResetSelection(); |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
1036 |
|
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
1037 |
UpdateCursorCoords(); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
1038 |
end; |
11365 | 1039 |
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
|
1040 |
begin |
10836 | 1041 |
if cursorPos < Length(InputStr.s) then |
1042 |
begin |
|
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
1043 |
|
10836 | 1044 |
if selMode or (selectedPos < 0) then |
1045 |
begin |
|
1046 |
HandleSelection(selMode); |
|
10920
11a28d22985f
different implementation for utf-8 char detection/handling
sheepluva
parents:
10919
diff
changeset
|
1047 |
MoveCursorToNextChar(); |
10836 | 1048 |
end |
1049 |
else // if we're leaving selection mode, jump to its right end |
|
1050 |
begin |
|
1051 |
cursorPos:= max(cursorPos, selectedPos); |
|
1052 |
ResetSelection(); |
|
1053 |
end; |
|
10844
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
1054 |
|
953d85b7d529
holding ctrl will now make cursor skip words/etc in a fashion similar to Qt
sheepluva
parents:
10843
diff
changeset
|
1055 |
if ctrl then |
10845
1dbd50690951
quick word deletion while holding ctrl (qt style)
sheepluva
parents:
10844
diff
changeset
|
1056 |
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
|
1057 |
|
10846
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
1058 |
end |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
1059 |
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
|
1060 |
ResetSelection(); |
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
1061 |
|
c76fd416eff6
attempt to move cursor now removes selection even if cursor cannot actually move in the specified direction
sheepluva
parents:
10845
diff
changeset
|
1062 |
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
|
1063 |
end; |
11365 | 1064 |
SDL_SCANCODE_PAGEUP, SDL_SCANCODE_PAGEDOWN: |
8745 | 1065 |
begin |
1066 |
// ignore me!!! |
|
1067 |
end; |
|
11365 | 1068 |
// TODO: figure out how to determine those keys better |
1069 |
SDL_SCANCODE_a: |
|
10836 | 1070 |
begin |
1071 |
// 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
|
1072 |
if ctrlonly then |
10836 | 1073 |
begin |
1074 |
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
|
1075 |
cursorPos:= 0; |
10836 | 1076 |
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
|
1077 |
cursorPos:= Length(InputStr.s); |
10836 | 1078 |
UpdateCursorCoords(); |
1079 |
end |
|
1080 |
end; |
|
11365 | 1081 |
SDL_SCANCODE_c: |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1082 |
begin |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1083 |
// copy |
11004
bd62cdbea391
chat: make sure that CTRL is the /only/ modifier key pressed when detecting ctrl+a etc
sheepluva
parents:
10985
diff
changeset
|
1084 |
if ctrlonly then |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1085 |
CopySelectionToClipboard() |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1086 |
end; |
11365 | 1087 |
SDL_SCANCODE_v: |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1088 |
begin |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1089 |
// paste |
11004
bd62cdbea391
chat: make sure that CTRL is the /only/ modifier key pressed when detecting ctrl+a etc
sheepluva
parents:
10985
diff
changeset
|
1090 |
if ctrlonly then |
10921 | 1091 |
begin |
1092 |
DeleteSelected(); |
|
1093 |
PasteFromClipboard(); |
|
1094 |
end |
|
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1095 |
end; |
11365 | 1096 |
SDL_SCANCODE_x: |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1097 |
begin |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1098 |
// cut |
11004
bd62cdbea391
chat: make sure that CTRL is the /only/ modifier key pressed when detecting ctrl+a etc
sheepluva
parents:
10985
diff
changeset
|
1099 |
if ctrlonly then |
10849
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1100 |
begin |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1101 |
CopySelectionToClipboard(); |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1102 |
DeleteSelected(); |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1103 |
end |
a772d342066a
copy&paste (wip), currently using only a local clipboard
sheepluva
parents:
10846
diff
changeset
|
1104 |
end; |
8742
b7b8bd398c1b
Key returned 0 for arrows under linux. Sym works, clearer anyway.
nemo
parents:
8741
diff
changeset
|
1105 |
end; |
946 | 1106 |
end; |
1107 |
||
11365 | 1108 |
procedure TextInput(var event: TSDL_TextInputEvent); |
1109 |
var s: shortstring; |
|
1110 |
l: byte; |
|
11697
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1111 |
isl: integer; |
11365 | 1112 |
begin |
1113 |
DeleteSelected(); |
|
1114 |
||
1115 |
l:= 0; |
|
11697
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1116 |
// fetch all bytes of character/input |
11365 | 1117 |
while event.text[l] <> #0 do |
1118 |
begin |
|
1119 |
s[l + 1]:= event.text[l]; |
|
1120 |
inc(l) |
|
1121 |
end; |
|
1122 |
||
1123 |
if l > 0 then |
|
1124 |
begin |
|
11697
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1125 |
isl:= Length(InputStr.s); |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1126 |
// check if user is typing a redundant closing hog-speech quotation mark |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1127 |
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:
11696
diff
changeset
|
1128 |
and (s[1] = InputStr.s[1]) and (s[1] = InputStr.s[isl]) then |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1129 |
begin |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1130 |
MoveCursorToNextChar(); |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1131 |
UpdateCursorCoords(); |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1132 |
end |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1133 |
else |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1134 |
begin |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1135 |
// don't add input that doesn't fit |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1136 |
if isl + l > MaxInputStrLen then exit; |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1137 |
s[0]:= char(l); |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1138 |
InsertIntoInputStr(s); |
11696
fa4bc078e509
restore closing hog speech quotation marks being added automatically (lost in SDL2 transition... I think)
sheepluva
parents:
11476
diff
changeset
|
1139 |
|
11697
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1140 |
// add closing hog speech quotation marks automagically |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1141 |
if (l = 1) and (Length(InputStr.s) = 1) and charIsForHogSpeech(s[1]) then |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1142 |
begin |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1143 |
InsertIntoInputStr(s); |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1144 |
MoveCursorToPreviousChar(); |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1145 |
UpdateCursorCoords(); |
446ce60700dd
some more dark magic regarding hog speech input
sheepluva
parents:
11696
diff
changeset
|
1146 |
end; |
11696
fa4bc078e509
restore closing hog speech quotation marks being added automatically (lost in SDL2 transition... I think)
sheepluva
parents:
11476
diff
changeset
|
1147 |
end; |
fa4bc078e509
restore closing hog speech quotation marks being added automatically (lost in SDL2 transition... I think)
sheepluva
parents:
11476
diff
changeset
|
1148 |
|
11365 | 1149 |
end |
1150 |
end; |
|
1151 |
||
1152 |
||
4404 | 1153 |
procedure chChatMessage(var s: shortstring); |
1154 |
begin |
|
1155 |
AddChatString(s) |
|
1156 |
end; |
|
1157 |
||
4402 | 1158 |
procedure chSay(var s: shortstring); |
1159 |
begin |
|
1160 |
SendIPC('s' + s); |
|
1161 |
||
1162 |
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
|
1163 |
s:= #2 + '* ' + UserNick + ' ' + copy(s, 5, Length(s) - 4) |
4402 | 1164 |
else |
13898 | 1165 |
s:= #1 + Format(shortstring(trmsg[sidChat]), UserNick, s); |
4402 | 1166 |
|
1167 |
AddChatString(s) |
|
1168 |
end; |
|
1169 |
||
1170 |
procedure chTeamSay(var s: shortstring); |
|
1171 |
begin |
|
1172 |
SendIPC('b' + s); |
|
1173 |
||
13898 | 1174 |
s:= #4 + Format(shortstring(trmsg[sidChatTeam]), UserNick, s); |
4402 | 1175 |
|
1176 |
AddChatString(s) |
|
1177 |
end; |
|
1178 |
||
1179 |
procedure chHistory(var s: shortstring); |
|
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1180 |
var i: LongInt; |
4402 | 1181 |
begin |
1182 |
s:= s; // avoid compiler hint |
|
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1183 |
showAll:= not showAll; |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1184 |
// immediatly recount |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1185 |
visibleCount:= 0; |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1186 |
if showAll or (not ChatHidden) then |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1187 |
for i:= 0 to MaxStrIndex do |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1188 |
begin |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1189 |
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
|
1190 |
inc(visibleCount); |
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1191 |
end; |
4402 | 1192 |
end; |
1193 |
||
1194 |
procedure chChat(var s: shortstring); |
|
12846
e5c461729fe3
Fix chat input key being sometimes registered twice
alfadur
parents:
12410
diff
changeset
|
1195 |
var i: Integer; |
4402 | 1196 |
begin |
1197 |
s:= s; // avoid compiler hint |
|
13077 | 1198 |
isInChatMode:= true; |
11365 | 1199 |
SDL_StopTextInput(); |
9697 | 1200 |
SDL_StartTextInput(); |
12846
e5c461729fe3
Fix chat input key being sometimes registered twice
alfadur
parents:
12410
diff
changeset
|
1201 |
//Make REALLY sure unexpected events are flushed (1 time is insufficient as of SDL 2.0.7) |
e5c461729fe3
Fix chat input key being sometimes registered twice
alfadur
parents:
12410
diff
changeset
|
1202 |
for i := 1 to 2 do |
e5c461729fe3
Fix chat input key being sometimes registered twice
alfadur
parents:
12410
diff
changeset
|
1203 |
begin |
e5c461729fe3
Fix chat input key being sometimes registered twice
alfadur
parents:
12410
diff
changeset
|
1204 |
SDL_PumpEvents(); |
e5c461729fe3
Fix chat input key being sometimes registered twice
alfadur
parents:
12410
diff
changeset
|
1205 |
SDL_FlushEvent(SDL_TEXTINPUT); |
e5c461729fe3
Fix chat input key being sometimes registered twice
alfadur
parents:
12410
diff
changeset
|
1206 |
end; |
11365 | 1207 |
//SDL_EnableKeyRepeat(200,45); |
4402 | 1208 |
if length(s) = 0 then |
5100 | 1209 |
SetLine(InputStr, '', true) |
4402 | 1210 |
else |
1211 |
begin |
|
13852
266a25b79374
Rename chat command /team to /clan (but keep /team as alias for now)
Wuzzy <Wuzzy2@mail.ru>
parents:
13847
diff
changeset
|
1212 |
SetLine(InputStr, '/clan ', true); |
10841 | 1213 |
cursorPos:= 6; |
1214 |
UpdateCursorCoords(); |
|
1215 |
end; |
|
4402 | 1216 |
end; |
1217 |
||
3038 | 1218 |
procedure initModule; |
4925 | 1219 |
var i: ShortInt; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1220 |
begin |
6898 | 1221 |
RegisterVariable('chatmsg', @chChatMessage, true); |
1222 |
RegisterVariable('say', @chSay, true); |
|
1223 |
RegisterVariable('team', @chTeamSay, true); |
|
1224 |
RegisterVariable('history', @chHistory, true ); |
|
1225 |
RegisterVariable('chat', @chChat, true ); |
|
4402 | 1226 |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1227 |
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
|
1228 |
localLastStr:= 0; |
8737
0d56265dd60a
implement up and down keys to navigate in the chat history, needs testing over network
koda
parents:
8736
diff
changeset
|
1229 |
history:= 0; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1230 |
visibleCount:= 0; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1231 |
showAll:= false; |
3539 | 1232 |
ChatReady:= false; |
1233 |
missedCount:= 0; |
|
10312 | 1234 |
liveLua:= false; |
10514
a1423588a4e4
chat: fix some glitches, add /togglechat command for changing chat visibility
sheepluva
parents:
10513
diff
changeset
|
1235 |
ChatHidden:= false; |
10842
a039464cbb4a
since fonts can be loaded in late, update cursor position before first chat display
sheepluva
parents:
10841
diff
changeset
|
1236 |
firstDraw:= true; |
4925 | 1237 |
|
10852
9e5763cb805e
render input prefix independent of inputstr so that e.g. a username will not lead to weirdnesses
sheepluva
parents:
10851
diff
changeset
|
1238 |
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
|
1239 |
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
|
1240 |
inputStr.s:= ''; |
4925 | 1241 |
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
|
1242 |
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
|
1243 |
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
|
1244 |
|
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
|
1245 |
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
|
1246 |
ResetCursor(); |
11365 | 1247 |
SDL_StopTextInput(); |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1248 |
end; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1249 |
|
3038 | 1250 |
procedure freeModule; |
4901 | 1251 |
var i: ShortInt; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1252 |
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
|
1253 |
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
|
1254 |
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
|
1255 |
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
|
1256 |
FreeAndNilTexture(Strs[i].Tex); |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
1257 |
end; |
946 | 1258 |
|
942 | 1259 |
end. |