1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "macros.h"

     7

#include "spritecache.h"

     8

#include "strings.h"

     9

#include "string.h"

    10

#include "gfx.h"

    11

#include "table/palettes.h"

    12

#include "table/sprites.h"

    13

#include "hal.h"

    14

#include "variables.h"

    17

#include "genworld.h"

    18

    19

#ifdef _DEBUG

    20

bool _dbg_screen_rect;

    21

#endif

    22

    23

Colour _cur_palette[256];

    24

byte _stringwidth_table[FS_END][224];

    25

    26

static void GfxMainBlitter(const Sprite *sprite, int x, int y, int mode);

    27

    28

FontSize _cur_fontsize;

    29

static FontSize _last_fontsize;

    30

static Pixel _cursor_backup[64 * 64];

    31

static Rect _invalid_rect;

    32

static const byte *_color_remap_ptr;

    33

static byte _string_colorremap[3];

    34

    35

#define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH / 64)

    36

static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

    37

    38

void memcpy_pitch(void *dst, void *src, int w, int h, int srcpitch, int dstpitch)

    39

{

    40

	byte *dstp = (byte*)dst;

    41

	byte *srcp = (byte*)src;

    42

    43

	assert(h >= 0);

    44

	for (; h != 0; --h) {

    45

		memcpy(dstp, srcp, w);

    46

		dstp += dstpitch;

    47

		srcp += srcpitch;

    48

	}

    49

}

    50

    51

void GfxScroll(int left, int top, int width, int height, int xo, int yo)

    52

{

    53

	const Pixel *src;

    54

	Pixel *dst;

    55

	int p;

    56

	int ht;

    57

    58

	if (xo == 0 && yo == 0) return;

    59

    60

	if (_cursor.visible) UndrawMouseCursor();

    61

	UndrawTextMessage();

    62

    63

	p = _screen.pitch;

    64

    65

	if (yo > 0) {

    66

		// Calculate pointers

    67

		dst = _screen.dst_ptr + (top + height - 1) * p + left;

    68

		src = dst - yo * p;

    69

    70

		// Decrease height and increase top

    71

		top += yo;

    72

		height -= yo;

    73

		assert(height > 0);

    74

    75

		// Adjust left & width

    76

		if (xo >= 0) {

    77

			dst += xo;

    78

			left += xo;

    79

			width -= xo;

    80

		} else {

    81

			src -= xo;

    82

			width += xo;

    83

		}

    84

    85

		for (ht = height; ht > 0; --ht) {

    86

			memcpy(dst, src, width);

    87

			src -= p;

    88

			dst -= p;

    89

		}

    90

	} else {

    91

		// Calculate pointers

    92

		dst = _screen.dst_ptr + top * p + left;

    93

		src = dst - yo * p;

    94

    95

		// Decrese height. (yo is <=0).

    96

		height += yo;

    97

		assert(height > 0);

    98

    99

		// Adjust left & width

   100

		if (xo >= 0) {

   101

			dst += xo;

   102

			left += xo;

   103

			width -= xo;

   104

		} else {

   105

			src -= xo;

   106

			width += xo;

   107

		}

   108

   109

		// the y-displacement may be 0 therefore we have to use memmove,

   110

		// because source and destination may overlap

   111

		for (ht = height; ht > 0; --ht) {

   112

			memmove(dst, src, width);

   113

			src += p;

   114

			dst += p;

   115

		}

   116

	}

   117

	// This part of the screen is now dirty.

   118

	_video_driver->make_dirty(left, top, width, height);

   119

}

   120

   121

   122

void GfxFillRect(int left, int top, int right, int bottom, int color)

   123

