19 

    19 #include "string.h"

    20 // Windows stuff for Clipboard

    21 #if defined(WIN32)

    22 #include <windows.h>

    23 #endif

   782 /* Get the count of characters in the string as well as the width in pixels

   778 static void DelChar(Textbuf *tb)

   783  * [IN]buf: string to be checked

   779 {

   784  * [OUT]count: gets set to the count of characters

   780 	tb->width -= GetCharacterWidth(tb->buf[tb->caretpos]);

   785  * [OUT]width: gets set to the pixels width */

   781 	memmove(tb->buf + tb->caretpos, tb->buf + tb->caretpos + 1, tb->length - tb->caretpos);

   786 static void GetCurrentStringSize(const char *buf, int *count, int *width)

   782 	tb->length--;

   787 {

   783 }

   788 	*count = 0;

   784 

   789 	*width = -1;

   785 /**

   790 

   786  * Delete a character from a textbuffer, either with 'Delete' or 'Backspace'

   791 	do {

   787  * The character is delete from the position the caret is at

   792 		if (*++buf == 0)

   788  * @param tb @Textbuf type to be changed

   793 			break;

   789  * @param delmode Type of deletion, either @WKC_BACKSPACE or @WKC_DELETE

   794 		(*count)++;

   790  * @return Return true on successfull change of Textbuf, or false otherwise

   795 		(*width) += _stringwidth_table[(byte)*buf - 32];

   791  */

   796 	} while (1);

   792 bool DeleteTextBufferChar(Textbuf *tb, int delmode)

   793 {

   794 	if (delmode == WKC_BACKSPACE && tb->caretpos != 0) {

   795 		tb->caretpos--;

   796 		tb->caretxoffs -= GetCharacterWidth(tb->buf[tb->caretpos]);

   797 

   798 		DelChar(tb);

   799 		return true;

   800 	} else if (delmode == WKC_DELETE && tb->caretpos < tb->length) {

   801 		DelChar(tb);

   802 		return true;

   803 	}

   804 

   805 	return false;

   806 }

   807 

   808 /**

   809  * Insert a character to a textbuffer. If maxlength is zero, we don't care about

   810  * the screenlength but only about the physical length of the string

   811  * @param tb @Textbuf type to be changed

   812  * @param key Character to be inserted

   813  * @return Return true on successfull change of Textbuf, or false otherwise

   814  */

   815 bool InsertTextBufferChar(Textbuf *tb, byte key)

   816 {

   817 	const byte charwidth = GetCharacterWidth(key);

   818 	if (tb->length < tb->maxlength && (tb->maxwidth == 0 || tb->width + charwidth <= tb->maxwidth)) {

   819 		memmove(tb->buf + tb->caretpos + 1, tb->buf + tb->caretpos, tb->length - tb->caretpos);

   820 		tb->buf[tb->caretpos] = key;

   821 		tb->length++;

   822 		tb->width += charwidth;

   823 

   824 		tb->caretpos++;

   825 		tb->caretxoffs += charwidth;

   826 		return true;

   827 	}

   828 	return false;

   829 }

   830 

   831 /**

   832  * Handle text navigation with arrow keys left/right.

   833  * This defines where the caret will blink and the next characer interaction will occur

   834  * @param tb @Textbuf type where navigation occurs

   835  * @param navmode Direction in which navigation occurs @WKC_LEFT, @WKC_RIGHT, @WKC_END, @WKC_HOME

   836  * @return Return true on successfull change of Textbuf, or false otherwise

   837  */

   838 bool MoveTextBufferPos(Textbuf *tb, int navmode)

   839 {

   840 	switch (navmode) {

   841 	case WKC_LEFT:

   842 		if (tb->caretpos != 0) {

   843 			tb->caretpos--;

   844 			tb->caretxoffs -= GetCharacterWidth(tb->buf[tb->caretpos]);

   845 			return true;

   846 		}

   847 		break;

   848 	case WKC_RIGHT:

   849 		if (tb->caretpos < tb->length) {

   850 			tb->caretxoffs += GetCharacterWidth(tb->buf[tb->caretpos]);

   851 			tb->caretpos++;

   852 			return true;

   853 		}

   854 		break;

   855 	case WKC_HOME:

   856 		tb->caretpos = 0;

   857 		tb->caretxoffs = 0;

   858 		return true;

   859 	case WKC_END:

   860 		tb->caretpos = tb->length;

   861 		tb->caretxoffs = tb->width;

   862 		return true;

   863 	}

   864 

   865 	return false;

   866 }

   867 

   868 /**

   869  * Update @Textbuf type with its actual physical character and screenlength

   870  * Get the count of characters in the string as well as the width in pixels.

   871  * Useful when copying in a larger amount of text at once

   872  * @param tb @Textbuf type which length is calculated

   873  */

   874 void UpdateTextBufferSize(Textbuf *tb)

   875 {

   876 	char *buf;

   877 	tb->length = 0;

   878 	tb->width = 0;

   879 

   880 	for (buf = tb->buf; *buf != '\0' && tb->length <= tb->maxlength; buf++) {

   881 		tb->length++;

   882 		tb->width += GetCharacterWidth((byte)*buf);

   883 	}

   884 

   885 	tb->caretpos = tb->length;

   886 	tb->caretxoffs = tb->width;

   806 	if (we->keypress.keycode == WKC_ESC) {

   893 	switch (we->keypress.keycode) {

   807 		return 2;

   894 	case WKC_ESC: return 2;

   808 	} else if (we->keypress.keycode == WKC_RETURN) {

   895 	case WKC_RETURN: case WKC_NUM_ENTER: return 1;

   809 		return 1;

   896 	case (WKC_CTRL | 'V'):

   810 #ifdef WIN32

   897 		if (InsertTextBufferClipboard(&WP(w, querystr_d).text))

   811 	} else if (we->keypress.keycode == (WKC_CTRL | 'V')) {

   812 		if (IsClipboardFormatAvailable(CF_TEXT)) {

   813 			const byte* data;

   814 			HGLOBAL cbuf;

   815 

   816 			OpenClipboard(NULL);

   817 			cbuf = GetClipboardData(CF_TEXT);

   818 			data = GlobalLock(cbuf); // clipboard data

   819 

   820 			GetCurrentStringSize(WP(w,querystr_d).buf - 1, &count, &width);

   821 

   822 			/* IS_INT_INSIDE = filter for ascii-function codes like BELL and so on [we need an special filter here later] */

   823 			for (; (IS_INT_INSIDE(*data, ' ', 256)) && // valid ASCII char

   824 					(count < WP(w,querystr_d).maxlen - 1 && // max charcount; always allow for terminating '\0'

   825 					width + _stringwidth_table[(int)(*data) - 32] <= WP(w,querystr_d).maxwidth); ++data) { // max screensize

   826 

   827 				// append data and update size parameters

   828 				WP(w,querystr_d).buf[count] = *data;

   829 				count++;

   830 				width += _stringwidth_table[*data - 32];

   831 			}

   832 			WP(w,querystr_d).buf[count + 1] = '\0';

   833 

   834 			GlobalUnlock(cbuf);

   835 			CloseClipboard();

   837 		}

   899 		break;

   838 #endif

   900 	case WKC_BACKSPACE: case WKC_DELETE:

   839 	} else {

   901 		if (DeleteTextBufferChar(&WP(w, querystr_d).text, we->keypress.keycode))

   840 		GetCurrentStringSize(WP(w,querystr_d).buf - 1, &count, &width);

   902 			InvalidateWidget(w, wid);

   841 

   903 		break;

   842 		if (we->keypress.keycode == WKC_BACKSPACE) {

   904 	case WKC_LEFT: case WKC_RIGHT: case WKC_END: case WKC_HOME:

   843 			if (count != 0) {

   905 		if (MoveTextBufferPos(&WP(w, querystr_d).text, we->keypress.keycode))

   844 				WP(w,querystr_d).buf[count-1] = 0;

   906 			InvalidateWidget(w, wid);

   907   	break;

   908 	default:

   909 		if (IsValidAsciiChar(we->keypress.ascii)) {

   910 			if (InsertTextBufferChar(&WP(w, querystr_d).text, we->keypress.ascii))

   862 	bool b;

   933 	if (HandleCaret(&WP(w, querystr_d).text))

   863 

   864 	/* caret changed? */

   865 	b = !!(_caret_timer & 0x20);

   866 	if (b != WP(w,querystr_d).caret) {

   867 		WP(w,querystr_d).caret = b;

   875 	int x;

   940 	const Textbuf *tb = &WP(w,querystr_d).text;

   878 	x = DoDrawString(WP(w,querystr_d).buf, wi->left+2, wi->top+1, 8);

   943 	DoDrawString(tb->buf, wi->left+2, wi->top+1, 8);

   879 	if (WP(w,querystr_d).caret)

   944 	if (tb->caret)

   880 		DoDrawString("_", x, wi->top+1, 12);

   945 		DoDrawString("_", wi->left + 2 + tb->caretxoffs, wi->top + 1, 12);

   881 }

   946 }

   882 

   888 	case WE_PAINT: {

   952 	case WE_PAINT:

   889 //		int x;

   890 

   895 	} break;

   957 		break;

   903 					strcmp(WP(w, querystr_d).buf, WP(w, querystr_d).orig) == 0) {

   965 					strcmp(WP(w, querystr_d).text.buf, WP(w, querystr_d).orig) == 0) {

   906 				char *buf = WP(w,querystr_d).buf;

   968 				char *buf = WP(w,querystr_d).text.buf;

   989 

  1053 	uint realmaxlen = maxlen & ~0x1000;

   990 	assert(maxlen < lengthof(_edit_str_buf));

  1054 

  1055 	assert(realmaxlen < lengthof(_edit_str_buf));

   998 	_edit_str_buf[maxlen] = '\0';

  1063 	_edit_str_buf[realmaxlen] = '\0';

  1009 	WP(w,querystr_d).caption = caption;

  1073 	WP(w, querystr_d).caption = caption;

  1010 	WP(w,querystr_d).wnd_class = window_class;

  1074 	WP(w, querystr_d).wnd_class = window_class;

  1011 	WP(w,querystr_d).wnd_num = window_number;

  1075 	WP(w, querystr_d).wnd_num = window_number;

  1012 	WP(w,querystr_d).caret = 0;

  1076 	WP(w, querystr_d).text.caret = false;

  1013 	WP(w,querystr_d).maxlen = maxlen;

  1077 	WP(w, querystr_d).text.maxlength = realmaxlen - 1;

  1014 	WP(w,querystr_d).maxwidth = maxwidth;

  1078 	WP(w, querystr_d).text.maxwidth = maxwidth;

  1015 	WP(w,querystr_d).buf = _edit_str_buf;

  1079 	WP(w, querystr_d).text.buf = _edit_str_buf;

  1080 	UpdateTextBufferSize(&WP(w, querystr_d).text);

  1223 					strcpy(WP(w,querystr_d).buf, file->title[0] ? file->title : file->name);

  1288 					ttd_strlcpy(WP(w, querystr_d).text.buf, (file->title[0] != '\0') ? file->title : file->name, WP(w, querystr_d).text.maxlength);

  1289 					UpdateTextBufferSize(&WP(w, querystr_d).text);

  1249 			FiosDelete(WP(w,querystr_d).buf);

  1315 			FiosDelete(WP(w,querystr_d).text.buf);

  1256 			FiosMakeSavegameName(_file_to_saveload.name, WP(w,querystr_d).buf);

  1322 			FiosMakeSavegameName(_file_to_saveload.name, WP(w,querystr_d).text.buf);

  1342 	w->click_state |= (1 << 6);

  1408 	SETBIT(w->click_state, 6);

  1343 	WP(w,querystr_d).caret = 0;

  1409 	WP(w,querystr_d).text.caret = false;

  1344 	WP(w,querystr_d).maxlen = lengthof(_edit_str_buf);

  1410 	WP(w,querystr_d).text.maxlength = lengthof(_edit_str_buf) - 1;

  1345 	WP(w,querystr_d).maxwidth = 240;

  1411 	WP(w,querystr_d).text.maxwidth = 240;

  1346 	WP(w,querystr_d).buf = _edit_str_buf;

  1412 	WP(w,querystr_d).text.buf = _edit_str_buf;

  1413 	UpdateTextBufferSize(&WP(w, querystr_d).text);

  1350 	} else if (mode == SLD_SAVE_SCENARIO) {

  1417 	} else if (mode == SLD_SAVE_SCENARIO)