kitlist_finalcut.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 "kitlist_finalcut.hpp"
#include "kitparser.hpp"
#include "config.h"
#include <final/final.h>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
 
using namespace finalcut;
using namespace std;
using namespace fdsd::fc;
 
CategoryListDialog::CategoryListDialog(finalcut::FWidget* parent, KitListBaseApp* base_app)
  : FDialog{parent}, base_app(base_app)
{
  setText("Categories");
}
 
void CategoryListDialog::adjustSize()
{
  const auto w = getWidth();
  const auto h = getHeight();
  category_list->setGeometry(FPoint{2, 3}, FSize{w - 2, h - 3});
  FDialog::adjustSize();
}
 
void CategoryListDialog::initLayout()
{
  const auto w = getDesktopWidth() / 2 - 15;
  const auto h = getDesktopHeight() - 4;
  populate_category_list();
  category_list->ignorePadding();
  setResizeable();
  setGeometry(FPoint{2, 2}, FSize{w, h - 1});
  setMinimumSize(FSize{20, 12});
  FDialog::initLayout();
  const bool focus_result = category_list->setFocus(true);
  assert(focus_result);
}
 
void CategoryListDialog::populate_category_list()
{
  if (category_list->getCount() != 0) {
    category_list->delCallback("clicked");
    category_list->delCallback("row-selected");
    category_list->clear();
  }
  const auto cats = base_app->get_categories();
  for (const auto& cat : cats) {
    FListBoxItem lbi{cat->name, cat->get_id()};
    category_list->insert(lbi);
  }
  category_list->addCallback(
      "clicked",
      this,
      [&] {
        show_current_item_category();
      });
  // row-selected seems to only be called when using mouse
  category_list->addCallback(
      "row-selected",
      this,
      [&] {
        show_current_item_category();
      });
  redraw();
}
 
void CategoryListDialog::onFocusIn (finalcut::FFocusEvent* ev)
{
  auto parent = getParent();
  assert(parent->getClassName() == "KitListWindow");
  if (parent->getClassName() == "KitListWindow")
    static_cast<KitListWindow*>(parent)->update_menus();
}
 
void CategoryListDialog::show_current_item_category()
{
  const auto p = category_list->currentItem();
  const FListBoxItem& i = category_list->getItem(p);
  const auto category_id = i.getData<int32_t>();
  auto parent = getParentWidget();
  assert(parent);
  auto klw = static_cast<KitListWindow*>(parent);
  auto list = klw->get_item_dialog_for_category_id(category_id);
  if (list) {
    KitListWindow::bring_to_front(list);
  } else {
    create_item_list_view(category_id);
  }
  klw->update_menus();
}
 
void CategoryListDialog::create_item_list_view(int32_t category_id)
{
  auto d = new ItemListDialog{getParentWidget(), base_app, category_id};
  d->show();
}
 
int32_t CategoryListDialog::get_current_category_id()
{
  const auto p = category_list->currentItem();
  const FListBoxItem& i = category_list->getItem(p);
  const auto category_id = i.getData<int32_t>();
  return category_id;
}
 
shared_ptr<Category> CategoryListDialog::get_current_category()
{
  return base_app->get_category(get_current_category_id());
}
 
ItemListDialog::ItemListDialog(finalcut::FWidget* parent, KitListBaseApp* base_app,
                           int32_t category_id)
  : FDialog{parent}, base_app(base_app), category_id(category_id)
{
  if (category_id == Model::no_category) {
    setText("All Items");
  } else {
    const auto category = base_app->get_category(category_id);
    assert(category);
    if (category) {
      setText(category->get_name());
    }
  }
  item_list_view.addColumn("Item");
  item_list_view.setColumnSortType (1, finalcut::SortType::Name);
  // item_list_view.addCallback("clicked", this, [=]{
  // });
  populate_item_list();
}
 
void ItemListDialog::populate_item_list()
{
  base_app->select_category(category_id);
  auto items = base_app->filter_items_for_current_selected_category();
  item_list_view.delCallback("changed");
  item_list_view.clear();
  for (const auto& i : items) {
    FStringList str_list{};
    const FString name{i->name};
    str_list.push_back(name);
    auto iter = item_list_view.insert(str_list);
    auto item = static_cast<finalcut::FListViewItem*>(*iter);
    item->setData(i->get_id());
    item->setChecked(i->is_checked());
    item->setCheckable(true);
  }
  // Relies on modifying `flistview.h` to call `processChanged()` in
  // `FListView::toggleItemCheckState`, otherwise we do not get a
  // notification of the checkbox state change.
  item_list_view.addCallback(
      "changed",
      this,
      [&] {
        const FListViewItem* p = item_list_view.getCurrentItem();
        assert(p);
        const int32_t item_id = p->getData<int32_t>();
        shared_ptr<Item> item =
          base_app->set_item_checked(item_id, p->isChecked());
        assert(item);
        if (item) {
          auto parent = getParentWidget();
          assert(parent);
          static_cast<KitListWindow*>(parent)->refresh_item_dialogs(item);
        }
      });
  redraw();
}
 
