kitlist_finalcut.hpp

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/>.
 
*/
#ifndef FINALCUT_HPP
#define FINALCUT_HPP
 
#include "kitlist_base_app.hpp"
#include <final/final.h>
#include <memory>
#include <vector>

namespace fdsd
{
namespace fc
{
 
enum user_events {
  refresh_categories = 0,
  refresh_items = 1,
};

class KitListFinalcut : public KitListBaseApp {
 
public:
  KitListFinalcut() : KitListBaseApp() {}

  int run(int argc, char* argv[], const std::string filename);
 
};
 
class KitListWindow;

class CategoryListDialog final : public finalcut::FDialog {
 
  friend class KitListWindow;
 
public:
  explicit CategoryListDialog(finalcut::FWidget* parent, KitListBaseApp* base_app);
  finalcut::FString getClassName() const override { return "CategoryListDialog"; }
  int32_t get_current_category_id();
  std::shared_ptr<Category> get_current_category();
  bool is_categories() {
    return (category_list != nullptr && category_list->getCount() > 0);
  }
 
protected:
  void populate_category_list();
  virtual void onFocusIn (finalcut::FFocusEvent* ev) override;
 
private:
  KitListBaseApp* base_app;
  finalcut::FListBox* category_list = new finalcut::FListBox{this};
  void adjustSize() override;
  void initLayout() override;
  void show_current_item_category();
  void create_item_list_view(int32_t category_id);
};

class ItemListDialog final : public finalcut::FDialog {
 
  friend class KitListWindow;
 
public:
  explicit ItemListDialog(finalcut::FWidget* parent, KitListBaseApp* base_app,
                        int32_t category_id);
  finalcut::FString getClassName() const override { return "ItemListDialog"; }
  int32_t get_category_id() const { return category_id; }
  bool delete_current_item();
  void remove_current_item();
  bool is_items() {
    return item_list_view.getCount() > 0;
  }
 
protected:
  void populate_item_list();
  void refresh_item_check_status(std::shared_ptr<Item> item);
  virtual void onFocusIn (finalcut::FFocusEvent* ev) override;
 
private:
  KitListBaseApp* base_app;
  int32_t category_id;
  finalcut::FListView item_list_view{this};
  void adjustSize() override;
  void initLayout() override;
};

class CategoryDialog final : public finalcut::FDialog {
public:
  explicit CategoryDialog(finalcut::FWidget* parent,
                      KitListBaseApp* base_app,
                      int32_t category_id);
  finalcut::FString getClassName() const override { return "CategoryDialog"; }
  bool is_cancelled() { return cancelled; }
  finalcut::FString get_name() { return input_name.getText(); }
  void set_name(finalcut::FString name) { input_name.setText(name); }
private:
  KitListBaseApp* base_app;
  int32_t category_id;
  finalcut::FLineEdit input_name{this};
  finalcut::FButton btn_cancel{this};
  finalcut::FButton btn_ok{this};
  std::shared_ptr<Category> category = nullptr;
  bool cancelled = true;
  void adjustSize() override;
  void initLayout() override;
};

class ItemDialog final : public finalcut::FDialog {
public:
  explicit ItemDialog(finalcut::FWidget* parent,
                      KitListBaseApp* base_app,
                      int32_t item_id);
  finalcut::FString getClassName() const override { return "ItemDialog"; }
  bool is_cancelled() { return cancelled; }
  finalcut::FString get_name() { return input_name.getText(); }
  void set_name(finalcut::FString name) { input_name.setText(name); }
  bool is_checked() { return checkbox.isChecked(); }
  void set_checked(bool checked) { checkbox.setChecked(checked); }
private:
  KitListBaseApp* base_app;
  int32_t item_id;
  finalcut::FLineEdit input_name{this};
  finalcut::FCheckBox checkbox{"Chec&ked", this};
  finalcut::FButton btn_cancel{this};
  finalcut::FButton btn_ok{this};
  std::shared_ptr<Item> item = nullptr;
  bool cancelled = true;
  void adjustSize() override;
  void initLayout() override;
};

class SelectCategoriesDialog final : public finalcut::FDialog {
 
public:
  explicit SelectCategoriesDialog(finalcut::FWidget* parent,
                                  KitListBaseApp* base_app);
  finalcut::FString getClassName() const override { return "ItemDialog"; }
  void populate_select_category_list();
  std::vector<int32_t> get_selected_category_ids();
 
private:
  KitListBaseApp* base_app;
  finalcut::FListBox* category_list = new finalcut::FListBox{this};
  void adjustSize() override;
  void initLayout() override;
  finalcut::FButton btn_cancel{this};
  finalcut::FButton btn_ok{this};
};

class KitListWindow final : public finalcut::FWidget {
 