{

   124

	const DrawPixelInfo* dpi = _cur_dpi;

   125

	Pixel *dst;

   126

	const int otop = top;

   127

	const int oleft = left;

   128

   129

	if (dpi->zoom != 0) return;

   130

	if (left > right || top > bottom) return;

   131

	if (right < dpi->left || left >= dpi->left + dpi->width) return;

   132

	if (bottom < dpi->top || top >= dpi->top + dpi->height) return;

   133

   134

	if ( (left -= dpi->left) < 0) left = 0;

   135

	right = right - dpi->left + 1;

   136

	if (right > dpi->width) right = dpi->width;

   137

	right -= left;

   138

	assert(right > 0);

   139

   140

	if ( (top -= dpi->top) < 0) top = 0;

   141

	bottom = bottom - dpi->top + 1;

   142

	if (bottom > dpi->height) bottom = dpi->height;

   143

	bottom -= top;

   144

	assert(bottom > 0);

   145

   146

	dst = dpi->dst_ptr + top * dpi->pitch + left;

   147

   148

	if (!(color & PALETTE_MODIFIER_GREYOUT)) {

   149

		if (!(color & USE_COLORTABLE)) {

   150

			do {

   151

				memset(dst, color, right);

   152

				dst += dpi->pitch;

   153

			} while (--bottom);

   154

		} else {

   155

			/* use colortable mode */

   156

			const byte* ctab = GetNonSprite(color & COLORTABLE_MASK) + 1;

   157

   158

			do {

   159

				int i;

   160

				for (i = 0; i != right; i++) dst[i] = ctab[dst[i]];

   161

				dst += dpi->pitch;

   162

			} while (--bottom);

   163

		}

   164

	} else {

   165

		byte bo = (oleft - left + dpi->left + otop - top + dpi->top) & 1;

   166

		do {

   167

			int i;

   168

			for (i = (bo ^= 1); i < right; i += 2) dst[i] = (byte)color;

   169

			dst += dpi->pitch;

   170

		} while (--bottom > 0);

   171

	}

   172

}

   173

   174

static void GfxSetPixel(int x, int y, int color)

   175

{

   176

	const DrawPixelInfo* dpi = _cur_dpi;

   177

	if ((x-=dpi->left) < 0 || x>=dpi->width || (y-=dpi->top)<0 || y>=dpi->height)

   178

		return;

   179

	dpi->dst_ptr[y * dpi->pitch + x] = color;

   180

}

   181

   182

void GfxDrawLine(int x, int y, int x2, int y2, int color)

   183

{

   184

	int dy;

   185

	int dx;

   186

	int stepx;

   187

	int stepy;

   188

	int frac;

   189

   190

	// Check clipping first

   191

	{

   192

		DrawPixelInfo *dpi = _cur_dpi;

   193

		int t;

   194

   195

		if (x < dpi->left && x2 < dpi->left) return;

   196

   197

		if (y < dpi->top && y2 < dpi->top) return;

   198

   199

		t = dpi->left + dpi->width;

   200

		if (x > t && x2 > t) return;

   201

   202

		t = dpi->top + dpi->height;

   203

		if (y > t && y2 > t) return;

   204

	}

   205

   206

	dy = (y2 - y) * 2;

   207

	if (dy < 0) {

   208

		dy = -dy;

   209

		stepy = -1;

   210

	} else {

   211

		stepy = 1;

   212

	}

   213

   214

	dx = (x2 - x) * 2;

   215

	if (dx < 0) {

   216

		dx = -dx;

   217

		stepx = -1;

   218

	} else {

   219

		stepx = 1;

   220

	}

   221

   222

	GfxSetPixel(x, y, color);

   223

	if (dx > dy) {

   224

		frac = dy - (dx >> 1);

   225

		while (x != x2) {

   226

			if (frac >= 0) {

   227

				y += stepy;

   228

				frac -= dx;

   229

			}

   230

			x += stepx;

   231

			frac += dy;

   232

			GfxSetPixel(x, y, color);

   233

		}

   234

	} else {

   235

		frac = dx - (dy >> 1);

   236

		while (y != y2) {

   237

			if (frac >= 0) {

   238

				x += stepx;

   239

				frac -= dy;

   240

			}

   241

			y += stepy;

   242

			frac += dx;

   243

			GfxSetPixel(x, y, color);

   244

		}

   245

	}

   246

}

   247

   248

   249

/** Truncate a given string to a maximum width if neccessary.

   250

 * If the string is truncated, add three dots ('...') to show this.

   251

 * @param *dest string that is checked and possibly truncated

   252

 * @param maxw maximum width in pixels of the string

   253

 * @return new width of (truncated) string */

   254

