From 2872d9ef363dc84abcc1a5a73ad7778ab70ee4ab Mon Sep 17 00:00:00 2001
From: Michael Hasling <mjh65@github.com>
Date: Sun, 17 Mar 2024 15:25:40 +0000
Subject: [PATCH] Convert ChartFox interfacing to v2 API.

---
 .gitignore                                    |  16 +-
 CMakeLists.txt                                |   6 +-
 config.h.in                                   |   2 +-
 src/CMakeLists.txt                            |   5 +-
 src/avitab/apps/AppLauncher.cpp               |   2 +-
 src/avitab/apps/ProvidersApp.cpp              | 179 +++++++++---
 src/avitab/apps/ProvidersApp.h                |  26 +-
 src/charts/Chart.h                            |   3 +-
 src/charts/ChartService.cpp                   |  35 ++-
 src/charts/ChartService.h                     |  12 +-
 src/charts/RESTClient.h                       |   1 +
 src/charts/libchartfox/CMakeLists.txt         |   2 +
 src/charts/libchartfox/ChartFoxAPI.cpp        | 182 +++++++++---
 src/charts/libchartfox/ChartFoxAPI.h          |  46 ++-
 src/charts/libchartfox/ChartFoxAuthServer.cpp | 276 ++++++++++++++++++
 src/charts/libchartfox/ChartFoxAuthServer.h   |  59 ++++
 src/charts/libchartfox/ChartFoxChart.cpp      | 121 +++-----
 src/charts/libchartfox/ChartFoxChart.h        |  35 ++-
 .../libchartfox/ChartFoxOAuth2Client.cpp      | 249 ++++++++++++++++
 src/charts/libchartfox/ChartFoxOAuth2Client.h |  84 ++++++
 src/charts/liblocalfile/LocalFileChart.h      |  19 +-
 src/charts/libnavigraph/NavigraphChart.h      |  18 +-
 src/gui_toolkit/widgets/Widget.cpp            |   5 +
 src/gui_toolkit/widgets/Widget.h              |   1 +
 24 files changed, 1130 insertions(+), 254 deletions(-)
 create mode 100644 src/charts/libchartfox/ChartFoxAuthServer.cpp
 create mode 100644 src/charts/libchartfox/ChartFoxAuthServer.h
 create mode 100644 src/charts/libchartfox/ChartFoxOAuth2Client.cpp
 create mode 100644 src/charts/libchartfox/ChartFoxOAuth2Client.h

diff --git a/.gitignore b/.gitignore
index 8bddc2f8..7c28b745 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,9 +34,18 @@
 *.app
 
 # Project specific ignores
-build
-build-third
-cmake-build-debug
+/build/
+/build-third/
+/cmake-build-debug/
+/build-*/
+/scratch/
+
+# Ignore hidden files, apart from some project specifics
+/.*
+!/.gitattributes
+!/.gitignore
+!/.gitmodules
+!/.clang-format
 
 # Jetbrains IDE
 .idea/
@@ -46,6 +55,7 @@ cmake-build-debug
 
 # VSCode IDE
 .vscode/
+*.code-workspace
 
 # clangd index and compilation database
 .cache
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 72138837..d7217b91 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,11 +1,11 @@
-cmake_minimum_required(VERSION 3.9)
+cmake_minimum_required(VERSION 3.20)
 project(AviTab VERSION 0.6.3 DESCRIPTION "AviTab X-Plane plugin")
 
 if (NOT "$ENV{NAVIGRAPH_SECRET}" STREQUAL "")
     set(NAVIGRAPH_SECRET "$ENV{NAVIGRAPH_SECRET}" CACHE INTERNAL "Copied from environment variable")
 endif()
-if (NOT "$ENV{CHARTFOX_SECRET}" STREQUAL "")
-    set(CHARTFOX_SECRET "$ENV{CHARTFOX_SECRET}" CACHE INTERNAL "Copied from environment variable")
+if (NOT "$ENV{CHARTFOX_CLIENTID}" STREQUAL "")
+    set(CHARTFOX_CLIENTID "$ENV{CHARTFOX_CLIENTID}" CACHE INTERNAL "Copied from environment variable")
 endif()
 
 configure_file(
diff --git a/config.h.in b/config.h.in
index a23ece67..6c061e9e 100644
--- a/config.h.in
+++ b/config.h.in
@@ -21,4 +21,4 @@
 #define AVITAB_VERSION_PATCH @AviTab_VERSION_PATCH@
 #define AVITAB_VERSION_STR "@AviTab_VERSION_MAJOR@.@AviTab_VERSION_MINOR@.@AviTab_VERSION_PATCH@"
 #define NAVIGRAPH_CLIENT_SECRET "@NAVIGRAPH_SECRET@"
-#define CHARTFOX_CLIENT_SECRET "@CHARTFOX_SECRET@"
+#define CHARTFOX_CLIENT_ID "@CHARTFOX_CLIENTID@"
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 20fb1e11..767d9ca1 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -158,8 +158,9 @@ if(WIN32 AND DEFINED ENV{MSFS_SDK})
     )
 
     add_library(SimConnect STATIC IMPORTED)
-    set_property(TARGET SimConnect PROPERTY IMPORTED_LOCATION "$ENV{MSFS_SDK}/SimConnect SDK/lib/SimConnect.dll")
-    set_property(TARGET SimConnect PROPERTY IMPORTED_IMPLIB "$ENV{MSFS_SDK}/SimConnect SDK/lib/SimConnect.lib")
+    cmake_path(SET MSFS_SDK $ENV{MSFS_SDK})
+    set_property(TARGET SimConnect PROPERTY IMPORTED_LOCATION "${MSFS_SDK}/SimConnect SDK/lib/SimConnect.dll")
+    set_property(TARGET SimConnect PROPERTY IMPORTED_IMPLIB "${MSFS_SDK}/SimConnect SDK/lib/SimConnect.lib")
 
     target_link_libraries(AviTab-msfs
         -static
diff --git a/src/avitab/apps/AppLauncher.cpp b/src/avitab/apps/AppLauncher.cpp
index 1fc8a463..76595703 100644
--- a/src/avitab/apps/AppLauncher.cpp
+++ b/src/avitab/apps/AppLauncher.cpp
@@ -43,7 +43,7 @@ AppLauncher::AppLauncher(FuncsPtr appFuncs):
     addEntry<PlaneManualApp>("Aircraft", root + "if_ilustracoes_04-11_1519786.png", AppId::PLANE_MANUAL);
     addEntry<NotesApp>("Notes", root + "if_txt2_3783.png", AppId::NOTES);
 
-    if (api().getChartService()->getNavigraph()->isSupported() || api().getChartService()->getChartfox()->isSupported()) {
+    if (api().getChartService()->getNavigraph()->isSupported() || api().getChartService()->getChartFox()->isSupported()) {
         addEntry<ProvidersApp>("Providers", root + "if_Airport_22906.png", AppId::NAVIGRAPH);
     }
 
diff --git a/src/avitab/apps/ProvidersApp.cpp b/src/avitab/apps/ProvidersApp.cpp
index 158f8d42..8e3778e9 100644
--- a/src/avitab/apps/ProvidersApp.cpp
+++ b/src/avitab/apps/ProvidersApp.cpp
@@ -39,11 +39,17 @@ ProvidersApp::ProvidersApp(FuncsPtr appFuncs):
         }
     }
 
-    if (api().getChartService()->getChartfox()->isSupported()) {
+    if (api().getChartService()->getChartFox() != nullptr) {
         chartFoxPage = tabs->addTab(tabs, "ChartFox");
         windowChartFox = std::make_shared<Window>(chartFoxPage, "ChartFox");
         windowChartFox->setOnClose([this] () { exit(); });
         resetChartFoxLayout();
+
+        auto chartFox = api().getChartService()->getChartFox();
+        if (chartFox->isAuthenticated()) {
+            // modify the tab to display as if just logged in
+            onChartFoxLoginSuccessful();
+        }
     }
 }
 
