static const byte *_color_remap_ptr;

static byte _string_colorremap[3];

static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

}

	int p;

	int ht;

	UndrawTextMessage();

	p = _screen.pitch;

}

	DrawPixelInfo *dpi = _cur_dpi;

	byte *dst;

	const int otop = top;

	const int oleft = left;

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

	right = right - dpi->left + 1;

	right -= left;

	assert(right > 0);

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

	bottom = bottom - dpi->top + 1;

	bottom -= top;

	assert(bottom > 0);

	DrawPixelInfo *dpi = _cur_dpi;

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

		return;

}

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

{

	int dy;

	int dx;

	int frac;

	// Check clipping first

		DrawPixelInfo *dpi = _cur_dpi;

		int t;

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

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

	}

	dy = (y2 - y) * 2;

	dx = (x2 - x) * 2;

	GfxSetPixel(x, y, color);

	if (dx > dy) {

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

{

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

}

static uint32 FormatStringLinebreaks(char *str, int maxw)

	}

}

	char buffer[512];

	uint32 tmp;

	int num, w, mt, t;

	return w;

}

	byte color_2 = _color_list[ctab].window_color_1a;

	byte color_interior = _color_list[ctab].window_color_bga;

	byte color_3 = _color_list[ctab].window_color_bgb;

	if (!(flags & 0x8))	{

		if (!(flags & 0x20)) {

			GfxFillRect(left, bottom, right, bottom, color_2);

			if (!(flags & 0x10)) {

			}

		} else {

			GfxFillRect(left, top, left, bottom, color_2);

			if (!(flags & 0x10)) {

			}

		}

	} else if (flags & 0x1) {

	}

}

	if (img & 0x8000) {

		_color_remap_ptr = GetNonSprite(img >> 16) + 1;

		GfxMainBlitter(GetSprite(img & 0x3FFF), x, y, 1);

	byte *dst;

	int mode;

	int width, height;

	int pitch;

	byte info;

} BlitterParams;

				} else {

					src -= skip;

					num += skip;

					skip = 0;

				}

				skip = skip + num - bp->width;

				if (skip > 0) {

					num -= skip;

				}

				ctab = _color_remap_ptr;

			} while (!(done & 0x80));

			bp->dst += bp->pitch;

	} else if (bp->mode & 2) {

		src_o += READ_LE_UINT16(src_o + bp->start_y * 2);

		do {

					dst += skip;

				} else {

					num += skip;

					skip = 0;

				}

				skip = skip + num - bp->width;

				if (skip > 0) {

					num -= skip;

				}

				ctab = _color_remap_ptr;

			} while (!(done & 0x80));

			bp->dst += bp->pitch;

	} else {

		src_o += READ_LE_UINT16(src_o + bp->start_y * 2);

		do {

				} else {

					src -= skip;

					num += skip;

					skip = 0;

				}

				skip = skip + num - bp->width;

				if (skip > 0) {

					num -= skip;

				}

#if defined(_WIN32)

				if (num & 1) *dst++ = *src++;

						*(uint32*)dst = *(uint32*)src;

						dst += 4;

						src += 4;

				}

#else

				memcpy(dst, src, num);

			} while (!(done & 0x80));

			bp->dst += bp->pitch;

	}

}

				}

				src += bp->width_org;

				dst += bp->pitch;

		}

	} else if (bp->mode & 2) {

		if (bp->info & 1) {

					if (src[i] != 0) dst[i] = ctab[dst[i]];

				src += bp->width_org;

				dst += bp->pitch;

		}

	} else {

		if (!(bp->info & 1)) {

				memcpy(dst, src, width);

				src += bp->width_org;

				dst += bp->pitch;

		} else {

			do {

				int n = width;

				src += bp->width_org - width;

				dst += bp->pitch - width;

		}

	}

}

				} else {

					src -= skip;

					num += skip;

					skip = 0;

				}

				skip = skip + num - bp->width;

				if (skip > 0) {

					num -= skip;

				}

				ctab = _color_remap_ptr;

				done = src_o[0];

				src_o += (done & 0x7F) + 2;

			} while (!(done & 0x80));

	} else if (bp->mode & 2) {

		src_o += READ_LE_UINT16(src_o + bp->start_y * 2);

		do {

					dst += skip >> 1;

				} else {

					num += skip;

					skip = 0;

				}

				skip = skip + num - bp->width;

				if (skip > 0) {

					num -= skip;

				}

				ctab = _color_remap_ptr;

				done = src_o[0];

				src_o += (done & 0x7F) + 2;

			} while (!(done & 0x80));

	} else {

		src_o += READ_LE_UINT16(src_o + bp->start_y * 2);

		do {

				} else {

					src -= skip;

					num += skip;

					skip = 0;

				}

				skip = skip + num - bp->width;

				if (skip > 0) {

					num -= skip;

				}

				num = (num + 1) >> 1;

				done = src_o[0];

				src_o += (done & 0x7F) + 2;

			} while (!(done & 0x80));

	}

}

	DoPaletteAnimations();

}

void DoPaletteAnimations(void)

{

void DrawMouseCursor(void)

{

	// Don't draw the mouse cursor if it's already drawn

	if (_cursor.visible) {

		UndrawMouseCursor();

	}

	w = _cursor.size.x;

	x = _cursor.pos.x + _cursor.offs.x;

	if (w <= 0) return;

	_cursor.draw_pos.x = x;

	_cursor.draw_size.x = w;

	h = _cursor.size.y;

	y = _cursor.pos.y + _cursor.offs.y;

	if (h <= 0) return;

	_cursor.draw_pos.y = y;

	_cursor.draw_size.y = h;

	// Make backup of stuff below cursor

	memcpy_pitch(

#if defined(_DEBUG)

static void DbgScreenRect(int left, int top, int right, int bottom)

{

	old = _cur_dpi;

	_cur_dpi = &dp;

	dp = _screen;

	_cur_dpi = old;

}

#endif

#endif

		DrawOverlappedWindowForAll(left, top, right, bottom);

}

void DrawDirtyBlocks(void)

{

	byte *b = _dirty_blocks;

	const int w = (_screen.width + 63) & ~63;

	const int h = (_screen.height + 7) & ~7;

void SetDirtyBlocks(int left, int top, int right, int bottom)

{

	byte *b;

	if (left < 0) left = 0;

	if (top < 0) top = 0;

	if (right > _screen.width) right = _screen.width;

	if (bottom > _screen.height) bottom = _screen.height;

	left >>= 6;

	b = _dirty_blocks + top * DIRTY_BYTES_PER_LINE + left;

	assert(width > 0 && height > 0);

	do {

		do b[--i] = 0xFF; while (i);

		b += DIRTY_BYTES_PER_LINE;

}

void MarkWholeScreenDirty(void)

{

	int t;

	n->zoom = 0;

	n->left = 0;

	if ((left -= o->left) < 0) {

		n->left = -left;

		left = 0;

	}

	if ((t=width + left - o->width) > 0) {

	}

	n->width = width;

	n->top = 0;

	if ((top -= o->top) < 0) {

		n->top = -top;

		top = 0;

	}

	n->dst_ptr = o->dst_ptr + left + top * (n->pitch = o->pitch);

	if ((t=height + top - o->height) > 0) {

	}

	n->height = height;

	return true;

}

	CursorVars *cv = &_cursor;

	const Sprite *p;

	p =	GetSprite(cursor & 0x3FFF);

	cv->sprite = cursor;

void CursorTick(void)

{

		SwitchAnimatedCursor();

}