openttd-ottdgrfs: comparison src/window.cpp

equal deleted inserted replaced

-:70d78ac95d6c
+:7bd07f43b0e3
 * - Main window (gamefield), Toolbar, Statusbar (always on)
 * - News window, Chatbar (when on)
 * - Any sticked windows since we wanted to keep these
 * @return w pointer to the window that is going to be deleted
 */
-static Window *FindDeletableWindow(void)
+static Window *FindDeletableWindow()
 {
 	Window* const *wz;
 	FOR_ALL_WINDOWS(wz) {
 		Window *w = *wz;
 * windows intact (Main window, Toolbar, Statusbar, News Window, Chatbar)
 * Start finding an appropiate candidate from the lowest z-values (bottom)
 * @see FindDeletableWindow()
 * @return w Pointer to the window that is being deleted
 */
-static Window *ForceFindDeletableWindow(void)
+static Window *ForceFindDeletableWindow()
 {
 	Window* const *wz;
 	for (wz = _z_windows;; wz++) {
 		Window *w = *wz;
 		w->widget = NULL;
 		w->widget_count = 0;
 	}
 }
-static Window *FindFreeWindow(void)
+static Window *FindFreeWindow()
 {
 	Window *w;
 	for (w = _windows; w < endof(_windows); w++) {
 		Window* const *wz;
 							WindowProc *proc, WindowClass cls, const Widget *widget)
 {
 	return LocalAllocateWindow(x, y, width, height, proc, cls, widget, 0);
 }
-typedef struct SizeRect {
+struct SizeRect {
 	int left,top,width,height;
-} SizeRect;
+};
 static SizeRect _awap_r;
 static bool IsGoodAutoPlace1(int left, int top)
 	}
 	return NULL;
 }
-void InitWindowSystem(void)
+void InitWindowSystem()
 {
 	IConsoleClose();
 	memset(&_windows, 0, sizeof(_windows));
 	_last_z_window = _z_windows;
 	InitViewports();
 	_no_scroll = 0;
 }
-void UnInitWindowSystem(void)
+void UnInitWindowSystem()
 {
 	Window **wz;
 restart_search:
 	/* Delete all windows, reset z-array.
 	}
 	assert(_last_z_window == _z_windows);
 }
-void ResetWindowSystem(void)
+void ResetWindowSystem()
 {
 	UnInitWindowSystem();
 	InitWindowSystem();
 	_thd.pos.x = 0;
 	_thd.pos.y = 0;
 	_thd.new_pos.x = 0;
 	_thd.new_pos.y = 0;
 }
-static void DecreaseWindowCounters(void)
+static void DecreaseWindowCounters()
 {
 	Window *w;
 	Window* const *wz;
 	for (wz = _last_z_window; wz != _z_windows;) {
 			if (w->desc_flags & WDF_UNCLICK_BUTTONS) RaiseWindowButtons(w);
 		}
 	}
 }
-Window *GetCallbackWnd(void)
+Window *GetCallbackWnd()
 {
 	return FindWindowById(_thd.window_class, _thd.window_number);
 }
-static void HandlePlacePresize(void)
+static void HandlePlacePresize()
 {
 	Window *w;
 	WindowEvent e;
 	if (_special_mouse_mode != WSM_PRESIZE) return;
 	e.we.place.tile = TileVirtXY(e.we.place.pt.x, e.we.place.pt.y);
 	e.event = WE_PLACE_PRESIZE;
 	w->wndproc(w, &e);
 }
-static bool HandleDragDrop(void)
+static bool HandleDragDrop()
 {
 	Window *w;
 	WindowEvent e;
 	if (_special_mouse_mode != WSM_DRAGDROP) return true;
 		w->wndproc(w, &e);
 	}
 	return false;
 }
-static bool HandlePopupMenu(void)
+static bool HandlePopupMenu()
 {
 	Window *w;
 	WindowEvent e;
 	if (!_popup_menu_active) return true;
 	w->wndproc(w, &e);
 	return false;
 }
-static bool HandleMouseOver(void)
+static bool HandleMouseOver()
 {
 	Window *w;
 	WindowEvent e;
 	static Window *last_w = NULL;
 	SetWindowDirty(w);
 }
 static bool _dragging_window;
-static bool HandleWindowDragging(void)
+static bool HandleWindowDragging()
 {
 	Window* const *wz;
 	// Get out immediately if no window is being dragged at all.
 	if (!_dragging_window) return true;
 	BringWindowToFront(w);
 	DeleteWindowById(WC_DROPDOWN_MENU, 0);
 }
-static bool HandleScrollbarScrolling(void)
+static bool HandleScrollbarScrolling()
 {
 	Window* const *wz;
 	int i;
 	int pos;
 	Scrollbar *sb;
 	_scrolling_scrollbar = false;
 	return false;
 }
-static bool HandleViewportScroll(void)
+static bool HandleViewportScroll()
 {
 	WindowEvent e;
 	Window *w;
+	bool scrollwheel_scrolling = _patches.scrollwheel_scrolling == 1 && (_cursor.v_wheel != 0 || _cursor.h_wheel != 0);
 	if (!_scrolling_viewport) return true;
 	w = FindWindowFromPt(_cursor.pos.x, _cursor.pos.y);
-	if (!_right_button_down || w == NULL) {
+	if (!(_right_button_down || scrollwheel_scrolling) || w == NULL) {
 		_cursor.fix_at = false;
 		_scrolling_viewport = false;
 		return true;
 	}
 		e.we.scroll.delta.x = -_cursor.delta.x;
 		e.we.scroll.delta.y = -_cursor.delta.y;
 	} else {
 		e.we.scroll.delta.x = _cursor.delta.x;
 		e.we.scroll.delta.y = _cursor.delta.y;
+	}
+	if (scrollwheel_scrolling) {
+		/* We are using scrollwheels for scrolling */
+		e.we.scroll.delta.x = _cursor.h_wheel;
+		e.we.scroll.delta.y = _cursor.v_wheel;
+		_cursor.v_wheel = 0;
+		_cursor.h_wheel = 0;
 	}
 	/* Create a scroll-event and send it to the window */
 	e.event = WE_SCROLL;
 	w->wndproc(w, &e);
 		// When there is no toolbar w is null, check for that
 		if (w != NULL) w->wndproc(w, &e);
 	}
 }