void ItemListDialog::refresh_item_check_status(std::shared_ptr<Item> item)
{
  auto items = item_list_view.getData();
  const auto id = item->get_id();
  bool changed = false;
  for (auto i : items) {
    if (i->getData<int32_t>() == id && i->isChecked() != item->is_checked()) {
      changed = true;
      i->setChecked(item->is_checked());
    }
  }
  if (changed)
    redraw();
}
 
void ItemListDialog::onFocusIn (finalcut::FFocusEvent* ev)
{
  base_app->select_category(category_id);
  finalcut::FDialog::onFocusIn(ev);
  auto parent = getParent();
  assert(parent->getClassName() == "KitListWindow");
  if (parent->getClassName() == "KitListWindow")
    static_cast<KitListWindow*>(parent)->update_menus();
}
 
bool ItemListDialog::delete_current_item()
{
  if (category_id != Model::no_category)
    return false;
  const auto p = item_list_view.getCurrentItem();
  const auto item_id = p->getData<int32_t>();
  auto item = base_app->get_item(item_id);
  if (!item)
    return false;
 
  FMessageBox mb{"Delete Item",
    "Are you sure you want to delete the \"" + item->get_name() + "\" item?",
    FMessageBox::ButtonType::Cancel,
    FMessageBox::ButtonType::Yes,
    FMessageBox::ButtonType::No,
    this};
  auto result = mb.exec();
  if (result != FMessageBox::ButtonType::Yes)
    return false;
  base_app->delete_item(item_id);
  return true;
}
 
void ItemListDialog::remove_current_item()
{
  if (category_id == Model::no_category)
    return;
  const auto p = item_list_view.getCurrentItem();
  const auto item_id = p->getData<int32_t>();
  auto item = base_app->get_item(item_id);
  if (!item)
    return;
 
  FMessageBox mb{"Remove Item",
    "Are you sure you want to remove the \"" + item->get_name() + "\" item?",
    FMessageBox::ButtonType::Cancel,
    FMessageBox::ButtonType::Yes,
    FMessageBox::ButtonType::No,
    this};
  auto result = mb.exec();
  if (result != FMessageBox::ButtonType::Yes)
    return;
 
  base_app->select_category(category_id);
  base_app->remove_item(item_id);
  populate_item_list();
}
 
void ItemListDialog::adjustSize()
{
  auto w = getWidth();
  auto h = getHeight();
  item_list_view.setGeometry(FPoint{2, 3}, FSize{w - 2, h - 3});
  FDialog::adjustSize();
}
 
void ItemListDialog::initLayout()
{
  const auto left = getDesktopWidth() / 2 - 10;
  const auto w = getDesktopWidth() / 2 + 8;
  const auto h = getDesktopHeight() - 4;
  item_list_view.ignorePadding();
  setResizeable();
  setGeometry(FPoint{static_cast<int>(left), 2}, FSize{w, h - 1});
  setMinimumSize(FSize{20, 12});
  FDialog::initLayout();
  const bool focus_result = item_list_view.setFocus(true);
  assert(focus_result);
};
 
CategoryDialog::CategoryDialog(finalcut::FWidget* parent,
                       KitListBaseApp* base_app,
                       int32_t category_id)
  : FDialog(parent),
    base_app(base_app),
    category_id(category_id)
{
  if (this->category_id >=0 ) {
    category = this->base_app->get_category(category_id);
    input_name.setText(category->get_name());
  }
  input_name.setLabelText("Category &name");
  btn_ok.setText("&Ok");
  btn_ok.addCallback(
      "clicked",
      this,
      [&] {
        cancelled = false;
        hide();
      });
  btn_cancel.setText("&Cancel");
  btn_cancel.addCallback(
      "clicked",
      this,
      [&] {
        cancelled = true;
        hide();
      });
}
 
void CategoryDialog::initLayout()
{
  setResizeable();
  const auto w = getDesktopWidth();
  setGeometry(finalcut::FPoint{4, 2}, FSize{w - 6 , 11});
  setMinimumSize(finalcut::FSize{30, 10});
  btn_cancel.setGeometry(FPoint{17, 5}, FSize{8, 1});
  btn_ok.setGeometry(FPoint{33, 5}, FSize{8, 1});
  FDialog::initLayout();
}
 
void CategoryDialog::adjustSize()
{
  const auto dw = getWidth() - 22;
  input_name.setGeometry(FPoint{17, 2}, FSize{dw, 1});
  FDialog::adjustSize();
}
 
ItemDialog::ItemDialog(finalcut::FWidget* parent,
                       KitListBaseApp* base_app,
                       int32_t item_id)
  : FDialog(parent),
    base_app(base_app),
    item_id(item_id)
{
  if (this->item_id >=0 ) {
    item = this->base_app->get_item(item_id);
    checkbox.setChecked(item->is_checked());
    input_name.setText(item->get_name());
  }
  input_name.setLabelText("Item &name");
  btn_ok.setText("&Ok");
  btn_ok.addCallback(
      "clicked",
      this,
      [&] {
        cancelled = false;
        hide();
      });
  btn_cancel.setText("&Cancel");
  btn_cancel.addCallback(
      "clicked",
      this,
      [&] {
        cancelled = true;
        hide();
      });
}
 
