window.cpp

Go to the documentation of this file.
00001 /* $Id: window.cpp 22461 2011-05-15 09:38:54Z rubidium $ */
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;
00545   _cur_dpi = &bk;
00546 
00547   FOR_ALL_WINDOWS_FROM_BACK(w) {
00548     if (right > w->left &&
00549         bottom > w->top &&
00550         left < w->left + w->width &&
00551         top < w->top + w->height) {
00552       /* Window w intersects with the rectangle => needs repaint */
00553       DrawOverlappedWindow(w, left, top, right, bottom);
00554     }
00555   }
00556 }
00557 
00562 void Window::SetDirty() const
00563 {
00564   SetDirtyBlocks(this->left, this->top, this->left + this->width, this->top + this->height);
00565 }
00566 
00573 void Window::ReInit(int rx, int ry)
00574 {
00575   this->SetDirty(); // Mark whole current window as dirty.
00576 
00577   /* Save current size. */
00578   int window_width  = this->width;
00579   int window_height = this->height;
00580 
00581   this->OnInit();
00582   /* Re-initialize the window from the ground up. No need to change the nested_array, as all widgets stay where they are. */
00583   this->nested_root->SetupSmallestSize(this, false);
00584   this->nested_root->AssignSizePosition(ST_SMALLEST, 0, 0, this->nested_root->smallest_x, this->nested_root->smallest_y, _current_text_dir == TD_RTL);
00585   this->width  = this->nested_root->smallest_x;
00586   this->height = this->nested_root->smallest_y;
00587   this->resize.step_width  = this->nested_root->resize_x;
00588   this->resize.step_height = this->nested_root->resize_y;
00589 
00590   /* Resize as close to the original size + requested resize as possible. */
00591   window_width  = max(window_width  + rx, this->width);
00592   window_height = max(window_height + ry, this->height);
00593   int dx = (this->resize.step_width  == 0) ? 0 : window_width  - this->width;
00594   int dy = (this->resize.step_height == 0) ? 0 : window_height - this->height;
00595   /* dx and dy has to go by step.. calculate it.
00596    * The cast to int is necessary else dx/dy are implicitly casted to unsigned int, which won't work. */
00597   if (this->resize.step_width  > 1) dx -= dx % (int)this->resize.step_width;
00598   if (this->resize.step_height > 1) dy -= dy % (int)this->resize.step_height;
00599 
00600   ResizeWindow(this, dx, dy);
00601   /* ResizeWindow() does this->SetDirty() already, no need to do it again here. */
00602 }
00603 
00609 void Window::SetShaded(bool make_shaded)
00610 {
00611   if (this->shade_select == NULL) return;
00612 
00613   int desired = make_shaded ? SZSP_HORIZONTAL : 0;
00614   if (this->shade_select->shown_plane != desired) {
00615     if (make_shaded) {
00616       this->unshaded_size.width  = this->width;
00617       this->unshaded_size.height = this->height;
00618       this->shade_select->SetDisplayedPlane(desired);
00619       this->ReInit(0, -this->height);
00620     } else {
00621       this->shade_select->SetDisplayedPlane(desired);
00622       int dx = ((int)this->unshaded_size.width  > this->width)  ? (int)this->unshaded_size.width  - this->width  : 0;
00623       int dy = ((int)this->unshaded_size.height > this->height) ? (int)this->unshaded_size.height - this->height : 0;
00624       this->ReInit(dx, dy);
00625     }
00626   }
00627 }
00628 
00635 static Window *FindChildWindow(const Window *w, WindowClass wc)
00636 {
00637   Window *v;
00638   FOR_ALL_WINDOWS_FROM_BACK(v) {
00639     if ((wc == WC_INVALID || wc == v->window_class) && v->parent == w) return v;
00640   }
00641 
00642   return NULL;
00643 }
00644 
00649 void Window::DeleteChildWindows(WindowClass wc) const
00650 {
00651   Window *child = FindChildWindow(this, wc);
00652   while (child != NULL) {
00653     delete child;
00654     child = FindChildWindow(this, wc);
00655   }
00656 }
00657 
00661 Window::~Window()
00662 {
00663   if (_thd.window_class == this->window_class &&
00664       _thd.window_number == this->window_number) {
00665     ResetObjectToPlace();
00666   }
00667 
00668   /* Prevent Mouseover() from resetting mouse-over coordinates on a non-existing window */
00669   if (_mouseover_last_w == this) _mouseover_last_w = NULL;
00670 
00671   /* We can't scroll the window when it's closed. */
00672   if (_last_scroll_window == this) _last_scroll_window = NULL;
00673 
00674   /* Make sure we don't try to access this window as the focused window when it doesn't exist anymore. */
00675   if (_focused_window == this) _focused_window = NULL;
00676 
00677   this->DeleteChildWindows();
00678 
00679   if (this->viewport != NULL) DeleteWindowViewport(this);
00680 
00681   this->SetDirty();
00682 
00683   free(this->nested_array); // Contents is released through deletion of #nested_root.
00684   delete this->nested_root;
00685 
00686   this->window_class = WC_INVALID;
00687 }
00688 
00695 Window *FindWindowById(WindowClass cls, WindowNumber number)
00696 {
00697   Window *w;
00698   FOR_ALL_WINDOWS_FROM_BACK(w) {
00699     if (w->window_class == cls && w->window_number == number) return w;
00700   }
00701 
00702   return NULL;
00703 }
00704 
00711 Window *FindWindowByClass(WindowClass cls)
00712 {
00713   Window *w;
00714   FOR_ALL_WINDOWS_FROM_BACK(w) {
00715     if (w->window_class == cls) return w;
00716   }
00717 
00718   return NULL;
00719 }
00720 
00727 void DeleteWindowById(WindowClass cls, WindowNumber number, bool force)
00728 {
00729   Window *w = FindWindowById(cls, number);
00730   if (force || w == NULL ||
00731       (w->flags4 & WF_STICKY) == 0) {
00732     delete w;
00733   }
00734 }
00735 
00740 void DeleteWindowByClass(WindowClass cls)
00741 {
00742   Window *w;
00743 
00744 restart_search:
00745   /* When we find the window to delete, we need to restart the search
00746    * as deleting this window could cascade in deleting (many) others
00747    * anywhere in the z-array */
00748   FOR_ALL_WINDOWS_FROM_BACK(w) {
00749     if (w->window_class == cls) {
00750       delete w;
00751       goto restart_search;
00752     }
00753   }
00754 }
00755 
00762 void DeleteCompanyWindows(CompanyID id)
00763 {
00764   Window *w;
00765 
00766 restart_search:
00767   /* When we find the window to delete, we need to restart the search
00768    * as deleting this window could cascade in deleting (many) others
00769    * anywhere in the z-array */
00770   FOR_ALL_WINDOWS_FROM_BACK(w) {
00771     if (w->owner == id) {
00772       delete w;
00773       goto restart_search;
00774     }
00775   }
00776 
00777   /* Also delete the company specific windows that don't have a company-colour. */
00778   DeleteWindowById(WC_BUY_COMPANY, id);
00779 }
00780 
00788 void ChangeWindowOwner(Owner old_owner, Owner new_owner)
00789 {
00790   Window *w;
00791   FOR_ALL_WINDOWS_FROM_BACK(w) {
00792     if (w->owner != old_owner) continue;
00793 
00794     switch (w->window_class) {
00795       case WC_COMPANY_COLOUR:
00796       case WC_FINANCES:
00797       case WC_STATION_LIST:
00798       case WC_TRAINS_LIST:
00799       case WC_ROADVEH_LIST:
00800       case WC_SHIPS_LIST:
00801       case WC_AIRCRAFT_LIST:
00802       case WC_BUY_COMPANY:
00803       case WC_COMPANY:
00804         continue;
00805 
00806       default:
00807         w->owner = new_owner;
00808         break;
00809     }
00810   }
00811 }
00812 
00813 static void BringWindowToFront(Window *w);
00814 
00822 Window *BringWindowToFrontById(WindowClass cls, WindowNumber number)
00823 {
00824   Window *w = FindWindowById(cls, number);
00825 
00826   if (w != NULL) {
00827     if (w->IsShaded()) w->SetShaded(false); // Restore original window size if it was shaded.
00828 
00829     w->flags4 |= WF_WHITE_BORDER_MASK;
00830     BringWindowToFront(w);
00831     w->SetDirty();
00832   }
00833 
00834   return w;
00835 }
00836 
00837 static inline bool IsVitalWindow(const Window *w)
00838 {
00839   switch (w->window_class) {
00840     case WC_MAIN_TOOLBAR:
00841     case WC_STATUS_BAR:
00842     case WC_NEWS_WINDOW:
00843     case WC_SEND_NETWORK_MSG:
00844       return true;
00845 
00846     default:
00847       return false;
00848   }
00849 }
00850 
00860 static void BringWindowToFront(Window *w)
00861 {
00862   Window *v = _z_front_window;
00863 
00864   /* Bring the window just below the vital windows */
00865   for (; v != NULL && v != w && IsVitalWindow(v); v = v->z_back) { }
00866 
00867   if (v == NULL || w == v) return; // window is already in the right position
00868 
00869   /* w cannot be at the top already! */
00870   assert(w != _z_front_window);
00871 
00872   if (w->z_back == NULL) {
00873     _z_back_window = w->z_front;
00874   } else {
00875     w->z_back->z_front = w->z_front;
00876   }
00877   w->z_front->z_back = w->z_back;
00878 
00879   w->z_front = v->z_front;
00880   w->z_back = v;
00881 
00882   if (v->z_front == NULL) {
00883     _z_front_window = w;
00884   } else {
00885     v->z_front->z_back = w;
00886   }
00887   v->z_front = w;
00888 
00889   w->SetDirty();
00890 }
00891 
00900 void Window::InitializeData(const WindowDesc *desc, WindowNumber window_number)
00901 {
00902   /* Set up window properties; some of them are needed to set up smallest size below */
00903   this->window_class = desc->cls;
00904   this->flags4 |= WF_WHITE_BORDER_MASK; // just opened windows have a white border
00905   if (desc->default_pos == WDP_CENTER) this->flags4 |= WF_CENTERED;
00906   this->owner = INVALID_OWNER;
00907   this->nested_focus = NULL;
00908   this->window_number = window_number;
00909   this->desc_flags = desc->flags;
00910 
00911   this->OnInit();
00912   /* Initialize nested widget tree. */
00913   if (this->nested_array == NULL) {
00914     this->nested_array = CallocT<NWidgetBase *>(this->nested_array_size);
00915     this->nested_root->SetupSmallestSize(this, true);
00916   } else {
00917     this->nested_root->SetupSmallestSize(this, false);
00918   }
00919   /* Initialize to smallest size. */
00920   this->nested_root->AssignSizePosition(ST_SMALLEST, 0, 0, this->nested_root->smallest_x, this->nested_root->smallest_y, _current_text_dir == TD_RTL);
00921 
00922   /* Further set up window properties,
00923    * this->left, this->top, this->width, this->height, this->resize.width, and this->resize.height are initialized later. */
00924   this->resize.step_width  = this->nested_root->resize_x;
00925   this->resize.step_height = this->nested_root->resize_y;
00926 
00927   /* Give focus to the opened window unless it is the OSK window or a text box
00928    * of focused window has focus (so we don't interrupt typing). But if the new
00929    * window has a text box, then take focus anyway. */
00930   if (this->window_class != WC_OSK && (!EditBoxInGlobalFocus() || this->nested_root->GetWidgetOfType(WWT_EDITBOX) != NULL)) SetFocusedWindow(this);
00931 
00932   /* Hacky way of specifying always-on-top windows. These windows are
00933    * always above other windows because they are moved below them.
00934    * status-bar is above news-window because it has been created earlier.
00935    * Also, as the chat-window is excluded from this, it will always be
00936    * the last window, thus always on top.
00937    * XXX - Yes, ugly, probably needs something like w->always_on_top flag
00938    * to implement correctly, but even then you need some kind of distinction
00939    * between on-top of chat/news and status windows, because these conflict */
00940   Window *w = _z_front_window;
00941   if (w != NULL && this->window_class != WC_SEND_NETWORK_MSG && this->window_class != WC_HIGHSCORE && this->window_class != WC_ENDSCREEN) {
00942     if (FindWindowById(WC_MAIN_TOOLBAR, 0)     != NULL) w = w->z_back;
00943     if (FindWindowById(WC_STATUS_BAR, 0)       != NULL) w = w->z_back;
00944     if (FindWindowById(WC_NEWS_WINDOW, 0)      != NULL) w = w->z_back;
00945     if (FindWindowByClass(WC_SEND_NETWORK_MSG) != NULL) w = w->z_back;
00946 
00947     if (w == NULL) {
00948       _z_back_window->z_front = this;
00949       this->z_back = _z_back_window;
00950       _z_back_window = this;
00951     } else {
00952       if (w->z_front == NULL) {
00953         _z_front_window = this;
00954       } else {
00955         this->z_front = w->z_front;
00956         w->z_front->z_back = this;
00957       }
00958 
00959       this->z_back = w;
00960       w->z_front = this;
00961     }
00962   } else {
00963     this->z_back = _z_front_window;
00964     if (_z_front_window != NULL) {
00965       _z_front_window->z_front = this;
00966     } else {
00967       _z_back_window = this;
00968     }
00969     _z_front_window = this;
00970   }
00971 }
00972 
00980 void Window::InitializePositionSize(int x, int y, int sm_width, int sm_height)
00981 {
00982   this->left = x;
00983   this->top = y;
00984   this->width = sm_width;
00985   this->height = sm_height;
00986 }
00987 
00998 void Window::FindWindowPlacementAndResize(int def_width, int def_height)
00999 {
01000   def_width  = max(def_width,  this->width); // Don't allow default size to be smaller than smallest size
01001   def_height = max(def_height, this->height);
01002   /* Try to make windows smaller when our window is too small.
01003    * w->(width|height) is normally the same as min_(width|height),
01004    * but this way the GUIs can be made a little more dynamic;
01005    * one can use the same spec for multiple windows and those
01006    * can then determine the real minimum size of the window. */
01007   if (this->width != def_width || this->height != def_height) {
01008     /* Think about the overlapping toolbars when determining the minimum window size */
01009     int free_height = _screen.height;
01010     const Window *wt = FindWindowById(WC_STATUS_BAR, 0);
01011     if (wt != NULL) free_height -= wt->height;
01012     wt = FindWindowById(WC_MAIN_TOOLBAR, 0);
01013     if (wt != NULL) free_height -= wt->height;
01014 
01015     int enlarge_x = max(min(def_width  - this->width,  _screen.width - this->width),  0);
01016     int enlarge_y = max(min(def_height - this->height, free_height   - this->height), 0);
01017 
01018     /* X and Y has to go by step.. calculate it.
01019      * The cast to int is necessary else x/y are implicitly casted to
01020      * unsigned int, which won't work. */
01021     if (this->resize.step_width  > 1) enlarge_x -= enlarge_x % (int)this->resize.step_width;
01022     if (this->resize.step_height > 1) enlarge_y -= enlarge_y % (int)this->resize.step_height;
01023 
01024     ResizeWindow(this, enlarge_x, enlarge_y);
01025     /* ResizeWindow() calls this->OnResize(). */
01026   } else {
01027     /* Always call OnResize; that way the scrollbars and matrices get initialized. */
01028     this->OnResize();
01029   }
01030 
01031   int nx = this->left;
01032   int ny = this->top;
01033 
01034   if (nx + this->width > _screen.width) nx -= (nx + this->width - _screen.width);
01035 
01036   const Window *wt = FindWindowById(WC_MAIN_TOOLBAR, 0);
01037   ny = max(ny, (wt == NULL || this == wt || this->top == 0) ? 0 : wt->height);
01038   nx = max(nx, 0);
01039 
01040   if (this->viewport != NULL) {
01041     this->viewport->left += nx - this->left;
01042     this->viewport->top  += ny - this->top;
01043   }
01044   this->left = nx;
01045   this->top = ny;
01046 
01047   this->SetDirty();
01048 }
01049 
01061 static bool IsGoodAutoPlace1(int left, int top, int width, int height, Point &pos)
01062 {
01063   int right  = width + left;
01064   int bottom = height + top;
01065 
01066   const Window *main_toolbar = FindWindowByClass(WC_MAIN_TOOLBAR);
01067   if (left < 0 || (main_toolbar != NULL && top < main_toolbar->height) || right > _screen.width || bottom > _screen.height) return false;
01068 
01069   /* Make sure it is not obscured by any window. */
01070   const Window *w;
01071   FOR_ALL_WINDOWS_FROM_BACK(w) {
01072     if (w->window_class == WC_MAIN_WINDOW) continue;
01073 
01074     if (right > w->left &&
01075         w->left + w->width > left &&
01076         bottom > w->top &&
01077         w->top + w->height > top) {
01078       return false;
01079     }
01080   }
01081 
01082   pos.x = left;
01083   pos.y = top;
01084   return true;
01085 }
01086 
01098 static bool IsGoodAutoPlace2(int left, int top, int width, int height, Point &pos)
01099 {
01100   /* Left part of the rectangle may be at most 1/4 off-screen,
01101    * right part of the rectangle may be at most 1/2 off-screen
01102    */
01103   if (left < -(width >> 2) || left > _screen.width - (width >> 1)) return false;
01104   /* Bottom part of the rectangle may be at most 1/4 off-screen */
01105   if (top < 22 || top > _screen.height - (height >> 2)) return false;
01106 
01107   /* Make sure it is not obscured by any window. */
01108   const Window *w;
01109   FOR_ALL_WINDOWS_FROM_BACK(w) {
01110     if (w->window_class == WC_MAIN_WINDOW) continue;
01111 
01112     if (left + width > w->left &&
01113         w->left + w->width > left &&
01114         top + height > w->top &&
01115         w->top + w->height > top) {
01116       return false;
01117     }
01118   }
01119 
01120   pos.x = left;
01121   pos.y = top;
01122   return true;
01123 }
01124 
01131 static Point GetAutoPlacePosition(int width, int height)
01132 {
01133   Point pt;
01134 
01135   /* First attempt, try top-left of the screen */
01136   const Window *main_toolbar = FindWindowByClass(WC_MAIN_TOOLBAR);
01137   if (IsGoodAutoPlace1(0, main_toolbar != NULL ? main_toolbar->height + 2 : 2, width, height, pt)) return pt;
01138 
01139   /* Second attempt, try around all existing windows with a distance of 2 pixels.
01140    * The new window must be entirely on-screen, and not overlap with an existing window.
01141    * Eight starting points are tried, two at each corner.
01142    */
01143   const Window *w;
01144   FOR_ALL_WINDOWS_FROM_BACK(w) {
01145     if (w->window_class == WC_MAIN_WINDOW) continue;
01146 
01147     if (IsGoodAutoPlace1(w->left + w->width + 2, w->top, width, height, pt)) return pt;
01148     if (IsGoodAutoPlace1(w->left - width - 2,    w->top, width, height, pt)) return pt;
01149     if (IsGoodAutoPlace1(w->left, w->top + w->height + 2, width, height, pt)) return pt;
01150     if (IsGoodAutoPlace1(w->left, w->top - height - 2,    width, height, pt)) return pt;
01151     if (IsGoodAutoPlace1(w->left + w->width + 2, w->top + w->height - height, width, height, pt)) return pt;
01152     if (IsGoodAutoPlace1(w->left - width - 2,    w->top + w->height - height, width, height, pt)) return pt;
01153     if (IsGoodAutoPlace1(w->left + w->width - width, w->top + w->height + 2, width, height, pt)) return pt;
01154     if (IsGoodAutoPlace1(w->left + w->width - width, w->top - height - 2,    width, height, pt)) return pt;
01155   }
01156 
01157   /* Third attempt, try around all existing windows with a distance of 2 pixels.
01158    * The new window may be partly off-screen, and must not overlap with an existing window.
01159    * Only four starting points are tried.
01160    */
01161   FOR_ALL_WINDOWS_FROM_BACK(w) {
01162     if (w->window_class == WC_MAIN_WINDOW) continue;
01163 
01164     if (IsGoodAutoPlace2(w->left + w->width + 2, w->top, width, height, pt)) return pt;
01165     if (IsGoodAutoPlace2(w->left - width - 2,    w->top, width, height, pt)) return pt;
01166     if (IsGoodAutoPlace2(w->left, w->top + w->height + 2, width, height, pt)) return pt;
01167     if (IsGoodAutoPlace2(w->left, w->top - height - 2,    width, height, pt)) return pt;
01168   }
01169 
01170   /* Fourth and final attempt, put window at diagonal starting from (0, 24), try multiples
01171    * of (+5, +5)
01172    */
01173   int left = 0, top = 24;
01174 
01175 restart:
01176   FOR_ALL_WINDOWS_FROM_BACK(w) {
01177     if (w->left == left && w->top == top) {
01178       left += 5;
01179       top += 5;
01180       goto restart;
01181     }
01182   }
01183 
01184   pt.x = left;
01185   pt.y = top;
01186   return pt;
01187 }
01188 
01195 Point GetToolbarAlignedWindowPosition(int window_width)
01196 {
01197   const Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);
01198   assert(w != NULL);
01199   Point pt = { _current_text_dir == TD_RTL ? w->left : (w->left + w->width) - window_width, w->top + w->height };
01200   return pt;
01201 }
01202 
01220 static Point LocalGetWindowPlacement(const WindowDesc *desc, int16 sm_width, int16 sm_height, int window_number)
01221 {
01222   Point pt;
01223   const Window *w;
01224 
01225   int16 default_width  = max(desc->default_width,  sm_width);
01226   int16 default_height = max(desc->default_height, sm_height);
01227 
01228   if (desc->parent_cls != 0 /* WC_MAIN_WINDOW */ &&
01229       (w = FindWindowById(desc->parent_cls, window_number)) != NULL &&
01230       w->left < _screen.width - 20 && w->left > -60 && w->top < _screen.height - 20) {
01231 
01232     pt.x = w->left + ((desc->parent_cls == WC_BUILD_TOOLBAR || desc->parent_cls == WC_SCEN_LAND_GEN) ? 0 : 10);
01233     if (pt.x > _screen.width + 10 - default_width) {
01234       pt.x = (_screen.width + 10 - default_width) - 20;
01235     }
01236     pt.y = w->top + ((desc->parent_cls == WC_BUILD_TOOLBAR || desc->parent_cls == WC_SCEN_LAND_GEN) ? w->height : 10);
01237     return pt;
01238   }
01239 
01240   switch (desc->default_pos) {
01241     case WDP_ALIGN_TOOLBAR: // Align to the toolbar
01242       return GetToolbarAlignedWindowPosition(default_width);
01243 
01244     case WDP_AUTO: // Find a good automatic position for the window
01245       return GetAutoPlacePosition(default_width, default_height);
01246 
01247     case WDP_CENTER: // Centre the window horizontally
01248       pt.x = (_screen.width - default_width) / 2;
01249       pt.y = (_screen.height - default_height) / 2;
01250       break;
01251 
01252     case WDP_MANUAL:
01253       pt.x = 0;
01254       pt.y = 0;
01255       break;
01256 
01257     default:
01258       NOT_REACHED();
01259   }
01260 
01261   return pt;
01262 }
01263 
01264 /* virtual */ Point Window::OnInitialPosition(const WindowDesc *desc, int16 sm_width, int16 sm_height, int window_number)
01265 {
01266   return LocalGetWindowPlacement(desc, sm_width, sm_height, window_number);
01267 }
01268 
01277 void Window::CreateNestedTree(const WindowDesc *desc, bool fill_nested)
01278 {
01279   int biggest_index = -1;
01280   this->nested_root = MakeWindowNWidgetTree(desc->nwid_parts, desc->nwid_length, &biggest_index, &this->shade_select);
01281   this->nested_array_size = (uint)(biggest_index + 1);
01282 
01283   if (fill_nested) {
01284     this->nested_array = CallocT<NWidgetBase *>(this->nested_array_size);
01285     this->nested_root->FillNestedArray(this->nested_array, this->nested_array_size);
01286   }
01287 }
01288 
01294 void Window::FinishInitNested(const WindowDesc *desc, WindowNumber window_number)
01295 {
01296   this->InitializeData(desc, window_number);
01297   Point pt = this->OnInitialPosition(desc, this->nested_root->smallest_x, this->nested_root->smallest_y, window_number);
01298   this->InitializePositionSize(pt.x, pt.y, this->nested_root->smallest_x, this->nested_root->smallest_y);
01299   this->FindWindowPlacementAndResize(desc->default_width, desc->default_height);
01300 }
01301 
01307 void Window::InitNested(const WindowDesc *desc, WindowNumber window_number)
01308 {
01309   this->CreateNestedTree(desc, false);
01310   this->FinishInitNested(desc, window_number);
01311 }
01312 
01314 Window::Window() : scrolling_scrollbar(-1)
01315 {
01316 }
01317 
01325 Window *FindWindowFromPt(int x, int y)
01326 {
01327   Window *w;
01328   FOR_ALL_WINDOWS_FROM_FRONT(w) {
01329     if (IsInsideBS(x, w->left, w->width) && IsInsideBS(y, w->top, w->height)) {
01330       return w;
01331     }
01332   }
01333 
01334   return NULL;
01335 }
01336 
01340 void InitWindowSystem()
01341 {
01342   IConsoleClose();
01343 
01344   _z_back_window = NULL;
01345   _z_front_window = NULL;
01346   _focused_window = NULL;
01347   _mouseover_last_w = NULL;
01348   _last_scroll_window = NULL;
01349   _scrolling_viewport = false;
01350   _mouse_hovering = false;
01351 
01352   NWidgetLeaf::InvalidateDimensionCache(); // Reset cached sizes of several widgets.
01353 }
01354 
01358 void UnInitWindowSystem()
01359 {
01360   Window *w;
01361   FOR_ALL_WINDOWS_FROM_FRONT(w) delete w;
01362 
01363   for (w = _z_front_window; w != NULL; /* nothing */) {
01364     Window *to_del = w;
01365     w = w->z_back;
01366     free(to_del);
01367   }
01368 
01369   _z_front_window = NULL;
01370   _z_back_window = NULL;
01371 }
01372 
01376 void ResetWindowSystem()
01377 {
01378   UnInitWindowSystem();
01379   InitWindowSystem();
01380   _thd.Reset();
01381 }
01382 
01383 static void DecreaseWindowCounters()
01384 {
01385   Window *w;
01386   FOR_ALL_WINDOWS_FROM_FRONT(w) {
01387     if (_scroller_click_timeout == 0) {
01388       /* Unclick scrollbar buttons if they are pressed. */
01389       for (uint i = 0; i < w->nested_array_size; i++) {
01390         NWidgetBase *nwid = w->nested_array[i];
01391         if (nwid != NULL && (nwid->type == NWID_HSCROLLBAR || nwid->type == NWID_VSCROLLBAR)) {
01392           NWidgetScrollbar *sb = static_cast<NWidgetScrollbar*>(nwid);
01393           if (sb->disp_flags & (ND_SCROLLBAR_UP | ND_SCROLLBAR_DOWN)) {
01394             sb->disp_flags &= ~(ND_SCROLLBAR_UP | ND_SCROLLBAR_DOWN);
01395             w->scrolling_scrollbar = -1;
01396             sb->SetDirty(w);
01397           }
01398         }
01399       }
01400     }
01401     w->OnMouseLoop();
01402   }
01403 
01404   FOR_ALL_WINDOWS_FROM_FRONT(w) {
01405     if ((w->flags4 & WF_TIMEOUT_MASK) && !(--w->flags4 & WF_TIMEOUT_MASK)) {
01406       w->OnTimeout();
01407       if (w->desc_flags & WDF_UNCLICK_BUTTONS) w->RaiseButtons(true);
01408     }
01409   }
01410 }
01411 
01412 static void HandlePlacePresize()
01413 {
01414   if (_special_mouse_mode != WSM_PRESIZE) return;
01415 
01416   Window *w = _thd.GetCallbackWnd();
01417   if (w == NULL) return;
01418 
01419   Point pt = GetTileBelowCursor();
01420   if (pt.x == -1) {
01421     _thd.selend.x = -1;
01422     return;
01423   }
01424 
01425   w->OnPlacePresize(pt, TileVirtXY(pt.x, pt.y));
01426 }
01427 
01432 static EventState HandleMouseDragDrop()
01433 {
01434   if (_special_mouse_mode != WSM_DRAGDROP) return ES_NOT_HANDLED;
01435 
01436   if (_left_button_down && _cursor.delta.x == 0 && _cursor.delta.y == 0) return ES_HANDLED; // Dragging, but the mouse did not move.
01437 
01438   Window *w = _thd.GetCallbackWnd();
01439   if (w != NULL) {
01440     /* Send an event in client coordinates. */
01441     Point pt;
01442     pt.x = _cursor.pos.x - w->left;
01443     pt.y = _cursor.pos.y - w->top;
01444     if (_left_button_down) {
01445       w->OnMouseDrag(pt, GetWidgetFromPos(w, pt.x, pt.y));
01446     } else {
01447       w->OnDragDrop(pt, GetWidgetFromPos(w, pt.x, pt.y));
01448     }
01449   }
01450 
01451   if (!_left_button_down) ResetObjectToPlace(); // Button released, finished dragging.
01452   return ES_HANDLED;
01453 }
01454 
01456 static void HandleMouseOver()
01457 {
01458   Window *w = FindWindowFromPt(_cursor.pos.x, _cursor.pos.y);
01459 
01460   /* We changed window, put a MOUSEOVER event to the last window */
01461   if (_mouseover_last_w != NULL && _mouseover_last_w != w) {
01462     /* Reset mouse-over coordinates of previous window */
01463     Point pt = { -1, -1 };
01464     _mouseover_last_w->OnMouseOver(pt, 0);
01465   }
01466 
01467   /* _mouseover_last_w will get reset when the window is deleted, see DeleteWindow() */
01468   _mouseover_last_w = w;
01469 
01470   if (w != NULL) {
01471     /* send an event in client coordinates. */
01472     Point pt = { _cursor.pos.x - w->left, _cursor.pos.y - w->top };
01473     const NWidgetCore *widget = w->nested_root->GetWidgetFromPos(pt.x, pt.y);
01474     if (widget != NULL) w->OnMouseOver(pt, widget->index);
01475   }
01476 }
01477 
01479 static const int MIN_VISIBLE_TITLE_BAR = 13;
01480 
01482 enum PreventHideDirection {
01483   PHD_UP,   
01484   PHD_DOWN, 
01485 };
01486 
01497 static void PreventHiding(int *nx, int *ny, const Rect &rect, const Window *v, int px, PreventHideDirection dir)
01498 {
01499   if (v == NULL) return;
01500 
01501   int v_bottom = v->top + v->height;
01502   int v_right = v->left + v->width;
01503   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.
01504 
01505   if (*ny + rect.top <= v->top - MIN_VISIBLE_TITLE_BAR) return; // Above v is enough space
01506   if (*ny + rect.bottom >= v_bottom + MIN_VISIBLE_TITLE_BAR) return; // Below v is enough space
01507 
01508   /* Vertically, the rectangle is hidden behind v. */
01509   if (*nx + rect.left + MIN_VISIBLE_TITLE_BAR < v->left) { // At left of v.
01510     if (v->left < MIN_VISIBLE_TITLE_BAR) *ny = safe_y; // But enough room, force it to a safe position.
01511     return;
01512   }
01513   if (*nx + rect.right - MIN_VISIBLE_TITLE_BAR > v_right) { // At right of v.
01514     if (v_right > _screen.width - MIN_VISIBLE_TITLE_BAR) *ny = safe_y; // Not enough room, force it to a safe position.
01515     return;
01516   }
01517 
01518   /* Horizontally also hidden, force movement to a safe area. */
01519   if (px + rect.left < v->left && v->left >= MIN_VISIBLE_TITLE_BAR) { // Coming from the left, and enough room there.
01520     *nx = v->left - MIN_VISIBLE_TITLE_BAR - rect.left;
01521   } else if (px + rect.right > v_right && v_right <= _screen.width - MIN_VISIBLE_TITLE_BAR) { // Coming from the right, and enough room there.
01522     *nx = v_right + MIN_VISIBLE_TITLE_BAR - rect.right;
01523   } else {
01524     *ny = safe_y;
01525   }
01526 }
01527 
01535 static void EnsureVisibleCaption(Window *w, int nx, int ny)
01536 {
01537   /* Search for the title bar rectangle. */
01538   Rect caption_rect;
01539   const NWidgetBase *caption = w->nested_root->GetWidgetOfType(WWT_CAPTION);
01540   if (caption != NULL) {
01541     caption_rect.left   = caption->pos_x;
01542     caption_rect.right  = caption->pos_x + caption->current_x;
01543     caption_rect.top    = caption->pos_y;
01544     caption_rect.bottom = caption->pos_y + caption->current_y;
01545 
01546     /* Make sure the window doesn't leave the screen */
01547     nx = Clamp(nx, MIN_VISIBLE_TITLE_BAR - caption_rect.right, _screen.width - MIN_VISIBLE_TITLE_BAR - caption_rect.left);
01548     ny = Clamp(ny, 0, _screen.height - MIN_VISIBLE_TITLE_BAR);
01549 
01550     /* Make sure the title bar isn't hidden behind the main tool bar or the status bar. */
01551     PreventHiding(&nx, &ny, caption_rect, FindWindowById(WC_MAIN_TOOLBAR, 0), w->left, PHD_DOWN);
01552     PreventHiding(&nx, &ny, caption_rect, FindWindowById(WC_STATUS_BAR,   0), w->left, PHD_UP);
01553 
01554     if (w->viewport != NULL) {
01555       w->viewport->left += nx - w->left;
01556       w->viewport->top  += ny - w->top;
01557     }
01558   }
01559   w->left = nx;
01560   w->top  = ny;
01561 }
01562 
01572 void ResizeWindow(Window *w, int delta_x, int delta_y)
01573 {
01574   if (delta_x != 0 || delta_y != 0) {
01575     w->SetDirty();
01576 
01577     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);
01578     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);
01579     assert(w->nested_root->resize_x == 0 || new_xinc % w->nested_root->resize_x == 0);
01580     assert(w->nested_root->resize_y == 0 || new_yinc % w->nested_root->resize_y == 0);
01581 
01582     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);
01583     w->width  = w->nested_root->current_x;
01584     w->height = w->nested_root->current_y;
01585   }
01586 
01587   EnsureVisibleCaption(w, w->left, w->top);
01588 
01589   /* Always call OnResize to make sure everything is initialised correctly if it needs to be. */
01590   w->OnResize();
01591   w->SetDirty();
01592 }
01593 
01599 int GetMainViewTop()
01600 {
01601   Window *w = FindWindowById(WC_MAIN_TOOLBAR, 0);
01602   return (w == NULL) ? 0 : w->top + w->height;
01603 }
01604 
01610 int GetMainViewBottom()
01611 {
01612   Window *w = FindWindowById(WC_STATUS_BAR, 0);
01613   return (w == NULL) ? _screen.height : w->top;
01614 }
01615 
01616 static bool _dragging_window; 
01617 
01622 static EventState HandleWindowDragging()
01623 {
01624   /* Get out immediately if no window is being dragged at all. */
01625   if (!_dragging_window) return ES_NOT_HANDLED;
01626 
01627   /* If button still down, but cursor hasn't moved, there is nothing to do. */
01628   if (_left_button_down && _cursor.delta.x == 0 && _cursor.delta.y == 0) return ES_HANDLED;
01629 
01630   /* Otherwise find the window... */
01631   Window *w;
01632   FOR_ALL_WINDOWS_FROM_BACK(w) {
01633     if (w->flags4 & WF_DRAGGING) {
01634       /* Stop the dragging if the left mouse button was released */
01635       if (!_left_button_down) {
01636         w->flags4 &= ~WF_DRAGGING;
01637         break;
01638       }
01639 
01640       w->SetDirty();
01641 
01642       int x = _cursor.pos.x + _drag_delta.x;
01643       int y = _cursor.pos.y + _drag_delta.y;
01644       int nx = x;
01645       int ny = y;
01646 
01647       if (_settings_client.gui.window_snap_radius != 0) {
01648         const Window *v;
01649 
01650         int hsnap = _settings_client.gui.window_snap_radius;
01651         int vsnap = _settings_client.gui.window_snap_radius;
01652         int delta;
01653 
01654         FOR_ALL_WINDOWS_FROM_BACK(v) {
01655           if (v == w) continue; // Don't snap at yourself
01656 
01657           if (y + w->height > v->top && y < v->top + v->height) {
01658             /* Your left border <-> other right border */
01659             delta = abs(v->left + v->width - x);
01660             if (delta <= hsnap) {
01661               nx = v->left + v->width;
01662               hsnap = delta;
01663             }
01664 
01665             /* Your right border <-> other left border */
01666             delta = abs(v->left - x - w->width);
01667             if (delta <= hsnap) {
01668               nx = v->left - w->width;
01669               hsnap = delta;
01670             }
01671           }
01672 
01673           if (w->top + w->height >= v->top && w->top <= v->top + v->height) {
01674             /* Your left border <-> other left border */
01675             delta = abs(v->left - x);
01676             if (delta <= hsnap) {
01677               nx = v->left;
01678               hsnap = delta;
01679             }
01680 
01681             /* Your right border <-> other right border */
01682             delta = abs(v->left + v->width - x - w->width);
01683             if (delta <= hsnap) {
01684               nx = v->left + v->width - w->width;
01685               hsnap = delta;
01686             }
01687           }
01688 
01689           if (x + w->width > v->left && x < v->left + v->width) {
01690             /* Your top border <-> other bottom border */
01691             delta = abs(v->top + v->height - y);
01692             if (delta <= vsnap) {
01693               ny = v->top + v->height;
01694               vsnap = delta;
01695             }
01696 
01697             /* Your bottom border <-> other top border */
01698             delta = abs(v->top - y - w->height);
01699             if (delta <= vsnap) {
01700               ny = v->top - w->height;
01701               vsnap = delta;
01702             }
01703           }
01704 
01705           if (w->left + w->width >= v->left && w->left <= v->left + v->width) {
01706             /* Your top border <-> other top border */
01707             delta = abs(v->top - y);
01708             if (delta <= vsnap) {
01709               ny = v->top;
01710               vsnap = delta;
01711             }
01712 
01713             /* Your bottom border <-> other bottom border */
01714             delta = abs(v->top + v->height - y - w->height);
01715             if (delta <= vsnap) {
01716               ny = v->top + v->height - w->height;
01717               vsnap = delta;
01718             }
01719           }
01720         }
01721       }
01722 
01723       EnsureVisibleCaption(w, nx, ny);
01724 
01725       w->SetDirty();
01726       return ES_HANDLED;
01727     } else if (w->flags4 & WF_SIZING) {
01728       /* Stop the sizing if the left mouse button was released */
01729       if (!_left_button_down) {
01730         w->flags4 &= ~WF_SIZING;
01731         w->SetDirty();
01732         break;
01733       }
01734 
01735       /* Compute difference in pixels between cursor position and reference point in the window.
01736        * If resizing the left edge of the window, moving to the left makes the window bigger not smaller.
01737        */
01738       int x, y = _cursor.pos.y - _drag_delta.y;
01739       if (w->flags4 & WF_SIZING_LEFT) {
01740         x = _drag_delta.x - _cursor.pos.x;
01741       } else {
01742         x = _cursor.pos.x - _drag_delta.x;
01743       }
01744 
01745       /* resize.step_width and/or resize.step_height may be 0, which means no resize is possible. */
01746       if (w->resize.step_width  == 0) x = 0;
01747       if (w->resize.step_height == 0) y = 0;
01748 
01749       /* Check the resize button won't go past the bottom of the screen */
01750       if (w->top + w->height + y > _screen.height) {
01751         y = _screen.height - w->height - w->top;
01752       }
01753 
01754       /* X and Y has to go by step.. calculate it.
01755        * The cast to int is necessary else x/y are implicitly casted to
01756        * unsigned int, which won't work. */
01757       if (w->resize.step_width  > 1) x -= x % (int)w->resize.step_width;
01758       if (w->resize.step_height > 1) y -= y % (int)w->resize.step_height;
01759 
01760       /* Check that we don't go below the minimum set size */
01761       if ((int)w->width + x < (int)w->nested_root->smallest_x) {
01762         x = w->nested_root->smallest_x - w->width;
01763       }
01764       if ((int)w->height + y < (int)w->nested_root->smallest_y) {
01765         y = w->nested_root->smallest_y - w->height;
01766       }
01767 
01768       /* Window already on size */
01769       if (x == 0 && y == 0) return ES_HANDLED;
01770 
01771       /* Now find the new cursor pos.. this is NOT _cursor, because we move in steps. */
01772       _drag_delta.y += y;
01773       if ((w->flags4 & WF_SIZING_LEFT) && x != 0) {
01774         _drag_delta.x -= x; // x > 0 -> window gets longer -> left-edge moves to left -> subtract x to get new position.
01775         w->SetDirty();
01776         w->left -= x;  // If dragging left edge, move left window edge in opposite direction by the same amount.
01777         /* ResizeWindow() below ensures marking new position as dirty. */
01778       } else {
01779         _drag_delta.x += x;
01780       }
01781 
01782       /* ResizeWindow sets both pre- and after-size to dirty for redrawal */
01783       ResizeWindow(w, x, y);
01784       return ES_HANDLED;
01785     }
01786   }
01787 
01788   _dragging_window = false;
01789   return ES_HANDLED;
01790 }
01791 
01796 static void StartWindowDrag(Window *w)
01797 {
01798   w->flags4 |= WF_DRAGGING;
01799   w->flags4 &= ~WF_CENTERED;
01800   _dragging_window = true;
01801 
01802   _drag_delta.x = w->left - _cursor.pos.x;
01803   _drag_delta.y = w->top  - _cursor.pos.y;
01804 
01805   BringWindowToFront(w);
01806   DeleteWindowById(WC_DROPDOWN_MENU, 0);
01807 }
01808 
01814 static void StartWindowSizing(Window *w, bool to_left)
01815 {
01816   w->flags4 |= to_left ? WF_SIZING_LEFT : WF_SIZING_RIGHT;
01817   w->flags4 &= ~WF_CENTERED;
01818   _dragging_window = true;
01819 
01820   _drag_delta.x = _cursor.pos.x;
01821   _drag_delta.y = _cursor.pos.y;
01822 
01823   BringWindowToFront(w);
01824   DeleteWindowById(WC_DROPDOWN_MENU, 0);
01825 }
01826 
01831 static EventState HandleScrollbarScrolling()
01832 {
01833   Window *w;
01834   FOR_ALL_WINDOWS_FROM_BACK(w) {
01835     if (w->scrolling_scrollbar >= 0) {
01836       /* Abort if no button is clicked any more. */
01837       if (!_left_button_down) {
01838         w->scrolling_scrollbar = -1;
01839         w->SetDirty();
01840         return ES_HANDLED;
01841       }
01842 
01843       int i;
01844       NWidgetScrollbar *sb = w->GetWidget<NWidgetScrollbar>(w->scrolling_scrollbar);
01845       bool rtl = false;
01846 
01847       if (sb->type == NWID_HSCROLLBAR) {
01848         i = _cursor.pos.x - _cursorpos_drag_start.x;
01849         rtl = _current_text_dir == TD_RTL;
01850       } else {
01851         i = _cursor.pos.y - _cursorpos_drag_start.y;
01852       }
01853 
01854       if (sb->disp_flags & ND_SCROLLBAR_BTN) {
01855         if (_scroller_click_timeout == 1) {
01856           _scroller_click_timeout = 3;
01857           sb->UpdatePosition(rtl == HasBit(sb->disp_flags, NDB_SCROLLBAR_UP) ? 1 : -1);
01858           w->SetDirty();
01859         }
01860         return ES_HANDLED;
01861       }
01862 
01863       /* Find the item we want to move to and make sure it's inside bounds. */
01864       int pos = min(max(0, i + _scrollbar_start_pos) * sb->GetCount() / _scrollbar_size, max(0, sb->GetCount() - sb->GetCapacity()));
01865       if (rtl) pos = max(0, sb->GetCount() - sb->GetCapacity() - pos);
01866       if (pos != sb->GetPosition()) {
01867         sb->SetPosition(pos);
01868         w->SetDirty();
01869       }
01870       return ES_HANDLED;
01871     }
01872   }
01873 
01874   return ES_NOT_HANDLED;
01875 }
01876 
01881 static EventState HandleViewportScroll()
01882 {
01883   bool scrollwheel_scrolling = _settings_client.gui.scrollwheel_scrolling == 1 && (_cursor.v_wheel != 0 || _cursor.h_wheel != 0);
01884 
01885   if (!_scrolling_viewport) return ES_NOT_HANDLED;
01886 
01887   /* When we don't have a last scroll window we are starting to scroll.
01888    * When the last scroll window and this are not the same we went
01889    * outside of the window and should not left-mouse scroll anymore. */
01890   if (_last_scroll_window == NULL) _last_scroll_window = FindWindowFromPt(_cursor.pos.x, _cursor.pos.y);
01891 
01892   if (_last_scroll_window == NULL || !(_right_button_down || scrollwheel_scrolling || (_settings_client.gui.left_mouse_btn_scrolling && _left_button_down))) {
01893     _cursor.fix_at = false;
01894     _scrolling_viewport = false;
01895     _last_scroll_window = NULL;
01896     return ES_NOT_HANDLED;
01897   }
01898 
01899   if (_last_scroll_window == FindWindowById(WC_MAIN_WINDOW, 0) && _last_scroll_window->viewport->follow_vehicle != INVALID_VEHICLE) {
01900     /* If the main window is following a vehicle, then first let go of it! */
01901     const Vehicle *veh = Vehicle::Get(_last_scroll_window->viewport->follow_vehicle);
01902     ScrollMainWindowTo(veh->x_pos, veh->y_pos, veh->z_pos, true); // This also resets follow_vehicle
01903     return ES_NOT_HANDLED;
01904   }
01905 
01906   Point delta;
01907   if (_settings_client.gui.reverse_scroll || (_settings_client.gui.left_mouse_btn_scrolling && _left_button_down)) {
01908     delta.x = -_cursor.delta.x;
01909     delta.y = -_cursor.delta.y;
01910   } else {
01911     delta.x = _cursor.delta.x;
01912     delta.y = _cursor.delta.y;
01913   }
01914 
01915   if (scrollwheel_scrolling) {
01916     /* We are using scrollwheels for scrolling */
01917     delta.x = _cursor.h_wheel;
01918     delta.y = _cursor.v_wheel;
01919     _cursor.v_wheel = 0;
01920     _cursor.h_wheel = 0;
01921   }
01922 
01923   /* Create a scroll-event and send it to the window */
01924   if (delta.x != 0 || delta.y != 0) _last_scroll_window->OnScroll(delta);
01925 
01926   _cursor.delta.x = 0;
01927   _cursor.delta.y = 0;
01928   return ES_HANDLED;
01929 }
01930 
01941 static bool MaybeBringWindowToFront(Window *w)
01942 {
01943   bool bring_to_front = false;
01944 
01945   if (w->window_class == WC_MAIN_WINDOW ||
01946       IsVitalWindow(w) ||
01947       w->window_class == WC_TOOLTIPS ||
01948       w->window_class == WC_DROPDOWN_MENU) {
01949     return true;
01950   }
01951 
01952   /* Use unshaded window size rather than current size for shaded windows. */
01953   int w_width  = w->width;
01954   int w_height = w->height;
01955   if (w->IsShaded()) {
01956     w_width  = w->unshaded_size.width;
01957     w_height = w->unshaded_size.height;
01958   }
01959 
01960   Window *u;
01961   FOR_ALL_WINDOWS_FROM_BACK_FROM(u, w->z_front) {
01962     /* A modal child will prevent the activation of the parent window */
01963     if (u->parent == w && (u->desc_flags & WDF_MODAL)) {
01964       u->flags4 |= WF_WHITE_BORDER_MASK;
01965       u->SetDirty();
01966       return false;
01967     }
01968 
01969     if (u->window_class == WC_MAIN_WINDOW ||
01970         IsVitalWindow(u) ||
01971         u->window_class == WC_TOOLTIPS ||
01972         u->window_class == WC_DROPDOWN_MENU) {
01973       continue;
01974     }
01975 
01976     /* Window sizes don't interfere, leave z-order alone */
01977     if (w->left + w_width <= u->left ||
01978         u->left + u->width <= w->left ||
01979         w->top  + w_height <= u->top ||
01980         u->top + u->height <= w->top) {
01981       continue;
01982     }
01983 
01984     bring_to_front = true;
01985   }
01986 
01987   if (bring_to_front) BringWindowToFront(w);
01988   return true;
01989 }
01990 
01995 void HandleKeypress(uint32 raw_key)
01996 {
01997   /* World generation is multithreaded and messes with companies.
01998    * But there is no company related window open anyway, so _current_company is not used. */
01999   assert(IsGeneratingWorld() || IsLocalCompany());
02000 
02001   /* Setup event */
02002   uint16 key     = GB(raw_key,  0, 16);
02003   uint16 keycode = GB(raw_key, 16, 16);
02004 
02005   /*
02006    * The Unicode standard defines an area called the private use area. Code points in this
02007    * area are reserved for private use and thus not portable between systems. For instance,
02008    * Apple defines code points for the arrow keys in this area, but these are only printable
02009    * on a system running OS X. We don't want these keys to show up in text fields and such,
02010    * and thus we have to clear the unicode character when we encounter such a key.
02011    */
02012   if (key >= 0xE000 && key <= 0xF8FF) key = 0;
02013 
02014   /*
02015    * If both key and keycode is zero, we don't bother to process the event.
02016    */
02017   if (key == 0 && keycode == 0) return;
02018 
02019   /* Check if the focused window has a focused editbox */
02020   if (EditBoxInGlobalFocus()) {
02021     /* All input will in this case go to the focused window */
02022     if (_focused_window->OnKeyPress(key, keycode) == ES_HANDLED) return;
02023   }
02024 
02025   /* Call the event, start with the uppermost window, but ignore the toolbar. */
02026   Window *w;
02027   FOR_ALL_WINDOWS_FROM_FRONT(w) {
02028     if (w->window_class == WC_MAIN_TOOLBAR) continue;
02029     if (w->OnKeyPress(key, keycode) == ES_HANDLED) return;
02030   }
02031 
02032   w = FindWindowById(WC_MAIN_TOOLBAR, 0);
02033   /* When there is no toolbar w is null, check for that */
02034   if (w != NULL && w->OnKeyPress(key, keycode) == ES_HANDLED) return;
02035 
02036   HandleGlobalHotkeys(key, keycode);
02037 }
02038 
02042 void HandleCtrlChanged()
02043 {
02044   /* Call the event, start with the uppermost window. */
02045   Window *w;
02046   FOR_ALL_WINDOWS_FROM_FRONT(w) {
02047     if (w->OnCTRLStateChange() == ES_HANDLED) return;
02048   }
02049 }
02050 
02057 static int _input_events_this_tick = 0;
02058 
02063 static void HandleAutoscroll()
02064 {
02065   if (_settings_client.gui.autoscroll && _game_mode != GM_MENU && !IsGeneratingWorld()) {
02066     int x = _cursor.pos.x;
02067     int y = _cursor.pos.y;
02068     Window *w = FindWindowFromPt(x, y);
02069     if (w == NULL || w->flags4 & WF_DISABLE_VP_SCROLL) return;
02070     ViewPort *vp = IsPtInWindowViewport(w, x, y);
02071     if (vp != NULL) {
02072       x -= vp->left;
02073       y -= vp->top;
02074 
02075       /* here allows scrolling in both x and y axis */
02076 #define scrollspeed 3
02077       if (x - 15 < 0) {
02078         w->viewport->dest_scrollpos_x += ScaleByZoom((x - 15) * scrollspeed, vp->zoom);
02079       } else if (15 - (vp->width - x) > 0) {
02080         w->viewport->dest_scrollpos_x += ScaleByZoom((15 - (vp->width - x)) * scrollspeed, vp->zoom);
02081       }
02082       if (y - 15 < 0) {
02083         w->viewport->dest_scrollpos_y += ScaleByZoom((y - 15) * scrollspeed, vp->zoom);
02084       } else if (15 - (vp->height - y) > 0) {
02085         w->viewport->dest_scrollpos_y += ScaleByZoom((15 - (vp->height - y)) * scrollspeed, vp->zoom);
02086       }
02087 #undef scrollspeed
02088     }
02089   }
02090 }
02091 
02092 enum MouseClick {
02093   MC_NONE = 0,
02094   MC_LEFT,
02095   MC_RIGHT,
02096   MC_DOUBLE_LEFT,
02097   MC_HOVER,
02098 
02099   MAX_OFFSET_DOUBLE_CLICK = 5,     
02100   TIME_BETWEEN_DOUBLE_CLICK = 500, 
02101   MAX_OFFSET_HOVER = 5,            
02102 };
02103 extern EventState VpHandlePlaceSizingDrag();
02104 
02105 static void ScrollMainViewport(int x, int y)
02106 {
02107   if (_game_mode != GM_MENU) {
02108     Window *w = FindWindowById(WC_MAIN_WINDOW, 0);
02109     assert(w);
02110 
02111     w->viewport->dest_scrollpos_x += ScaleByZoom(x, w->viewport->zoom);
02112     w->viewport->dest_scrollpos_y += ScaleByZoom(y, w->viewport->zoom);
02113   }
02114 }
02115 
02125 static const int8 scrollamt[16][2] = {
02126   { 0,  0}, 
02127   {-2,  0}, 
02128   { 0, -2}, 
02129   {-2, -1}, 
02130   { 2,  0}, 
02131   { 0,  0}, 
02132   { 2, -1}, 
02133   { 0, -2}, 
02134   { 0,  2}, 
02135   {-2,  1}, 
02136   { 0,  0}, 
02137   {-2,  0}, 
02138   { 2,  1}, 
02139   { 0,  2}, 
02140   { 2,  0}, 
02141   { 0,  0}, 
02142 };
02143 
02144 static void HandleKeyScrolling()
02145 {
02146   /*
02147    * Check that any of the dirkeys is pressed and that the focused window
02148    * dont has an edit-box as focused widget.
02149    */
02150   if (_dirkeys && !EditBoxInGlobalFocus()) {
02151     int factor = _shift_pressed ? 50 : 10;
02152     ScrollMainViewport(scrollamt[_dirkeys][0] * factor, scrollamt[_dirkeys][1] * factor);
02153   }
02154 }
02155 
02156 static void MouseLoop(MouseClick click, int mousewheel)
02157 {
02158   /* World generation is multithreaded and messes with companies.
02159    * But there is no company related window open anyway, so _current_company is not used. */
02160   assert(IsGeneratingWorld() || IsLocalCompany());
02161 
02162   HandlePlacePresize();
02163   UpdateTileSelection();
02164 
02165   if (VpHandlePlaceSizingDrag()  == ES_HANDLED) return;
02166   if (HandleMouseDragDrop()      == ES_HANDLED) return;
02167   if (HandleWindowDragging()     == ES_HANDLED) return;
02168   if (HandleScrollbarScrolling() == ES_HANDLED) return;
02169   if (HandleViewportScroll()     == ES_HANDLED) return;
02170 
02171   HandleMouseOver();
02172 
02173   bool scrollwheel_scrolling = _settings_client.gui.scrollwheel_scrolling == 1 && (_cursor.v_wheel != 0 || _cursor.h_wheel != 0);
02174   if (click == MC_NONE && mousewheel == 0 && !scrollwheel_scrolling) return;
02175 
02176   int x = _cursor.pos.x;
02177   int y = _cursor.pos.y;
02178   Window *w = FindWindowFromPt(x, y);
02179   if (w == NULL) return;
02180 
02181   if (click != MC_HOVER && !MaybeBringWindowToFront(w)) return;
02182   ViewPort *vp = IsPtInWindowViewport(w, x, y);
02183 
02184   /* Don't allow any action in a viewport if either in menu of in generating world */
02185   if (vp != NULL && (_game_mode == GM_MENU || IsGeneratingWorld())) return;
02186 
02187   if (mousewheel != 0) {
02188     /* Send mousewheel event to window */
02189     w->OnMouseWheel(mousewheel);
02190 
02191     /* Dispatch a MouseWheelEvent for widgets if it is not a viewport */
02192     if (vp == NULL) DispatchMouseWheelEvent(w, w->nested_root->GetWidgetFromPos(x - w->left, y - w->top), mousewheel);
02193   }
02194 
02195   if (vp != NULL) {
02196     if (scrollwheel_scrolling) click = MC_RIGHT; // we are using the scrollwheel in a viewport, so we emulate right mouse button
02197     switch (click) {
02198       case MC_DOUBLE_LEFT:
02199       case MC_LEFT:
02200         DEBUG(misc, 2, "Cursor: 0x%X (%d)", _cursor.sprite, _cursor.sprite);
02201         if (!HandleViewportClicked(vp, x, y) &&
02202             !(w->flags4 & WF_DISABLE_VP_SCROLL) &&
02203             _settings_client.gui.left_mouse_btn_scrolling) {
02204           _scrolling_viewport = true;
02205           _cursor.fix_at = false;
02206         }
02207         break;
02208 
02209       case MC_RIGHT:
02210         if (!(w->flags4 & WF_DISABLE_VP_SCROLL)) {
02211           _scrolling_viewport = true;
02212           _cursor.fix_at = true;
02213 
02214           /* clear 2D scrolling caches before we start a 2D scroll */
02215           _cursor.h_wheel = 0;
02216           _cursor.v_wheel = 0;
02217         }
02218         break;
02219 
02220       default:
02221         break;
02222     }
02223   } else {
02224     switch (click) {
02225       case MC_LEFT:
02226       case MC_DOUBLE_LEFT:
02227         DispatchLeftClickEvent(w, x - w->left, y - w->top, click == MC_DOUBLE_LEFT ? 2 : 1);
02228         break;
02229 
02230       default:
02231         if (!scrollwheel_scrolling || w == NULL || w->window_class != WC_SMALLMAP) break;
02232         /* We try to use the scrollwheel to scroll since we didn't touch any of the buttons.
02233          * Simulate a right button click so we can get started. */
02234         /* FALL THROUGH */
02235 
02236       case MC_RIGHT: DispatchRightClickEvent(w, x - w->left, y - w->top); break;
02237 
02238       case MC_HOVER: DispatchHoverEvent(w, x - w->left, y - w->top); break;
02239     }
02240   }
02241 }
02242 
02246 void HandleMouseEvents()
02247 {
02248   /* World generation is multithreaded and messes with companies.
02249    * But there is no company related window open anyway, so _current_company is not used. */
02250   assert(IsGeneratingWorld() || IsLocalCompany());
02251 
02252   static int double_click_time = 0;
02253   static Point double_click_pos = {0, 0};
02254 
02255   /* Mouse event? */
02256   MouseClick click = MC_NONE;
02257   if (_left_button_down && !_left_button_clicked) {
02258     click = MC_LEFT;
02259     if (double_click_time != 0 && _realtime_tick - double_click_time   < TIME_BETWEEN_DOUBLE_CLICK &&
02260         double_click_pos.x != 0 && abs(_cursor.pos.x - double_click_pos.x) < MAX_OFFSET_DOUBLE_CLICK  &&
02261         double_click_pos.y != 0 && abs(_cursor.pos.y - double_click_pos.y) < MAX_OFFSET_DOUBLE_CLICK) {
02262       click = MC_DOUBLE_LEFT;
02263     }
02264     double_click_time = _realtime_tick;
02265     double_click_pos = _cursor.pos;
02266     _left_button_clicked = true;
02267     _input_events_this_tick++;
02268   } else if (_right_button_clicked) {
02269     _right_button_clicked = false;
02270     click = MC_RIGHT;
02271     _input_events_this_tick++;
02272   }
02273 
02274   int mousewheel = 0;
02275   if (_cursor.wheel) {
02276     mousewheel = _cursor.wheel;
02277     _cursor.wheel = 0;
02278     _input_events_this_tick++;
02279   }
02280 
02281   static uint32 hover_time = 0;
02282   static Point hover_pos = {0, 0};
02283 
02284   if (_settings_client.gui.hover_delay > 0) {
02285     if (!_cursor.in_window || click != MC_NONE || mousewheel != 0 || _left_button_down || _right_button_down ||
02286         hover_pos.x == 0 || abs(_cursor.pos.x - hover_pos.x) >= MAX_OFFSET_HOVER  ||
02287         hover_pos.y == 0 || abs(_cursor.pos.y - hover_pos.y) >= MAX_OFFSET_HOVER) {
02288       hover_pos = _cursor.pos;
02289       hover_time = _realtime_tick;
02290       _mouse_hovering = false;
02291     } else {
02292       if (hover_time != 0 && _realtime_tick > hover_time + _settings_client.gui.hover_delay * 1000) {
02293         click = MC_HOVER;
02294         _input_events_this_tick++;
02295         _mouse_hovering = true;
02296       }
02297     }
02298   }
02299 
02300   /* Handle sprite picker before any GUI interaction */
02301   if (_newgrf_debug_sprite_picker.mode == SPM_REDRAW && _newgrf_debug_sprite_picker.click_time != _realtime_tick) {
02302     /* Next realtime tick? Then redraw has finished */
02303     _newgrf_debug_sprite_picker.mode = SPM_NONE;
02304     InvalidateWindowData(WC_SPRITE_ALIGNER, 0, 1);
02305   }
02306 
02307   if (click == MC_LEFT && _newgrf_debug_sprite_picker.mode == SPM_WAIT_CLICK) {
02308     /* Mark whole screen dirty, and wait for the next realtime tick, when drawing is finished. */
02309     Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();
02310     _newgrf_debug_sprite_picker.clicked_pixel = blitter->MoveTo(_screen.dst_ptr, _cursor.pos.x, _cursor.pos.y);
02311     _newgrf_debug_sprite_picker.click_time = _realtime_tick;
02312     _newgrf_debug_sprite_picker.sprites.Clear();
02313     _newgrf_debug_sprite_picker.mode = SPM_REDRAW;
02314     MarkWholeScreenDirty();
02315   } else {
02316     MouseLoop(click, mousewheel);
02317   }
02318 
02319   /* We have moved the mouse the required distance,
02320    * no need to move it at any later time. */
02321   _cursor.delta.x = 0;
02322   _cursor.delta.y = 0;
02323 }
02324 
02328 static void CheckSoftLimit()
02329 {
02330   if (_settings_client.gui.window_soft_limit == 0) return;
02331 
02332   for (;;) {
02333     uint deletable_count = 0;
02334     Window *w, *last_deletable = NULL;
02335     FOR_ALL_WINDOWS_FROM_FRONT(w) {
02336       if (w->window_class == WC_MAIN_WINDOW || IsVitalWindow(w) || (w->flags4 & WF_STICKY)) continue;
02337 
02338       last_deletable = w;
02339       deletable_count++;
02340     }
02341 
02342     /* We've ot reached the soft limit yet */
02343     if (deletable_count <= _settings_client.gui.window_soft_limit) break;
02344 
02345     assert(last_deletable != NULL);
02346     delete last_deletable;
02347   }
02348 }
02349 
02353 void InputLoop()
02354 {
02355   /* World generation is multithreaded and messes with companies.
02356    * But there is no company related window open anyway, so _current_company is not used. */
02357   assert(IsGeneratingWorld() || IsLocalCompany());
02358 
02359   CheckSoftLimit();
02360   HandleKeyScrolling();
02361 
02362   /* Do the actual free of the deleted windows. */
02363   for (Window *v = _z_front_window; v != NULL; /* nothing */) {
02364     Window *w = v;
02365     v = v->z_back;
02366 
02367     if (w->window_class != WC_INVALID) continue;
02368 
02369     /* Find the window in the z-array, and effectively remove it
02370      * by moving all windows after it one to the left. This must be
02371      * done before removing the child so we cannot cause recursion
02372      * between the deletion of the parent and the child. */
02373     if (w->z_front == NULL) {
02374       _z_front_window = w->z_back;
02375     } else {
02376       w->z_front->z_back = w->z_back;
02377     }
02378     if (w->z_back == NULL) {
02379       _z_back_window  = w->z_front;
02380     } else {
02381       w->z_back->z_front = w->z_front;
02382     }
02383     free(w);
02384   }
02385 
02386   if (_scroller_click_timeout != 0) _scroller_click_timeout--;
02387   DecreaseWindowCounters();
02388 
02389   if (_input_events_this_tick != 0) {
02390     /* The input loop is called only once per GameLoop() - so we can clear the counter here */
02391     _input_events_this_tick = 0;
02392     /* there were some inputs this tick, don't scroll ??? */
02393     return;
02394   }
02395 
02396   /* HandleMouseEvents was already called for this tick */
02397   HandleMouseEvents();
02398   HandleAutoscroll();
02399 }
02400 
02404 void UpdateWindows()
02405 {
02406   Window *w;
02407 
02408   FOR_ALL_WINDOWS_FROM_FRONT(w) {
02409     w->ProcessScheduledInvalidations();
02410   }
02411 
02412   static int we4_timer = 0;
02413   int t = we4_timer + 1;
02414 
02415   if (t >= 100) {
02416     FOR_ALL_WINDOWS_FROM_FRONT(w) {
02417       w->OnHundredthTick();
02418     }
02419     t = 0;
02420   }
02421   we4_timer = t;
02422 
02423   FOR_ALL_WINDOWS_FROM_FRONT(w) {
02424     if (w->flags4 & WF_WHITE_BORDER_MASK) {
02425       w->flags4 -= WF_WHITE_BORDER_ONE;
02426 
02427       if (!(w->flags4 & WF_WHITE_BORDER_MASK)) w->SetDirty();
02428     }
02429   }
02430 
02431   DrawDirtyBlocks();
02432 
02433   FOR_ALL_WINDOWS_FROM_BACK(w) {
02434     /* Update viewport only if window is not shaded. */
02435     if (w->viewport != NULL && !w->IsShaded()) UpdateViewportPosition(w);
02436   }
02437   NetworkDrawChatMessage();
02438   /* Redraw mouse cursor in case it was hidden */
02439   DrawMouseCursor();
02440 }
02441 
02447 void SetWindowDirty(WindowClass cls, WindowNumber number)
02448 {
02449   const Window *w;
02450   FOR_ALL_WINDOWS_FROM_BACK(w) {
02451     if (w->window_class == cls && w->window_number == number) w->SetDirty();
02452   }
02453 }
02454 
02461 void SetWindowWidgetDirty(WindowClass cls, WindowNumber number, byte widget_index)
02462 {
02463   const Window *w;
02464   FOR_ALL_WINDOWS_FROM_BACK(w) {
02465     if (w->window_class == cls && w->window_number == number) {
02466       w->SetWidgetDirty(widget_index);
02467     }
02468   }
02469 }
02470 
02475 void SetWindowClassesDirty(WindowClass cls)
02476 {
02477   Window *w;
02478   FOR_ALL_WINDOWS_FROM_BACK(w) {
02479     if (w->window_class == cls) w->SetDirty();
02480   }
02481 }
02482 
02509 void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
02510 {
02511   Window *w;
02512   FOR_ALL_WINDOWS_FROM_BACK(w) {
02513     if (w->window_class == cls && w->window_number == number) {
02514       w->InvalidateData(data, gui_scope);
02515     }
02516   }
02517 }
02518 
02527 void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope)
02528 {
02529   Window *w;
02530 
02531   FOR_ALL_WINDOWS_FROM_BACK(w) {
02532     if (w->window_class == cls) {
02533       w->InvalidateData(data, gui_scope);
02534     }
02535   }
02536 }
02537 
02541 void CallWindowTickEvent()
02542 {
02543   Window *w;
02544   FOR_ALL_WINDOWS_FROM_FRONT(w) {
02545     w->OnTick();
02546   }
02547 }
02548 
02555 void DeleteNonVitalWindows()
02556 {
02557   Window *w;
02558 
02559 restart_search:
02560   /* When we find the window to delete, we need to restart the search
02561    * as deleting this window could cascade in deleting (many) others
02562    * anywhere in the z-array */
02563   FOR_ALL_WINDOWS_FROM_BACK(w) {
02564     if (w->window_class != WC_MAIN_WINDOW &&
02565         w->window_class != WC_SELECT_GAME &&
02566         w->window_class != WC_MAIN_TOOLBAR &&
02567         w->window_class != WC_STATUS_BAR &&
02568         w->window_class != WC_TOOLTIPS &&
02569         (w->flags4 & WF_STICKY) == 0) { // do not delete windows which are 'pinned'
02570 
02571       delete w;
02572       goto restart_search;
02573     }
02574   }
02575 }
02576 
02584 void DeleteAllNonVitalWindows()
02585 {
02586   Window *w;
02587 
02588   /* Delete every window except for stickied ones, then sticky ones as well */
02589   DeleteNonVitalWindows();
02590 
02591 restart_search:
02592   /* When we find the window to delete, we need to restart the search
02593    * as deleting this window could cascade in deleting (many) others
02594    * anywhere in the z-array */
02595   FOR_ALL_WINDOWS_FROM_BACK(w) {
02596     if (w->flags4 & WF_STICKY) {
02597       delete w;
02598       goto restart_search;
02599     }
02600   }
02601 }
02602 
02607 void DeleteConstructionWindows()
02608 {
02609   Window *w;
02610 
02611 restart_search:
02612   /* When we find the window to delete, we need to restart the search
02613    * as deleting this window could cascade in deleting (many) others
02614    * anywhere in the z-array */
02615   FOR_ALL_WINDOWS_FROM_BACK(w) {
02616     if (w->desc_flags & WDF_CONSTRUCTION) {
02617       delete w;
02618       goto restart_search;
02619     }
02620   }
02621 
02622   FOR_ALL_WINDOWS_FROM_BACK(w) w->SetDirty();
02623 }
02624 
02626 void HideVitalWindows()
02627 {
02628   DeleteWindowById(WC_MAIN_TOOLBAR, 0);
02629   DeleteWindowById(WC_STATUS_BAR, 0);
02630 }
02631 
02633 void ReInitAllWindows()
02634 {
02635   NWidgetLeaf::InvalidateDimensionCache(); // Reset cached sizes of several widgets.
02636 
02637   Window *w;
02638   FOR_ALL_WINDOWS_FROM_BACK(w) {
02639     w->ReInit();
02640   }
02641 #ifdef ENABLE_NETWORK
02642   void NetworkReInitChatBoxSize();
02643   NetworkReInitChatBoxSize();
02644 #endif
02645 
02646   /* Make sure essential parts of all windows are visible */
02647   RelocateAllWindows(_cur_resolution.width, _cur_resolution.height);
02648   MarkWholeScreenDirty();
02649 }
02650 
02658 static int PositionWindow(Window *w, WindowClass clss, int setting)
02659 {
02660   if (w == NULL || w->window_class != clss) {
02661     w = FindWindowById(clss, 0);
02662   }
02663   if (w == NULL) return 0;
02664 
02665   int old_left = w->left;
02666   switch (setting) {
02667     case 1:  w->left = (_screen.width - w->width) / 2; break;
02668     case 2:  w->left = _screen.width - w->width; break;
02669     default: w->left = 0; break;
02670   }
02671   if (w->viewport != NULL) w->viewport->left += w->left - old_left;
02672   SetDirtyBlocks(0, w->top, _screen.width, w->top + w->height); // invalidate the whole row
02673   return w->left;
02674 }
02675 
02681 int PositionMainToolbar(Window *w)
02682 {
02683   DEBUG(misc, 5, "Repositioning Main Toolbar...");
02684   return PositionWindow(w, WC_MAIN_TOOLBAR, _settings_client.gui.toolbar_pos);
02685 }
02686 
02692 int PositionStatusbar(Window *w)
02693 {
02694   DEBUG(misc, 5, "Repositioning statusbar...");
02695   return PositionWindow(w, WC_STATUS_BAR, _settings_client.gui.statusbar_pos);
02696 }
02697 
02703 int PositionNewsMessage(Window *w)
02704 {
02705   DEBUG(misc, 5, "Repositioning news message...");
02706   return PositionWindow(w, WC_NEWS_WINDOW, _settings_client.gui.statusbar_pos);
02707 }
02708 
02714 int PositionNetworkChatWindow(Window *w)
02715 {
02716   DEBUG(misc, 5, "Repositioning network chat window...");
02717   return PositionWindow(w, WC_SEND_NETWORK_MSG, _settings_client.gui.statusbar_pos);
02718 }
02719 
02720 
02726 void ChangeVehicleViewports(VehicleID from_index, VehicleID to_index)
02727 {
02728   Window *w;
02729   FOR_ALL_WINDOWS_FROM_BACK(w) {
02730     if (w->viewport != NULL && w->viewport->follow_vehicle == from_index) {
02731       w->viewport->follow_vehicle = to_index;
02732       w->SetDirty();
02733     }
02734   }
02735 }
02736 
02737 
02743 void RelocateAllWindows(int neww, int newh)
02744 {
02745   Window *w;
02746 
02747   FOR_ALL_WINDOWS_FROM_BACK(w) {
02748     int left, top;
02749 
02750     if (w->window_class == WC_MAIN_WINDOW) {
02751       ViewPort *vp = w->viewport;
02752       vp->width = w->width = neww;
02753       vp->height = w->height = newh;
02754       vp->virtual_width = ScaleByZoom(neww, vp->zoom);
02755       vp->virtual_height = ScaleByZoom(newh, vp->zoom);
02756       continue; // don't modify top,left
02757     }
02758 
02759     /* XXX - this probably needs something more sane. For example specifying
02760      * in a 'backup'-desc that the window should always be centered. */
02761     switch (w->window_class) {
02762       case WC_MAIN_TOOLBAR:
02763         ResizeWindow(w, min(neww, *_preferred_toolbar_size) - w->width, 0);
02764 
02765         top = w->top;
02766         left = PositionMainToolbar(w); // changes toolbar orientation
02767         break;
02768 
02769       case WC_NEWS_WINDOW:
02770         top = newh - w->height;
02771         left = PositionNewsMessage(w);
02772         break;
02773 
02774       case WC_STATUS_BAR:
02775         ResizeWindow(w, min(neww, *_preferred_statusbar_size) - w->width, 0);
02776 
02777         top = newh - w->height;
02778         left = PositionStatusbar(w);
02779         break;
02780 
02781       case WC_SEND_NETWORK_MSG:
02782         ResizeWindow(w, Clamp(neww, 320, 640) - w->width, 0);
02783         top = newh - w->height - FindWindowById(WC_STATUS_BAR, 0)->height;
02784         left = PositionNetworkChatWindow(w);
02785         break;
02786 
02787       case WC_CONSOLE:
02788         IConsoleResize(w);
02789         continue;
02790 
02791       default: {
02792         if (w->flags4 & WF_CENTERED) {
02793           top = (newh - w->height) >> 1;
02794           left = (neww - w->width) >> 1;
02795           break;
02796         }
02797 
02798         left = w->left;
02799         if (left + (w->width >> 1) >= neww) left = neww - w->width;
02800         if (left < 0) left = 0;
02801 
02802         top = w->top;
02803         if (top + (w->height >> 1) >= newh) top = newh - w->height;
02804 
02805         const Window *wt = FindWindowById(WC_MAIN_TOOLBAR, 0);
02806         if (wt != NULL) {
02807           if (top < wt->height && wt->left < (w->left + w->width) && (wt->left + wt->width) > w->left) top = wt->height;
02808           if (top >= newh) top = newh - 1;
02809         } else {
02810           if (top < 0) top = 0;
02811         }
02812         break;
02813       }
02814     }
02815 
02816     if (w->viewport != NULL) {
02817       w->viewport->left += left - w->left;
02818       w->viewport->top += top - w->top;
02819     }
02820 
02821     w->left = left;
02822     w->top = top;
02823   }
02824 }
02825 
02831 PickerWindowBase::~PickerWindowBase()
02832 {
02833   this->window_class = WC_INVALID; // stop the ancestor from freeing the already (to be) child
02834   ResetObjectToPlace();
02835 }

Generated on Sun May 15 19:20:19 2011 for OpenTTD by  doxygen 1.6.1