static int TruncateString(char *str, int maxw)

   255

{

   256

	int w = 0;

   257

	FontSize size = _cur_fontsize;

   258

	int ddd, ddd_w;

   259

   261

	char *ddd_pos;

   262

   263

	ddd_w = ddd = GetCharacterWidth(size, '.') * 3;

   264

   267

			w += GetCharacterWidth(size, c);

   268

   269

			if (w >= maxw) {

   270

				// string got too big... insert dotdotdot

   271

				ddd_pos[0] = ddd_pos[1] = ddd_pos[2] = '.';

   272

				ddd_pos[3] = 0;

   273

				return ddd_w;

   274

			}

   275

		} else {

   279

				size = FS_SMALL;

   280

				ddd = GetCharacterWidth(size, '.') * 3;

   282

				size = FS_LARGE;

   283

				ddd = GetCharacterWidth(size, '.') * 3;

   284

			}

   285

		}

   286

   287

		// Remember the last position where three dots fit.

   288

		if (w + ddd < maxw) {

   289

			ddd_w = w + ddd;

   290

			ddd_pos = str;

   291

		}

   292

	}

   293

   294

	return w;

   295

}

   296

   297

static inline int TruncateStringID(StringID src, char *dest, int maxw, const char* last)

   298

{

   299

	GetString(dest, src, last);

   300

	return TruncateString(dest, maxw);

   301

}

   302

   303

/* returns right coordinate */

   304

int DrawString(int x, int y, StringID str, uint16 color)

   305

{

   306

	char buffer[512];

   307

   308

	GetString(buffer, str, lastof(buffer));

   309

	return DoDrawString(buffer, x, y, color);

   310

}

   311

   312

int DrawStringTruncated(int x, int y, StringID str, uint16 color, uint maxw)

   313

{

   314

	char buffer[512];

   315

	TruncateStringID(str, buffer, maxw, lastof(buffer));

   316

	return DoDrawString(buffer, x, y, color);

   317

}

   318

   319

   320

int DrawStringRightAligned(int x, int y, StringID str, uint16 color)

   321

{

   322

	char buffer[512];

   323

	int w;

   324

   325

	GetString(buffer, str, lastof(buffer));

   326

	w = GetStringBoundingBox(buffer).width;

   327

	DoDrawString(buffer, x - w, y, color);

   328

   329

	return w;

   330

}

   331

   332

void DrawStringRightAlignedTruncated(int x, int y, StringID str, uint16 color, uint maxw)

   333

{

   334

	char buffer[512];

   335

   336

	TruncateStringID(str, buffer, maxw, lastof(buffer));

   337

	DoDrawString(buffer, x - GetStringBoundingBox(buffer).width, y, color);

   338

}

   339

   340

void DrawStringRightAlignedUnderline(int x, int y, StringID str, uint16 color)

   341

{

   342

	int w = DrawStringRightAligned(x, y, str, color);

   343

	GfxFillRect(x - w, y + 10, x, y + 10, _string_colorremap[1]);

   344

}

   345

   346

   347

int DrawStringCentered(int x, int y, StringID str, uint16 color)

   348

{

   349

	char buffer[512];

   350

	int w;

   351

   352

	GetString(buffer, str, lastof(buffer));

   353

   354

	w = GetStringBoundingBox(buffer).width;

   355

	DoDrawString(buffer, x - w / 2, y, color);

   356

   357

	return w;

   358

}

   359

   360

int DrawStringCenteredTruncated(int xl, int xr, int y, StringID str, uint16 color)

   361

{

   362

	char buffer[512];

   363

	int w = TruncateStringID(str, buffer, xr - xl, lastof(buffer));

   364

	return DoDrawString(buffer, (xl + xr - w) / 2, y, color);

   365

}

   366

   367

int DoDrawStringCentered(int x, int y, const char *str, uint16 color)

   368

{

   369

	int w = GetStringBoundingBox(str).width;

   370

	DoDrawString(str, x - w / 2, y, color);

   371

	return w;

   372

}

   373

   374

void DrawStringCenterUnderline(int x, int y, StringID str, uint16 color)

   375

