kitlistgui.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_GUI_HPP
#define KITLIST_GUI_HPP
 
#include "kitlist_base_app.hpp"
#include "wx/dataview.h"
#include "wx/filehistory.h"
#include "wx/richtext/richtextprint.h"
#include "wx/splitter.h"
#include "wx/wx.h"
#include <cassert>
#include <stdexcept>
#include <memory>
#include <vector>
 
class MyFrame;

class KitListGui : public wxApp, public KitListBaseApp
{
  MyFrame* my_frame;
public:

  KitListGui() : wxApp(), KitListBaseApp(), my_frame() {}

  virtual void category_entry_changed(const std::shared_ptr<Category> category) override;

  virtual void item_entry_changed(const std::shared_ptr<Item> item) override;

  virtual void OnInitCmdLine(wxCmdLineParser& parser) override;

  virtual bool OnCmdLineParsed(wxCmdLineParser& parser) override;

  virtual bool OnInit() override;

  virtual int OnExit() override;

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

  virtual void update_menu_state(bool is_dirty) override;
 
};

class MyFrame : public wxFrame
{
  friend class KitListGui;

  std::unique_ptr<wxRichTextPrinting> rich_text_printing;

  static const int MIN_PANE_SIZE;

  KitListGui* gui_app;

  wxDataViewListCtrl* category_list_ctrl;

  wxMenu* file_menu;

  wxMenu* edit_menu;

  wxMenu* file_history_menu;

  wxFileHistory* file_history;

  wxMenuItem* file_history_menu_item;

  std::unique_ptr<std::exception> last_error;

  static const int ITEM_CHECKED_COL;
  static const int ITEM_NAME_COL;
  static const int CATEGORY_NAME_COL;
 
public:
  MyFrame(KitListGui* app, const wxPoint& pos);

  virtual ~MyFrame();

  void OnShow(wxShowEvent& event);

  void OnAbout(wxCommandEvent& event);

  void OnNewFile(wxCommandEvent& event);

  void OnOpen(wxCommandEvent& event);

  void OnFileHistoryMenuItem(wxCommandEvent& event);

  void OnSave(wxCommandEvent& event);

  void OnSaveAs(wxCommandEvent& event);

  void OnQuit(wxCommandEvent& event);

  void OnAddItem(wxCommandEvent& WXUNUSED(event));

  void OnAddCategory(wxCommandEvent& WXUNUSED(event));

  void OnSelectCategory(wxDataViewEvent& event);

  void OnSelectItem(wxDataViewEvent& event);

  void selected_item_changed();

  void OnCategoryStartEditing(wxDataViewEvent& event) {
    const int row = category_list_ctrl->ItemToRow(event.GetItem());
    if (row == 0)
      event.Veto();
  }

  void OnCategoryContextMenu(wxDataViewEvent& event);

  void OnItemContextMenu(wxDataViewEvent& event);

  void OnCategoryListValueChanged(wxDataViewEvent& event);

  void OnItemListValueChanged(wxDataViewEvent& event);

  void OnShowAll(wxCommandEvent& WXUNUSED(event)) {
    gui_app->set_filter(Model::all);
    populate_item_list();
  }

  void OnShowChecked(wxCommandEvent& WXUNUSED(event)) {
    gui_app->set_filter(Model::checked);
    populate_item_list();
  }

  void OnShowUnchecked(wxCommandEvent& WXUNUSED(event)) {
    gui_app->set_filter(Model::unchecked);
    populate_item_list();
  }

  void OnSelectAllItems(wxCommandEvent& WXUNUSED(event)) {
    item_list_ctrl->SelectAll();
    selected_item_changed();
  }

  void OnUnselectAllItems(wxCommandEvent& WXUNUSED(event)) {
    item_list_ctrl->UnselectAll();
    selected_item_changed();
  }

  void OnCheckAll(wxCommandEvent& WXUNUSED(event)) {
    gui_app->change_all_current_items_checked_states(Model::check);
    populate_item_list();
    update_edit_menu();
  }

  void OnUncheckAll(wxCommandEvent& WXUNUSED(event)) {
    gui_app->change_all_current_items_checked_states(Model::uncheck);
    populate_item_list();
    update_edit_menu();
  }

  void OnToggleAll(wxCommandEvent& WXUNUSED(event)) {
    gui_app->change_all_current_items_checked_states(Model::toggle);
    populate_item_list();
    update_edit_menu();
 }

  void OnCheckSelected(wxCommandEvent& event);

  void OnUncheckSelected(wxCommandEvent& event);

  void OnToggleSelected(wxCommandEvent& event);

  void CopyCheckedToCategories(wxCommandEvent& WXUNUSED(event));

  void OnCopySelectedItemsToCategories(wxCommandEvent& event);

  void OnRemoveSelectedItems(wxCommandEvent& event);

  void OnRemoveCheckedItems(wxCommandEvent& WXUNUSED(event));

  void OnDeleteCheckedItems(wxCommandEvent& WXUNUSED(event));

  // Don't remove this method without confirming it compiles under linux.
  wxSize get_right_panel_width() {
    return right_panel->GetSize();
  }

  static const int VSPLIT_DIST;
private:
  wxWindow* left_panel = nullptr;
  wxWindow* right_panel = nullptr;

  wxDataViewListCtrl* item_list_ctrl = nullptr;

  wxSplitterWindow* split_window = nullptr;

  void load_file(const std::string filename);

  unsigned populate_category_list(int32_t select_category = Model::no_category);

  void populate_item_list();

  void delete_category(int32_t id) {
    gui_app->delete_category(id);
    populate_category_list();
    populate_item_list();
  }

  void delete_item(int32_t id) {
    gui_app->delete_item(id);
    populate_item_list();
  }

  void remove_item(int32_t id) {
    gui_app->remove_item(id);
    populate_item_list();
  }

  void change_selected_checked_states(Model::check_action action);

  void select_and_copy_to_categories(std::vector<std::shared_ptr<Item>> selected_items);

  void copy_items_to_categories(std::vector<std::shared_ptr<Item>>& items,
                             std::vector<std::shared_ptr<Category>>& categories);

  void save();

  void update_file_menu(bool is_dirty);

  void update_edit_menu();

  void setup_rich_text_printing();

  void OnPrint(wxCommandEvent& event);

  void OnPrintPreview(wxCommandEvent& event);
 

  void FillBuffer(wxRichTextBuffer& buf) const;

  void do_open(wxString wx_path);

  wxDECLARE_EVENT_TABLE();
};

class MySplitterWindow : public wxSplitterWindow {
public:
  MySplitterWindow(MyFrame* parent)
    : wxSplitterWindow(parent, wxID_ANY,
                       wxDefaultPosition, wxDefaultSize,
                       wxSP_3D | wxSP_LIVE_UPDATE |
                       wxCLIP_CHILDREN) {
    frame = parent;
  }

  MySplitterWindow(const MySplitterWindow&) = delete;

  MySplitterWindow& operator=(const MySplitterWindow&) = delete;

  void OnPositionChanged(wxSplitterEvent& event);
 
private:
  MyFrame* frame;

  wxDECLARE_EVENT_TABLE();
};

class ItemDialog : public wxDialog {

  wxCheckBox* checkbox_ctrl;

  wxTextCtrl* name_ctrl;
 
public:
  ItemDialog(wxWindow* parent, const wxString& title);

  const std::string get_name() const {
    auto v = name_ctrl->GetValue();
    return v.ToStdString();
  }

  bool is_checked() const {
    return checkbox_ctrl->GetValue();
  }
};
 
#endif // KITLIST_GUI_HPP