cpp/openttd-patchpack/source Changeset - r28814:02b90af3b0cc

Changeset - r28814:02b90af3b0cc

Parent rev.

Child rev.

[Not reviewed]

master

0 19 0

Peter Nelson - 11 months ago 2023-12-28 10:04:55
peter1138@openttd.org

Codechange: Give ColourShade values names instead of numbers.

19 files changed with 55 insertions and 55 deletions:

src/build_vehicle_gui.cpp

src/company_cmd.cpp

src/console_gui.cpp

src/depot_gui.cpp

src/graph_gui.cpp

src/group_gui.cpp

src/linkgraph/linkgraph_gui.cpp

src/misc_gui.cpp

src/network/network_gui.cpp

src/order_gui.cpp

src/palette_func.h

src/settings_gui.cpp

src/smallmap_gui.cpp

src/train_gui.cpp

src/vehicle_gui.cpp

src/viewport.cpp

src/widget.cpp

src/widgets/dropdown_type.h

src/widgets/slider.cpp

0 comments (0 inline, 0 general)

src/build_vehicle_gui.cpp

➞

Show inline comments

@@ @@ -996,49 +996,49 @@ int DrawVehiclePurchaseInfo(int left, in @@
 /**
  * Engine drawing loop
  * @param type Type of vehicle (VEH_*)
  * @param r The Rect of the list
  * @param eng_list What engines to draw
  * @param min where to start in the list
  * @param max where in the list to end
  * @param selected_id what engine to highlight as selected, if any
  * @param show_count Whether to show the amount of engines or not
  * @param selected_group the group to list the engines of
  */
 void DrawEngineList(VehicleType type, const Rect &r, const GUIEngineList &eng_list, uint16_t min, uint16_t max, EngineID selected_id, bool show_count, GroupID selected_group)
+{
 	static const int sprite_y_offsets[] = { -1, -1, -2, -2 };
 	/* Obligatory sanity checks! */
 	assert(max <= eng_list.size());
 	bool rtl = _current_text_dir == TD_RTL;
 	int step_size = GetEngineListHeight(type);
 	int sprite_left  = GetVehicleImageCellSize(type, EIT_PURCHASE).extend_left;
 	int sprite_right = GetVehicleImageCellSize(type, EIT_PURCHASE).extend_right;
 	int sprite_width = sprite_left + sprite_right;
 	int circle_width = std::max(GetScaledSpriteSize(SPR_CIRCLE_FOLDED).width, GetScaledSpriteSize(SPR_CIRCLE_UNFOLDED).width);
-	int linecolour = GetColourGradient(COLOUR_ORANGE, SHADE_4);
+	int linecolour = GetColourGradient(COLOUR_ORANGE, SHADE_NORMAL);
 	Rect ir      = r.WithHeight(step_size).Shrink(WidgetDimensions::scaled.matrix);
 	int sprite_y_offset = ScaleSpriteTrad(sprite_y_offsets[type]) + ir.Height() / 2;
 	Dimension replace_icon = {0, 0};
 	int count_width = 0;
 	if (show_count) {
 		replace_icon = GetSpriteSize(SPR_GROUP_REPLACE_ACTIVE);
 		uint biggest_num_engines = 0;
 		for (auto i = min; i < max; i++) {
 			const auto &item = eng_list[i];
 			const uint num_engines = GetGroupNumEngines(_local_company, selected_group, item.engine_id);
 			biggest_num_engines = std::max(biggest_num_engines, num_engines);
+		}
 		SetDParam(0, biggest_num_engines);
 		count_width = GetStringBoundingBox(STR_JUST_COMMA, FS_SMALL).width;
+	}
 	Rect tr = ir.Indent(circle_width + WidgetDimensions::scaled.hsep_normal + sprite_width + WidgetDimensions::scaled.hsep_wide, rtl); // Name position
 	Rect cr = tr.Indent(replace_icon.width + WidgetDimensions::scaled.hsep_wide, !rtl).WithWidth(count_width, !rtl);  // Count position
 	Rect rr = tr.WithWidth(replace_icon.width, !rtl);                                                                 // Replace icon position
 	if (show_count) tr = tr.Indent(count_width + WidgetDimensions::scaled.hsep_normal + replace_icon.width + WidgetDimensions::scaled.hsep_wide, !rtl);

src/company_cmd.cpp

➞

Show inline comments

@@ @@ -125,50 +125,50 @@ void SetLocalCompany(CompanyID new_compa @@
 	assert(IsLocalCompany());
 	_current_company = _local_company = new_company;
 	if (switching_company) {
 		InvalidateWindowClassesData(WC_COMPANY);
 		/* Delete any construction windows... */
 		CloseConstructionWindows();
+	}
 	/* ... and redraw the whole screen. */
 	MarkWholeScreenDirty();
 	InvalidateWindowClassesData(WC_SIGN_LIST, -1);
 	InvalidateWindowClassesData(WC_GOALS_LIST);
+}
 /**
  * Get the colour for DrawString-subroutines which matches the colour of the company.
  * @param company Company to get the colour of.
  * @return Colour of \a company.
  */
 TextColour GetDrawStringCompanyColour(CompanyID company)
+{
 	if (!Company::IsValidID(company)) return (TextColour)GetColourGradient(COLOUR_WHITE, SHADE_4) | TC_IS_PALETTE_COLOUR;
 	return (TextColour)GetColourGradient(_company_colours[company], SHADE_4) | TC_IS_PALETTE_COLOUR;
 	if (!Company::IsValidID(company)) return (TextColour)GetColourGradient(COLOUR_WHITE, SHADE_NORMAL) | TC_IS_PALETTE_COLOUR;
 	return (TextColour)GetColourGradient(_company_colours[company], SHADE_NORMAL) | TC_IS_PALETTE_COLOUR;
+}
 /**
  * Draw the icon of a company.
  * @param c Company that needs its icon drawn.
  * @param x Horizontal coordinate of the icon.
  * @param y Vertical coordinate of the icon.
  */
 void DrawCompanyIcon(CompanyID c, int x, int y)
+{
 	DrawSprite(SPR_COMPANY_ICON, COMPANY_SPRITE_COLOUR(c), x, y);
+}
 /**
  * Checks whether a company manager's face is a valid encoding.
  * Unused bits are not enforced to be 0.
  * @param cmf the fact to check
  * @return true if and only if the face is valid
  */
 static bool IsValidCompanyManagerFace(CompanyManagerFace cmf)
+{
 	if (!AreCompanyManagerFaceBitsValid(cmf, CMFV_GEN_ETHN, GE_WM)) return false;
 	GenderEthnicity ge   = (GenderEthnicity)GetCompanyManagerFaceBits(cmf, CMFV_GEN_ETHN, GE_WM);

src/console_gui.cpp

➞

Show inline comments

@@ @@ -473,29 +473,29 @@ static bool TruncateBuffer() @@
+	}
 	if (need_truncation) {
 		_iconsole_buffer.resize(count - 1);
+	}
 	return need_truncation;
+}
 /**
  * Check whether the given TextColour is valid for console usage.
  * @param c The text colour to compare to.
  * @return true iff the TextColour is valid for console usage.
  */
 bool IsValidConsoleColour(TextColour c)
+{
 	/* A normal text colour is used. */
 	if (!(c & TC_IS_PALETTE_COLOUR)) return TC_BEGIN <= c && c < TC_END;
 	/* A text colour from the palette is used; must be the company
 	 * colour gradient, so it must be one of those. */
 	c &= ~TC_IS_PALETTE_COLOUR;
 	for (Colours i = COLOUR_BEGIN; i < COLOUR_END; i++) {
-		if (GetColourGradient(i, SHADE_4) == c) return true;
+		if (GetColourGradient(i, SHADE_NORMAL) == c) return true;
+	}
 	return false;
+}

src/depot_gui.cpp

➞

Show inline comments

@@ @@ -363,49 +363,49 @@ struct DepotWindow : Window { @@
+		}
+	}
 	void DrawWidget(const Rect &r, WidgetID widget) const override
+	{
 		if (widget != WID_D_MATRIX) return;
 		bool rtl = _current_text_dir == TD_RTL;
 		/* Set the row and number of boxes in each row based on the number of boxes drawn in the matrix */
 		const NWidgetCore *wid = this->GetWidget<NWidgetCore>(WID_D_MATRIX);
 		/* Set up rect for each cell */
 		Rect ir = r.WithHeight(this->resize.step_height);
 		if (this->num_columns != 1) ir = ir.WithWidth(this->resize.step_width, rtl);
 		ir = ir.Shrink(WidgetDimensions::scaled.framerect, RectPadding::zero);
 		/* Draw vertical separators at whole tiles.
 		 * This only works in two cases:
 		 *  - All vehicles use VEHICLEINFO_FULL_VEHICLE_WIDTH as reference width.
 		 *  - All vehicles are 8/8. This cannot be checked for NewGRF, so instead we check for "all vehicles are original vehicles".
 		 */
 		if (this->type == VEH_TRAIN && _consistent_train_width != 0) {
 			int w = ScaleSpriteTrad(2 * _consistent_train_width);
-			int col = GetColourGradient(wid->colour, SHADE_4);
+			int col = GetColourGradient(wid->colour, SHADE_NORMAL);
 			Rect image = ir.Indent(this->header_width, rtl).Indent(this->count_width, !rtl);
 			int first_line = w + (-this->hscroll->GetPosition()) % w;
 			if (rtl) {
 				for (int x = image.right - first_line; x >= image.left; x -= w) {
 					GfxDrawLine(x, r.top, x, r.bottom, col, ScaleGUITrad(1), ScaleGUITrad(3));
+				}
 			} else {
 				for (int x = image.left + first_line; x <= image.right; x += w) {
 					GfxDrawLine(x, r.top, x, r.bottom, col, ScaleGUITrad(1), ScaleGUITrad(3));
+				}
+			}
+		}
 		uint16_t rows_in_display = wid->current_y / wid->resize_y;
 		uint num = this->vscroll->GetPosition() * this->num_columns;
 		uint maxval = static_cast<uint>(std::min<size_t>(this->vehicle_list.size(), num + (rows_in_display * this->num_columns)));
 		for (; num < maxval; ir = ir.Translate(0, this->resize.step_height)) { // Draw the rows
 			Rect cell = ir; /* Keep track of horizontal cells */
 			for (uint i = 0; i < this->num_columns && num < maxval; i++, num++) {
 				/* Draw all vehicles in the current row */
 				const Vehicle *v = this->vehicle_list[num];
 				this->DrawVehicleInDepot(v, cell);
 				cell = cell.Translate(rtl ? -(int)this->resize.step_width : (int)this->resize.step_width, 0);

src/graph_gui.cpp

➞

Show inline comments

@@ @@ -606,49 +606,49 @@ public: @@
+		}
 		int mo = (TimerGameEconomy::month / 3 - nums) * 3;
 		auto yr = TimerGameEconomy::year;
 		while (mo < 0) {
 			yr--;
 			mo += 12;
+		}
 		if (!initialize && this->excluded_data == excluded_companies && this->num_on_x_axis == nums &&
 				this->year == yr && this->month == mo) {
 			/* There's no reason to get new stats */
 			return;
+		}
 		this->excluded_data = excluded_companies;
 		this->num_on_x_axis = nums;
 		this->year = yr;
 		this->month = mo;
 		int numd = 0;
 		for (CompanyID k = COMPANY_FIRST; k < MAX_COMPANIES; k++) {
 			const Company *c = Company::GetIfValid(k);
 			if (c != nullptr) {
-				this->colours[numd] = GetColourGradient(c->colour, SHADE_6);
+				this->colours[numd] = GetColourGradient(c->colour, SHADE_LIGHTER);
 				for (int j = this->num_on_x_axis, i = 0; --j >= 0;) {
 					if (j >= c->num_valid_stat_ent) {
 						this->cost[numd][i] = INVALID_DATAPOINT;
 					} else {
 						/* Ensure we never assign INVALID_DATAPOINT, as that has another meaning.
 						 * Instead, use the value just under it. Hopefully nobody will notice. */
 						this->cost[numd][i] = std::min(GetGraphData(c, j), INVALID_DATAPOINT - 1);
+					}
 					i++;
+				}
+			}
 			numd++;
+		}
 		this->num_dataset = numd;
+	}
 };
 /********************/
 /* OPERATING PROFIT */
 /********************/
 struct OperatingProfitGraphWindow : BaseGraphWindow {
@@ @@ -1273,50 +1273,50 @@ struct PerformanceRatingDetailWindow : W @@
 				this->bar_left  = left + (rtl ? score_detail_width : score_info_width) + WidgetDimensions::scaled.hsep_wide;
 				this->bar_right = this->bar_left + this->bar_width - 1;
 				break;
+		}
+	}
 	void DrawWidget(const Rect &r, WidgetID widget) const override
