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   /**
 155    * Destroy the current "bottom" Widget, but don't resize the main
 156    * area.  The caller is responsible for doing that or installing a
 157    * new bottom Widget.
 158    */
 159   void KillBottomWidget();
 160
 161 public:
 162   void Create(PixelSize size, TopWindowStyle style=TopWindowStyle());
 163
 164   void Destroy();
 165
 166   void Initialise();
 167   void InitialiseConfigured();
 168
 169   /**
 170    * Destroy the components of the main view (map, info boxes,
 171    * gauges).
 172    */
 173   void Deinitialise();
 174
 175 private:
 176   gcc_pure
 177   const PixelRect &GetMainRect(const PixelRect &full_rc) const {
 178     return FullScreen ? full_rc : map_rect;
 179   }
 180
 181   gcc_pure
 182   PixelRect GetMainRect() const {
 183     return FullScreen ? GetClientRect() : map_rect;
 184   }
 185
 186   /**
 187    * Adjust the flarm radar position
 188    */
 189   void ReinitialiseLayout_flarm(PixelRect rc, const InfoBoxLayout::Layout ib_layout);
 190
 191   /**
 192    * Adjust vario
 193    */
 194   void ReinitialiseLayout_vario(const InfoBoxLayout::Layout &layout);
 195
 196   void ReinitialiseLayoutTA(PixelRect rc, const InfoBoxLayout::Layout &layout);
 197
 198 public:
 199   /**
 200    * Called by XCSoarInterface::Startup() after startup has been
 201    * completed.
 202    */
 203   void FinishStartup();
 204
 205   /**
 206    * Called by XCSoarInterface::Shutdown() before shutdown begins.
 207    */
 208   void BeginShutdown();
 209
 210   /**
 211    * Destroy and re-create all info boxes, and adjust the map
 212    * position/size.
 213    */
 214   void ReinitialiseLayout();
 215
 216   /**
 217    * Suspend threads that are owned by this object.
 218    */
 219   void SuspendThreads();
 220
 221   /**
 222    * Resumt threads that are owned by this object.
 223    */
 224   void ResumeThreads();
 225
 226   /**
 227    * Set the keyboard focus on the default element (i.e. the
 228    * MapWindow).
 229    */
 230   void SetDefaultFocus();
 231
 232   /**
 233    * Trigger a full redraw of the screen.
 234    */
 235   void FullRedraw();
 236
 237   bool GetFullScreen() const {
 238     return FullScreen;
 239   }
 240
 241   void SetFullScreen(bool _full_screen);
 242
 243   /**
 244    * A new airspace warning was found.  This method sends the
 245    * Command::AIRSPACE_WARNING command to this window, which displays the
 246    * airspace warning dialog.
 247    */
 248   void SendAirspaceWarning() {
 249     airspace_warning_pending = true;
 250     SendUser((unsigned)Command::AIRSPACE_WARNING);
 251   }
 252
 253   void SendGPSUpdate() {
 254     SendUser((unsigned)Command::GPS_UPDATE);
 255   }
 256
 257   void SendCalculatedUpdate() {
 258     SendUser((unsigned)Command::CALCULATED_UPDATE);
 259   }
 260
 261   void SetTerrain(RasterTerrain *terrain);
 262   void SetTopography(TopographyStore *topography);
 263
 264   const Look &GetLook() const {
 265     assert(look != NULL);
 266
 267     return *look;
 268   }
 269
 270   Look &SetLook() {
 271     assert(look != NULL);
 272
 273     return *look;
 274   }
 275
 276   void SetComputerSettings(const ComputerSettings &settings_computer);
 277   void SetMapSettings(const MapSettings &settings_map);
 278   void SetUIState(const UIState &ui_state);
 279
 280   /**
 281    * Returns the map even if it is not active.  May return NULL if
 282    * there is no map.
 283    */
 284   gcc_pure
 285   GlueMapWindow *GetMap() {
 286     return map;
 287   }
 288
 289   /**
 290    * Is the map active, i.e. currently visible?
 291    */
 292   bool IsMapActive() const {
 293     return widget == NULL;
 294   }
 295
 296   /**
 297    * Returns the map if it is active, or NULL if the map is not
 298    * active.
 299    */
 300   gcc_pure
 301   GlueMapWindow *GetMapIfActive();
 302
 303   /**
 304    * Activate the map and return a pointer to it.  May return NULL if
 305    * there is no map.
 306    */
 307   GlueMapWindow *ActivateMap();
 308
 309   /**
 310    * Schedule a call to PageActions::Restore().  The function returns
 311    * immediately, and there is no guarantee that it succeeds.
 312    */
 313   void DeferredRestorePage();
 314
 315   /**
 316    * Show this #Widget below the map.  This replaces (deletes) the
 317    * previous bottom widget, if any.  To disable this feature, call
 318    * this method with widget==nullptr.
 319    */
 320   void SetBottomWidget(Widget *widget);
 321
 322   /**
 323    * Replace the map with a #Widget.  The Widget instance gets deleted
 324    * when the map gets reactivated with ActivateMap() or if another
 325    * Widget gets set.
 326    */
 327   void SetWidget(Widget *_widget);
 328
 329   /**
 330    * Returns the current #Widget, but only if the specified flavour is
 331    * active.
 332    *
 333    * @see InputEvents::IsFlavour(), InputEvents::SetFlavour()
 334    */
 335   gcc_pure
 336   Widget *GetFlavourWidget(const TCHAR *flavour);
 337
 338   void UpdateGaugeVisibility();
 339
 340   gcc_pure
 341   const MapWindowProjection &GetProjection() const;
 342
 343   void ToggleSuppressFLARMRadar();
 344   void ToggleForceFLARMRadar();
 345
 346 private:
 347   void UpdateVarioGaugeVisibility();
 348   void UpdateTrafficGaugeVisibility();
 349
 350   void StopDragging();
 351
 352 protected:
 353   /* virtual methods from class Window */
 354   virtual void OnDestroy() override;
 355   virtual void OnResize(PixelSize new_size) override;
 356   virtual void OnSetFocus() override;
 357   virtual void OnCancelMode() override;
 358   virtual bool OnMouseDown(PixelScalar x, PixelScalar y) override;
 359   virtual bool OnMouseUp(PixelScalar x, PixelScalar y) override;
 360   virtual bool OnMouseMove(PixelScalar x, PixelScalar y,
 361                            unsigned keys) override;
 362   virtual bool OnMouseDouble(PixelScalar x, PixelScalar y) override;
 363   virtual bool OnKeyDown(unsigned key_code) override;
 364   virtual bool OnUser(unsigned id) override;
 365   virtual bool OnTimer(WindowTimer &timer) override;
 366
 367   /* virtual methods from class TopWindow */
 368   virtual bool OnClose() override;
 369   virtual bool OnActivate() override;
 370
 371 #ifdef ANDROID
 372   virtual void OnPause() override;
 373 #endif
 374 };
 375
 376 #endif