1

/* $Id$ */

     2

     3

/** @file network_chat_gui.cpp GUI for handling chat messages. */

     4

     5

#include <stdarg.h> /* va_list */

     6

     7

#ifdef ENABLE_NETWORK

     8

     9

#include "../stdafx.h"

    10

#include "network.h"

    11

#include "network_type.h"

    12

#include "../date_func.h"

    13

#include "../gfx_func.h"

    14

#include "../strings_func.h"

    15

#include "../blitter/factory.hpp"

    16

#include "../console_func.h"

    17

#include "../video/video_driver.hpp"

    18

#include "../table/sprites.h"

    19

#include "../window_gui.h"

    20

#include "../textbuf_gui.h"

    21

#include "../querystring_gui.h"

    22

#include "../town.h"

    23

#include "../window_func.h"

    24

#include "network_internal.h"

    25

#include "network_client.h"

    26

    27

#include "table/strings.h"

    28

    29

enum {

    30

	MAX_CHAT_MESSAGES      =  10,

    31

};

    32

    33

struct ChatMessage {

    34

	char message[NETWORK_CHAT_LENGTH];

    35

	uint16 color;

    36

	Date end_date;

    37

};

    38

    39

/* used for chat window */

    40

static ChatMessage _chatmsg_list[MAX_CHAT_MESSAGES];

    41

static bool _chatmessage_dirty = false;

    42

static bool _chatmessage_visible = false;

    43

static bool _chat_tab_completion_active;

    44

    45

/* The chatbox grows from the bottom so the coordinates are pixels from

    46

 * the left and pixels from the bottom. The height is the maximum height */

    47

static const PointDimension _chatmsg_box = {10, 30, 500, 150};

    48

static uint8 _chatmessage_backup[150 * 500 * 6]; // (height * width)

    49

    50

static inline uint GetChatMessageCount()

    51

{

    52

	uint i = 0;

    53

	for (; i < MAX_CHAT_MESSAGES; i++) {

    54

		if (_chatmsg_list[i].message[0] == '\0') break;

    55

	}

    56

    57

	return i;

    58

}

    59

    60

/**

    61

 * Add a text message to the 'chat window' to be shown

    62

 * @param color The colour this message is to be shown in

    63

 * @param duration The duration of the chat message in game-days

    64

 * @param message message itself in printf() style

    65

 */

    66

void CDECL NetworkAddChatMessage(uint16 color, uint8 duration, const char *message, ...)

    67

{

    68

	char buf[NETWORK_CHAT_LENGTH];

    69

	const char *bufp;

    70

	va_list va;

    71

	uint msg_count;

    72

	uint16 lines;

    73

    74

	va_start(va, message);

    75

	vsnprintf(buf, lengthof(buf), message, va);

    76

	va_end(va);

    77

    78

    79

	Utf8TrimString(buf, NETWORK_CHAT_LENGTH);

    80

    81

	/* Force linebreaks for strings that are too long */

    82

	lines = GB(FormatStringLinebreaks(buf, _chatmsg_box.width - 8), 0, 16) + 1;

    83

	if (lines >= MAX_CHAT_MESSAGES) return;

    84

    85

	msg_count = GetChatMessageCount();

    86

	/* We want to add more chat messages than there is free space for, remove 'old' */

    87

	if (lines > MAX_CHAT_MESSAGES - msg_count) {

    88

		int i = lines - (MAX_CHAT_MESSAGES - msg_count);

    89

		memmove(&_chatmsg_list[0], &_chatmsg_list[i], sizeof(_chatmsg_list[0]) * (msg_count - i));

    90

		msg_count = MAX_CHAT_MESSAGES - lines;

    91

	}

    92

    93

	for (bufp = buf; lines != 0; lines--) {

    94

		ChatMessage *cmsg = &_chatmsg_list[msg_count++];

    95

		ttd_strlcpy(cmsg->message, bufp, sizeof(cmsg->message));

    96

    97

		/* The default colour for a message is player colour. Replace this with

    98

		 * white for any additional lines */

    99

		cmsg->color = (bufp == buf && color & IS_PALETTE_COLOR) ? color : (0x1D - 15) | IS_PALETTE_COLOR;

   100

		cmsg->end_date = _date + duration;

   101

   102

		bufp += strlen(bufp) + 1; // jump to 'next line' in the formatted string

   103

	}

   104

   105

	_chatmessage_dirty = true;

   106

}

   107

   108