void ItemDialog::initLayout()
{
  setResizeable();
  const auto w = getDesktopWidth();
  setGeometry(finalcut::FPoint{4, 2}, FSize{w - 6 , 11});
  setMinimumSize(finalcut::FSize{30, 12});
  checkbox.setGeometry(FPoint{17, 5}, FSize{22, 1});
  btn_cancel.setGeometry(FPoint{17, 7}, FSize{8, 1});
  btn_ok.setGeometry(FPoint{33, 7}, FSize{8, 1});
  FDialog::initLayout();
}
 
void ItemDialog::adjustSize()
{
  const auto dw = getWidth() - 22;
  input_name.setGeometry(FPoint{17, 2}, FSize{dw, 1});
  FDialog::adjustSize();
}
 
SelectCategoriesDialog::SelectCategoriesDialog(finalcut::FWidget* parent,
                                               KitListBaseApp* base_app)
  : FDialog{parent}, base_app(base_app)
{
  setText("Select Categories");
  btn_ok.setText("&Ok");
  btn_ok.addCallback(
      "clicked",
      this,
      [&] {
        done(ResultCode::Accept);
      });
  btn_cancel.setText("&Cancel");
  btn_cancel.addCallback(
      "clicked",
      this,
      [&] { 
        done(ResultCode::Reject);
      });
}
 
void SelectCategoriesDialog::initLayout()
{
  category_list->setMultiSelection(true);
  const auto w = getDesktopWidth();
  const auto vertical_middle = w / 2;
  const auto h = getDesktopHeight();
  populate_select_category_list();
  category_list->ignorePadding();
  category_list->setStatusbarMessage("Use spacebar to select categories");
  setResizeable();
  setGeometry(FPoint{static_cast<int>(vertical_middle) - 15, 4},
              FSize{30, h - 8});
  setMinimumSize(FSize{28, 12});
  FDialog::initLayout();
  const bool focus_result = category_list->setFocus(true);
  assert(focus_result);
}
 
void SelectCategoriesDialog::adjustSize()
{
  const auto w = getWidth();
  const auto h = getHeight();
  const auto vertical_middle = w / 2;
  category_list->setGeometry(FPoint{2, 3}, FSize{w - 2, h - 5});
  btn_cancel.setGeometry(FPoint{static_cast<int>(vertical_middle) - 10,
      static_cast<int>(h) - 4}, FSize{8, 1});
  btn_ok.setGeometry(FPoint{static_cast<int>(vertical_middle) + 4,
      static_cast<int>(h) - 4}, FSize{8, 1});
  FDialog::adjustSize();
}
 
void SelectCategoriesDialog::populate_select_category_list()
{
  const auto cats = base_app->get_categories();
  for (const auto& cat : cats) {
    FListBoxItem lbi{cat->name, cat->get_id()};
    category_list->insert(lbi);
  }
  redraw();
}
 
vector<int32_t> SelectCategoriesDialog::get_selected_category_ids()
{
  vector<int32_t> retval{};
  const auto list_box_items = category_list->getData();
  for (const auto& i : list_box_items) {
    if (i.isSelected()) {
      const auto category_id = i.getData<int32_t>();
      retval.push_back(category_id);
    }
  }
  return retval;
}
 
 
int KitListFinalcut::run(int argc, char* argv[], const string filename)
{
  FApplication app{argc, argv};
  if (!filename.empty()) {
    try {
      load_file(filename);
    } catch (const KitListBaseApp::file_not_found& e) {
      cerr << "File not found: \"" << filename << "\" - " << e.what() << '\n';
      app.exit(EXIT_FAILURE); // app.isQuit() will now return true
    } catch (const KitParser::parse_exception& e) {
      cerr << "Error parsing file: \"" << filename << "\" - " << e.what() << '\n';
      app.exit(EXIT_FAILURE);// app.isQuit() will now return true
    }
  }
  // Will exit app if isQuit() is true
  if (app.isQuit())
    return app.exec();
 
  // Cannot put main_window inside `if (!app.isQuit()` as it is destroyed when
  // it loses scope, before running app.exec()
  KitListWindow main_window{&app, this};
  FWidget::setMainWidget(&main_window);
  main_window.show();
  return app.exec();
}
 
KitListWindow::KitListWindow(finalcut::FWidget* parent, KitListBaseApp* base_app)
  : FWidget{parent}, base_app{base_app}
{
  // Message shown on the status bar when the 'File' menu option is active
  main_menu.file_menu.setStatusbarMessage("File commands");
 
  configure_file_menu();
  configure_edit_menu();
  configure_view_menu();
  configure_window_menu();
  update_menus();
  // setText(PACKAGE_NAME);
}
 
void KitListWindow::refresh_category_dialog()
{
  auto d = get_category_dialog();
  if (d)
    d->populate_category_list();
  update_menus();
}
 
void KitListWindow::remove_item_list_dialog(int32_t removed_category)
{
  auto id = get_item_dialog_for_category_id(removed_category);
  if (id)
    id->close();
  refresh_category_dialog();
}
 
