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 "../settings_type.h"

    25

#include "network_internal.h"

    26

#include "network_client.h"

    27

    28

#include "table/strings.h"

    29

    30

/* The draw buffer must be able to contain the chat message, client name and the "[All]" message,

    31

 * some spaces and possible translations of [All] to other languages. */

    32

assert_compile((int)DRAW_STRING_BUFFER >= (int)NETWORK_CHAT_LENGTH + NETWORK_NAME_LENGTH + 40);

    33

    34

enum {

    35

	NETWORK_CHAT_LINE_HEIGHT = 13,

    36

};

    37

    38

struct ChatMessage {

    39

	char message[DRAW_STRING_BUFFER];

    40

	uint16 color;

    41

	Date end_date;

    42

};

    43

    44

/* used for chat window */

    45

static ChatMessage *_chatmsg_list = NULL;

    46

static bool _chatmessage_dirty = false;

    47

static bool _chatmessage_visible = false;

    48

static bool _chat_tab_completion_active;

    49

static uint MAX_CHAT_MESSAGES = 0;

    50

    51

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

    52

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

    53

static PointDimension _chatmsg_box;

    54

static uint8 *_chatmessage_backup = NULL;

    55

    56

static inline uint GetChatMessageCount()

    57

{

    58

	uint i = 0;

    59

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

    60

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

    61

	}

    62

    63

	return i;

    64

}

    65

    66

/**

    67

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

    68

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

    69

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

    70

 * @param message message itself in printf() style

    71

 */

    72

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

    73

{

    74

	char buf[DRAW_STRING_BUFFER];

    75

	const char *bufp;

    76

	va_list va;

    77

	uint msg_count;

    78

	uint16 lines;

    79

    80

	va_start(va, message);

    81

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

    82

	va_end(va);

    83

    84

	Utf8TrimString(buf, DRAW_STRING_BUFFER);

    85

    86

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

    87

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

    88

	if (lines >= MAX_CHAT_MESSAGES) return;

    89

    90

	msg_count = GetChatMessageCount();

    91

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

    92

	if (lines > MAX_CHAT_MESSAGES - msg_count) {

    93

		int i = lines - (MAX_CHAT_MESSAGES - msg_count);

    94

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

    95

		msg_count = MAX_CHAT_MESSAGES - lines;

    96

	}

    97

    98

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

    99

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

   100

		strecpy(cmsg->message, bufp, lastof(cmsg->message));

   101

   102

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

   103

		 * white for any additional lines */

   104

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

   105

		cmsg->end_date = _date + duration;

   106

   107

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

   108

	}

   109

   110

	_chatmessage_dirty = true;

   111

}

   112

   113

void NetworkInitChatMessage()

   114

{

   115

	MAX_CHAT_MESSAGES   = _settings_client.gui.network_chat_box_height;

   116

   117

	_chatmsg_list       = ReallocT(_chatmsg_list, _settings_client.gui.network_chat_box_height);

   118

	_chatmsg_box.x      = 10;

   119

	_chatmsg_box.y      = 30;

   120

	_chatmsg_box.width  = _settings_client.gui.network_chat_box_width;

   121

	_chatmsg_box.height = _settings_client.gui.network_chat_box_height * NETWORK_CHAT_LINE_HEIGHT + 2;

   122

	_chatmessage_backup = ReallocT(_chatmessage_backup, _chatmsg_box.width * _chatmsg_box.height * BlitterFactoryBase::GetCurrentBlitter()->GetBytesPerPixel());

   123

   124

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

   125

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

   126

	}

   127

}

   128

   129

/** Hide the chatbox */

   130

void NetworkUndrawChatMessage()

   131

{

   132

	if (_chatmessage_visible) {

   133

		Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   134

		/* Sometimes we also need to hide the cursor

   135

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

   136

		 *   screen before drawing.

   137

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

   138

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

   139

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

   140

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

   141

		 *   looks nicely ;)

   142

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

   143

		 */

   144

   145

		if (_cursor.visible) {

   146

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

   147

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

   148

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

   149

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

   150

				UndrawMouseCursor();

   151

			}

   152

		}

   153

   154

		int x      = _chatmsg_box.x;

   155

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

   156

		int width  = _chatmsg_box.width;

   157

		int height = _chatmsg_box.height;

   158

		if (y < 0) {

   159

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

   160

			y = 0;

   161

		}

   162

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

   163

			width = _screen.width - x;

   164

		}

   165

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

   166

   167

		_chatmessage_visible = false;

   168

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

   169

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

   170

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

   171

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

   172

   173

		_chatmessage_dirty = true;

   174

	}

   175

}

   176

   177

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

   178

