openttd-ottdgrfs: comparison src/window.cpp

equal deleted inserted replaced

-:3b068c3a1c74
+:0fa543611bbe
 #include "variables.h"
 #include "table/sprites.h"
 #include "genworld.h"
 #include "helpers.hpp"
-// delta between mouse cursor and upper left corner of dragged window
+/* delta between mouse cursor and upper left corner of dragged window */
 static Point _drag_delta;
 static Window _windows[25];
 Window *_z_windows[lengthof(_windows)];
 Window **_last_z_window; ///< always points to the next free space in the z-array
 	e.we.click.pt.y = y;
 	e.event = WE_CLICK;
 	if (w->desc_flags & WDF_DEF_WIDGET) {
 		e.we.click.widget = GetWidgetFromPos(w, x, y);
-		if (e.we.click.widget < 0) return; /* exit if clicked outside of widgets */
+		if (e.we.click.widget < 0) return; // exit if clicked outside of widgets
 		/* don't allow any interaction if the button has been disabled */
 		if (IsWindowWidgetDisabled(w, e.we.click.widget)) return;
 		wi = &w->widget[e.we.click.widget];
 	/* default tooltips handler? */
 	if (w->desc_flags & WDF_STD_TOOLTIPS) {
 		e.we.click.widget = GetWidgetFromPos(w, x, y);
 		if (e.we.click.widget < 0)
-			return; /* exit if clicked outside of widgets */
+			return; // exit if clicked outside of widgets
 		if (w->widget[e.we.click.widget].tooltips != 0) {
 			GuiShowTooltips(w->widget[e.we.click.widget].tooltips);
 			return;
 		}
 	if (w == NULL) return;
 	SetDirtyBlocks(w->left, w->top, w->left + w->width, w->top + w->height);
 }
 /** Find the Window whose parent pointer points to this window
-* @parent w Window to find child of
+* @param w parent Window to find child of
-* @return return a Window pointer that is the child of w, or NULL otherwise */
+* @return a Window pointer that is the child of w, or NULL otherwise */
 static Window *FindChildWindow(const Window *w)
 {
 	Window* const *wz;
 	FOR_ALL_WINDOWS(wz) {
 	return NULL;
 }
 /** Find the z-value of a window. A window must already be open
-* or the behaviour is undefined but function should never fail */
+* or the behaviour is undefined but function should never fail
+* @param w window to query Z Position
+* @return the window that matches it */
 Window **FindWindowZPosition(const Window *w)
 {
 	Window **wz;
 	for (wz = _z_windows; wz != _last_z_window; wz++) {
 }
 static void BringWindowToFront(const Window *w);
 /** Find a window and make it the top-window on the screen. The window
-* gets a white border for a brief period of time to visualize its
+* gets a white border for a brief period of time to visualize its "activation"
-* "activation"
+* @param cls WindowClass of the window to activate
+* @param number WindowNumber of the window to activate
 * @return a pointer to the window thus activated */
 Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)
 {
 	Window *w = FindWindowById(cls, number);
 bool IsWindowOfPrototype(const Window *w, const Widget *widget)
 {
 	return (w->original_widget == widget);
 }
-/* Copies 'widget' to 'w->widget' to allow for resizable windows */
+/** Copies 'widget' to 'w->widget' to allow for resizable windows
+* @param w Window on which to attach the widget array
+* @param widget pointer of widget array to fill the window with */
 void AssignWidgetToWindow(Window *w, const Widget *widget)
 {
 	w->original_widget = widget;
 	if (widget != NULL) {
 	assert(_last_z_window == endof(_z_windows));
 	return NULL;
 }
-/* Open a new window.
+/** Open a new window.
 * This function is called from AllocateWindow() or AllocateWindowDesc()
 * See descriptions for those functions for usage
 * See AllocateWindow() for description of arguments.
 * Only addition here is window_number, which is the window_number being assigned to the new window
-*/
+* @param x offset in pixels from the left of the screen
+* @param y offset in pixels from the top of the screen
+* @param width width in pixels of the window
+* @param height height in pixels of the window
+* @param *proc see WindowProc function to call when any messages/updates happen to the window
+* @param cls see WindowClass class of the window, used for identification and grouping
+* @param *widget see Widget pointer to the window layout and various elements
+* @param window_number number being assigned to the new window
+* @return Window pointer of the newly created window */
 static Window *LocalAllocateWindow(
 							int x, int y, int width, int height,
 							WindowProc *proc, WindowClass cls, const Widget *widget, int window_number)
 {
 	Window *w = FindFreeWindow();
 		w = FindDeletableWindow();
 		if (w == NULL) w = ForceFindDeletableWindow();
 		DeleteWindow(w);
 	}
-	// Set up window properties
+	/* Set up window properties */
 	memset(w, 0, sizeof(*w));
 	w->window_class = cls;
 	w->flags4 = WF_WHITE_BORDER_MASK; // just opened windows have a white border
 	w->caption_color = 0xFF;
 	w->left = x;
 * ones. Finally set all variables and call the WE_CREATE event
 * @param x offset in pixels from the left of the screen
 * @param y offset in pixels from the top of the screen
 * @param width width in pixels of the window
 * @param height height in pixels of the window
-* @param *proc @see WindowProc function to call when any messages/updates happen to the window
+* @param *proc see WindowProc function to call when any messages/updates happen to the window
-* @param cls @see WindowClass class of the window, used for identification and grouping
+* @param cls see WindowClass class of the window, used for identification and grouping
-* @param *widget @see Widget pointer to the window layout and various elements
+* @param *widget see Widget pointer to the window layout and various elements
-* @return @see Window pointer of the newly created window
+* @return Window pointer of the newly created window */
-*/
 Window *AllocateWindow(
 							int x, int y, int width, int height,
 							WindowProc *proc, WindowClass cls, const Widget *widget)
 {
 	return LocalAllocateWindow(x, y, width, height, proc, cls, widget, 0);
 	bottom = _awap_r.height + top;
 	if (left < 0 || top < 22 || right > _screen.width || bottom > _screen.height)
 		return false;
-	// Make sure it is not obscured by any window.
+	/* Make sure it is not obscured by any window. */
 	FOR_ALL_WINDOWS(wz) {
 		const Window *w = *wz;
 		if (w->window_class == WC_MAIN_WINDOW) continue;
 		if (right > w->left &&
 	height = _awap_r.height;
 	if (left < -(width>>2) || left > _screen.width - (width>>1)) return false;
 	if (top < 22 || top > _screen.height - (height>>2)) return false;
-	// Make sure it is not obscured by any window.
+	/* Make sure it is not obscured by any window. */
 	FOR_ALL_WINDOWS(wz) {
 		const Window *w = *wz;
 		if (w->window_class == WC_MAIN_WINDOW) continue;
 		if (left + width > w->left &&
 }
 /**
 * Open a new window.
 * @param *desc The pointer to the WindowDesc to be created
-* @return @see Window pointer of the newly created window
+* @return Window pointer of the newly created window
 */
 Window *AllocateWindowDesc(const WindowDesc *desc)
 {
 	return LocalAllocateWindowDesc(desc, 0);
 }
 /**
 * Open a new window.
 * @param *desc The pointer to the WindowDesc to be created
 * @param window_number the window number of the new window
-* @return @see Window pointer of the newly created window
+* @return see Window pointer of the newly created window
 */
 Window *AllocateWindowDescFront(const WindowDesc *desc, int window_number)
 {
 	Window *w;
 	return w;
 }
 /** Do a search for a window at specific coordinates. For this we start
 * at the topmost window, obviously and work our way down to the bottom
+* @param x position x to query
+* @param y position y to query
 * @return a pointer to the found window if any, NULL otherwise */
 Window *FindWindowFromPt(int x, int y)
 {
 	Window* const *wz;
 	Window *w;
 	Window* const *wz;
 	for (wz = _last_z_window; wz != _z_windows;) {
 		w = *--wz;
-		// Unclick scrollbar buttons if they are pressed.
+		/* Unclick scrollbar buttons if they are pressed. */
 		if (w->flags4 & (WF_SCROLL_DOWN | WF_SCROLL_UP)) {
 			w->flags4 &= ~(WF_SCROLL_DOWN | WF_SCROLL_UP);
 			SetWindowDirty(w);
 		}
 		CallWindowEventNP(w, WE_MOUSELOOP);
 	w = GetCallbackWnd();
 	ResetObjectToPlace();
 	if (w != NULL) {
-		// send an event in client coordinates.
+		/* send an event in client coordinates. */
 		e.event = WE_DRAGDROP;
 		e.we.dragdrop.pt.x = _cursor.pos.x - w->left;
 		e.we.dragdrop.pt.y = _cursor.pos.y - w->top;
 		e.we.dragdrop.widget = GetWidgetFromPos(w, e.we.dragdrop.pt.x, e.we.dragdrop.pt.y);
 		w->wndproc(w, &e);
 	WindowEvent e;
 	static Window *last_w = NULL;
 	w = FindWindowFromPt(_cursor.pos.x, _cursor.pos.y);
-	// We changed window, put a MOUSEOVER event to the last window
+	/* We changed window, put a MOUSEOVER event to the last window */
 	if (last_w != NULL && last_w != w) {
 		e.event = WE_MOUSEOVER;
 		e.we.mouseover.pt.x = -1;
 		e.we.mouseover.pt.y = -1;
 		if (last_w->wndproc) last_w->wndproc(last_w, &e);
 	}
 	last_w = w;
 	if (w != NULL) {
-		// send an event in client coordinates.
+		/* send an event in client coordinates. */
 		e.event = WE_MOUSEOVER;
 		e.we.mouseover.pt.x = _cursor.pos.x - w->left;
 		e.we.mouseover.pt.y = _cursor.pos.y - w->top;
 		if (w->widget != NULL) {
 			e.we.mouseover.widget = GetWidgetFromPos(w, e.we.mouseover.pt.x, e.we.mouseover.pt.y);
 		}
 		w->wndproc(w, &e);
 	}
-	// Mouseover never stops execution
+	/* Mouseover never stops execution */
 	return true;
 }
 /** Update all the widgets of a window based on their resize flags
 * Both the areas of the old window and the new sized window are set dirty
 static bool _dragging_window;
 static bool HandleWindowDragging()
 {
 	Window* const *wz;
-	// Get out immediately if no window is being dragged at all.
+	/* Get out immediately if no window is being dragged at all. */
 	if (!_dragging_window) return true;
-	// Otherwise find the window...
+	/* Otherwise find the window... */
 	FOR_ALL_WINDOWS(wz) {
 		Window *w = *wz;
 		if (w->flags4 & WF_DRAGGING) {
 			const Widget *t = &w->widget[1]; // the title bar ... ugh
 			int x;
 			int y;
 			int nx;
 			int ny;
-			// Stop the dragging if the left mouse button was released
+			/* Stop the dragging if the left mouse button was released */
 			if (!_left_button_down) {
 				w->flags4 &= ~WF_DRAGGING;
 				break;
 			}
 					const Window *v = *vz;
 					if (v == w) continue; // Don't snap at yourself
 					if (y + w->height > v->top && y < v->top + v->height) {
-						// Your left border <-> other right border
+						/* Your left border <-> other right border */
 						delta = abs(v->left + v->width - x);
 						if (delta <= hsnap) {
 							nx = v->left + v->width;
 							hsnap = delta;
 						}
-						// Your right border <-> other left border
+						/* Your right border <-> other left border */
 						delta = abs(v->left - x - w->width);
 						if (delta <= hsnap) {
 							nx = v->left - w->width;
 							hsnap = delta;
 						}
 					}
 					if (w->top + w->height >= v->top && w->top <= v->top + v->height) {
-						// Your left border <-> other left border
+						/* Your left border <-> other left border */
 						delta = abs(v->left - x);
 						if (delta <= hsnap) {
 							nx = v->left;
 							hsnap = delta;
 						}
-						// Your right border <-> other right border
+						/* Your right border <-> other right border */
 						delta = abs(v->left + v->width - x - w->width);
 						if (delta <= hsnap) {
 							nx = v->left + v->width - w->width;
 							hsnap = delta;
 						}
 					}
 					if (x + w->width > v->left && x < v->left + v->width) {
-						// Your top border <-> other bottom border
+						/* Your top border <-> other bottom border */
 						delta = abs(v->top + v->height - y);
 						if (delta <= vsnap) {
 							ny = v->top + v->height;
 							vsnap = delta;
 						}
-						// Your bottom border <-> other top border
+						/* Your bottom border <-> other top border */
 						delta = abs(v->top - y - w->height);
 						if (delta <= vsnap) {
 							ny = v->top - w->height;
 							vsnap = delta;
 						}
 					}
 					if (w->left + w->width >= v->left && w->left <= v->left + v->width) {
-						// Your top border <-> other top border
+						/* Your top border <-> other top border */
 						delta = abs(v->top - y);
 						if (delta <= vsnap) {
 							ny = v->top;
 							vsnap = delta;
 						}
-						// Your bottom border <-> other bottom border
+						/* Your bottom border <-> other bottom border */
 						delta = abs(v->top + v->height - y - w->height);
 						if (delta <= vsnap) {
 							ny = v->top + v->height - w->height;
 							vsnap = delta;
 						}
 					}
 				}
 			}
-			// Make sure the window doesn't leave the screen
+			/* Make sure the window doesn't leave the screen
-			// 13 is the height of the title bar
+			 * 13 is the height of the title bar */
 			nx = clamp(nx, 13 - t->right, _screen.width - 13 - t->left);
 			ny = clamp(ny, 0, _screen.height - 13);
-			// Make sure the title bar isn't hidden by behind the main tool bar
+			/* Make sure the title bar isn't hidden by behind the main tool bar */
 			v = FindWindowById(WC_MAIN_TOOLBAR, 0);
 			if (v != NULL) {
 				int v_bottom = v->top + v->height;
 				int v_right = v->left + v->width;
 				if (ny + t->top >= v->top && ny + t->top < v_bottom) {
 	Window* const *wz;
 	int i;
 	int pos;
 	Scrollbar *sb;
-	// Get out quickly if no item is being scrolled
+	/* Get out quickly if no item is being scrolled */
 	if (!_scrolling_scrollbar) return true;
-	// Find the scrolling window
+	/* Find the scrolling window */
 	FOR_ALL_WINDOWS(wz) {
 		Window *w = *wz;
 		if (w->flags4 & WF_SCROLL_MIDDLE) {
-			// Abort if no button is clicked any more.
+			/* Abort if no button is clicked any more. */
 			if (!_left_button_down) {
 				w->flags4 &= ~WF_SCROLL_MIDDLE;
 				SetWindowDirty(w);
 				break;
 			}
 			} else {
 				sb = &w->vscroll;
 				i = _cursor.pos.y - _cursorpos_drag_start.y;
 			}
-			// Find the item we want to move to and make sure it's inside bounds.
+			/* Find the item we want to move to and make sure it's inside bounds. */
 			pos = min(max(0, i + _scrollbar_start_pos) * sb->count / _scrollbar_size, max(0, sb->count - sb->cap));
 			if (pos != sb->pos) {
 				sb->pos = pos;
 				SetWindowDirty(w);
 			}
 	if (bring_to_front) BringWindowToFront(w);
 	return true;
 }
 /** Send a message from one window to another. The receiving window is found by
-* @param w @see Window pointer pointing to the other window
+* @param w Window pointer pointing to the other window
 * @param msg Specifies the message to be sent
 * @param wparam Specifies additional message-specific information
 * @param lparam Specifies additional message-specific information
 */
 static void SendWindowMessageW(Window *w, uint msg, uint wparam, uint lparam)
 	w->wndproc(w, &e);
 }
 /** Send a message from one window to another. The receiving window is found by
-* @param wnd_class @see WindowClass class AND
+* @param wnd_class see WindowClass class AND
-* @param wnd_num @see WindowNumber number, mostly 0
+* @param wnd_num see WindowNumber number, mostly 0
 * @param msg Specifies the message to be sent
 * @param wparam Specifies additional message-specific information
 * @param lparam Specifies additional message-specific information
 */
 void SendWindowMessage(WindowClass wnd_class, WindowNumber wnd_num, int msg, int wparam, int lparam)
 	if (w != NULL) SendWindowMessageW(w, msg, wparam, lparam);
 }
 /** Send a message from one window to another. The message will be sent
 * to ALL windows of the windowclass specified in the first parameter
-* @param wnd_class @see WindowClass class
+* @param wnd_class see WindowClass class
 * @param msg Specifies the message to be sent
 * @param wparam Specifies additional message-specific information
 * @param lparam Specifies additional message-specific information
 */
 void SendWindowMessageClass(WindowClass wnd_class, int msg, int wparam, int lparam)
 	* This is not necessary either, as the only events that
 	* can be handled are the 'close application' events
 	*/
 	if (!IsGeneratingWorld()) _current_player = _local_player;
-	// Setup event
+	/* Setup event */
 	e.event = WE_KEYPRESS;
 	e.we.keypress.key     = GB(key,  0, 16);
 	e.we.keypress.keycode = GB(key, 16, 16);
 	e.we.keypress.cont = true;
-	// check if we have a query string window open before allowing hotkeys
+	/* check if we have a query string window open before allowing hotkeys */
 	if (FindWindowById(WC_QUERY_STRING,       0) != NULL ||
 			FindWindowById(WC_SEND_NETWORK_MSG,   0) != NULL ||
 			FindWindowById(WC_GENERATE_LANDSCAPE, 0) != NULL ||
 			FindWindowById(WC_CONSOLE,            0) != NULL ||
 			FindWindowById(WC_SAVELOAD,           0) != NULL) {
 		query_open = true;
 	}
-	// Call the event, start with the uppermost window.
+	/* Call the event, start with the uppermost window. */
 	for (wz = _last_z_window; wz != _z_windows;) {
 		Window *w = *--wz;
-		// if a query window is open, only call the event for certain window types
+		/* if a query window is open, only call the event for certain window types */
 		if (query_open &&
 				w->window_class != WC_QUERY_STRING &&
 				w->window_class != WC_SEND_NETWORK_MSG &&
 				w->window_class != WC_GENERATE_LANDSCAPE &&
 				w->window_class != WC_CONSOLE &&
 		if (!e.we.keypress.cont) break;
 	}
 	if (e.we.keypress.cont) {
 		Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);
-		// When there is no toolbar w is null, check for that
+		/* When there is no toolbar w is null, check for that */
 		if (w != NULL) w->wndproc(w, &e);
 	}
 }
 extern void UpdateTileSelection();
 		if (w == NULL || w->flags4 & WF_DISABLE_VP_SCROLL) return;
 		vp = IsPtInWindowViewport(w, x, y);
 		if (vp != NULL) {
 			x -= vp->left;
 			y -= vp->top;
-			//here allows scrolling in both x and y axis
+			/* here allows scrolling in both x and y axis */
 #define scrollspeed 3
 			if (x - 15 < 0) {
 				WP(w, vp_d).scrollpos_x += (x - 15) * scrollspeed << vp->zoom;
 			} else if (15 - (vp->width - x) > 0) {
 				WP(w, vp_d).scrollpos_x += (15 - (vp->width - x)) * scrollspeed << vp->zoom;
 		if (scrollwheel_scrolling) click = 2; // we are using the scrollwheel in a viewport, so we emulate right mouse button
 		switch (click) {
 			case 1:
 				DEBUG(misc, 2, "Cursor: 0x%X (%d)", _cursor.sprite, _cursor.sprite);
 				if (_thd.place_mode != 0 &&
-						// query button and place sign button work in pause mode
+						/* query button and place sign button work in pause mode */
 						_cursor.sprite != SPR_CURSOR_QUERY &&
 						_cursor.sprite != SPR_CURSOR_SIGN &&
 						_pause_game != 0 &&
 						!_cheats.build_in_pause.value) {
 					return;
 	 * This is not necessary either, as the only events that
 	 * can be handled are the 'close application' events
 	 */
 	if (!IsGeneratingWorld()) _current_player = _local_player;
-	// Mouse event?
+	/* Mouse event? */
 	click = 0;
 	if (_left_button_down && !_left_button_clicked) {
 		_left_button_clicked = true;
 		click = 1;
 		_input_events_this_tick++;
 	FOR_ALL_WINDOWS(wz) {
 		if ((*wz)->viewport != NULL) UpdateViewportPosition(*wz);
 	}
 	DrawTextMessage();
-	// Redraw mouse cursor in case it was hidden
+	/* Redraw mouse cursor in case it was hidden */
 	DrawMouseCursor();
 }
 int GetMenuItemIndex(const Window *w, int x, int y)
 			goto restart_search;
 		}
 	}
 }
-/* It is possible that a stickied window gets to a position where the
+/** It is possible that a stickied window gets to a position where the
 * 'close' button is outside the gaming area. You cannot close it then; except
 * with this function. It closes all windows calling the standard function,
 * then, does a little hacked loop of closing all stickied windows. Note
 * that standard windows (status bar, etc.) are not stickied, so these aren't affected */
 void DeleteAllNonVitalWindows()
 			goto restart_search;
 		}
 	}
 }
-/* Delete all always on-top windows to get an empty screen */
+/** Delete all always on-top windows to get an empty screen */
 void HideVitalWindows()
 {
 	DeleteWindowById(WC_TOOLBAR_MENU, 0);
 	DeleteWindowById(WC_MAIN_TOOLBAR, 0);
 	DeleteWindowById(WC_STATUS_BAR, 0);

branch	gamebalance
changeset 9908	0fa543611bbe
parent 9895	7bd07f43b0e3
child 9909	dce9a6923bb7