  friend class CategoryListDialog;
  friend class ItemListDialog;
 
public:

  explicit KitListWindow(finalcut::FWidget* parent, KitListBaseApp* base_app);
 
  finalcut::FString getClassName() const override { return "KitListWindow"; }
 
  void onClose (finalcut::FCloseEvent*) override;
 
  bool confirm_delete(std::shared_ptr<Category> category);
 
  void update_menus();
 
protected:
    void close_item_windows();
 
private:
 
  KitListBaseApp* base_app;
 
  finalcut::FMenuBar menu_bar{this};

  struct KitListMenu {
    explicit KitListMenu(finalcut::FMenuBar& menu_bar);
    finalcut::FMenu file_menu;
    finalcut::FMenuItem file_new;
    finalcut::FMenuItem file_open;
    finalcut::FMenuItem file_save;
    finalcut::FMenuItem file_save_as;
    finalcut::FMenuItem separator1;
    finalcut::FMenuItem file_quit;
 
    finalcut::FMenu edit_menu;
    finalcut::FMenuItem new_item;
    finalcut::FMenuItem edit_item;
    finalcut::FMenuItem new_category;
    finalcut::FMenuItem edit_category;
    finalcut::FMenuItem separator3;
    finalcut::FMenuItem delete_item;
    finalcut::FMenuItem remove_item;
    finalcut::FMenuItem delete_category;
    finalcut::FMenuItem separator4;
    finalcut::FMenuItem remove_checked_items;
    finalcut::FMenuItem delete_checked_items;
    finalcut::FMenuItem separator5;
    finalcut::FMenuItem check_items;
    finalcut::FMenuItem uncheck_items;
    finalcut::FMenuItem toggle_items;
    finalcut::FMenuItem separator6;
    finalcut::FMenuItem copy_item;
    finalcut::FMenuItem copy_checked_items;
 
    finalcut::FMenu view_menu;
    finalcut::FMenuItem view_category_list;
    finalcut::FMenuItem view_all_items_list;
    finalcut::FMenuItem separator2;
    finalcut::FRadioMenuItem view_checked_unchecked;
    finalcut::FRadioMenuItem view_checked;
    finalcut::FRadioMenuItem view_unchecked;
  };
 
  KitListMenu main_menu{menu_bar};
  finalcut::FDialogListMenu window{"&Window", &menu_bar};
 
  finalcut::FStatusBar status_bar{this};
  void refresh_category_dialog();
  void remove_item_list_dialog(int32_t removed_category);
  void refresh_item_dialogs(std::shared_ptr<Item> item);
  void refresh_item_dialogs();
  void configure_file_menu();
  void configure_edit_menu();
  void configure_view_menu();
  void configure_window_menu();
  void adjustSize() override;
  void initLayout() override {
    // setResizeable();
    setGeometry(finalcut::FPoint{5, 3}, finalcut::FSize{40, 15});
    setMinimumSize(finalcut::FSize{25, 9});
    FWidget::initLayout();
  };
  void on_new_file();
  void on_open_file();
  void on_save_file();
  void on_save_file_as();
  void on_new_item();
  void on_edit_item();
  void on_new_category();
  void on_edit_category();
  void on_delete_item();
  void on_remove_item();
  void on_delete_category();
  void on_remove_checked_items();
  void on_delete_checked_items();
  void on_check_items();
  void on_uncheck_items();
  void on_toggle_items();
  void on_copy_item();
  void on_copy_checked_items();
  void on_view_category_list();
  void on_view_all_items_list();
  void on_view_checked_unchecked();
  void on_view_checked();
  void on_view_unchecked();
  static void bring_to_front(finalcut::FWindow* window);
  CategoryListDialog* get_category_dialog();
  ItemListDialog* get_item_dialog_for_category_id(int32_t category_id);
  void update_checked_filter_state(Model::state_filter state);
  std::vector<std::shared_ptr<Category>> get_categories() {
    return base_app->get_categories();
  }
  void copy_current_item_and_select_target_categories();
  void copy_checked_item_and_select_target_categories();
  void onUserEvent(finalcut::FUserEvent* ev) override;
};
 
} // namespace fc
} // namespace fdsd
 
#endif // FINALCUT_HPP