src/PageActions.cpp

   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 #include "PageActions.hpp"
  25 #include "UIActions.hpp"
  26 #include "UIState.hpp"
  27 #include "Interface.hpp"
  28 #include "ActionInterface.hpp"
  29 #include "MainWindow.hpp"
  30 #include "CrossSection/CrossSectionWidget.hpp"
  31 #include "InfoBoxes/InfoBoxSettings.hpp"
  32 #include "Pan.hpp"
  33 #include "UIGlobals.hpp"
  34 #include "MapWindow/GlueMapWindow.hpp"
  35
  36 #if defined(ENABLE_SDL) && defined(main)
  37 /* on some platforms, SDL wraps the main() function and clutters our
  38    namespace with a macro called "main" */
  39 #undef main
  40 #endif
  41
  42 namespace PageActions {
  43   /**
  44    * Call this when we're about to leave the current page.  This
  45    * function checks if settings need to be remembered.
  46    */
  47   static void LeavePage();
  48
  49   /**
  50    * Restore the map zoom afte switching to a configured page.
  51    */
  52   static void RestoreMapZoom();
  53
  54   /**
  55    * Loads the layout without updating current page information in
  56    * #UIState.
  57    */
  58   static void LoadLayout(const PageLayout &layout);
  59 };
  60
  61 void
  62 PageActions::LeavePage()
  63 {
  64   PagesState &state = CommonInterface::SetUIState().pages;
  65
  66   if (state.special_page.IsDefined())
  67     return;
  68
  69   PageState &page = state.pages[state.current_index];
  70
  71   const GlueMapWindow *map = UIGlobals::GetMapIfActive();
  72   if (map != nullptr)
  73     page.map_scale = map->VisibleProjection().GetMapScale();
  74 }
  75
  76 void
  77 PageActions::RestoreMapZoom()
  78 {
  79   const PagesState &state = CommonInterface::SetUIState().pages;
  80   if (state.special_page.IsDefined())
  81     return;
  82
  83   const PageState &page = state.pages[state.current_index];
  84   const PageSettings &settings = CommonInterface::GetUISettings().pages;
  85
  86   if (settings.distinct_zoom && positive(page.map_scale)) {
  87     GlueMapWindow *map = UIGlobals::GetMapIfActive();
  88     if (map != nullptr) {
  89       map->SetMapScale(page.map_scale);
  90       map->QuickRedraw();
  91     }
  92   }
  93 }
  94
  95 static const PageLayout &
  96 GetConfiguredLayout()
  97 {
  98   const PageSettings &settings = CommonInterface::GetUISettings().pages;
  99   const PagesState &state = CommonInterface::GetUIState().pages;
 100
 101   return settings.pages[state.current_index];
 102 }
 103
 104 const PageLayout &
 105 PageActions::GetCurrentLayout()
 106 {
 107   const PagesState &state = CommonInterface::GetUIState().pages;
 108
 109   return state.special_page.IsDefined()
 110     ? state.special_page
 111     : GetConfiguredLayout();
 112 }
 113
 114 void
 115 PageActions::Update()
 116 {
 117   LoadLayout(GetCurrentLayout());
 118 }
 119
 120
 121 unsigned
 122 PageActions::NextIndex()
 123 {
 124   const PageSettings &settings = CommonInterface::GetUISettings().pages;
 125   const PagesState &state = CommonInterface::GetUIState().pages;
 126
 127   if (state.special_page.IsDefined())
 128     /* if a "special" page is active, any page switch will return to
 129        the last configured page */
 130     return state.current_index;
 131
 132   return (state.current_index + 1) % settings.n_pages;
 133 }
 134
 135
 136 void
 137 PageActions::Next()
 138 {
 139   LeavePage();
 140
 141   PagesState &state = CommonInterface::SetUIState().pages;
 142
 143   state.current_index = NextIndex();
 144   state.special_page.SetUndefined();
 145
 146   Update();
 147   RestoreMapZoom();
 148 }
 149
 150 unsigned
 151 PageActions::PrevIndex()
 152 {
 153   const PageSettings &settings = CommonInterface::GetUISettings().pages;
 154   const PagesState &state = CommonInterface::GetUIState().pages;
 155
 156   if (state.special_page.IsDefined())
 157     /* if a "special" page is active, any page switch will return to
 158        the last configured page */
 159     return state.current_index;
 160
 161   return (state.current_index + settings.n_pages - 1)
 162     % settings.n_pages;
 163 }
 164
 165
 166 void
 167 PageActions::Prev()
 168 {
 169   LeavePage();
 170
 171   PagesState &state = CommonInterface::SetUIState().pages;
 172
 173   state.current_index = PrevIndex();
 174   state.special_page.SetUndefined();
 175
 176   Update();
 177   RestoreMapZoom();
 178 }
 179
 180 void
 181 PageActions::LoadLayout(const PageLayout &layout)
 182 {
 183   UIState &ui_state = CommonInterface::SetUIState();
 184
 185   if (!layout.valid)
 186     return;
 187
 188   DisablePan();
 189
 190   if (!layout.infobox_config.enabled) {
 191     CommonInterface::main_window->SetFullScreen(true);
 192     ui_state.auxiliary_enabled = false;
 193   } else {
 194     if (!layout.infobox_config.auto_switch &&
 195         layout.infobox_config.panel < InfoBoxSettings::MAX_PANELS) {
 196       CommonInterface::main_window->SetFullScreen(false);
 197       ui_state.auxiliary_enabled = true;
 198       ui_state.auxiliary_index = layout.infobox_config.panel;
 199     }
 200     else {
 201       CommonInterface::main_window->SetFullScreen(false);
 202       ui_state.auxiliary_enabled = false;
 203     }
 204   }
 205
 206   switch (layout.bottom) {
 207   case PageLayout::Bottom::NOTHING:
 208     CommonInterface::main_window->SetBottomWidget(nullptr);
 209     break;
 210
 211   case PageLayout::Bottom::CROSS_SECTION:
 212     CommonInterface::main_window->SetBottomWidget(new CrossSectionWidget());
 213     break;
 214
 215   case PageLayout::Bottom::MAX:
 216     gcc_unreachable();
 217   }
 218
 219   switch (layout.main) {
 220   case PageLayout::Main::MAP:
 221     CommonInterface::main_window->ActivateMap();
 222     break;
 223
 224   case PageLayout::Main::FLARM_RADAR:
 225     UIActions::ShowTrafficRadar();
 226     break;
 227
 228   case PageLayout::Main::THERMAL_ASSISTANT:
 229     UIActions::ShowThermalAssistant();
 230     break;
 231
 232   case PageLayout::Main::MAX:
 233     gcc_unreachable();
 234   }
 235
 236   ActionInterface::UpdateDisplayMode();
 237   ActionInterface::SendUIState();
 238 }
 239
 240 void
 241 PageActions::OpenLayout(const PageLayout &layout)
 242 {
 243   PagesState &state = CommonInterface::SetUIState().pages;
 244   state.special_page = layout;
 245
 246   LoadLayout(layout);
 247 }
 248
 249 void
 250 PageActions::Restore()
 251 {
 252   PageLayout &special_page = CommonInterface::SetUIState().pages.special_page;
 253   if (!special_page.IsDefined())
 254     return;
 255
 256   special_page.SetUndefined();
 257
 258   LoadLayout(GetConfiguredLayout());
 259   RestoreMapZoom();
 260 }
 261
 262 void
 263 PageActions::DeferredRestore()
 264 {
 265   CommonInterface::main_window->DeferredRestorePage();
 266 }
 267
 268 GlueMapWindow *
 269 PageActions::ShowMap()
 270 {
 271   PageLayout layout = GetCurrentLayout();
 272   if (layout.main != PageLayout::Main::MAP) {
 273     /* not showing map currently: activate it */
 274
 275     if (GetConfiguredLayout().main == PageLayout::Main::MAP)
 276       /* the configured page is a map page: restore it */
 277       Restore();
 278     else {
 279       /* generate a "special" map page based on the current page */
 280       layout.main = PageLayout::Main::MAP;
 281       OpenLayout(layout);
 282     }
 283   }
 284
 285   return CommonInterface::main_window->ActivateMap();
 286 }
 287
 288 GlueMapWindow *
 289 PageActions::ShowOnlyMap()
 290 {
 291   OpenLayout(PageLayout::FullScreen());
 292   return CommonInterface::main_window->ActivateMap();
 293 }
 294
 295 void
 296 PageActions::ShowTrafficRadar()
 297 {
 298   PageLayout layout = GetCurrentLayout();
 299   if (layout.main == PageLayout::Main::FLARM_RADAR)
 300     /* already showing the traffic radar */
 301     return;
 302
 303   if (GetConfiguredLayout().main == PageLayout::Main::FLARM_RADAR)
 304     /* the configured page is a traffic radar page: restore it */
 305     Restore();
 306   else {
 307     /* generate a "special" page based on the current page */
 308     layout.main = PageLayout::Main::FLARM_RADAR;
 309     layout.bottom = PageLayout::Bottom::NOTHING;
 310     OpenLayout(layout);
 311   }
 312 }
 313
 314
 315 void
 316 PageActions::ShowThermalAssistant()
 317 {
 318   PageLayout layout = GetCurrentLayout();
 319   if (layout.main == PageLayout::Main::THERMAL_ASSISTANT)
 320     /* already showing the traffic radar */
 321     return;
 322
 323   if (GetConfiguredLayout().main == PageLayout::Main::THERMAL_ASSISTANT)
 324     /* the configured page is a traffic radar page: restore it */
 325     Restore();
 326   else {
 327     /* generate a "special" page based on the current page */
 328     layout.main = PageLayout::Main::THERMAL_ASSISTANT;
 329     layout.bottom = PageLayout::Bottom::NOTHING;
 330     OpenLayout(layout);
 331   }
 332 }