void NetworkInitChatMessage()

   109

{

   110

	for (uint i = 0; i < MAX_CHAT_MESSAGES; i++) {

   111

		_chatmsg_list[i].message[0] = '\0';

   112

	}

   113

}

   114

   115

/** Hide the chatbox */

   116

void NetworkUndrawChatMessage()

   117

{

   118

	if (_chatmessage_visible) {

   119

		Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   120

		/* Sometimes we also need to hide the cursor

   121

		 *   This is because both textmessage and the cursor take a shot of the

   122

		 *   screen before drawing.

   123

		 *   Now the textmessage takes his shot and paints his data before the cursor

   124

		 *   does, so in the shot of the cursor is the screen-data of the textmessage

   125

		 *   included when the cursor hangs somewhere over the textmessage. To

   126

		 *   avoid wrong repaints, we undraw the cursor in that case, and everything

   127

		 *   looks nicely ;)

   128

		 * (and now hope this story above makes sense to you ;))

   129

		 */

   130

   131

		if (_cursor.visible) {

   132

			if (_cursor.draw_pos.x + _cursor.draw_size.x >= _chatmsg_box.x &&

   133

				_cursor.draw_pos.x <= _chatmsg_box.x + _chatmsg_box.width &&

   134

				_cursor.draw_pos.y + _cursor.draw_size.y >= _screen.height - _chatmsg_box.y - _chatmsg_box.height &&

   135

				_cursor.draw_pos.y <= _screen.height - _chatmsg_box.y) {

   136

				UndrawMouseCursor();

   137

			}

   138

		}

   139

   140

		int x      = _chatmsg_box.x;

   141

		int y      = _screen.height - _chatmsg_box.y - _chatmsg_box.height;

   142

		int width  = _chatmsg_box.width;

   143

		int height = _chatmsg_box.height;

   144

		if (y < 0) {

   145

			height = max(height + y, min(_chatmsg_box.height, _screen.height));

   146

			y = 0;

   147

		}

   148

		if (x + width >= _screen.width) {

   149

			width = _screen.width - x;

   150

		}

   151

		if (width <= 0 || height <= 0) return;

   152

   153

		_chatmessage_visible = false;

   154

		/* Put our 'shot' back to the screen */

   155

		blitter->CopyFromBuffer(blitter->MoveTo(_screen.dst_ptr, x, y), _chatmessage_backup, width, height);

   156

		/* And make sure it is updated next time */

   157

		_video_driver->MakeDirty(x, y, width, height);

   158

   159

		_chatmessage_dirty = true;

   160

	}

   161

}

   162

   163

/** Check if a message is expired every day */

   164

void NetworkChatMessageDailyLoop()

   165

{

   166

	for (uint i = 0; i < MAX_CHAT_MESSAGES; i++) {

   167

		ChatMessage *cmsg = &_chatmsg_list[i];

   168

		if (cmsg->message[0] == '\0') continue;

   169

   170

		/* Message has expired, remove from the list */

   171

		if (cmsg->end_date < _date) {

   172

			/* Move the remaining messages over the current message */

   173

			if (i != MAX_CHAT_MESSAGES - 1) memmove(cmsg, cmsg + 1, sizeof(*cmsg) * (MAX_CHAT_MESSAGES - i - 1));

   174

   175

			/* Mark the last item as empty */

   176

			_chatmsg_list[MAX_CHAT_MESSAGES - 1].message[0] = '\0';

   177

			_chatmessage_dirty = true;

   178

   179

			/* Go one item back, because we moved the array 1 to the left */

   180

			i--;

   181

		}

   182

	}

   183

}

   184

   185

/** Draw the chat message-box */

   186

void NetworkDrawChatMessage()

   187

