Files @ r20063:f808fc7ab0bd
Branch filter:

Location: cpp/openttd-patchpack/source/src/textbuf.cpp

rubidium
(svn r25021) -Codechange: make a lot of SmallMapWindow members protected (fonsinchen)
  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
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
/* $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 <stdarg.h>

#include "textbuf_type.h"
#include "string_func.h"
#include "strings_func.h"
#include "gfx_type.h"
#include "gfx_func.h"
#include "window_func.h"
#include "core/alloc_func.hpp"

/**
 * Try to retrieve the current clipboard contents.
 *
 * @note OS-specific function.
 * @return True if some text could be retrieved.
 */
bool GetClipboardContents(char *buffer, size_t buff_len);

int _caret_timer;


/**
 * Checks if it is possible to delete a character.
 * @param backspace if set, delete the character before the caret,
 * otherwise, delete the character after it.
 * @return true if a character can be deleted in the given direction.
 */
bool Textbuf::CanDelChar(bool backspace)
{
	return backspace ? this->caretpos != 0 : this->caretpos < this->bytes - 1;
}

/**
 * Get the next character that will be removed by DelChar.
 * @param backspace if set, delete the character before the caret,
 * otherwise, delete the character after it.
 * @return the next character that will be removed by DelChar.
 * @warning You should ensure Textbuf::CanDelChar returns true before calling this function.
 */
WChar Textbuf::GetNextDelChar(bool backspace)
{
	assert(this->CanDelChar(backspace));

	const char *s;
	if (backspace) {
		s = Utf8PrevChar(this->buf + this->caretpos);
	} else {
		s = this->buf + this->caretpos;
	}

	WChar c;
	Utf8Decode(&c, s);
	return c;
}

/**
 * Delete a character at the caret position in a text buf.
 * @param backspace if set, delete the character before the caret,
 * else delete the character after it.
 * @warning You should ensure Textbuf::CanDelChar returns true before calling this function.
 */
void Textbuf::DelChar(bool backspace)
{
	assert(this->CanDelChar(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 || delmode == WKC_DELETE) {
		bool backspace = delmode == WKC_BACKSPACE;
		if (CanDelChar(backspace)) {
			this->DelChar(backspace);
			return true;
		}
		return false;
	}

	if (delmode == (WKC_CTRL | WKC_BACKSPACE) || delmode == (WKC_CTRL | WKC_DELETE)) {
		bool backspace = delmode == (WKC_CTRL | WKC_BACKSPACE);

		if (!CanDelChar(backspace)) return false;
		WChar c = this->GetNextDelChar(backspace);

		/* Backspace: Delete left whitespaces.
		 * Delete:    Delete right word.
		 */
		while (backspace ? IsWhitespace(c) : !IsWhitespace(c)) {
			this->DelChar(backspace);
			if (!this->CanDelChar(backspace)) return true;
			c = this->GetNextDelChar(backspace);
		}
		/* Backspace: Delete left word.
		 * Delete:    Delete right whitespaces.
		 */
		while (backspace ? !IsWhitespace(c) : IsWhitespace(c)) {
			this->DelChar(backspace);
			if (!this->CanDelChar(backspace)) return true;
			c = this->GetNextDelChar(backspace);
		}
		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 caret 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 caret 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 character interaction will occur
 * @param navmode Direction in which navigation occurs (WKC_CTRL |) WKC_LEFT, (WKC_CTRL |) 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_CTRL | WKC_LEFT: {
			if (!this->CanMoveCaretLeft()) break;

			/* Unconditionally move one char to the left. */
			WChar c = this->MoveCaretLeft();
			/* Consume left whitespaces. */
			while (IsWhitespace(c)) {
				if (!this->CanMoveCaretLeft()) return true;
				c = this->MoveCaretLeft();
			}
			/* Consume left word. */
			while (!IsWhitespace(c)) {
				if (!this->CanMoveCaretLeft()) return true;
				c = this->MoveCaretLeft();
			}
			/* Place caret at the beginning of the left word. */
			this->MoveCaretRight();
			return true;
		}

		case WKC_RIGHT:
			if (this->CanMoveCaretRight()) {
				this->MoveCaretRight();
				return true;
			}
			break;

		case WKC_CTRL | WKC_RIGHT: {
			if (!this->CanMoveCaretRight()) break;

			/* Unconditionally move one char to the right. */
			WChar c = this->MoveCaretRight();
			/* Continue to consume current word. */
			while (!IsWhitespace(c)) {
				if (!this->CanMoveCaretRight()) return true;
				c = this->MoveCaretRight();
			}
			/* Consume right whitespaces. */
			while (IsWhitespace(c)) {
				if (!this->CanMoveCaretRight()) return true;
				c = this->MoveCaretRight();
			}
			return true;
		}

		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'
 * @param max_chars maximum size in chars, including terminating '\0'
 */
Textbuf::Textbuf(uint16 max_bytes, uint16 max_chars)
	: buf(MallocT<char>(max_bytes))
{
	assert(max_bytes != 0);
	assert(max_chars != 0);

	this->max_bytes  = max_bytes;
	this->max_chars  = max_chars == UINT16_MAX ? max_bytes : max_chars;
	this->caret      = true;
	this->DeleteAll();
}

Textbuf::~Textbuf()
{
	free(this->buf);
}

/**
 * Render a string into the textbuffer.
 * @param string String
 */
void Textbuf::Assign(StringID string)
{
	GetString(this->buf, string, &this->buf[this->max_bytes - 1]);
	this->UpdateSize();
}

/**
 * Copy a string into the textbuffer.
 * @param text Source.
 */
void Textbuf::Assign(const char *text)
{
	ttd_strlcpy(this->buf, text, this->max_bytes);
	this->UpdateSize();
}

/**
 * Print a formatted string into the textbuffer.
 */
void Textbuf::Print(const char *format, ...)
{
	va_list va;
	va_start(va, format);
	vsnprintf(this->buf, this->max_bytes, format, va);
	va_end(va);
	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;
}