void KitListWindow::refresh_item_dialogs(std::shared_ptr<Item> item)
{
  for (const auto& child : getChildren()) {
    const auto class_name = child->getClassName();
    if (class_name == "ItemListDialog") {
      ItemListDialog* d = static_cast<ItemListDialog*>(child);
      d->refresh_item_check_status(item);
    }
  }
  update_menus();
}
 
void KitListWindow::close_item_windows()
{
  for (const auto& child : getChildren()) {
    const auto class_name = child->getClassName();
    if (class_name == "ItemListDialog") {
      ItemListDialog* d = static_cast<ItemListDialog*>(child);
      d->close();
    }
  }
  update_menus();
}
 
void KitListWindow::refresh_item_dialogs()
{
  for (const auto& child : getChildren()) {
    const auto class_name = child->getClassName();
    if (class_name == "ItemListDialog") {
      ItemListDialog* d = static_cast<ItemListDialog*>(child);
      d->populate_item_list();
    }
  }
  update_menus();
}
 
void KitListWindow::configure_file_menu()
{
  main_menu.file_new.addAccelerator(FKey::Ctrl_n);
  main_menu.file_new.setStatusbarMessage("Create a new kitlist");
 
  main_menu.file_open.addAccelerator(FKey::Ctrl_o);
  main_menu.file_open.setStatusbarMessage("Open another kitlist");
 
  main_menu.file_save.addAccelerator(FKey::Ctrl_s);
  main_menu.file_save.setStatusbarMessage("Saves the changes");
 
  main_menu.file_save.setStatusbarMessage("Saves the changes to a new file");
 
  main_menu.separator1.setSeparator();
 
  main_menu.file_quit.addAccelerator(FKey::Ctrl_q);
  main_menu.file_quit.setStatusbarMessage("Quit");
 
  main_menu.file_new.addCallback(
      "clicked",
      this,
      &KitListWindow::on_new_file
    );
 
  main_menu.file_open.addCallback(
      "clicked",
      this,
      &KitListWindow::on_open_file
    );
 
  main_menu.file_save.addCallback(
      "clicked",
      this,
      &KitListWindow::on_save_file
    );
 
  main_menu.file_save_as.addCallback(
      "clicked",
      this,
      &KitListWindow::on_save_file_as
    );
 
  main_menu.file_quit.addCallback(
      "clicked",
      getFApplication(),
      &FApplication::cb_exitApp,
      this);
}
 
void KitListWindow::configure_edit_menu()
{
  main_menu.new_item.setStatusbarMessage("Create a new item");
  main_menu.edit_item.setStatusbarMessage("Edit the selected item");
  main_menu.new_category.setStatusbarMessage("Create a new category");
  main_menu.edit_category.setStatusbarMessage("Rename the selected category");
 
  main_menu.separator3.setSeparator();
 
  main_menu.delete_item.setStatusbarMessage("Delete the currently selected item");
  main_menu.remove_item.setStatusbarMessage("Remove the currently selected item from the category");
  main_menu.delete_category.setStatusbarMessage("Delete the currently selected category");
 
  main_menu.separator4.setSeparator();
 
  main_menu.remove_checked_items.setStatusbarMessage("Remove the checked items from the category");
  main_menu.delete_checked_items.setStatusbarMessage("Permanently delete the checked items");
 
  main_menu.separator5.setSeparator();
 
  main_menu.check_items.setStatusbarMessage("Check the items");
  main_menu.uncheck_items.setStatusbarMessage("Uncheck the items");
  main_menu.toggle_items.setStatusbarMessage("Toggle the checked state of the items");
 
  main_menu.separator6.setSeparator();
 
  main_menu.copy_item.setStatusbarMessage("Copy the selected item to categories");
  main_menu.copy_checked_items.setStatusbarMessage("Copy the checked items to other categories");
 
  main_menu.new_item.addCallback(
      "clicked",
      this,
      &KitListWindow::on_new_item
    );
 
  main_menu.edit_item.addCallback(
      "clicked",
      this,
      &KitListWindow::on_edit_item
    );
 
  main_menu.new_category.addCallback(
      "clicked",
      this,
      &KitListWindow::on_new_category
    );
 
  main_menu.edit_category.addCallback(
      "clicked",
      this,
      &KitListWindow::on_edit_category
    );
 
  main_menu.delete_item.addCallback(
      "clicked",
      this,
      &KitListWindow::on_delete_item
    );
 
  main_menu.remove_item.addCallback(
      "clicked",
      this,
      &KitListWindow::on_remove_item
    );
 
  main_menu.delete_category.addCallback(
      "clicked",
      this,
      &KitListWindow::on_delete_category
    );
 
    main_menu.remove_checked_items.addCallback(
      "clicked",
      this,
      &KitListWindow::on_remove_checked_items
    );
 
    main_menu.delete_checked_items.addCallback(
      "clicked",
      this,
      &KitListWindow::on_delete_checked_items
    );
 
  main_menu.check_items.addCallback(
      "clicked",
      this,
      &KitListWindow::on_check_items
    );
 
  main_menu.uncheck_items.addCallback(
      "clicked",
      this,
      &KitListWindow::on_uncheck_items
    );
 
  main_menu.toggle_items.addCallback(
      "clicked",
      this,
      &KitListWindow::on_toggle_items
    );
 
  main_menu.copy_item.addCallback(
      "clicked",
      this,
      &KitListWindow::on_copy_item
    );
 
  main_menu.copy_checked_items.addCallback(
      "clicked",
      this,
      &KitListWindow::on_copy_checked_items
    );
 
}
void KitListWindow::configure_view_menu()
{
  main_menu.view_category_list.setStatusbarMessage("View list of categories…");
  main_menu.view_category_list.addAccelerator(FKey::Ctrl_e);
 
  main_menu.view_all_items_list.addAccelerator(FKey::Ctrl_b);
  main_menu.view_all_items_list.setStatusbarMessage("View list of all items");
 
  main_menu.separator2.setSeparator();
 
  main_menu.view_checked_unchecked.setStatusbarMessage("View both checked and unchecked items");
  main_menu.view_checked.setStatusbarMessage("View only checked items");
  main_menu.view_unchecked.setStatusbarMessage("View only unchecked items");
  update_checked_filter_state(base_app->get_filter());
 
  main_menu.view_category_list.addCallback(
      "clicked",
      this,
      &KitListWindow::on_view_category_list
    );
 
  main_menu.view_all_items_list.addCallback(
      "clicked",
      this,
      &KitListWindow::on_view_all_items_list
    );
 
  main_menu.view_checked_unchecked.addCallback(
      "clicked",
      this,
      &KitListWindow::on_view_checked_unchecked
    );
 
  main_menu.view_checked.addCallback(
      "clicked",
      this,
      &KitListWindow::on_view_checked
    );
 
  main_menu.view_unchecked.addCallback(
      "clicked",
      this,
      &KitListWindow::on_view_unchecked
    );
 
}
 