{

   188

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   189

	if (!_chatmessage_dirty) return;

   190

   191

	/* First undraw if needed */

   192

	NetworkUndrawChatMessage();

   193

   194

	if (_iconsole_mode == ICONSOLE_FULL) return;

   195

   196

	/* Check if we have anything to draw at all */

   197

	uint count = GetChatMessageCount();

   198

	if (count == 0) return;

   199

   200

	int x      = _chatmsg_box.x;

   201

	int y      = _screen.height - _chatmsg_box.y - _chatmsg_box.height;

   202

	int width  = _chatmsg_box.width;

   203

	int height = _chatmsg_box.height;

   204

	if (y < 0) {

   205

		height = max(height + y, min(_chatmsg_box.height, _screen.height));

   206

		y = 0;

   207

	}

   208

	if (x + width >= _screen.width) {

   209

		width = _screen.width - x;

   210

	}

   211

	if (width <= 0 || height <= 0) return;

   212

   213

	assert(blitter->BufferSize(width, height) < (int)sizeof(_chatmessage_backup));

   214

   215

	/* Make a copy of the screen as it is before painting (for undraw) */

   216

	blitter->CopyToBuffer(blitter->MoveTo(_screen.dst_ptr, x, y), _chatmessage_backup, width, height);

   217

   218

	_cur_dpi = &_screen; // switch to _screen painting

   219

   220

	/* Paint a half-transparent box behind the chat messages */

   221

	GfxFillRect(

   222

			_chatmsg_box.x,

   223

			_screen.height - _chatmsg_box.y - count * 13 - 2,

   224

			_chatmsg_box.x + _chatmsg_box.width - 1,

   225

			_screen.height - _chatmsg_box.y - 2,

   226

			PALETTE_TO_TRANSPARENT, FILLRECT_RECOLOR // black, but with some alpha for background

   227

		);

   228

   229

	/* Paint the chat messages starting with the lowest at the bottom */

   230

	for (uint y = 13; count-- != 0; y += 13) {

   231

		DoDrawString(_chatmsg_list[count].message, _chatmsg_box.x + 3, _screen.height - _chatmsg_box.y - y + 1, _chatmsg_list[count].color);

   232

	}

   233

   234

	/* Make sure the data is updated next flush */

   235

	_video_driver->MakeDirty(x, y, width, height);

   236

   237

	_chatmessage_visible = true;

   238

	_chatmessage_dirty = false;

   239

}

   240

   241

   242

static void SendChat(const char *buf, DestType type, int dest)

   243

{

   244

	if (StrEmpty(buf)) return;

   245

	if (!_network_server) {

   246

		SEND_COMMAND(PACKET_CLIENT_CHAT)((NetworkAction)(NETWORK_ACTION_CHAT + type), type, dest, buf);

   247

	} else {

   248

		NetworkServerSendChat((NetworkAction)(NETWORK_ACTION_CHAT + type), type, dest, buf, NETWORK_SERVER_INDEX);

   249

	}

   250

}

   251

   252

   253

struct NetworkChatWindow : public QueryStringBaseWindow {

   254

	DestType dtype;

   255

	int dest;

   256

   257

	NetworkChatWindow (const WindowDesc *desc, DestType type, int dest) : QueryStringBaseWindow(NETWORK_CHAT_LENGTH, desc)

   258

	{

   259

		this->LowerWidget(2);

   260

		this->dtype   = type;

   261

		this->dest    = dest;

   262

		this->afilter = CS_ALPHANUMERAL;

   263

		InitializeTextBuffer(&this->text, this->edit_str_buf, this->edit_str_size, 0);

   264

   265

		InvalidateWindowData(WC_NEWS_WINDOW, 0, this->height);

   266

		SetBit(_no_scroll, SCROLL_CHAT); // do not scroll the game with the arrow-keys

   267

   268

		_chat_tab_completion_active = false;

   269

   270

		this->FindWindowPlacementAndResize(desc);

   271

	}

   272

   273

	~NetworkChatWindow ()

   274

	{

   275

		InvalidateWindowData(WC_NEWS_WINDOW, 0, 0);

   276

		ClrBit(_no_scroll, SCROLL_CHAT);

   277

	}

   278

   279

	/**

   280

	 * Find the next item of the list of things that can be auto-completed.

   281

	 * @param item The current indexed item to return. This function can, and most

   282

	 *     likely will, alter item, to skip empty items in the arrays.

   283

	 * @return Returns the char that matched to the index.

   284

	 */

   285

	const char *ChatTabCompletionNextItem(uint *item)

   286

