kitlistgui.cpp

Go to the documentation of this file.

/*
 
    This file is part of Kitlist, a program to maintain a simple list
    of items and assign items to one or more categories.
 
    Copyright (C) 2008-2025 Frank Dean
 
    Kitlist is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    Kitlist 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 General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with Kitlist.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#include "config.h"
#include "kitlistgui.hpp"
#include "kitparser.hpp"
#ifdef HAVE_FINALCUT
#include "kitlist_finalcut.hpp"
#endif
#ifdef HAVE_FTXUI
#include "kitlist_ftxui.hpp"
#endif
#include "wx/aboutdlg.h"
#include "wx/app.h"
#include "wx/cmdline.h"
#include "wx/config.h"
#include "wx/dcmirror.h"
#include "wx/filefn.h"
#include "wx/filename.h"
#include <memory>
#include <vector>
 
using namespace std;
 
// ----------------------------------------------------------------------------
// resources
// ----------------------------------------------------------------------------
 
#ifndef wxHAS_IMAGES_IN_RESOURCES
    #include "../kitlist.xpm"
#endif
 
// ----------------------------------------------------------------------------
// MySplitterWindow
// ----------------------------------------------------------------------------
 
wxBEGIN_EVENT_TABLE(MySplitterWindow, wxSplitterWindow)
    EVT_SPLITTER_SASH_POS_CHANGED(wxID_ANY, MySplitterWindow::OnPositionChanged)
wxEND_EVENT_TABLE()
 
void MySplitterWindow::OnPositionChanged(wxSplitterEvent& WXUNUSED(event))
{
#ifdef __linux__
  // Workaround where the sash is positioned incorrectly on startup when running on Linux
  if (ToDIP(frame->get_right_panel_width()).GetWidth() < 1)
    SetSashPosition(MyFrame::VSPLIT_DIST);
#endif
}
 
// ----------------------------------------------------------------------------
// MyFrame
// ----------------------------------------------------------------------------
 
const int MyFrame::VSPLIT_DIST = 200;
const int MyFrame::MIN_PANE_SIZE = 1;
const int MyFrame::ITEM_NAME_COL = 0;
const int MyFrame::ITEM_CHECKED_COL = 1;
const int MyFrame::CATEGORY_NAME_COL = 0;
 
enum
{
  QUIT = 1,
  NEW_FILE,
  OPEN_FILE,
  SAVE,
  SAVE_AS,
  ADD_ITEM,
  ADD_CATEGORY,
  SELECT_CATEGORY,
  SELECT_ITEM,
  CATEGORY_CONTEXT_MENU,
  ITEM_CONTEXT_MENU,
  CATEGORY_ITEM_CHANGE,
  CATEGORY_ITEM_START_EDITING,
  ITEM_CHANGE,
  DELETE_CATEGORY,
  DELETE_ITEM,
  COPY_ITEM_TO_CATEGORIES,
  REMOVE_ITEM,
  SHOW_ALL_EVENT,
  SHOW_CHECKED_EVENT,
  SHOW_UNCHECKED_EVENT,
  SELECT_ALL_ITEMS,
  UNSELECT_ALL_ITEMS,
  CHECK_ALL,
  UNCHECK_ALL,
  TOGGLE_ALL,
  CHECK_SELECTED,
  UNCHECK_SELECTED,
  TOGGLE_SELECTED,
  COPY_CHECKED_TO_CATEGORIES,
  COPY_SELECTED_ITEMS_TO_CATEGORIES,
  REMOVE_SELECTED_ITEMS,
  REMOVE_CHECKED_ITEMS,
  DELETE_CHECKED_ITEMS,
};
 
wxBEGIN_EVENT_TABLE(MyFrame, wxFrame)
    EVT_SHOW(MyFrame::OnShow)
    EVT_MENU(wxID_ABOUT, MyFrame::OnAbout)
    EVT_MENU(wxID_FILE1, MyFrame::OnFileHistoryMenuItem)
    EVT_MENU(wxID_FILE2, MyFrame::OnFileHistoryMenuItem)
    EVT_MENU(wxID_FILE3, MyFrame::OnFileHistoryMenuItem)
    EVT_MENU(wxID_FILE4, MyFrame::OnFileHistoryMenuItem)
    EVT_MENU(wxID_FILE5, MyFrame::OnFileHistoryMenuItem)
    EVT_MENU(wxID_FILE6, MyFrame::OnFileHistoryMenuItem)
    EVT_MENU(wxID_FILE7, MyFrame::OnFileHistoryMenuItem)
    EVT_MENU(wxID_FILE8, MyFrame::OnFileHistoryMenuItem)
    EVT_MENU(wxID_FILE9, MyFrame::OnFileHistoryMenuItem)
    EVT_MENU(NEW_FILE, MyFrame::OnNewFile)
    EVT_MENU(OPEN_FILE, MyFrame::OnOpen)
    EVT_MENU(SAVE, MyFrame::OnSave)
    EVT_MENU(SAVE_AS, MyFrame::OnSaveAs)
    EVT_MENU(QUIT, MyFrame::OnQuit)
    EVT_MENU(wxID_PRINT, MyFrame::OnPrint)
    EVT_MENU(wxID_PREVIEW, MyFrame::OnPrintPreview)
    EVT_DATAVIEW_SELECTION_CHANGED(SELECT_CATEGORY, MyFrame::OnSelectCategory)
    EVT_DATAVIEW_SELECTION_CHANGED(SELECT_ITEM, MyFrame::OnSelectItem)
    EVT_DATAVIEW_ITEM_VALUE_CHANGED(CATEGORY_ITEM_CHANGE, MyFrame::OnCategoryListValueChanged)
    EVT_DATAVIEW_ITEM_VALUE_CHANGED(ITEM_CHANGE, MyFrame::OnItemListValueChanged)
    EVT_DATAVIEW_ITEM_START_EDITING(CATEGORY_ITEM_START_EDITING, MyFrame::OnCategoryStartEditing)
    EVT_DATAVIEW_ITEM_CONTEXT_MENU(CATEGORY_CONTEXT_MENU, MyFrame::OnCategoryContextMenu)
    EVT_DATAVIEW_ITEM_CONTEXT_MENU(ITEM_CONTEXT_MENU, MyFrame::OnItemContextMenu)
    EVT_MENU(ADD_ITEM, MyFrame::OnAddItem)
    EVT_MENU(ADD_CATEGORY, MyFrame::OnAddCategory)
    EVT_MENU(SHOW_ALL_EVENT, MyFrame::OnShowAll)
    EVT_MENU(SHOW_CHECKED_EVENT, MyFrame::OnShowChecked)
    EVT_MENU(SHOW_UNCHECKED_EVENT, MyFrame::OnShowUnchecked)
    EVT_MENU(UNSELECT_ALL_ITEMS, MyFrame::OnUnselectAllItems)
    EVT_MENU(SELECT_ALL_ITEMS, MyFrame::OnSelectAllItems)
    EVT_MENU(CHECK_ALL, MyFrame::OnCheckAll)
    EVT_MENU(UNCHECK_ALL, MyFrame::OnUncheckAll)
    EVT_MENU(TOGGLE_ALL, MyFrame::OnToggleAll)
    EVT_MENU(CHECK_SELECTED, MyFrame::OnCheckSelected)
    EVT_MENU(UNCHECK_SELECTED, MyFrame::OnUncheckSelected)
    EVT_MENU(TOGGLE_SELECTED, MyFrame::OnToggleSelected)
    EVT_MENU(COPY_CHECKED_TO_CATEGORIES, MyFrame::CopyCheckedToCategories)
    EVT_MENU(COPY_SELECTED_ITEMS_TO_CATEGORIES, MyFrame::OnCopySelectedItemsToCategories)
    EVT_MENU(REMOVE_SELECTED_ITEMS, MyFrame::OnRemoveSelectedItems)
    EVT_MENU(REMOVE_CHECKED_ITEMS, MyFrame::OnRemoveCheckedItems)
    EVT_MENU(DELETE_CHECKED_ITEMS, MyFrame::OnDeleteCheckedItems)
wxEND_EVENT_TABLE()
 
MyFrame::MyFrame(KitListGui* app, const wxPoint& pos)
    : wxFrame(nullptr, wxID_ANY, "Kitlist", pos),
    rich_text_printing(),
    gui_app(app),
    category_list_ctrl(),
    file_menu(),
    edit_menu(),
    last_error(nullptr) {
 
  wxLOG_COMPONENT = "KitList/MyFrame";
  SetIcon(wxICON(kitlist));
  CreateStatusBar(2);
 
  file_history_menu = new wxMenu();
  file_history = new wxFileHistory();
  file_history->UseMenu(file_history_menu);
 
  file_menu = new wxMenu;
  file_menu->Append(NEW_FILE, L"&New\tCtrl-N", "Create a new kitlist");
  file_menu->Append(OPEN_FILE, L"&Open…\tCtrl-O", "Open…");
  file_history_menu_item = file_menu->AppendSubMenu(file_history_menu, L"Open &Recent…");
  file_menu->AppendSeparator();
  file_menu->Append(SAVE, "&Save\tCtrl-S", "Save");
  file_menu->Append(SAVE_AS, L"Save &As…\tShift-Ctrl-S", L"Save As…");
  file_menu->AppendSeparator();
  file_menu->Append(wxID_PRINT, "&Print...\tCtrl+P", "Show \"Print\" dialog");
  file_menu->Append(wxID_PREVIEW, "Pre&view\tAlt-Shift-Ctrl+V", "Show print preview");
  file_menu->AppendSeparator();
  file_menu->Append(QUIT, "&Quit\tCtrl-Q", "Quit");
 
  auto config = wxConfig::Get();
  auto old_path = config->GetPath();
  config->SetPath("/FileHistory");
  file_history->Load(*config);
  config->SetPath(old_path);
 
  file_menu->Enable(file_history_menu_item->GetId(), file_history->GetCount() > 0);
  update_file_menu(false);
 
  edit_menu = new wxMenu;
  edit_menu->Append(ADD_ITEM, L"New &Item…\tShift-Ctrl-I", L"Create new item");
  edit_menu->Append(ADD_CATEGORY, L"New &Category…\tShift-Ctrl-N", L"Create new category");
  edit_menu->AppendSeparator();
  edit_menu->Append(SELECT_ALL_ITEMS, "Select &All\tCtrl-A", "Select all items");
  edit_menu->Append(UNSELECT_ALL_ITEMS, "&Unse&lect All\tCtrl-U", "Unselect all items");
  edit_menu->AppendSeparator();
  edit_menu->Append(CHECK_SELECTED, "Chec&k Selected\tAlt-Ctrl-K", "Check selected items");
  edit_menu->Append(UNCHECK_SELECTED, "Uncheck &Selected\tAlt-Ctrl-U", "Uncheck selected items");
  edit_menu->Append(TOGGLE_SELECTED, "&Toggle Selected\tAlt-Ctrl-T", "Toggle selected items");
  edit_menu->AppendSeparator();
  edit_menu->Append(COPY_SELECTED_ITEMS_TO_CATEGORIES, L"Cop&y Selected Items…\tShift-Ctrl-C", "Copy selected items to one or more categories");
  edit_menu->Append(REMOVE_SELECTED_ITEMS, "&Remove Selected Items\tShift-Ctrl-R", "Remove selected items from the current category");
  edit_menu->AppendSeparator();
  edit_menu->Append(REMOVE_CHECKED_ITEMS, "&Remove Checked Items\tShift-Ctrl-H", "Remove checked items from the current category");
  edit_menu->Append(DELETE_CHECKED_ITEMS, "&Delete Checked Items\tShift-Ctrl-H", "Delete checked items from the current category");
  edit_menu->AppendSeparator();
  edit_menu->Append(CHECK_ALL, "Ch&eck all\tAlt-Shift-Ctrl-K", "Check all items in list");
  edit_menu->Append(UNCHECK_ALL, "Unc&heck all\tAlt-Shift-Ctrl-U", "Uncheck all items in list");
  edit_menu->Append(TOGGLE_ALL, "To&ggle all\tAlt-Shift-Ctrl-T", "Toggle all items in the list");
  edit_menu->AppendSeparator();
  edit_menu->Append(COPY_CHECKED_TO_CATEGORIES, L"Copy Checked Ite&ms…\tAlt-Ctrl-c", "Copy checked items to one or more categories");
 
  edit_menu->Enable(CHECK_SELECTED, false);
  edit_menu->Enable(UNCHECK_SELECTED, false);
  edit_menu->Enable(TOGGLE_SELECTED, false);
  edit_menu->Enable(REMOVE_SELECTED_ITEMS, false);
  edit_menu->Enable(REMOVE_CHECKED_ITEMS, false);
  edit_menu->Enable(
      DELETE_CHECKED_ITEMS,
      gui_app->count_filter_items_for_current_selected_category() > 0);
  edit_menu->Enable(COPY_SELECTED_ITEMS_TO_CATEGORIES, false);
 
  wxMenu* view_menu = new wxMenu;
  view_menu->Append(SHOW_ALL_EVENT, "Show &All\tShift-Ctrl-A", "Show all", wxITEM_RADIO);
  view_menu->Append(SHOW_CHECKED_EVENT, "Show &Checked\tShift-Ctrl-K", "Show checked", wxITEM_RADIO);
  view_menu->Append(SHOW_UNCHECKED_EVENT, "Show &Unchecked\tShift-Ctrl-U", "Show unchecked", wxITEM_RADIO);
 
  wxMenu* help_menu = new wxMenu;
  help_menu->Append(wxID_ABOUT, "&About", "About Kitlist");
 
  wxMenuBar* menuBar = new wxMenuBar;
  menuBar->Append(file_menu, "&File");
  menuBar->Append(edit_menu, "&Edit");
  menuBar->Append(view_menu, "&View");
  menuBar->Append(help_menu, "&Help");
 
  SetMenuBar(menuBar);
 
  split_window = new MySplitterWindow(this);
 
  split_window->SetSize(GetClientSize());
  split_window->SetSashGravity(0.25);
  split_window->SetMinimumPaneSize(MIN_PANE_SIZE);
 
  // If the filename is set, we were given it on the command line
  auto filename = gui_app->get_filename();
 
  // If not set on the command line, see if there's one in the file history
  if (filename.empty() && file_history->GetCount() > 0) {
    const wxString last_file = file_history->GetHistoryFile(0);
    if (!last_file.empty() && wxFileExists(last_file)) {
      // wxLogDebug("Last file loaded: \"%s\"", last_file);
      filename = last_file.ToStdString();
      gui_app->set_filename(filename);
    }
  }
 
  if (!filename.empty()) {
    try {
      wxLogInfo("Loading \"%s\"", filename);
      load_file(filename);
      file_history->AddFileToHistory(filename);
      file_menu->Enable(file_history_menu_item->GetId(), true);
    } catch (const KitListGui::file_not_found& e) {
      wxLogError("%s", e.what());
      last_error = std::make_unique<KitListGui::file_not_found>(e);
    } catch (const KitParser::parse_exception& e) {
      wxLogError("%s", e.what());
      last_error = std::make_unique<KitParser::parse_exception>(e);
    }
  }
 
  auto category_list_sizer = new wxBoxSizer(wxVERTICAL);
  left_panel = new wxPanel(split_window, wxID_ANY);
  category_list_ctrl = new wxDataViewListCtrl(left_panel, wxID_ANY);
  category_list_ctrl->Bind(wxEVT_DATAVIEW_ITEM_VALUE_CHANGED, &MyFrame::OnCategoryListValueChanged, this);
  category_list_ctrl->Bind(wxEVT_DATAVIEW_ITEM_START_EDITING, &MyFrame::OnCategoryStartEditing, this);
  category_list_ctrl->Bind(wxEVT_DATAVIEW_SELECTION_CHANGED, &MyFrame::OnSelectCategory, this);
  category_list_ctrl->AppendTextColumn(
      "Categories",
      wxDATAVIEW_CELL_EDITABLE,
      -1,
      wxALIGN_LEFT,
      wxDATAVIEW_COL_RESIZABLE | wxDATAVIEW_COL_REORDERABLE | wxDATAVIEW_COL_SORTABLE);
  populate_category_list();
  category_list_sizer->Add(category_list_ctrl, 1, wxGROW);
  left_panel->SetSizerAndFit(category_list_sizer);
 
  auto item_list_sizer = new wxBoxSizer(wxVERTICAL);
  right_panel = new wxPanel(split_window, wxID_ANY);
  item_list_ctrl = new wxDataViewListCtrl(right_panel, wxID_ANY,
                                          wxDefaultPosition,
                                          wxDefaultSize,
                                          wxDV_ROW_LINES | wxDV_MULTIPLE);
  item_list_ctrl->Bind(wxEVT_DATAVIEW_SELECTION_CHANGED, &MyFrame::OnSelectItem, this);
  item_list_ctrl->Bind(wxEVT_DATAVIEW_ITEM_VALUE_CHANGED, &MyFrame::OnItemListValueChanged, this);
  category_list_ctrl->Bind(wxEVT_DATAVIEW_ITEM_CONTEXT_MENU, &MyFrame::OnCategoryContextMenu, this);
  item_list_ctrl->Bind(wxEVT_DATAVIEW_ITEM_CONTEXT_MENU, &MyFrame::OnItemContextMenu, this);
  // Only the first column has text search enabled on platforms using GTK.
  //
  // If we place the checked column first, search is enabled but doesn't do
  // anything useful.  If the user subsequently moves the checked column to be
  // the first, text search on the name column still works.
  //
  // https://github.com/wxWidgets/wxWidgets/issues/23779
  wxDataViewColumn* name_view_column = item_list_ctrl->AppendTextColumn(
      "Item",
      wxDATAVIEW_CELL_EDITABLE,
      -1,
      wxALIGN_LEFT,
      wxDATAVIEW_COL_RESIZABLE |
      wxDATAVIEW_COL_REORDERABLE |
      wxDATAVIEW_COL_SORTABLE);
  wxDataViewColumn* checked_view_column = item_list_ctrl->AppendToggleColumn(
      "Checked",
      wxDATAVIEW_CELL_ACTIVATABLE,
      -1,
      wxALIGN_LEFT,
      wxDATAVIEW_COL_RESIZABLE | wxDATAVIEW_COL_REORDERABLE | wxDATAVIEW_COL_SORTABLE);
 
  checked_view_column->SetMinWidth(40);
  checked_view_column->SetWidth(60);
  name_view_column->SetMinWidth(100);
  name_view_column->SetWidth(270);
  populate_item_list();
  item_list_sizer->Add(item_list_ctrl, 1, wxGROW);
  right_panel->SetSizerAndFit(item_list_sizer);
 
  // Part of the workaround where the sash is positioned incorrectly when running on Linux
  // #ifdef __linux__
  // left_panel->SetMinSize(FromDIP(wxSize(vsplit_dist + 1, 0)));
  // #endif
  // you can also try -100
  split_window->SplitVertically(left_panel, right_panel, FromDIP(VSPLIT_DIST));
 
  old_path = config->GetPath();
  config->SetPath("/MainFrame");
 
  // restore frame position and size
  int x = config->Read("x", 50),
    y = config->Read("y", 50),
    w = config->Read("w", 640),
    h = config->Read("h", 480);
  Move(x, y);
  SetClientSize(w, h);
  config->SetPath(old_path);
  gui_app->initialization_complete();
  selected_item_changed();
}
 
MyFrame::~MyFrame()
{
  wxConfigBase* config = wxConfig::Get();
  if (config == nullptr)
    return;
 
  // save the frame position
  int x, y, w, h;
  GetClientSize(&w, &h);
  GetPosition(&x, &y);
  config->Write("/MainFrame/x", (long) x);
  config->Write("/MainFrame/y", (long) y);
  config->Write("/MainFrame/w", (long) w);
  config->Write("/MainFrame/h", (long) h);
}
 
void MyFrame::OnCategoryListValueChanged(wxDataViewEvent& event)
{
  const wxDataViewItem anItem = event.GetItem();
  const int row = category_list_ctrl->ItemToRow(anItem);
  if (row != wxNOT_FOUND && row > 0) {
    const wxUIntPtr item_data = category_list_ctrl->GetItemData(anItem);
    const int32_t cat_id = item_data;
    wxVariant value;
    category_list_ctrl->GetValue(value, row, CATEGORY_NAME_COL);
    wxString s(value);
    s.Trim();
    gui_app->set_category_name(cat_id, s.ToStdString());
  }
}
 
void MyFrame::OnItemListValueChanged(wxDataViewEvent& event)
{
  const wxDataViewItem anItem = event.GetItem();
  const int row = item_list_ctrl->ItemToRow(anItem);
  if (row != wxNOT_FOUND) {
    const wxUIntPtr item_data = item_list_ctrl->GetItemData(anItem);
    const int32_t id = item_data;
    // wxLogDebug("Searching for item %d", i);
    shared_ptr<Item> item = gui_app->get_item(id);
    if (item) {
      // NOTE: if the columns have been re-ordered, the original column number
      // no longer reflects what is reported in the event.  The event reports
      // the new position the column ID but also returns the wxDataViewItem
      // based on the original column order not the actual one associated with
      // the event.
      //
      // So, we retrieve the values of both columns and check to see if they
      // have changed.
      // wxLogDebug("item %d: Row %d, column %d", i, row, event.GetColumn());
      wxVariant name_value, checked_value;
      item_list_ctrl->GetValue(name_value, row, ITEM_NAME_COL);
      item_list_ctrl->GetValue(checked_value, row, ITEM_CHECKED_COL);
      const bool b = checked_value;
      if (b != item->is_checked()) {
        gui_app->set_item_checked(id, b);
        // wxLogDebug("Item %s", b ? "checked" : "unchecked");
      }
      wxString s(name_value);
      s.Trim();
      gui_app->set_item_name(id, s.ToStdString());
    } else {
      wxLogError("Failed to find item for row %d", row);
    }
  } else {
    wxLogError("Failed to find row for event");
  }
}
 
void MyFrame::OnCheckSelected(wxCommandEvent& WXUNUSED(event))
{
  change_selected_checked_states(Model::check);
  populate_item_list();
}
 
void MyFrame::OnUncheckSelected(wxCommandEvent& WXUNUSED(event))
{
  change_selected_checked_states(Model::uncheck);
  populate_item_list();
}
 
void MyFrame::OnToggleSelected(wxCommandEvent& WXUNUSED(event))
{
  change_selected_checked_states(Model::toggle);
  populate_item_list();
}
 
void MyFrame::change_selected_checked_states(Model::check_action action)
{
  wxDataViewItemArray view_items;
  const unsigned long long count = item_list_ctrl->GetSelections(view_items);
  if (count == 0)
    return;
  for (const auto& view_item : view_items) {
    gui_app->change_checked_state(
        item_list_ctrl->GetItemData(view_item), action);
  }
  populate_item_list();
  update_file_menu(gui_app->is_dirty());
}
 
void MyFrame::OnRemoveSelectedItems(wxCommandEvent& WXUNUSED(event))
{
  const auto cat_id = gui_app->get_selected_category();
  assert(cat_id != Model::no_category);
  if (cat_id == Model::no_category)
    return;
 
  wxDataViewItemArray view_items;
  const auto count = item_list_ctrl->GetSelections(view_items);
  if (count == 0)
    return;
  vector<shared_ptr<Item>> selected_items;
  for (const auto& view_item : view_items) {
    const int32_t id = item_list_ctrl->GetItemData(view_item);
    auto item = gui_app->get_item(id);
    if (item) {
      selected_items.push_back(item);
    }
  }
  gui_app->remove_items(selected_items);
  populate_item_list();
  selected_item_changed();
  update_file_menu(gui_app->is_dirty());
}
 
void MyFrame::OnRemoveCheckedItems(wxCommandEvent& WXUNUSED(event))
{
  gui_app->remove_all_current_checked_items();
  populate_item_list();
  selected_item_changed();
  update_file_menu(gui_app->is_dirty());
}
 
void MyFrame::OnDeleteCheckedItems(wxCommandEvent& WXUNUSED(event))
{
  gui_app->delete_all_current_checked_items();
  populate_item_list();
  selected_item_changed();
  update_file_menu(gui_app->is_dirty());
}
 
void MyFrame::CopyCheckedToCategories(wxCommandEvent& WXUNUSED(event))
{
  const auto items = gui_app->get_all_items_for_current_selected_category();
  vector<shared_ptr<Item>> selected_items;
  for (const auto& item : items)
    if (item->is_checked())
      selected_items.push_back(item);
  select_and_copy_to_categories(selected_items);
}
 
void MyFrame::OnCopySelectedItemsToCategories(wxCommandEvent& WXUNUSED(event))
{
  wxDataViewItemArray view_items;
  const auto count = item_list_ctrl->GetSelections(view_items);
  if (count == 0)
    return;
  vector<shared_ptr<Item>> selected_items;
  for (const auto&  view_item : view_items) {
    const int32_t id = item_list_ctrl->GetItemData(view_item);
    auto item = gui_app->get_item(id);
    if (item) {
      selected_items.push_back(item);
    }
  }
  select_and_copy_to_categories(selected_items);
}
 
void MyFrame::select_and_copy_to_categories(vector<shared_ptr<Item>> selected_items)
{
  wxArrayString s_cat;
  auto categories = gui_app->get_categories();
  for (const auto& c : categories)
    s_cat.Add(wxString::FromUTF8(c->get_name()));
  wxMultiChoiceDialog dlg(this, "Select target categories", "Categories", s_cat);
  if (dlg.ShowModal() == wxID_CANCEL)
    return;
  wxArrayInt selected = dlg.GetSelections();
  vector<shared_ptr<Category>> selected_categories;
  for (unsigned int i = 0; i < selected.size(); i++) {
    const unsigned int idx = selected[i];
    if (idx >= 0 && idx < categories.size())
      selected_categories.push_back(categories[idx]);
  }
  if (!selected_categories.empty())
    gui_app->copy_items_to_categories(selected_items, selected_categories);
  update_file_menu(gui_app->is_dirty());
}
 
void MyFrame::OnCategoryContextMenu(wxDataViewEvent& event)
{
  const wxDataViewItem anItem = event.GetItem();
  if (!anItem.IsOk())
    return;
  const int row = category_list_ctrl->ItemToRow(anItem);
  if (row == wxNOT_FOUND)
    return;
  const wxUIntPtr item_data = category_list_ctrl->GetItemData(anItem);
  const int32_t id = item_data;
  shared_ptr<Category> category = gui_app->get_category(id);
  if (!category)
    return;
 
  wxMenu menu;
  menu.Append(DELETE_CATEGORY, "&Delete category");
  int result = GetPopupMenuSelectionFromUser(menu);
  if (result == wxID_NONE)
    return;
  switch (result) {
    case DELETE_CATEGORY:
      delete_category(id);
      break;
  }
  update_file_menu(gui_app->is_dirty());
}
 
void MyFrame::OnItemContextMenu(wxDataViewEvent& event)
{
  const wxDataViewItem anItem = event.GetItem();
  if (!anItem.IsOk())
    return;
  const int row = item_list_ctrl->ItemToRow(anItem);
  if (row == wxNOT_FOUND)
    return;
  const wxUIntPtr item_data = item_list_ctrl->GetItemData(anItem);
  const int32_t i = item_data;
  // wxLogDebug("Searching for item %d", i);
  shared_ptr<Item> item = gui_app->get_item(i);
  auto selected_category = gui_app->get_selected_category();
  if (item) {
    wxMenu menu;
    if (selected_category < 0)
      menu.Append(DELETE_ITEM, "&Delete item");
    else
      menu.Append(REMOVE_ITEM, "&Remove item");
 
    menu.Append(COPY_ITEM_TO_CATEGORIES, "&Copy item");
    int result = GetPopupMenuSelectionFromUser(menu);
    if (result == wxID_NONE)
      return;
    switch (result) {
      case DELETE_ITEM:
        delete_item(i);
        break;
      case REMOVE_ITEM:
        remove_item(i);
        break;
      case COPY_ITEM_TO_CATEGORIES:
        vector<shared_ptr<Item>> items;
        items.push_back(item);
        select_and_copy_to_categories(items);
        break;
      }
  }
}
 
void MyFrame::OnSelectCategory(wxDataViewEvent& event)
{
  const wxDataViewItem anItem = event.GetItem();
  const int row = category_list_ctrl->ItemToRow(anItem);
  if (row == 0) {
    gui_app->select_category(Model::no_category);
  } else if (row != wxNOT_FOUND && row > 0) {
    const wxUIntPtr category_data = category_list_ctrl->GetItemData(anItem);
    const int32_t cat_id = category_data;
    const auto found_category = gui_app->get_category(cat_id);
    if (found_category)
      gui_app->select_category(cat_id);
    else
      wxLogError("Failed to find category with ID %d", cat_id);
  // } else {
  //   wxLogDebug("Row not found, not selecting a category");
  }
  populate_item_list();
}
 
void MyFrame::OnSelectItem(wxDataViewEvent& WXUNUSED(event))
{
  selected_item_changed();
}
 
void MyFrame::selected_item_changed()
{
  update_edit_menu();
}
 
unsigned MyFrame::populate_category_list(int32_t select_category)
{
  unsigned retval = 0;
  category_list_ctrl->DeleteAllItems();
  auto categories = gui_app->get_categories();
  wxVector<wxVariant> data;
  data.push_back(wxVariant(gui_app->all_items_text));
  category_list_ctrl->AppendItem(data, wxUIntPtr(CATEGORY_NAME_COL));
  data.clear();
  unsigned row = 0;
  for (const shared_ptr<Category>& cat : categories) {
    data.push_back(wxVariant(wxString::FromUTF8(cat->get_name())));
    wxUIntPtr client_data = cat->get_id();
    row++;
    if (select_category == cat->get_id())
      retval = row;
    category_list_ctrl->AppendItem(data, client_data);
    data.clear();
  }
  return retval;
}
 
void MyFrame::populate_item_list()
{
  item_list_ctrl->DeleteAllItems();
  const auto items = gui_app->filter_items_for_current_selected_category();
  wxVector<wxVariant> data;
  for (const shared_ptr<Item>& item : items) {
    wxUIntPtr client_data = item->get_id();
    data.push_back(wxVariant(wxString::FromUTF8(item->get_name())));
    data.push_back(wxVariant(item->is_checked()));
    item_list_ctrl->AppendItem(data, client_data);
    data.clear();
  }
  update_edit_menu();
}
 
void MyFrame::setup_rich_text_printing() {
  auto config = wxConfig::Get();
  const auto old_path = config->GetPath();
  config->SetPath("/reports/item-list");
  const auto title = config->Read("title", "Kitlist");
  config->SetPath(old_path);
  rich_text_printing = make_unique<wxRichTextPrinting>(title, this);
  rich_text_printing->SetHeaderText("@TITLE@", wxRICHTEXT_PAGE_ALL, wxRICHTEXT_PAGE_CENTRE);
  rich_text_printing->SetFooterText("- @PAGENUM@ / @PAGESCNT@ -", wxRICHTEXT_PAGE_ALL, wxRICHTEXT_PAGE_CENTRE);
  rich_text_printing->SetParentWindow(this);
}
 
void MyFrame::OnPrint(wxCommandEvent& WXUNUSED(event))
{
  if (!rich_text_printing)
    setup_rich_text_printing();
  wxRichTextBuffer buf;
  FillBuffer(buf);
  rich_text_printing->PrintBuffer(buf);
}
 
void MyFrame::OnPrintPreview(wxCommandEvent& WXUNUSED(event))
{
  if (!rich_text_printing)
    setup_rich_text_printing();
  wxRichTextBuffer buf;
  FillBuffer(buf);
  rich_text_printing->PreviewBuffer(buf);
}
 
void MyFrame::FillBuffer(wxRichTextBuffer& buf) const
{
  const auto items = gui_app->filter_items_for_current_selected_category();
  buf.BeginParagraphSpacing(10, 10);
  for (const shared_ptr<Item>& item : items)
    buf.AddParagraph(wxString::FromUTF8(item->get_name()));
}
 
void KitListGui::category_entry_changed(const shared_ptr<Category> category)
{
  if (my_frame) {
    if (category) {
      const auto row = my_frame->populate_category_list(category->get_id());
      my_frame->category_list_ctrl->SelectRow(row);
    } else {
      my_frame->populate_category_list();
    }
  }
}
 
void KitListGui::item_entry_changed(const shared_ptr<Item> WXUNUSED(item))
{
  if (my_frame)
    my_frame->populate_item_list();
}
 
void KitListGui::load_file(const std::string& filename)
{
  if (!wxFileExists(filename)) {
    throw file_not_found("File not found: " + filename);
  }
  KitListBaseApp::load_file(filename);
}
 
void KitListGui::update_menu_state(bool is_dirty)
{
  my_frame->update_edit_menu();
  my_frame->update_file_menu(is_dirty);
}
 
void KitListGui::OnInitCmdLine(wxCmdLineParser& parser)
{
  wxApp::OnInitCmdLine(parser);
  // parser.AddUsageText("Usage:\n  kitlist [FILENAME]\n\n");
  // parser.AddSwitch("h", "help", "show this help, then exit");
  // parser.AddSwitch(nullptr, "verbose", "generate verbose log messages");
  parser.AddSwitch("v", "version", "shows the application's version and exits");
  parser.AddParam("FILENAME", wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL);
  #ifdef HAVE_FINALCUT
  parser.AddSwitch("t", "finalcut", "runs the application with FINAL CUT Text-based User Interface");
  #endif
  #ifdef HAVE_FTXUI
  parser.AddSwitch("x", "ftxui", "runs the application with FTXUI Text-based User Interface");
  #endif
}
 
bool KitListGui::OnCmdLineParsed(wxCmdLineParser& parser)
{
 
  if (parser.GetParamCount() > 0) {
    auto filename = parser.GetParam(0);
    // If the filename is set, we will load the file later
    set_filename(filename.ToStdString());
  }
  // Leave log level at default unless release build
#ifdef NDEBUG
  if (parser.Found("verbose")) {
    wxLog::SetLogLevel(wxLOG_Debug);
  } else {
    wxLog::SetLogLevel(wxLOG_Message);
  }
#endif // NDEBUG
  if (parser.Found("version")) {
    std::cout << PACKAGE_NAME << " version " << PACKAGE_VERSION << std::endl;
    return false;
  }
#ifdef HAVE_FINALCUT
  if (parser.Found("finalcut")) {
    fdsd::fc::KitListFinalcut finalcut;
    finalcut.run(argc, argv, get_filename());
    return false;
  }
#endif // HAVE_FINALCUT
#ifdef HAVE_FTXUI
  if (parser.Found("ftxui")) {
    fdsd::ftxui::KitListFtxui ftxui_app;
    string filename = get_filename();
    if (filename.empty()) {
      wxLogError("Specify an existing kitlist file when using the FTXUI interface.");
      return false;
    }
    ftxui_app.run(filename);
    return false;
  }
#endif // HAVE_FTXUI
  return wxApp::OnCmdLineParsed(parser);
}
 
bool KitListGui::OnInit()
{
  if (!wxApp::OnInit())
    return false;
 
  wxLOG_COMPONENT = "KitList";
  // Fails to compile on macOS aarch64 with GCC
#ifdef __clang__
  wxLog* logger = new wxLogStream(&cout);
  wxLog::SetActiveTarget(logger);
#else
#ifndef __APPLE__
  wxLog* logger = new wxLogStream(&cout);
  wxLog::SetActiveTarget(logger);
#else
  cerr << "Disabling logging as compiled with GCC on Apple aarch64\n";
  wxLog::EnableLogging(false);
#endif
#endif
 
#ifndef NDEBUG // Is a release build
  wxLogWarning("Assertions are enabled.  Configure with --disable-assertions to disable them.");
#endif
  SetVendorName("uk.co.fdsd.kitlist");
  SetAppName("kitlist-2");
  auto config = new wxConfig(GetAppName(), GetVendorName(), wxString{}, wxString{}, wxCONFIG_USE_LOCAL_FILE);
  // Cause reading with defaults from config file to update the file with the default.
  config->SetRecordDefaults();
  wxConfig::Set(config);
 
  my_frame = new MyFrame(this, wxPoint(100, 100));
  my_frame->Show();
  return true;
}
 
int KitListGui::OnExit()
{
  return wxApp::OnExit();
}
 
void MyFrame::OnShow(wxShowEvent& event)
{
  if (last_error && event.IsShown()) {
    CallAfter([&]{
      wxMessageBox(last_error->what(), "Error", wxICON_ERROR);
      last_error.reset();
    });
  }
}
 
// menu command handlers
 
void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
  wxAboutDialogInfo aboutInfo;
  aboutInfo.SetName("Kitlist");
  aboutInfo.SetVersion(PACKAGE_VERSION);
  aboutInfo.SetDescription("A list manager for maintaining kit lists");
  aboutInfo.SetCopyright("(C) 2008-2025");
  aboutInfo.SetWebSite("https://www.fdsd.co.uk/kitlist");
  aboutInfo.AddDeveloper("Frank Dean <frank.dean@fdsd.co.uk>");
  wxAboutBox(aboutInfo);
}
 
void MyFrame::OnNewFile(wxCommandEvent& WXUNUSED(event))
{
  SetStatusText("");
  if (gui_app->is_dirty()) {
    if (wxMessageBox("Kitlist has not been saved!  Continue?", "Please confirm",
                     wxICON_QUESTION | wxYES_NO | wxNO_DEFAULT | wxCANCEL, this) != wxYES)
      return;
  }
  gui_app->new_file();
  populate_category_list();
  populate_item_list();
}
 
void MyFrame::OnFileHistoryMenuItem(wxCommandEvent& event)
{
  SetStatusText("");
  if (gui_app->is_dirty()) {
    if (wxMessageBox("Kitlist has not been saved!  Continue?", "Please confirm",
                     wxICON_QUESTION | wxYES_NO | wxNO_DEFAULT | wxCANCEL, this) != wxYES)
      return;
  }
  do_open(file_history->GetHistoryFile(event.GetId() - wxID_FILE1));
}
 
void MyFrame::OnOpen(wxCommandEvent& WXUNUSED(event))
{
  SetStatusText("");
  if (gui_app->is_dirty()) {
    if (wxMessageBox("Kitlist has not been saved!  Continue?", "Please confirm",
                     wxICON_QUESTION | wxYES_NO | wxNO_DEFAULT | wxCANCEL, this) != wxYES)
      return;
  }
  wxFileDialog openFileDialog(
      this, "Open Kitlist file", "", "",
      "Kitlist files (*.kit)|*.kit|XML files (*.xml)|*.xml|All files|*",
      wxFD_OPEN | wxFD_FILE_MUST_EXIST | wxFD_CHANGE_DIR);
 
  if (openFileDialog.ShowModal() == wxID_CANCEL)
    return;
 
  do_open(openFileDialog.GetPath());
}
 
void MyFrame::do_open(wxString wx_path)
{
  try {
    const string path = wx_path.ToStdString();
    gui_app->load_file(path);
    file_history->AddFileToHistory(wx_path);
    file_menu->Enable(file_history_menu_item->GetId(), true);
    populate_category_list();
    populate_item_list();
  } catch (const KitListGui::file_not_found& e) {
    wxLogError("File not found: %s", wx_path);
    wxMessageDialog dlg(this, wxString(e.what()), "File not found", wxICON_ERROR);
    dlg.ShowModal();
  } catch (const KitParser::parse_exception& e) {
    wxLogError("Failure loading \"%s\": %s", wx_path, wxString::FromUTF8(e.what()));
    wxMessageDialog dlg(this, wxString(e.what()), wxMessageBoxCaptionStr, wxICON_ERROR);
    dlg.ShowModal();
  }
}

void MyFrame::load_file(std::string filename)
{
  gui_app->load_file(filename);
}
 
void MyFrame::OnSave(wxCommandEvent& WXUNUSED(event))
{
  SetStatusText("");
  save();
}
 
void MyFrame::OnSaveAs(wxCommandEvent& WXUNUSED(event))
{
  SetStatusText("");
  wxFileDialog saveFileDialog(
      this, "Save Kitlist file", "", "",
      "Kitlist files (*.kit)|*.kit",
      wxFD_SAVE | wxFD_CHANGE_DIR | wxFD_OVERWRITE_PROMPT);
 
  if (saveFileDialog.ShowModal() == wxID_CANCEL)
    return;
 
  wxString wx_path = saveFileDialog.GetPath();
  if (!wx_path.ends_with(KitListBaseApp::DEFAULT_FILE_EXTENSION))
    wx_path.append(KitListBaseApp::DEFAULT_FILE_EXTENSION);
  // wxLogDebug("Chose file: \"%s\"", path);
 
  gui_app->set_filename(wx_path.ToStdString());
  save();
  file_history->AddFileToHistory(wx_path);
  file_menu->Enable(file_history_menu_item->GetId(), true);
}
 
void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event) )
{
  if (gui_app->is_dirty()) {
    if (wxMessageBox("Kitlist has not been saved!  Quit anyway?", "Please confirm",
                     wxICON_QUESTION | wxYES_NO | wxNO_DEFAULT| wxCANCEL, this) != wxYES)
      return;
  }
  auto config = wxConfig::Get();
  const auto old_path = config->GetPath();
  config->SetPath("/FileHistory");
  file_history->Save(*config);
  config->SetPath(old_path);
  Close(true);
}
 
void MyFrame::OnAddItem(wxCommandEvent& WXUNUSED(event))
{
  ItemDialog dlg(this, "New item");
  if (dlg.ShowModal() == wxID_CANCEL)
    return;
 
  const string name = dlg.get_name();
  if (name.empty())
    return;
 
  bool checked = dlg.is_checked();
  gui_app->new_item(name, checked);
  populate_item_list();
}
 
void MyFrame::OnAddCategory(wxCommandEvent& WXUNUSED(event))
{
  auto d = wxTextEntryDialog(this, "Category name", "New Category");
  if (d.ShowModal() == wxID_CANCEL)
    return;
  const string name = d.GetValue().ToStdString();
  if (name.empty())
    return;
  auto cat_id = gui_app->new_category(name);
  gui_app->select_category(cat_id);
  const auto row = populate_category_list(cat_id);
  populate_item_list();
  category_list_ctrl->SelectRow(row);
}
 
void MyFrame::save()
{
  bool result = gui_app->save();
  if (result) {
    SetStatusText("Saved");
  } else {
    SetStatusText("Save failed");
  }
}
 
void MyFrame::update_file_menu(bool is_dirty)
{
  if (!file_menu)
    return;
  file_menu->Enable(SAVE, is_dirty && !gui_app->get_filename().empty());
}
 
void MyFrame::update_edit_menu()
{
  if (!edit_menu)
    return;
  const bool have_selected_items = item_list_ctrl->HasSelection();
  const auto visible_item_count = item_list_ctrl->GetItemCount();
  const bool have_visible_items = visible_item_count != 0;
  const bool have_checked_items = gui_app->get_current_checked_item_count();
  const bool is_category_selected = gui_app->get_selected_category() != Model::no_category;
  edit_menu->Enable(SELECT_ALL_ITEMS, have_visible_items);
  edit_menu->Enable(UNSELECT_ALL_ITEMS, have_visible_items && have_selected_items);
  edit_menu->Enable(CHECK_ALL, have_visible_items);
  edit_menu->Enable(UNCHECK_ALL, have_visible_items);
  edit_menu->Enable(TOGGLE_ALL, have_visible_items);
  edit_menu->Enable(COPY_CHECKED_TO_CATEGORIES, have_checked_items);
 
  edit_menu->Enable(CHECK_SELECTED, have_selected_items);
  edit_menu->Enable(UNCHECK_SELECTED, have_selected_items);
  edit_menu->Enable(TOGGLE_SELECTED, have_selected_items);
  edit_menu->Enable(REMOVE_SELECTED_ITEMS,
                    have_selected_items &&
                    is_category_selected);
  edit_menu->Enable(REMOVE_CHECKED_ITEMS,
                    have_visible_items &&
                    is_category_selected);
  edit_menu->Enable(DELETE_CHECKED_ITEMS,
                    have_visible_items &&
                    !is_category_selected);
  edit_menu->Enable(COPY_SELECTED_ITEMS_TO_CATEGORIES, have_selected_items);
}
 
// ----------------------------------------------------------------------------
//  ItemDialog
// ----------------------------------------------------------------------------
 
ItemDialog::ItemDialog(wxWindow* parent, const wxString& title)
  : wxDialog(parent, wxID_ANY, title,
             wxDefaultPosition, wxDefaultSize,
             wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER),
    checkbox_ctrl(),
    name_ctrl() {
 
  wxBoxSizer* main_sizer = new wxBoxSizer(wxVERTICAL);
  wxBoxSizer* item_options_sizer = new wxBoxSizer(wxHORIZONTAL);
  checkbox_ctrl = new wxCheckBox(this, wxID_ANY, "Checked",
                                wxDefaultPosition, wxDefaultSize,
                                wxCHK_2STATE | wxALIGN_RIGHT);
  item_options_sizer->Add(checkbox_ctrl,
                          wxSizerFlags().Border().Center());
  item_options_sizer->Add(new wxStaticText(this, wxID_ANY, "Item name"),
                          wxSizerFlags().Border().Center());
  name_ctrl = new wxTextCtrl(this, wxID_ANY);
  auto min_size = name_ctrl->GetMinSize();
  min_size.SetWidth(180);
  name_ctrl->SetMinSize(min_size);
  item_options_sizer->Add(name_ctrl, wxSizerFlags().Proportion(1).Center());
  main_sizer->Add(item_options_sizer, wxSizerFlags().DoubleBorder().Expand().Proportion(1));
  wxSizer* button_sizer = CreateSeparatedButtonSizer( wxOK|wxCANCEL );
  main_sizer->Add(button_sizer, wxSizerFlags().Border().Expand());
  SetSizerAndFit( main_sizer );
  Center();
}