{

   376

	int w = DrawStringCentered(x, y, str, color);

   377

	GfxFillRect(x - (w >> 1), y + 10, x - (w >> 1) + w, y + 10, _string_colorremap[1]);

   378

}

   379

   380

void DrawStringCenterUnderlineTruncated(int xl, int xr, int y, StringID str, uint16 color)

   381

{

   382

	int w = DrawStringCenteredTruncated(xl, xr, y, str, color);

   383

	GfxFillRect((xl + xr - w) / 2, y + 10, (xl + xr + w) / 2, y + 10, _string_colorremap[1]);

   384

}

   385

   386

/** 'Correct' a string to a maximum length. Longer strings will be cut into

   387

 * additional lines at whitespace characters if possible. The string parameter

   388

 * is modified with terminating characters mid-string which are the

   389

 * placeholders for the newlines.<br/>

   390

 * The string WILL be truncated if there was no whitespace for the current

   391

 * line's maximum width.

   392

 *

   393

 * @note To know if the the terminating '\0' is the string end or just a

   394

 * newline, the returned 'num' value should be consulted. The num'th '\0',

   395

 * starting with index 0 is the real string end.

   396

 *

   397

 * @param str string to check and correct for length restrictions

   398

 * @param maxw the maximum width the string can have on one line

   399

 * @return return a 32bit wide number consisting of 2 packed values:

   400

 *  0 - 15 the number of lines ADDED to the string

   401

 * 16 - 31 the fontsize in which the length calculation was done at */

   402

uint32 FormatStringLinebreaks(char *str, int maxw)

   403

{

   404

	FontSize size = _cur_fontsize;

   405

	int num = 0;

   406

   407

	assert(maxw > 0);

   408

   409

	for (;;) {

   410

		char *last_space = NULL;

   411

		int w = 0;

   412

   413

		for (;;) {

   415

			/* whitespace is where we will insert the line-break */

   417

   419

				w += GetCharacterWidth(size, c);

   420

				/* string is longer than maximum width so we need to decide what to

   421

				 * do. We can do two things:

   422

				 * 1. If no whitespace was found at all up until now (on this line) then

   423

				 *    we will truncate the string and bail out.

   424

				 * 2. In all other cases force a linebreak at the last seen whitespace */

   425

				if (w > maxw) {

   426

					if (last_space == NULL) {

   427

						str[-1] = '\0';

   428

						return num + (size << 16);

   429

					}

   430

					str = last_space;

   431

					break;

   432

				}

   433

			} else {

   434

				switch (c) {

   435

					case '\0': return num + (size << 16); break;

   441

				}

   442

			}

   443

		}

   444

end_of_inner_loop:

   445

		/* string didn't fit on line, so 'dummy' terminate and increase linecount */

   446

		num++;

   447

		str[-1] = '\0';

   448

	}

   449

}

   450

   451

void DrawStringMultiCenter(int x, int y, StringID str, int maxw)

   452

{

   453

	char buffer[512];

   454

	uint32 tmp;

   455

	int num, w, mt;

   456

	const char *src;

   458

   459

	GetString(buffer, str, lastof(buffer));

   460

   461

	tmp = FormatStringLinebreaks(buffer, maxw);

   462

	num = GB(tmp, 0, 16);

   463

   464

	mt = GetCharacterHeight(GB(tmp, 16, 16));

   465

   466

	y -= (mt >> 1) * num;

   467

   468

	src = buffer;

   469

   470

	for (;;) {

   471

		w = GetStringBoundingBox(src).width;

   472

		DoDrawString(src, x - (w>>1), y, 0xFE);

   473

		_cur_fontsize = _last_fontsize;

   474

   475

		for (;;) {

   477

			if (c == 0) {

   478

				y += mt;

   479

				if (--num < 0) {

   480

					_cur_fontsize = FS_NORMAL;

   481

					return;

   482

				}

   483

				break;

   485

				src++;

   487

				src+=2;

   488

			}

   489

		}

   490

	}

   491

}

   492

   493

   494

uint DrawStringMultiLine(int x, int y, StringID str, int maxw)