	{

   287

		static char chat_tab_temp_buffer[64];

   288

   289

		/* First, try clients */

   290

		if (*item < MAX_CLIENT_INFO) {

   291

			/* Skip inactive clients */

   292

			while (_network_client_info[*item].client_index == NETWORK_EMPTY_INDEX && *item < MAX_CLIENT_INFO) (*item)++;

   293

			if (*item < MAX_CLIENT_INFO) return _network_client_info[*item].client_name;

   294

		}

   295

   296

		/* Then, try townnames */

   297

		/* Not that the following assumes all town indices are adjacent, ie no

   298

		* towns have been deleted. */

   299

		if (*item <= (uint)MAX_CLIENT_INFO + GetMaxTownIndex()) {

   300

			const Town *t;

   301

   302

			FOR_ALL_TOWNS_FROM(t, *item - MAX_CLIENT_INFO) {

   303

				/* Get the town-name via the string-system */

   304

				SetDParam(0, t->index);

   305

				GetString(chat_tab_temp_buffer, STR_TOWN, lastof(chat_tab_temp_buffer));

   306

				return &chat_tab_temp_buffer[0];

   307

			}

   308

		}

   309

   310

		return NULL;

   311

	}

   312

   313

	/**

   314

	 * Find what text to complete. It scans for a space from the left and marks

   315

	 *  the word right from that as to complete. It also writes a \0 at the

   316

	 *  position of the space (if any). If nothing found, buf is returned.

   317

	 */

   318

	static char *ChatTabCompletionFindText(char *buf)

   319

	{

   320

		char *p = strrchr(buf, ' ');

   321

		if (p == NULL) return buf;

   322

   323

		*p = '\0';

   324

		return p + 1;

   325

	}

   326

   327

	/**

   328

	 * See if we can auto-complete the current text of the user.

   329

	 */

   330

	void ChatTabCompletion()

   331

	{

   332

		static char _chat_tab_completion_buf[NETWORK_CHAT_LENGTH];

   333

		assert(this->edit_str_size == lengthof(_chat_tab_completion_buf));

   334

   335

		Textbuf *tb = &this->text;

   336

		size_t len, tb_len;

   337

		uint item;

   338

		char *tb_buf, *pre_buf;

   339

		const char *cur_name;

   340

		bool second_scan = false;

   341

   342

		item = 0;

   343

   344

		/* Copy the buffer so we can modify it without damaging the real data */

   345

		pre_buf = (_chat_tab_completion_active) ? strdup(_chat_tab_completion_buf) : strdup(tb->buf);

   346

   347

		tb_buf  = ChatTabCompletionFindText(pre_buf);

   348

		tb_len  = strlen(tb_buf);

   349

   350

		while ((cur_name = ChatTabCompletionNextItem(&item)) != NULL) {

   351

			item++;

   352

   353

			if (_chat_tab_completion_active) {

   354

				/* We are pressing TAB again on the same name, is there an other name

   355

				*  that starts with this? */

   356

				if (!second_scan) {

   357

					size_t offset;

   358

					size_t length;

   359

   360

					/* If we are completing at the begin of the line, skip the ': ' we added */

   361

					if (tb_buf == pre_buf) {

   362

						offset = 0;

   363

						length = tb->length - 2;

   364

					} else {

   365

						/* Else, find the place we are completing at */

   366

						offset = strlen(pre_buf) + 1;

   367

						length = tb->length - offset;

   368

					}

   369

   370

					/* Compare if we have a match */

   371

					if (strlen(cur_name) == length && strncmp(cur_name, tb->buf + offset, length) == 0) second_scan = true;

   372

   373

					continue;

   374

				}

   375

   376

				/* Now any match we make on _chat_tab_completion_buf after this, is perfect */

   377

			}

   378

   379

			len = strlen(cur_name);

   380

			if (tb_len < len && strncasecmp(cur_name, tb_buf, tb_len) == 0) {

   381

				/* Save the data it was before completion */

   382

				if (!second_scan) snprintf(_chat_tab_completion_buf, lengthof(_chat_tab_completion_buf), "%s", tb->buf);

   383

				_chat_tab_completion_active = true;

   384

   385

				/* Change to the found name. Add ': ' if we are at the start of the line (pretty) */

   386

				if (pre_buf == tb_buf) {

   387

					snprintf(tb->buf, this->edit_str_size, "%s: ", cur_name);

   388

				} else {

   389

					snprintf(tb->buf, this->edit_str_size, "%s %s", pre_buf, cur_name);

   390

				}

   391

   392

				/* Update the textbuffer */

   393

				UpdateTextBufferSize(&this->text);

   394

   395

				this->SetDirty();

   396

				free(pre_buf);

   397

				return;

   398

			}

   399

		}

   400

   401

		if (second_scan) {

   402

			/* We walked all posibilities, and the user presses tab again.. revert to original text */

   403

			strcpy(tb->buf, _chat_tab_completion_buf);

   404

			_chat_tab_completion_active = false;

   405

   406

			/* Update the textbuffer */

   407

			UpdateTextBufferSize(&this->text);

   408

   409

			this->SetDirty();

   410

		}

   411

		free(pre_buf);

   412

	}