void KitListWindow::configure_window_menu()
{
  window.setStatusbarMessage ("List of active dialogs");
}
 
void KitListWindow::adjustSize()
{
  const int pw = getDesktopWidth();
  const int ph = getDesktopHeight();
  setX(1 + (pw - int(getWidth())) / 2, false);
  setY(1 + (ph - int(getHeight())) / 4, false);
  // setWidth(pw / 2);
  // setHeight(pw / 4);
  FWidget::adjustSize();
}
 
KitListWindow::KitListMenu::KitListMenu(FMenuBar& menu_bar)
  : file_menu("&File", &menu_bar),
    file_new("&New", &file_menu),
    file_open("&Open…", &file_menu),
    file_save("&Save", &file_menu),
    file_save_as("Save &As…", &file_menu),
    separator1(&file_menu),
    file_quit("&Quit", &file_menu),
 
    edit_menu("&Edit", &menu_bar),
    new_item("&New Item…", &edit_menu),
    edit_item("Edit &Item…", &edit_menu),
    new_category("Ne&w Category…", &edit_menu),
    edit_category("Rename &Category…", &edit_menu),
    separator3(&edit_menu),
    delete_item("&Delete Item", &edit_menu),
    remove_item("&Remove Item", &edit_menu),
    delete_category("Dele&te Category", &edit_menu),
    separator4(&edit_menu),
    remove_checked_items("Remo&ve Checked Items", &edit_menu),
    delete_checked_items("De&lete Checked Items", &edit_menu),
    separator5(&edit_menu),
    check_items("Chec&k Items", &edit_menu),
    uncheck_items("&Uncheck Items", &edit_menu),
    toggle_items("To&ggle Items", &edit_menu),
    separator6(&edit_menu),
    copy_item("C&opy Item", &edit_menu),
    copy_checked_items("Cop&y Checked Items", &edit_menu),
 
    view_menu("&View", &menu_bar),
    view_category_list("View &Categories", &view_menu),
    view_all_items_list("View All &Items", &view_menu),
    separator2(&view_menu),
    view_checked_unchecked("Show &All", &view_menu),
    view_checked("Show Chec&ked", &view_menu),
    view_unchecked("Show &Unchecked", &view_menu)
{
}
 
void KitListWindow::on_new_file()
{
  if (base_app->is_dirty()) {
    FMessageBox mb{"Unsaved Changes",
      "Changes not saved.  Are you sure you want to abandon your changes?",
      FMessageBox::ButtonType::Cancel,
      FMessageBox::ButtonType::Yes,
      FMessageBox::ButtonType::No,
      this};
    auto result = mb.exec();
    if (result != FMessageBox::ButtonType::Yes)
      return;
  }
  base_app->new_file();
  refresh_category_dialog();
  close_item_windows();
  auto d = new ItemListDialog{this, base_app, Model::no_category};
  d->show();
  auto cd = get_category_dialog();
  if (cd)  {
    KitListWindow::bring_to_front(get_category_dialog());
  } else {
    cd = new CategoryListDialog{this, base_app};
    cd->show();
  }
}
 
