#include "stdafx.h"

#include "clear_map.h"

#include "industry.h"

#include "station_map.h"

#include "landscape.h"

#include "tree_map.h"

#include "viewport_func.h"

#include "town.h"

#include "tunnelbridge_map.h"

#include "core/endian_func.hpp"

#include "vehicle_base.h"

#include "sound_func.h"

#include "window_func.h"

#include "company_base.h"

#include "table/strings.h"

static int _smallmap_industry_count; ///< Number of used industries

static int _smallmap_company_count;  ///< Number of entries in the owner legend.

/**

 * Macro for break marker in arrays of LegendAndColour.

 * It will have valid data, though

 */

#define MS(a, b) {a, b, INVALID_INDUSTRYTYPE, 0, INVALID_COMPANY, true, false, true}

/** Legend text giving the colours to look for on the minimap */

static LegendAndColour _legend_land_contours[] = {

	/* The colours for the following values are set at BuildLandLegend() based on each colour scheme. */

	MC(0),

	MC(4),

	MC(8),

/** Vehicle colours in #SMT_VEHICLES mode. Indexed by #VehicleTypeByte. */

static const byte _vehicle_type_colours[6] = {

	PC_RED, PC_YELLOW, PC_LIGHT_BLUE, PC_WHITE, PC_BLACK, PC_RED

};

	{

		Point pt;

		pt.x = (y - x) * 2;

		pt.y = y + x;

		return pt;

	}

	/**

	 * Remap tile to location on this smallmap.

	 * @param tile_x X coordinate of the tile.

	 * @param tile_y Y coordinate of the tile.

	 * @return Position to draw on.

	 */

	{

		int x_offset = tile_x - this->scroll_x / (int)TILE_SIZE;

		int y_offset = tile_y - this->scroll_y / (int)TILE_SIZE;

		if (this->zoom == 1) return SmallmapRemapCoords(x_offset, y_offset);

	 * @param py       Vertical coordinate of the pixel.

	 * @param sub[out] Pixel position at the tile (0..3).

	 * @param add_sub  Add current #subscroll to the position.

	 * @return Tile being displayed at the given position relative to #scroll_x and #scroll_y.

	 * @note The #subscroll offset is already accounted for.

	 */

	{

		if (add_sub) px += this->subscroll;  // Total horizontal offset.

		/* For each two rows down, add a x and a y tile, and

		 * For each four pixels to the right, move a tile to the right. */

		Point pt = {((py >> 1) - (px >> 2)) * this->zoom, ((py >> 1) + (px >> 2)) * this->zoom};

	 * @param ty        Tile y coordinate.

	 * @param x         Non-negative horizontal position in the display where the tile starts.

	 * @param y         Non-negative vertical position in the display where the tile starts.

	 * @param sub [out] Value of #subscroll needed.

	 * @return #scroll_x, #scroll_y values.

	 */

	{

		assert(x >= 0 && y >= 0);

		int new_sub;

		Point tile_xy = PixelToTile(x, y, &new_sub, false);

		tx -= tile_xy.x;

	/**

	 * Initialize or change the zoom level.

	 * @param change  Way to change the zoom level.

	 * @param zoom_pt Position to keep fixed while zooming.

	 * @pre \c *zoom_pt should contain a point in the smallmap display when zooming in or out.

	 */

	{

		static const int zoomlevels[] = {1, 2, 4, 6, 8}; // Available zoom levels. Bigger number means more zoom-out (further away).

		static const int MIN_ZOOM_INDEX = 0;

		static const int MAX_ZOOM_INDEX = lengthof(zoomlevels) - 1;

		int new_index, cur_index, sub;

	/**

	 * Decide which colours to show to the user for a group of tiles.

	 * @param ta Tile area to investigate.

	 * @return Colours to display.

	 */

	{

		int importance = 0;

		TileIndex tile = INVALID_TILE; // Position of the most important tile.

		TileType et = MP_VOID;         // Effective tile type at that position.

		TILE_AREA_LOOP(ti, ta) {

	 * @param reps Number of lines to draw

	 * @param start_pos Position of first pixel to draw.

	 * @param end_pos Position of last pixel to draw (exclusive).

	 * @param blitter current blitter

	 * @note If pixel position is below \c 0, skip drawing.

	 */

	{

		void *dst_ptr_abs_end = blitter->MoveTo(_screen.dst_ptr, 0, _screen.height);

		uint min_xy = _settings_game.construction.freeform_edges ? 1 : 0;

		do {

			/* Check if the tile (xc,yc) is within the map range */

	/**

	 * Adds vehicles to the smallmap.

	 * @param dpi the part of the smallmap to be drawn into

	 * @param blitter current blitter

	 */

	{

		const Vehicle *v;

		FOR_ALL_VEHICLES(v) {

			if (v->type == VEH_EFFECT) continue;

			if (v->vehstatus & (VS_HIDDEN | VS_UNCLICKABLE)) continue;

	}

	/**

	 * Adds town names to the smallmap.

	 * @param dpi the part of the smallmap to be drawn into

	 */

	{

		const Town *t;

		FOR_ALL_TOWNS(t) {

			/* Remap the town coordinate */

			Point pt = this->RemapTile(TileX(t->xy), TileY(t->xy));

			int x = pt.x - this->subscroll - (t->cache.sign.width_small >> 1);

				DrawString(x, x + t->cache.sign.width_small, y, STR_SMALLMAP_TOWN);

			}

		}

	}

	/**

	 * Adds map indicators to the smallmap.

	 */

	{

		/* Find main viewport. */

		const ViewPort *vp = FindWindowById(WC_MAIN_WINDOW, 0)->viewport;

		Point tile = InverseRemapCoords(vp->virtual_left, vp->virtual_top);

		Point tl = this->RemapTile(tile.x >> 4, tile.y >> 4);

	 * The passes are:

	 * <ol><li>The colours of tiles in the different modes.</li>

	 * <li>Town names (optional)</li></ol>

	 *

	 * @param dpi pointer to pixel to write onto

	 */

	{

		Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

		DrawPixelInfo *old_dpi;

		old_dpi = _cur_dpi;

		_cur_dpi = dpi;

		_cur_dpi = old_dpi;

	}

	/**

	 * Function to set up widgets depending on the information being shown on the smallmap.

	 */

	{

		StringID legend_tooltip;

		StringID enable_all_tooltip;

		StringID disable_all_tooltip;

		int plane;

		switch (this->map_type) {

		this->GetWidget<NWidgetCore>(WID_SM_LEGEND)->SetDataTip(STR_NULL, legend_tooltip);

		this->GetWidget<NWidgetCore>(WID_SM_ENABLE_ALL)->SetDataTip(STR_SMALLMAP_ENABLE_ALL, enable_all_tooltip);

		this->GetWidget<NWidgetCore>(WID_SM_DISABLE_ALL)->SetDataTip(STR_SMALLMAP_DISABLE_ALL, disable_all_tooltip);

		this->GetWidget<NWidgetStacked>(WID_SM_SELECT_BUTTONS)->SetDisplayedPlane(plane);

	}

	{

		_smallmap_industry_highlight = INVALID_INDUSTRYTYPE;

		this->InitNested(desc, window_number);

		this->LowerWidget(this->map_type + WID_SM_CONTOUR);

		BuildLandLegend();

		this->SetZoomLevel(ZLC_INITIALIZE, NULL);

		this->SmallMapCenterOnCurrentPos();

	}

	/**

	 * Compute height given a number of columns.

	 * @param num_columns Number of columns.

	 * @return Needed height for displaying the smallmap legends in pixels.

	 */

	{

		uint num_rows = max(this->min_number_of_fixed_rows, CeilDiv(max(_smallmap_company_count, _smallmap_industry_count), num_columns));

		return WD_FRAMERECT_TOP + WD_FRAMERECT_BOTTOM + num_rows * FONT_HEIGHT_SMALL;

	}

	{

		switch (widget) {

			case WID_SM_CAPTION:

				SetDParam(0, STR_SMALLMAP_TYPE_CONTOURS + this->map_type);

				break;

		}

	}

	{

		uint min_width = 0;

		this->min_number_of_columns = INDUSTRY_MIN_NUMBER_OF_COLUMNS;

		this->min_number_of_fixed_rows = 0;

		for (uint i = 0; i < lengthof(_legend_table); i++) {

			uint height = 0;

		}

		/* The width of a column is the minimum width of all texts + the size of the blob + some spacing */

		this->column_width = min_width + LEGEND_BLOB_WIDTH + WD_FRAMERECT_LEFT + WD_FRAMERECT_RIGHT;

	}

	{

		if (this->map_type == SMT_OWNER) {

			for (const LegendAndColour *tbl = _legend_table[this->map_type]; !tbl->end; ++tbl) {

				if (tbl->company != INVALID_COMPANY && !Company::IsValidID(tbl->company)) {

					/* Rebuild the owner legend. */

					BuildOwnerLegend();

			}

		}

		this->DrawWidgets();

	}

	{

		switch (widget) {

			case WID_SM_MAP: {

				DrawPixelInfo new_dpi;

				if (!FillDrawPixelInfo(&new_dpi, r.left + 1, r.top + 1, r.right - r.left - 1, r.bottom - r.top - 1)) return;

				this->DrawSmallMap(&new_dpi);

	}

	/**

	 * Select a new map type.

	 * @param map_type New map type.

	 */

	{

		this->RaiseWidget(this->map_type + WID_SM_CONTOUR);

		this->map_type = map_type;

		this->LowerWidget(this->map_type + WID_SM_CONTOUR);

		this->SetupWidgetData();

	/**

	 * Determines the mouse position on the legend.

	 * @param pt Mouse position.

	 * @return Legend item under the mouse.

	 */

	{

		const NWidgetBase *wi = this->GetWidget<NWidgetBase>(WID_SM_LEGEND);

		uint line = (pt.y - wi->pos_y - WD_FRAMERECT_TOP) / FONT_HEIGHT_SMALL;

		uint columns = this->GetNumberColumnsLegend(wi->current_x);

		uint number_of_rows = max(CeilDiv(max(_smallmap_company_count, _smallmap_industry_count), columns), this->min_number_of_fixed_rows);

		if (line >= number_of_rows) return -1;

		if (rtl) x = wi->current_x - x;

		uint column = (x - WD_FRAMERECT_LEFT) / this->column_width;

		return (column * number_of_rows) + line;

	}

	{

		IndustryType new_highlight = INVALID_INDUSTRYTYPE;

		if (widget == WID_SM_LEGEND && this->map_type == SMT_INDUSTRY) {

			int industry_pos = GetPositionOnLegend(pt);

			if (industry_pos >= 0 && industry_pos < _smallmap_industry_count) {

				new_highlight = _legend_from_industries[industry_pos].type;

			this->refresh = _smallmap_industry_highlight != INVALID_INDUSTRYTYPE ? BLINK_PERIOD : FORCE_REFRESH_PERIOD;

			_smallmap_industry_highlight_state = true;

			this->SetDirty();

		}

	}

	{

		/* User clicked something, notify the industry chain window to stop sending newly selected industries. */

		InvalidateWindowClassesData(WC_INDUSTRY_CARGOES, NUM_INDUSTRYTYPES);

		switch (widget) {

			case WID_SM_MAP: { // Map window

	 * Some data on this window has become invalid.

	 * @param data Information about the changed data.

	 * - data = 0: Displayed industries at the industry chain window have changed.

	 * - data = 1: Companies have changed.

	 * @param gui_scope Whether the call is done from GUI scope. You may not do everything when not in GUI scope. See #InvalidateWindowData() for details.

	 */

	{

		if (!gui_scope) return;

		switch (data) {

			case 1:

				/* The owner legend has already been rebuilt. */

				this->ReInit();

			default: NOT_REACHED();

		}

		this->SetDirty();

	}

	{

		if (widget != WID_SM_MAP || _scrolling_viewport) return false;

		_scrolling_viewport = true;

		return true;

	}

	{

		if (_settings_client.gui.scrollwheel_scrolling == 0) {

			const NWidgetBase *wid = this->GetWidget<NWidgetBase>(WID_SM_MAP);

			int cursor_x = _cursor.pos.x - this->left - wid->pos_x;

			int cursor_y = _cursor.pos.y - this->top  - wid->pos_y;

			if (IsInsideMM(cursor_x, 0, wid->current_x) && IsInsideMM(cursor_y, 0, wid->current_y)) {

				Point pt = {cursor_x, cursor_y};

				this->SetZoomLevel((wheel < 0) ? ZLC_ZOOM_IN : ZLC_ZOOM_OUT, &pt);

			}

		}

	}

	{

		/* Update the window every now and then */

		if (--this->refresh != 0) return;

		_smallmap_industry_highlight_state = !_smallmap_industry_highlight_state;

	 * Set new #scroll_x, #scroll_y, and #subscroll values after limiting them such that the center

	 * of the smallmap always contains a part of the map.

	 * @param sx  Proposed new #scroll_x

	 * @param sy  Proposed new #scroll_y

	 * @param sub Proposed new #subscroll

	 */

	{

		const NWidgetBase *wi = this->GetWidget<NWidgetBase>(WID_SM_MAP);

		Point hv = InverseRemapCoords(wi->current_x * ZOOM_LVL_BASE * TILE_SIZE / 2, wi->current_y * ZOOM_LVL_BASE * TILE_SIZE / 2);

		hv.x *= this->zoom;

		hv.y *= this->zoom;

		this->scroll_x = sx;

		this->scroll_y = sy;

		this->subscroll = sub;

	}

	{

		_cursor.fix_at = true;

		/* While tile is at (delta.x, delta.y)? */

		int sub;

		Point pt = this->PixelToTile(delta.x, delta.y, &sub);

		this->SetNewScroll(this->scroll_x + pt.x * TILE_SIZE, this->scroll_y + pt.y * TILE_SIZE, sub);

		this->SetDirty();

	}

	{

		const ViewPort *vp = FindWindowById(WC_MAIN_WINDOW, 0)->viewport;

		Point pt = InverseRemapCoords(vp->virtual_left + vp->virtual_width  / 2, vp->virtual_top  + vp->virtual_height / 2);

		int sub;

		const NWidgetBase *wid = this->GetWidget<NWidgetBase>(WID_SM_MAP);

		Point sxy = this->ComputeScroll(pt.x / TILE_SIZE, pt.y / TILE_SIZE, max(0, (int)wid->current_x / 2 - 2), wid->current_y / 2, &sub);

		this->SetNewScroll(sxy.x, sxy.y, sub);

		this->SetDirty();

	}

SmallMapWindow::SmallMapType SmallMapWindow::map_type = SMT_CONTOUR;

bool SmallMapWindow::show_towns = true;

/**

 * Custom container class for displaying smallmap with a vertically resizing legend panel.

/** @file smallmap_gui.h Smallmap GUI functions. */

#ifndef SMALLMAP_GUI_H

#define SMALLMAP_GUI_H

void BuildIndustriesLegend();

void ShowSmallMap();

void BuildLandLegend();

void BuildOwnerLegend();

#endif /* SMALLMAP_GUI_H */