+	{
 		/* No need to draw when there's nothing to draw */
 		if (this->company == INVALID_COMPANY) return;
 		if (IsInsideMM(widget, WID_PRD_COMPANY_FIRST, WID_PRD_COMPANY_LAST + 1)) {
 			if (this->IsWidgetDisabled(widget)) return;
 			CompanyID cid = (CompanyID)(widget - WID_PRD_COMPANY_FIRST);
 			Dimension sprite_size = GetSpriteSize(SPR_COMPANY_ICON);
 			DrawCompanyIcon(cid, CenterBounds(r.left, r.right, sprite_size.width), CenterBounds(r.top, r.bottom, sprite_size.height));
 			return;
+		}
 		if (!IsInsideMM(widget, WID_PRD_SCORE_FIRST, WID_PRD_SCORE_LAST + 1)) return;
 		ScoreID score_type = (ScoreID)(widget - WID_PRD_SCORE_FIRST);
 		/* The colours used to show how the progress is going */
 		int colour_done = GetColourGradient(COLOUR_GREEN, SHADE_4);
 		int colour_notdone = GetColourGradient(COLOUR_RED, SHADE_4);
 		int colour_done = GetColourGradient(COLOUR_GREEN, SHADE_NORMAL);
 		int colour_notdone = GetColourGradient(COLOUR_RED, SHADE_NORMAL);
 		/* Draw all the score parts */
 		int64_t val    = _score_part[company][score_type];
 		int64_t needed = _score_info[score_type].needed;
 		int   score  = _score_info[score_type].score;
 		/* SCORE_TOTAL has its own rules ;) */
 		if (score_type == SCORE_TOTAL) {
 			for (ScoreID i = SCORE_BEGIN; i < SCORE_END; i++) score += _score_info[i].score;
 			needed = SCORE_MAX;
+		}
 		uint bar_top  = CenterBounds(r.top, r.bottom, this->bar_height);
 		uint text_top = CenterBounds(r.top, r.bottom, GetCharacterHeight(FS_NORMAL));
 		DrawString(this->score_info_left, this->score_info_right, text_top, STR_PERFORMANCE_DETAIL_VEHICLES + score_type);
 		/* Draw the score */
 		SetDParam(0, score);
 		DrawString(this->score_info_left, this->score_info_right, text_top, STR_JUST_COMMA, TC_BLACK, SA_RIGHT);
 		/* Calculate the %-bar */
 		uint x = Clamp<int64_t>(val, 0, needed) * this->bar_width / needed;
 		bool rtl = _current_text_dir == TD_RTL;

src/group_gui.cpp

➞

Show inline comments

@@ @@ -241,49 +241,49 @@ private: @@
 		return WidgetDimensions::scaled.framerect.left +
 			this->column_size[VGC_FOLD].width + WidgetDimensions::scaled.hsep_normal +
 			this->column_size[VGC_NAME].width + WidgetDimensions::scaled.hsep_wide +
 			this->column_size[VGC_PROTECT].width + WidgetDimensions::scaled.hsep_normal +
 			this->column_size[VGC_AUTOREPLACE].width + WidgetDimensions::scaled.hsep_normal +
 			this->column_size[VGC_PROFIT].width + WidgetDimensions::scaled.hsep_normal +
 			this->column_size[VGC_NUMBER].width +
 			WidgetDimensions::scaled.framerect.right;
+	}
 	/**
 	 * Draw a row in the group list.
 	 * @param y Top of the row.
 	 * @param left Left of the row.
 	 * @param right Right of the row.
 	 * @param g_id Group to list.
 	 * @param indent Indentation level.
 	 * @param protection Whether autoreplace protection is set.
 	 * @param has_children Whether the group has children and should have a fold / unfold button.
 	 */
 	void DrawGroupInfo(int y, int left, int right, GroupID g_id, int indent = 0, bool protection = false, bool has_children = false) const
+	{
 		/* Highlight the group if a vehicle is dragged over it */
 		if (g_id == this->group_over) {
-			GfxFillRect(left + WidgetDimensions::scaled.bevel.left, y + WidgetDimensions::scaled.framerect.top, right - WidgetDimensions::scaled.bevel.right, y + this->tiny_step_height - 1 - WidgetDimensions::scaled.framerect.bottom, GetColourGradient(COLOUR_GREY, SHADE_7));
+			GfxFillRect(left + WidgetDimensions::scaled.bevel.left, y + WidgetDimensions::scaled.framerect.top, right - WidgetDimensions::scaled.bevel.right, y + this->tiny_step_height - 1 - WidgetDimensions::scaled.framerect.bottom, GetColourGradient(COLOUR_GREY, SHADE_LIGHTEST));
+		}
 		if (g_id == NEW_GROUP) return;
 		/* draw the selected group in white, else we draw it in black */
 		TextColour colour = g_id == this->vli.index ? TC_WHITE : TC_BLACK;
 		const GroupStatistics &stats = GroupStatistics::Get(this->vli.company, g_id, this->vli.vtype);
 		bool rtl = _current_text_dir == TD_RTL;
 		/* draw fold / unfold button */
 		int x = rtl ? right - WidgetDimensions::scaled.framerect.right - this->column_size[VGC_FOLD].width + 1 : left + WidgetDimensions::scaled.framerect.left;
 		if (has_children) {
 			DrawSprite(Group::Get(g_id)->folded ? SPR_CIRCLE_FOLDED : SPR_CIRCLE_UNFOLDED, PAL_NONE, rtl ? x - indent : x + indent, y + (this->tiny_step_height - this->column_size[VGC_FOLD].height) / 2);
+		}
 		/* draw group name */
 		StringID str;
 		if (IsAllGroupID(g_id)) {
 			str = STR_GROUP_ALL_TRAINS + this->vli.vtype;
 		} else if (IsDefaultGroupID(g_id)) {
 			str = STR_GROUP_DEFAULT_TRAINS + this->vli.vtype;
 		} else {
 			SetDParam(0, g_id);
 			str = STR_GROUP_NAME;
@@ @@ -609,49 +609,49 @@ public: @@
 					assert(g->owner == this->owner);
 					DrawGroupInfo(y1, r.left, r.right, g->index, this->indents[i] * WidgetDimensions::scaled.hsep_indent, HasBit(g->flags, GroupFlags::GF_REPLACE_PROTECTION), g->folded || (i + 1 < this->groups.size() && indents[i + 1] > this->indents[i]));
 					y1 += this->tiny_step_height;
+				}
 				if ((uint)this->group_sb->GetPosition() + this->group_sb->GetCapacity() > this->groups.size()) {
 					DrawGroupInfo(y1, r.left, r.right, NEW_GROUP);
+				}
 				break;
+			}
 			case WID_GL_SORT_BY_ORDER:
 				this->DrawSortButtonState(WID_GL_SORT_BY_ORDER, this->vehgroups.IsDescSortOrder() ? SBS_DOWN : SBS_UP);
 				break;
 			case WID_GL_LIST_VEHICLE:
 				if (this->vli.index != ALL_GROUP && this->grouping == GB_NONE) {
 					/* Mark vehicles which are in sub-groups (only if we are not using shared order coalescing) */
 					Rect mr = r.WithHeight(this->resize.step_height);
 					size_t max = std::min<size_t>(this->vscroll->GetPosition() + this->vscroll->GetCapacity(), this->vehgroups.size());
 					for (size_t i = this->vscroll->GetPosition(); i < max; ++i) {
 						const Vehicle *v = this->vehgroups[i].GetSingleVehicle();
 						if (v->group_id != this->vli.index) {
-							GfxFillRect(mr.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(COLOUR_GREY, SHADE_3), FILLRECT_CHECKER);
+							GfxFillRect(mr.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(COLOUR_GREY, SHADE_DARK), FILLRECT_CHECKER);
+						}
 						mr = mr.Translate(0, this->resize.step_height);
+					}
+				}
 				this->DrawVehicleListItems(this->vehicle_sel, this->resize.step_height, r);
 				break;
+		}
+	}
 	static void DeleteGroupCallback(Window *win, bool confirmed)
+	{
 		if (confirmed) {
 			VehicleGroupWindow *w = (VehicleGroupWindow*)win;
 			w->vli.index = ALL_GROUP;
 			Command<CMD_DELETE_GROUP>::Post(STR_ERROR_GROUP_CAN_T_DELETE, w->group_confirm);
+		}
+	}
 	void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
