src/MainWindow.hpp

   1 /*
   2 Copyright_License {
   3
   4   XCSoar Glide Computer - http://www.xcsoar.org/
   5   Copyright (C) 2000-2013 The XCSoar Project
   6   A detailed list of copyright holders can be found in the file "AUTHORS".
   7
   8   This program is free software; you can redistribute it and/or
   9   modify it under the terms of the GNU General Public License
  10   as published by the Free Software Foundation; either version 2
  11   of the License, or (at your option) any later version.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18   You should have received a copy of the GNU General Public License
  19   along with this program; if not, write to the Free Software
  20   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21 }
  22 */
  23
  24 #ifndef XCSOAR_MAIN_WINDOW_HXX
  25 #define XCSOAR_MAIN_WINDOW_HXX
  26
  27 #include "Screen/SingleWindow.hpp"
  28 #include "Screen/Timer.hpp"
  29 #include "InfoBoxes/InfoBoxLayout.hpp"
  30 #include "PopupMessage.hpp"
  31 #include "BatteryTimer.hpp"
  32 #include "Widget/ManagedWidget.hpp"
  33 #include "UIUtil/GestureManager.hpp"
  34
  35 #include <stdint.h>
  36 #include <assert.h>
  37
  38 struct ComputerSettings;
  39 struct MapSettings;
  40 struct UIState;
  41 struct Look;
  42 class GlueMapWindow;
  43 class Widget;
  44 class StatusMessageList;
  45 class RasterTerrain;
  46 class TopographyStore;
  47 class MapWindowProjection;
  48
  49 /**
  50  * The XCSoar main window.
  51  */
  52 class MainWindow : public SingleWindow {
  53   enum class Command: uint8_t {
  54     /**
  55      * Check the airspace_warning_pending flag and show the airspace
  56      * warning dialog.
  57      */
  58     AIRSPACE_WARNING,
  59
  60     /**
  61      * Called by the #MergeThread when new GPS data is available.
  62      */
  63     GPS_UPDATE,
  64
  65     /**
  66      * Called by the calculation thread when new calculation results
  67      * are available.  This updates the map and the info boxes.
  68      */
  69     CALCULATED_UPDATE,
  70
  71     /**
  72      * @see DeferredRestorePage()
  73      */
  74     RESTORE_PAGE,
  75   };
  76
  77   static constexpr const TCHAR *title = _T("XCSoar");
  78
  79   Look *look;
  80
  81   GlueMapWindow *map;
  82
  83   /**
  84    * A #Widget that is shown below the map.
  85    */
  86   Widget *bottom_widget;
  87
  88   /**
  89    * A #Widget that is shown instead of the map.  The #GlueMapWindow
  90    * is hidden and the DrawThread is suspended while this attribute is
  91    * non-NULL.
  92    */
  93   Widget *widget;
  94
  95   ManagedWidget vario;
  96
  97   ManagedWidget traffic_gauge;
  98   bool suppress_traffic_gauge, force_traffic_gauge;
  99
 100   ManagedWidget thermal_assistant;
 101
 102   bool dragging;
 103   GestureManager gestures;
 104
 105 public:
 106   PopupMessage popup;
 107
 108 private:
 109   WindowTimer timer;
 110
 111   BatteryTimer battery_timer;
 112
 113   PixelRect map_rect;
 114   bool FullScreen;
 115
 116 #ifndef ENABLE_OPENGL
 117   /**
 118    * This variable tracks whether the #DrawThread was suspended
 119    * because the map was replaced by a #Widget.
 120    */
 121   bool draw_suspended;
 122 #endif
 123
 124   bool restore_page_pending;
 125
 126   bool airspace_warning_pending;
 127
 128 public:
 129   MainWindow(const StatusMessageList &status_messages);
 130   virtual ~MainWindow();
 131
 132 #ifdef USE_GDI
 133   static bool Find() {
 134     return SingleWindow::Find(title);
 135   }
 136 #endif
 137
 138 protected:
 139   /**
 140    * Is XCSoar already up and running?
 141    */
 142   bool IsRunning() {
 143     /* it is safe enough to say that XCSoar initialization is complete
 144        after the MapWindow has been created */
 145     return map != NULL;
 146   }
 147
 148   /**
 149    * Destroy the current Widget, but don't reactivate the map.  The
 150    * caller is responsible for reactivating the map or another Widget.
 151    */
 152   void KillWidget();
 153
 154 public:
 155   void Create(PixelSize size, TopWindowStyle style=TopWindowStyle());
 156
 157   void Destroy();
 158
 159   void Initialise();
 160   void InitialiseConfigured();
 161
 162   /**
 163    * Destroy the components of the main view (map, info boxes,
 164    * gauges).
 165    */
 166   void Deinitialise();
 167
 168 private:
 169   gcc_pure
 170   const PixelRect &GetMainRect(const PixelRect &full_rc) const {
 171     return FullScreen ? full_rc : map_rect;
 172   }
 173
 174   gcc_pure
 175   PixelRect GetMainRect() const {
 176     return FullScreen ? GetClientRect() : map_rect;
 177   }
 178
 179   /**
 180    * Adjust the flarm radar position
 181    */
 182   void ReinitialiseLayout_flarm(PixelRect rc, const InfoBoxLayout::Layout ib_layout);
 183
 184   /**
 185    * Adjust vario
 186    */
 187   void ReinitialiseLayout_vario(const InfoBoxLayout::Layout &layout);
 188
 189   void ReinitialiseLayoutTA(PixelRect rc, const InfoBoxLayout::Layout &layout);
 190
 191 public:
 192   /**
 193    * Called by XCSoarInterface::Startup() after startup has been
 194    * completed.
 195    */
 196   void FinishStartup();
 197
 198   /**
 199    * Called by XCSoarInterface::Shutdown() before shutdown begins.
 200    */
 201   void BeginShutdown();
 202
 203   /**
 204    * Destroy and re-create all info boxes, and adjust the map
 205    * position/size.
 206    */
 207   void ReinitialiseLayout();
 208
 209   /**
 210    * Suspend threads that are owned by this object.
 211    */
 212   void SuspendThreads();
 213
 214   /**
 215    * Resumt threads that are owned by this object.
 216    */
 217   void ResumeThreads();
 218
 219   /**
 220    * Set the keyboard focus on the default element (i.e. the
 221    * MapWindow).
 222    */
 223   void SetDefaultFocus();
 224
 225   /**
 226    * Trigger a full redraw of the screen.
 227    */
 228   void FullRedraw();
 229
 230   bool GetFullScreen() const {
 231     return FullScreen;
 232   }
 233
 234   void SetFullScreen(bool _full_screen);
 235
 236   /**
 237    * A new airspace warning was found.  This method sends the
 238    * Command::AIRSPACE_WARNING command to this window, which displays the
 239    * airspace warning dialog.
 240    */
 241   void SendAirspaceWarning() {
 242     airspace_warning_pending = true;
 243     SendUser((unsigned)Command::AIRSPACE_WARNING);
 244   }
 245
 246   void SendGPSUpdate() {
 247     SendUser((unsigned)Command::GPS_UPDATE);
 248   }
 249
 250   void SendCalculatedUpdate() {
 251     SendUser((unsigned)Command::CALCULATED_UPDATE);
 252   }
 253
 254   void SetTerrain(RasterTerrain *terrain);
 255   void SetTopography(TopographyStore *topography);
 256
 257   const Look &GetLook() const {
 258     assert(look != NULL);
 259
 260     return *look;
 261   }
 262
 263   Look &SetLook() {
 264     assert(look != NULL);
 265
 266     return *look;
 267   }
 268
 269   void SetComputerSettings(const ComputerSettings &settings_computer);
 270   void SetMapSettings(const MapSettings &settings_map);
 271   void SetUIState(const UIState &ui_state);
 272
 273   /**
 274    * Returns the map even if it is not active.  May return NULL if
 275    * there is no map.
 276    */
 277   gcc_pure
 278   GlueMapWindow *GetMap() {
 279     return map;
 280   }
 281
 282   /**
 283    * Is the map active, i.e. currently visible?
 284    */
 285   bool IsMapActive() const {
 286     return widget == NULL;
 287   }
 288
 289   /**
 290    * Returns the map if it is active, or NULL if the map is not
 291    * active.
 292    */
 293   gcc_pure
 294   GlueMapWindow *GetMapIfActive();
 295
 296   /**
 297    * Activate the map and return a pointer to it.  May return NULL if
 298    * there is no map.
 299    */
 300   GlueMapWindow *ActivateMap();
 301
 302   /**
 303    * Schedule a call to PageActions::Restore().  The function returns
 304    * immediately, and there is no guarantee that it succeeds.
 305    */
 306   void DeferredRestorePage();
 307
 308   /**
 309    * Show this #Widget below the map.  This replaces (deletes) the
 310    * previous bottom widget, if any.  To disable this feature, call
 311    * this method with widget==nullptr.
 312    */
 313   void SetBottomWidget(Widget *widget);
 314
 315   /**
 316    * Replace the map with a #Widget.  The Widget instance gets deleted
 317    * when the map gets reactivated with ActivateMap() or if another
 318    * Widget gets set.
 319    */
 320   void SetWidget(Widget *_widget);
 321
 322   /**
 323    * Returns the current #Widget, but only if the specified flavour is
 324    * active.
 325    *
 326    * @see InputEvents::IsFlavour(), InputEvents::SetFlavour()
 327    */
 328   gcc_pure
 329   Widget *GetFlavourWidget(const TCHAR *flavour);
 330
 331   void UpdateGaugeVisibility();
 332
 333   gcc_pure
 334   const MapWindowProjection &GetProjection() const;
 335
 336   void ToggleSuppressFLARMRadar();
 337   void ToggleForceFLARMRadar();
 338
 339 private:
 340   void UpdateVarioGaugeVisibility();
 341   void UpdateTrafficGaugeVisibility();
 342
 343   void StopDragging();
 344
 345 protected:
 346   /* virtual methods from class Window */
 347   virtual void OnDestroy() override;
 348   virtual void OnResize(PixelSize new_size) override;
 349   virtual void OnSetFocus() override;
 350   virtual void OnCancelMode() override;
 351   virtual bool OnMouseDown(PixelScalar x, PixelScalar y) override;
 352   virtual bool OnMouseUp(PixelScalar x, PixelScalar y) override;
 353   virtual bool OnMouseMove(PixelScalar x, PixelScalar y,
 354                            unsigned keys) override;
 355   virtual bool OnMouseDouble(PixelScalar x, PixelScalar y) override;
 356   virtual bool OnKeyDown(unsigned key_code) override;
 357   virtual bool OnUser(unsigned id) override;
 358   virtual bool OnTimer(WindowTimer &timer) override;
 359
 360   /* virtual methods from class TopWindow */
 361   virtual bool OnClose() override;
 362   virtual bool OnActivate() override;
 363
 364 #ifdef ANDROID
 365   virtual void OnPause() override;
 366 #endif
 367 };
 368
 369 #endif