void KitListWindow::on_open_file()
{
  if (base_app->is_dirty()) {
    FMessageBox mb{"Unsaved Changes",
      "Changes not saved.  Are you sure you want to abandon your changes?",
      FMessageBox::ButtonType::Cancel,
      FMessageBox::ButtonType::Yes,
      FMessageBox::ButtonType::No,
      this};
    auto result = mb.exec();
    if (result != FMessageBox::ButtonType::Yes)
      return;
  }
  auto f = FFileDialog::fileOpenChooser(this, ".", "*.kit");
  if (f.isEmpty())
    return;
  try {
    base_app->load_file(f.toString());
  } catch (const KitListBaseApp::file_not_found& e) {
    FMessageBox mb{"Error",
      "The file was not found",
      FMessageBox::ButtonType::Ok,
      FMessageBox::ButtonType::Reject,
      FMessageBox::ButtonType::Reject,
      this};
    mb.exec();
    base_app->new_file();
  } catch (const KitParser::parse_exception& e) {
    FMessageBox mb{"Error",
      "Failed to parse file",
      FMessageBox::ButtonType::Ok,
      FMessageBox::ButtonType::Reject,
      FMessageBox::ButtonType::Reject,
      this};
    mb.exec();
    base_app->new_file();
  }
  refresh_category_dialog();
  close_item_windows();
  auto d = new ItemListDialog{this, base_app, Model::no_category};
  d->show();
  auto cd = get_category_dialog();
  if (cd)  {
    KitListWindow::bring_to_front(get_category_dialog());
  } else {
    cd = new CategoryListDialog{this, base_app};
    cd->show();
  }
}
 
void KitListWindow::on_save_file()
{
  if (base_app->get_filename().empty())
    on_save_file_as();
  if (base_app->save())
    status_bar.setMessage("File saved");
  else
    status_bar.setMessage("Save failed");
 
  status_bar.drawMessage();
  update_menus();
}
 
void KitListWindow::on_save_file_as()
{
  auto f = fileChooser(this, ".", "*.kit", FFileDialog::DialogType::Save);
  if (f.isEmpty())
    return;
 
  if (base_app->save(f.toString()))
    status_bar.setMessage("Saved file");
  else
    status_bar.setMessage("Failed to save file \"" + f + '"');
 
  status_bar.drawMessage();
  update_menus();
}
 
void KitListWindow::on_new_item()
{
  ItemDialog d{this, base_app, -1};
  d.setModal();
  d.show();
  if (d.is_cancelled())
    return;
 
  const auto item_name = d.get_name();
  if (item_name.isEmpty())
    return;
 
  base_app->new_item(item_name.toString(), d.is_checked());
  // Queue an event to refresh the item list, (which also updates menu items)
  // after the interface has been updated, otherwise any item lists will not
  // be on top when the menus are updated, resulting in relevant menu items
  // potentially remaining disabled.
  FUserEvent user_event(Event::User, refresh_items);
  FApplication::getApplicationObject()->queueEvent(getMainWidget(), &user_event);
}
 
void KitListWindow::on_edit_item()
{
  auto aw = getActiveWindow();
  if (aw->getClassName() != "ItemListDialog")
    return;
  auto ild = static_cast<ItemListDialog*>(aw);
 
  const auto p = ild->item_list_view.getCurrentItem();
  const auto item_id = p->getData<int32_t>();
  auto item = base_app->get_item(item_id);
  if (!item)
    return;
 
  ItemDialog d{this, base_app, item_id};
  d.set_name(item->get_name());
  d.set_checked(item->is_checked());
  d.setModal();
  d.show();
  if (d.is_cancelled())
    return;
 
  const auto item_name = d.get_name();
  if (item_name.isEmpty())
    return;
 
  base_app->set_item_name(item_id, item_name.toString());
  base_app->set_item_checked(item_id, d.is_checked());
  refresh_item_dialogs();
}
 
void KitListWindow::on_new_category()
{
  CategoryDialog d{this, base_app, -1};
  d.setModal();
  d.show();
  if (d.is_cancelled())
    return;
 
  const auto category_name = d.get_name();
  if (category_name.isEmpty())
    return;
 
  base_app->new_category(category_name.toString());
  // Queue an event to refresh the category list, (which also updates menu
  // items) after the interface has been updated, otherwise any item lists
  // will not be on top when the menus are updated, resulting in relevant menu
  // items potentially remaining disabled.
  FUserEvent user_event(Event::User, refresh_categories);
  FApplication::getApplicationObject()->queueEvent(getMainWidget(), &user_event);
}
 
void KitListWindow::on_edit_category()
{
  auto cd = get_category_dialog();
  if (!cd)
    return;
 
  shared_ptr<Category> category = cd->get_current_category();
  if (!category)
    return;
 
  CategoryDialog d{this, base_app, category->get_id()};
  d.set_name(category->get_name());
  d.setModal();
  d.show();
  if (d.is_cancelled())
    return;
 
  const auto category_name = d.get_name();
  if (category_name.isEmpty())
    return;
 
  ItemListDialog* list = get_item_dialog_for_category_id(category->get_id());
  if (list)
    list->setText(category_name);
  base_app->set_category_name(category->get_id(), category_name.toString());
  refresh_item_dialogs();
  refresh_category_dialog();
}
 
void KitListWindow::on_delete_item()
{
  auto aw = getActiveWindow();
  if (aw->getClassName() != "ItemListDialog")
    return;
  auto d = static_cast<ItemListDialog*>(aw);
  if (d->delete_current_item())
    refresh_item_dialogs();
}
 