void NetworkChatMessageDailyLoop()

   179

{

   180

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

   181

		ChatMessage *cmsg = &_chatmsg_list[i];

   182

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

   183

   184

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

   185

		if (cmsg->end_date < _date) {

   186

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

   187

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

   188

   189

			/* Mark the last item as empty */

   190

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

   191

			_chatmessage_dirty = true;

   192

   193

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

   194

			i--;

   195

		}

   196

	}

   197

}

   198

   199

/** Draw the chat message-box */

   200

void NetworkDrawChatMessage()

   201

{

   202

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   203

	if (!_chatmessage_dirty) return;

   204

   205

	/* First undraw if needed */

   206

	NetworkUndrawChatMessage();

   207

   208

	if (_iconsole_mode == ICONSOLE_FULL) return;

   209

   210

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

   211

	uint count = GetChatMessageCount();

   212

	if (count == 0) return;

   213

   214

	int x      = _chatmsg_box.x;

   215

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

   216

	int width  = _chatmsg_box.width;

   217

	int height = _chatmsg_box.height;

   218

	if (y < 0) {

   219

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

   220

		y = 0;

   221

	}

   222

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

   223

		width = _screen.width - x;

   224

	}

   225

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

   226

   227

	assert(blitter->BufferSize(width, height) <= (int)(_chatmsg_box.width * _chatmsg_box.height * blitter->GetBytesPerPixel()));

   228

   229

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

   230

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

   231

   232

	_cur_dpi = &_screen; // switch to _screen painting

   233

   234

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

   235

	GfxFillRect(

   236

			_chatmsg_box.x,

   237

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

   238

			_chatmsg_box.x + _chatmsg_box.width - 1,

   239

			_screen.height - _chatmsg_box.y - 2,

   240

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

   241

		);

   242

   243

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

   244

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

   245

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

   246

	}

   247

   248

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

   249

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

   250

   251

	_chatmessage_visible = true;

   252

	_chatmessage_dirty = false;

   253

}

   254

   255

   256

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

   257

{

   258

	if (StrEmpty(buf)) return;

   259

	if (!_network_server) {

   260

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

   261

	} else {

   262

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

   263

	}

   264

}

   265

   266

   267

struct NetworkChatWindow : public QueryStringBaseWindow {

   268

	DestType dtype;

   269

	int dest;

   270

   271

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

   272

	{

   273

		this->LowerWidget(2);

   274

		this->dtype   = type;

   275

		this->dest    = dest;

   276

		this->afilter = CS_ALPHANUMERAL;

   277

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

   278

   279

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

   280

   281

		_chat_tab_completion_active = false;

   282

   283

		this->FindWindowPlacementAndResize(desc);

   284

	}

   285

   286

	~NetworkChatWindow ()

   287

	{

   288

		InvalidateWindowData(WC_NEWS_WINDOW, 0, 0);

   289

	}

   290

   291

	/**

   292

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

   293

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

   294

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

   295

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

   296

	 */

   297

	const char *ChatTabCompletionNextItem(uint *item)

   298

	{

   299

		static char chat_tab_temp_buffer[64];

   300

   301

		/* First, try clients */

   302

		if (*item < MAX_CLIENT_INFO) {

   303

			/* Skip inactive clients */

   304

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

   305

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

   306

		}

   307

   308

		/* Then, try townnames */

   309

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

   310

		* towns have been deleted. */

   311

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

   312

			const Town *t;

   313

   314

			FOR_ALL_TOWNS_FROM(t, *item - MAX_CLIENT_INFO) {

   315

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

   316

				SetDParam(0, t->index);

   317

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

   318

				return &chat_tab_temp_buffer[0];

   319

			}

   320

		}

   321

   322

		return NULL;