   413

   414

	virtual void OnPaint()

   415

	{

   416

		static const StringID chat_captions[] = {

   417

			STR_NETWORK_CHAT_ALL_CAPTION,

   418

			STR_NETWORK_CHAT_COMPANY_CAPTION,

   419

			STR_NETWORK_CHAT_CLIENT_CAPTION

   420

		};

   421

   422

		this->DrawWidgets();

   423

   424

		assert((uint)this->dtype < lengthof(chat_captions));

   425

		DrawStringRightAligned(this->widget[2].left - 2, this->widget[2].top + 1, chat_captions[this->dtype], TC_BLACK);

   426

		this->DrawEditBox(2);

   427

	}

   428

   429

	virtual void OnClick(Point pt, int widget)

   430

	{

   431

		switch (widget) {

   432

			case 2:

   433

				ShowOnScreenKeyboard(this, 2, 0, 3);

   434

				break;

   435

   436

			case 3: /* Send */

   437

				SendChat(this->text.buf, this->dtype, this->dest);

   438

			/* FALLTHROUGH */

   439

			case 0: /* Cancel */ delete this; break;

   440

		}

   441

	}

   442

   443

	virtual void OnMouseLoop()

   444

	{

   445

		this->HandleEditBox(2);

   446

	}

   447

   448

	virtual EventState OnKeyPress(uint16 key, uint16 keycode)

   449

	{

   450

		EventState state = ES_NOT_HANDLED;

   451

		if (keycode == WKC_TAB) {

   452

			ChatTabCompletion();

   453

		} else {

   454

			_chat_tab_completion_active = false;

   455

			switch (this->HandleEditBoxKey(2, key, keycode, state)) {

   456

				case 1: /* Return */

   457

					SendChat(this->text.buf, this->dtype, this->dest);

   458

				/* FALLTHROUGH */

   459

				case 2: /* Escape */ delete this; break;

   460

			}

   461

		}

   462

		return state;

   463

	}

   464

};

   465

   466

static const Widget _chat_window_widgets[] = {

   467

{   WWT_CLOSEBOX, RESIZE_NONE,   COLOUR_GREY,   0,  10,  0, 13, STR_00C5,                  STR_018B_CLOSE_WINDOW},

   468

{      WWT_PANEL, RESIZE_RIGHT,  COLOUR_GREY,  11, 319,  0, 13, 0x0,                       STR_NULL}, // background

   469

{    WWT_EDITBOX, RESIZE_RIGHT,  COLOUR_GREY,  75, 257,  1, 12, STR_NETWORK_CHAT_OSKTITLE, STR_NULL}, // text box

   470

{ WWT_PUSHTXTBTN, RESIZE_LR,     COLOUR_GREY, 258, 319,  1, 12, STR_NETWORK_SEND,          STR_NULL}, // send button

   471

{   WIDGETS_END},

   472

};

   473

   474

static const WindowDesc _chat_window_desc = {

   475

	WDP_CENTER, -26, 320, 14, 640, 14, // x, y, width, height

   476

	WC_SEND_NETWORK_MSG, WC_NONE,

   477

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET,

   478

	_chat_window_widgets,

   479

};

   480

   481

void ShowNetworkChatQueryWindow(DestType type, int dest)

   482

{

   483

	DeleteWindowById(WC_SEND_NETWORK_MSG, 0);

   484

	new NetworkChatWindow (&_chat_window_desc, type, dest);

   485

}

   486

   487

#endif /* ENABLE_NETWORK */