void KitListWindow::on_remove_item()
{
  auto aw = getActiveWindow();
  if (aw->getClassName() != "ItemListDialog")
    return;
  auto d = static_cast<ItemListDialog*>(aw);
  d->remove_current_item();
  update_menus();
}
 
void KitListWindow::on_delete_category()
{
  auto cd = get_category_dialog();
  shared_ptr<Category> category = nullptr;
  if (cd && (category = cd->get_current_category())) {
    if (!confirm_delete(category))
      return;
    base_app->delete_category(category->get_id());
    remove_item_list_dialog(category->get_id());
  } else {
    auto aw = getActiveWindow();
    if (aw) {
      const auto class_name = aw->getClassName();
      if (class_name == "ItemListDialog") {
        const auto cid = static_cast<ItemListDialog*>(aw)->get_category_id();
        if (cid != Model::no_category) {
          category = base_app->get_category(cid);
          if (!category)
            return;
          if (!confirm_delete(category))
            return;
          base_app->delete_category(cid);
          remove_item_list_dialog(category->get_id());
        }
      }
    }
  }
}
 
void KitListWindow::on_remove_checked_items()
{
  auto aw = getActiveWindow();
  if (aw->getClassName() != "ItemListDialog")
    return;
  auto d = static_cast<ItemListDialog*>(aw);
  base_app->select_category(d->get_category_id());
  base_app->remove_all_current_checked_items();
  refresh_item_dialogs();
}
 
void KitListWindow::on_delete_checked_items()
{
  auto aw = getActiveWindow();
  if (aw->getClassName() != "ItemListDialog")
    return;
  auto d = static_cast<ItemListDialog*>(aw);
  base_app->select_category(d->get_category_id());
  base_app->delete_all_current_checked_items();
  refresh_item_dialogs();
}
 
void KitListWindow::on_check_items()
{
  auto aw = getActiveWindow();
  if (aw->getClassName() != "ItemListDialog")
    return;
  auto d = static_cast<ItemListDialog*>(aw);
  base_app->select_category(d->get_category_id());
  base_app->change_all_current_items_checked_states(Model::check_action::check);
  refresh_item_dialogs();
}
 
void KitListWindow::on_uncheck_items()
{
  auto aw = getActiveWindow();
  if (aw->getClassName() != "ItemListDialog")
    return;
  auto d = static_cast<ItemListDialog*>(aw);
  base_app->select_category(d->get_category_id());
  base_app->change_all_current_items_checked_states(Model::check_action::uncheck);
  refresh_item_dialogs();
}
 
void KitListWindow::on_toggle_items()
{
  auto aw = getActiveWindow();
  if (aw->getClassName() != "ItemListDialog")
    return;
  auto d = static_cast<ItemListDialog*>(aw);
  base_app->select_category(d->get_category_id());
  base_app->change_all_current_items_checked_states(Model::check_action::toggle);
  refresh_item_dialogs();
}
 
void KitListWindow::on_copy_item()
{
  auto aw = getActiveWindow();
  if (aw->getClassName() != "ItemListDialog")
    return;
  auto ild = static_cast<ItemListDialog*>(aw);
  auto cid = ild->get_category_id();
  base_app->select_category(cid);
 
  const auto p = ild->item_list_view.getCurrentItem();
  const auto item_id = p->getData<int32_t>();
 
  SelectCategoriesDialog scd(this, base_app);
  scd.setModal();
  auto result = scd.exec();
  if (result != FDialog::ResultCode::Accept)
    return;
  auto cids = scd.get_selected_category_ids();
  if (cids.empty())
    return;
  base_app->copy_item_to_categories(item_id, cids);
  refresh_item_dialogs();
}
 
void KitListWindow::on_copy_checked_items()
{
  auto aw = getActiveWindow();
  if (aw->getClassName() != "ItemListDialog")
    return;
  auto ild = static_cast<ItemListDialog*>(aw);
  auto cid = ild->get_category_id();
  base_app->select_category(cid);
  SelectCategoriesDialog scd(this, base_app);
  scd.setModal();
  auto result = scd.exec();
  if (result != FDialog::ResultCode::Accept)
    return;
  auto cids = scd.get_selected_category_ids();
  if (cids.empty())
    return;
  base_app->copy_checked_items_to_categories(cids);
  refresh_item_dialogs();
}
 
void KitListWindow::onClose(finalcut::FCloseEvent* ev)
{
  if (!base_app->is_dirty()) {
    ev->accept();
    return;
  }
  FMessageBox mb{"Unsaved Changes",
    "Changes not saved.  Are you sure you want to quit?",
    FMessageBox::ButtonType::Cancel,
    FMessageBox::ButtonType::Yes,
    FMessageBox::ButtonType::No,
    this};
  auto result = mb.exec();
  if (result == FMessageBox::ButtonType::Yes)
    ev->accept();
  else
    ev->ignore();
}
 
void KitListWindow::on_view_category_list()
{
  auto category_dialog = get_category_dialog();
  if (category_dialog) {
    KitListWindow::bring_to_front(category_dialog);
  } else {
    auto d = new CategoryListDialog{this, base_app};
    d->show();
  }
  update_menus();
}
 
