1 files changed, 208 insertions, 86 deletions

@@ -1,30 +1,64 @@
 #include "tracker_frame.h"
 
+#include <fmt/core.h>
 #include <wx/aboutdlg.h>
 #include <wx/choicebk.h>
+#include <wx/filedlg.h>
+#include <wx/notebook.h>
+#include <wx/splitter.h>
+#include <wx/stdpaths.h>
 #include <wx/webrequest.h>
 
+#include <algorithm>
 #include <nlohmann/json.hpp>
 #include <sstream>
 
 #include "achievements_pane.h"
 #include "ap_state.h"
 #include "connection_dialog.h"
+#include "ipc_dialog.h"
+#include "ipc_state.h"
+#include "items_pane.h"
+#include "log_dialog.h"
+#include "logger.h"
+#include "options_pane.h"
+#include "paintings_pane.h"
 #include "settings_dialog.h"
 #include "subway_map.h"
 #include "tracker_config.h"
 #include "tracker_panel.h"
 #include "version.h"
 
+namespace {
+
+std::string GetStatusMessage() {
+  std::string msg = AP_GetStatusMessage();
+
+  std::optional<std::string> ipc_msg = IPC_GetStatusMessage();
+  if (ipc_msg) {
+    msg += " ";
+    msg += *ipc_msg;
+  }
+
+  return msg;
+}
+
+}  // namespace
+
 enum TrackerFrameIds {
-  ID_CONNECT = 1,
+  ID_AP_CONNECT = 1,
   ID_CHECK_FOR_UPDATES = 2,
-  ID_SETTINGS = 3
+  ID_SETTINGS = 3,
+  ID_ZOOM_IN = 4,
+  ID_ZOOM_OUT = 5,
+  ID_IPC_CONNECT = 7,
+  ID_LOG_DIALOG = 8,
 };
 
 wxDEFINE_EVENT(STATE_RESET, wxCommandEvent);
-wxDEFINE_EVENT(STATE_CHANGED, wxCommandEvent);
+wxDEFINE_EVENT(STATE_CHANGED, StateChangedEvent);
 wxDEFINE_EVENT(STATUS_CHANGED, wxCommandEvent);