+	{
 		switch (widget) {
 			case WID_GL_SORT_BY_ORDER: // Flip sorting method ascending/descending
 				this->vehgroups.ToggleSortOrder();

src/linkgraph/linkgraph_gui.cpp

➞

Show inline comments

@@ @@ -291,70 +291,70 @@ void LinkGraphOverlay::DrawLinks(const D @@
 /**
  * Draw one specific link.
  * @param pta Source of the link.
  * @param ptb Destination of the link.
  * @param cargo Properties of the link.
  */
 void LinkGraphOverlay::DrawContent(Point pta, Point ptb, const LinkProperties &cargo) const
+{
 	uint usage_or_plan = std::min(cargo.capacity * 2 + 1, cargo.Usage());
 	int colour = LinkGraphOverlay::LINK_COLOURS[_settings_client.gui.linkgraph_colours][usage_or_plan * lengthof(LinkGraphOverlay::LINK_COLOURS[0]) / (cargo.capacity * 2 + 2)];
 	int width = ScaleGUITrad(this->scale);
 	int dash = cargo.shared ? width * 4 : 0;
 	/* Move line a bit 90° against its dominant direction to prevent it from
 	 * being hidden below the grey line. */
 	int side = _settings_game.vehicle.road_side ? 1 : -1;
 	if (abs(pta.x - ptb.x) < abs(pta.y - ptb.y)) {
 		int offset_x = (pta.y > ptb.y ? 1 : -1) * side * width;
 		GfxDrawLine(pta.x + offset_x, pta.y, ptb.x + offset_x, ptb.y, colour, width, dash);
 	} else {
 		int offset_y = (pta.x < ptb.x ? 1 : -1) * side * width;
 		GfxDrawLine(pta.x, pta.y + offset_y, ptb.x, ptb.y + offset_y, colour, width, dash);
+	}
-	GfxDrawLine(pta.x, pta.y, ptb.x, ptb.y, GetColourGradient(COLOUR_GREY, SHADE_1), width);
+	GfxDrawLine(pta.x, pta.y, ptb.x, ptb.y, GetColourGradient(COLOUR_GREY, SHADE_DARKEST), width);
+}
 /**
  * Draw dots for stations into the smallmap. The dots' sizes are determined by the amount of
  * cargo produced there, their colours by the type of cargo produced.
  */
 void LinkGraphOverlay::DrawStationDots(const DrawPixelInfo *dpi) const
+{
 	int width = ScaleGUITrad(this->scale);
 	for (const auto &i : this->cached_stations) {
 		const Station *st = Station::GetIfValid(i.first);
 		if (st == nullptr) continue;
 		Point pt = this->GetStationMiddle(st);
 		if (!this->IsPointVisible(pt, dpi, 3 * width)) continue;
 		uint r = width * 2 + width * 2 * std::min(200U, i.second) / 200;
 		LinkGraphOverlay::DrawVertex(pt.x, pt.y, r,
 				GetColourGradient(st->owner != OWNER_NONE ?
 						Company::Get(st->owner)->colour : COLOUR_GREY, SHADE_5),
 				GetColourGradient(COLOUR_GREY, SHADE_1));
 						Company::Get(st->owner)->colour : COLOUR_GREY, SHADE_LIGHT),
 				GetColourGradient(COLOUR_GREY, SHADE_DARKEST));
+	}
+}
 /**
  * Draw a square symbolizing a producer of cargo.
  * @param x X coordinate of the middle of the vertex.
  * @param y Y coordinate of the middle of the vertex.
  * @param size x and y extent of the vertex.
  * @param colour Colour with which the vertex will be filled.
  * @param border_colour Colour for the border of the vertex.
  */
 /* static */ void LinkGraphOverlay::DrawVertex(int x, int y, int size, int colour, int border_colour)
+{
 	size--;
 	int w1 = size / 2;
 	int w2 = size / 2 + size % 2;
 	int borderwidth = ScaleGUITrad(1);
 	GfxFillRect(x - w1 - borderwidth, y - w1 - borderwidth, x + w2 + borderwidth, y + w2 + borderwidth, border_colour);
 	GfxFillRect(x - w1, y - w1, x + w2, y + w2, colour);
+}
 bool LinkGraphOverlay::ShowTooltip(Point pt, TooltipCloseCondition close_cond)
+{

src/misc_gui.cpp

➞

Show inline comments

@@ @@ -773,49 +773,49 @@ void QueryString::HandleEditBox(Window * @@
+	}
+}
 static int GetCaretWidth()
+{
 	return GetCharacterWidth(FS_NORMAL, '_');
+}
 void QueryString::DrawEditBox(const Window *w, WidgetID wid) const
+{
 	const NWidgetLeaf *wi = w->GetWidget<NWidgetLeaf>(wid);
 	assert((wi->type & WWT_MASK) == WWT_EDITBOX);
 	bool rtl = _current_text_dir == TD_RTL;
 	Dimension sprite_size = GetScaledSpriteSize(rtl ? SPR_IMG_DELETE_RIGHT : SPR_IMG_DELETE_LEFT);
 	int clearbtn_width = sprite_size.width + WidgetDimensions::scaled.imgbtn.Horizontal();
 	Rect r = wi->GetCurrentRect();
 	Rect cr = r.WithWidth(clearbtn_width, !rtl);
 	Rect fr = r.Indent(clearbtn_width, !rtl);
 	DrawFrameRect(cr, wi->colour, wi->IsLowered() ? FR_LOWERED : FR_NONE);
 	DrawSpriteIgnorePadding(rtl ? SPR_IMG_DELETE_RIGHT : SPR_IMG_DELETE_LEFT, PAL_NONE, cr, SA_CENTER);
-	if (this->text.bytes == 1) GfxFillRect(cr.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(wi->colour, SHADE_2), FILLRECT_CHECKER);
+	if (this->text.bytes == 1) GfxFillRect(cr.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(wi->colour, SHADE_DARKER), FILLRECT_CHECKER);
 	DrawFrameRect(fr, wi->colour, FR_LOWERED | FR_DARKENED);
 	GfxFillRect(fr.Shrink(WidgetDimensions::scaled.bevel), PC_BLACK);
 	fr = fr.Shrink(WidgetDimensions::scaled.framerect);
 	/* Limit the drawing of the string inside the widget boundaries */
 	DrawPixelInfo dpi;
 	if (!FillDrawPixelInfo(&dpi, fr)) return;
 	AutoRestoreBackup dpi_backup(_cur_dpi, &dpi);
 	/* We will take the current widget length as maximum width, with a small
 	 * space reserved at the end for the caret to show */
 	const Textbuf *tb = &this->text;
 	int delta = std::min(0, (fr.right - fr.left) - tb->pixels - GetCaretWidth());
 	if (tb->caretxoffs + delta < 0) delta = -tb->caretxoffs;
 	/* If we have a marked area, draw a background highlight. */
 	if (tb->marklength != 0) GfxFillRect(delta + tb->markxoffs, 0, delta + tb->markxoffs + tb->marklength - 1, fr.bottom - fr.top, PC_GREY);
 	DrawString(delta, tb->pixels, 0, tb->buf, TC_YELLOW);
 	bool focussed = w->IsWidgetGloballyFocused(wid) || IsOSKOpenedFor(w, wid);
 	if (focussed && tb->caret) {

src/network/network_gui.cpp

➞

Show inline comments

@@ @@ -1925,49 +1925,49 @@ public: @@
+	 *
 	 * The x-position in RTL is the most left or otherwise the most right pixel
 	 * we can draw the buttons from.
+	 *
 	 * @param x The x-position to start with the buttons. Updated during this function.
 	 * @param y The y-position to start with the buttons.
 	 * @param buttons The buttons to draw.
 	 */
 	void DrawButtons(int &x, uint y, const std::vector<std::unique_ptr<ButtonCommon>> &buttons) const
+	{
 		Rect r;
 		for (auto &button : buttons) {
 			bool rtl = _current_text_dir == TD_RTL;
 			int offset = (this->line_height - button->height) / 2;
 			r.left = rtl ? x : x - button->width + 1;
 			r.right = rtl ? x + button->width - 1 : x;
 			r.top = y + offset;
 			r.bottom = r.top + button->height - 1;
 			DrawFrameRect(r, button->colour, FR_NONE);
 			DrawSprite(button->sprite, PAL_NONE, r.left + WidgetDimensions::scaled.framerect.left, r.top + WidgetDimensions::scaled.framerect.top);
 			if (button->disabled) {
-				GfxFillRect(r.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(button->colour, SHADE_2), FILLRECT_CHECKER);
+				GfxFillRect(r.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(button->colour, SHADE_DARKER), FILLRECT_CHECKER);
+			}
 			int width = button->width + WidgetDimensions::scaled.hsep_normal;
 			x += rtl ? width : -width;
+		}
+	}
 	/**
 	 * Draw a company and its clients on the matrix.
 	 * @param company_id The company to draw.
 	 * @param r The rect to draw within.
 	 * @param line The Nth line we are drawing. Updated during this function.
 	 */
 	void DrawCompany(CompanyID company_id, const Rect &r, uint &line) const
+	{
 		bool rtl = _current_text_dir == TD_RTL;
 		int text_y_offset = CenterBounds(0, this->line_height, GetCharacterHeight(FS_NORMAL));
 		Dimension d = GetSpriteSize(SPR_COMPANY_ICON);
 		int offset = CenterBounds(0, this->line_height, d.height);
 		uint line_start = this->vscroll->GetPosition();
 		uint line_end = line_start + this->vscroll->GetCapacity();

src/order_gui.cpp

➞

Show inline comments

@@ @@ -1103,49 +1103,49 @@ public: @@
 		if (widget != WID_O_ORDER_LIST) return;
 		Rect ir = r.Shrink(WidgetDimensions::scaled.frametext, WidgetDimensions::scaled.framerect);
 		bool rtl = _current_text_dir == TD_RTL;
 		SetDParamMaxValue(0, this->vehicle->GetNumOrders(), 2);
 		int index_column_width = GetStringBoundingBox(STR_ORDER_INDEX).width + 2 * GetSpriteSize(rtl ? SPR_ARROW_RIGHT : SPR_ARROW_LEFT).width + WidgetDimensions::scaled.hsep_normal;
 		int middle = rtl ? ir.right - index_column_width : ir.left + index_column_width;
 		int y = ir.top;
 		int line_height = this->GetWidget<NWidgetBase>(WID_O_ORDER_LIST)->resize_y;
 		int i = this->vscroll->GetPosition();
 		const Order *order = this->vehicle->GetOrder(i);
 		/* First draw the highlighting underground if it exists. */
 		if (this->order_over != INVALID_VEH_ORDER_ID) {
 			while (order != nullptr) {
 				/* Don't draw anything if it extends past the end of the window. */
 				if (!this->vscroll->IsVisible(i)) break;
 				if (i != this->selected_order && i == this->order_over) {
 					/* Highlight dragged order destination. */
 					int top = (this->order_over < this->selected_order ? y : y + line_height) - WidgetDimensions::scaled.framerect.top;
 					int bottom = std::min(top + 2, ir.bottom);
 					top = std::max(top - 3, ir.top);
-					GfxFillRect(ir.left, top, ir.right, bottom, GetColourGradient(COLOUR_GREY, SHADE_7));
+					GfxFillRect(ir.left, top, ir.right, bottom, GetColourGradient(COLOUR_GREY, SHADE_LIGHTEST));
 					break;
+				}
 				y += line_height;
 				i++;
 				order = order->next;
+			}
 			/* Reset counters for drawing the orders. */
 			y = ir.top;
 			i = this->vscroll->GetPosition();
 			order = this->vehicle->GetOrder(i);
+		}
 		/* Draw the orders. */
 		while (order != nullptr) {
 			/* Don't draw anything if it extends past the end of the window. */
 			if (!this->vscroll->IsVisible(i)) break;
 			DrawOrderString(this->vehicle, order, i, y, i == this->selected_order, false, ir.left, middle, ir.right);
 			y += line_height;
 			i++;
 			order = order->next;

src/palette_func.h

➞

Show inline comments

@@ @@ -21,55 +21,55 @@ bool CopyPalette(Palette &local_palette, @@
 void GfxInitPalettes();
 uint8_t GetNearestColourIndex(uint8_t r, uint8_t g, uint8_t b);
 inline uint8_t GetNearestColourIndex(const Colour colour)
+{
 	return GetNearestColourIndex(colour.r, colour.g, colour.b);
+}
 /**
  * Checks if a Colours value is valid.
+ *
  * @param colours The value to check
  * @return true if the given value is a valid Colours.
  */
 inline bool IsValidColours(Colours colours)
+{
 	return colours < COLOUR_END;
+}
 TextColour GetContrastColour(uint8_t background, uint8_t threshold = 128);
 enum ColourShade : uint8_t {
 	SHADE_BEGIN = 0,
 	SHADE_1,
 	SHADE_2,
 	SHADE_3,
 	SHADE_4,
 	SHADE_5,
 	SHADE_6,
 	SHADE_7,
 	SHADE_DARKEST,
 	SHADE_DARKER,
 	SHADE_DARK,
 	SHADE_NORMAL,
 	SHADE_LIGHT,
 	SHADE_LIGHTER,
 	SHADE_LIGHTEST,
 	SHADE_END,
 };
 DECLARE_POSTFIX_INCREMENT(ColourShade)
 byte GetColourGradient(Colours colour, ColourShade shade);
 void SetColourGradient(Colours colour, ColourShade shade, byte palette_colour);
 /**
  * Return the colour for a particular greyscale level.
  * @param level Intensity, 0 = black, 15 = white
  * @return colour
  */
 #define GREY_SCALE(level) (level)
 static const uint8_t PC_BLACK              = GREY_SCALE(1);  ///< Black palette colour.
 static const uint8_t PC_DARK_GREY          = GREY_SCALE(6);  ///< Dark grey palette colour.
 static const uint8_t PC_GREY               = GREY_SCALE(10); ///< Grey palette colour.
 static const uint8_t PC_WHITE              = GREY_SCALE(15); ///< White palette colour.
 static const uint8_t PC_VERY_DARK_RED      = 0xB2;           ///< Almost-black red palette colour.
 static const uint8_t PC_DARK_RED           = 0xB4;           ///< Dark red palette colour.
 static const uint8_t PC_RED                = 0xB8;           ///< Red palette colour.
 static const uint8_t PC_VERY_DARK_BROWN    = 0x56;           ///< Almost-black brown palette colour.

src/settings_gui.cpp

➞

Show inline comments

@@ @@ -1393,49 +1393,49 @@ BaseSettingEntry *BaseSettingEntry::Find @@
  * appropriate bit in the \a parent_last parameter.
+ *
  * @param settings_ptr Pointer to current values of all settings
  * @param left         Left-most position in window/panel to start drawing \a first_row
  * @param right        Right-most x position to draw strings at.
  * @param y            Upper-most position in window/panel to start drawing \a first_row
  * @param first_row    First row number to draw
  * @param max_row      Row-number to stop drawing (the row-number of the row below the last row to draw)
  * @param selected     Selected entry by the user.
  * @param cur_row      Current row number (internal variable)
  * @param parent_last  Last-field booleans of parent page level (page level \e i sets bit \e i to 1 if it is its last field)
  * @return Row number of the next row to draw
  */
 uint BaseSettingEntry::Draw(GameSettings *settings_ptr, int left, int right, int y, uint first_row, uint max_row, BaseSettingEntry *selected, uint cur_row, uint parent_last) const
+{
 	if (this->IsFiltered()) return cur_row;
 	if (cur_row >= max_row) return cur_row;
 	bool rtl = _current_text_dir == TD_RTL;
 	int offset = (rtl ? -(int)_circle_size.width : (int)_circle_size.width) / 2;
 	int level_width = rtl ? -WidgetDimensions::scaled.hsep_indent : WidgetDimensions::scaled.hsep_indent;
 	int x = rtl ? right : left;
 	if (cur_row >= first_row) {
-		int colour = GetColourGradient(COLOUR_ORANGE, SHADE_4);
+		int colour = GetColourGradient(COLOUR_ORANGE, SHADE_NORMAL);
 		y += (cur_row - first_row) * SETTING_HEIGHT; // Compute correct y start position
 		/* Draw vertical for parent nesting levels */
 		for (uint lvl = 0; lvl < this->level; lvl++) {
 			if (!HasBit(parent_last, lvl)) GfxDrawLine(x + offset, y, x + offset, y + SETTING_HEIGHT - 1, colour);
 			x += level_width;
+		}
 		/* draw own |- prefix */
 		int halfway_y = y + SETTING_HEIGHT / 2;
 		int bottom_y = (flags & SEF_LAST_FIELD) ? halfway_y : y + SETTING_HEIGHT - 1;
 		GfxDrawLine(x + offset, y, x + offset, bottom_y, colour);
 		/* Small horizontal line from the last vertical line */
 		GfxDrawLine(x + offset, halfway_y, x + level_width - (rtl ? -WidgetDimensions::scaled.hsep_normal : WidgetDimensions::scaled.hsep_normal), halfway_y, colour);
 		x += level_width;
 		this->DrawSetting(settings_ptr, rtl ? left : x, rtl ? x : right, y, this == selected);
+	}
 	cur_row++;
 	return cur_row;
+}
 /* == SettingEntry methods == */
@@ @@ -2888,80 +2888,80 @@ static WindowDesc _settings_selection_de @@
 	WC_GAME_OPTIONS, WC_NONE,
 ,
 	std::begin(_nested_settings_selection_widgets), std::end(_nested_settings_selection_widgets)
 );
 /** Open advanced settings window. */
 void ShowGameSettings()
+{
 	CloseWindowByClass(WC_GAME_OPTIONS);
 	new GameSettingsWindow(&_settings_selection_desc);
+}
 /**
  * Draw [<][>] boxes.
  * @param x the x position to draw
  * @param y the y position to draw
  * @param button_colour the colour of the button
  * @param state 0 = none clicked, 1 = first clicked, 2 = second clicked
  * @param clickable_left is the left button clickable?
  * @param clickable_right is the right button clickable?
  */
 void DrawArrowButtons(int x, int y, Colours button_colour, byte state, bool clickable_left, bool clickable_right)
+{
-	int colour = GetColourGradient(button_colour, SHADE_2);
+	int colour = GetColourGradient(button_colour, SHADE_DARKER);
 	Dimension dim = NWidgetScrollbar::GetHorizontalDimension();
 	Rect lr = {x,                  y, x + (int)dim.width     - 1, y + (int)dim.height - 1};
 	Rect rr = {x + (int)dim.width, y, x + (int)dim.width * 2 - 1, y + (int)dim.height - 1};
 	DrawFrameRect(lr, button_colour, (state == 1) ? FR_LOWERED : FR_NONE);
 	DrawFrameRect(rr, button_colour, (state == 2) ? FR_LOWERED : FR_NONE);
 	DrawSpriteIgnorePadding(SPR_ARROW_LEFT,  PAL_NONE, lr, SA_CENTER);
 	DrawSpriteIgnorePadding(SPR_ARROW_RIGHT, PAL_NONE, rr, SA_CENTER);
 	/* Grey out the buttons that aren't clickable */
 	bool rtl = _current_text_dir == TD_RTL;
 	if (rtl ? !clickable_right : !clickable_left) {
 		GfxFillRect(lr.Shrink(WidgetDimensions::scaled.bevel), colour, FILLRECT_CHECKER);
+	}
 	if (rtl ? !clickable_left : !clickable_right) {
 		GfxFillRect(rr.Shrink(WidgetDimensions::scaled.bevel), colour, FILLRECT_CHECKER);
+	}
+}
 /**
  * Draw a dropdown button.
  * @param x the x position to draw
  * @param y the y position to draw
  * @param button_colour the colour of the button
  * @param state true = lowered
  * @param clickable is the button clickable?
  */
 void DrawDropDownButton(int x, int y, Colours button_colour, bool state, bool clickable)
+{
-	int colour = GetColourGradient(button_colour, SHADE_2);
+	int colour = GetColourGradient(button_colour, SHADE_DARKER);
 	Rect r = {x, y, x + SETTING_BUTTON_WIDTH - 1, y + SETTING_BUTTON_HEIGHT - 1};
 	DrawFrameRect(r, button_colour, state ? FR_LOWERED : FR_NONE);
 	DrawSpriteIgnorePadding(SPR_ARROW_DOWN, PAL_NONE, r, SA_CENTER);
 	if (!clickable) {
 		GfxFillRect(r.Shrink(WidgetDimensions::scaled.bevel), colour, FILLRECT_CHECKER);
+	}
+}
 /**
  * Draw a toggle button.
  * @param x the x position to draw
  * @param y the y position to draw
  * @param state true = lowered
  * @param clickable is the button clickable?
  */
 void DrawBoolButton(int x, int y, bool state, bool clickable)
+{
 	static const Colours _bool_ctabs[2][2] = {{COLOUR_CREAM, COLOUR_RED}, {COLOUR_DARK_GREEN, COLOUR_GREEN}};
 	Rect r = {x, y, x + SETTING_BUTTON_WIDTH - 1, y + SETTING_BUTTON_HEIGHT - 1};
 	DrawFrameRect(r, _bool_ctabs[state][clickable], state ? FR_LOWERED : FR_NONE);

src/smallmap_gui.cpp

➞

Show inline comments

@@ @@ -325,49 +325,49 @@ void BuildLandLegend() @@
 	int rows = CeilDiv(total_entries, 2);
 	int j = 0;
 	for (i = 0; i < lengthof(_legend_land_contours) - 1 && j < total_entries; i++) {
 		if (_legend_land_contours[i].legend != STR_TINY_BLACK_HEIGHT) continue;
 		_legend_land_contours[i].col_break = j % rows == 0;
 		_legend_land_contours[i].end = false;
 		_legend_land_contours[i].height = j * delta;
 		_legend_land_contours[i].colour = _heightmap_schemes[_settings_client.gui.smallmap_land_colour].height_colours[j * delta];
 		j++;
+	}
 	_legend_land_contours[i].end = true;
+}
 /**
  * Completes the array for the owned property legend.
  */
 void BuildOwnerLegend()
+{
 	_legend_land_owners[1].colour = _heightmap_schemes[_settings_client.gui.smallmap_land_colour].default_colour;
 	int i = NUM_NO_COMPANY_ENTRIES;
 	for (const Company *c : Company::Iterate()) {
-		_legend_land_owners[i].colour = GetColourGradient(c->colour, SHADE_5);
+		_legend_land_owners[i].colour = GetColourGradient(c->colour, SHADE_LIGHT);
 		_legend_land_owners[i].company = c->index;
 		_legend_land_owners[i].show_on_map = true;
 		_legend_land_owners[i].col_break = false;
 		_legend_land_owners[i].end = false;
 		_company_to_list_pos[c->index] = i;
 		i++;
+	}
 	/* Terminate the list */
 	_legend_land_owners[i].end = true;
 	/* Store maximum amount of owner legend entries. */
 	_smallmap_company_count = i;
+}
 struct AndOr {
 	uint32_t mor;
 	uint32_t mand;
 };
 static inline uint32_t ApplyMask(uint32_t colour, const AndOr *mask)
+{
 	return (colour & mask->mand) | mask->mor;
+}

src/train_gui.cpp

➞

Show inline comments

@@ @@ -55,49 +55,49 @@ void CcBuildWagon(Commands, const Comman @@
  * @param y         The vertical centre position to draw from.
  * @param selection Selected vehicle that is dragged.
  * @param chain     Whether a whole chain is dragged.
  * @return The width of the highlight mark.
  */
 static int HighlightDragPosition(int px, int max_width, int y, VehicleID selection, bool chain)
+{
 	bool rtl = _current_text_dir == TD_RTL;
 	assert(selection != INVALID_VEHICLE);
 	int dragged_width = 0;
 	for (Train *t = Train::Get(selection); t != nullptr; t = chain ? t->Next() : (t->HasArticulatedPart() ? t->GetNextArticulatedPart() : nullptr)) {
 		dragged_width += t->GetDisplayImageWidth(nullptr);
+	}
 	int drag_hlight_left = rtl ? std::max(px - dragged_width + 1, 0) : px;
 	int drag_hlight_right = rtl ? px : std::min(px + dragged_width, max_width) - 1;
 	int drag_hlight_width = std::max(drag_hlight_right - drag_hlight_left + 1, 0);
 	if (drag_hlight_width > 0) {
 		int height = ScaleSpriteTrad(12);
 		int top = y - height / 2;
 		Rect r = {drag_hlight_left, top, drag_hlight_right, top + height - 1};
 		/* Sprite-scaling is used here as the area is from sprite size */
-		GfxFillRect(r.Shrink(ScaleSpriteTrad(1)), GetColourGradient(COLOUR_GREY, SHADE_7));
+		GfxFillRect(r.Shrink(ScaleSpriteTrad(1)), GetColourGradient(COLOUR_GREY, SHADE_LIGHTEST));
+	}
 	return drag_hlight_width;
+}
 /**
  * Draws an image of a whole train
  * @param v         Front vehicle
  * @param r         Rect to draw at
  * @param selection Selected vehicle to draw a frame around
  * @param skip      Number of pixels to skip at the front (for scrolling)
  * @param drag_dest The vehicle another one is dragged over, \c INVALID_VEHICLE if none.
  */
 void DrawTrainImage(const Train *v, const Rect &r, VehicleID selection, EngineImageType image_type, int skip, VehicleID drag_dest)
+{
 	bool rtl = _current_text_dir == TD_RTL;
 	Direction dir = rtl ? DIR_E : DIR_W;
 	DrawPixelInfo tmp_dpi;
 	/* Position of highlight box */
 	int highlight_l = 0;
 	int highlight_r = 0;
 	int max_width = r.Width();
@@ @@ -378,49 +378,49 @@ void DrawTrainDetails(const Train *v, co @@
+					}
 					PaletteID pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(u);
 					VehicleSpriteSeq seq;
 					u->GetImage(dir, EIT_IN_DETAILS, &seq);
 					seq.Draw(px + (rtl ? -offset.x : offset.x), r.top - line_height * vscroll_pos + sprite_y_offset + pitch, pal, (v->vehstatus & VS_CRASHED) != 0);
+				}
 				px += rtl ? -width : width;
 				dx += width;
 				u = u->Next();
 			} while (u != nullptr && u->IsArticulatedPart());
 			bool separate_sprite_row = (dx > (uint)ScaleSpriteTrad(TRAIN_DETAILS_MAX_INDENT));
 			if (separate_sprite_row) {
 				vscroll_pos--;
 				dx = 0;
+			}
 			int sprite_width = std::max<int>(dx, ScaleSpriteTrad(TRAIN_DETAILS_MIN_INDENT)) + WidgetDimensions::scaled.hsep_normal;
 			Rect dr = r.Indent(sprite_width, rtl);
 			uint num_lines = std::max(1u, (unsigned)_cargo_summary.size());
 			for (uint i = 0; i < num_lines; i++) {
 				if (vscroll_pos <= 0 && vscroll_pos > -vscroll_cap) {
 					int py = r.top - line_height * vscroll_pos + text_y_offset;
 					if (i > 0 || separate_sprite_row) {
-						if (vscroll_pos != 0) GfxFillRect(r.left, py - WidgetDimensions::scaled.matrix.top - 1, r.right, py - WidgetDimensions::scaled.matrix.top, GetColourGradient(COLOUR_GREY, SHADE_5));
+						if (vscroll_pos != 0) GfxFillRect(r.left, py - WidgetDimensions::scaled.matrix.top - 1, r.right, py - WidgetDimensions::scaled.matrix.top, GetColourGradient(COLOUR_GREY, SHADE_LIGHT));
+					}
 					switch (det_tab) {
 						case TDW_TAB_CARGO:
 							if (i < _cargo_summary.size()) {
 								TrainDetailsCargoTab(&_cargo_summary[i], dr.left, dr.right, py);
 							} else {
 								DrawString(dr.left, dr.right, py, STR_QUANTITY_N_A, TC_LIGHT_BLUE);
+							}
 							break;
 						case TDW_TAB_INFO:
 							if (i == 0) TrainDetailsInfoTab(v, dr.left, dr.right, py);
 							break;
 						case TDW_TAB_CAPACITY:
 							if (i < _cargo_summary.size()) {
 								TrainDetailsCapacityTab(&_cargo_summary[i], dr.left, dr.right, py);
 							} else {
 								SetDParam(0, STR_EMPTY);
 								DrawString(dr.left, dr.right, py, STR_VEHICLE_INFO_NO_CAPACITY);
+							}
 							break;
 						default: NOT_REACHED();

src/vehicle_gui.cpp

➞

Show inline comments

@@ @@ -603,49 +603,49 @@ struct RefitOption { @@
+	{
 		return other.cargo == this->cargo && other.string == this->string;
+	}
 };
 using RefitOptions = std::map<CargoID, std::vector<RefitOption>, CargoIDComparator>; ///< Available refit options (subtype and string) associated with each cargo type.
 /**
  * Draw the list of available refit options for a consist and highlight the selected refit option (if any).
  * @param refits Available refit options for each (sorted) cargo.
  * @param sel   Selected refit option in the window
  * @param pos   Position of the selected item in caller widow
  * @param rows  Number of rows(capacity) in caller window
  * @param delta Step height in caller window
  * @param r     Rectangle of the matrix widget.
  */
 static void DrawVehicleRefitWindow(const RefitOptions &refits, const RefitOption *sel, uint pos, uint rows, uint delta, const Rect &r)
+{
 	Rect ir = r.Shrink(WidgetDimensions::scaled.matrix);
 	uint current = 0;
 	bool rtl = _current_text_dir == TD_RTL;
 	uint iconwidth = std::max(GetSpriteSize(SPR_CIRCLE_FOLDED).width, GetSpriteSize(SPR_CIRCLE_UNFOLDED).width);
 	uint iconheight = GetSpriteSize(SPR_CIRCLE_FOLDED).height;
-	int linecolour = GetColourGradient(COLOUR_ORANGE, SHADE_4);
+	int linecolour = GetColourGradient(COLOUR_ORANGE, SHADE_NORMAL);
 	int iconleft   = rtl ? ir.right - iconwidth     : ir.left;
 	int iconcenter = rtl ? ir.right - iconwidth / 2 : ir.left + iconwidth / 2;
 	int iconinner  = rtl ? ir.right - iconwidth     : ir.left + iconwidth;
 	Rect tr = ir.Indent(iconwidth + WidgetDimensions::scaled.hsep_wide, rtl);
 	/* Draw the list of subtypes for each cargo, and find the selected refit option (by its position). */
 	for (const auto &pair : refits) {
 		bool has_subtypes = pair.second.size() > 1;
 		for (const RefitOption &refit : pair.second) {
 			if (current >= pos + rows) break;
 			/* Hide subtypes if selected cargo type does not match */
 			if ((sel == nullptr || sel->cargo != refit.cargo) && refit.subtype != UINT8_MAX) continue;
 			/* Refit options with a position smaller than pos don't have to be drawn. */
 			if (current < pos) {
 				current++;
 				continue;
+			}
 			if (has_subtypes) {
 				if (refit.subtype != UINT8_MAX) {

src/viewport.cpp

➞

Show inline comments

@@ @@ -1695,49 +1695,49 @@ static void ViewportDrawDirtyBlocks() @@
 	dst = dpi->dst_ptr;
 	byte bo = UnScaleByZoom(dpi->left + dpi->top, dpi->zoom) & 1;
 	do {
 		for (int i = (bo ^= 1); i < right; i += 2) blitter->SetPixel(dst, i, 0, (uint8_t)colour);
 		dst = blitter->MoveTo(dst, 0, 1);
 	} while (--bottom > 0);
+}
 static void ViewportDrawStrings(ZoomLevel zoom, const StringSpriteToDrawVector *sstdv)
+{
 	for (const StringSpriteToDraw &ss : *sstdv) {
 		TextColour colour = TC_BLACK;
 		bool small = HasBit(ss.width, 15);
 		int w = GB(ss.width, 0, 15);
 		int x = UnScaleByZoom(ss.x, zoom);
 		int y = UnScaleByZoom(ss.y, zoom);
 		int h = WidgetDimensions::scaled.fullbevel.top + (small ? GetCharacterHeight(FS_SMALL) : GetCharacterHeight(FS_NORMAL)) + WidgetDimensions::scaled.fullbevel.bottom;
 		if (ss.colour != INVALID_COLOUR) {
 			if (IsTransparencySet(TO_SIGNS) && ss.string_id != STR_WHITE_SIGN) {
 				/* Don't draw the rectangle.
 				 * Real colours need the TC_IS_PALETTE_COLOUR flag.
 				 * Otherwise colours from _string_colourmap are assumed. */
-				colour = (TextColour)GetColourGradient(ss.colour, SHADE_6) | TC_IS_PALETTE_COLOUR;
+				colour = (TextColour)GetColourGradient(ss.colour, SHADE_LIGHTER) | TC_IS_PALETTE_COLOUR;
 			} else {
 				/* Draw the rectangle if 'transparent station signs' is off,
 				 * or if we are drawing a general text sign (STR_WHITE_SIGN). */
 				DrawFrameRect(
 					x, y, x + w - 1, y + h - 1, ss.colour,
 					IsTransparencySet(TO_SIGNS) ? FR_TRANSPARENT : FR_NONE
 				);
+			}
+		}
 		DrawString(x + WidgetDimensions::scaled.fullbevel.left, x + w - 1 - WidgetDimensions::scaled.fullbevel.right, y + WidgetDimensions::scaled.fullbevel.top, ss.string, colour, SA_HOR_CENTER, false, small ? FS_SMALL : FS_NORMAL);
+	}
+}
 void ViewportDoDraw(const Viewport *vp, int left, int top, int right, int bottom)
+{
 	_vd.dpi.zoom = vp->zoom;
 	int mask = ScaleByZoom(-1, vp->zoom);
 	_vd.combine_sprites = SPRITE_COMBINE_NONE;
 	_vd.dpi.width = (right - left) & mask;
 	_vd.dpi.height = (bottom - top) & mask;
 	_vd.dpi.left = left & mask;

src/widget.cpp

➞

Show inline comments

@@ @@ -261,52 +261,52 @@ void ScrollbarClickHandler(Window *w, NW @@
  * @param *w Window to look inside
  * @param  x The Window client X coordinate
  * @param  y The Window client y coordinate
  * @return A widget index, or -1 if no widget was found.
  */
 WidgetID GetWidgetFromPos(const Window *w, int x, int y)
+{
 	NWidgetCore *nw = w->nested_root->GetWidgetFromPos(x, y);
 	return (nw != nullptr) ? nw->index : -1;
+}
 /**
  * Draw frame rectangle.
  * @param left   Left edge of the frame
  * @param top    Top edge of the frame
  * @param right  Right edge of the frame
  * @param bottom Bottom edge of the frame
  * @param colour Colour table to use. @see Colours
  * @param flags  Flags controlling how to draw the frame. @see FrameFlags
  */
 void DrawFrameRect(int left, int top, int right, int bottom, Colours colour, FrameFlags flags)
+{
 	assert(colour < COLOUR_END);
 	uint dark         = GetColourGradient(colour, SHADE_3);
 	uint medium_dark  = GetColourGradient(colour, SHADE_5);
 	uint medium_light = GetColourGradient(colour, SHADE_6);
 	uint light        = GetColourGradient(colour, SHADE_7);
 	uint dark         = GetColourGradient(colour, SHADE_DARK);
 	uint medium_dark  = GetColourGradient(colour, SHADE_LIGHT);
 	uint medium_light = GetColourGradient(colour, SHADE_LIGHTER);
 	uint light        = GetColourGradient(colour, SHADE_LIGHTEST);
 	if (flags & FR_TRANSPARENT) {
 		GfxFillRect(left, top, right, bottom, PALETTE_TO_TRANSPARENT, FILLRECT_RECOLOUR);
 	} else {
 		uint interior;
 		Rect outer = {left, top, right, bottom};                   // Outside rectangle
 		Rect inner = outer.Shrink(WidgetDimensions::scaled.bevel); // Inside rectangle
 		if (flags & FR_LOWERED) {
 			GfxFillRect(outer.left,      outer.top,        inner.left - 1,  outer.bottom, dark);   // Left
 			GfxFillRect(inner.left,      outer.top,        outer.right,     inner.top - 1, dark);  // Top
 			GfxFillRect(inner.right + 1, inner.top,        outer.right,     inner.bottom,  light); // Right
 			GfxFillRect(inner.left,      inner.bottom + 1, outer.right,     outer.bottom, light);  // Bottom
 			interior = (flags & FR_DARKENED ? medium_dark : medium_light);
 		} else {
 			GfxFillRect(outer.left,      outer.top,        inner.left - 1, inner.bottom,  light); // Left
 			GfxFillRect(inner.left,      outer.top,        inner.right,    inner.top - 1, light); // Top
 			GfxFillRect(inner.right + 1, outer.top,        outer.right,    inner.bottom,  dark);  // Right
 			GfxFillRect(outer.left,      inner.bottom + 1, outer.right,    outer.bottom, dark);   // Bottom
 			interior = medium_dark;
+		}
 		if (!(flags & FR_BORDERONLY)) {
 			GfxFillRect(inner.left,  inner.top, inner.right, inner.bottom, interior); // Inner
@@ @@ -402,174 +402,174 @@ static inline void DrawInset(const Rect @@
  * @param resize_y Matrix resize unit size.
  */
 static inline void DrawMatrix(const Rect &r, Colours colour, bool clicked, uint16_t data, uint resize_x, uint resize_y)
+{
 	DrawFrameRect(r.left, r.top, r.right, r.bottom, colour, (clicked) ? FR_LOWERED : FR_NONE);
 	int num_columns = GB(data, MAT_COL_START, MAT_COL_BITS);  // Lower 8 bits of the widget data: Number of columns in the matrix.
 	int column_width; // Width of a single column in the matrix.
 	if (num_columns == 0) {
 		column_width = resize_x;
 		num_columns = r.Width() / column_width;
 	} else {
 		column_width = r.Width() / num_columns;
+	}
 	int num_rows = GB(data, MAT_ROW_START, MAT_ROW_BITS); // Upper 8 bits of the widget data: Number of rows in the matrix.
 	int row_height; // Height of a single row in the matrix.
 	if (num_rows == 0) {
 		row_height = resize_y;
 		num_rows = r.Height() / row_height;
 	} else {
 		row_height = r.Height() / num_rows;
+	}
-	int col = GetColourGradient(colour, SHADE_6);
+	int col = GetColourGradient(colour, SHADE_LIGHTER);
 	int x = r.left;
 	for (int ctr = num_columns; ctr > 1; ctr--) {
 		x += column_width;
 		GfxFillRect(x, r.top + WidgetDimensions::scaled.bevel.top, x + WidgetDimensions::scaled.bevel.left - 1, r.bottom - WidgetDimensions::scaled.bevel.bottom, col);
+	}
 	x = r.top;
 	for (int ctr = num_rows; ctr > 1; ctr--) {
 		x += row_height;
 		GfxFillRect(r.left + WidgetDimensions::scaled.bevel.left, x, r.right - WidgetDimensions::scaled.bevel.right, x + WidgetDimensions::scaled.bevel.top - 1, col);
+	}
-	col = GetColourGradient(colour, SHADE_4);
+	col = GetColourGradient(colour, SHADE_NORMAL);
 	x = r.left - 1;
 	for (int ctr = num_columns; ctr > 1; ctr--) {
 		x += column_width;
 		GfxFillRect(x - WidgetDimensions::scaled.bevel.right + 1, r.top + WidgetDimensions::scaled.bevel.top, x, r.bottom - WidgetDimensions::scaled.bevel.bottom, col);
+	}
 	x = r.top - 1;
 	for (int ctr = num_rows; ctr > 1; ctr--) {
 		x += row_height;
 		GfxFillRect(r.left + WidgetDimensions::scaled.bevel.left, x - WidgetDimensions::scaled.bevel.bottom + 1, r.right - WidgetDimensions::scaled.bevel.right, x, col);
+	}
+}
 /**
  * Draw a vertical scrollbar.
  * @param r            Rectangle of the scrollbar widget.
  * @param colour       Colour of the scrollbar widget.
  * @param up_clicked   Up-arrow is clicked.
  * @param bar_dragged  Bar is dragged.
  * @param down_clicked Down-arrow is clicked.
  * @param scrollbar    Scrollbar size, offset, and capacity information.
  */
 static inline void DrawVerticalScrollbar(const Rect &r, Colours colour, bool up_clicked, bool bar_dragged, bool down_clicked, const Scrollbar *scrollbar)
+{
 	int height = NWidgetScrollbar::GetVerticalDimension().height;
 	/* draw up/down buttons */
 	DrawImageButtons(r.WithHeight(height, false),  NWID_VSCROLLBAR, colour, up_clicked,   SPR_ARROW_UP,   SA_CENTER);
 	DrawImageButtons(r.WithHeight(height, true),   NWID_VSCROLLBAR, colour, down_clicked, SPR_ARROW_DOWN, SA_CENTER);
 	int c1 = GetColourGradient(colour, SHADE_3);
 	int c2 = GetColourGradient(colour, SHADE_7);
 	int c1 = GetColourGradient(colour, SHADE_DARK);
 	int c2 = GetColourGradient(colour, SHADE_LIGHTEST);
 	/* draw "shaded" background */
 	GfxFillRect(r.left, r.top + height, r.right, r.bottom - height, c2);
 	GfxFillRect(r.left, r.top + height, r.right, r.bottom - height, c1, FILLRECT_CHECKER);
 	/* track positions. These fractions are based on original 1x dimensions, but scale better. */
 	int left  = r.left + r.Width() * 3 / 11; /*  left track is positioned 3/11ths from the left */
 	int right = r.left + r.Width() * 8 / 11; /* right track is positioned 8/11ths from the left */
 	const uint8_t bl = WidgetDimensions::scaled.bevel.left;
 	const uint8_t br = WidgetDimensions::scaled.bevel.right;
 	/* draw shaded lines */
 	GfxFillRect(left - bl,  r.top + height, left       - 1, r.bottom - height, c1);
 	GfxFillRect(left,       r.top + height, left + br  - 1, r.bottom - height, c2);
 	GfxFillRect(right - bl, r.top + height, right      - 1, r.bottom - height, c1);
 	GfxFillRect(right,      r.top + height, right + br - 1, r.bottom - height, c2);
 	Point pt = HandleScrollbarHittest(scrollbar, r.top, r.bottom, false);
 	DrawFrameRect(r.left, pt.x, r.right, pt.y, colour, bar_dragged ? FR_LOWERED : FR_NONE);
+}
 /**
  * Draw a horizontal scrollbar.
  * @param r             Rectangle of the scrollbar widget.
  * @param colour        Colour of the scrollbar widget.
  * @param left_clicked  Left-arrow is clicked.
  * @param bar_dragged   Bar is dragged.
  * @param right_clicked Right-arrow is clicked.
  * @param scrollbar     Scrollbar size, offset, and capacity information.
  */
 static inline void DrawHorizontalScrollbar(const Rect &r, Colours colour, bool left_clicked, bool bar_dragged, bool right_clicked, const Scrollbar *scrollbar)
+{
 	int width = NWidgetScrollbar::GetHorizontalDimension().width;
 	DrawImageButtons(r.WithWidth(width, false), NWID_HSCROLLBAR, colour, left_clicked,  SPR_ARROW_LEFT,  SA_CENTER);
 	DrawImageButtons(r.WithWidth(width, true),  NWID_HSCROLLBAR, colour, right_clicked, SPR_ARROW_RIGHT, SA_CENTER);
 	int c1 = GetColourGradient(colour, SHADE_3);
 	int c2 = GetColourGradient(colour, SHADE_7);
 	int c1 = GetColourGradient(colour, SHADE_DARK);
 	int c2 = GetColourGradient(colour, SHADE_LIGHTEST);
 	/* draw "shaded" background */
 	GfxFillRect(r.left + width, r.top, r.right - width, r.bottom, c2);
 	GfxFillRect(r.left + width, r.top, r.right - width, r.bottom, c1, FILLRECT_CHECKER);
 	/* track positions. These fractions are based on original 1x dimensions, but scale better. */
 	int top    = r.top + r.Height() * 3 / 11; /*    top track is positioned 3/11ths from the top */
 	int bottom = r.top + r.Height() * 8 / 11; /* bottom track is positioned 8/11ths from the top */
 	const uint8_t bt = WidgetDimensions::scaled.bevel.top;
 	const uint8_t bb = WidgetDimensions::scaled.bevel.bottom;
 	/* draw shaded lines */
 	GfxFillRect(r.left + width, top - bt,    r.right - width, top         - 1, c1);
 	GfxFillRect(r.left + width, top,         r.right - width, top + bb    - 1, c2);
 	GfxFillRect(r.left + width, bottom - bt, r.right - width, bottom      - 1, c1);
 	GfxFillRect(r.left + width, bottom,      r.right - width, bottom + bb - 1, c2);
 	/* draw actual scrollbar */
 	Point pt = HandleScrollbarHittest(scrollbar, r.left, r.right, true);
 	DrawFrameRect(pt.x, r.top, pt.y, r.bottom, colour, bar_dragged ? FR_LOWERED : FR_NONE);
+}
 /**
  * Draw a frame widget.
  * @param r           Rectangle of the frame.
  * @param colour      Colour of the frame.
  * @param text_colour Colour of the text.
  * @param str         Text of the frame.
  * @param align       Alignment of the text in the frame.
  * @param fs          Font size of the text.
  */
 static inline void DrawFrame(const Rect &r, Colours colour, TextColour text_colour, StringID str, StringAlignment align, FontSize fs)
+{
 	int x2 = r.left; // by default the left side is the left side of the widget
 	if (str != STR_NULL) x2 = DrawString(r.left + WidgetDimensions::scaled.frametext.left, r.right - WidgetDimensions::scaled.frametext.right, r.top, str, text_colour, align, false, fs);
 	int c1 = GetColourGradient(colour, SHADE_3);
 	int c2 = GetColourGradient(colour, SHADE_7);
 	int c1 = GetColourGradient(colour, SHADE_DARK);
 	int c2 = GetColourGradient(colour, SHADE_LIGHTEST);
 	/* If the frame has text, adjust the top bar to fit half-way through */
 	Rect inner = r.Shrink(ScaleGUITrad(1));
 	if (str != STR_NULL) inner.top = r.top + GetCharacterHeight(FS_NORMAL) / 2;
 	Rect outer  = inner.Expand(WidgetDimensions::scaled.bevel);
 	Rect inside = inner.Shrink(WidgetDimensions::scaled.bevel);
 	if (_current_text_dir == TD_LTR) {
 		/* Line from upper left corner to start of text */
 		GfxFillRect(outer.left, outer.top, r.left + WidgetDimensions::scaled.frametext.left - WidgetDimensions::scaled.bevel.left - 1, inner.top  - 1, c1);
 		GfxFillRect(inner.left, inner.top, r.left + WidgetDimensions::scaled.frametext.left - WidgetDimensions::scaled.bevel.left - 1, inside.top - 1, c2);
 		/* Line from end of text to upper right corner */
 		GfxFillRect(x2 + WidgetDimensions::scaled.bevel.right, outer.top, inner.right,  inner.top  - 1, c1);
 		GfxFillRect(x2 + WidgetDimensions::scaled.bevel.right, inner.top, inside.right, inside.top - 1, c2);
 	} else {
 		/* Line from upper left corner to start of text */
 		GfxFillRect(outer.left, outer.top, x2 - WidgetDimensions::scaled.bevel.left - 1, inner.top  - 1, c1);
 		GfxFillRect(inner.left, inner.top, x2 - WidgetDimensions::scaled.bevel.left - 1, inside.top - 1, c2);
 		/* Line from end of text to upper right corner */
 		GfxFillRect(r.right - WidgetDimensions::scaled.frametext.right + WidgetDimensions::scaled.bevel.right, outer.top, inner.right,  inner.top  - 1, c1);
 		GfxFillRect(r.right - WidgetDimensions::scaled.frametext.right + WidgetDimensions::scaled.bevel.right, inner.top, inside.right, inside.top - 1, c2);
@@ @@ -624,89 +624,89 @@ static inline void DrawDefSizeBox(const @@
 /**
  * Draw a NewGRF debug box.
  * @param r       Rectangle of the box.
  * @param colour  Colour of the debug box.
  * @param clicked Box is lowered.
  */
 static inline void DrawDebugBox(const Rect &r, Colours colour, bool clicked)
+{
 	DrawImageButtons(r, WWT_DEBUGBOX, colour, clicked, SPR_WINDOW_DEBUG, SA_CENTER);
+}
 /**
  * Draw a resize box.
  * @param r       Rectangle of the box.
  * @param colour  Colour of the resize box.
  * @param at_left Resize box is at left-side of the window,
  * @param clicked Box is lowered.
  * @param bevel   Draw bevel iff set.
  */
 static inline void DrawResizeBox(const Rect &r, Colours colour, bool at_left, bool clicked, bool bevel)
+{
 	if (bevel) {
 		DrawFrameRect(r.left, r.top, r.right, r.bottom, colour, (clicked) ? FR_LOWERED : FR_NONE);
 	} else if (clicked) {
-		GfxFillRect(r.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(colour, SHADE_6));
+		GfxFillRect(r.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(colour, SHADE_LIGHTER));
+	}
 	DrawSpriteIgnorePadding(at_left ? SPR_WINDOW_RESIZE_LEFT : SPR_WINDOW_RESIZE_RIGHT, PAL_NONE, r.Shrink(ScaleGUITrad(2)), at_left ? (SA_LEFT | SA_BOTTOM | SA_FORCE) : (SA_RIGHT | SA_BOTTOM | SA_FORCE));
+}
 /**
  * Draw a close box.
  * @param r      Rectangle of the box.`
  * @param colour Colour of the close box.
  */
 static inline void DrawCloseBox(const Rect &r, Colours colour)
+{
 	if (colour != COLOUR_WHITE) DrawFrameRect(r.left, r.top, r.right, r.bottom, colour, FR_NONE);
 	Point offset;
 	Dimension d = GetSpriteSize(SPR_CLOSEBOX, &offset);
 	d.width  -= offset.x;
 	d.height -= offset.y;
 	int s = ScaleSpriteTrad(1); /* Offset to account for shadow of SPR_CLOSEBOX */
 	DrawSprite(SPR_CLOSEBOX, (colour != COLOUR_WHITE ? TC_BLACK : TC_SILVER) | (1U << PALETTE_TEXT_RECOLOUR), CenterBounds(r.left, r.right, d.width - s) - offset.x, CenterBounds(r.top, r.bottom, d.height - s) - offset.y);
+}
 /**
  * Draw a caption bar.
  * @param r           Rectangle of the bar.
  * @param colour      Colour of the window.
  * @param owner       'Owner' of the window.
  * @param text_colour Colour of the text.
  * @param str         Text to draw in the bar.
  * @param align       Alignment of the text.
  * @param fs          Font size of the text.
  */
 void DrawCaption(const Rect &r, Colours colour, Owner owner, TextColour text_colour, StringID str, StringAlignment align, FontSize fs)
+{
 	bool company_owned = owner < MAX_COMPANIES;
 	DrawFrameRect(r, colour, FR_BORDERONLY);
 	Rect ir = r.Shrink(WidgetDimensions::scaled.bevel);
 	DrawFrameRect(ir, colour, company_owned ? FR_LOWERED | FR_DARKENED | FR_BORDERONLY : FR_LOWERED | FR_DARKENED);
 	if (company_owned) {
-		GfxFillRect(ir.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(_company_colours[owner], SHADE_4));
+		GfxFillRect(ir.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(_company_colours[owner], SHADE_NORMAL));
+	}
 	if (str != STR_NULL) {
 		Dimension d = GetStringBoundingBox(str);
 		Point p = GetAlignedPosition(r, d, align);
 		DrawString(r.left + WidgetDimensions::scaled.captiontext.left, r.right - WidgetDimensions::scaled.captiontext.left, p.y, str, text_colour, align, false, fs);
+	}
+}
 /**
  * Draw a button with a dropdown (#WWT_DROPDOWN and #NWID_BUTTON_DROPDOWN).
  * @param r                Rectangle containing the widget.
  * @param colour           Background colour of the widget.
  * @param clicked_button   The button-part is clicked.
  * @param clicked_dropdown The drop-down part is clicked.
  * @param str              Text of the button.
  * @param align            Alignment of the text within the dropdown.
+ *
  * @note Magic constants are also used in #NWidgetLeaf::ButtonHit.
  */
 static inline void DrawButtonDropdown(const Rect &r, Colours colour, bool clicked_button, bool clicked_dropdown, StringID str, StringAlignment align)
+{
 	int dd_width  = NWidgetLeaf::dropdown_dimension.width;
@@ @@ -1885,49 +1885,49 @@ NWidgetCore *NWidgetMatrix::GetWidgetFro @@
 	int widget_col = (rtl ?
 				-x + (int)this->pip_post + this->pos_x + base_offs_x + this->widget_w - 1 - (int)this->pip_inter :
 				 x - (int)this->pip_pre  - this->pos_x - base_offs_x
 			) / this->widget_w;
 	int widget_row = (y - base_offs_y - (int)this->pip_pre - this->pos_y) / this->widget_h;
 	this->current_element = (widget_row + start_y) * this->widgets_x + start_x + widget_col;
 	if (this->current_element >= this->count) return nullptr;
 	NWidgetCore *child = dynamic_cast<NWidgetCore *>(this->children.front().get());
 	assert(child != nullptr);
 	child->AssignSizePosition(ST_RESIZE,
 			this->pos_x + (rtl ? this->pip_post - widget_col * this->widget_w : this->pip_pre + widget_col * this->widget_w) + base_offs_x,
 			this->pos_y + this->pip_pre + widget_row * this->widget_h + base_offs_y,
 			child->smallest_x, child->smallest_y, rtl);
 	return child->GetWidgetFromPos(x, y);
+}
 /* virtual */ void NWidgetMatrix::Draw(const Window *w)
+{
 	/* Fill the background. */
-	GfxFillRect(this->GetCurrentRect(), GetColourGradient(this->colour, SHADE_5));
+	GfxFillRect(this->GetCurrentRect(), GetColourGradient(this->colour, SHADE_LIGHT));
 	/* Set up a clipping area for the previews. */
 	bool rtl = _current_text_dir == TD_RTL;
 	DrawPixelInfo tmp_dpi;
 	if (!FillDrawPixelInfo(&tmp_dpi, this->pos_x + (rtl ? this->pip_post : this->pip_pre), this->pos_y + this->pip_pre, this->current_x - this->pip_pre - this->pip_post, this->current_y - this->pip_pre - this->pip_post)) return;
+	{
 		AutoRestoreBackup dpi_backup(_cur_dpi, &tmp_dpi);
 		/* Get the appropriate offsets so we can draw the right widgets. */
 		NWidgetCore *child = dynamic_cast<NWidgetCore *>(this->children.front().get());
 		assert(child != nullptr);
 		int start_x, start_y, base_offs_x, base_offs_y;
 		this->GetScrollOffsets(start_x, start_y, base_offs_x, base_offs_y);
 		int offs_y = base_offs_y;
 		for (int y = start_y; y < start_y + this->widgets_y + 1; y++, offs_y += this->widget_h) {
 			/* Are we within bounds? */
 			if (offs_y + child->smallest_y <= 0) continue;
 			if (offs_y >= (int)this->current_y) break;
 			/* We've passed our amount of widgets. */
 			if (y * this->widgets_x >= this->count) break;
@@ @@ -2150,49 +2150,49 @@ void NWidgetBackground::Draw(const Windo @@
 	switch (this->type) {
 		case WWT_PANEL:
 			assert(this->widget_data == 0);
 			DrawFrameRect(r.left, r.top, r.right, r.bottom, this->colour, this->IsLowered() ? FR_LOWERED : FR_NONE);
 			break;
 		case WWT_FRAME:
 			if (this->index >= 0) w->SetStringParameters(this->index);
 			DrawFrame(r, this->colour, this->text_colour, this->widget_data, this->align, this->text_size);
 			break;
 		case WWT_INSET:
 			if (this->index >= 0) w->SetStringParameters(this->index);
 			DrawInset(r, this->colour, this->text_colour, this->widget_data, this->align, this->text_size);
 			break;
 		default:
 			NOT_REACHED();
+	}
 	if (this->index >= 0) w->DrawWidget(r, this->index);
 	if (this->child != nullptr) this->child->Draw(w);
 	if (this->IsDisabled()) {
-		GfxFillRect(r.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(this->colour, SHADE_2), FILLRECT_CHECKER);
+		GfxFillRect(r.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(this->colour, SHADE_DARKER), FILLRECT_CHECKER);
+	}
 	DrawOutline(w, this);
+}
 NWidgetCore *NWidgetBackground::GetWidgetFromPos(int x, int y)
+{
 	NWidgetCore *nwid = nullptr;
 	if (IsInsideBS(x, this->pos_x, this->current_x) && IsInsideBS(y, this->pos_y, this->current_y)) {
 		if (this->child != nullptr) nwid = this->child->GetWidgetFromPos(x, y);
 		if (nwid == nullptr) nwid = this;
+	}
 	return nwid;
+}
 NWidgetBase *NWidgetBackground::GetWidgetOfType(WidgetType tp)
+{
 	NWidgetBase *nwid = nullptr;
 	if (this->child != nullptr) nwid = this->child->GetWidgetOfType(tp);
 	if (nwid == nullptr && this->type == tp) nwid = this;
 	return nwid;
+}
 NWidgetViewport::NWidgetViewport(WidgetID index) : NWidgetCore(NWID_VIEWPORT, INVALID_COLOUR, index, 1, 1, 0x0, STR_NULL)
@@ @@ -2395,49 +2395,49 @@ void NWidgetScrollbar::SetupSmallestSize @@
 	this->smallest_x = this->min_x;
 	this->smallest_y = this->min_y;
+}
 void NWidgetScrollbar::Draw(const Window *w)
+{
 	if (this->current_x == 0 || this->current_y == 0) return;
 	Rect r = this->GetCurrentRect();
 	const DrawPixelInfo *dpi = _cur_dpi;
 	if (dpi->left > r.right || dpi->left + dpi->width <= r.left || dpi->top > r.bottom || dpi->top + dpi->height <= r.top) return;
 	bool up_lowered = HasBit(this->disp_flags, NDB_SCROLLBAR_UP);
 	bool down_lowered = HasBit(this->disp_flags, NDB_SCROLLBAR_DOWN);
 	bool middle_lowered = !(this->disp_flags & ND_SCROLLBAR_BTN) && w->mouse_capture_widget == this->index;
 	if (this->type == NWID_HSCROLLBAR) {
 		DrawHorizontalScrollbar(r, this->colour, up_lowered, middle_lowered, down_lowered, this);
 	} else {
 		DrawVerticalScrollbar(r, this->colour, up_lowered, middle_lowered, down_lowered, this);
+	}
 	if (this->IsDisabled()) {
-		GfxFillRect(r.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(this->colour, SHADE_2), FILLRECT_CHECKER);
+		GfxFillRect(r.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(this->colour, SHADE_DARKER), FILLRECT_CHECKER);
+	}
 	DrawOutline(w, this);
+}
 /* static */ void NWidgetScrollbar::InvalidateDimensionCache()
+{
 	vertical_dimension.width   = vertical_dimension.height   = 0;
 	horizontal_dimension.width = horizontal_dimension.height = 0;
+}
 /* static */ Dimension NWidgetScrollbar::GetVerticalDimension()
+{
 	if (vertical_dimension.width == 0) {
 		vertical_dimension = maxdim(GetScaledSpriteSize(SPR_ARROW_UP), GetScaledSpriteSize(SPR_ARROW_DOWN));
 		vertical_dimension.width += WidgetDimensions::scaled.vscrollbar.Horizontal();
 		vertical_dimension.height += WidgetDimensions::scaled.vscrollbar.Vertical();
+	}
 	return vertical_dimension;
+}
 /* static */ Dimension NWidgetScrollbar::GetHorizontalDimension()
+{
 	if (horizontal_dimension.width == 0) {
@@ @@ -2846,49 +2846,49 @@ void NWidgetLeaf::Draw(const Window *w) @@
 			DrawResizeBox(r, this->colour, this->pos_x < (w->width / 2), !!(w->flags & WF_SIZING), this->widget_data == 0);
 			break;
 		case WWT_CLOSEBOX:
 			DrawCloseBox(r, this->colour);
 			break;
 		case WWT_DROPDOWN:
 			if (this->index >= 0) w->SetStringParameters(this->index);
 			DrawButtonDropdown(r, this->colour, false, clicked, this->widget_data, this->align);
 			break;
 		case NWID_BUTTON_DROPDOWN:
 		case NWID_PUSHBUTTON_DROPDOWN:
 			if (this->index >= 0) w->SetStringParameters(this->index);
 			DrawButtonDropdown(r, this->colour, clicked, (this->disp_flags & ND_DROPDOWN_ACTIVE) != 0, this->widget_data, this->align);
 			break;
 		default:
 			NOT_REACHED();
+	}
 	if (this->index >= 0) w->DrawWidget(r, this->index);
 	if (this->IsDisabled()) {
-		GfxFillRect(r.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(this->colour, SHADE_2), FILLRECT_CHECKER);
+		GfxFillRect(r.Shrink(WidgetDimensions::scaled.bevel), GetColourGradient(this->colour, SHADE_DARKER), FILLRECT_CHECKER);
+	}
 	DrawOutline(w, this);
+}
 /**
  * For a #NWID_BUTTON_DROPDOWN, test whether \a pt refers to the button or to the drop-down.
  * @param pt Point in the widget.
  * @return The point refers to the button.
+ *
  * @note The magic constants are also used at #DrawButtonDropdown.
  */
 bool NWidgetLeaf::ButtonHit(const Point &pt)
+{
 	if (_current_text_dir == TD_LTR) {
 		int button_width = this->pos_x + this->current_x - NWidgetLeaf::dropdown_dimension.width;
 		return pt.x < button_width;
 	} else {
 		int button_left = this->pos_x + NWidgetLeaf::dropdown_dimension.width;
 		return pt.x >= button_left;
+	}
+}
 /* == Conversion code from NWidgetPart array to NWidgetBase* tree == */

src/widgets/dropdown_type.h

➞

Show inline comments

@@ @@ -16,76 +16,76 @@ @@
 #include "../palette_func.h"
 #include "../string_func.h"
 #include "../strings_func.h"
 #include "../table/strings.h"
 #include "../window_gui.h"
 /**
  * Base list item class from which others are derived.
  */
 class DropDownListItem {
 public:
 	int result; ///< Result value to return to window on selection.
 	bool masked; ///< Masked and unselectable item.
 	bool shaded; ///< Shaded item, affects text colour.
 	explicit DropDownListItem(int result, bool masked = false, bool shaded = false) : result(result), masked(masked), shaded(shaded) {}
 	virtual ~DropDownListItem() = default;
 	virtual bool Selectable() const { return true; }
 	virtual uint Height() const { return 0; }
 	virtual uint Width() const { return 0; }
 	virtual void Draw(const Rect &full, const Rect &, bool, Colours bg_colour) const
+	{
-		if (this->masked) GfxFillRect(full, GetColourGradient(bg_colour, SHADE_5), FILLRECT_CHECKER);
+		if (this->masked) GfxFillRect(full, GetColourGradient(bg_colour, SHADE_LIGHT), FILLRECT_CHECKER);
+	}
 	TextColour GetColour(bool sel) const
+	{
 		if (this->shaded) return (sel ? TC_SILVER : TC_GREY) | TC_NO_SHADE;
 		return sel ? TC_WHITE : TC_BLACK;
+	}
 };
 /**
  * Drop down divider component.
  * @tparam TBase Base component.
  * @tparam TFs Font size -- used to determine height.
  */
 template<class TBase, FontSize TFs = FS_NORMAL>
 class DropDownDivider : public TBase {
 public:
 	template <typename... Args>
 	explicit DropDownDivider(Args&&... args) : TBase(std::forward<Args>(args)...) {}
 	bool Selectable() const override { return false; }
 	uint Height() const override { return std::max<uint>(GetCharacterHeight(TFs), this->TBase::Height()); }
 	void Draw(const Rect &full, const Rect &, bool, Colours bg_colour) const override
+	{
 		uint8_t c1 = GetColourGradient(bg_colour, SHADE_3);
 		uint8_t c2 = GetColourGradient(bg_colour, SHADE_7);
 		uint8_t c1 = GetColourGradient(bg_colour, SHADE_DARK);
 		uint8_t c2 = GetColourGradient(bg_colour, SHADE_LIGHTEST);
 		int mid = CenterBounds(full.top, full.bottom, 0);
 		GfxFillRect(full.left, mid - WidgetDimensions::scaled.bevel.bottom, full.right, mid - 1, c1);
 		GfxFillRect(full.left, mid, full.right, mid + WidgetDimensions::scaled.bevel.top - 1, c2);
+	}
 };
 /**
  * Drop down string component.
  * @tparam TBase Base component.
  * @tparam TFs Font size.
  * @tparam TEnd Position string at end if true, or start if false.
  */
 template<class TBase, FontSize TFs = FS_NORMAL, bool TEnd = false>
 class DropDownString : public TBase {
 	std::string string; ///< String to be drawn.
 	Dimension dim; ///< Dimensions of string.
 public:
 	template <typename... Args>
 	explicit DropDownString(StringID string, Args&&... args) : TBase(std::forward<Args>(args)...)
+	{
 		this->SetString(GetString(string));
+	}

src/widgets/slider.cpp

➞

Show inline comments

@@ @@ -20,51 +20,51 @@ @@
 static const int SLIDER_WIDTH = 3;
 /**
  * Draw a slider widget with knob at given value
  * @param r Rectangle to draw the widget in
  * @param min_value Minimum value of slider
  * @param max_value Maximum value of slider
  * @param value Value to put the slider at
  * @param labels List of positions and labels to draw along the slider.
  */
 void DrawSliderWidget(Rect r, int min_value, int max_value, int value, const std::map<int, StringID> &labels)
+{
 	/* Allow space for labels. We assume they are in the small font. */
 	if (!labels.empty()) r.bottom -= GetCharacterHeight(FS_SMALL) + WidgetDimensions::scaled.hsep_normal;
 	max_value -= min_value;
 	/* Draw a wedge indicating low to high value. */
 	const int ha = (r.bottom - r.top) / 5;
 	const int sw = ScaleGUITrad(SLIDER_WIDTH);
 	const int t = WidgetDimensions::scaled.bevel.top; /* Thickness of lines */
 	int wx1 = r.left  + sw / 2;
 	int wx2 = r.right - sw / 2;
 	if (_current_text_dir == TD_RTL) std::swap(wx1, wx2);
 	const uint shadow = GetColourGradient(COLOUR_GREY, SHADE_3);
 	const uint fill = GetColourGradient(COLOUR_GREY, SHADE_6);
 	const uint light = GetColourGradient(COLOUR_GREY, SHADE_7);
 	const uint shadow = GetColourGradient(COLOUR_GREY, SHADE_DARK);
 	const uint fill = GetColourGradient(COLOUR_GREY, SHADE_LIGHTER);
 	const uint light = GetColourGradient(COLOUR_GREY, SHADE_LIGHTEST);
 	const std::vector<Point> wedge{ Point{wx1, r.bottom - ha}, Point{wx2, r.top + ha}, Point{wx2, r.bottom - ha} };
 	GfxFillPolygon(wedge, fill);
 	GfxDrawLine(wedge[0].x, wedge[0].y, wedge[2].x, wedge[2].y, light, t);
 	GfxDrawLine(wedge[1].x, wedge[1].y, wedge[2].x, wedge[2].y, _current_text_dir == TD_RTL ? shadow : light, t);
 	GfxDrawLine(wedge[0].x, wedge[0].y, wedge[1].x, wedge[1].y, shadow, t);
 	int x;
 	for (auto label : labels) {
 		x = label.first - min_value;
 		if (_current_text_dir == TD_RTL) x = max_value - x;
 		x = r.left + (x * (r.right - r.left - sw) / max_value) + sw / 2;
 		GfxDrawLine(x, r.bottom - ha + 1, x, r.bottom + (label.second == STR_NULL ? 0 : WidgetDimensions::scaled.hsep_normal), shadow, t);
 		if (label.second != STR_NULL) {
 			Dimension d = GetStringBoundingBox(label.second, FS_SMALL);
 			x = Clamp(x - d.width / 2, r.left, r.right - d.width);
 			DrawString(x, x + d.width, r.bottom + 1 + WidgetDimensions::scaled.hsep_normal, label.second, TC_BLACK, SA_CENTER, false, FS_SMALL);
+		}
+	}
 	/* Draw a slider handle indicating current value. */
 	value -= min_value;
 	if (_current_text_dir == TD_RTL) value = max_value - value;
 	x = r.left + (value * (r.right - r.left - sw) / max_value);
 	DrawFrameRect(x, r.top, x + sw, r.bottom, COLOUR_GREY, FR_NONE);

0 comments (0 inline, 0 general)