void KitListWindow::on_view_all_items_list()
{
  auto list = get_item_dialog_for_category_id(Model::no_category);
  if (list) {
    KitListWindow::bring_to_front(list);
  } else {
    auto d = new ItemListDialog{this, base_app, Model::no_category};
    d->show();
  }
  update_menus();
}
 
void KitListWindow::on_view_checked_unchecked()
{
  update_checked_filter_state(Model::state_filter::all);
}
 
void KitListWindow::on_view_checked()
{
  update_checked_filter_state(Model::state_filter::checked);
}
 
void KitListWindow::on_view_unchecked()
{
  update_checked_filter_state(Model::state_filter::unchecked);
}
 
void KitListWindow::bring_to_front(FWindow* window)
{
  // This is how FMenuItem::cb_switchToDialog focuses the window.
  if (window->isMinimized())
    window->minimizeWindow();  // Acutally unminimizes window
  auto focus = getFocusWidget();
  FAccelEvent ev (Event::Accelerator, focus);
  FApplication::sendEvent (window, &ev);
}
 
bool KitListWindow::confirm_delete(shared_ptr<Category> category) {
  FMessageBox mb{"Delete Category",
    "Are you sure you want to delete the \"" + category->get_name() + "\" category?",
    FMessageBox::ButtonType::Cancel,
    FMessageBox::ButtonType::Yes,
    FMessageBox::ButtonType::No,
    this};
  auto result = mb.exec();
  return (result == FMessageBox::ButtonType::Yes);
}
 
CategoryListDialog* KitListWindow::get_category_dialog()
{
  for (const auto& child : getChildren())
    if (child->getClassName() == "CategoryListDialog")
      return static_cast<CategoryListDialog*>(child);
  return nullptr;
}
 
ItemListDialog* KitListWindow::get_item_dialog_for_category_id(int32_t category_id)
{
  for (const auto& child : getChildren()) {
    const auto class_name = child->getClassName();
    if (class_name == "ItemListDialog") {
      ItemListDialog* d = static_cast<ItemListDialog*>(child);
      if (d->get_category_id() == category_id)
        return d;
    }
  }
  return nullptr;
}
 
void KitListWindow::update_checked_filter_state(Model::state_filter state)
{
  base_app->set_filter(state);
  switch (state) {
  case Model::state_filter::all:
    main_menu.view_checked_unchecked.setChecked();
    main_menu.view_checked.unsetChecked();
    main_menu.view_unchecked.unsetChecked();
    break;
  case Model::state_filter::checked:
    main_menu.view_checked_unchecked.unsetChecked();
    main_menu.view_checked.setChecked();
    main_menu.view_unchecked.unsetChecked();
    break;
  case Model::state_filter::unchecked:
    main_menu.view_checked_unchecked.unsetChecked();
    main_menu.view_checked.unsetChecked();
    main_menu.view_unchecked.setChecked();
    break;
  }
  refresh_item_dialogs();
}
 
void KitListWindow::update_menus()
{
  const bool dirty = base_app->is_dirty();
  bool all_item_list_on_top = false;
  bool have_visible_items = false;
  bool have_visible_categories = false;
  bool item_list_on_top = false;
  bool category_list_on_top = false;
  auto aw = getActiveWindow();
  if (aw) {
    item_list_on_top = aw->getClassName() == "ItemListDialog";
    if (item_list_on_top) {
      auto ild = static_cast<ItemListDialog*>(aw);
      all_item_list_on_top = ild->get_category_id() == Model::no_category;
      have_visible_items = ild->is_items();
    }
    category_list_on_top = aw->getClassName() == "CategoryListDialog";
    if (category_list_on_top) {
      have_visible_categories = static_cast<CategoryListDialog*>(aw)->is_categories();
    }
  }
  
  main_menu.file_save.setEnable(dirty);
  main_menu.edit_item.setEnable(have_visible_items);
  main_menu.edit_category.setEnable(have_visible_categories || !all_item_list_on_top);
  main_menu.delete_item.setEnable(all_item_list_on_top && have_visible_items);
  main_menu.remove_item.setEnable(!all_item_list_on_top && have_visible_items);
  main_menu.delete_category.setEnable(!all_item_list_on_top || (category_list_on_top && have_visible_categories));
  main_menu.remove_checked_items.setEnable(!all_item_list_on_top && have_visible_items);
  main_menu.delete_checked_items.setEnable(all_item_list_on_top && have_visible_items);
  main_menu.check_items.setEnable(have_visible_items);
  main_menu.uncheck_items.setEnable(have_visible_items);
  main_menu.toggle_items.setEnable(have_visible_items);
  main_menu.copy_item.setEnable(have_visible_items);
  main_menu.copy_checked_items.setEnable(have_visible_items);
}
 
void KitListWindow::onUserEvent(FUserEvent* ev)
{
  // getUserId() returns the user_event_id we created the FUserEvent object with
  switch(ev->getUserId()) {
  case refresh_categories:
    refresh_category_dialog();
    break;
  case refresh_items:
    refresh_item_dialogs();
    break;
  }
}