kitlist_base_app.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 KITLIST_BASE_APP_HPP
#define KITLIST_BASE_APP_HPP
 
#include "model.hpp"
#include <iostream>
#include <memory>
#include <string>
#include <vector>

class KitListBaseApp {
 
  friend class Model;

  std::unique_ptr<Model> model;

  std::string filename;

  bool initialized;
 
protected:

  virtual void update_menu_state(bool is_dirty) {
    (void)is_dirty; // unused parameter
  }

  virtual void category_entry_changed(const std::shared_ptr<Category> category) {}

  virtual void item_entry_changed(const std::shared_ptr<Item> item) {}

  virtual void category_name_changed(const std::shared_ptr<Category> category) {
    sort_categories();
    category_entry_changed(category);
    update_menu_state(model->is_dirty());
  }

  virtual void item_name_changed(const std::shared_ptr<Item> item) {
    sort();
    item_entry_changed(item);
    update_menu_state(model->is_dirty());
  }

  virtual void item_checked_changed(const std::shared_ptr<Item> item) {
    if (get_filter() != Model::all)
      item_entry_changed(item);
    update_menu_state(model->is_dirty());
  }

  virtual void model_state_changed(bool is_dirty) {
    if (initialized)
      update_menu_state(is_dirty);
  }
 
public:

  KitListBaseApp();

  virtual ~KitListBaseApp();

  const std::string all_items_text = "-- Show all items --";

  static const std::string DEFAULT_FILE_EXTENSION;

  bool is_dirty() const {
    return model->is_dirty();
  }
 
  void set_dirty(bool dirty = true) const {
    model->set_dirty(dirty);
  }

  auto get_current_checked_item_count() const {
    return model->get_current_checked_item_count();
  }

  void new_file() {
    model.reset(new Model());
    filename.clear();
  }

  virtual void load_file(const std::string& filename);

  virtual bool save() {
    if (filename.empty())
      return false;
    const bool retval = model->save(filename);
    if (!model->is_dirty())
      update_menu_state(false);
    return retval;
  }
 
  virtual bool save(std::string filename) {
    this->filename = filename;
    return save();
  }

  const std::shared_ptr<Category> set_category_name(const int32_t id,
                                              const std::string& name) {
    auto category = model->set_category_name(id, name);
    category_name_changed(category);
    return category;
  }

  const std::shared_ptr<Item> set_item_name(const int32_t id,
                                      const std::string& name) {
    auto item = model->set_item_name(id, name);
    if (item)
      item_name_changed(item);
    return item;
  }

  const std::shared_ptr<Item> set_item_checked(const int32_t id,
                                               const bool state) {
    auto item = model->set_item_checked(id, state);
    if (item)
      item_checked_changed(item);
    return item;
  }

  virtual const std::shared_ptr<Item> change_checked_state(
      int32_t id,
      Model::check_action action) {
 
    return model->change_checked_state(id, action);
  }

  void change_all_current_items_checked_states(
      Model::check_action action) const {
 
    model->change_all_current_items_checked_states(action);
  }

  void set_filename(const std::string& filename) {
    this->filename = filename;
  }

  const std::string get_filename() const {
    return filename;
  }

  virtual void initialization_complete() {
    initialized = true;
  }

  int32_t new_item(const std::string& name, bool checked) const {
    return model->new_item(name, checked);
  }

  void delete_category(int32_t id) const {
    model->delete_category(id);
  }

  void delete_item(int32_t id) const {
    model->delete_item(id);
  }

  void remove_items(const std::vector<std::shared_ptr<Item>>& items) const {
    model->remove_items(items);
  }

  void remove_item(int32_t id) const {
    model->remove_item(id);
  }

  int32_t new_category(const std::string& name) const {
    return model->new_category(name);
  }

  const std::shared_ptr<Item> get_item(int32_t id) const {
    return model->get_item(id);
  }

  const std::shared_ptr<Category> get_category(int32_t id) const {
    return model->get_category(id);
  }

  const std::vector<std::shared_ptr<Item>>
      get_all_items_for_current_selected_category() const {
 
    return model->get_all_items_for_current_selected_category();
  }

  const std::vector<std::shared_ptr<Item>>
      filter_items_for_current_selected_category() const {
 
    return model->filter_items_for_current_selected_category();
  }

  auto count_filter_items_for_current_selected_category() const {
    return model->count_filter_items_for_current_selected_category();
  }

  void remove_all_current_checked_items() {
    model->remove_all_current_checked_items();
  }

  void delete_all_current_checked_items() {
    model->delete_all_current_checked_items();
  }

  void associate_item_with_category(int32_t item_id, std::shared_ptr<Category> category) {
    model->associate_item_with_category(item_id, category);
  }

  void copy_items_to_categories(
      std::vector<std::shared_ptr<Item>>& items,
      std::vector<std::shared_ptr<Category>>& categories) const {
 
    model->copy_items_to_categories(items, categories);
  }

  void copy_checked_items_to_categories(std::vector<int32_t> cids) const {
    model->copy_checked_items_to_categories(cids);
  }

  void copy_item_to_categories(int32_t item_id, std::vector<int32_t> cids) {
    model->copy_item_to_categories(item_id, cids);
  }

  void select_category(int32_t id) {
    model->select_category(id);
    update_menu_state(model->is_dirty());
  }

  int32_t get_selected_category() const {
    return model->get_selected_category();
  }

  const std::vector<std::shared_ptr<Category>> get_categories() const {
    return model->get_categories();
  }

  const std::vector<std::shared_ptr<Item>> get_all_items() const {
    return model->get_all_items();
  }

  void set_filter(Model::state_filter state) const {
    model->set_filter(state);
  }

  Model::state_filter get_filter() const {
    return model->get_filter();
  }

  void sort_categories() const {
    model->sort_categories();
  }

  void sort() const {
    model->sort();
  }

  class file_not_found : public std::exception {
    std::string message;
  public:
    file_not_found(std::string message) : std::exception(), message(message) {}
    virtual const char* what() const throw() override {
      return message.c_str();
    }
  };
 
};
 
#endif // KITLIST_BASE_APP_HPP