+wxDEFINE_EVENT(CONNECT_TO_AP, ApConnectEvent);
 
 TrackerFrame::TrackerFrame()
     : wxFrame(nullptr, wxID_ANY, "Lingo Archipelago Tracker", wxDefaultPosition,
@@ -32,52 +66,87 @@ TrackerFrame::TrackerFrame()
   ::wxInitAllImageHandlers();
 
   AP_SetTrackerFrame(this);
+  IPC_SetTrackerFrame(this);
+
+  SetTheIconCache(&icons_);
+
+  updater_ = std::make_unique<Updater>(this);
+  updater_->Cleanup();
 
   wxMenu *menuFile = new wxMenu();
-  menuFile->Append(ID_CONNECT, "&Connect");
+  menuFile->Append(ID_AP_CONNECT, "&Connect to Archipelago");
+  menuFile->Append(ID_IPC_CONNECT, "&Connect to Lingo");
   menuFile->Append(ID_SETTINGS, "&Settings");
   menuFile->Append(wxID_EXIT);
 
+  wxMenu *menuView = new wxMenu();
+  zoom_in_menu_item_ = menuView->Append(ID_ZOOM_IN, "Zoom In\tCtrl-+");
+  zoom_out_menu_item_ = menuView->Append(ID_ZOOM_OUT, "Zoom Out\tCtrl--");
+  menuView->AppendSeparator();
+  menuView->Append(ID_LOG_DIALOG, "Show Log Window\tCtrl-L");
+
+  zoom_in_menu_item_->Enable(false);
+  zoom_out_menu_item_->Enable(false);
+
   wxMenu *menuHelp = new wxMenu();
   menuHelp->Append(wxID_ABOUT);
   menuHelp->Append(ID_CHECK_FOR_UPDATES, "Check for Updates");
 
   wxMenuBar *menuBar = new wxMenuBar();
   menuBar->Append(menuFile, "&File");
+  menuBar->Append(menuView, "&View");
   menuBar->Append(menuHelp, "&Help");
 
   SetMenuBar(menuBar);
 
   CreateStatusBar();
-  SetStatusText("Not connected to Archipelago.");
 
   Bind(wxEVT_MENU, &TrackerFrame::OnAbout, this, wxID_ABOUT);
   Bind(wxEVT_MENU, &TrackerFrame::OnExit, this, wxID_EXIT);
-  Bind(wxEVT_MENU, &TrackerFrame::OnConnect, this, ID_CONNECT);
+  Bind(wxEVT_MENU, &TrackerFrame::OnApConnect, this, ID_AP_CONNECT);
+  Bind(wxEVT_MENU, &TrackerFrame::OnIpcConnect, this, ID_IPC_CONNECT);
   Bind(wxEVT_MENU, &TrackerFrame::OnSettings, this, ID_SETTINGS);
   Bind(wxEVT_MENU, &TrackerFrame::OnCheckForUpdates, this,
        ID_CHECK_FOR_UPDATES);
+  Bind(wxEVT_MENU, &TrackerFrame::OnZoomIn, this, ID_ZOOM_IN);
+  Bind(wxEVT_MENU, &TrackerFrame::OnZoomOut, this, ID_ZOOM_OUT);
+  Bind(wxEVT_MENU, &TrackerFrame::OnOpenLogWindow, this, ID_LOG_DIALOG);
+  Bind(wxEVT_NOTEBOOK_PAGE_CHANGED, &TrackerFrame::OnChangePage, this);
+  Bind(wxEVT_SPLITTER_SASH_POS_CHANGED, &TrackerFrame::OnSashPositionChanged,
+       this);
   Bind(STATE_RESET, &TrackerFrame::OnStateReset, this);
   Bind(STATE_CHANGED, &TrackerFrame::OnStateChanged, this);
   Bind(STATUS_CHANGED, &TrackerFrame::OnStatusChanged, this);
+  Bind(CONNECT_TO_AP, &TrackerFrame::OnConnectToAp, this);
+
+  wxSize logicalSize = FromDIP(wxSize(1280, 728));
 
-  achievements_pane_ = new AchievementsPane(this);
+  splitter_window_ = new wxSplitterWindow(this, wxID_ANY);
+  splitter_window_->SetMinimumPaneSize(logicalSize.x / 5);
 
-  wxChoicebook *choicebook = new wxChoicebook(this, wxID_ANY);
+  wxChoicebook *choicebook = new wxChoicebook(splitter_window_, wxID_ANY);
+
+  achievements_pane_ = new AchievementsPane(choicebook);
   choicebook->AddPage(achievements_pane_, "Achievements");
 
-  wxNotebook *rightpane = new wxNotebook(this, wxID_ANY);
-  tracker_panel_ = new TrackerPanel(rightpane);
-  subway_map_ = new SubwayMap(rightpane);
-  rightpane->AddPage(tracker_panel_, "Map");
-  rightpane->AddPage(subway_map_, "Subway");
+  items_pane_ = new ItemsPane(choicebook);
+  choicebook->AddPage(items_pane_, "Items");
+
+  options_pane_ = new OptionsPane(choicebook);
+  choicebook->AddPage(options_pane_, "Options");
+
+  paintings_pane_ = new PaintingsPane(choicebook);
+  choicebook->AddPage(paintings_pane_, "Paintings");
 
-  wxBoxSizer *top_sizer = new wxBoxSizer(wxHORIZONTAL);
-  top_sizer->Add(choicebook, wxSizerFlags().Expand().Proportion(1));
-  top_sizer->Add(rightpane, wxSizerFlags().Expand().Proportion(3));
+  notebook_ = new wxNotebook(splitter_window_, wxID_ANY);
+  tracker_panel_ = new TrackerPanel(notebook_);
+  subway_map_ = new SubwayMap(notebook_);
+  notebook_->AddPage(tracker_panel_, "Map");
+  notebook_->AddPage(subway_map_, "Subway");
 
-  SetSizerAndFit(top_sizer);
-  SetSize(1280, 728);
+  splitter_window_->SplitVertically(choicebook, notebook_, logicalSize.x / 4);
+
+  SetSize(logicalSize);
 
   if (!GetTrackerConfig().asked_to_check_for_updates) {
     GetTrackerConfig().asked_to_check_for_updates = true;
@@ -94,23 +163,28 @@ TrackerFrame::TrackerFrame()
   }
 
   if (GetTrackerConfig().should_check_for_updates) {
-    CheckForUpdates(/*manual=*/false);
+    updater_->CheckForUpdates(/*invisible=*/true);
   }
+
+  SetStatusText(GetStatusMessage());
 }
 