   323

	}

   324

   325

	/**

   326

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

   327

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

   328

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

   329

	 */

   330

	static char *ChatTabCompletionFindText(char *buf)

   331

	{

   332

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

   333

		if (p == NULL) return buf;

   334

   335

		*p = '\0';

   336

		return p + 1;

   337

	}

   338

   339

	/**

   340

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

   341

	 */

   342

	void ChatTabCompletion()

   343

	{

   344

		static char _chat_tab_completion_buf[NETWORK_CHAT_LENGTH];

   345

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

   346

   347

		Textbuf *tb = &this->text;

   348

		size_t len, tb_len;

   349

		uint item;

   350

		char *tb_buf, *pre_buf;

   351

		const char *cur_name;

   352

		bool second_scan = false;

   353

   354

		item = 0;

   355

   356

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

   357

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

   358

   359

		tb_buf  = ChatTabCompletionFindText(pre_buf);

   360

		tb_len  = strlen(tb_buf);

   361

   362

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

   363

			item++;

   364

   365

			if (_chat_tab_completion_active) {

   366

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

   367

				*  that starts with this? */

   368

				if (!second_scan) {

   369

					size_t offset;

   370

					size_t length;

   371

   372

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

   373

					if (tb_buf == pre_buf) {

   374

						offset = 0;

   375

						length = (tb->size - 1) - 2;

   376

					} else {

   377

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

   378

						offset = strlen(pre_buf) + 1;

   379

						length = (tb->size - 1) - offset;

   380

					}

   381

   382

					/* Compare if we have a match */

   383

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

   384

   385

					continue;

   386

				}

   387

   388

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

   389

			}

   390

   391

			len = strlen(cur_name);

   392

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

   393

				/* Save the data it was before completion */

   394

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

   395

				_chat_tab_completion_active = true;

   396

   397

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

   398

				if (pre_buf == tb_buf) {

   399

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

   400

				} else {

   401

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

   402

				}

   403

   404

				/* Update the textbuffer */

   405

				UpdateTextBufferSize(&this->text);

   406

   407

				this->SetDirty();

   408

				free(pre_buf);

   409

				return;

   410

			}

   411

		}

   412

   413

		if (second_scan) {

   414

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

   415

			strcpy(tb->buf, _chat_tab_completion_buf);

   416

			_chat_tab_completion_active = false;

   417

   418

			/* Update the textbuffer */

   419

			UpdateTextBufferSize(&this->text);

   420

   421

			this->SetDirty();

   422

		}

   423

		free(pre_buf);

   424

	}

   425

   426

	virtual void OnPaint()

   427

	{

   428

		static const StringID chat_captions[] = {

   429

			STR_NETWORK_CHAT_ALL_CAPTION,

   430

			STR_NETWORK_CHAT_COMPANY_CAPTION,

   431

			STR_NETWORK_CHAT_CLIENT_CAPTION

   432

		};

   433

   434

		this->DrawWidgets();

   435

   436

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

   437

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

   438

		this->DrawEditBox(2);

   439

	}

   440

   441

	virtual void OnClick(Point pt, int widget)

   442

	{

   443

		switch (widget) {

   444

			case 2:

   445

				ShowOnScreenKeyboard(this, 2, 0, 3);

   446

				break;

   447

   448

			case 3: /* Send */

   449

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

   450

			/* FALLTHROUGH */

   451

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

   452

		}

   453

	}

   454

   455

	virtual void OnMouseLoop()

   456

	{

   457

		this->HandleEditBox(2);

   458

	}

   459

   460

	virtual EventState OnKeyPress(uint16 key, uint16 keycode)

   461

	{

   462

		EventState state = ES_NOT_HANDLED;

   463

		if (keycode == WKC_TAB) {

   464

			ChatTabCompletion();

   465

		} else {

   466

			_chat_tab_completion_active = false;

   467

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

   468

				default: NOT_REACHED();

   469

				case HEBR_EDITING: {

   470

					Window *osk = FindWindowById(WC_OSK, 0);

   471

					if (osk != NULL && osk->parent == this) osk->OnInvalidateData();

   472

				} break;

   473

				case HEBR_CONFIRM:

   474

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

   475

				/* FALLTHROUGH */

   476

				case HEBR_CANCEL: delete this; break;

   477

			}

   478

		}

   479

		return state;

   480

	}

   481

};

   482

   483

static const Widget _chat_window_widgets[] = {

   484

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

   485

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

   486

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

   487

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

   488

{   WIDGETS_END},

   489

};

   490

   491

static const WindowDesc _chat_window_desc = {

   492

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

   493

	WC_SEND_NETWORK_MSG, WC_NONE,

   494

	WDF_STD_TOOLTIPS | WDF_DEF_WIDGET,

   495

	_chat_window_widgets,

   496

};

   497

   498

void ShowNetworkChatQueryWindow(DestType type, int dest)

   499

{

   500

	DeleteWindowById(WC_SEND_NETWORK_MSG, 0);

   501

	new NetworkChatWindow (&_chat_window_desc, type, dest);

   502

}

   503

   504

#endif /* ENABLE_NETWORK */