1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
|
/* $Id$ */
/*
* This file is part of OpenTTD.
* OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
* OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file textbuf.cpp Textbuffer handling. */
#include "stdafx.h"
#include "textbuf_type.h"
#include "string_func.h"
#include "gfx_type.h"
#include "gfx_func.h"
#include "window_func.h"
/**
* Try to retrive the current clipboard contents.
*
* @note OS-specific funtion.
* @return True if some text could be retrived.
*/
bool GetClipboardContents(char *buffer, size_t buff_len);
int _caret_timer;
/* Delete a character at the caret position in a text buf.
* If backspace is set, delete the character before the caret,
* else delete the character after it. */
void Textbuf::DelChar(bool backspace)
{
WChar c;
char *s = this->buf + this->caretpos;
if (backspace) s = Utf8PrevChar(s);
uint16 len = (uint16)Utf8Decode(&c, s);
uint width = GetCharacterWidth(FS_NORMAL, c);
this->pixels -= width;
if (backspace) {
this->caretpos -= len;
this->caretxoffs -= width;
}
/* Move the remaining characters over the marker */
memmove(s, s + len, this->bytes - (s - this->buf) - len);
this->bytes -= len;
this->chars--;
}
/**
* Delete a character from a textbuffer, either with 'Delete' or 'Backspace'
* The character is delete from the position the caret is at
* @param delmode Type of deletion, either WKC_BACKSPACE or WKC_DELETE
* @return Return true on successful change of Textbuf, or false otherwise
*/
bool Textbuf::DeleteChar(int delmode)
{
if (delmode == WKC_BACKSPACE && this->caretpos != 0) {
this->DelChar(true);
return true;
} else if (delmode == WKC_DELETE && this->caretpos < this->bytes - 1) {
this->DelChar(false);
return true;
}
return false;
}
/**
* Delete every character in the textbuffer
*/
void Textbuf::DeleteAll()
{
memset(this->buf, 0, this->max_bytes);
this->bytes = this->chars = 1;
this->pixels = this->caretpos = this->caretxoffs = 0;
}
/**
* Insert a character to a textbuffer. If maxwidth of the Textbuf is zero,
* we don't care about the visual-length but only about the physical
* length of the string
* @param key Character to be inserted
* @return Return true on successful change of Textbuf, or false otherwise
*/
bool Textbuf::InsertChar(WChar key)
{
const byte charwidth = GetCharacterWidth(FS_NORMAL, key);
uint16 len = (uint16)Utf8CharLen(key);
if (this->bytes + len <= this->max_bytes && this->chars + 1 <= this->max_chars) {
memmove(this->buf + this->caretpos + len, this->buf + this->caretpos, this->bytes - this->caretpos);
Utf8Encode(this->buf + this->caretpos, key);
this->chars++;
this->bytes += len;
this->pixels += charwidth;
this->caretpos += len;
this->caretxoffs += charwidth;
return true;
}
return false;
}
/**
* Insert a chunk of text from the clipboard onto the textbuffer. Get TEXT clipboard
* and append this up to the maximum length (either absolute or screenlength). If maxlength
* is zero, we don't care about the screenlength but only about the physical length of the string
* @return true on successful change of Textbuf, or false otherwise
*/
bool Textbuf::InsertClipboard()
{
char utf8_buf[512];
if (!GetClipboardContents(utf8_buf, lengthof(utf8_buf))) return false;
uint16 pixels = 0, bytes = 0, chars = 0;
WChar c;
for (const char *ptr = utf8_buf; (c = Utf8Consume(&ptr)) != '\0';) {
if (!IsPrintable(c)) break;
byte len = Utf8CharLen(c);
if (this->bytes + bytes + len > this->max_bytes) break;
if (this->chars + chars + 1 > this->max_chars) break;
byte char_pixels = GetCharacterWidth(FS_NORMAL, c);
pixels += char_pixels;
bytes += len;
chars++;
}
if (bytes == 0) return false;
memmove(this->buf + this->caretpos + bytes, this->buf + this->caretpos, this->bytes - this->caretpos);
memcpy(this->buf + this->caretpos, utf8_buf, bytes);
this->pixels += pixels;
this->caretxoffs += pixels;
this->bytes += bytes;
this->chars += chars;
this->caretpos += bytes;
assert(this->bytes <= this->max_bytes);
assert(this->chars <= this->max_chars);
this->buf[this->bytes - 1] = '\0'; // terminating zero
return true;
}
/**
* Checks if it is possible to move carret to the left
* @return true if the caret can be moved to the left, otherwise false.
*/
bool Textbuf::CanMoveCaretLeft()
{
return this->caretpos != 0;
}
/**
* Moves the caret to the left.
* @pre Ensure that Textbuf::CanMoveCaretLeft returns true
* @return The character under the caret.
*/
WChar Textbuf::MoveCaretLeft()
{
assert(this->CanMoveCaretLeft());
WChar c;
const char *s = Utf8PrevChar(this->buf + this->caretpos);
Utf8Decode(&c, s);
this->caretpos = s - this->buf;
this->caretxoffs -= GetCharacterWidth(FS_NORMAL, c);
return c;
}
/**
* Checks if it is possible to move carret to the right
* @return true if the caret can be moved to the right, otherwise false.
*/
bool Textbuf::CanMoveCaretRight()
{
return this->caretpos < this->bytes - 1;
}
/**
* Moves the caret to the right.
* @pre Ensure that Textbuf::CanMoveCaretRight returns true
* @return The character under the caret.
*/
WChar Textbuf::MoveCaretRight()
{
assert(this->CanMoveCaretRight());
WChar c;
this->caretpos += (uint16)Utf8Decode(&c, this->buf + this->caretpos);
this->caretxoffs += GetCharacterWidth(FS_NORMAL, c);
Utf8Decode(&c, this->buf + this->caretpos);
return c;
}
/**
* Handle text navigation with arrow keys left/right.
* This defines where the caret will blink and the next characer interaction will occur
* @param navmode Direction in which navigation occurs WKC_LEFT, WKC_RIGHT, WKC_END, WKC_HOME
* @return Return true on successful change of Textbuf, or false otherwise
*/
bool Textbuf::MovePos(int navmode)
{
switch (navmode) {
case WKC_LEFT:
if (this->CanMoveCaretLeft()) {
this->MoveCaretLeft();
return true;
}
break;
case WKC_RIGHT:
if (this->CanMoveCaretRight()) {
this->MoveCaretRight();
return true;
}
break;
case WKC_HOME:
this->caretpos = 0;
this->caretxoffs = 0;
return true;
case WKC_END:
this->caretpos = this->bytes - 1;
this->caretxoffs = this->pixels;
return true;
default:
break;
}
return false;
}
/**
* Initialize the textbuffer by supplying it the buffer to write into
* and the maximum length of this buffer
* @param buf the buffer that will be holding the data for input
* @param max_bytes maximum size in bytes, including terminating '\0'
*/
void Textbuf::Initialize(char *buf, uint16 max_bytes)
{
this->Initialize(buf, max_bytes, max_bytes);
}
/**
* Initialize the textbuffer by supplying it the buffer to write into
* and the maximum length of this buffer
* @param buf the buffer that will be holding the data for input
* @param max_bytes maximum size in bytes, including terminating '\0'
* @param max_chars maximum size in chars, including terminating '\0'
*/
void Textbuf::Initialize(char *buf, uint16 max_bytes, uint16 max_chars)
{
assert(max_bytes != 0);
assert(max_chars != 0);
this->buf = buf;
this->max_bytes = max_bytes;
this->max_chars = max_chars;
this->caret = true;
this->UpdateSize();
}
/**
* Update Textbuf type with its actual physical character and screenlength
* Get the count of characters in the string as well as the width in pixels.
* Useful when copying in a larger amount of text at once
*/
void Textbuf::UpdateSize()
{
const char *buf = this->buf;
this->pixels = 0;
this->chars = this->bytes = 1; // terminating zero
WChar c;
while ((c = Utf8Consume(&buf)) != '\0') {
this->pixels += GetCharacterWidth(FS_NORMAL, c);
this->bytes += Utf8CharLen(c);
this->chars++;
}
assert(this->bytes <= this->max_bytes);
assert(this->chars <= this->max_chars);
this->caretpos = this->bytes - 1;
this->caretxoffs = this->pixels;
}
/**
* Handle the flashing of the caret.
* @return True if the caret state changes.
*/
bool Textbuf::HandleCaret()
{
/* caret changed? */
bool b = !!(_caret_timer & 0x20);
if (b != this->caret) {
this->caret = b;
return true;
}
return false;
}
|