-void TrackerFrame::SetStatusMessage(std::string message) {
-  wxCommandEvent *event = new wxCommandEvent(STATUS_CHANGED);
-  event->SetString(message.c_str());
+void TrackerFrame::ConnectToAp(std::string server, std::string user,
+                               std::string pass) {
+  QueueEvent(new ApConnectEvent(CONNECT_TO_AP, GetId(), std::move(server),
+                                std::move(user), std::move(pass)));
+}
 
-  QueueEvent(event);
+void TrackerFrame::UpdateStatusMessage() {
+  QueueEvent(new wxCommandEvent(STATUS_CHANGED));
 }
 
 void TrackerFrame::ResetIndicators() {
   QueueEvent(new wxCommandEvent(STATE_RESET));
 }
 
-void TrackerFrame::UpdateIndicators() {
-  QueueEvent(new wxCommandEvent(STATE_CHANGED));
+void TrackerFrame::UpdateIndicators(StateUpdate state) {
+  QueueEvent(new StateChangedEvent(STATE_CHANGED, GetId(), std::move(state)));
 }
 
 void TrackerFrame::OnAbout(wxCommandEvent &event) {
@@ -118,6 +192,7 @@ void TrackerFrame::OnAbout(wxCommandEvent &event) {
   about_info.SetName("Lingo Archipelago Tracker");
   about_info.SetVersion(kTrackerVersion.ToString());
   about_info.AddDeveloper("hatkirby");
+  about_info.AddDeveloper("art0007i");
   about_info.AddArtist("Brenton Wildes");
   about_info.AddArtist("kinrah");
 
@@ -126,7 +201,7 @@ void TrackerFrame::OnAbout(wxCommandEvent &event) {
 
 void TrackerFrame::OnExit(wxCommandEvent &event) { Close(true); }
 
-void TrackerFrame::OnConnect(wxCommandEvent &event) {
+void TrackerFrame::OnApConnect(wxCommandEvent &event) {
   ConnectionDialog dlg;
 
   if (dlg.ShowModal() == wxID_OK) {
@@ -144,7 +219,7 @@ void TrackerFrame::OnConnect(wxCommandEvent &event) {
       }
     }
 
-    while (new_history.size() > 5) {
+    while (new_history.size() > 10) {
       new_history.pop_back();
     }
 
@@ -156,6 +231,17 @@ void TrackerFrame::OnConnect(wxCommandEvent &event) {
   }
 }
 
+void TrackerFrame::OnIpcConnect(wxCommandEvent &event) {
+  IpcDialog dlg;
+
+  if (dlg.ShowModal() == wxID_OK) {
+    GetTrackerConfig().ipc_address = dlg.GetIpcAddress();
+    GetTrackerConfig().Save();
+
+    IPC_Connect(dlg.GetIpcAddress());
+  }
+}
+
 void TrackerFrame::OnSettings(wxCommandEvent &event) {
   SettingsDialog dlg;
 
@@ -163,83 +249,119 @@ void TrackerFrame::OnSettings(wxCommandEvent &event) {
     GetTrackerConfig().should_check_for_updates =
         dlg.GetShouldCheckForUpdates();
     GetTrackerConfig().hybrid_areas = dlg.GetHybridAreas();
-    GetTrackerConfig().show_hunt_panels = dlg.GetShowHuntPanels();
+    GetTrackerConfig().visible_panels = dlg.GetVisiblePanels();
+    GetTrackerConfig().track_position = dlg.GetTrackPosition();
     GetTrackerConfig().Save();
 
-    UpdateIndicators();
+    UpdateIndicators(StateUpdate{.cleared_locations = true,
+                                 .player_position = true,
+                                 .changed_settings = true});
   }
 }
 
 void TrackerFrame::OnCheckForUpdates(wxCommandEvent &event) {
-  CheckForUpdates(/*manual=*/true);
+  updater_->CheckForUpdates(/*invisible=*/false);
 }
 
-void TrackerFrame::OnStateReset(wxCommandEvent& event) {
-  tracker_panel_->UpdateIndicators();
-  achievements_pane_->UpdateIndicators();
-  subway_map_->OnConnect();
-  Refresh();
+void TrackerFrame::OnZoomIn(wxCommandEvent &event) {
+  if (notebook_->GetSelection() == 1) {
+    subway_map_->Zoom(true);
+  }
 }
 
-void TrackerFrame::OnStateChanged(wxCommandEvent &event) {
-  tracker_panel_->UpdateIndicators();
-  achievements_pane_->UpdateIndicators();
-  subway_map_->UpdateIndicators();
-  Refresh();
+void TrackerFrame::OnZoomOut(wxCommandEvent &event) {
+  if (notebook_->GetSelection() == 1) {
+    subway_map_->Zoom(false);
+  }
 }
 
-void TrackerFrame::OnStatusChanged(wxCommandEvent &event) {
-  SetStatusText(event.GetString());
+void TrackerFrame::OnOpenLogWindow(wxCommandEvent &event) {
+  if (log_dialog_ == nullptr) {
+    log_dialog_ = new LogDialog(this);
+    log_dialog_->Show();
+    TrackerSetLogDialog(log_dialog_);
+
+    log_dialog_->Bind(wxEVT_CLOSE_WINDOW, &TrackerFrame::OnCloseLogWindow,
+                      this);
+  } else {
+    log_dialog_->SetFocus();
+  }
 }
 
-void TrackerFrame::CheckForUpdates(bool manual) {
-  wxWebRequest request = wxWebSession::GetDefault().CreateRequest(
-      this, "https://code.fourisland.com/lingo-ap-tracker/plain/VERSION");
+void TrackerFrame::OnCloseLogWindow(wxCloseEvent& event) {
+  TrackerSetLogDialog(nullptr);
+  log_dialog_ = nullptr;
 
-  if (!request.IsOk()) {
-    if (manual) {
-      wxMessageBox("Could not check for updates.", "Error",
-                   wxOK | wxICON_ERROR);
-    } else {
-      SetStatusText("Could not check for updates.");
+  event.Skip();
+}
+
+void TrackerFrame::OnChangePage(wxBookCtrlEvent &event) {
+  zoom_in_menu_item_->Enable(event.GetSelection() == 1);
+  zoom_out_menu_item_->Enable(event.GetSelection() == 1);
+}
+
+void TrackerFrame::OnSashPositionChanged(wxSplitterEvent& event) {
+  notebook_->Refresh();
+}
+
+void TrackerFrame::OnStateReset(wxCommandEvent &event) {
+  tracker_panel_->UpdateIndicators(/*reset=*/true);
+  achievements_pane_->UpdateIndicators();
+  items_pane_->ResetIndicators();
+  options_pane_->OnConnect();
+  paintings_pane_->ResetIndicators();
+  subway_map_->OnConnect();
+  Refresh();
+}
+
+void TrackerFrame::OnStateChanged(StateChangedEvent &event) {
+  const StateUpdate &state = event.GetState();
+
+  bool hunt_panels = false;
+  if (GetTrackerConfig().visible_panels == TrackerConfig::kHUNT_PANELS) {
+    hunt_panels = std::any_of(
+        state.panels.begin(), state.panels.end(), [](int solve_index) {
+          return GD_GetPanel(GD_GetPanelBySolveIndex(solve_index)).hunt;
+        });
+  } else if (GetTrackerConfig().visible_panels == TrackerConfig::kALL_PANELS) {
+    hunt_panels = true;
+  }
+  
+  if (!state.items.empty() || !state.paintings.empty() ||
+      state.cleared_locations || hunt_panels) {
+    // TODO: The only real reason to reset tracker_panel during an active
+    // connection is if the hunt panels setting changes. If we remove hunt
+    // panels later, we can get rid of this.
+    tracker_panel_->UpdateIndicators(/*reset=*/state.changed_settings);
+    subway_map_->UpdateIndicators();
+    Refresh();
+  } else if (state.player_position && GetTrackerConfig().track_position) {
+    if (notebook_->GetSelection() == 0) {
+      tracker_panel_->Refresh();
     }
+  }
 
-    return;
+  if (std::any_of(state.panels.begin(), state.panels.end(),
+                  [](int solve_index) {
+                    return GD_GetPanel(GD_GetPanelBySolveIndex(solve_index))
+                        .achievement;
+                  })) {
+    achievements_pane_->UpdateIndicators();
   }
 
-  Bind(wxEVT_WEBREQUEST_STATE, [this, manual](wxWebRequestEvent &evt) {
-    if (evt.GetState() == wxWebRequest::State_Completed) {
-      std::string response = evt.GetResponse().AsString().ToStdString();
-
-      Version latest_version(response);
-      if (kTrackerVersion < latest_version) {
-        std::ostringstream message_text;
-        message_text << "There is a newer version of Lingo AP Tracker "
-                        "available. You have "
-                     << kTrackerVersion.ToString()
-                     << ", and the latest version is "
-                     << latest_version.ToString()
-                     << ". Would you like to update?";
-
-        if (wxMessageBox(message_text.str(), "Update available", wxYES_NO) ==
-            wxYES) {
-          wxLaunchDefaultBrowser(
-              "https://code.fourisland.com/lingo-ap-tracker/about/"
-              "CHANGELOG.md");
-        }
-      } else if (manual) {
-        wxMessageBox("Lingo AP Tracker is up to date!", "Lingo AP Tracker",
-                     wxOK);
-      }
-    } else if (evt.GetState() == wxWebRequest::State_Failed) {
-      if (manual) {
-        wxMessageBox("Could not check for updates.", "Error",
-                     wxOK | wxICON_ERROR);
-      } else {
-        SetStatusText("Could not check for updates.");
-      }
-    }
-  });
+  if (!state.items.empty()) {
+    items_pane_->UpdateIndicators(state.items);
+  }
+
+  if (!state.paintings.empty()) {
+    paintings_pane_->UpdateIndicators(state.paintings);
+  }
+}
+
+void TrackerFrame::OnStatusChanged(wxCommandEvent &event) {
+  SetStatusText(wxString::FromUTF8(GetStatusMessage()));
+}
 
-  request.Start();
+void TrackerFrame::OnConnectToAp(ApConnectEvent &event) {
+  AP_Connect(event.GetServer(), event.GetUser(), event.GetPass());
 }