From 335744a1af89466f9a2003cc0f9b59f26b7c0e14 Mon Sep 17 00:00:00 2001 From: frosch Date: Sun, 13 Mar 2011 21:32:13 +0000 Subject: [PATCH] (svn r22242) -Codechange: Let OnInvalidateData() decide itself what to do immediately in command scope, and what to do asynchronously in GUI-scope. --- src/window.cpp | 43 ++++++++++++++++++++++++++----------------- src/window_func.h | 4 ++-- src/window_gui.h | 22 ++++++++-------------- 3 files changed, 36 insertions(+), 33 deletions(-) diff --git a/src/window.cpp b/src/window.cpp index aa02aad115..fdf8811170 100644 --- a/src/window.cpp +++ b/src/window.cpp @@ -2481,46 +2481,55 @@ void SetWindowClassesDirty(WindowClass cls) /** * Mark window data of the window of a given class and specific window number as invalid (in need of re-computing) - * Note that by default the invalidation is not executed immediately but is scheduled till the next redraw. + * + * Note that by default the invalidation is not considered to be called from GUI scope. + * That means only a part of invalidation is executed immediately. The rest is scheduled for the next redraw. * The asynchronous execution is important to prevent GUI code being executed from command scope. + * When not in GUI-scope: + * - OnInvalidateData() may not do test-runs on commands, as they might affect the execution of + * the command which triggered the invalidation. (town rating and such) + * - OnInvalidateData() may not rely on _current_company == _local_company. + * This implies that no NewGRF callbacks may be run. + * + * However, when invalidations are scheduled, then multiple calls may be scheduled before execution starts. Earlier scheduled + * invalidations may be called with invalidation-data, which is already invalid at the point of execution. + * That means some stuff requires to be executed immediately in command scope, while not everything may be executed in command + * scope. While GUI-scope calls have no restrictions on what they may do, they cannot assume the game to still be in the state + * when the invalidation was scheduled; passed IDs may have got invalid in the mean time. + * + * Finally, note that invalidations triggered from commands or the game loop result in OnInvalidateData() being called twice. + * Once in command-scope, once in GUI-scope. So make sure to not process differential-changes twice. + * * @param cls Window class * @param number Window number within the class * @param data The data to invalidate with - * @param immediately If true then do not schedule the event, but execute immediately. + * @param gui_scope Whether the call is done from GUI scope */ -void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool immediately) +void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope) { Window *w; FOR_ALL_WINDOWS_FROM_BACK(w) { if (w->window_class == cls && w->window_number == number) { - if (immediately) { - w->InvalidateData(data); - } else { - w->ScheduleInvalidateData(data); - } + w->InvalidateData(data, gui_scope); } } } /** * Mark window data of all windows of a given class as invalid (in need of re-computing) - * Note that by default the invalidation is not executed immediately but is scheduled till the next redraw. - * The asynchronous execution is important to prevent GUI code being executed from command scope. + * Note that by default the invalidation is not considered to be called from GUI scope. + * See InvalidateWindowData() for details on GUI-scope vs. command-scope. * @param cls Window class * @param data The data to invalidate with - * @param immediately If true then do not schedule the event, but execute immediately. + * @param gui_scope Whether the call is done from GUI scope */ -void InvalidateWindowClassesData(WindowClass cls, int data, bool immediately) +void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope) { Window *w; FOR_ALL_WINDOWS_FROM_BACK(w) { if (w->window_class == cls) { - if (immediately) { - w->InvalidateData(data); - } else { - w->ScheduleInvalidateData(data); - } + w->InvalidateData(data, gui_scope); } } } diff --git a/src/window_func.h b/src/window_func.h index 43f50111d4..604cb1d98a 100644 --- a/src/window_func.h +++ b/src/window_func.h @@ -34,8 +34,8 @@ void ResetWindowSystem(); void SetupColoursAndInitialWindow(); void InputLoop(); -void InvalidateWindowData(WindowClass cls, WindowNumber number, int data = 0, bool immediately = false); -void InvalidateWindowClassesData(WindowClass cls, int data = 0, bool immediately = false); +void InvalidateWindowData(WindowClass cls, WindowNumber number, int data = 0, bool gui_scope = false); +void InvalidateWindowClassesData(WindowClass cls, int data = 0, bool gui_scope = false); void DeleteNonVitalWindows(); void DeleteAllNonVitalWindows(); diff --git a/src/window_gui.h b/src/window_gui.h index fc5ebeedae..0ec585e34a 100644 --- a/src/window_gui.h +++ b/src/window_gui.h @@ -434,22 +434,16 @@ public: /** * Mark this window's data as invalid (in need of re-computing) * @param data The data to invalidate with + * @param gui_scope Whether the funtion is called from GUI scope. */ - void InvalidateData(int data = 0) + void InvalidateData(int data = 0, bool gui_scope = true) { this->SetDirty(); - this->OnInvalidateData(data); - } - - /** - * Schedule a invalidation call for next redraw. - * Important for asynchronous invalidation from commands. - * @param data The data to invalidate with - */ - void ScheduleInvalidateData(int data = 0) - { - this->SetDirty(); - *this->scheduled_invalidation_data.Append() = data; + if (!gui_scope) { + /* Schedule GUI-scope invalidation for next redraw. */ + *this->scheduled_invalidation_data.Append() = data; + } + this->OnInvalidateData(data, gui_scope); } /** @@ -458,7 +452,7 @@ public: void ProcessScheduledInvalidations() { for (int *data = this->scheduled_invalidation_data.Begin(); this->window_class != WC_INVALID && data != this->scheduled_invalidation_data.End(); data++) { - this->OnInvalidateData(*data); + this->OnInvalidateData(*data, true); } this->scheduled_invalidation_data.Clear(); }