@@ -60,10 +66,10 @@ void ProvidersApp::resetNavigraphLayout() {
     labelNavigraph->setLongMode(true);
     labelNavigraph->alignInTopLeft();
 
-    button.reset();
-    button = std::make_shared<Button>(windowNavigraph, "Link Navigraph Account");
-    button->alignBelow(labelNavigraph);
-    button->setCallback([this] (const Button &btn) {
+    linkNavigraphButton.reset();
+    linkNavigraphButton = std::make_shared<Button>(windowNavigraph, "Link Navigraph Account");
+    linkNavigraphButton->alignBelow(labelNavigraph);
+    linkNavigraphButton->setCallback([this] (const Button &btn) {
         api().executeLater([this] () { onNavigraphLogin(); });
     });
 }
@@ -71,16 +77,16 @@ void ProvidersApp::resetNavigraphLayout() {
 void ProvidersApp::onNavigraphLogin() {
     auto svc = api().getChartService();
 
-    button.reset();
+    linkNavigraphButton.reset();
     labelNavigraph->setText("Logging in...");
 
     auto call = svc->loginNavigraph();
     call->andThen([this] (std::future<bool> result) {
         try {
             result.get();
-            api().executeLater([this] () { onAuthSuccess(); });
+            api().executeLater([this] () { onNavigraphAuthSuccess(); });
         } catch (const navigraph::LoginException &e) {
-            api().executeLater([this] () { onAuthRequired(); });
+            api().executeLater([this] () { onNavigraphAuthRequired(); });
         } catch (const std::exception &e) {
             labelNavigraph->setTextFormatted("Error: %s", e.what());
         }
@@ -89,23 +95,23 @@ void ProvidersApp::onNavigraphLogin() {
     svc->submitCall(call);
 }
 
-void ProvidersApp::onAuthRequired() {
+void ProvidersApp::onNavigraphAuthRequired() {
     auto navigraph = api().getChartService()->getNavigraph();
 
     labelNavigraph->setText("Linking required\n"
-                   "Clicking the button will open your browser to login to your Navigraph account.\n"
+                   "Clicking the linkNavigraphButton will open your browser to login to your Navigraph account.\n"
                    "If your browser doesn't start, you can find the link to open in AviTab.log\n"
                    "This process is required only once every 30 days.");
 
-    button.reset();
-    button = std::make_shared<Button>(windowNavigraph, "Open Browser");
-    button->alignBelow(labelNavigraph);
-    button->setCallback([this] (const Button &) {
-        api().executeLater([this] () { onStartAuth(); });
+    linkNavigraphButton.reset();
+    linkNavigraphButton = std::make_shared<Button>(windowNavigraph, "Open Browser");
+    linkNavigraphButton->alignBelow(labelNavigraph);
+    linkNavigraphButton->setCallback([this] (const Button &) {
+        api().executeLater([this] () { onNavigraphStartAuth(); });
     });
 }
 
-void ProvidersApp::onStartAuth() {
+void ProvidersApp::onNavigraphStartAuth() {
     auto navigraph = api().getChartService()->getNavigraph();
     auto link = navigraph->startAuthentication([this] {
         api().executeLater([this] () {
@@ -118,73 +124,71 @@ void ProvidersApp::onStartAuth() {
     labelNavigraph->setText("Follow the instructions in your browser.\n"
                    "If your browser didn't start, manually open the link in AviTab's log file");
 
-    button = std::make_shared<Button>(windowNavigraph, "Cancel");
-    button->alignBelow(labelNavigraph);
-    button->setCallback([this] (const Button &btn) {
-        api().executeLater([this] () { onCancelLoginButton(); });
+    linkNavigraphButton = std::make_shared<Button>(windowNavigraph, "Cancel");
+    linkNavigraphButton->alignBelow(labelNavigraph);
+    linkNavigraphButton->setCallback([this] (const Button &btn) {
+        api().executeLater([this] () { onNavigraphCancelLoginButton(); });
     });
 }
 
-void ProvidersApp::onCancelLoginButton() {
+void ProvidersApp::onNavigraphCancelLoginButton() {
     auto navigraph = api().getChartService()->getNavigraph();
     navigraph->cancelAuth();
     resetNavigraphLayout();
 }
 
-void ProvidersApp::onAuthSuccess() {
+void ProvidersApp::onNavigraphAuthSuccess() {
     auto navigraph = api().getChartService()->getNavigraph();
     if (navigraph->isInDemoMode()) {
         labelNavigraph->setText("Your Navigraph account is linked but doesn't have a charts subscription.\n"
                        "Only LEAL and KONT are usable in demo mode.\n"
                        "Visit navigraph.com to subscribe to Navigraph Charts or Ultimate.\n"
                        "Use the Airport app to access the demo charts.\n"
-                       "Use the home button or the X to close this app.\n");
+                       "Use the home linkNavigraphButton or the X to close this app.\n");
     } else {
         labelNavigraph->setText("Your Navigraph account is now linked to AviTab! Use the Airport app to access charts.\n"
-                       "Use the home button or the X to close this app.\n");
+                       "Use the home linkNavigraphButton or the X to close this app.\n");
     }
 
-    button.reset();
-    button = std::make_shared<Button>(windowNavigraph, "Switch Account");
-    button->alignBelow(labelNavigraph);
-    button->setCallback([this] (const Button &btn) {
-        api().executeLater([this] () { onLogoutButton(); });
+    linkNavigraphButton.reset();
+    linkNavigraphButton = std::make_shared<Button>(windowNavigraph, "Switch Account");
+    linkNavigraphButton->alignBelow(labelNavigraph);
+    linkNavigraphButton->setCallback([this] (const Button &btn) {
+        api().executeLater([this] () { onNavigraphLogoutButton(); });
     });
 }
 
-void ProvidersApp::onLogoutButton() {
+void ProvidersApp::onNavigraphLogoutButton() {
     auto navigraph = api().getChartService()->getNavigraph();
     navigraph->logout();
     resetNavigraphLayout();
 }
 
 void ProvidersApp::resetChartFoxLayout() {
+    api().getChartService()->setUseChartFox(false);
+
     labelChartFox.reset();
     labelChartFox = std::make_shared<Label>(windowChartFox,
-            "ChartFox.org is a free online service that collects the web locations of\n"
+            "chartfox.org is a free online service that collects the web locations of\n"
             "several official and unofficial (e.g. Vatsim) charts.\n"
-            "AviTab can use ChartFox to look up the locations of airport charts\n"
+            "AviTab can use your ChartFox account to look up the locations of airport charts\n"
             "in order to download them from 3rd party sites for you.\n"
             "\n"
-            "If you want to donate to ChartFox, use the button below (opens browser).\n"
+            "Click the Link Account button to authorise Avitab to use your ChartFox account.\n"
+            "If you want to donate to ChartFox, use the Donate below (opens browser).\n"
         );
     labelChartFox->setLongMode(true);
     labelChartFox->alignInTopLeft();
 
-    chartFoxCheckbox = std::make_shared<Checkbox>(windowChartFox, "Use ChartFox in airport app");
-    chartFoxCheckbox->alignBelow(labelChartFox);
-
-    bool useCf = api().getSettings()->getGeneralSetting<bool>("useChartFox");
-    api().getChartService()->setUseChartFox(useCf);
-
-    chartFoxCheckbox->setChecked(useCf);
-    chartFoxCheckbox->setCallback([this] (bool checked) {
-        api().getSettings()->setGeneralSetting("useChartFox", checked);
-        api().getChartService()->setUseChartFox(checked);
+    chartFoxActionButton.reset();
+    chartFoxActionButton = std::make_shared<Button>(windowChartFox, "Link Account");
+    chartFoxActionButton->alignBelow(labelChartFox);
+    chartFoxActionButton->setCallback([this] (const Button &btn) {
+        api().executeLater([this] () { testChartFoxLinkage(); });
     });
 
     chartFoxDonateButton = std::make_shared<Button>(windowChartFox, "Donate to ChartFox");
-    chartFoxDonateButton->alignBelow(chartFoxCheckbox);
+    chartFoxDonateButton->alignInBottomRight();
     chartFoxDonateButton->setCallback([this] (const Button &) {
         auto call = api().getChartService()->getChartFoxDonationLink();
         call->andThen([] (std::future<std::string> urlFuture) {
@@ -199,4 +203,91 @@ void ProvidersApp::resetChartFoxLayout() {
     });
 }
 
+void ProvidersApp::testChartFoxLinkage() {
+    auto svc = api().getChartService();
+
+    // short (transient) message, and no button
+    labelChartFox->setText("Logging in...");
+    chartFoxActionButton.reset();
+
+    auto call = svc->verifyChartFoxAccess();
+    call->andThen([this] (std::future<bool> result) {
+        try {
+            bool authenticated = result.get();
+            if (!authenticated) throw chartfox::LoginException();
+            api().executeLater([this] () { onChartFoxLoginSuccessful(); });
+        } catch (const chartfox::LoginException &e) {
+            api().executeLater([this] () { onChartFoxAuthRequired(); });
+        } catch (const std::exception &e) {
+            labelChartFox->setTextFormatted("Error: %s", e.what());
+        }
+    });
+
+    svc->submitCall(call);
+}
+
+void ProvidersApp::onChartFoxAuthRequired() {
+    api().getChartService()->setUseChartFox(false);
+
+    labelChartFox->setText("ChartFox login is required.\n"
+                   "Clicking Open Browser will open your browser to login to your ChartFox account.\n"
+                   "If your browser doesn't start, you can find the URL to visit in AviTab.log\n");
+
+    chartFoxActionButton.reset();
+    chartFoxActionButton = std::make_shared<Button>(windowChartFox, "Open Browser");
+    chartFoxActionButton->alignBelow(labelChartFox);
+    chartFoxActionButton->setCallback([this] (const Button &) {
+        api().executeLater([this] () { onChartFoxStartAuth(); });
+    });
+}
+
+void ProvidersApp::onChartFoxStartAuth() {
+    auto chartFox = api().getChartService()->getChartFox();
+    if (chartFox == nullptr) return;
+    auto link = chartFox->startAuthentication([this] {
+        api().executeLater([this] () {
+            testChartFoxLinkage(); // callback on completion of the OAuth(PKCE) flow
+        });
+    });
+
+    platform::openBrowser(link);
+    labelChartFox->setText("Follow the instructions in your browser.\n"
+                   "If your browser didn't start, visit the URL manually.\n"
+                   "The URL can be found in AviTab's log file, near the end.");
+
+    chartFoxActionButton = std::make_shared<Button>(windowChartFox, "Cancel");
+    chartFoxActionButton->alignBelow(labelChartFox);
+    chartFoxActionButton->setCallback([this] (const Button &btn) {
+        api().executeLater([this] () { onChartFoxCancelLoginButton(); });
+    });
+}
+
+void ProvidersApp::onChartFoxCancelLoginButton() {
+    auto chartFox = api().getChartService()->getChartFox();
+    if (chartFox) chartFox->cancelAuth();
+    resetChartFoxLayout();
+}
+
+void ProvidersApp::onChartFoxLoginSuccessful() {
+    labelChartFox->setText("Avitab is authorised to use your ChartFox account and will\n"
+                    "attempt to download charts indexed by ChartFox when you use\n"
+                    "the Airport app. You can revoke this by clicking Logout.\n"
+                    "Use the home button or the X to close this app.\n");
+
+    chartFoxActionButton.reset();
+    chartFoxActionButton = std::make_shared<Button>(windowChartFox, "Logout");
+    chartFoxActionButton->alignBelow(labelChartFox);
+    chartFoxActionButton->setCallback([this] (const Button &btn) {
+        api().executeLater([this] () { onChartFoxLogoutButton(); });
+    });
+
+    api().getChartService()->setUseChartFox(true);
+}
+
+void ProvidersApp::onChartFoxLogoutButton() {
+    auto chartFox = api().getChartService()->getChartFox();
+    if (chartFox) chartFox->logout();
+    resetChartFoxLayout();
+}
+
 } /* namespace avitab */
diff --git a/src/avitab/apps/ProvidersApp.h b/src/avitab/apps/ProvidersApp.h
index 342bacec..ee50c38c 100644
--- a/src/avitab/apps/ProvidersApp.h
+++ b/src/avitab/apps/ProvidersApp.h
@@ -15,8 +15,7 @@
  *   You should have received a copy of the GNU Affero General Public License
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-#ifndef SRC_AVITAB_APPS_PROVIDERSAPP_H_
-#define SRC_AVITAB_APPS_PROVIDERSAPP_H_
+#pragma once
 
 #include <memory>
 #include "App.h"
@@ -36,24 +35,27 @@ class ProvidersApp: public App {
     std::shared_ptr<TabGroup> tabs;
     std::shared_ptr<Window> windowNavigraph, windowChartFox;
     std::shared_ptr<Label> labelNavigraph, labelChartFox;
-    std::shared_ptr<Button> button;
-    std::shared_ptr<PixMap> pixmap;
+    std::shared_ptr<Button> linkNavigraphButton, chartFoxActionButton;
 
     std::shared_ptr<Page> navigraphPage, chartFoxPage;
-    std::shared_ptr<Checkbox> chartFoxCheckbox;
     std::shared_ptr<Button> chartFoxDonateButton;
 
     void resetNavigraphLayout();
     void onNavigraphLogin();
-    void onAuthRequired();
-    void onStartAuth();
-    void onCancelLoginButton();
-    void onAuthSuccess();
-    void onLogoutButton();
+    void onNavigraphAuthRequired();
+    void onNavigraphStartAuth();
+    void onNavigraphCancelLoginButton();
+    void onNavigraphAuthSuccess();
+    void onNavigraphLogoutButton();
 
     void resetChartFoxLayout();
+    void testChartFoxLinkage();
+    void onChartFoxAuthComplete();
+    void onChartFoxAuthRequired();
+    void onChartFoxStartAuth();
+    void onChartFoxCancelLoginButton();
+    void onChartFoxLoginSuccessful();
+    void onChartFoxLogoutButton();
 };
 
 } /* namespace avitab */
-
-#endif /* SRC_AVITAB_APPS_PROVIDERSAPP_H_ */
diff --git a/src/charts/Chart.h b/src/charts/Chart.h
index 683a03be..6dfb6912 100644
--- a/src/charts/Chart.h
+++ b/src/charts/Chart.h
@@ -40,12 +40,11 @@ class Chart {
     virtual ChartCategory getCategory() const = 0;
     virtual std::string getName() const = 0;
 
-    virtual bool isLoaded() const = 0;
     virtual std::shared_ptr<img::TileSource> createTileSource(bool nightMode) = 0;
     virtual void changeNightMode(std::shared_ptr<img::TileSource> src, bool nightMode) = 0;
     virtual void setCalibrationMetadata(std::string metadata) = 0;
 };
 
-} /* namespace navigraph */
+} /* namespace apis */
 
 #endif //AVITAB_CHART_H
diff --git a/src/charts/ChartService.cpp b/src/charts/ChartService.cpp
index 525104bf..046259e2 100644
--- a/src/charts/ChartService.cpp
+++ b/src/charts/ChartService.cpp
@@ -27,7 +27,10 @@ namespace apis {
 
 ChartService::ChartService(const std::string &programPath) {
     navigraph = std::make_shared<navigraph::NavigraphAPI>(programPath + "/Navigraph/");
-    chartfox = std::make_shared<chartfox::ChartFoxAPI>();
+    if (chartfox::ChartFoxAPI::isSupported()) {
+        chartFox = std::make_shared<chartfox::ChartFoxAPI>(programPath + "/ChartFox/");
+        useChartFox = chartFox->isAuthenticated();
+    }
     localFile= std::make_shared<localfile::LocalFileAPI>(programPath + "/charts/");
 
     keepAlive = true;
@@ -50,15 +53,15 @@ void ChartService::setUseNavigraph(bool use) {
 }
 
 void ChartService::setUseChartFox(bool use) {
-    useChartFox = use;
+    useChartFox = chartFox ? use : false;
 }
 
 std::shared_ptr<navigraph::NavigraphAPI> ChartService::getNavigraph() {
     return navigraph;
 }
 
-std::shared_ptr<chartfox::ChartFoxAPI> ChartService::getChartfox() {
-    return chartfox;
+std::shared_ptr<chartfox::ChartFoxAPI> ChartService::getChartFox() {
+    return chartFox;
 }
 
 std::shared_ptr<APICall<bool>> ChartService::loginNavigraph() {
@@ -72,6 +75,14 @@ std::shared_ptr<APICall<bool>> ChartService::loginNavigraph() {
     return call;
 }
 
+std::shared_ptr<APICall<bool>> ChartService::verifyChartFoxAccess() {
+    auto call = std::make_shared<APICall<bool>>([this] {
+        if (chartFox) return chartFox->isAuthenticated();
+        return false;
+    });
+    return call;
+}
+
 std::shared_ptr<APICall<ChartService::ChartList>> ChartService::getChartsFor(const std::string &icao) {
     auto call = std::make_shared<APICall<ChartList>>([this, icao] {
         ChartList res;
@@ -82,7 +93,7 @@ std::shared_ptr<APICall<ChartService::ChartList>> ChartService::getChartsFor(con
         }
 
         if (useChartFox) {
-            auto charts = chartfox->getChartsFor(icao);
+            auto charts = chartFox->getChartsFor(icao);
             res.insert(res.end(), charts.begin(), charts.end());
         }
 
@@ -99,14 +110,14 @@ std::shared_ptr<APICall<ChartService::ChartList>> ChartService::getChartsFor(con
 
 std::shared_ptr<APICall<std::shared_ptr<Chart>>> ChartService::loadChart(std::shared_ptr<Chart> chart) {
     auto call = std::make_shared<APICall<std::shared_ptr<Chart>>>([this, chart] {
-        auto cfChart = std::dynamic_pointer_cast<chartfox::ChartFoxChart>(chart);
-        if (cfChart) {
-            chartfox->loadChart(cfChart);
-            auto pdfData = cfChart->getPdfData();
+        auto bgChart = std::dynamic_pointer_cast<chartfox::ChartFoxChart>(chart);
+        if (bgChart) {
+            chartFox->loadChart(bgChart);
+            auto pdfData = bgChart->getPdfData();
             auto in = std::string((char *)pdfData.data(), pdfData.size());
             auto hash = crypto.sha256String(in);
             std::string calibrationMetadata = getCalibrationMetadataForHash(hash);
-            cfChart->setCalibrationMetadata(calibrationMetadata);
+            bgChart->setCalibrationMetadata(calibrationMetadata);
         }
 
         auto nvChart = std::dynamic_pointer_cast<navigraph::NavigraphChart>(chart);
@@ -129,7 +140,7 @@ std::shared_ptr<APICall<std::shared_ptr<Chart>>> ChartService::loadChart(std::sh
 
 std::shared_ptr<APICall<std::string>> ChartService::getChartFoxDonationLink() {
     auto call = std::make_shared<APICall<std::string>>([this] {
-        return chartfox->getDonationLink();
+        return chartFox->getDonationLink();
     });
 
     return call;
@@ -183,7 +194,6 @@ void ChartService::workLoop() {
 
 void ChartService::stop() {
     if (apiThread) {
-        logger::verbose("Ending ChartService");
         {
             std::lock_guard<std::mutex> lock(mutex);
             keepAlive = false;
@@ -249,7 +259,6 @@ std::string ChartService::getCalibrationMetadataForHash(std::string hash) const
 
 ChartService::~ChartService() {
     stop();
-    logger::verbose("~ChartService");
 }
 
 }
diff --git a/src/charts/ChartService.h b/src/charts/ChartService.h
index 6030c7b2..ce86cc52 100644
--- a/src/charts/ChartService.h
+++ b/src/charts/ChartService.h
@@ -15,17 +15,16 @@
  *   You should have received a copy of the GNU Affero General Public License
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-#ifndef AVITAB_CHARTSERVICE_H
-#define AVITAB_CHARTSERVICE_H
+#pragma once
 
 #include <vector>
 #include <memory>
 #include <thread>
 #include "APICall.h"
 #include "Chart.h"
-#include "src/charts/libchartfox/ChartFoxAPI.h"
 #include "src/charts/liblocalfile/LocalFileAPI.h"
 #include "src/charts/libnavigraph/NavigraphAPI.h"
+#include "src/charts/libchartfox/ChartFoxAPI.h"
 #include "src/charts/Crypto.h"
 
 namespace apis {
@@ -44,13 +43,14 @@ class ChartService {
 
     // asynchronous calls
     std::shared_ptr<APICall<bool>> loginNavigraph();
+    std::shared_ptr<APICall<bool>> verifyChartFoxAccess();
     std::shared_ptr<APICall<ChartList>> getChartsFor(const std::string &icao);
     std::shared_ptr<APICall<std::shared_ptr<Chart>>> loadChart(std::shared_ptr<Chart> chart);
     std::shared_ptr<APICall<std::string>> getChartFoxDonationLink();
 
     // state
     std::shared_ptr<navigraph::NavigraphAPI> getNavigraph();
-    std::shared_ptr<chartfox::ChartFoxAPI> getChartfox();
+    std::shared_ptr<chartfox::ChartFoxAPI> getChartFox();
     void submitCall(std::shared_ptr<BaseCall> call);
 
     std::string getCalibrationMetadataForFile(std::string utf8ChartFileName) const;
@@ -58,7 +58,7 @@ class ChartService {
 
 private:
     std::shared_ptr<navigraph::NavigraphAPI> navigraph;
-    std::shared_ptr<chartfox::ChartFoxAPI> chartfox;
+    std::shared_ptr<chartfox::ChartFoxAPI> chartFox;
     std::shared_ptr<localfile::LocalFileAPI> localFile;
 
     bool useNavigraph = false;
@@ -81,5 +81,3 @@ class ChartService {
 };
 
 } // namespace apis
-
-#endif //AVITAB_CHARTSERVICE_H
diff --git a/src/charts/RESTClient.h b/src/charts/RESTClient.h
index 69439ce1..5e96522a 100644
--- a/src/charts/RESTClient.h
+++ b/src/charts/RESTClient.h
@@ -55,6 +55,7 @@ class RESTClient {
     long head(const std::string &Turl, bool &cancel);
 
     std::map<std::string, std::string> getCookies() const;
+
 private:
     bool verbose = true;
     std::vector<uint8_t> downloadBuf;
diff --git a/src/charts/libchartfox/CMakeLists.txt b/src/charts/libchartfox/CMakeLists.txt
index 1c417317..85b01fa9 100644
--- a/src/charts/libchartfox/CMakeLists.txt
+++ b/src/charts/libchartfox/CMakeLists.txt
@@ -1,4 +1,6 @@
 target_sources(avitab_common PRIVATE
+    ${CMAKE_CURRENT_LIST_DIR}/ChartFoxOAuth2Client.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/ChartFoxAuthServer.cpp
     ${CMAKE_CURRENT_LIST_DIR}/ChartFoxAPI.cpp
     ${CMAKE_CURRENT_LIST_DIR}/ChartFoxChart.cpp
 )
diff --git a/src/charts/libchartfox/ChartFoxAPI.cpp b/src/charts/libchartfox/ChartFoxAPI.cpp
index cd124082..a429b8d7 100644
--- a/src/charts/libchartfox/ChartFoxAPI.cpp
+++ b/src/charts/libchartfox/ChartFoxAPI.cpp
@@ -1,6 +1,6 @@
 /*
  *   AviTab - Aviator's Virtual Tablet
- *   Copyright (C) 2018 Folke Will <folko@solhost.org>
+ *   Copyright (C) 2024 Folke Will <folko@solhost.org>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -15,75 +15,165 @@
  *   You should have received a copy of the GNU Affero General Public License
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-
-#include <cstring>
-#include <stdexcept>
+#include <sstream>
+#include <iomanip>
+#include <chrono>
 #include <nlohmann/json.hpp>
+#include <curl/curl.h>
 #include "ChartFoxAPI.h"
-#include "src/charts/Crypto.h"
+#include "src/platform/Platform.h"
+#include "src/platform/CrashHandler.h"
 #include "src/Logger.h"
 
 namespace chartfox {
 
-ChartFoxAPI::ChartFoxAPI() {
-    apis::Crypto crypto;
-    apiKey = crypto.aesDecrypt(CHARTFOX_CLIENT_SECRET, "Please do not decrypt the client secret, this would lead to AviTab losing the ChartFox key.");
-    restClient.setReferrer("app.avitab");
+bool ChartFoxAPI::isSupported() {
+    return (strlen(CHARTFOX_CLIENT_ID) > 0);
 }
 
-bool ChartFoxAPI::isSupported() {
-    return strlen(CHARTFOX_CLIENT_SECRET) > 0;
+ChartFoxAPI::ChartFoxAPI(const std::string &cacheDirectory):
+    cacheDirectory(cacheDirectory),
+    oauth(std::make_shared<ChartFoxOAuth2Client>(CHARTFOX_CLIENT_ID))
+{
+    if (!platform::fileExists(cacheDirectory)) {
+        platform::mkdir(cacheDirectory);
+    }
+
+    oauth->setCacheDirectory(cacheDirectory);
+}
+
+bool ChartFoxAPI::isAuthenticated() {
+    try {
+        auto resp = oauth->get("https://api.chartfox.org/v2/airports");
+        if (!resp.empty() && (resp.front() == '{') && (resp.back() == '}')) {
+            // we'll only get a response in json format if the authentication worked
+            return true;
+        }
+    } catch (const std::exception &e) {
+        logger::warn("ChartFox: isAuthenticated attempt failed: %s", e.what());
+    }
+    oauth->logout();
+    return false;
+}
+
+void ChartFoxAPI::logout() {
+    charts.clear();
+    oauth->logout();
+}
+
+std::string ChartFoxAPI::startAuthentication(std::function<void()> onAuthDone) {
+    return oauth->startAuth(onAuthDone);
+}
+
+void ChartFoxAPI::cancelAuth() {
+    oauth->cancelAuth();
 }
 
 std::string ChartFoxAPI::getDonationLink() {
-    auto resJson = restClient.get(urlFor("/link/donation", true), cancelToken);
-    nlohmann::json data = nlohmann::json::parse(resJson);
-    return data.at("link");
+    return "https://chartfox.org/donate";
+}
+
+std::string ChartFoxAPI::encodeUrl(std::string url) {
+    std::string qurl;
+    for (auto c: url) {
+        switch (c) {
+        case ' ':
+            qurl.append("%20");
+            break;
+        default:
+            qurl += c;
+            break;
+        }
+    }
+    return qurl;
 }
 
-std::vector<std::shared_ptr<apis::Chart>> ChartFoxAPI::getChartsFor(const std::string &icao) {
-    std::vector<std::shared_ptr<apis::Chart>> charts;
+ChartFoxAPI::ChartsList ChartFoxAPI::getChartsFor(const std::string& icao) {
+    std::vector<std::shared_ptr<apis::Chart>> res;
+
+    // check the cache and return these if any
+    auto lower = charts.lower_bound(icao);
+    auto upper = charts.upper_bound(icao);
+    if (lower != upper) {
+        for (auto it = lower; it != upper; ++it) {
+            res.push_back(it->second);
+        }
+        return res;
+    }
 
+#if 1
+    // this version uses the grouped charts API
     try {
-        std::map<std::string, std::string> params;
-        params.insert(std::make_pair("token", apiKey));
-        auto jsonList = restClient.post(urlFor("/charts/grouped/" + icao), params, cancelToken);
-
-        nlohmann::json chartData = nlohmann::json::parse(jsonList);
-        for (auto chartGroup: chartData.at("charts")) {
-            size_t idx = 1;
-            for (auto chartJson: chartGroup.at("charts")) {
-                try {
-                    auto chart = std::make_shared<ChartFoxChart>(chartJson, icao, idx++);
-                    charts.push_back(chart);
-                } catch (const std::exception &e) {
-                    logger::verbose("Ignoring chart: %s", e.what());
+        std::string url = std::string("https://api.chartfox.org/v2/airports/") + icao + "/charts/grouped";
+        while (!url.empty()) {
+            std::string response = oauth->get(url);
+            nlohmann::json respJson = nlohmann::json::parse(response);
+            for (auto chartGroup: respJson.at("data")) {
+                int code = 1;
+                for (auto& chartJson: chartGroup.items()) {
+                    try {
+                        auto chart = std::make_shared<ChartFoxChart>(chartJson.value(), code);
+                        res.push_back(chart);
+                        charts.insert(std::make_pair(icao, chart));
+                        ++code;
+                    } catch (const std::exception &e) {
+                        logger::verbose("Ignoring chart: %s", e.what());
+                    }
                 }
             }
+            try {
+                url = respJson.at("meta").at("next_page_url");
+            } catch (const std::exception &e) {
+                url.clear();
+            }
         }
     } catch (const std::exception &e) {
-        logger::error(e.what());
+        logger::warn("Error fetching charts for %s: %s", icao.c_str(), e.what());
     }
+#else
+    // this version uses the non-grouped charts API
+    try {
+        std::string url = std::string("https://api.chartfox.org/v2/airports/") + icao + "/charts";
+        while (!url.empty()) {
+            std::string response = oauth->get(url);
+            nlohmann::json respJson = nlohmann::json::parse(response);
+            for (auto chartJson: respJson.at("data")) {
+                auto chart = std::make_shared<ChartFoxChart>(chartJson);
+                res.push_back(chart);
+                charts.insert(std::make_pair(icao, chart));
+            }
+            try {
+                url = respJson.at("meta").at("next_page_url");
+            } catch (const std::exception &e) {
+                url.clear();
+            }
+        }
+    } catch (const std::exception &e) {
+        logger::warn("Error fetching charts for %s: %s", icao.c_str(), e.what());
+    }
+#endif
 
-    return charts;
+    return res;
 }
 
 void ChartFoxAPI::loadChart(std::shared_ptr<ChartFoxChart> chart) {
-    auto url = chart->getURL();
-    auto pdfData = restClient.getBinary(url, cancelToken);
-    chart->attachPDF(pdfData);
-}
-
-std::string ChartFoxAPI::urlFor(const std::string &path, bool withToken) {
-    std::string url = "https://chartfox.org/api" + path;
-    if (withToken) {
-        url += std::string("?token=") + apiKey;
+    auto chartUrl = chart->getURL();
+    if (chartUrl.empty()) {
+        try {
+            std::string url = std::string("https://api.chartfox.org/v2/charts/") + chart->getID();
+            std::string response = oauth->get(url);
+            nlohmann::json respJson = nlohmann::json::parse(response);
+            chartUrl = encodeUrl(respJson.at("url"));
+            chart->setURL(chartUrl);
+            std::string calib = nlohmann::to_string(respJson.at("georefs"));
+            logger::info("georefs=%s", calib.c_str());
+        } catch (const std::exception &e) {
+            logger::warn("Unable to obtain URL for chart: %s, %s", chart->getICAO().c_str(), chart->getName().c_str());
+            return;
+        }
     }
-    return url;
-}
-
-ChartFoxAPI::~ChartFoxAPI() {
-    cancelToken = true;
+    auto pdfData = oauth->getBinary(chartUrl);
+    chart->attachPDF(pdfData);
 }
 
-} // namespace chartfox
+} /* namespace chartfox */
diff --git a/src/charts/libchartfox/ChartFoxAPI.h b/src/charts/libchartfox/ChartFoxAPI.h
index 74b76cc6..9e06456f 100644
--- a/src/charts/libchartfox/ChartFoxAPI.h
+++ b/src/charts/libchartfox/ChartFoxAPI.h
@@ -1,6 +1,6 @@
 /*
  *   AviTab - Aviator's Virtual Tablet
- *   Copyright (C) 2018 Folke Will <folko@solhost.org>
+ *   Copyright (C) 2024 Folke Will <folko@solhost.org>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -15,36 +15,50 @@
  *   You should have received a copy of the GNU Affero General Public License
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-
-#ifndef AVITAB_CHARTFOXAPI_H
-#define AVITAB_CHARTFOXAPI_H
+#pragma once
 
 #include <string>
+#include <memory>
 #include <vector>
+#include <map>
+#include <functional>
+#include <mutex>
+#include <condition_variable>
+#include <nlohmann/json_fwd.hpp>
+#include "src/libimg/Image.h"
+#include "src/libimg/TTFStamper.h"
+#include "src/charts/APICall.h"
+#include "ChartFoxOAuth2Client.h"
 #include "ChartFoxChart.h"
-#include "src/charts/RESTClient.h"
 
 namespace chartfox {
 
 class ChartFoxAPI {
 public:
-    ChartFoxAPI();
-    ~ChartFoxAPI();
+    static bool isSupported();
+
+    using ChartsList = std::vector<std::shared_ptr<apis::Chart>>;
+
+    ChartFoxAPI(const std::string &cacheDirectory);
+    virtual ~ChartFoxAPI() = default;
 
-    bool isSupported();
+    bool isAuthenticated();
+    std::string startAuthentication(std::function<void()> onAuthDone);
+    void cancelAuth();
+    void logout();
 
-    std::vector<std::shared_ptr<apis::Chart>> getChartsFor(const std::string &icao);
+    ChartsList getChartsFor(const std::string &icao);
     void loadChart(std::shared_ptr<ChartFoxChart> chart);
     std::string getDonationLink();
 
 private:
-    bool cancelToken = false;
-    std::string apiKey;
-    apis::RESTClient restClient;
+    std::string encodeUrl(std::string url);
 
-    std::string urlFor(const std::string &path, bool withToken = false);
-};
+private:
+    std::string cacheDirectory;
+    std::shared_ptr<ChartFoxOAuth2Client> oauth;
 
-} // namespace chartfox
+    std::multimap<std::string, std::shared_ptr<ChartFoxChart>> charts;
+};
 
-#endif //AVITAB_CHARTFOXAPI_H
+} /* namespace chartfox */
diff --git a/src/charts/libchartfox/ChartFoxAuthServer.cpp b/src/charts/libchartfox/ChartFoxAuthServer.cpp
new file mode 100644
index 00000000..5ec1fcd2
--- /dev/null
+++ b/src/charts/libchartfox/ChartFoxAuthServer.cpp
@@ -0,0 +1,276 @@
+/*
+ *   AviTab - Aviator's Virtual Tablet
+ *   Copyright (C) 2024 Folke Will <folko@solhost.org>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program 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.  See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#include <vector>
+#include <stdexcept>
+#ifndef _POSIX_SOURCE
+#define _POSIX_SOURCE
+#endif
+#include <unistd.h>
+#ifndef _WIN32
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#endif
+#include "ChartFoxAuthServer.h"
+#include "src/Logger.h"
+#include "src/platform/CrashHandler.h"
+
+#ifdef WIN32
+#include <windows.h>
+// close doesn't actually close sockets on Windows, there's a special API function for that <3
+#define close closesocket
+typedef int socklen_t;
+#endif
+
+namespace chartfox {
+
+ChartFoxAuthServer::ChartFoxAuthServer() {
+}
+
+void ChartFoxAuthServer::setAuthCallback(AuthCallback cb) {
+    onAuth = cb;
+}
+
+int ChartFoxAuthServer::start() {
+    if (serverThread) {
+        keepAlive = false;
+        serverThread->join();
+        serverThread.reset();
+    }
+
+    srvSock = socket(AF_INET, SOCK_STREAM, 0);
+    if (srvSock < 0) {
+        throw std::runtime_error("Couldn't create server socket");
+    }
+
+    int val = 1;
+    (void) setsockopt(srvSock, SOL_SOCKET, SO_REUSEADDR, (char *) &val, sizeof(val));
+
+    sockaddr_in serverAddr {};
+    serverAddr.sin_family = AF_INET;
+    serverAddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+    serverAddr.sin_port = 0;
+
+    if (bind(srvSock, (sockaddr *) &serverAddr, sizeof(serverAddr)) < 0) {
+        close(srvSock);
+        throw std::runtime_error(std::string("Couldn't bind server socket"));
+    }
+
+    if (listen(srvSock, 5) < 0) {
+        close(srvSock);
+        throw std::runtime_error("Couldn't listen on server socket");
+    }
+
+    sockaddr_in chosenAddr;
+    socklen_t size = sizeof(chosenAddr);
+    if (getsockname(srvSock, (sockaddr *) &chosenAddr, &size) != 0) {
+        close(srvSock);
+        throw std::runtime_error("Couldn't get server socket port");
+    }
+
+    keepAlive = true;
+    serverThread = std::make_unique<std::thread>(&ChartFoxAuthServer::loop, this);
+
+    return ntohs(chosenAddr.sin_port);
+}
+
+void ChartFoxAuthServer::loop() {
+    crash::ThreadCookie crashCookie;
+
+    sockaddr_in clientAddr {};
+    socklen_t clientLen = sizeof(clientAddr);
+
+    fd_set readSet;
+
+    timeval timeout{};
+    timeout.tv_usec = 1000 * 100;
+
+    while (keepAlive) {
+        FD_ZERO(&readSet);
+        FD_SET(srvSock, &readSet);
+        int fdMax = srvSock;
+
+        if (select(fdMax + 1, &readSet, nullptr, nullptr, &timeout) < 0) {
+            break;
+        }
+
+        if (FD_ISSET(srvSock, &readSet)) {
+            int clientSock = accept(srvSock, (sockaddr *) &clientAddr, &clientLen);
+            handleClient(clientSock);
+            shutdown(clientSock, SHUT_RDWR);
+            close(clientSock);
+        }
+    }
+    close(srvSock);
+}
+
+void ChartFoxAuthServer::handleClient(int client) {
+    method.clear();
+    url.clear();
+    version.clear();
+    curHeaderField.clear();
+    curHeaderValue.clear();
+    contentBytesLeft = 0;
+    postFields.clear();
+    curPostField.clear();
+    curPostValue.clear();
+    state = State::METHOD;
+
+    timeval timeout{};
+    timeout.tv_usec = 1000 * 100;
+
+    while (keepAlive) {
+        fd_set readSet;
+        FD_ZERO(&readSet);
+        FD_SET(client, &readSet);
+        int fdMax = client;
+
+        if (select(fdMax + 1, &readSet, nullptr, nullptr, &timeout) < 0) {
+            break;
+        }
+
+        if (FD_ISSET(client, &readSet)) {
+            char buf[255];
+            int readNow = recv(client, buf, sizeof(buf), 0);
+            if (readNow <= 0) {
+                break;
+            }
+            if (!handleData(std::string(buf, readNow))) {
+                break;
+            }
+        }
+    }
+
+    std::string reply;
+    if (method == "GET") {
+        try {
+            if (onAuth) {
+                onAuth(url);
+                reply = "HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Type: text/plain\r\n\r\nAviTab: Success, you can close this tab now!";
+            }
+            keepAlive = false;
+        } catch (const std::exception &e) {
+            reply = std::string("HTTP/1.1 500 Internal Error\r\nConnection: close\r\nContent-Type: text/plain\r\n\r\nAviTab Error: ") + e.what();
+        }
+    } else {
+        reply = "HTTP/1.1 404 NOT FOUND\r\nConnection: close\r\nContent-Type: text/plain\r\n\r\nAviTab: 404 Not Found";
+    }
+
+    (void) send(client, reply.c_str(), reply.length(), 0);
+}
+
+bool ChartFoxAuthServer::handleData(const std::string& data) {
+    for (char c: data) {
+        switch (state) {
+        case State::METHOD:
+            if (!isspace(c)) {
+                method.push_back(c);
+            } else {
+                state = State::URL;
+            }
+            break;
+        case State::URL:
+            if (!isspace(c)) {
+                url.push_back(c);
+            } else {
+                state = State::VERSION;
+            }
+            break;
+        case State::VERSION:
+            if (c != '\r' && c != '\n') {
+                version.push_back(c);
+            } else if (c == '\n') {
+                curHeaderField.clear();
+                state = State::FIELD;
+            }
+            break;
+        case State::FIELD:
+            if (c != ':' && c != '\r' && c != '\n') {
+                curHeaderField.push_back(c);
+            } else if (c == ':') {
+                curHeaderValue.clear();
+                state = State::VALUE;
+            } else if (c == '\n') {
+                // end of header
+                if (contentBytesLeft > 0) {
+                    state = State::POST_FIELD;
+                } else {
+                    return false;
+                }
+            }
+            break;
+        case State::VALUE:
+            if (c != '\r' && c != '\n') {
+                curHeaderValue.push_back(c);
+            } else if (c == '\n') {
+                if (curHeaderField == "Content-Length") {
+                    contentBytesLeft = std::stoul(curHeaderValue);
+                }
+                curHeaderField.clear();
+                state = State::FIELD;
+            }
+            break;
+        case State::POST_FIELD:
+            if (c == '=') {
+                state = State::POST_VALUE;
+            } else if (c == '&') {
+                postFields[curPostField] = "";
+                curPostField.clear();
+            } else {
+                curPostField.push_back(c);
+            }
+            contentBytesLeft--;
+            if (contentBytesLeft == 0) {
+                postFields[curPostField] = "";
+                return false;
+            }
+            break;
+        case State::POST_VALUE:
+            if (c == '&') {
+                postFields[curPostField] = curPostValue;
+                curPostField.clear();
+                curPostValue.clear();
+                state = State::POST_FIELD;
+            } else {
+                curPostValue.push_back(c);
+            }
+            contentBytesLeft--;
+            if (contentBytesLeft == 0) {
+                postFields[curPostField] = curPostValue;
+                return false;
+            }
+            break;
+        }
+    }
+    return true;
+}
+
+void ChartFoxAuthServer::stop() {
+    // could be called from the server thread, so no joining here
+    keepAlive = false;
+}
+
+ChartFoxAuthServer::~ChartFoxAuthServer() {
+    keepAlive = false;
+
+    if (serverThread) {
+        serverThread->join();
+        serverThread.reset();
+    }
+}
+
+} /* namespace chartfox */
diff --git a/src/charts/libchartfox/ChartFoxAuthServer.h b/src/charts/libchartfox/ChartFoxAuthServer.h
new file mode 100644
index 00000000..d9a008ae
--- /dev/null
+++ b/src/charts/libchartfox/ChartFoxAuthServer.h
@@ -0,0 +1,59 @@
+/*
+ *   AviTab - Aviator's Virtual Tablet
+ *   Copyright (C) 2024 Folke Will <folko@solhost.org>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program 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.  See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include <memory>
+#include <atomic>
+#include <thread>
+#include <string>
+#include <map>
+#include <functional>
+
+namespace chartfox {
+
+class ChartFoxAuthServer {
+public:
+    using AuthCallback = std::function<void(const std::string &)>;
+
+    ChartFoxAuthServer();
+    void setAuthCallback(AuthCallback cb);
+    int start(); // returns port
+    void stop();
+    virtual ~ChartFoxAuthServer();
+private:
+    enum class State {METHOD, URL, VERSION, FIELD, VALUE, POST_FIELD, POST_VALUE};
+
+    AuthCallback onAuth;
+
+    int srvSock = -1;
+    std::atomic_bool keepAlive { false };
+    std::unique_ptr<std::thread> serverThread;
+
+    State state = State::METHOD;
+    std::string method, url, version;
+    std::string curHeaderField, curHeaderValue;
+    std::string curPostField, curPostValue;
+    std::map<std::string, std::string> postFields;
+    size_t contentBytesLeft = 0;
+
+    void loop();
+    void handleClient(int client);
+    bool handleData(const std::string& data);
+};
+
+} /* namespace chartfox */
diff --git a/src/charts/libchartfox/ChartFoxChart.cpp b/src/charts/libchartfox/ChartFoxChart.cpp
index 32fb2ee4..54b784eb 100644
--- a/src/charts/libchartfox/ChartFoxChart.cpp
+++ b/src/charts/libchartfox/ChartFoxChart.cpp
@@ -1,6 +1,6 @@
 /*
  *   AviTab - Aviator's Virtual Tablet
- *   Copyright (C) 2018 Folke Will <folko@solhost.org>
+ *   Copyright (C) 2024 Folke Will <folko@solhost.org>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -15,67 +15,38 @@
  *   You should have received a copy of the GNU Affero General Public License
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-
 #include <nlohmann/json.hpp>
-#include <stdexcept>
+#include <sstream>
+#include "ChartFoxChart.h"
 #include "src/maps/sources/PDFSource.h"
 #include "src/Logger.h"
-#include "ChartFoxChart.h"
 
 namespace chartfox {
 
-/*
-    type_codes from API docs:
-    0 - Unknown / General
-    1 - Textual Data
-    2 - Ground Layout
-    6 - SID
-    7 - STAR
-    8 - Approach
-    9 - Transition
-    99 - Pilot Briefing
-*/
-
-ChartFoxChart::ChartFoxChart(const nlohmann::json &json, const std::string &icao, size_t idx):
-    icao(icao),
-    index(idx)
-{
-    auto typeCode = json.at("type_code").get<int>();
-    switch (typeCode) {
-        case 1:  category = apis::ChartCategory::REF; break;
-        case 2:  category = apis::ChartCategory::APT; break;
-        case 6:  category = apis::ChartCategory::DEP; break;
-        case 7:  category = apis::ChartCategory::ARR; break;
-        case 8:  category = apis::ChartCategory::APP; break;
-        case 9:  category = apis::ChartCategory::APP; break;
-        case 99: category = apis::ChartCategory::REF; break;
-        default: category = apis::ChartCategory::REF; break;
-    }
-
-    auto id = json.at("identifier");
-    auto name = json.at("name");
-    if (!name.is_null()) {
-        identifier = name;
-    } else if (!id.is_null()) {
-        identifier = id;
-    } else {
-        throw std::runtime_error("No chart name");
+ChartFoxChart::ChartFoxChart(const nlohmann::json &json, int icode) {
+    icao = json.at("airport_icao");
+    id = json.at("id");
+    name = json.at("name");
+    try {
+        code = json.at("code");
+    } catch (const std::exception &e) {
+        std::ostringstream oss;
+        oss << icode;
+        code = oss.str();
     }
-
-    auto urlJ = json.at("url");
-    if (!urlJ.is_null()) {
-        url = urlJ;
-        size_t i = 0;
-        while (true) {
-            i = url.find(" ", i);
-            if (i == std::string::npos) {
-                break;
-            }
-            url.replace(i, 1, "%20");
-            i += 3;
-        }
-    } else {
-        throw std::runtime_error("No chart URL");
+    // Allowed Values: 0 (Unknown), 1 (General), 2 (Textual), 3 (GroundLayout), 4 (SID), 5 (STAR), 6 (Approach), 7 (Transition), 99 (Briefing)
+    auto catNum = json.at("type").get<int>();
+    category = apis::ChartCategory::OTHER;
+    switch (catNum) {
+        case 1:  category = apis::ChartCategory::REF; break;
+        case 2:  category = apis::ChartCategory::REF; break;
+        case 3:  category = apis::ChartCategory::APT; break;
+        case 4:  category = apis::ChartCategory::DEP; break;
+        case 5:  category = apis::ChartCategory::ARR; break;
+        case 6:  category = apis::ChartCategory::APP; break;
+        case 7:  category = apis::ChartCategory::APP; break;
+        case 99: category = apis::ChartCategory::OTHER; break;
+        default: logger::error("UNKNOWN CATEGORY ID: %d", catNum);
     }
 }
 
@@ -84,41 +55,35 @@ std::string ChartFoxChart::getICAO() const {
 }
 
 std::string ChartFoxChart::getIndex() const {
-    return std::string("CF-") +
-           std::to_string(static_cast<int>(category)) + "-" +
-           std::to_string(index);
-}
-
-apis::ChartCategory ChartFoxChart::getCategory() const {
-    return category;
+    return code;
 }
 
 std::string ChartFoxChart::getName() const {
-    return identifier;
+    return name;
 }
 
-bool ChartFoxChart::isLoaded() const {
-    return !pdfData.empty();
+apis::ChartCategory ChartFoxChart::getCategory() const {
+    return category;
 }
 
-std::string ChartFoxChart::getURL() const {
-    return url;
+void ChartFoxChart::setCalibrationMetadata(std::string metadata) {
+    calibrationMetadata = metadata;
 }
 
-void ChartFoxChart::attachPDF(const std::vector<uint8_t> &data) {
-    pdfData = data;
+std::string ChartFoxChart::getID() const {
+    return id;
 }
 
-std::vector<uint8_t> ChartFoxChart::getPdfData() {
-    return pdfData;
+void ChartFoxChart::setURL(const std::string u) {
+    url = u;
 }
 
-void ChartFoxChart::setCalibrationMetadata(std::string metadata) {
-    calibrationMetadata = metadata;
+std::string ChartFoxChart::getURL() const {
+    return url;
 }
 
 std::shared_ptr<img::TileSource> ChartFoxChart::createTileSource(bool nightMode) {
-    if (!isLoaded()) {
+    if (pdfData.empty()) {
         throw std::runtime_error("Chart not loaded");
     }
 
@@ -136,4 +101,10 @@ void ChartFoxChart::changeNightMode(std::shared_ptr<img::TileSource> src, bool n
     pdfSrc->setNightMode(nightMode);
 }
 
-} // namespace chartfox
+void ChartFoxChart::attachPDF(const std::vector<uint8_t> &data) {
+    pdfData = data;
+}
+
+const std::vector<uint8_t> ChartFoxChart::getPdfData() const { return pdfData; }
+
+} /* namespace chartfox */
diff --git a/src/charts/libchartfox/ChartFoxChart.h b/src/charts/libchartfox/ChartFoxChart.h
index 2dd6560f..510032d2 100644
--- a/src/charts/libchartfox/ChartFoxChart.h
+++ b/src/charts/libchartfox/ChartFoxChart.h
@@ -1,6 +1,6 @@
 /*
  *   AviTab - Aviator's Virtual Tablet
- *   Copyright (C) 2018 Folke Will <folko@solhost.org>
+ *   Copyright (C) 2024 Folke Will <folko@solhost.org>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -15,19 +15,25 @@
  *   You should have received a copy of the GNU Affero General Public License
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-#ifndef AVITAB_CHARTFOXCHART_H
-#define AVITAB_CHARTFOXCHART_H
+#pragma once
 
 #include <nlohmann/json_fwd.hpp>
-#include <vector>
+#include <memory>
 #include <string>
+#include "src/libimg/Image.h"
 #include "src/charts/Chart.h"
 
 namespace chartfox {
 
+struct ChartGEOReference {
+    double lon1, x1, lon2, x2;
+    double lat1, y1, lat2, y2;
+    bool valid = false;
+};
+
 class ChartFoxChart: public apis::Chart {
 public:
-    ChartFoxChart(const nlohmann::json &json, const std::string &icao, size_t idx);
+    ChartFoxChart(const nlohmann::json &json, int code);
     virtual ~ChartFoxChart() = default;
 
     virtual std::string getICAO() const override;
@@ -35,25 +41,28 @@ class ChartFoxChart: public apis::Chart {
     virtual apis::ChartCategory getCategory() const override;
     virtual std::string getName() const override;
 
-    virtual bool isLoaded() const override;
     virtual std::shared_ptr<img::TileSource> createTileSource(bool nightMode) override;
     virtual void changeNightMode(std::shared_ptr<img::TileSource> src, bool nightMode) override;
     virtual void setCalibrationMetadata(std::string metadata) override;
 
+    std::string getID() const;
+
+    void setURL(const std::string url);
     std::string getURL() const;
+
     void attachPDF(const std::vector<uint8_t> &data);
-    std::vector<uint8_t> getPdfData();
+    const std::vector<uint8_t> getPdfData() const;
 
 private:
+    ChartGEOReference geoRef;
     std::string icao;
-    size_t index;
+    std::string id;
+    std::string name;
+    std::string code;
     apis::ChartCategory category;
-    std::string identifier;
     std::string url;
     std::vector<uint8_t> pdfData;
-    std::string calibrationMetadata = "";
+    std::string calibrationMetadata;
 };
 
-} // namespace chartfox
-
-#endif //AVITAB_CHARTFOXCHART_H
+} /* namespace chartfox */
diff --git a/src/charts/libchartfox/ChartFoxOAuth2Client.cpp b/src/charts/libchartfox/ChartFoxOAuth2Client.cpp
new file mode 100644
index 00000000..03bf9188
--- /dev/null
+++ b/src/charts/libchartfox/ChartFoxOAuth2Client.cpp
@@ -0,0 +1,249 @@
+/*
+ *   AviTab - Aviator's Virtual Tablet
+ *   Copyright (C) 2024 Folke Will <folko@solhost.org>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program 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.  See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#include <sstream>
+#include <stdexcept>
+#include <nlohmann/json.hpp>
+#include "ChartFoxOAuth2Client.h"
+#include "src/Logger.h"
+#include "src/platform/Platform.h"
+
+namespace chartfox {
+
+const char* LoginException::what() const noexcept
+{
+    return "Login required";
+}
+
+ChartFoxOAuth2Client::ChartFoxOAuth2Client(const std::string &ci)
+:   clientId(ci)
+{
+    server.setAuthCallback([this] (const std::string &reply) { onAuthReply(reply); });
+}
+
+void ChartFoxOAuth2Client::setCacheDirectory(const std::string& dir)
+{
+    tokenFile = dir + "/login.avicrypt";
+    if (platform::fileExists(tokenFile)) {
+        loadTokens();
+    }
+}
+
+bool ChartFoxOAuth2Client::relogin()
+{
+    // since the access token lasts for a year relogin hasn't been implemented
+    logger::verbose("ChartFoxOAuth2Client::relogin() UNIMPLEMENTED");
+    return false;
+}
+
+std::string ChartFoxOAuth2Client::startAuth(AuthCallback cb)
+{
+    onAuthCompleted = cb;
+    authPort = server.start();
+
+    std::ostringstream url;
+
+    verifier = crypto.base64URLEncode(crypto.generateRandom(32));
+    state = crypto.base64URLEncode(crypto.generateRandom(8));
+
+    url << "https://api.chartfox.org/oauth/authorize";
+    url << "?response_type=" << crypto.urlEncode("code");
+    url << "&client_id=" << crypto.urlEncode(clientId.c_str());
+    url << "&scope=" << crypto.urlEncode("charts:index charts:view charts:geos charts:files airports:view");
+    url << "&redirect_uri=" << crypto.urlEncode(std::string("http://127.0.0.1:") + std::to_string(authPort));
+    url << "&state=" << state;
+    url << "&code_challenge_method=S256";
+    url << "&code_challenge=" << crypto.base64URLEncode(crypto.sha256(verifier));
+
+    return url.str();
+}
+
+void ChartFoxOAuth2Client::onAuthReply(const std::string &authUrl)
+{
+    // this is called from the http server thread!
+
+    // extract the URL parameters
+    std::map<std::string, std::string> urlParams;
+    auto q = authUrl.find('?');
+    if (q != std::string::npos) {
+        auto params = authUrl.substr(q + 1);
+        while (!params.empty()) {
+            size_t amp = params.find('&');
+            if (amp == std::string::npos) {
+                amp = params.size();
+            }
+            std::string ptext = params.substr(0, amp);
+            params.erase(0, amp + 1);
+            size_t eq = std::string::npos;
+            if ((eq = ptext.find('=')) != std::string::npos) {
+                std::string name = ptext.substr(0, eq);
+                ptext.erase(0, eq + 1);
+                urlParams[name] = ptext;
+            } else {
+                urlParams[ptext] = "";
+            }
+        }
+    }
+
+    // check our state
+    auto istate = urlParams.find("state");
+    if (istate == urlParams.end()) {
+        throw std::runtime_error("No state");
+    }
+    if (istate->second != state) {
+        throw std::runtime_error("Invalid state, the link only works once!");
+    }
+
+    // copy auth code
+    auto icode = urlParams.find("code");
+    if (icode == urlParams.end()) {
+        throw std::runtime_error("No auth code");
+    }
+
+    std::map<std::string, std::string> replyFields;
+    replyFields["code"] = icode->second;
+    replyFields["grant_type"] = "authorization_code";
+    replyFields["code_verifier"] = verifier;
+    replyFields["redirect_uri"] = std::string("http://127.0.0.1:") + std::to_string(authPort);
+    replyFields["client_id"] = crypto.urlEncode(clientId.c_str());
+
+    std::string reply = restClient.post("https://api.chartfox.org/oauth/token", replyFields, restCancel);
+    handleToken(reply, restClient.getCookies());
+
+    server.stop();
+    onAuthCompleted();
+}
+
+void ChartFoxOAuth2Client::handleToken(const std::string& inputJson, const std::map<std::string, std::string> &cookies)
+{
+    // could be called from either thread
+
+    nlohmann::json data = nlohmann::json::parse(inputJson);
+    accessToken = data.at("access_token");
+    refreshToken = data.at("refresh_token");
+    cookieJar = cookies;
+    storeTokens();
+}
+
+void ChartFoxOAuth2Client::cancelAuth()
+{
+    server.stop();
+}
+
+void ChartFoxOAuth2Client::logout()
+{
+    platform::removeFile(tokenFile);
+    accessToken.clear();
+    refreshToken.clear();
+}
+
+std::string ChartFoxOAuth2Client::get(const std::string& url)
+{
+    std::string res;
+    tryWithRelogin([this, &res, &url] () {
+        res = restClient.get(url, restCancel);
+    });
+    return res;
+}
+
+std::vector<uint8_t> ChartFoxOAuth2Client::getBinary(const std::string& url)
+{
+    std::vector<uint8_t> res;
+    tryWithRelogin([this, &res, &url] () {
+        res = restClient.getBinary(url, restCancel);
+    });
+    return res;
+}
+
+long ChartFoxOAuth2Client::getTimestamp(const std::string& url)
+{
+    long res;
+    tryWithRelogin([this, &res, &url] () {
+        auto newUrl = restClient.getRedirect(url, restCancel);
+        res = restClient.head(newUrl, restCancel);
+    });
+    return res;
+}
+
+void ChartFoxOAuth2Client::tryWithRelogin(std::function<void()> f)
+{
+    // no login yet -> try using the refresh token
+    if (accessToken.empty()) {
+        if (!relogin()) {
+            throw LoginException();
+        }
+    }
+
+    try {
+        restClient.setBearer(accessToken);
+        f();
+    } catch (const apis::HTTPException &e) {
+        if (e.getStatusCode() == apis::HTTPException::UNAUTHORIZED || e.getStatusCode() == apis::HTTPException::FORBIDDEN) {
+            logger::info("Access token expired, trying refresh_token");
+            if (relogin()) {
+                restClient.setBearer(accessToken);
+                f();
+            } else {
+                throw LoginException();
+            }
+        } else {
+            throw;
+        }
+    }
+}
+
+void ChartFoxOAuth2Client::loadTokens()
+{
+    auto key = clientId + platform::getMachineID();
+
+    fs::ifstream fileStream(fs::u8path(tokenFile));
+    std::string line;
+    std::getline(fileStream, line);
+
+    auto tokenStr = crypto.aesDecrypt(line, key);
+
+    try {
+        nlohmann::json tokens = nlohmann::json::parse(tokenStr);
+        refreshToken = tokens.at("refresh_token");
+        accessToken = tokens.at("access_token");
+        // accessToken = "foobar"; // for testing unauthorized API access
+    } catch (const std::exception &e) {
+        refreshToken.clear();
+        accessToken.clear();
+    }
+}
+
+void ChartFoxOAuth2Client::storeTokens()
+{
+    auto key = clientId + platform::getMachineID();
+
+    std::stringstream tokenStream;
+    tokenStream << nlohmann::json {
+        {"access_token", accessToken},
+        {"refresh_token", refreshToken}
+    };
+
+    fs::ofstream fileStream(fs::u8path(tokenFile));
+    fileStream << crypto.aesEncrypt(tokenStream.str(), key);
+}
+
+ChartFoxOAuth2Client::~ChartFoxOAuth2Client()
+{
+    restCancel = true;
+}
+
+} /* namespace chartfox */
diff --git a/src/charts/libchartfox/ChartFoxOAuth2Client.h b/src/charts/libchartfox/ChartFoxOAuth2Client.h
new file mode 100644
index 00000000..6bef57a8
--- /dev/null
+++ b/src/charts/libchartfox/ChartFoxOAuth2Client.h
@@ -0,0 +1,84 @@
+/*
+ *   AviTab - Aviator's Virtual Tablet
+ *   Copyright (C) 2024 Folke Will <folko@solhost.org>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program 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.  See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include <string>
+#include <vector>
+#include <map>
+#include <thread>
+#include <memory>
+#include <functional>
+#include "src/charts/Crypto.h"
+#include "src/charts/RESTClient.h"
+#include "ChartFoxAuthServer.h"
+
+namespace chartfox {
+
+class LoginException: public std::exception {
+public:
+    const char *what() const noexcept override;
+};
+
+class ChartFoxOAuth2Client {
+public:
+    using AuthCallback = std::function<void()>;
+
+    ChartFoxOAuth2Client(const std::string &clientId);
+    void setCacheDirectory(const std::string &dir);
+
+    std::string startAuth(AuthCallback cb);
+    void cancelAuth();
+    void logout();
+
+    std::string get(const std::string &url);
+    std::vector<uint8_t> getBinary(const std::string &url);
+    long getTimestamp(const std::string &url);
+
+    virtual ~ChartFoxOAuth2Client();
+
+private:
+    std::string const clientId;
+    std::string cacheDir;
+    std::string tokenFile;
+
+    apis::RESTClient restClient;
+    ChartFoxAuthServer server;
+    apis::Crypto crypto;
+
+    // for auth process
+    int authPort = 0;
+    std::string verifier;
+    std::string state;
+
+    // state
+    AuthCallback onAuthCompleted;
+    std::string accessToken, refreshToken;
+    std::map<std::string, std::string> cookieJar;
+
+    bool restCancel = false; // set true on destruction to cancel any incomplete transaction
+
+    bool relogin();
+    void onAuthReply(const std::string &authUrl);
+    void handleToken(const std::string &inputJson, const std::map<std::string, std::string> &cookies);
+    void tryWithRelogin(std::function<void()> f);
+
+    void loadTokens();
+    void storeTokens();
+};
+
+} /* namespace chartfox */
diff --git a/src/charts/liblocalfile/LocalFileChart.h b/src/charts/liblocalfile/LocalFileChart.h
index 2382fb39..2230ae2e 100644
--- a/src/charts/liblocalfile/LocalFileChart.h
+++ b/src/charts/liblocalfile/LocalFileChart.h
@@ -29,18 +29,21 @@ class LocalFileChart: public apis::Chart {
     LocalFileChart(const std::string dir, const std::string name, const std::string &icao, size_t idx);
     virtual ~LocalFileChart() = default;
 
-    virtual std::string getICAO() const override;
-    virtual std::string getIndex() const override;
-    virtual apis::ChartCategory getCategory() const override;
-    virtual std::string getName() const override;
+    std::string getICAO() const override;
+    std::string getIndex() const override;
+    apis::ChartCategory getCategory() const override;
+    std::string getName() const override;
 
-    virtual bool isLoaded() const override;
-    virtual std::shared_ptr<img::TileSource> createTileSource(bool nightMode) override;
-    virtual void changeNightMode(std::shared_ptr<img::TileSource> src, bool nightMode) override;
-    virtual void setCalibrationMetadata(std::string metadata) override;
+    std::shared_ptr<img::TileSource> createTileSource(bool nightMode) override;
+    void changeNightMode(std::shared_ptr<img::TileSource> src, bool nightMode) override;
+    void setCalibrationMetadata(std::string metadata) override;
 
     std::string getPath() const;
+
+private:
     void attachData(const std::vector<uint8_t> &data);
+    bool isLoaded() const;
+
 private:
     std::string icao;
     size_t index;
diff --git a/src/charts/libnavigraph/NavigraphChart.h b/src/charts/libnavigraph/NavigraphChart.h
index 557cf862..fae98580 100644
--- a/src/charts/libnavigraph/NavigraphChart.h
+++ b/src/charts/libnavigraph/NavigraphChart.h
@@ -37,19 +37,21 @@ class NavigraphChart: public apis::Chart {
     NavigraphChart(const nlohmann::json &json);
     virtual ~NavigraphChart() = default;
 
-    virtual std::string getICAO() const override;
-    virtual std::string getIndex() const override;
-    virtual apis::ChartCategory getCategory() const override;
-    virtual std::string getName() const override;
+    std::string getICAO() const override;
+    std::string getIndex() const override;
+    apis::ChartCategory getCategory() const override;
+    std::string getName() const override;
 
-    virtual bool isLoaded() const override;
-    virtual std::shared_ptr<img::TileSource> createTileSource(bool nightMode) override;
-    virtual void changeNightMode(std::shared_ptr<img::TileSource> src, bool nightMode) override;
-    virtual void setCalibrationMetadata(std::string metadata) override {}; // Ignore
+    std::shared_ptr<img::TileSource> createTileSource(bool nightMode) override;
+    void changeNightMode(std::shared_ptr<img::TileSource> src, bool nightMode) override;
+    void setCalibrationMetadata(std::string metadata) override {} // Ignore
 
+public: // used by NavigraphAPI
+    bool isLoaded() const;
     std::string getFileDay() const;
     std::string getFileNight() const;
     void attachImages(std::shared_ptr<img::Image> day, std::shared_ptr<img::Image> night);
+
 private:
     ChartGEOReference geoRef{};
     std::string fileDay, fileNight;
diff --git a/src/gui_toolkit/widgets/Widget.cpp b/src/gui_toolkit/widgets/Widget.cpp
index 4ea86ff4..29e22703 100644
--- a/src/gui_toolkit/widgets/Widget.cpp
+++ b/src/gui_toolkit/widgets/Widget.cpp
@@ -82,6 +82,11 @@ void Widget::alignTopRightInParent(int padRight, int padTop) {
     lv_obj_set_auto_realign(lvObj, true);
 }
 
+void Widget::alignInBottomLeft() {
+    lv_obj_align(lvObj, nullptr, LV_ALIGN_IN_BOTTOM_LEFT, 0, 0);
+    lv_obj_set_auto_realign(lvObj, true);
+}
+
 void Widget::alignInBottomCenter() {
     lv_obj_align(lvObj, nullptr, LV_ALIGN_IN_BOTTOM_MID, 0, 0);
     lv_obj_set_auto_realign(lvObj, true);
diff --git a/src/gui_toolkit/widgets/Widget.h b/src/gui_toolkit/widgets/Widget.h
index aeb76e3a..070520a4 100644
--- a/src/gui_toolkit/widgets/Widget.h
+++ b/src/gui_toolkit/widgets/Widget.h
@@ -53,6 +53,7 @@ class Widget {
     void alignTopRightInParent(int padRight = 0, int padTop = 0);
     void alignInTopLeft();
     void alignInTopRight(int xPad = 0);
+    void alignInBottomLeft();
     void alignInBottomCenter();
     void alignInBottomRight();
     void alignLeftOf(WidgetPtr base);