-extern void UpdateTileSelection(void);
+extern void UpdateTileSelection();
-extern bool VpHandlePlaceSizingDrag(void);
+extern bool VpHandlePlaceSizingDrag();
 static int _input_events_this_tick = 0;
-static void HandleAutoscroll(void)
+static void HandleAutoscroll()
 {
 	Window *w;
 	ViewPort *vp;
 	int x = _cursor.pos.x;
 	int y = _cursor.pos.y;
 void MouseLoop(int click, int mousewheel)
 {
 	int x,y;
 	Window *w;
 	ViewPort *vp;
+	bool scrollwheel_scrolling = _patches.scrollwheel_scrolling == 1 && (_cursor.v_wheel != 0 || _cursor.h_wheel != 0);
 	DecreaseWindowCounters();
 	HandlePlacePresize();
 	UpdateTileSelection();
 	if (!VpHandlePlaceSizingDrag())  return;
 	if (!HandleMouseOver())          return;
 	x = _cursor.pos.x;
 	y = _cursor.pos.y;
-	if (click == 0 && mousewheel == 0) return;
+	if (click == 0 && mousewheel == 0 && !scrollwheel_scrolling) return;
 	w = FindWindowFromPt(x, y);
 	if (w == NULL) return;
 	if (!MaybeBringWindowToFront(w)) return;
 	vp = IsPtInWindowViewport(w, x, y);
 	/* Don't allow any action in a viewport if either in menu of in generating world */
 	if (vp != NULL && (_game_mode == GM_MENU || IsGeneratingWorld())) return;
 	if (mousewheel != 0) {
-		WindowEvent e;
+		if (_patches.scrollwheel_scrolling == 0) {
+			/* Scrollwheel is in zoom mode. Make the zoom event. */
-		/* Send WE_MOUSEWHEEL event to window */
+			WindowEvent e;
-		e.event = WE_MOUSEWHEEL;
-		e.we.wheel.wheel = mousewheel;
+			/* Send WE_MOUSEWHEEL event to window */
-		w->wndproc(w, &e);
+			e.event = WE_MOUSEWHEEL;
+			e.we.wheel.wheel = mousewheel;
+			w->wndproc(w, &e);
+		}
 		/* Dispatch a MouseWheelEvent for widgets if it is not a viewport */
 		if (vp == NULL) DispatchMouseWheelEvent(w, GetWidgetFromPos(w, x - w->left, y - w->top), mousewheel);
 	}
 	if (vp != NULL) {
+		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
 						_cursor.sprite != SPR_CURSOR_QUERY &&
 						_cursor.sprite != SPR_CURSOR_SIGN &&
-						_pause != 0 &&
+						_pause_game != 0 &&
 						!_cheats.build_in_pause.value) {
 					return;
 				}
 				if (_thd.place_mode == 0) {
 				break;
 		}
 	} else {
 		switch (click) {
 			case 1: DispatchLeftClickEvent(w, x - w->left, y - w->top);  break;
+			default:
+				if (!scrollwheel_scrolling || w == NULL || w->window_class != WC_SMALLMAP) break;
+				/* We try to use the scrollwheel to scroll since we didn't touch any of the buttons.
+				* Simulate a right button click so we can get started. */
+				/* fallthough */
 			case 2: DispatchRightClickEvent(w, x - w->left, y - w->top); break;
 		}
 	}
 }
-void HandleMouseEvents(void)
+void HandleMouseEvents()
 {
 	int click;
 	int mousewheel;
 	/*
 	}
 	MouseLoop(click, mousewheel);
 }
-void InputLoop(void)
+void InputLoop()
 {
 	HandleMouseEvents();
 	HandleAutoscroll();
 }
-void UpdateWindows(void)
+void UpdateWindows()
 {
 	Window* const *wz;
 	static int we4_timer = 0;
 	int t = we4_timer + 1;
 	FOR_ALL_WINDOWS(wz) {
 		if ((*wz)->window_class == cls) InvalidateThisWindowData(*wz);
 	}
 }
-void CallWindowTickEvent(void)
+void CallWindowTickEvent()
 {
 	Window* const *wz;
 	for (wz = _last_z_window; wz != _z_windows;) {
 		CallWindowEventNP(*--wz, WE_TICK);
 	}
 }
-void DeleteNonVitalWindows(void)
+void DeleteNonVitalWindows()
 {
 	Window* const *wz;
 restart_search:
 	/* When we find the window to delete, we need to restart the search
 /* 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(void)
+void DeleteAllNonVitalWindows()
 {
 	Window* const *wz;
 	/* Delete every window except for stickied ones, then sticky ones as well */
 	DeleteNonVitalWindows();
 		}
 	}
 }
 /* Delete all always on-top windows to get an empty screen */
-void HideVitalWindows(void)
+void HideVitalWindows()
 {
 	DeleteWindowById(WC_TOOLBAR_MENU, 0);
 	DeleteWindowById(WC_MAIN_TOOLBAR, 0);
 	DeleteWindowById(WC_STATUS_BAR, 0);
 }

branch	gamebalance
changeset 9895	7bd07f43b0e3
parent 6443	b8f06d8eb7be
child 9908	0fa543611bbe