# window.cpp

Go to the documentation of this file.

    00001 /* $Id$ */
    00002
    00003 /*
    00004  * This file is part of OpenTTD.
    00005  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
    00006  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    00007  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
    00008  */
    00009
    00012 #include "stdafx.h"
    00013 #include <stdarg.h>
    00014 #include "company_func.h"
    00015 #include "gfx_func.h"
    00016 #include "console_func.h"
    00017 #include "console_gui.h"
    00018 #include "viewport_func.h"
    00019 #include "genworld.h"
    00020 #include "blitter/factory.hpp"
    00021 #include "zoom_func.h"
    00022 #include "vehicle_base.h"
    00023 #include "window_func.h"
    00024 #include "tilehighlight_func.h"
    00025 #include "network/network.h"
    00026 #include "querystring_gui.h"
    00027 #include "widgets/dropdown_func.h"
    00028 #include "strings_func.h"
    00029 #include "settings_type.h"
    00030 #include "newgrf_debug.h"
    00031 #include "hotkeys.h"
    00032 #include "toolbar_gui.h"
    00033 #include "statusbar_gui.h"
    00034
    00035
    00036 static Point _drag_delta;
    00037 static Window *_mouseover_last_w = NULL;
    00038 static Window *_last_scroll_window = NULL;
    00039
    00041 Window *_z_front_window = NULL;
    00043 Window *_z_back_window  = NULL;
    00044
    00045 /*
    00046  * Window that currently has focus. - The main purpose is to generate
    00047  * #FocusLost events, not to give next window in z-order focus when a
    00048  * window is closed.
    00049  */
    00050 Window *_focused_window;
    00051
    00052 Point _cursorpos_drag_start;
    00053
    00054 int _scrollbar_start_pos;
    00055 int _scrollbar_size;
    00056 byte _scroller_click_timeout = 0;
    00057
    00058 bool _scrolling_viewport;
    00059 bool _mouse_hovering;
    00060
    00061 SpecialMouseMode _special_mouse_mode;
    00062
    00064 WindowDesc::WindowDesc(WindowPosition def_pos, int16 def_width, int16 def_height,
    00065       WindowClass window_class, WindowClass parent_class, uint32 flags,
    00066       const NWidgetPart *nwid_parts, int16 nwid_length) :
    00067   default_pos(def_pos),
    00068   default_width(def_width),
    00069   default_height(def_height),
    00070   cls(window_class),
    00071   parent_cls(parent_class),
    00072   flags(flags),
    00073   nwid_parts(nwid_parts),
    00074   nwid_length(nwid_length)
    00075 {
    00076 }
    00077
    00078 WindowDesc::~WindowDesc()
    00079 {
    00080 }
    00081
    00091 int Window::GetRowFromWidget(int clickpos, int widget, int padding, int line_height) const
    00092 {
    00093   const NWidgetBase *wid = this->GetWidget<NWidgetBase>(widget);
    00094   if (line_height < 0) line_height = wid->resize_y;
    00095   if (clickpos < (int)wid->pos_y + padding) return INT_MAX;
    00096   return (clickpos - (int)wid->pos_y - padding) / line_height;
    00097 }
    00098
    00104 const Scrollbar *Window::GetScrollbar(uint widnum) const
    00105 {
    00106   return this->GetWidget<NWidgetScrollbar>(widnum);
    00107 }
    00108
    00114 Scrollbar *Window::GetScrollbar(uint widnum)
    00115 {
    00116   return this->GetWidget<NWidgetScrollbar>(widnum);
    00117 }
    00118
    00119
    00124 void SetFocusedWindow(Window *w)
    00125 {
    00126   if (_focused_window == w) return;
    00127
    00128   /* Invalidate focused widget */
    00129   if (_focused_window != NULL) {
    00130     if (_focused_window->nested_focus != NULL) _focused_window->nested_focus->SetDirty(_focused_window);
    00131   }
    00132
    00133   /* Remember which window was previously focused */
    00134   Window *old_focused = _focused_window;
    00135   _focused_window = w;
    00136
    00137   /* So we can inform it that it lost focus */
    00138   if (old_focused != NULL) old_focused->OnFocusLost();
    00139   if (_focused_window != NULL) _focused_window->OnFocus();
    00140 }
    00141
    00147 static bool EditBoxInGlobalFocus()
    00148 {
    00149   if (_focused_window == NULL) return false;
    00150
    00151   /* The console does not have an edit box so a special case is needed. */
    00152   if (_focused_window->window_class == WC_CONSOLE) return true;
    00153
    00154   return _focused_window->nested_focus != NULL && _focused_window->nested_focus->type == WWT_EDITBOX;
    00155 }
    00156
    00160 void Window::UnfocusFocusedWidget()
    00161 {
    00162   if (this->nested_focus != NULL) {
    00163     /* Repaint the widget that lost focus. A focused edit box may else leave the caret on the screen. */
    00164     this->nested_focus->SetDirty(this);
    00165     this->nested_focus = NULL;
    00166   }
    00167 }
    00168
    00174 bool Window::SetFocusedWidget(byte widget_index)
    00175 {
    00176   /* Do nothing if widget_index is already focused, or if it wasn't a valid widget. */
    00177   if (widget_index >= this->nested_array_size) return false;
    00178
    00179   assert(this->nested_array[widget_index] != NULL); // Setting focus to a non-existing widget is a bad idea.
    00180   if (this->nested_focus != NULL) {
    00181     if (this->GetWidget<NWidgetCore>(widget_index) == this->nested_focus) return false;
    00182
    00183     /* Repaint the widget that lost focus. A focused edit box may else leave the caret on the screen. */
    00184     this->nested_focus->SetDirty(this);
    00185   }
    00186   this->nested_focus = this->GetWidget<NWidgetCore>(widget_index);
    00187   return true;
    00188 }
    00189
    00197 void CDECL Window::SetWidgetsDisabledState(bool disab_stat, int widgets, ...)
    00198 {
    00199   va_list wdg_list;
    00200
    00201   va_start(wdg_list, widgets);
    00202
    00203   while (widgets != WIDGET_LIST_END) {
    00204     SetWidgetDisabledState(widgets, disab_stat);
    00205     widgets = va_arg(wdg_list, int);
    00206   }
    00207
    00208   va_end(wdg_list);
    00209 }
    00210
    00216 void CDECL Window::SetWidgetsLoweredState(bool lowered_stat, int widgets, ...)
    00217 {
    00218   va_list wdg_list;
    00219
    00220   va_start(wdg_list, widgets);
    00221
    00222   while (widgets != WIDGET_LIST_END) {
    00223     SetWidgetLoweredState(widgets, lowered_stat);
    00224     widgets = va_arg(wdg_list, int);
    00225   }
    00226
    00227   va_end(wdg_list);
    00228 }
    00229
    00234 void Window::RaiseButtons(bool autoraise)
    00235 {
    00236   for (uint i = 0; i < this->nested_array_size; i++) {
    00237     if (this->nested_array[i] != NULL && (this->nested_array[i]->type & ~WWB_PUSHBUTTON) < WWT_LAST &&
    00238         (!autoraise || (this->nested_array[i]->type & WWB_PUSHBUTTON)) && this->IsWidgetLowered(i)) {
    00239       this->RaiseWidget(i);
    00240       this->SetWidgetDirty(i);
    00241     }
    00242   }
    00243 }
    00244
    00249 void Window::SetWidgetDirty(byte widget_index) const
    00250 {
    00251   /* Sometimes this function is called before the window is even fully initialized */
    00252   if (this->nested_array == NULL) return;
    00253
    00254   this->nested_array[widget_index]->SetDirty(this);
    00255 }
    00256
    00262 void Window::HandleButtonClick(byte widget)
    00263 {
    00264   this->LowerWidget(widget);
    00265   this->flags4 |= WF_TIMEOUT_BEGIN;
    00266   this->SetWidgetDirty(widget);
    00267 }
    00268
    00269 static void StartWindowDrag(Window *w);
    00270 static void StartWindowSizing(Window *w, bool to_left);
    00271
    00279 static void DispatchLeftClickEvent(Window *w, int x, int y, int click_count)
    00280 {
    00281   NWidgetCore *nw = w->nested_root->GetWidgetFromPos(x, y);
    00282   WidgetType widget_type = (nw != NULL) ? nw->type : WWT_EMPTY;
    00283
    00284   bool focused_widget_changed = false;
    00285   /* If clicked on a window that previously did dot have focus */
    00286   if (_focused_window != w &&                 // We already have focus, right?
    00287       (w->desc_flags & WDF_NO_FOCUS) == 0 &&  // Don't lose focus to toolbars
    00288       widget_type != WWT_CLOSEBOX) {          // Don't change focused window if 'X' (close button) was clicked
    00289     focused_widget_changed = true;
    00290     if (_focused_window != NULL) {
    00291       _focused_window->OnFocusLost();
    00292
    00293       /* The window that lost focus may have had opened a OSK, window so close it, unless the user has clicked on the OSK window. */
    00294       if (w->window_class != WC_OSK) DeleteWindowById(WC_OSK, 0);
    00295     }
    00296     SetFocusedWindow(w);
    00297     w->OnFocus();
    00298   }
    00299
    00300   if (nw == NULL) return; // exit if clicked outside of widgets
    00301
    00302   /* don't allow any interaction if the button has been disabled */
    00303   if (nw->IsDisabled()) return;
    00304
    00305   int widget_index = nw->index;
    00306
    00307   /* Clicked on a widget that is not disabled.
    00308    * So unless the clicked widget is the caption bar, change focus to this widget */
    00309   if (widget_type != WWT_CAPTION) {
    00310     /* Close the OSK window if a edit box loses focus */
    00311     if (w->nested_focus != NULL &&  w->nested_focus->type == WWT_EDITBOX && w->nested_focus != nw && w->window_class != WC_OSK) {
    00312       DeleteWindowById(WC_OSK, 0);
    00313     }
    00314
    00315     /* focused_widget_changed is 'now' only true if the window this widget
    00316      * is in gained focus. In that case it must remain true, also if the
    00317      * local widget focus did not change. As such it's the logical-or of
    00318      * both changed states.
    00319      *
    00320      * If this is not preserved, then the OSK window would be opened when
    00321      * a user has the edit box focused and then click on another window and
    00322      * then back again on the edit box (to type some text).
    00323      */
    00324     focused_widget_changed |= w->SetFocusedWidget(widget_index);
    00325   }
    00326
    00327   /* Close any child drop down menus. If the button pressed was the drop down
    00328    * list's own button, then we should not process the click any further. */
    00329   if (HideDropDownMenu(w) == widget_index && widget_index >= 0) return;
    00330
    00331   if ((widget_type & ~WWB_PUSHBUTTON) < WWT_LAST && (widget_type & WWB_PUSHBUTTON)) w->HandleButtonClick(widget_index);
    00332
    00333   switch (widget_type) {
    00334     case NWID_VSCROLLBAR:
    00335     case NWID_HSCROLLBAR:
    00336       ScrollbarClickHandler(w, nw, x, y);
    00337       break;
    00338
    00339     case WWT_EDITBOX:
    00340       if (!focused_widget_changed) { // Only open the OSK window if clicking on an already focused edit box
    00341         /* Open the OSK window if clicked on an edit box */
    00342         QueryStringBaseWindow *qs = dynamic_cast<QueryStringBaseWindow *>(w);
    00343         if (qs != NULL) {
    00344           qs->OnOpenOSKWindow(widget_index);
    00345         }
    00346       }
    00347       break;
    00348
    00349     case WWT_CLOSEBOX: // 'X'
    00350       delete w;
    00351       return;
    00352
    00353     case WWT_CAPTION: // 'Title bar'
    00354       StartWindowDrag(w);
    00355       return;
    00356
    00357     case WWT_RESIZEBOX:
    00358       /* When the resize widget is on the left size of the window
    00359        * we assume that that button is used to resize to the left. */
    00360       StartWindowSizing(w, (int)nw->pos_x < (w->width / 2));
    00361       nw->SetDirty(w);
    00362       return;
    00363
    00364     case WWT_DEBUGBOX:
    00365       w->ShowNewGRFInspectWindow();
    00366       break;
    00367
    00368     case WWT_SHADEBOX:
    00369       nw->SetDirty(w);
    00370       w->SetShaded(!w->IsShaded());
    00371       return;
    00372
    00373     case WWT_STICKYBOX:
    00374       w->flags4 ^= WF_STICKY;
    00375       nw->SetDirty(w);
    00376       return;
    00377
    00378     default:
    00379       break;
    00380   }
    00381
    00382   /* Widget has no index, so the window is not interested in it. */
    00383   if (widget_index < 0) return;
    00384
    00385   Point pt = { x, y };
    00386   w->OnClick(pt, widget_index, click_count);
    00387 }
    00388
    00395 static void DispatchRightClickEvent(Window *w, int x, int y)
    00396 {
    00397   NWidgetCore *wid = w->nested_root->GetWidgetFromPos(x, y);
    00398   if (wid == NULL) return;
    00399
    00400   /* No widget to handle, or the window is not interested in it. */
    00401   if (wid->index >= 0) {
    00402     Point pt = { x, y };
    00403     if (w->OnRightClick(pt, wid->index)) return;
    00404   }
    00405
    00406   if (_settings_client.gui.hover_delay == 0 && wid->tool_tip != 0) GuiShowTooltips(w, wid->tool_tip, 0, NULL, TCC_RIGHT_CLICK);
    00407 }
    00408
    00415 static void DispatchHoverEvent(Window *w, int x, int y)
    00416 {
    00417   NWidgetCore *wid = w->nested_root->GetWidgetFromPos(x, y);
    00418
    00419   /* No widget to handle */
    00420   if (wid == NULL) return;
    00421
    00422   /* Show the tooltip if there is any */
    00423   if (wid->tool_tip != 0) {
    00424     GuiShowTooltips(w, wid->tool_tip);
    00425     return;
    00426   }
    00427
    00428   /* Widget has no index, so the window is not interested in it. */
    00429   if (wid->index < 0) return;
    00430
    00431   Point pt = { x, y };
    00432   w->OnHover(pt, wid->index);
    00433 }
    00434
    00442 static void DispatchMouseWheelEvent(Window *w, NWidgetCore *nwid, int wheel)
    00443 {
    00444   if (nwid == NULL) return;
    00445
    00446   /* Using wheel on caption/shade-box shades or unshades the window. */
    00447   if (nwid->type == WWT_CAPTION || nwid->type == WWT_SHADEBOX) {
    00448     w->SetShaded(wheel < 0);
    00449     return;
    00450   }
    00451
    00452   /* Wheeling a vertical scrollbar. */
    00453   if (nwid->type == NWID_VSCROLLBAR) {
    00454     NWidgetScrollbar *sb = static_cast<NWidgetScrollbar *>(nwid);
    00455     if (sb->GetCount() > sb->GetCapacity()) {
    00456       sb->UpdatePosition(wheel);
    00457       w->SetDirty();
    00458     }
    00459     return;
    00460   }
    00461
    00462   /* Scroll the widget attached to the scrollbar. */
    00463   Scrollbar *sb = (nwid->scrollbar_index >= 0 ? w->GetScrollbar(nwid->scrollbar_index) : NULL);
    00464   if (sb != NULL && sb->GetCount() > sb->GetCapacity()) {
    00465     sb->UpdatePosition(wheel);
    00466     w->SetDirty();
    00467   }
    00468 }
    00469
    00482 static void DrawOverlappedWindow(Window *w, int left, int top, int right, int bottom)
    00483 {
    00484   const Window *v;
    00485   FOR_ALL_WINDOWS_FROM_BACK_FROM(v, w->z_front) {
    00486     if (right > v->left &&
    00487         bottom > v->top &&
    00488         left < v->left + v->width &&
    00489         top < v->top + v->height) {
    00490       /* v and rectangle intersect with eeach other */
    00491       int x;
    00492
    00493       if (left < (x = v->left)) {
    00494         DrawOverlappedWindow(w, left, top, x, bottom);
    00495         DrawOverlappedWindow(w, x, top, right, bottom);
    00496         return;
    00497       }
    00498
    00499       if (right > (x = v->left + v->width)) {
    00500         DrawOverlappedWindow(w, left, top, x, bottom);
    00501         DrawOverlappedWindow(w, x, top, right, bottom);
    00502         return;
    00503       }
    00504
    00505       if (top < (x = v->top)) {
    00506         DrawOverlappedWindow(w, left, top, right, x);
    00507         DrawOverlappedWindow(w, left, x, right, bottom);
    00508         return;
    00509       }
    00510
    00511       if (bottom > (x = v->top + v->height)) {
    00512         DrawOverlappedWindow(w, left, top, right, x);
    00513         DrawOverlappedWindow(w, left, x, right, bottom);
    00514         return;
    00515       }
    00516
    00517       return;
    00518     }
    00519   }
    00520
    00521   /* Setup blitter, and dispatch a repaint event to window *wz */
    00522   DrawPixelInfo *dp = _cur_dpi;
    00523   dp->width = right - left;
    00524   dp->height = bottom - top;
    00525   dp->left = left - w->left;
    00526   dp->top = top - w->top;
    00527   dp->pitch = _screen.pitch;
    00528   dp->dst_ptr = BlitterFactoryBase::GetCurrentBlitter()->MoveTo(_screen.dst_ptr, left, top);
    00529   dp->zoom = ZOOM_LVL_NORMAL;
    00530   w->OnPaint();
    00531 }
    00532
    00541 void DrawOverlappedWindowForAll(int left, int top, int right, int bottom)
    00542 {
    00543   Window *w;
    00544   DrawPixelInfo bk, *old_dpi;
    00545   old_dpi = _cur_dpi;
    00546   /* GT TODO: find out why the game signals 11 if we don't backup _cur_dpi here */
    00547   _cur_dpi = &bk;
    00548
    00549   FOR_ALL_WINDOWS_FROM_BACK(w) {
    00550     if (right > w->left &&
    00551         bottom > w->top &&
    00552         left < w->left + w->width &&
    00553         top < w->top + w->height) {
    00554       /* Window w intersects with the rectangle => needs repaint */
    00555       DrawOverlappedWindow(w, left, top, right, bottom);
    00556     }
    00557   }
    00558   _cur_dpi = old_dpi;
    00559 }
    00560
    00565 void Window::SetDirty() const
    00566 {
    00567   SetDirtyBlocks(this->left, this->top, this->left + this->width, this->top + this->height);
    00568 }
    00569
    00576 void Window::ReInit(int rx, int ry)
    00577 {
    00578   this->SetDirty(); // Mark whole current window as dirty.
    00579
    00580   /* Save current size. */
    00581   int window_width  = this->width;
    00582   int window_height = this->height;
    00583
    00584   this->OnInit();
    00585   /* Re-initialize the window from the ground up. No need to change the nested_array, as all widgets stay where they are. */
    00586   this->nested_root->SetupSmallestSize(this, false);
    00587   this->nested_root->AssignSizePosition(ST_SMALLEST, 0, 0, this->nested_root->smallest_x, this->nested_root->smallest_y, _current_text_dir == TD_RTL);
    00588   this->width  = this->nested_root->smallest_x;
    00589   this->height = this->nested_root->smallest_y;
    00590   this->resize.step_width  = this->nested_root->resize_x;
    00591   this->resize.step_height = this->nested_root->resize_y;
    00592
    00593   /* Resize as close to the original size + requested resize as possible. */
    00594   window_width  = max(window_width  + rx, this->width);
    00595   window_height = max(window_height + ry, this->height);
    00596   int dx = (this->resize.step_width  == 0) ? 0 : window_width  - this->width;
    00597   int dy = (this->resize.step_height == 0) ? 0 : window_height - this->height;
    00598   /* dx and dy has to go by step.. calculate it.
    00599    * The cast to int is necessary else dx/dy are implicitly casted to unsigned int, which won't work. */
    00600   if (this->resize.step_width  > 1) dx -= dx % (int)this->resize.step_width;
    00601   if (this->resize.step_height > 1) dy -= dy % (int)this->resize.step_height;
    00602
    00603   ResizeWindow(this, dx, dy);
    00604   /* ResizeWindow() does this->SetDirty() already, no need to do it again here. */
    00605 }
    00606
    00612 void Window::SetShaded(bool make_shaded)
    00613 {
    00614   if (this->shade_select == NULL) return;
    00615
    00616   int desired = make_shaded ? SZSP_HORIZONTAL : 0;
    00617   if (this->shade_select->shown_plane != desired) {
    00618     if (make_shaded) {
    00619       this->unshaded_size.width  = this->width;
    00620       this->unshaded_size.height = this->height;
    00621       this->shade_select->SetDisplayedPlane(desired);
    00622       this->ReInit(0, -this->height);
    00623     } else {
    00624       this->shade_select->SetDisplayedPlane(desired);
    00625       int dx = ((int)this->unshaded_size.width  > this->width)  ? (int)this->unshaded_size.width  - this->width  : 0;
    00626       int dy = ((int)this->unshaded_size.height > this->height) ? (int)this->unshaded_size.height - this->height : 0;
    00627       this->ReInit(dx, dy);
    00628     }
    00629   }
    00630 }
    00631
    00638 static Window *FindChildWindow(const Window *w, WindowClass wc)
    00639 {
    00640   Window *v;
    00641   FOR_ALL_WINDOWS_FROM_BACK(v) {
    00642     if ((wc == WC_INVALID || wc == v->window_class) && v->parent == w) return v;
    00643   }
    00644
    00645   return NULL;
    00646 }
    00647
    00652 void Window::DeleteChildWindows(WindowClass wc) const
    00653 {
    00654   Window *child = FindChildWindow(this, wc);
    00655   while (child != NULL) {
    00656     delete child;
    00657     child = FindChildWindow(this, wc);
    00658   }
    00659 }
    00660
    00664 Window::~Window()
    00665 {
    00666   if (_thd.window_class == this->window_class &&
    00667       _thd.window_number == this->window_number) {
    00668     ResetObjectToPlace();
    00669   }
    00670
    00671   /* Prevent Mouseover() from resetting mouse-over coordinates on a non-existing window */
    00672   if (_mouseover_last_w == this) _mouseover_last_w = NULL;
    00673
    00674   /* We can't scroll the window when it's closed. */
    00675   if (_last_scroll_window == this) _last_scroll_window = NULL;
    00676
    00677   /* Make sure we don't try to access this window as the focused window when it doesn't exist anymore. */
    00678   if (_focused_window == this) _focused_window = NULL;
    00679
    00680   this->DeleteChildWindows();
    00681
    00682   if (this->viewport != NULL) DeleteWindowViewport(this);
    00683
    00684   this->SetDirty();
    00685
    00686   free(this->nested_array); // Contents is released through deletion of #nested_root.
    00687   delete this->nested_root;
    00688
    00689   this->window_class = WC_INVALID;
    00690 }
    00691
    00698 Window *FindWindowById(WindowClass cls, WindowNumber number)
    00699 {
    00700   Window *w;
    00701   FOR_ALL_WINDOWS_FROM_BACK(w) {
    00702     if (w->window_class == cls && w->window_number == number) return w;
    00703   }
    00704
    00705   return NULL;
    00706 }
    00707
    00714 Window *FindWindowByClass(WindowClass cls)
    00715 {
    00716   Window *w;
    00717   FOR_ALL_WINDOWS_FROM_BACK(w) {
    00718     if (w->window_class == cls) return w;
    00719   }
    00720
    00721   return NULL;
    00722 }
    00723
    00730 void DeleteWindowById(WindowClass cls, WindowNumber number, bool force)
    00731 {
    00732   Window *w = FindWindowById(cls, number);
    00733   if (force || w == NULL ||
    00734       (w->flags4 & WF_STICKY) == 0) {
    00735     delete w;
    00736   }
    00737 }
    00738
    00743 void DeleteWindowByClass(WindowClass cls)
    00744 {
    00745   Window *w;
    00746
    00747 restart_search:
    00748   /* When we find the window to delete, we need to restart the search
    00749    * as deleting this window could cascade in deleting (many) others
    00750    * anywhere in the z-array */
    00751   FOR_ALL_WINDOWS_FROM_BACK(w) {
    00752     if (w->window_class == cls) {
    00753       delete w;
    00754       goto restart_search;
    00755     }
    00756   }
    00757 }
    00758
    00765 void DeleteCompanyWindows(CompanyID id)
    00766 {
    00767   Window *w;
    00768
    00769 restart_search:
    00770   /* When we find the window to delete, we need to restart the search
    00771    * as deleting this window could cascade in deleting (many) others
    00772    * anywhere in the z-array */
    00773   FOR_ALL_WINDOWS_FROM_BACK(w) {
    00774     if (w->owner == id) {
    00775       delete w;
    00776       goto restart_search;
    00777     }
    00778   }
    00779
    00780   /* Also delete the company specific windows that don't have a company-colour. */
    00781   DeleteWindowById(WC_BUY_COMPANY, id);
    00782 }
    00783
    00791 void ChangeWindowOwner(Owner old_owner, Owner new_owner)
    00792 {
    00793   Window *w;
    00794   FOR_ALL_WINDOWS_FROM_BACK(w) {
    00795     if (w->owner != old_owner) continue;
    00796
    00797     switch (w->window_class) {
    00798       case WC_COMPANY_COLOUR:
    00799       case WC_FINANCES:
    00800       case WC_STATION_LIST:
    00801       case WC_TRAINS_LIST:
    00802       case WC_ROADVEH_LIST:
    00803       case WC_SHIPS_LIST:
    00804       case WC_AIRCRAFT_LIST:
    00805       case WC_BUY_COMPANY:
    00806       case WC_COMPANY:
    00807         continue;
    00808
    00809       default:
    00810         w->owner = new_owner;
    00811         break;
    00812     }
    00813   }
    00814 }
    00815
    00816 static void BringWindowToFront(Window *w);
    00817
    00825 Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)
    00826 {
    00827   Window *w = FindWindowById(cls, number);
    00828
    00829   if (w != NULL) {
    00830     if (w->IsShaded()) w->SetShaded(false); // Restore original window size if it was shaded.
    00831
    00832     w->flags4 |= WF_WHITE_BORDER_MASK;
    00833     BringWindowToFront(w);
    00834     w->SetDirty();
    00835   }
    00836
    00837   return w;
    00838 }
    00839
    00840 static inline bool IsVitalWindow(const Window *w)
    00841 {
    00842   switch (w->window_class) {
    00843     case WC_MAIN_TOOLBAR:
    00844     case WC_STATUS_BAR:
    00845     case WC_NEWS_WINDOW:
    00846     case WC_SEND_NETWORK_MSG:
    00847       return true;
    00848
    00849     default:
    00850       return false;
    00851   }
    00852 }
    00853
    00863 static void BringWindowToFront(Window *w)
    00864 {
    00865   Window *v = _z_front_window;
    00866
    00867   /* Bring the window just below the vital windows */
    00868   for (; v != NULL && v != w && IsVitalWindow(v); v = v->z_back) { }
    00869
    00870   if (v == NULL || w == v) return; // window is already in the right position
    00871
    00872   /* w cannot be at the top already! */
    00873   assert(w != _z_front_window);
    00874
    00875   if (w->z_back == NULL) {
    00876     _z_back_window = w->z_front;
    00877   } else {
    00878     w->z_back->z_front = w->z_front;
    00879   }
    00880   w->z_front->z_back = w->z_back;
    00881
    00882   w->z_front = v->z_front;
    00883   w->z_back = v;
    00884
    00885   if (v->z_front == NULL) {
    00886     _z_front_window = w;
    00887   } else {
    00888     v->z_front->z_back = w;
    00889   }
    00890   v->z_front = w;
    00891
    00892   w->SetDirty();
    00893 }
    00894
    00903 void Window::InitializeData(const WindowDesc *desc, WindowNumber window_number)
    00904 {
    00905   /* Set up window properties; some of them are needed to set up smallest size below */
    00906   this->window_class = desc->cls;
    00907   this->flags4 |= WF_WHITE_BORDER_MASK; // just opened windows have a white border
    00908   if (desc->default_pos == WDP_CENTER) this->flags4 |= WF_CENTERED;
    00909   this->owner = INVALID_OWNER;
    00910   this->nested_focus = NULL;
    00911   this->window_number = window_number;
    00912   this->desc_flags = desc->flags;
    00913
    00914   this->OnInit();
    00915   /* Initialize nested widget tree. */
    00916   if (this->nested_array == NULL) {
    00917     this->nested_array = CallocT<NWidgetBase *>(this->nested_array_size);
    00918     this->nested_root->SetupSmallestSize(this, true);
    00919   } else {
    00920     this->nested_root->SetupSmallestSize(this, false);
    00921   }
    00922   /* Initialize to smallest size. */
    00923   this->nested_root->AssignSizePosition(ST_SMALLEST, 0, 0, this->nested_root->smallest_x, this->nested_root->smallest_y, _current_text_dir == TD_RTL);
    00924
    00925   /* Further set up window properties,
    00926    * this->left, this->top, this->width, this->height, this->resize.width, and this->resize.height are initialized later. */
    00927   this->resize.step_width  = this->nested_root->resize_x;
    00928   this->resize.step_height = this->nested_root->resize_y;
    00929
    00930   /* Give focus to the opened window unless it is the OSK window or a text box
    00931    * of focused window has focus (so we don't interrupt typing). But if the new
    00932    * window has a text box, then take focus anyway. */
    00933   if (this->window_class != WC_OSK && (!EditBoxInGlobalFocus() || this->nested_root->GetWidgetOfType(WWT_EDITBOX) != NULL)) SetFocusedWindow(this);
    00934
    00935   /* Hacky way of specifying always-on-top windows. These windows are
    00936    * always above other windows because they are moved below them.
    00937    * status-bar is above news-window because it has been created earlier.
    00938    * Also, as the chat-window is excluded from this, it will always be
    00939    * the last window, thus always on top.
    00940    * XXX - Yes, ugly, probably needs something like w->always_on_top flag
    00941    * to implement correctly, but even then you need some kind of distinction
    00942    * between on-top of chat/news and status windows, because these conflict */
    00943   Window *w = _z_front_window;
    00944   if (w != NULL && this->window_class != WC_SEND_NETWORK_MSG && this->window_class != WC_HIGHSCORE && this->window_class != WC_ENDSCREEN) {
    00945     if (FindWindowById(WC_MAIN_TOOLBAR, 0)     != NULL) w = w->z_back;
    00946     if (FindWindowById(WC_STATUS_BAR, 0)       != NULL) w = w->z_back;
    00947     if (FindWindowById(WC_NEWS_WINDOW, 0)      != NULL) w = w->z_back;
    00948     if (FindWindowByClass(WC_SEND_NETWORK_MSG) != NULL) w = w->z_back;
    00949
    00950     if (w == NULL) {
    00951       _z_back_window->z_front = this;
    00952       this->z_back = _z_back_window;
    00953       _z_back_window = this;
    00954     } else {
    00955       if (w->z_front == NULL) {
    00956         _z_front_window = this;
    00957       } else {
    00958         this->z_front = w->z_front;
    00959         w->z_front->z_back = this;
    00960       }
    00961
    00962       this->z_back = w;
    00963       w->z_front = this;
    00964     }
    00965   } else {
    00966     this->z_back = _z_front_window;
    00967     if (_z_front_window != NULL) {
    00968       _z_front_window->z_front = this;
    00969     } else {
    00970       _z_back_window = this;
    00971     }
    00972     _z_front_window = this;
    00973   }
    00974 }
    00975
    00983 void Window::InitializePositionSize(int x, int y, int sm_width, int sm_height)
    00984 {
    00985   this->left = x;
    00986   this->top = y;
    00987   this->width = sm_width;
    00988   this->height = sm_height;
    00989 }
    00990
    01001 void Window::FindWindowPlacementAndResize(int def_width, int def_height)
    01002 {
    01003   def_width  = max(def_width,  this->width); // Don't allow default size to be smaller than smallest size
    01004   def_height = max(def_height, this->height);
    01005   /* Try to make windows smaller when our window is too small.
    01006    * w->(width|height) is normally the same as min_(width|height),
    01007    * but this way the GUIs can be made a little more dynamic;
    01008    * one can use the same spec for multiple windows and those
    01009    * can then determine the real minimum size of the window. */
    01010   if (this->width != def_width || this->height != def_height) {
    01011     /* Think about the overlapping toolbars when determining the minimum window size */
    01012     int free_height = _screen.height;
    01013     const Window *wt = FindWindowById(WC_STATUS_BAR, 0);
    01014     if (wt != NULL) free_height -= wt->height;
    01015     wt = FindWindowById(WC_MAIN_TOOLBAR, 0);
    01016     if (wt != NULL) free_height -= wt->height;
    01017
    01018     int enlarge_x = max(min(def_width  - this->width,  _screen.width - this->width),  0);
    01019     int enlarge_y = max(min(def_height - this->height, free_height   - this->height), 0);
    01020
    01021     /* X and Y has to go by step.. calculate it.
    01022      * The cast to int is necessary else x/y are implicitly casted to
    01023      * unsigned int, which won't work. */
    01024     if (this->resize.step_width  > 1) enlarge_x -= enlarge_x % (int)this->resize.step_width;
    01025     if (this->resize.step_height > 1) enlarge_y -= enlarge_y % (int)this->resize.step_height;
    01026
    01027     ResizeWindow(this, enlarge_x, enlarge_y);
    01028     /* ResizeWindow() calls this->OnResize(). */
    01029   } else {
    01030     /* Always call OnResize; that way the scrollbars and matrices get initialized. */
    01031     this->OnResize();
    01032   }
    01033
    01034   int nx = this->left;
    01035   int ny = this->top;
    01036
    01037   if (nx + this->width > _screen.width) nx -= (nx + this->width - _screen.width);
    01038
    01039   const Window *wt = FindWindowById(WC_MAIN_TOOLBAR, 0);
    01040   ny = max(ny, (wt == NULL || this == wt || this->top == 0) ? 0 : wt->height);
    01041   nx = max(nx, 0);
    01042
    01043   if (this->viewport != NULL) {
    01044     this->viewport->left += nx - this->left;
    01045     this->viewport->top  += ny - this->top;
    01046   }
    01047   this->left = nx;
    01048   this->top = ny;
    01049
    01050   this->SetDirty();
    01051 }
    01052
    01064 static bool IsGoodAutoPlace1(int left, int top, int width, int height, Point &pos)
    01065 {
    01066   int right  = width + left;
    01067   int bottom = height + top;
    01068
    01069   const Window *main_toolbar = FindWindowByClass(WC_MAIN_TOOLBAR);
    01070   if (left < 0 || (main_toolbar != NULL && top < main_toolbar->height) || right > _screen.width || bottom > _screen.height) return false;
    01071
    01072   /* Make sure it is not obscured by any window. */
    01073   const Window *w;
    01074   FOR_ALL_WINDOWS_FROM_BACK(w) {
    01075     if (w->window_class == WC_MAIN_WINDOW) continue;
    01076
    01077     if (right > w->left &&
    01078         w->left + w->width > left &&
    01079         bottom > w->top &&
    01080         w->top + w->height > top) {
    01081       return false;
    01082     }
    01083   }
    01084
    01085   pos.x = left;
    01086   pos.y = top;
    01087   return true;
    01088 }
    01089
    01101 static bool IsGoodAutoPlace2(int left, int top, int width, int height, Point &pos)
    01102 {
    01103   /* Left part of the rectangle may be at most 1/4 off-screen,
    01104    * right part of the rectangle may be at most 1/2 off-screen
    01105    */
    01106   if (left < -(width >> 2) || left > _screen.width - (width >> 1)) return false;
    01107   /* Bottom part of the rectangle may be at most 1/4 off-screen */
    01108   if (top < 22 || top > _screen.height - (height >> 2)) return false;
    01109
    01110   /* Make sure it is not obscured by any window. */
    01111   const Window *w;
    01112   FOR_ALL_WINDOWS_FROM_BACK(w) {
    01113     if (w->window_class == WC_MAIN_WINDOW) continue;
    01114
    01115     if (left + width > w->left &&
    01116         w->left + w->width > left &&
    01117         top + height > w->top &&
    01118         w->top + w->height > top) {
    01119       return false;
    01120     }
    01121   }
    01122
    01123   pos.x = left;
    01124   pos.y = top;
    01125   return true;
    01126 }
    01127
    01134 static Point GetAutoPlacePosition(int width, int height)
    01135 {
    01136   Point pt;
    01137
    01138   /* First attempt, try top-left of the screen */
    01139   const Window *main_toolbar = FindWindowByClass(WC_MAIN_TOOLBAR);
    01140   if (IsGoodAutoPlace1(0, main_toolbar != NULL ? main_toolbar->height + 2 : 2, width, height, pt)) return pt;
    01141
    01142   /* Second attempt, try around all existing windows with a distance of 2 pixels.
    01143    * The new window must be entirely on-screen, and not overlap with an existing window.
    01144    * Eight starting points are tried, two at each corner.
    01145    */
    01146   const Window *w;
    01147   FOR_ALL_WINDOWS_FROM_BACK(w) {
    01148     if (w->window_class == WC_MAIN_WINDOW) continue;
    01149
    01150     if (IsGoodAutoPlace1(w->left + w->width + 2, w->top, width, height, pt)) return pt;
    01151     if (IsGoodAutoPlace1(w->left - width - 2,    w->top, width, height, pt)) return pt;
    01152     if (IsGoodAutoPlace1(w->left, w->top + w->height + 2, width, height, pt)) return pt;
    01153     if (IsGoodAutoPlace1(w->left, w->top - height - 2,    width, height, pt)) return pt;
    01154     if (IsGoodAutoPlace1(w->left + w->width + 2, w->top + w->height - height, width, height, pt)) return pt;
    01155     if (IsGoodAutoPlace1(w->left - width - 2,    w->top + w->height - height, width, height, pt)) return pt;
    01156     if (IsGoodAutoPlace1(w->left + w->width - width, w->top + w->height + 2, width, height, pt)) return pt;
    01157     if (IsGoodAutoPlace1(w->left + w->width - width, w->top - height - 2,    width, height, pt)) return pt;
    01158   }
    01159
    01160   /* Third attempt, try around all existing windows with a distance of 2 pixels.
    01161    * The new window may be partly off-screen, and must not overlap with an existing window.
    01162    * Only four starting points are tried.
    01163    */
    01164   FOR_ALL_WINDOWS_FROM_BACK(w) {
    01165     if (w->window_class == WC_MAIN_WINDOW) continue;
    01166
    01167     if (IsGoodAutoPlace2(w->left + w->width + 2, w->top, width, height, pt)) return pt;
    01168     if (IsGoodAutoPlace2(w->left - width - 2,    w->top, width, height, pt)) return pt;
    01169     if (IsGoodAutoPlace2(w->left, w->top + w->height + 2, width, height, pt)) return pt;
    01170     if (IsGoodAutoPlace2(w->left, w->top - height - 2,    width, height, pt)) return pt;
    01171   }
    01172
    01173   /* Fourth and final attempt, put window at diagonal starting from (0, 24), try multiples
    01174    * of (+5, +5)
    01175    */
    01176   int left = 0, top = 24;
    01177
    01178 restart:
    01179   FOR_ALL_WINDOWS_FROM_BACK(w) {
    01180     if (w->left == left && w->top == top) {
    01181       left += 5;
    01182       top += 5;
    01183       goto restart;
    01184     }
    01185   }
    01186
    01187   pt.x = left;
    01188   pt.y = top;
    01189   return pt;
    01190 }
    01191
    01198 Point GetToolbarAlignedWindowPosition(int window_width)
    01199 {
    01200   const Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);
    01201   assert(w != NULL);
    01202   Point pt = { _current_text_dir == TD_RTL ? w->left : (w->left + w->width) - window_width, w->top + w->height };
    01203   return pt;
    01204 }
    01205
    01223 static Point LocalGetWindowPlacement(const WindowDesc *desc, int16 sm_width, int16 sm_height, int window_number)
    01224 {
    01225   Point pt;
    01226   const Window *w;
    01227
    01228   int16 default_width  = max(desc->default_width,  sm_width);
    01229   int16 default_height = max(desc->default_height, sm_height);
    01230
    01231   if (desc->parent_cls != 0 /* WC_MAIN_WINDOW */ &&
    01232       (w = FindWindowById(desc->parent_cls, window_number)) != NULL &&
    01233       w->left < _screen.width - 20 && w->left > -60 && w->top < _screen.height - 20) {
    01234
    01235     pt.x = w->left + ((desc->parent_cls == WC_BUILD_TOOLBAR || desc->parent_cls == WC_SCEN_LAND_GEN) ? 0 : 10);
    01236     if (pt.x > _screen.width + 10 - default_width) {
    01237       pt.x = (_screen.width + 10 - default_width) - 20;
    01238     }
    01239     pt.y = w->top + ((desc->parent_cls == WC_BUILD_TOOLBAR || desc->parent_cls == WC_SCEN_LAND_GEN) ? w->height : 10);
    01240     return pt;
    01241   }
    01242
    01243   switch (desc->default_pos) {
    01244     case WDP_ALIGN_TOOLBAR: // Align to the toolbar
    01245       return GetToolbarAlignedWindowPosition(default_width);
    01246
    01247     case WDP_AUTO: // Find a good automatic position for the window
    01248       return GetAutoPlacePosition(default_width, default_height);
    01249
    01250     case WDP_CENTER: // Centre the window horizontally
    01251       pt.x = (_screen.width - default_width) / 2;
    01252       pt.y = (_screen.height - default_height) / 2;
    01253       break;
    01254
    01255     case WDP_MANUAL:
    01256       pt.x = 0;
    01257       pt.y = 0;
    01258       break;
    01259
    01260     default:
    01261       NOT_REACHED();
    01262   }
    01263
    01264   return pt;
    01265 }
    01266
    01267 /* virtual */ Point Window::OnInitialPosition(const WindowDesc *desc, int16 sm_width, int16 sm_height, int window_number)
    01268 {
    01269   return LocalGetWindowPlacement(desc, sm_width, sm_height, window_number);
    01270 }
    01271
    01280 void Window::CreateNestedTree(const WindowDesc *desc, bool fill_nested)
    01281 {
    01282   int biggest_index = -1;
    01283   this->nested_root = MakeWindowNWidgetTree(desc->nwid_parts, desc->nwid_length, &biggest_index, &this->shade_select);
    01284   this->nested_array_size = (uint)(biggest_index + 1);
    01285
    01286   if (fill_nested) {
    01287     this->nested_array = CallocT<NWidgetBase *>(this->nested_array_size);
    01288     this->nested_root->FillNestedArray(this->nested_array, this->nested_array_size);
    01289   }
    01290 }
    01291
    01297 void Window::FinishInitNested(const WindowDesc *desc, WindowNumber window_number)
    01298 {
    01299   this->InitializeData(desc, window_number);
    01300   Point pt = this->OnInitialPosition(desc, this->nested_root->smallest_x, this->nested_root->smallest_y, window_number);
    01301   this->InitializePositionSize(pt.x, pt.y, this->nested_root->smallest_x, this->nested_root->smallest_y);
    01302   this->FindWindowPlacementAndResize(desc->default_width, desc->default_height);
    01303 }
    01304
    01310 void Window::InitNested(const WindowDesc *desc, WindowNumber window_number)
    01311 {
    01312   this->CreateNestedTree(desc, false);
    01313   this->FinishInitNested(desc, window_number);
    01314 }
    01315
    01317 Window::Window() : scrolling_scrollbar(-1)
    01318 {
    01319 }
    01320
    01328 Window *FindWindowFromPt(int x, int y)
    01329 {
    01330   Window *w;
    01331   FOR_ALL_WINDOWS_FROM_FRONT(w) {
    01332     if (IsInsideBS(x, w->left, w->width) && IsInsideBS(y, w->top, w->height)) {
    01333       return w;
    01334     }
    01335   }
    01336
    01337   return NULL;
    01338 }
    01339
    01343 void InitWindowSystem()
    01344 {
    01345   IConsoleClose();
    01346
    01347   _z_back_window = NULL;
    01348   _z_front_window = NULL;
    01349   _focused_window = NULL;
    01350   _mouseover_last_w = NULL;
    01351   _last_scroll_window = NULL;
    01352   _scrolling_viewport = false;
    01353   _mouse_hovering = false;
    01354
    01355   NWidgetLeaf::InvalidateDimensionCache(); // Reset cached sizes of several widgets.
    01356 }
    01357
    01361 void UnInitWindowSystem()
    01362 {
    01363   Window *w;
    01364   FOR_ALL_WINDOWS_FROM_FRONT(w) delete w;
    01365
    01366   for (w = _z_front_window; w != NULL; /* nothing */) {
    01367     Window *to_del = w;
    01368     w = w->z_back;
    01369     free(to_del);
    01370   }
    01371
    01372   _z_front_window = NULL;
    01373   _z_back_window = NULL;
    01374 }
    01375
    01379 void ResetWindowSystem()
    01380 {
    01381   UnInitWindowSystem();
    01382   InitWindowSystem();
    01383   _thd.Reset();
    01384 }
    01385
    01386 static void DecreaseWindowCounters()
    01387 {
    01388   Window *w;
    01389   FOR_ALL_WINDOWS_FROM_FRONT(w) {
    01390     if (_scroller_click_timeout == 0) {
    01391       /* Unclick scrollbar buttons if they are pressed. */
    01392       for (uint i = 0; i < w->nested_array_size; i++) {
    01393         NWidgetBase *nwid = w->nested_array[i];
    01394         if (nwid != NULL && (nwid->type == NWID_HSCROLLBAR || nwid->type == NWID_VSCROLLBAR)) {
    01395           NWidgetScrollbar *sb = static_cast<NWidgetScrollbar*>(nwid);
    01396           if (sb->disp_flags & (ND_SCROLLBAR_UP | ND_SCROLLBAR_DOWN)) {
    01397             sb->disp_flags &= ~(ND_SCROLLBAR_UP | ND_SCROLLBAR_DOWN);
    01398             sb->SetDirty(w);
    01399           }
    01400         }
    01401       }
    01402     }
    01403     w->OnMouseLoop();
    01404   }
    01405
    01406   FOR_ALL_WINDOWS_FROM_FRONT(w) {
    01407     if ((w->flags4 & WF_TIMEOUT_MASK) && !(--w->flags4 & WF_TIMEOUT_MASK)) {
    01408       w->OnTimeout();
    01409       if (w->desc_flags & WDF_UNCLICK_BUTTONS) w->RaiseButtons(true);
    01410     }
    01411   }
    01412 }
    01413
    01414 static void HandlePlacePresize()
    01415 {
    01416   if (_special_mouse_mode != WSM_PRESIZE) return;
    01417
    01418   Window *w = _thd.GetCallbackWnd();
    01419   if (w == NULL) return;
    01420
    01421   Point pt = GetTileBelowCursor();
    01422   if (pt.x == -1) {
    01423     _thd.selend.x = -1;
    01424     return;
    01425   }
    01426
    01427   w->OnPlacePresize(pt, TileVirtXY(pt.x, pt.y));
    01428 }
    01429
    01434 static EventState HandleMouseDragDrop()
    01435 {
    01436   if (_special_mouse_mode != WSM_DRAGDROP) return ES_NOT_HANDLED;
    01437
    01438   if (_left_button_down && _cursor.delta.x == 0 && _cursor.delta.y == 0) return ES_HANDLED; // Dragging, but the mouse did not move.
    01439
    01440   Window *w = _thd.GetCallbackWnd();
    01441   if (w != NULL) {
    01442     /* Send an event in client coordinates. */
    01443     Point pt;
    01444     pt.x = _cursor.pos.x - w->left;
    01445     pt.y = _cursor.pos.y - w->top;
    01446     if (_left_button_down) {
    01447       w->OnMouseDrag(pt, GetWidgetFromPos(w, pt.x, pt.y));
    01448     } else {
    01449       w->OnDragDrop(pt, GetWidgetFromPos(w, pt.x, pt.y));
    01450     }
    01451   }
    01452
    01453   if (!_left_button_down) ResetObjectToPlace(); // Button released, finished dragging.
    01454   return ES_HANDLED;
    01455 }
    01456
    01458 static void HandleMouseOver()
    01459 {
    01460   Window *w = FindWindowFromPt(_cursor.pos.x, _cursor.pos.y);
    01461
    01462   /* We changed window, put a MOUSEOVER event to the last window */
    01463   if (_mouseover_last_w != NULL && _mouseover_last_w != w) {
    01464     /* Reset mouse-over coordinates of previous window */
    01465     Point pt = { -1, -1 };
    01466     _mouseover_last_w->OnMouseOver(pt, 0);
    01467   }
    01468
    01469   /* _mouseover_last_w will get reset when the window is deleted, see DeleteWindow() */
    01470   _mouseover_last_w = w;
    01471
    01472   if (w != NULL) {
    01473     /* send an event in client coordinates. */
    01474     Point pt = { _cursor.pos.x - w->left, _cursor.pos.y - w->top };
    01475     const NWidgetCore *widget = w->nested_root->GetWidgetFromPos(pt.x, pt.y);
    01476     if (widget != NULL) w->OnMouseOver(pt, widget->index);
    01477   }
    01478 }
    01479
    01481 static const int MIN_VISIBLE_TITLE_BAR = 13;
    01482
    01484 enum PreventHideDirection {
    01485   PHD_UP,
    01486   PHD_DOWN,
    01487 };
    01488
    01499 static void PreventHiding(int *nx, int *ny, const Rect &rect, const Window *v, int px, PreventHideDirection dir)
    01500 {
    01501   if (v == NULL) return;
    01502
    01503   int v_bottom = v->top + v->height;
    01504   int v_right = v->left + v->width;
    01505   int safe_y = (dir == PHD_UP) ? (v->top - MIN_VISIBLE_TITLE_BAR - rect.top) : (v_bottom + MIN_VISIBLE_TITLE_BAR - rect.bottom); // Compute safe vertical position.
    01506
    01507   if (*ny + rect.top <= v->top - MIN_VISIBLE_TITLE_BAR) return; // Above v is enough space
    01508   if (*ny + rect.bottom >= v_bottom + MIN_VISIBLE_TITLE_BAR) return; // Below v is enough space
    01509
    01510   /* Vertically, the rectangle is hidden behind v. */
    01511   if (*nx + rect.left + MIN_VISIBLE_TITLE_BAR < v->left) { // At left of v.
    01512     if (v->left < MIN_VISIBLE_TITLE_BAR) *ny = safe_y; // But enough room, force it to a safe position.
    01513     return;
    01514   }
    01515   if (*nx + rect.right - MIN_VISIBLE_TITLE_BAR > v_right) { // At right of v.
    01516     if (v_right > _screen.width - MIN_VISIBLE_TITLE_BAR) *ny = safe_y; // Not enough room, force it to a safe position.
    01517     return;
    01518   }
    01519
    01520   /* Horizontally also hidden, force movement to a safe area. */
    01521   if (px + rect.left < v->left && v->left >= MIN_VISIBLE_TITLE_BAR) { // Coming from the left, and enough room there.
    01522     *nx = v->left - MIN_VISIBLE_TITLE_BAR - rect.left;
    01523   } else if (px + rect.right > v_right && v_right <= _screen.width - MIN_VISIBLE_TITLE_BAR) { // Coming from the right, and enough room there.
    01524     *nx = v_right + MIN_VISIBLE_TITLE_BAR - rect.right;
    01525   } else {
    01526     *ny = safe_y;
    01527   }
    01528 }
    01529
    01537 static void EnsureVisibleCaption(Window *w, int nx, int ny)
    01538 {
    01539   /* Search for the title bar rectangle. */
    01540   Rect caption_rect;
    01541   const NWidgetBase *caption = w->nested_root->GetWidgetOfType(WWT_CAPTION);
    01542   if (caption != NULL) {
    01543     caption_rect.left   = caption->pos_x;
    01544     caption_rect.right  = caption->pos_x + caption->current_x;
    01545     caption_rect.top    = caption->pos_y;
    01546     caption_rect.bottom = caption->pos_y + caption->current_y;
    01547
    01548     /* Make sure the window doesn't leave the screen */
    01549     nx = Clamp(nx, MIN_VISIBLE_TITLE_BAR - caption_rect.right, _screen.width - MIN_VISIBLE_TITLE_BAR - caption_rect.left);
    01550     ny = Clamp(ny, 0, _screen.height - MIN_VISIBLE_TITLE_BAR);
    01551
    01552     /* Make sure the title bar isn't hidden behind the main tool bar or the status bar. */
    01553     PreventHiding(&nx, &ny, caption_rect, FindWindowById(WC_MAIN_TOOLBAR, 0), w->left, PHD_DOWN);
    01554     PreventHiding(&nx, &ny, caption_rect, FindWindowById(WC_STATUS_BAR,   0), w->left, PHD_UP);
    01555
    01556     if (w->viewport != NULL) {
    01557       w->viewport->left += nx - w->left;
    01558       w->viewport->top  += ny - w->top;
    01559     }
    01560   }
    01561   w->left = nx;
    01562   w->top  = ny;
    01563 }
    01564
    01574 void ResizeWindow(Window *w, int delta_x, int delta_y)
    01575 {
    01576   if (delta_x != 0 || delta_y != 0) {
    01577     w->SetDirty();
    01578
    01579     uint new_xinc = max(0, (w->nested_root->resize_x == 0) ? 0 : (int)(w->nested_root->current_x - w->nested_root->smallest_x) + delta_x);
    01580     uint new_yinc = max(0, (w->nested_root->resize_y == 0) ? 0 : (int)(w->nested_root->current_y - w->nested_root->smallest_y) + delta_y);
    01581     assert(w->nested_root->resize_x == 0 || new_xinc % w->nested_root->resize_x == 0);
    01582     assert(w->nested_root->resize_y == 0 || new_yinc % w->nested_root->resize_y == 0);
    01583
    01584     w->nested_root->AssignSizePosition(ST_RESIZE, 0, 0, w->nested_root->smallest_x + new_xinc, w->nested_root->smallest_y + new_yinc, _current_text_dir == TD_RTL);
    01585     w->width  = w->nested_root->current_x;
    01586     w->height = w->nested_root->current_y;
    01587   }
    01588
    01589   EnsureVisibleCaption(w, w->left, w->top);
    01590
    01591   /* Always call OnResize to make sure everything is initialised correctly if it needs to be. */
    01592   w->OnResize();
    01593   w->SetDirty();
    01594 }
    01595
    01601 int GetMainViewTop()
    01602 {
    01603   Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);
    01604   return (w == NULL) ? 0 : w->top + w->height;
    01605 }
    01606
    01612 int GetMainViewBottom()
    01613 {
    01614   Window *w = FindWindowById(WC_STATUS_BAR, 0);
    01615   return (w == NULL) ? _screen.height : w->top;
    01616 }
    01617
    01618 static bool _dragging_window;
    01619
    01624 static EventState HandleWindowDragging()
    01625 {
    01626   /* Get out immediately if no window is being dragged at all. */
    01627   if (!_dragging_window) return ES_NOT_HANDLED;
    01628
    01629   /* If button still down, but cursor hasn't moved, there is nothing to do. */
    01630   if (_left_button_down && _cursor.delta.x == 0 && _cursor.delta.y == 0) return ES_HANDLED;
    01631
    01632   /* Otherwise find the window... */
    01633   Window *w;
    01634   FOR_ALL_WINDOWS_FROM_BACK(w) {
    01635     if (w->flags4 & WF_DRAGGING) {
    01636       /* Stop the dragging if the left mouse button was released */
    01637       if (!_left_button_down) {
    01638         w->flags4 &= ~WF_DRAGGING;
    01639         break;
    01640       }
    01641
    01642       w->SetDirty();
    01643
    01644       int x = _cursor.pos.x + _drag_delta.x;
    01645       int y = _cursor.pos.y + _drag_delta.y;
    01646       int nx = x;
    01647       int ny = y;
    01648
    01649       if (_settings_client.gui.window_snap_radius != 0) {
    01650         const Window *v;
    01651
    01652         int hsnap = _settings_client.gui.window_snap_radius;
    01653         int vsnap = _settings_client.gui.window_snap_radius;
    01654         int delta;
    01655
    01656         FOR_ALL_WINDOWS_FROM_BACK(v) {
    01657           if (v == w) continue; // Don't snap at yourself
    01658
    01659           if (y + w->height > v->top && y < v->top + v->height) {
    01660             /* Your left border <-> other right border */
    01661             delta = abs(v->left + v->width - x);
    01662             if (delta <= hsnap) {
    01663               nx = v->left + v->width;
    01664               hsnap = delta;
    01665             }
    01666
    01667             /* Your right border <-> other left border */
    01668             delta = abs(v->left - x - w->width);
    01669             if (delta <= hsnap) {
    01670               nx = v->left - w->width;
    01671               hsnap = delta;
    01672             }
    01673           }
    01674
    01675           if (w->top + w->height >= v->top && w->top <= v->top + v->height) {
    01676             /* Your left border <-> other left border */
    01677             delta = abs(v->left - x);
    01678             if (delta <= hsnap) {
    01679               nx = v->left;
    01680               hsnap = delta;
    01681             }
    01682
    01683             /* Your right border <-> other right border */
    01684             delta = abs(v->left + v->width - x - w->width);
    01685             if (delta <= hsnap) {
    01686               nx = v->left + v->width - w->width;
    01687               hsnap = delta;
    01688             }
    01689           }
    01690
    01691           if (x + w->width > v->left && x < v->left + v->width) {
    01692             /* Your top border <-> other bottom border */
    01693             delta = abs(v->top + v->height - y);
    01694             if (delta <= vsnap) {
    01695               ny = v->top + v->height;
    01696               vsnap = delta;
    01697             }
    01698
    01699             /* Your bottom border <-> other top border */
    01700             delta = abs(v->top - y - w->height);
    01701             if (delta <= vsnap) {
    01702               ny = v->top - w->height;
    01703               vsnap = delta;
    01704             }
    01705           }
    01706
    01707           if (w->left + w->width >= v->left && w->left <= v->left + v->width) {
    01708             /* Your top border <-> other top border */
    01709             delta = abs(v->top - y);
    01710             if (delta <= vsnap) {
    01711               ny = v->top;
    01712               vsnap = delta;
    01713             }
    01714
    01715             /* Your bottom border <-> other bottom border */
    01716             delta = abs(v->top + v->height - y - w->height);
    01717             if (delta <= vsnap) {
    01718               ny = v->top + v->height - w->height;
    01719               vsnap = delta;
    01720             }
    01721           }
    01722         }
    01723       }
    01724
    01725       EnsureVisibleCaption(w, nx, ny);
    01726
    01727       w->SetDirty();
    01728       return ES_HANDLED;
    01729     } else if (w->flags4 & WF_SIZING) {
    01730       /* Stop the sizing if the left mouse button was released */
    01731       if (!_left_button_down) {
    01732         w->flags4 &= ~WF_SIZING;
    01733         w->SetDirty();
    01734         break;
    01735       }
    01736
    01737       /* Compute difference in pixels between cursor position and reference point in the window.
    01738        * If resizing the left edge of the window, moving to the left makes the window bigger not smaller.
    01739        */
    01740       int x, y = _cursor.pos.y - _drag_delta.y;
    01741       if (w->flags4 & WF_SIZING_LEFT) {
    01742         x = _drag_delta.x - _cursor.pos.x;
    01743       } else {
    01744         x = _cursor.pos.x - _drag_delta.x;
    01745       }
    01746
    01747       /* resize.step_width and/or resize.step_height may be 0, which means no resize is possible. */
    01748       if (w->resize.step_width  == 0) x = 0;
    01749       if (w->resize.step_height == 0) y = 0;
    01750
    01751       /* Check the resize button won't go past the bottom of the screen */
    01752       if (w->top + w->height + y > _screen.height) {
    01753         y = _screen.height - w->height - w->top;
    01754       }
    01755
    01756       /* X and Y has to go by step.. calculate it.
    01757        * The cast to int is necessary else x/y are implicitly casted to
    01758        * unsigned int, which won't work. */
    01759       if (w->resize.step_width  > 1) x -= x % (int)w->resize.step_width;
    01760       if (w->resize.step_height > 1) y -= y % (int)w->resize.step_height;
    01761
    01762       /* Check that we don't go below the minimum set size */
    01763       if ((int)w->width + x < (int)w->nested_root->smallest_x) {
    01764         x = w->nested_root->smallest_x - w->width;
    01765       }
    01766       if ((int)w->height + y < (int)w->nested_root->smallest_y) {
    01767         y = w->nested_root->smallest_y - w->height;
    01768       }
    01769
    01770       /* Window already on size */
    01771       if (x == 0 && y == 0) return ES_HANDLED;
    01772
    01773       /* Now find the new cursor pos.. this is NOT _cursor, because we move in steps. */
    01774       _drag_delta.y += y;
    01775       if ((w->flags4 & WF_SIZING_LEFT) && x != 0) {
    01776         _drag_delta.x -= x; // x > 0 -> window gets longer -> left-edge moves to left -> subtract x to get new position.
    01777         w->SetDirty();
    01778         w->left -= x;  // If dragging left edge, move left window edge in opposite direction by the same amount.
    01779         /* ResizeWindow() below ensures marking new position as dirty. */
    01780       } else {
    01781         _drag_delta.x += x;
    01782       }
    01783
    01784       /* ResizeWindow sets both pre- and after-size to dirty for redrawal */
    01785       ResizeWindow(w, x, y);
    01786       return ES_HANDLED;
    01787     }
    01788   }
    01789
    01790   _dragging_window = false;
    01791   return ES_HANDLED;
    01792 }
    01793
    01798 static void StartWindowDrag(Window *w)
    01799 {
    01800   w->flags4 |= WF_DRAGGING;
    01801   w->flags4 &= ~WF_CENTERED;
    01802   _dragging_window = true;
    01803
    01804   _drag_delta.x = w->left - _cursor.pos.x;
    01805   _drag_delta.y = w->top  - _cursor.pos.y;
    01806
    01807   BringWindowToFront(w);
    01808   DeleteWindowById(WC_DROPDOWN_MENU, 0);
    01809 }
    01810
    01816 static void StartWindowSizing(Window *w, bool to_left)
    01817 {
    01818   w->flags4 |= to_left ? WF_SIZING_LEFT : WF_SIZING_RIGHT;
    01819   w->flags4 &= ~WF_CENTERED;
    01820   _dragging_window = true;
    01821
    01822   _drag_delta.x = _cursor.pos.x;
    01823   _drag_delta.y = _cursor.pos.y;
    01824
    01825   BringWindowToFront(w);
    01826   DeleteWindowById(WC_DROPDOWN_MENU, 0);
    01827 }
    01828
    01833 static EventState HandleScrollbarScrolling()
    01834 {
    01835   Window *w;
    01836   FOR_ALL_WINDOWS_FROM_BACK(w) {
    01837     if (w->scrolling_scrollbar >= 0) {
    01838       /* Abort if no button is clicked any more. */
    01839       if (!_left_button_down) {
    01840         w->scrolling_scrollbar = -1;
    01841         w->SetDirty();
    01842         return ES_HANDLED;
    01843       }
    01844
    01845       int i;
    01846       NWidgetScrollbar *sb = w->GetWidget<NWidgetScrollbar>(w->scrolling_scrollbar);
    01847       bool rtl = false;
    01848
    01849       if (sb->type == NWID_HSCROLLBAR) {
    01850         i = _cursor.pos.x - _cursorpos_drag_start.x;
    01851         rtl = _current_text_dir == TD_RTL;
    01852       } else {
    01853         i = _cursor.pos.y - _cursorpos_drag_start.y;
    01854       }
    01855
    01856       if (sb->disp_flags & ND_SCROLLBAR_BTN) {
    01857         if (_scroller_click_timeout == 1) {
    01858           _scroller_click_timeout = 3;
    01859           sb->UpdatePosition(rtl == HasBit(sb->disp_flags, NDB_SCROLLBAR_UP) ? 1 : -1);
    01860           w->SetDirty();
    01861         }
    01862         return ES_HANDLED;
    01863       }
    01864
    01865       /* Find the item we want to move to and make sure it's inside bounds. */
    01866       int pos = min(max(0, i + _scrollbar_start_pos) * sb->GetCount() / _scrollbar_size, max(0, sb->GetCount() - sb->GetCapacity()));
    01867       if (rtl) pos = max(0, sb->GetCount() - sb->GetCapacity() - pos);
    01868       if (pos != sb->GetPosition()) {
    01869         sb->SetPosition(pos);
    01870         w->SetDirty();
    01871       }
    01872       return ES_HANDLED;
    01873     }
    01874   }
    01875
    01876   return ES_NOT_HANDLED;
    01877 }
    01878
    01883 static EventState HandleViewportScroll()
    01884 {
    01885   bool scrollwheel_scrolling = _settings_client.gui.scrollwheel_scrolling == 1 && (_cursor.v_wheel != 0 || _cursor.h_wheel != 0);
    01886
    01887   if (!_scrolling_viewport) return ES_NOT_HANDLED;
    01888
    01889   /* When we don't have a last scroll window we are starting to scroll.
    01890    * When the last scroll window and this are not the same we went
    01891    * outside of the window and should not left-mouse scroll anymore. */
    01892   if (_last_scroll_window == NULL) _last_scroll_window = FindWindowFromPt(_cursor.pos.x, _cursor.pos.y);
    01893
    01894   if (_last_scroll_window == NULL || !(_right_button_down || scrollwheel_scrolling || (_settings_client.gui.left_mouse_btn_scrolling && _left_button_down))) {
    01895     _cursor.fix_at = false;
    01896     _scrolling_viewport = false;
    01897     _last_scroll_window = NULL;
    01898     return ES_NOT_HANDLED;
    01899   }
    01900
    01901   if (_last_scroll_window == FindWindowById(WC_MAIN_WINDOW, 0) && _last_scroll_window->viewport->follow_vehicle != INVALID_VEHICLE) {
    01902     /* If the main window is following a vehicle, then first let go of it! */
    01903     const Vehicle *veh = Vehicle::Get(_last_scroll_window->viewport->follow_vehicle);
    01904     ScrollMainWindowTo(veh->x_pos, veh->y_pos, veh->z_pos, true); // This also resets follow_vehicle
    01905     return ES_NOT_HANDLED;
    01906   }
    01907
    01908   Point delta;
    01909   if (_settings_client.gui.reverse_scroll || (_settings_client.gui.left_mouse_btn_scrolling && _left_button_down)) {
    01910     delta.x = -_cursor.delta.x;
    01911     delta.y = -_cursor.delta.y;
    01912   } else {
    01913     delta.x = _cursor.delta.x;
    01914     delta.y = _cursor.delta.y;
    01915   }
    01916
    01917   if (scrollwheel_scrolling) {
    01918     /* We are using scrollwheels for scrolling */
    01919     delta.x = _cursor.h_wheel;
    01920     delta.y = _cursor.v_wheel;
    01921     _cursor.v_wheel = 0;
    01922     _cursor.h_wheel = 0;
    01923   }
    01924
    01925   /* Create a scroll-event and send it to the window */
    01926   if (delta.x != 0 || delta.y != 0) _last_scroll_window->OnScroll(delta);
    01927
    01928   _cursor.delta.x = 0;
    01929   _cursor.delta.y = 0;
    01930   return ES_HANDLED;
    01931 }
    01932
    01943 static bool MaybeBringWindowToFront(Window *w)
    01944 {
    01945   bool bring_to_front = false;
    01946
    01947   if (w->window_class == WC_MAIN_WINDOW ||
    01948       IsVitalWindow(w) ||
    01949       w->window_class == WC_TOOLTIPS ||
    01950       w->window_class == WC_DROPDOWN_MENU) {
    01951     return true;
    01952   }
    01953
    01954   /* Use unshaded window size rather than current size for shaded windows. */
    01955   int w_width  = w->width;
    01956   int w_height = w->height;
    01957   if (w->IsShaded()) {
    01958     w_width  = w->unshaded_size.width;
    01959     w_height = w->unshaded_size.height;
    01960   }
    01961
    01962   Window *u;
    01963   FOR_ALL_WINDOWS_FROM_BACK_FROM(u, w->z_front) {
    01964     /* A modal child will prevent the activation of the parent window */
    01965     if (u->parent == w && (u->desc_flags & WDF_MODAL)) {
    01966       u->flags4 |= WF_WHITE_BORDER_MASK;
    01967       u->SetDirty();
    01968       return false;
    01969     }
    01970
    01971     if (u->window_class == WC_MAIN_WINDOW ||
    01972         IsVitalWindow(u) ||
    01973         u->window_class == WC_TOOLTIPS ||
    01974         u->window_class == WC_DROPDOWN_MENU) {
    01975       continue;
    01976     }
    01977
    01978     /* Window sizes don't interfere, leave z-order alone */
    01979     if (w->left + w_width <= u->left ||
    01980         u->left + u->width <= w->left ||
    01981         w->top  + w_height <= u->top ||
    01982         u->top + u->height <= w->top) {
    01983       continue;
    01984     }
    01985
    01986     bring_to_front = true;
    01987   }
    01988
    01989   if (bring_to_front) BringWindowToFront(w);
    01990   return true;
    01991 }
    01992
    01997 void HandleKeypress(uint32 raw_key)
    01998 {
    01999   /* World generation is multithreaded and messes with companies.
    02000    * But there is no company related window open anyway, so _current_company is not used. */
    02001   assert(IsGeneratingWorld() || IsLocalCompany());
    02002
    02003   /* Setup event */
    02004   uint16 key     = GB(raw_key,  0, 16);
    02005   uint16 keycode = GB(raw_key, 16, 16);
    02006
    02007   /*
    02008    * The Unicode standard defines an area called the private use area. Code points in this
    02009    * area are reserved for private use and thus not portable between systems. For instance,
    02010    * Apple defines code points for the arrow keys in this area, but these are only printable
    02011    * on a system running OS X. We don't want these keys to show up in text fields and such,
    02012    * and thus we have to clear the unicode character when we encounter such a key.
    02013    */
    02014   if (key >= 0xE000 && key <= 0xF8FF) key = 0;
    02015
    02016   /*
    02017    * If both key and keycode is zero, we don't bother to process the event.
    02018    */
    02019   if (key == 0 && keycode == 0) return;
    02020
    02021   /* Check if the focused window has a focused editbox */
    02022   if (EditBoxInGlobalFocus()) {
    02023     /* All input will in this case go to the focused window */
    02024     if (_focused_window->OnKeyPress(key, keycode) == ES_HANDLED) return;
    02025   }
    02026
    02027   /* Call the event, start with the uppermost window, but ignore the toolbar. */
    02028   Window *w;
    02029   FOR_ALL_WINDOWS_FROM_FRONT(w) {
    02030     if (w->window_class == WC_MAIN_TOOLBAR) continue;
    02031     if (w->OnKeyPress(key, keycode) == ES_HANDLED) return;
    02032   }
    02033
    02034   w = FindWindowById(WC_MAIN_TOOLBAR, 0);
    02035   /* When there is no toolbar w is null, check for that */
    02036   if (w != NULL && w->OnKeyPress(key, keycode) == ES_HANDLED) return;
    02037
    02038   HandleGlobalHotkeys(key, keycode);
    02039 }
    02040
    02044 void HandleCtrlChanged()
    02045 {
    02046   /* Call the event, start with the uppermost window. */
    02047   Window *w;
    02048   FOR_ALL_WINDOWS_FROM_FRONT(w) {
    02049     if (w->OnCTRLStateChange() == ES_HANDLED) return;
    02050   }
    02051 }
    02052
    02059 static int _input_events_this_tick = 0;
    02060
    02065 static void HandleAutoscroll()
    02066 {
    02067   if (_settings_client.gui.autoscroll && _game_mode != GM_MENU && !IsGeneratingWorld()) {
    02068     int x = _cursor.pos.x;
    02069     int y = _cursor.pos.y;
    02070     Window *w = FindWindowFromPt(x, y);
    02071     if (w == NULL || w->flags4 & WF_DISABLE_VP_SCROLL) return;
    02072     ViewPort *vp = IsPtInWindowViewport(w, x, y);
    02073     if (vp != NULL) {
    02074       x -= vp->left;
    02075       y -= vp->top;
    02076
    02077       /* here allows scrolling in both x and y axis */
    02078 #define scrollspeed 3
    02079       if (x - 15 < 0) {
    02080         w->viewport->dest_scrollpos_x += ScaleByZoom((x - 15) * scrollspeed, vp->zoom);
    02081       } else if (15 - (vp->width - x) > 0) {
    02082         w->viewport->dest_scrollpos_x += ScaleByZoom((15 - (vp->width - x)) * scrollspeed, vp->zoom);
    02083       }
    02084       if (y - 15 < 0) {
    02085         w->viewport->dest_scrollpos_y += ScaleByZoom((y - 15) * scrollspeed, vp->zoom);
    02086       } else if (15 - (vp->height - y) > 0) {
    02087         w->viewport->dest_scrollpos_y += ScaleByZoom((15 - (vp->height - y)) * scrollspeed, vp->zoom);
    02088       }
    02089 #undef scrollspeed
    02090     }
    02091   }
    02092 }
    02093
    02094 enum MouseClick {
    02095   MC_NONE = 0,
    02096   MC_LEFT,
    02097   MC_RIGHT,
    02098   MC_DOUBLE_LEFT,
    02099   MC_HOVER,
    02100
    02101   MAX_OFFSET_DOUBLE_CLICK = 5,
    02102   TIME_BETWEEN_DOUBLE_CLICK = 500,
    02103   MAX_OFFSET_HOVER = 5,
    02104 };
    02105 extern EventState VpHandlePlaceSizingDrag();
    02106
    02107 static void ScrollMainViewport(int x, int y)
    02108 {
    02109   if (_game_mode != GM_MENU) {
    02110     Window *w = FindWindowById(WC_MAIN_WINDOW, 0);
    02111     assert(w);
    02112
    02113     w->viewport->dest_scrollpos_x += ScaleByZoom(x, w->viewport->zoom);
    02114     w->viewport->dest_scrollpos_y += ScaleByZoom(y, w->viewport->zoom);
    02115   }
    02116 }
    02117
    02127 static const int8 scrollamt[16][2] = {
    02128   { 0,  0},
    02129   {-2,  0},
    02130   { 0, -2},
    02131   {-2, -1},
    02132   { 2,  0},
    02133   { 0,  0},
    02134   { 2, -1},
    02135   { 0, -2},
    02136   { 0,  2},
    02137   {-2,  1},
    02138   { 0,  0},
    02139   {-2,  0},
    02140   { 2,  1},
    02141   { 0,  2},
    02142   { 2,  0},
    02143   { 0,  0},
    02144 };
    02145
    02146 static void HandleKeyScrolling()
    02147 {
    02148   /*
    02149    * Check that any of the dirkeys is pressed and that the focused window
    02150    * dont has an edit-box as focused widget.
    02151    */
    02152   if (_dirkeys && !EditBoxInGlobalFocus()) {
    02153     int factor = _shift_pressed ? 50 : 10;
    02154     ScrollMainViewport(scrollamt[_dirkeys][0] * factor, scrollamt[_dirkeys][1] * factor);
    02155   }
    02156 }
    02157
    02158 static void MouseLoop(MouseClick click, int mousewheel)
    02159 {
    02160   /* World generation is multithreaded and messes with companies.
    02161    * But there is no company related window open anyway, so _current_company is not used. */
    02162   assert(IsGeneratingWorld() || IsLocalCompany());
    02163
    02164   HandlePlacePresize();
    02165   UpdateTileSelection();
    02166
    02167   if (VpHandlePlaceSizingDrag()  == ES_HANDLED) return;
    02168   if (HandleMouseDragDrop()      == ES_HANDLED) return;
    02169   if (HandleWindowDragging()     == ES_HANDLED) return;
    02170   if (HandleScrollbarScrolling() == ES_HANDLED) return;
    02171   if (HandleViewportScroll()     == ES_HANDLED) return;
    02172
    02173   HandleMouseOver();
    02174
    02175   bool scrollwheel_scrolling = _settings_client.gui.scrollwheel_scrolling == 1 && (_cursor.v_wheel != 0 || _cursor.h_wheel != 0);
    02176   if (click == MC_NONE && mousewheel == 0 && !scrollwheel_scrolling) return;
    02177
    02178   int x = _cursor.pos.x;
    02179   int y = _cursor.pos.y;
    02180   Window *w = FindWindowFromPt(x, y);
    02181   if (w == NULL) return;
    02182
    02183   if (click != MC_HOVER && !MaybeBringWindowToFront(w)) return;
    02184   ViewPort *vp = IsPtInWindowViewport(w, x, y);
    02185
    02186   /* Don't allow any action in a viewport if either in menu of in generating world */
    02187   if (vp != NULL && (_game_mode == GM_MENU || IsGeneratingWorld())) return;
    02188
    02189   if (mousewheel != 0) {
    02190     /* Send mousewheel event to window */
    02191     w->OnMouseWheel(mousewheel);
    02192
    02193     /* Dispatch a MouseWheelEvent for widgets if it is not a viewport */
    02194     if (vp == NULL) DispatchMouseWheelEvent(w, w->nested_root->GetWidgetFromPos(x - w->left, y - w->top), mousewheel);
    02195   }
    02196
    02197   if (vp != NULL) {
    02198     if (scrollwheel_scrolling) click = MC_RIGHT; // we are using the scrollwheel in a viewport, so we emulate right mouse button
    02199     switch (click) {
    02200       case MC_DOUBLE_LEFT:
    02201       case MC_LEFT:
    02202         DEBUG(misc, 2, "Cursor: 0x%X (%d)", _cursor.sprite, _cursor.sprite);
    02203         if (!HandleViewportClicked(vp, x, y) &&
    02204             !(w->flags4 & WF_DISABLE_VP_SCROLL) &&
    02205             _settings_client.gui.left_mouse_btn_scrolling) {
    02206           _scrolling_viewport = true;
    02207           _cursor.fix_at = false;
    02208         }
    02209         break;
    02210
    02211       case MC_RIGHT:
    02212         if (!(w->flags4 & WF_DISABLE_VP_SCROLL)) {
    02213           _scrolling_viewport = true;
    02214           _cursor.fix_at = true;
    02215
    02216           /* clear 2D scrolling caches before we start a 2D scroll */
    02217           _cursor.h_wheel = 0;
    02218           _cursor.v_wheel = 0;
    02219         }
    02220         break;
    02221
    02222       default:
    02223         break;
    02224     }
    02225   } else {
    02226     switch (click) {
    02227       case MC_LEFT:
    02228       case MC_DOUBLE_LEFT:
    02229         DispatchLeftClickEvent(w, x - w->left, y - w->top, click == MC_DOUBLE_LEFT ? 2 : 1);
    02230         break;
    02231
    02232       default:
    02233         if (!scrollwheel_scrolling || w == NULL || w->window_class != WC_SMALLMAP) break;
    02234         /* We try to use the scrollwheel to scroll since we didn't touch any of the buttons.
    02235          * Simulate a right button click so we can get started. */
    02236         /* FALL THROUGH */
    02237
    02238       case MC_RIGHT: DispatchRightClickEvent(w, x - w->left, y - w->top); break;
    02239
    02240       case MC_HOVER: DispatchHoverEvent(w, x - w->left, y - w->top); break;
    02241     }
    02242   }
    02243 }
    02244
    02248 void HandleMouseEvents()
    02249 {
    02250   /* World generation is multithreaded and messes with companies.
    02251    * But there is no company related window open anyway, so _current_company is not used. */
    02252   assert(IsGeneratingWorld() || IsLocalCompany());
    02253
    02254   static int double_click_time = 0;
    02255   static Point double_click_pos = {0, 0};
    02256
    02257   /* Mouse event? */
    02258   MouseClick click = MC_NONE;
    02259   if (_left_button_down && !_left_button_clicked) {
    02260     click = MC_LEFT;
    02261     if (double_click_time != 0 && _realtime_tick - double_click_time   < TIME_BETWEEN_DOUBLE_CLICK &&
    02262         double_click_pos.x != 0 && abs(_cursor.pos.x - double_click_pos.x) < MAX_OFFSET_DOUBLE_CLICK  &&
    02263         double_click_pos.y != 0 && abs(_cursor.pos.y - double_click_pos.y) < MAX_OFFSET_DOUBLE_CLICK) {
    02264       click = MC_DOUBLE_LEFT;
    02265     }
    02266     double_click_time = _realtime_tick;
    02267     double_click_pos = _cursor.pos;
    02268     _left_button_clicked = true;
    02269     _input_events_this_tick++;
    02270   } else if (_right_button_clicked) {
    02271     _right_button_clicked = false;
    02272     click = MC_RIGHT;
    02273     _input_events_this_tick++;
    02274   }
    02275
    02276   int mousewheel = 0;
    02277   if (_cursor.wheel) {
    02278     mousewheel = _cursor.wheel;
    02279     _cursor.wheel = 0;
    02280     _input_events_this_tick++;
    02281   }
    02282
    02283   static uint32 hover_time = 0;
    02284   static Point hover_pos = {0, 0};
    02285
    02286   if (_settings_client.gui.hover_delay > 0) {
    02287     if (!_cursor.in_window || click != MC_NONE || mousewheel != 0 || _left_button_down || _right_button_down ||
    02288         hover_pos.x == 0 || abs(_cursor.pos.x - hover_pos.x) >= MAX_OFFSET_HOVER  ||
    02289         hover_pos.y == 0 || abs(_cursor.pos.y - hover_pos.y) >= MAX_OFFSET_HOVER) {
    02290       hover_pos = _cursor.pos;
    02291       hover_time = _realtime_tick;
    02292       _mouse_hovering = false;
    02293     } else {
    02294       if (hover_time != 0 && _realtime_tick > hover_time + _settings_client.gui.hover_delay * 1000) {
    02295         click = MC_HOVER;
    02296         _input_events_this_tick++;
    02297         _mouse_hovering = true;
    02298       }
    02299     }
    02300   }
    02301
    02302   /* Handle sprite picker before any GUI interaction */
    02303   if (_newgrf_debug_sprite_picker.mode == SPM_REDRAW && _newgrf_debug_sprite_picker.click_time != _realtime_tick) {
    02304     /* Next realtime tick? Then redraw has finished */
    02305     _newgrf_debug_sprite_picker.mode = SPM_NONE;
    02306     InvalidateWindowData(WC_SPRITE_ALIGNER, 0, 1);
    02307   }
    02308
    02309   if (click == MC_LEFT && _newgrf_debug_sprite_picker.mode == SPM_WAIT_CLICK) {
    02310     /* Mark whole screen dirty, and wait for the next realtime tick, when drawing is finished. */
    02311     Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();
    02312     _newgrf_debug_sprite_picker.clicked_pixel = blitter->MoveTo(_screen.dst_ptr, _cursor.pos.x, _cursor.pos.y);
    02313     _newgrf_debug_sprite_picker.click_time = _realtime_tick;
    02314     _newgrf_debug_sprite_picker.sprites.Clear();
    02315     _newgrf_debug_sprite_picker.mode = SPM_REDRAW;
    02316     MarkWholeScreenDirty();
    02317   } else {
    02318     MouseLoop(click, mousewheel);
    02319   }
    02320
    02321   /* We have moved the mouse the required distance,
    02322    * no need to move it at any later time. */
    02323   _cursor.delta.x = 0;
    02324   _cursor.delta.y = 0;
    02325 }
    02326
    02330 static void CheckSoftLimit()
    02331 {
    02332   if (_settings_client.gui.window_soft_limit == 0) return;
    02333
    02334   for (;;) {
    02335     uint deletable_count = 0;
    02336     Window *w, *last_deletable = NULL;
    02337     FOR_ALL_WINDOWS_FROM_FRONT(w) {
    02338       if (w->window_class == WC_MAIN_WINDOW || IsVitalWindow(w) || (w->flags4 & WF_STICKY)) continue;
    02339
    02340       last_deletable = w;
    02341       deletable_count++;
    02342     }
    02343
    02344     /* We've ot reached the soft limit yet */
    02345     if (deletable_count <= _settings_client.gui.window_soft_limit) break;
    02346
    02347     assert(last_deletable != NULL);
    02348     delete last_deletable;
    02349   }
    02350 }
    02351
    02355 void InputLoop()
    02356 {
    02357   /* World generation is multithreaded and messes with companies.
    02358    * But there is no company related window open anyway, so _current_company is not used. */
    02359   assert(IsGeneratingWorld() || IsLocalCompany());
    02360
    02361   CheckSoftLimit();
    02362   HandleKeyScrolling();
    02363
    02364   /* Do the actual free of the deleted windows. */
    02365   for (Window *v = _z_front_window; v != NULL; /* nothing */) {
    02366     Window *w = v;
    02367     v = v->z_back;
    02368
    02369     if (w->window_class != WC_INVALID) continue;
    02370
    02371     /* Find the window in the z-array, and effectively remove it
    02372      * by moving all windows after it one to the left. This must be
    02373      * done before removing the child so we cannot cause recursion
    02374      * between the deletion of the parent and the child. */
    02375     if (w->z_front == NULL) {
    02376       _z_front_window = w->z_back;
    02377     } else {
    02378       w->z_front->z_back = w->z_back;
    02379     }
    02380     if (w->z_back == NULL) {
    02381       _z_back_window  = w->z_front;
    02382     } else {
    02383       w->z_back->z_front = w->z_front;
    02384     }
    02385     free(w);
    02386   }
    02387
    02388   if (_scroller_click_timeout != 0) _scroller_click_timeout--;
    02389   DecreaseWindowCounters();
    02390
    02391   if (_input_events_this_tick != 0) {
    02392     /* The input loop is called only once per GameLoop() - so we can clear the counter here */
    02393     _input_events_this_tick = 0;
    02394     /* there were some inputs this tick, don't scroll ??? */
    02395     return;
    02396   }
    02397
    02398   /* HandleMouseEvents was already called for this tick */
    02399   HandleMouseEvents();
    02400   HandleAutoscroll();
    02401 }
    02402
    02406 void UpdateWindows()
    02407 {
    02408   Window *w;
    02409
    02410   FOR_ALL_WINDOWS_FROM_FRONT(w) {
    02411     w->ProcessScheduledInvalidations();
    02412   }
    02413
    02414   static int we4_timer = 0;
    02415   int t = we4_timer + 1;
    02416
    02417   if (t >= 100) {
    02418     FOR_ALL_WINDOWS_FROM_FRONT(w) {
    02419       w->OnHundredthTick();
    02420     }
    02421     t = 0;
    02422   }
    02423   we4_timer = t;
    02424
    02425   FOR_ALL_WINDOWS_FROM_FRONT(w) {
    02426     if (w->flags4 & WF_WHITE_BORDER_MASK) {
    02427       w->flags4 -= WF_WHITE_BORDER_ONE;
    02428
    02429       if (!(w->flags4 & WF_WHITE_BORDER_MASK)) w->SetDirty();
    02430     }
    02431   }
    02432
    02433   DrawDirtyBlocks();
    02434
    02435   FOR_ALL_WINDOWS_FROM_BACK(w) {
    02436     /* Update viewport only if window is not shaded. */
    02437     if (w->viewport != NULL && !w->IsShaded()) UpdateViewportPosition(w);
    02438   }
    02439   NetworkDrawChatMessage();
    02440   /* Redraw mouse cursor in case it was hidden */
    02441   DrawMouseCursor();
    02442 }
    02443
    02449 void SetWindowDirty(WindowClass cls, WindowNumber number)
    02450 {
    02451   const Window *w;
    02452   FOR_ALL_WINDOWS_FROM_BACK(w) {
    02453     if (w->window_class == cls && w->window_number == number) w->SetDirty();
    02454   }
    02455 }
    02456
    02463 void SetWindowWidgetDirty(WindowClass cls, WindowNumber number, byte widget_index)
    02464 {
    02465   const Window *w;
    02466   FOR_ALL_WINDOWS_FROM_BACK(w) {
    02467     if (w->window_class == cls && w->window_number == number) {
    02468       w->SetWidgetDirty(widget_index);
    02469     }
    02470   }
    02471 }
    02472
    02477 void SetWindowClassesDirty(WindowClass cls)
    02478 {
    02479   Window *w;
    02480   FOR_ALL_WINDOWS_FROM_BACK(w) {
    02481     if (w->window_class == cls) w->SetDirty();
    02482   }
    02483 }
    02484
    02511 void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
    02512 {
    02513   Window *w;
    02514   FOR_ALL_WINDOWS_FROM_BACK(w) {
    02515     if (w->window_class == cls && w->window_number == number) {
    02516       w->InvalidateData(data, gui_scope);
    02517     }
    02518   }
    02519 }
    02520
    02529 void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope)
    02530 {
    02531   Window *w;
    02532
    02533   FOR_ALL_WINDOWS_FROM_BACK(w) {
    02534     if (w->window_class == cls) {
    02535       w->InvalidateData(data, gui_scope);
    02536     }
    02537   }
    02538 }
    02539
    02543 void CallWindowTickEvent()
    02544 {
    02545   Window *w;
    02546   FOR_ALL_WINDOWS_FROM_FRONT(w) {
    02547     w->OnTick();
    02548   }
    02549 }
    02550
    02557 void DeleteNonVitalWindows()
    02558 {
    02559   Window *w;
    02560
    02561 restart_search:
    02562   /* When we find the window to delete, we need to restart the search
    02563    * as deleting this window could cascade in deleting (many) others
    02564    * anywhere in the z-array */
    02565   FOR_ALL_WINDOWS_FROM_BACK(w) {
    02566     if (w->window_class != WC_MAIN_WINDOW &&
    02567         w->window_class != WC_SELECT_GAME &&
    02568         w->window_class != WC_MAIN_TOOLBAR &&
    02569         w->window_class != WC_STATUS_BAR &&
    02570         w->window_class != WC_TOOLBAR_MENU &&
    02571         w->window_class != WC_TOOLTIPS &&
    02572         (w->flags4 & WF_STICKY) == 0) { // do not delete windows which are 'pinned'
    02573
    02574       delete w;
    02575       goto restart_search;
    02576     }
    02577   }
    02578 }
    02579
    02587 void DeleteAllNonVitalWindows()
    02588 {
    02589   Window *w;
    02590
    02591   /* Delete every window except for stickied ones, then sticky ones as well */
    02592   DeleteNonVitalWindows();
    02593
    02594 restart_search:
    02595   /* When we find the window to delete, we need to restart the search
    02596    * as deleting this window could cascade in deleting (many) others
    02597    * anywhere in the z-array */
    02598   FOR_ALL_WINDOWS_FROM_BACK(w) {
    02599     if (w->flags4 & WF_STICKY) {
    02600       delete w;
    02601       goto restart_search;
    02602     }
    02603   }
    02604 }
    02605
    02610 void DeleteConstructionWindows()
    02611 {
    02612   Window *w;
    02613
    02614 restart_search:
    02615   /* When we find the window to delete, we need to restart the search
    02616    * as deleting this window could cascade in deleting (many) others
    02617    * anywhere in the z-array */
    02618   FOR_ALL_WINDOWS_FROM_BACK(w) {
    02619     if (w->desc_flags & WDF_CONSTRUCTION) {
    02620       delete w;
    02621       goto restart_search;
    02622     }
    02623   }
    02624
    02625   FOR_ALL_WINDOWS_FROM_BACK(w) w->SetDirty();
    02626 }
    02627
    02629 void HideVitalWindows()
    02630 {
    02631   DeleteWindowById(WC_TOOLBAR_MENU, 0);
    02632   DeleteWindowById(WC_MAIN_TOOLBAR, 0);
    02633   DeleteWindowById(WC_STATUS_BAR, 0);
    02634 }
    02635
    02637 void ReInitAllWindows()
    02638 {
    02639   NWidgetLeaf::InvalidateDimensionCache(); // Reset cached sizes of several widgets.
    02640
    02641   Window *w;
    02642   FOR_ALL_WINDOWS_FROM_BACK(w) {
    02643     w->ReInit();
    02644   }
    02645 #ifdef ENABLE_NETWORK
    02646   void NetworkReInitChatBoxSize();
    02647   NetworkReInitChatBoxSize();
    02648 #endif
    02649
    02650   /* Make sure essential parts of all windows are visible */
    02651   RelocateAllWindows(_cur_resolution.width, _cur_resolution.height);
    02652   MarkWholeScreenDirty();
    02653 }
    02654
    02662 static int PositionWindow(Window *w, WindowClass clss, int setting)
    02663 {
    02664   if (w == NULL || w->window_class != clss) {
    02665     w = FindWindowById(clss, 0);
    02666   }
    02667   if (w == NULL) return 0;
    02668
    02669   int old_left = w->left;
    02670   switch (setting) {
    02671     case 1:  w->left = (_screen.width - w->width) / 2; break;
    02672     case 2:  w->left = _screen.width - w->width; break;
    02673     default: w->left = 0; break;
    02674   }
    02675   if (w->viewport != NULL) w->viewport->left += w->left - old_left;
    02676   SetDirtyBlocks(0, w->top, _screen.width, w->top + w->height); // invalidate the whole row
    02677   return w->left;
    02678 }
    02679
    02685 int PositionMainToolbar(Window *w)
    02686 {
    02687   DEBUG(misc, 5, "Repositioning Main Toolbar...");
    02688   return PositionWindow(w, WC_MAIN_TOOLBAR, _settings_client.gui.toolbar_pos);
    02689 }
    02690
    02696 int PositionStatusbar(Window *w)
    02697 {
    02698   DEBUG(misc, 5, "Repositioning statusbar...");
    02699   return PositionWindow(w, WC_STATUS_BAR, _settings_client.gui.statusbar_pos);
    02700 }
    02701
    02707 int PositionNewsMessage(Window *w)
    02708 {
    02709   DEBUG(misc, 5, "Repositioning news message...");
    02710   return PositionWindow(w, WC_NEWS_WINDOW, _settings_client.gui.statusbar_pos);
    02711 }
    02712
    02718 int PositionNetworkChatWindow(Window *w)
    02719 {
    02720   DEBUG(misc, 5, "Repositioning network chat window...");
    02721   return PositionWindow(w, WC_SEND_NETWORK_MSG, _settings_client.gui.statusbar_pos);
    02722 }
    02723
    02724
    02730 void ChangeVehicleViewports(VehicleID from_index, VehicleID to_index)
    02731 {
    02732   Window *w;
    02733   FOR_ALL_WINDOWS_FROM_BACK(w) {
    02734     if (w->viewport != NULL && w->viewport->follow_vehicle == from_index) {
    02735       w->viewport->follow_vehicle = to_index;
    02736       w->SetDirty();
    02737     }
    02738   }
    02739 }
    02740
    02741
    02747 void RelocateAllWindows(int neww, int newh)
    02748 {
    02749   Window *w;
    02750
    02751   FOR_ALL_WINDOWS_FROM_BACK(w) {
    02752     int left, top;
    02753
    02754     if (w->window_class == WC_MAIN_WINDOW) {
    02755       ViewPort *vp = w->viewport;
    02756       vp->width = w->width = neww;
    02757       vp->height = w->height = newh;
    02758       vp->virtual_width = ScaleByZoom(neww, vp->zoom);
    02759       vp->virtual_height = ScaleByZoom(newh, vp->zoom);
    02760       continue; // don't modify top,left
    02761     }
    02762
    02763     /* XXX - this probably needs something more sane. For example specifying
    02764      * in a 'backup'-desc that the window should always be centered. */
    02765     switch (w->window_class) {
    02766       case WC_MAIN_TOOLBAR:
    02767         ResizeWindow(w, min(neww, *_preferred_toolbar_size) - w->width, 0);
    02768
    02769         top = w->top;
    02770         left = PositionMainToolbar(w); // changes toolbar orientation
    02771         break;
    02772
    02773       case WC_NEWS_WINDOW:
    02774         top = newh - w->height;
    02775         left = PositionNewsMessage(w);
    02776         break;
    02777
    02778       case WC_STATUS_BAR:
    02779         ResizeWindow(w, min(neww, *_preferred_statusbar_size) - w->width, 0);
    02780
    02781         top = newh - w->height;
    02782         left = PositionStatusbar(w);
    02783         break;
    02784
    02785       case WC_SEND_NETWORK_MSG:
    02786         ResizeWindow(w, Clamp(neww, 320, 640) - w->width, 0);
    02787         top = newh - w->height - FindWindowById(WC_STATUS_BAR, 0)->height;
    02788         left = PositionNetworkChatWindow(w);
    02789         break;
    02790
    02791       case WC_CONSOLE:
    02792         IConsoleResize(w);
    02793         continue;
    02794
    02795       default: {
    02796         if (w->flags4 & WF_CENTERED) {
    02797           top = (newh - w->height) >> 1;
    02798           left = (neww - w->width) >> 1;
    02799           break;
    02800         }
    02801
    02802         left = w->left;
    02803         if (left + (w->width >> 1) >= neww) left = neww - w->width;
    02804         if (left < 0) left = 0;
    02805
    02806         top = w->top;
    02807         if (top + (w->height >> 1) >= newh) top = newh - w->height;
    02808
    02809         const Window *wt = FindWindowById(WC_MAIN_TOOLBAR, 0);
    02810         if (wt != NULL) {
    02811           if (top < wt->height && wt->left < (w->left + w->width) && (wt->left + wt->width) > w->left) top = wt->height;
    02812           if (top >= newh) top = newh - 1;
    02813         } else {
    02814           if (top < 0) top = 0;
    02815         }
    02816         break;
    02817       }
    02818     }
    02819
    02820     if (w->viewport != NULL) {
    02821       w->viewport->left += left - w->left;
    02822       w->viewport->top += top - w->top;
    02823     }
    02824
    02825     w->left = left;
    02826     w->top = top;
    02827   }
    02828 }
    02829
    02835 PickerWindowBase::~PickerWindowBase()
    02836 {
    02837   this->window_class = WC_INVALID; // stop the ancestor from freeing the already (to be) child
    02838   ResetObjectToPlace();
    02839 }