1 /* $Id$ */

     2 

     3 #include "stdafx.h"

     4 #include <stdarg.h>

     5 #include "openttd.h"

     6 #include "debug.h"

     7 #include "functions.h"

     8 #include "map.h"

     9 #include "player.h"

    10 #include "window.h"

    11 #include "gfx.h"

    12 #include "viewport.h"

    13 #include "console.h"

    14 #include "variables.h"

    15 #include "table/sprites.h"

    16 #include "genworld.h"

    17 

    18 // delta between mouse cursor and upper left corner of dragged window

    19 static Point _drag_delta;

    20 

    21 static Window _windows[25];

    22 Window *_z_windows[lengthof(_windows)];

    23 Window **_last_z_window; ///< always points to the next free space in the z-array

    24 

    25 void CDECL SetWindowWidgetsDisabledState(Window *w, bool disab_stat, int widgets, ...)

    26 {

    27 	va_list wdg_list;

    28 

    29 	va_start(wdg_list, widgets);

    30 

    31 	while (widgets != WIDGET_LIST_END) {

    32 		SetWindowWidgetDisabledState(w, widgets, disab_stat);

    33 		widgets = va_arg(wdg_list, int);

    34 	}

    35 

    36 	va_end(wdg_list);

    37 }

    38 

    39 void CDECL SetWindowWidgetsHiddenState(Window *w, bool hidden_stat, int widgets, ...)

    40 {

    41 	va_list wdg_list;

    42 

    43 	va_start(wdg_list, widgets);

    44 

    45 	while (widgets != WIDGET_LIST_END) {

    46 		SetWindowWidgetHiddenState(w, widgets, hidden_stat);

    47 		widgets = va_arg(wdg_list, int);

    48 	}

    49 

    50 	va_end(wdg_list);

    51 }

    52 

    53 void CDECL SetWindowWidgetsLoweredState(Window *w, bool lowered_stat, int widgets, ...)

    54 {

    55 	va_list wdg_list;

    56 

    57 	va_start(wdg_list, widgets);

    58 

    59 	while (widgets != WIDGET_LIST_END) {

    60 		SetWindowWidgetLoweredState(w, widgets, lowered_stat);

    61 		widgets = va_arg(wdg_list, int);

    62 	}

    63 

    64 	va_end(wdg_list);

    65 }

    66 

    67 void RaiseWindowButtons(Window *w)

    68 {

    69 	uint i;

    70 

    71 	for (i = 0; i < w->widget_count; i++) {

    72 		if (IsWindowWidgetLowered(w, i)) {

    73 			RaiseWindowWidget(w, i);

    74 			InvalidateWidget(w, i);

    75 		}

    76 	}

    77 }

    78 

    79 void HandleButtonClick(Window *w, byte widget)

    80 {

    81 	LowerWindowWidget(w, widget);

    82 	w->flags4 |= 5 << WF_TIMEOUT_SHL;

    83 	InvalidateWidget(w, widget);

    84 }

    85 

    86 

    87 static void StartWindowDrag(Window *w);

    88 static void StartWindowSizing(Window *w);

    89 

    90 static void DispatchLeftClickEvent(Window *w, int x, int y)

    91 {

    92 	WindowEvent e;

    93 	const Widget *wi;

    94 

    95 	e.we.click.pt.x = x;

    96 	e.we.click.pt.y = y;

    97 	e.event = WE_CLICK;

    98 

    99 	if (w->desc_flags & WDF_DEF_WIDGET) {

   100 		e.we.click.widget = GetWidgetFromPos(w, x, y);

   101 		if (e.we.click.widget < 0) return; /* exit if clicked outside of widgets */

   102 

   103 		/* don't allow any interaction if the button has been disabled */

   104 		if (IsWindowWidgetDisabled(w, e.we.click.widget)) return;

   105 

   106 		wi = &w->widget[e.we.click.widget];

   107 

   108 		if (wi->type & WWB_MASK) {

   109 			/* special widget handling for buttons*/

   110 			switch (wi->type) {

   111 				case WWT_PANEL   | WWB_PUSHBUTTON: /* WWT_PUSHBTN */

   112 				case WWT_IMGBTN  | WWB_PUSHBUTTON: /* WWT_PUSHIMGBTN */

   113 				case WWT_TEXTBTN | WWB_PUSHBUTTON: /* WWT_PUSHTXTBTN */

   114 					HandleButtonClick(w, e.we.click.widget);

   115 					break;

   116 			}

   117 		} else if (wi->type == WWT_SCROLLBAR || wi->type == WWT_SCROLL2BAR || wi->type == WWT_HSCROLLBAR) {

   118 			ScrollbarClickHandler(w, wi, e.we.click.pt.x, e.we.click.pt.y);

   119 		}

   120 

   121 		if (w->desc_flags & WDF_STD_BTN) {

   122 			if (e.we.click.widget == 0) { /* 'X' */

   123 				DeleteWindow(w);

   124 				return;

   125 			}

   126 

   127 			if (e.we.click.widget == 1) { /* 'Title bar' */

   128 				StartWindowDrag(w);

   129 				return;

   130 			}

   131 		}

   132 

   133 		if (w->desc_flags & WDF_RESIZABLE && wi->type == WWT_RESIZEBOX) {

   134 			StartWindowSizing(w);

   135 			InvalidateWidget(w, e.we.click.widget);

   136 			return;

   137 		}

   138 

   139 		if (w->desc_flags & WDF_STICKY_BUTTON && wi->type == WWT_STICKYBOX) {

   140 			w->flags4 ^= WF_STICKY;

   141 			InvalidateWidget(w, e.we.click.widget);

   142 			return;

   143 		}

   144 	}

   145 

   146 	w->wndproc(w, &e);

   147 }

   148 

   149 static void DispatchRightClickEvent(Window *w, int x, int y)

   150 {

   151 	WindowEvent e;

   152 

   153 	/* default tooltips handler? */

   154 	if (w->desc_flags & WDF_STD_TOOLTIPS) {

   155 		e.we.click.widget = GetWidgetFromPos(w, x, y);

   156 		if (e.we.click.widget < 0)

   157 			return; /* exit if clicked outside of widgets */

   158 

   159 		if (w->widget[e.we.click.widget].tooltips != 0) {

   160 			GuiShowTooltips(w->widget[e.we.click.widget].tooltips);

   161 			return;

   162 		}

   163 	}

   164 

   165 	e.event = WE_RCLICK;

   166 	e.we.click.pt.x = x;

   167 	e.we.click.pt.y = y;

   168 	w->wndproc(w, &e);

   169 }

   170 

   171 /** Dispatch the mousewheel-action to the window which will scroll any

   172  * compatible scrollbars if the mouse is pointed over the bar or its contents

   173  * @param *w Window

   174  * @param widget the widget where the scrollwheel was used

   175  * @param wheel scroll up or down

   176  */

   177 static void DispatchMouseWheelEvent(Window *w, int widget, int wheel)

   178 {

   179 	const Widget *wi1, *wi2;

   180 	Scrollbar *sb;

   181 

   182 	if (widget < 0) return;

   183 

   184 	wi1 = &w->widget[widget];

   185 	wi2 = &w->widget[widget + 1];

   186 

   187 	/* The listbox can only scroll if scrolling was done on the scrollbar itself,

   188 	 * or on the listbox (and the next item is (must be) the scrollbar)

   189 	 * XXX - should be rewritten as a widget-dependent scroller but that's

   190 	 * not happening until someone rewrites the whole widget-code */

   191 	if ((sb = &w->vscroll,  wi1->type == WWT_SCROLLBAR)  || (sb = &w->vscroll2, wi1->type == WWT_SCROLL2BAR)  ||

   192 			(sb = &w->vscroll2, wi2->type == WWT_SCROLL2BAR) || (sb = &w->vscroll, wi2->type == WWT_SCROLLBAR) ) {

   193 

   194 		if (sb->count > sb->cap) {

   195 			int pos = clamp(sb->pos + wheel, 0, sb->count - sb->cap);

   196 			if (pos != sb->pos) {

   197 				sb->pos = pos;

   198 				SetWindowDirty(w);

   199 			}

   200 		}

   201 	}

   202 }

   203 

   204 static void DrawOverlappedWindow(Window* const *wz, int left, int top, int right, int bottom);

   205 

   206 void DrawOverlappedWindowForAll(int left, int top, int right, int bottom)

   207 {

   208 	Window* const *wz;

   209 	DrawPixelInfo bk;

   210 	_cur_dpi = &bk;

   211 

   212 	FOR_ALL_WINDOWS(wz) {

   213 		const Window *w = *wz;

   214 		if (right > w->left &&

   215 				bottom > w->top &&

   216 				left < w->left + w->width &&

   217 				top < w->top + w->height) {

   218 			DrawOverlappedWindow(wz, left, top, right, bottom);

   219 		}

   220 	}

   221 }

   222 

   223 static void DrawOverlappedWindow(Window* const *wz, int left, int top, int right, int bottom)

   224 {

   225 	Window* const *vz = wz;

   226 	int x;

   227 

   228 	while (++vz != _last_z_window) {

   229 		const Window *v = *vz;

   230 

   231 		if (right > v->left &&

   232 				bottom > v->top &&

   233 				left < v->left + v->width &&

   234 				top < v->top + v->height) {

   235 			if (left < (x=v->left)) {

   236 				DrawOverlappedWindow(wz, left, top, x, bottom);

   237 				DrawOverlappedWindow(wz, x, top, right, bottom);

   238 				return;

   239 			}

   240 

   241 			if (right > (x=v->left + v->width)) {

   242 				DrawOverlappedWindow(wz, left, top, x, bottom);

   243 				DrawOverlappedWindow(wz, x, top, right, bottom);

   244 				return;

   245 			}

   246 

   247 			if (top < (x=v->top)) {

   248 				DrawOverlappedWindow(wz, left, top, right, x);

   249 				DrawOverlappedWindow(wz, left, x, right, bottom);

   250 				return;

   251 			}

   252 

   253 			if (bottom > (x=v->top + v->height)) {

   254 				DrawOverlappedWindow(wz, left, top, right, x);

   255 				DrawOverlappedWindow(wz, left, x, right, bottom);

   256 				return;

   257 			}

   258 

   259 			return;

   260 		}

   261 	}

   262 

   263 	{

   264 		DrawPixelInfo *dp = _cur_dpi;

   265 		dp->width = right - left;

   266 		dp->height = bottom - top;

   267 		dp->left = left - (*wz)->left;

   268 		dp->top = top - (*wz)->top;

   269 		dp->pitch = _screen.pitch;

   270 		dp->dst_ptr = _screen.dst_ptr + top * _screen.pitch + left;

   271 		dp->zoom = 0;

   272 		CallWindowEventNP(*wz, WE_PAINT);

   273 	}

   274 }

   275 

   276 void CallWindowEventNP(Window *w, int event)

   277 {

   278 	WindowEvent e;

   279 

   280 	e.event = event;

   281 	w->wndproc(w, &e);

   282 }

   283 

   284 void SetWindowDirty(const Window *w)

   285 {

   286 	if (w == NULL) return;

   287 	SetDirtyBlocks(w->left, w->top, w->left + w->width, w->top + w->height);

   288 }

   289 

   290 /** Find the Window whose parent pointer points to this window

   291  * @parent w Window to find child of

   292  * @return return a Window pointer that is the child of w, or NULL otherwise */

   293 static Window *FindChildWindow(const Window *w)

   294 {

   295 	Window* const *wz;

   296 

   297 	FOR_ALL_WINDOWS(wz) {

   298 		Window *v = *wz;

   299 		if (v->parent == w) return v;

   300 	}

   301 

   302 	return NULL;

   303 }

   304 

   305 /** Find the z-value of a window. A window must already be open

   306  * or the behaviour is undefined but function should never fail */

   307 Window **FindWindowZPosition(const Window *w)

   308 {

   309 	Window **wz;

   310 

   311 	for (wz = _z_windows; wz != _last_z_window; wz++) {

   312 		if (*wz == w) return wz;

   313 	}

   314 

   315 	DEBUG(misc, 3, "Window (class %d, number %d) is not open, probably removed by recursive calls",

   316 		w->window_class, w->window_number);

   317 	return NULL;

   318 }

   319 

   320 void DeleteWindow(Window *w)

   321 {

   322 	Window *v;

   323 	Window **wz;

   324 	if (w == NULL) return;

   325 

   326 	/* Delete any children a window might have in a head-recursive manner */

   327 	v = FindChildWindow(w);

   328 	if (v != NULL) DeleteWindow(v);

   329 

   330 	if (_thd.place_mode != VHM_NONE &&

   331 			_thd.window_class == w->window_class &&

   332 			_thd.window_number == w->window_number) {

   333 		ResetObjectToPlace();

   334 	}

   335 

   336 	CallWindowEventNP(w, WE_DESTROY);

   337 	if (w->viewport != NULL) DeleteWindowViewport(w);

   338 

   339 	SetWindowDirty(w);

   340 	free(w->widget);

   341 	w->widget = NULL;

   342 	w->widget_count = 0;

   343 	w->parent = NULL;

   344 

   345 	/* Find the window in the z-array, and effectively remove it

   346 	 * by moving all windows after it one to the left */

   347 	wz = FindWindowZPosition(w);

   348 	if (wz == NULL) return;

   349 	memmove(wz, wz + 1, (byte*)_last_z_window - (byte*)wz);

   350 	_last_z_window--;

   351 }

   352 

   353 Window *FindWindowById(WindowClass cls, WindowNumber number)

   354 {

   355 	Window* const *wz;

   356 

   357 	FOR_ALL_WINDOWS(wz) {

   358 		Window *w = *wz;

   359 		if (w->window_class == cls && w->window_number == number) return w;

   360 	}

   361 

   362 	return NULL;

   363 }

   364 

   365 void DeleteWindowById(WindowClass cls, WindowNumber number)

   366 {

   367 	DeleteWindow(FindWindowById(cls, number));

   368 }

   369 

   370 void DeleteWindowByClass(WindowClass cls)

   371 {

   372 	Window* const *wz;

   373 

   374 restart_search:

   375 	/* When we find the window to delete, we need to restart the search

   376 	 * as deleting this window could cascade in deleting (many) others

   377 	 * anywhere in the z-array */

   378 	FOR_ALL_WINDOWS(wz) {

   379 		Window *w = *wz;

   380 		if (w->window_class == cls) {

   381 			DeleteWindow(w);

   382 			goto restart_search;

   383 		}

   384 	}

   385 }

   386 

   387 /** Delete all windows of a player. We identify windows of a player

   388  * by looking at the caption colour. If it is equal to the player ID

   389  * then we say the window belongs to the player and should be deleted

   390  * @param id PlayerID player identifier */

   391 void DeletePlayerWindows(PlayerID id)

   392 {

   393 	Window* const *wz;

   394 

   395 restart_search:

   396 	/* When we find the window to delete, we need to restart the search

   397 	 * as deleting this window could cascade in deleting (many) others

   398 	 * anywhere in the z-array */

   399 	FOR_ALL_WINDOWS(wz) {

   400 		Window *w = *wz;

   401 		if (w->caption_color == id) {

   402 			DeleteWindow(w);

   403 			goto restart_search;

   404 		}

   405 	}

   406 

   407 	/* Also delete the player specific windows, that don't have a player-colour */

   408 	DeleteWindowById(WC_BUY_COMPANY, id);

   409 }

   410 

   411 /** Change the owner of all the windows one player can take over from another

   412  * player in the case of a company merger. Do not change ownership of windows

   413  * that need to be deleted once takeover is complete

   414  * @param old_player PlayerID of original owner of the window

   415  * @param new_player PlayerID of the new owner of the window */

   416 void ChangeWindowOwner(PlayerID old_player, PlayerID new_player)

   417 {

   418 	Window* const *wz;

   419 

   420 	FOR_ALL_WINDOWS(wz) {

   421 		Window *w = *wz;

   422 

   423 		if (w->caption_color != old_player)      continue;

   424 		if (w->window_class == WC_PLAYER_COLOR)  continue;

   425 		if (w->window_class == WC_FINANCES)      continue;

   426 		if (w->window_class == WC_STATION_LIST)  continue;

   427 		if (w->window_class == WC_TRAINS_LIST)   continue;

   428 		if (w->window_class == WC_ROADVEH_LIST)  continue;

   429 		if (w->window_class == WC_SHIPS_LIST)    continue;

   430 		if (w->window_class == WC_AIRCRAFT_LIST) continue;

   431 		if (w->window_class == WC_BUY_COMPANY)   continue;

   432 		if (w->window_class == WC_COMPANY)       continue;

   433 

   434 		w->caption_color = new_player;

   435 	}

   436 }

   437 

   438 static void BringWindowToFront(const Window *w);

   439 

   440 /** Find a window and make it the top-window on the screen. The window

   441  * gets a white border for a brief period of time to visualize its

   442  * "activation"

   443  * @return a pointer to the window thus activated */

   444 Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)

   445 {

   446 	Window *w = FindWindowById(cls, number);

   447 

   448 	if (w != NULL) {

   449 		w->flags4 |= WF_WHITE_BORDER_MASK;

   450 		BringWindowToFront(w);

   451 		SetWindowDirty(w);

   452 	}

   453 

   454 	return w;

   455 }

   456 

   457 static inline bool IsVitalWindow(const Window *w)

   458 {

   459 	WindowClass wc = w->window_class;

   460 	return (wc == WC_MAIN_TOOLBAR || wc == WC_STATUS_BAR || wc == WC_NEWS_WINDOW || wc == WC_SEND_NETWORK_MSG);

   461 }

   462 

   463 /** On clicking on a window, make it the frontmost window of all. However

   464  * there are certain windows that always need to be on-top; these include

   465  * - Toolbar, Statusbar (always on)

   466  * - New window, Chatbar (only if open)

   467  * The window is marked dirty for a repaint if the window is actually moved

   468  * @param w window that is put into the foreground

   469  * @return pointer to the window, the same as the input pointer

   470  */

   471 static void BringWindowToFront(const Window *w)

   472 {

   473 	Window *tempz;

   474 	Window **wz = FindWindowZPosition(w);

   475 	Window **vz = _last_z_window;

   476 

   477 	/* Bring the window just below the vital windows */

   478 	do {

   479 		if (--vz < _z_windows) return;

   480 	} while (IsVitalWindow(*vz));

   481 

   482 	if (wz == vz) return; // window is already in the right position

   483 	assert(wz < vz);

   484 

   485 	tempz = *wz;

   486 	memmove(wz, wz + 1, (byte*)vz - (byte*)wz);

   487 	*vz = tempz;

   488 

   489 	SetWindowDirty(w);

   490 }

   491 

   492 /** We have run out of windows, so find a suitable candidate for replacement.

   493  * Keep all important windows intact. These are

   494  * - Main window (gamefield), Toolbar, Statusbar (always on)

   495  * - News window, Chatbar (when on)

   496  * - Any sticked windows since we wanted to keep these

   497  * @return w pointer to the window that is going to be deleted

   498  */

   499 static Window *FindDeletableWindow(void)

   500 {

   501 	Window* const *wz;

   502 

   503 	FOR_ALL_WINDOWS(wz) {

   504 		Window *w = *wz;

   505 		if (w->window_class != WC_MAIN_WINDOW && !IsVitalWindow(w) && !(w->flags4 & WF_STICKY)) {

   506 			return w;

   507 		}

   508 	}

   509 	return NULL;

   510 }

   511 

   512 /** A window must be freed, and all are marked as important windows. Ease the

   513  * restriction a bit by allowing to delete sticky windows. Keep important/vital

   514  * windows intact (Main window, Toolbar, Statusbar, News Window, Chatbar)

   515  * Start finding an appropiate candidate from the lowest z-values (bottom)

   516  * @see FindDeletableWindow()

   517  * @return w Pointer to the window that is being deleted

   518  */

   519 static Window *ForceFindDeletableWindow(void)

   520 {

   521 	Window* const *wz;

   522 

   523 	for (wz = _z_windows;; wz++) {

   524 		Window *w = *wz;

   525 		assert(wz < _last_z_window);

   526 		if (w->window_class != WC_MAIN_WINDOW && !IsVitalWindow(w)) return w;

   527 	}

   528 }

   529 

   530 bool IsWindowOfPrototype(const Window *w, const Widget *widget)

   531 {

   532 	return (w->original_widget == widget);

   533 }

   534 

   535 /* Copies 'widget' to 'w->widget' to allow for resizable windows */

   536 void AssignWidgetToWindow(Window *w, const Widget *widget)

   537 {

   538 	w->original_widget = widget;

   539 

   540 	if (widget != NULL) {

   541 		uint index = 1;

   542 		const Widget *wi;

   543 

   544 		for (wi = widget; wi->type != WWT_LAST; wi++) index++;

   545 

   546 		w->widget = realloc(w->widget, sizeof(*w->widget) * index);

   547 		memcpy(w->widget, widget, sizeof(*w->widget) * index);

   548 		w->widget_count = index - 1;

   549 	} else {

   550 		w->widget = NULL;

   551 		w->widget_count = 0;

   552 	}

   553 }

   554 

   555 static Window *FindFreeWindow(void)

   556 {

   557 	Window *w;

   558 

   559 	for (w = _windows; w < endof(_windows); w++) {

   560 		Window* const *wz;

   561 		bool window_in_use = false;

   562 

   563 		FOR_ALL_WINDOWS(wz) {

   564 			if (*wz == w) {

   565 				window_in_use = true;

   566 				break;

   567 			}

   568 		}

   569 

   570 		if (!window_in_use) return w;

   571 	}

   572 

   573 	assert(_last_z_window == endof(_z_windows));

   574 	return NULL;

   575 }

   576 

   577 /* Open a new window.

   578  * This function is called from AllocateWindow() or AllocateWindowDesc()

   579  * See descriptions for those functions for usage

   580  * See AllocateWindow() for description of arguments.

   581  * Only addition here is window_number, which is the window_number being assigned to the new window

   582  */

   583 static Window *LocalAllocateWindow(

   584 							int x, int y, int width, int height,

   585 							WindowProc *proc, WindowClass cls, const Widget *widget, int window_number)

   586 {

   587 	Window *w = FindFreeWindow();

   588 

   589 	/* We have run out of windows, close one and use that as the place for our new one */

   590 	if (w == NULL) {

   591 		w = FindDeletableWindow();

   592 		if (w == NULL) w = ForceFindDeletableWindow();

   593 		DeleteWindow(w);

   594 	}

   595 

   596 	// Set up window properties

   597 	memset(w, 0, sizeof(*w));

   598 	w->window_class = cls;

   599 	w->flags4 = WF_WHITE_BORDER_MASK; // just opened windows have a white border

   600 	w->caption_color = 0xFF;

   601 	w->left = x;

   602 	w->top = y;

   603 	w->width = width;

   604 	w->height = height;

   605 	w->wndproc = proc;

   606 	AssignWidgetToWindow(w, widget);

   607 	w->resize.width = width;

   608 	w->resize.height = height;

   609 	w->resize.step_width = 1;

   610 	w->resize.step_height = 1;

   611 	w->window_number = window_number;

   612 

   613 	{

   614 		Window **wz = _last_z_window;

   615 

   616 		/* Hacky way of specifying always-on-top windows. These windows are

   617 		 * always above other windows because they are moved below them.

   618 		 * status-bar is above news-window because it has been created earlier.

   619 		 * Also, as the chat-window is excluded from this, it will always be

   620 		 * the last window, thus always on top.

   621 		 * XXX - Yes, ugly, probably needs something like w->always_on_top flag

   622 		 * to implement correctly, but even then you need some kind of distinction

   623 		 * between on-top of chat/news and status windows, because these conflict */

   624 		if (wz != _z_windows && w->window_class != WC_SEND_NETWORK_MSG) {

   625 			if (FindWindowById(WC_MAIN_TOOLBAR, 0)     != NULL) wz--;

   626 			if (FindWindowById(WC_STATUS_BAR, 0)       != NULL) wz--;

   627 			if (FindWindowById(WC_NEWS_WINDOW, 0)      != NULL) wz--;

   628 			if (FindWindowById(WC_SEND_NETWORK_MSG, 0) != NULL) wz--;

   629 

   630 			assert(wz >= _z_windows);

   631 			if (wz != _last_z_window) memmove(wz + 1, wz, (byte*)_last_z_window - (byte*)wz);

   632 		}

   633 

   634 		*wz = w;

   635 		_last_z_window++;

   636 	}

   637 

   638 	SetWindowDirty(w);

   639 	CallWindowEventNP(w, WE_CREATE);

   640 

   641 	return w;

   642 }

   643 

   644 /**

   645  * Open a new window. If there is no space for a new window, close an open

   646  * window. Try to avoid stickied windows, but if there is no else, close one of

   647  * those as well. Then make sure all created windows are below some always-on-top

   648  * ones. Finally set all variables and call the WE_CREATE event

   649  * @param x offset in pixels from the left of the screen

   650  * @param y offset in pixels from the top of the screen

   651  * @param width width in pixels of the window

   652  * @param height height in pixels of the window

   653  * @param *proc @see WindowProc function to call when any messages/updates happen to the window

   654  * @param cls @see WindowClass class of the window, used for identification and grouping

   655  * @param *widget @see Widget pointer to the window layout and various elements

   656  * @return @see Window pointer of the newly created window

   657  */

   658 Window *AllocateWindow(

   659 							int x, int y, int width, int height,

   660 							WindowProc *proc, WindowClass cls, const Widget *widget)

   661 {

   662 	return LocalAllocateWindow(x, y, width, height, proc, cls, widget, 0);

   663 }

   664 

   665 typedef struct SizeRect {

   666 	int left,top,width,height;

   667 } SizeRect;

   668 

   669 

   670 static SizeRect _awap_r;

   671 

   672 static bool IsGoodAutoPlace1(int left, int top)

   673 {

   674 	int right,bottom;

   675 	Window* const *wz;

   676 

   677 	_awap_r.left= left;

   678 	_awap_r.top = top;

   679 	right = _awap_r.width + left;

   680 	bottom = _awap_r.height + top;

   681 

   682 	if (left < 0 || top < 22 || right > _screen.width || bottom > _screen.height)

   683 		return false;

   684 

   685 	// Make sure it is not obscured by any window.

   686 	FOR_ALL_WINDOWS(wz) {

   687 		const Window *w = *wz;

   688 		if (w->window_class == WC_MAIN_WINDOW) continue;

   689 

   690 		if (right > w->left &&

   691 				w->left + w->width > left &&

   692 				bottom > w->top &&

   693 				w->top + w->height > top) {

   694 			return false;

   695 		}

   696 	}

   697 

   698 	return true;

   699 }

   700 

   701 static bool IsGoodAutoPlace2(int left, int top)

   702 {

   703 	int width,height;

   704 	Window* const *wz;

   705 

   706 	_awap_r.left= left;

   707 	_awap_r.top = top;

   708 	width = _awap_r.width;

   709 	height = _awap_r.height;

   710 

   711 	if (left < -(width>>2) || left > _screen.width - (width>>1)) return false;

   712 	if (top < 22 || top > _screen.height - (height>>2)) return false;

   713 

   714 	// Make sure it is not obscured by any window.

   715 	FOR_ALL_WINDOWS(wz) {

   716 		const Window *w = *wz;

   717 		if (w->window_class == WC_MAIN_WINDOW) continue;

   718 

   719 		if (left + width > w->left &&

   720 				w->left + w->width > left &&

   721 				top + height > w->top &&

   722 				w->top + w->height > top) {

   723 			return false;

   724 		}

   725 	}

   726 

   727 	return true;

   728 }

   729 

   730 static Point GetAutoPlacePosition(int width, int height)

   731 {

   732 	Window* const *wz;

   733 	Point pt;

   734 

   735 	_awap_r.width = width;

   736 	_awap_r.height = height;

   737 

   738 	if (IsGoodAutoPlace1(0, 24)) goto ok_pos;

   739 

   740 	FOR_ALL_WINDOWS(wz) {

   741 		const Window *w = *wz;

   742 		if (w->window_class == WC_MAIN_WINDOW) continue;

   743 

   744 		if (IsGoodAutoPlace1(w->left+w->width+2,w->top)) goto ok_pos;

   745 		if (IsGoodAutoPlace1(w->left-   width-2,w->top)) goto ok_pos;

   746 		if (IsGoodAutoPlace1(w->left,w->top+w->height+2)) goto ok_pos;

   747 		if (IsGoodAutoPlace1(w->left,w->top-   height-2)) goto ok_pos;

   748 		if (IsGoodAutoPlace1(w->left+w->width+2,w->top+w->height-height)) goto ok_pos;

   749 		if (IsGoodAutoPlace1(w->left-   width-2,w->top+w->height-height)) goto ok_pos;

   750 		if (IsGoodAutoPlace1(w->left+w->width-width,w->top+w->height+2)) goto ok_pos;

   751 		if (IsGoodAutoPlace1(w->left+w->width-width,w->top-   height-2)) goto ok_pos;

   752 	}

   753 

   754 	FOR_ALL_WINDOWS(wz) {

   755 		const Window *w = *wz;

   756 		if (w->window_class == WC_MAIN_WINDOW) continue;

   757 

   758 		if (IsGoodAutoPlace2(w->left+w->width+2,w->top)) goto ok_pos;

   759 		if (IsGoodAutoPlace2(w->left-   width-2,w->top)) goto ok_pos;

   760 		if (IsGoodAutoPlace2(w->left,w->top+w->height+2)) goto ok_pos;

   761 		if (IsGoodAutoPlace2(w->left,w->top-   height-2)) goto ok_pos;

   762 	}

   763 

   764 	{

   765 		int left=0,top=24;

   766 

   767 restart:;

   768 		FOR_ALL_WINDOWS(wz) {

   769 			const Window *w = *wz;

   770 

   771 			if (w->left == left && w->top == top) {

   772 				left += 5;

   773 				top += 5;

   774 				goto restart;

   775 			}

   776 		}

   777 

   778 		pt.x = left;

   779 		pt.y = top;

   780 		return pt;

   781 	}

   782 

   783 ok_pos:;

   784 	pt.x = _awap_r.left;

   785 	pt.y = _awap_r.top;

   786 	return pt;

   787 }

   788 

   789 static Window *LocalAllocateWindowDesc(const WindowDesc *desc, int window_number)

   790 {

   791 	Point pt;

   792 	Window *w;

   793 

   794 	/* By default position a child window at an offset of 10/10 of its parent.

   795 	 * However if it falls too extremely outside window positions, reposition

   796 	 * it to an automatic place */

   797 	if (desc->parent_cls != 0 /* WC_MAIN_WINDOW */ &&

   798 			(w = FindWindowById(desc->parent_cls, window_number)) != NULL &&

   799 			w->left < _screen.width - 20 && w->left > -60 && w->top < _screen.height - 20) {

   800 

   801 		pt.x = w->left + 10;

   802 		if (pt.x > _screen.width + 10 - desc->width) {

   803 			pt.x = (_screen.width + 10 - desc->width) - 20;

   804 		}

   805 		pt.y = w->top + 10;

   806 	} else {

   807 		switch (desc->left) {

   808 			case WDP_ALIGN_TBR: { /* Align the right side with the top toolbar */

   809 				w = FindWindowById(WC_MAIN_TOOLBAR, 0);

   810 				pt.x = (w->left + w->width) - desc->width;

   811 			}	break;

   812 			case WDP_ALIGN_TBL: /* Align the left side with the top toolbar */

   813 				pt.x = FindWindowById(WC_MAIN_TOOLBAR, 0)->left;

   814 				break;

   815 			case WDP_AUTO: /* Find a good automatic position for the window */

   816 				pt = GetAutoPlacePosition(desc->width, desc->height);

   817 				goto allocate_window;

   818 			case WDP_CENTER: /* Centre the window horizontally */

   819 				pt.x = (_screen.width - desc->width) / 2;

   820 				break;

   821 			default:

   822 				pt.x = desc->left;

   823 				if (pt.x < 0) pt.x += _screen.width; // negative is from right of the screen

   824 		}

   825 

   826 		switch (desc->top) {

   827 			case WDP_CENTER: /* Centre the window vertically */

   828 				pt.y = (_screen.height - desc->height) / 2;

   829 				break;

   830 			/* WDP_AUTO sets the position at once and is controlled by desc->left.

   831 			 * Both left and top must be set to WDP_AUTO */

   832 			case WDP_AUTO:

   833 				NOT_REACHED();

   834 				assert(desc->left == WDP_AUTO && desc->top != WDP_AUTO);

   835 				/* fallthrough */

   836 			default:

   837 				pt.y = desc->top;

   838 				if (pt.y < 0) pt.y += _screen.height; // negative is from bottom of the screen

   839 				break;

   840 		}

   841 	}

   842 

   843 allocate_window:

   844 	w = LocalAllocateWindow(pt.x, pt.y, desc->width, desc->height, desc->proc, desc->cls, desc->widgets, window_number);

   845 	w->desc_flags = desc->flags;

   846 	return w;

   847 }

   848 

   849 /**

   850  * Open a new window.

   851  * @param *desc The pointer to the WindowDesc to be created

   852  * @return @see Window pointer of the newly created window

   853  */

   854 Window *AllocateWindowDesc(const WindowDesc *desc)

   855 {

   856 	return LocalAllocateWindowDesc(desc, 0);

   857 }

   858 

   859 /**

   860  * Open a new window.

   861  * @param *desc The pointer to the WindowDesc to be created

   862  * @param window_number the window number of the new window

   863  * @return @see Window pointer of the newly created window

   864  */

   865 Window *AllocateWindowDescFront(const WindowDesc *desc, int window_number)

   866 {

   867 	Window *w;

   868 

   869 	if (BringWindowToFrontById(desc->cls, window_number)) return NULL;

   870 	w = LocalAllocateWindowDesc(desc, window_number);

   871 	return w;

   872 }

   873 

   874 /** Do a search for a window at specific coordinates. For this we start

   875  * at the topmost window, obviously and work our way down to the bottom

   876  * @return a pointer to the found window if any, NULL otherwise */

   877 Window *FindWindowFromPt(int x, int y)

   878 {

   879 	Window* const *wz;

   880 

   881 	for (wz = _last_z_window; wz != _z_windows;) {

   882 		Window *w = *--wz;

   883 		if (IS_INSIDE_1D(x, w->left, w->width) && IS_INSIDE_1D(y, w->top, w->height)) {

   884 			return w;

   885 		}

   886 	}

   887 

   888 	return NULL;

   889 }

   890 

   891 void InitWindowSystem(void)

   892 {

   893 	IConsoleClose();

   894 

   895 	memset(&_windows, 0, sizeof(_windows));

   896 	_last_z_window = _z_windows;

   897 	InitViewports();

   898 	_no_scroll = 0;

   899 }

   900 

   901 void UnInitWindowSystem(void)

   902 {

   903 	Window **wz;

   904 	/* Delete all malloced widgets, and reset z-array */

   905 	FOR_ALL_WINDOWS(wz) {

   906 		free((*wz)->widget);

   907 		(*wz)->widget = NULL;

   908 		(*wz)->widget_count = 0;

   909 		*wz = NULL;

   910 	}

   911 	_last_z_window = _z_windows;

   912 }

   913 

   914 void ResetWindowSystem(void)

   915 {

   916 	UnInitWindowSystem();

   917 	InitWindowSystem();

   918 	_thd.pos.x = 0;

   919 	_thd.pos.y = 0;

   920 	_thd.new_pos.x = 0;

   921 	_thd.new_pos.y = 0;

   922 }

   923 

   924 static void DecreaseWindowCounters(void)

   925 {

   926 	Window *w;

   927 	Window* const *wz;

   928 

   929 	for (wz = _last_z_window; wz != _z_windows;) {

   930 		w = *--wz;

   931 		// Unclick scrollbar buttons if they are pressed.

   932 		if (w->flags4 & (WF_SCROLL_DOWN | WF_SCROLL_UP)) {

   933 			w->flags4 &= ~(WF_SCROLL_DOWN | WF_SCROLL_UP);

   934 			SetWindowDirty(w);

   935 		}

   936 		CallWindowEventNP(w, WE_MOUSELOOP);

   937 	}

   938 

   939 	for (wz = _last_z_window; wz != _z_windows;) {

   940 		w = *--wz;

   941 

   942 		if (w->flags4&WF_TIMEOUT_MASK && !(--w->flags4&WF_TIMEOUT_MASK)) {

   943 			CallWindowEventNP(w, WE_TIMEOUT);

   944 			if (w->desc_flags & WDF_UNCLICK_BUTTONS) RaiseWindowButtons(w);

   945 		}

   946 	}

   947 }

   948 

   949 Window *GetCallbackWnd(void)

   950 {

   951 	return FindWindowById(_thd.window_class, _thd.window_number);

   952 }

   953 

   954 static void HandlePlacePresize(void)

   955 {

   956 	Window *w;

   957 	WindowEvent e;

   958 

   959 	if (_special_mouse_mode != WSM_PRESIZE) return;

   960 

   961 	w = GetCallbackWnd();

   962 	if (w == NULL) return;

   963 

   964 	e.we.place.pt = GetTileBelowCursor();

   965 	if (e.we.place.pt.x == -1) {

   966 		_thd.selend.x = -1;

   967 		return;

   968 	}

   969 	e.we.place.tile = TileVirtXY(e.we.place.pt.x, e.we.place.pt.y);

   970 	e.event = WE_PLACE_PRESIZE;

   971 	w->wndproc(w, &e);

   972 }

   973 

   974 static bool HandleDragDrop(void)

   975 {

   976 	Window *w;

   977 	WindowEvent e;

   978 

   979 	if (_special_mouse_mode != WSM_DRAGDROP) return true;

   980 

   981 	if (_left_button_down) return false;

   982 

   983 	w = GetCallbackWnd();

   984 

   985 	ResetObjectToPlace();

   986 

   987 	if (w != NULL) {

   988 		// send an event in client coordinates.

   989 		e.event = WE_DRAGDROP;

   990 		e.we.dragdrop.pt.x = _cursor.pos.x - w->left;

   991 		e.we.dragdrop.pt.y = _cursor.pos.y - w->top;

   992 		e.we.dragdrop.widget = GetWidgetFromPos(w, e.we.dragdrop.pt.x, e.we.dragdrop.pt.y);

   993 		w->wndproc(w, &e);

   994 	}

   995 	return false;

   996 }

   997 

   998 static bool HandlePopupMenu(void)

   999 {

  1000 	Window *w;

  1001 	WindowEvent e;

  1002 

  1003 	if (!_popup_menu_active) return true;

  1004 

  1005 	w = FindWindowById(WC_TOOLBAR_MENU, 0);

  1006 	if (w == NULL) {

  1007 		_popup_menu_active = false;

  1008 		return false;

  1009 	}

  1010 

  1011 	if (_left_button_down) {

  1012 		e.event = WE_POPUPMENU_OVER;

  1013 		e.we.popupmenu.pt = _cursor.pos;

  1014 	} else {

  1015 		_popup_menu_active = false;

  1016 		e.event = WE_POPUPMENU_SELECT;

  1017 		e.we.popupmenu.pt = _cursor.pos;

  1018 	}

  1019 

  1020 	w->wndproc(w, &e);

  1021 

  1022 	return false;

  1023 }

  1024 

  1025 static bool HandleMouseOver(void)

  1026 {

  1027 	Window *w;

  1028 	WindowEvent e;

  1029 	static Window *last_w = NULL;

  1030 

  1031 	w = FindWindowFromPt(_cursor.pos.x, _cursor.pos.y);

  1032 

  1033 	// We changed window, put a MOUSEOVER event to the last window

  1034 	if (last_w != NULL && last_w != w) {

  1035 		e.event = WE_MOUSEOVER;

  1036 		e.we.mouseover.pt.x = -1;

  1037 		e.we.mouseover.pt.y = -1;

  1038 		if (last_w->wndproc) last_w->wndproc(last_w, &e);

  1039 	}

  1040 	last_w = w;

  1041 

  1042 	if (w != NULL) {

  1043 		// send an event in client coordinates.

  1044 		e.event = WE_MOUSEOVER;

  1045 		e.we.mouseover.pt.x = _cursor.pos.x - w->left;

  1046 		e.we.mouseover.pt.y = _cursor.pos.y - w->top;

  1047 		if (w->widget != NULL) {

  1048 			e.we.mouseover.widget = GetWidgetFromPos(w, e.we.mouseover.pt.x, e.we.mouseover.pt.y);

  1049 		}

  1050 		w->wndproc(w, &e);

  1051 	}

  1052 

  1053 	// Mouseover never stops execution

  1054 	return true;

  1055 }

  1056 

  1057 /** Update all the widgets of a window based on their resize flags

  1058  * Both the areas of the old window and the new sized window are set dirty

  1059  * ensuring proper redrawal.

  1060  * @param w Window to resize

  1061  * @param x delta x-size of changed window (positive if larger, etc.(

  1062  * @param y delta y-size of changed window */

  1063 void ResizeWindow(Window *w, int x, int y)

  1064 {

  1065 	Widget *wi;

  1066 	bool resize_height = false;

  1067 	bool resize_width = false;

  1068 

  1069 	if (x == 0 && y == 0) return;

  1070 

  1071 	SetWindowDirty(w);

  1072 	for (wi = w->widget; wi->type != WWT_LAST; wi++) {

  1073 		/* Isolate the resizing flags */

  1074 		byte rsizeflag = GB(wi->display_flags, 0, 4);

  1075 

  1076 		if (rsizeflag == RESIZE_NONE) continue;

  1077 

  1078 		/* Resize the widget based on its resize-flag */

  1079 		if (rsizeflag & RESIZE_LEFT) {

  1080 			wi->left += x;

  1081 			resize_width = true;

  1082 		}

  1083 

  1084 		if (rsizeflag & RESIZE_RIGHT) {

  1085 			wi->right += x;

  1086 			resize_width = true;

  1087 		}

  1088 

  1089 		if (rsizeflag & RESIZE_TOP) {

  1090 			wi->top += y;

  1091 			resize_height = true;

  1092 		}

  1093 

  1094 		if (rsizeflag & RESIZE_BOTTOM) {

  1095 			wi->bottom += y;

  1096 			resize_height = true;

  1097 		}

  1098 	}

  1099 

  1100 	/* We resized at least 1 widget, so let's resize the window totally */

  1101 	if (resize_width)  w->width  += x;

  1102 	if (resize_height) w->height += y;

  1103 

  1104 	SetWindowDirty(w);

  1105 }

  1106 

  1107 static bool _dragging_window;

  1108 

  1109 static bool HandleWindowDragging(void)

  1110 {

  1111 	Window* const *wz;

  1112 	// Get out immediately if no window is being dragged at all.

  1113 	if (!_dragging_window) return true;

  1114 

  1115 	// Otherwise find the window...

  1116 	FOR_ALL_WINDOWS(wz) {

  1117 		Window *w = *wz;

  1118 

  1119 		if (w->flags4 & WF_DRAGGING) {

  1120 			const Widget *t = &w->widget[1]; // the title bar ... ugh

  1121 			const Window *v;

  1122 			int x;

  1123 			int y;

  1124 			int nx;

  1125 			int ny;

  1126 

  1127 			// Stop the dragging if the left mouse button was released

  1128 			if (!_left_button_down) {

  1129 				w->flags4 &= ~WF_DRAGGING;

  1130 				break;

  1131 			}

  1132 

  1133 			SetWindowDirty(w);

  1134 

  1135 			x = _cursor.pos.x + _drag_delta.x;

  1136 			y = _cursor.pos.y + _drag_delta.y;