kitlist_ftxui.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_ftxui.hpp"
#include "kitparser.hpp"
#include <ftxui/component/captured_mouse.hpp>
#include <ftxui/component/component.hpp>
#include <ftxui/component/component_base.hpp>
#include <ftxui/component/component_options.hpp>
#include <ftxui/component/screen_interactive.hpp>
#include <ftxui/dom/elements.hpp>
#include <ftxui/screen/screen.hpp>
#include <filesystem>
#include <iostream>
#include <string>
#include <vector>
 
using namespace std;
using namespace ftxui;
using namespace fdsd::ftxui;
 
void KitListFtxui::do_refresh_select_category_list()
{
  if (refresh_select_category_list == true) {
    auto categories = get_categories();
    selected_categories.clear();
    for (auto& c : categories) {
      SelectCategory sc(false, c);
      selected_categories.push_back(sc);
    }
    refresh_select_category_list = false;
  }
}
 
Component KitListFtxui::select_category_list()
{
  do_refresh_select_category_list();
  if (refresh_copy_item_category_container == true) {
    copy_category_container->DetachAllChildren();
    for (auto& sc : selected_categories) {
      copy_category_container->Add(Checkbox(sc.category->name, &sc.selected));
    }
    refresh_copy_item_category_container = false;
  }
  Component component = Container::Vertical({copy_category_container});
 
  component |= Renderer([&](Element inner) {
    if (refresh_copy_item_category_container == true) {
      copy_category_container->DetachAllChildren();
      for (auto& sc : selected_categories) {
        copy_category_container->Add(Checkbox(sc.category->name, &sc.selected));
      }
      refresh_copy_item_category_container = false;
    }
    Element document = vbox({
        inner,
      });
    return document
      | vscroll_indicator | frame;
  });
  return component;
}
 
Component KitListFtxui::copy_items_dialog()
{
  auto ok_button = Button("Ok", [&] {
    layer = static_cast<int>(Layer::default_layer);
    auto all_items = get_all_items_for_current_selected_category();
    vector<shared_ptr<Item>> items;
    for (const auto& i : all_items) {
      if (i->checked)
        items.push_back(i);
    }
    vector<shared_ptr<Category>> categories;
    for (const auto& sc : selected_categories) {
      if (sc.selected)
        categories.push_back(sc.category);
    }
    if (!items.empty() && !categories.empty()) {
      copy_items_to_categories(items, categories);
      show_save = true;
    }
  });
  auto cancel_button = Button("Cancel", [&] {
    layer = static_cast<int>(Layer::default_layer);
  });
  Component category_list = select_category_list();
  auto buttons = Container::Horizontal({ok_button, cancel_button});
 
  buttons |= Renderer([&](Element inner) {
    Element document = vbox({
        separator(),
        inner,
      });
    return document;
  });
 
  Component component = Container::Vertical({
      category_list | flex,
      buttons,
    });
 
  component |= Renderer([&](Element inner) {
    Element document = vbox({
        text("Select categories "),
        separator(),
        inner,
      });
    return document
      | size(WIDTH, GREATER_THAN, 40)
      | size(HEIGHT, GREATER_THAN, 8)
      | border;
  });
  return component;
}
 
Component KitListFtxui::item_action_dialog()
{
  Component component = Renderer(item_action_container, [&] {
    item_action_container->DetachAllChildren();
    auto action_button = Button(get_selected_category() == Model::no_category ? "Delete" : "Remove",
                                [&] {
                                  if (get_selected_category() == Model::no_category) {
                                    delete_all_current_checked_items();
                                  } else {
                                    remove_all_current_checked_items();
                                  }
                                  show_save = true;
                                  layer = static_cast<int>(Layer::default_layer);
                                });
    auto cancel_button = Button("Cancel", [&] { layer = static_cast<int>(Layer::default_layer); });
    item_action_container->Add(action_button);
    item_action_container->Add(cancel_button);
    Element document = vbox({
        text(get_selected_category() ? "Delete checked items" : "Remove checked items"),
        separator(),
        hbox({
            action_button->Render(),
            cancel_button->Render(),
          }),
      });
    return document
      | size(WIDTH, GREATER_THAN, 40)
      | border;
  });
  return component;
}
 
Component KitListFtxui::new_category_component(
    std::function<void()> cancel,
    std::function<void()> create_category)
{
  InputOption input_option = InputOption::Default();
  input_option.multiline = false;
  input_option.transform = [](InputState state) {
 
    state.element |= color(Color::Black);
 
    if (state.is_placeholder) {
      state.element |= dim;
    }
 
    if (state.focused || state.hovered) {
      state.element |= inverted;
    }
    return state.element;
  };
 
  auto component = Container::Vertical({
      Container::Horizontal({
          Input(&category_name, "Enter name", input_option) | borderEmpty,
        }),
      Container::Horizontal({
          Button("OK", create_category),
          Button("Cancel", cancel),
        }) | flex,
    });
  // Polish how the components are rendered
  component |= Renderer([&](Element inner) {
    return vbox({
        text("Category editor"),
        separator(),
        hbox({
            inner,
          }),
      })
      | size(WIDTH, GREATER_THAN, 40)
      | border;
  });
  return component;
}
 
Component KitListFtxui::new_item_component(
    std::function<void()> cancel,
    std::function<void()> create_item)
{
  InputOption input_option = InputOption::Default();
  input_option.multiline = false;
  input_option.transform = [](InputState state) {
 
    state.element |= color(Color::Black);
 
    if (state.is_placeholder) {
      state.element |= dim;
    }
 
    if (state.focused || state.hovered) {
      state.element |= inverted;
    }
    return state.element;
  };
 
  auto component = Container::Vertical({
      Container::Horizontal({
          Checkbox("Checked", &item_checked) | borderEmpty,
          Input(&item_name, "Enter name", input_option) | borderEmpty,
        }),
      Container::Horizontal({
          Button("OK", create_item),
          Button("Cancel", cancel),
        }) | flex,
    });
  // Polish how the components are rendered
  component |= Renderer([&](Element inner) {
    return vbox({
        text("Item editor"),
        separator(),
        hbox({
            inner,
          }),
      })
      | size(WIDTH, GREATER_THAN, 40)
      | border;
  });
  return component;
}
 
int KitListFtxui::run(const string filename)
{
  if (!filename.empty()) {
    try {
      load_file(filename);
    } catch (const KitListBaseApp::file_not_found& e) {
      cerr << "File not found: \"" << filename << "\" - " << e.what() << '\n';
      exit(1);
    } catch (const KitParser::parse_exception& e) {
      cerr << "Error parsing file: \"" << filename << "\" - " << e.what() << '\n';
      exit(1);
    }
  }
 
  auto categories = get_categories();
  for (auto& c : categories) {
    SelectCategory sc(false, c);
    selected_categories.push_back(sc);
  }
 
  auto screen = ScreenInteractive::Fullscreen();
 
  // ---------- Button Container ----------
 
  vector<string> filter_entries = {
    "Show all",
    "Checked",
    "Unchecked",
  };
 
  auto button_container = Container::Vertical({
      Container::Horizontal({
          Button("Quit", screen.ExitLoopClosure()),
            Maybe(Button("Save", [&] {
              save();
              show_save = false;
            }), [&] { return show_save; }),
 
            Button("Check all", [&] {
              change_all_current_items_checked_states(Model::check_action::check);
              show_save = true;
            }),
 
            Button("Uncheck all", [&] {
              change_all_current_items_checked_states(Model::check_action::uncheck);
              show_save = true;
            }),
 
            Button("Toggle all", [&] {
              change_all_current_items_checked_states(Model::check_action::toggle);
              show_save = true;
            }),
            Dropdown(&filter_entries, &selected_filter),
      }),
      Container::Horizontal({
          Button("New category", [&] { layer = static_cast<int>(Layer::new_category_layer); }),
          Button("New item", [&] { layer = static_cast<int>(Layer::new_item_layer); }),
          Button(get_selected_category() == Model::no_category ? "Item action" : "Remove checked items",
                 [&] { layer = static_cast<int>(Layer::item_action_layer); }),
          Maybe(Button("Delete category", [&] {
            delete_category(get_selected_category());
            show_save = true;
            refresh_category_container = true;
            refresh_select_category_list = true;
            do_refresh_select_category_list();
          }), [&] { return get_selected_category() != Model::no_category; }),
          Maybe(Button("Copy to categories", [&] {
            refresh_copy_item_category_container = true;
            layer = static_cast<int>(Layer::copy_category_layer);
          }), [&] { return count_filter_items_for_current_selected_category() > 0; }),
      }),
   });
 
    // button_container |= Renderer([&](Element inner) {
    //   return vbox({
    //       text("Main component"),
    //       separator(),
    //       inner,
    //     })
    //     | size(WIDTH, GREATER_THAN, 20)
    //     | size(HEIGHT, GREATER_THAN, 20)
    //     | border
    //     | center;
    // });
 
  Component button_container_wrap = Renderer(button_container, [&] {
    return button_container->Render();
  });
 
  // ---------- Category Menu ----------
 
  Component category_container = Container::Vertical({});
 
  // When the category is re-rendered, update the model with the currently
  // selected category.
  Component category_container_wrap = Renderer(category_container, [&] {
 
    if (refresh_category_container) {
      category_container->DetachAllChildren();
      category_menu_entries.clear();
 
      // First entry is to show all items
      category_menu_entries.push_back(all_items_text);
 
      current_categories = get_categories();
      for (const auto& c : current_categories)
        category_menu_entries.push_back(c->name);
 
      // Assigning a Vertical menu option and setting the transform as follows,
      // achieves the same end result as simply defining MenuOption as:
      //     MenuOption option;
      //
      // Note that not passing a menu option results in it defaulting to
      // MenuOption::Vertical(), which shows inactive and non-focuses menu items
      // dimmed out.  So, specifically creating what we want in case someone in
      // future changes the defaults (as they are a bit inconsistent).
      MenuOption category_menu_option = MenuOption::Vertical();
 
      category_menu_option.entries_option.transform = [] (const EntryState& state) {
        Element e = text((state.active ? "> " : "  ") + state.label);
        if (state.focused) {
          e |= inverted;
        }
        if (state.active) {
          e |= bold;
        }
        // if (!state.focused && !state.active) {
        //   e |= dim;
        // }
        return e;
      };
 
      auto menu = Menu(&category_menu_entries, &menu_selected_category, category_menu_option);
 
      category_container->Add(menu);
      refresh_category_container = false;
    }
 
    auto current_category = get_category(get_selected_category());
    if (menu_selected_category <= 0 || menu_selected_category > (static_cast<int>(current_categories.size()))) {
      select_category(Model::no_category);
    } else {
      auto category = current_categories[menu_selected_category -1];
      select_category(category->get_id());
    }
    return category_container->Render();
  });
 
 
  // ---------- Item Container ----------
 
  Component item_container = Container::Vertical({});
  Component item_container_wrap = Renderer(item_container, [&] {
    item_container->DetachAllChildren();
    switch (selected_filter) {
    case 1:
      set_filter(Model::state_filter::checked);
      break;
    case 2:
      set_filter(Model::state_filter::unchecked);
      break;
    case 0:
      [[fallthrough]];
    default:
      set_filter(Model::state_filter::all);
    }
    const auto items = filter_items_for_current_selected_category();
    for (const auto& i : items) {
      CheckboxOption cbx_option;
      cbx_option.on_change = [&] {
        set_dirty();
        show_save = true;
      };
      item_container->Add(Checkbox(i->get_name(), &i->checked, cbx_option));
    }
    return item_container->Render();
  });
 
  // ---------- Combined Container ----------
 
  auto inner_container = Container::Horizontal({ category_container_wrap, item_container_wrap });
  auto layer_0_container = Container::Vertical({ button_container_wrap, inner_container });
  auto new_item_dialog = new_item_component(
      [&] { // Cancel
        layer = static_cast<int>(Layer::default_layer);
      },
      [&] { // Ok
        layer = static_cast<int>(Layer::default_layer);
        if (item_name.empty())
          return;
        new_item(item_name, item_checked);
        item_name = "";
        item_checked = false;
        show_save = true;
      });
 
  auto layer_1_container = Container::Horizontal({new_item_dialog});
 
  auto layer_1_renderer = Renderer(layer_1_container, [&] {
    return
      layer_1_container->Render();
  });
 
  auto new_category_dialog = new_category_component(
      [&] { // Cancel
        layer = static_cast<int>(Layer::default_layer);
      },
      [&] { // Ok
        layer = static_cast<int>(Layer::default_layer);
        if (category_name.empty())
          return;
        new_category(category_name);
        category_name = "";
        show_save = true;
        refresh_category_container = true;
        refresh_select_category_list = true;
        do_refresh_select_category_list();
      });
 
  auto layer_2_container = Container::Horizontal({new_category_dialog});
  auto layer_2_renderer = Renderer(layer_2_container, [&] {
    return
      layer_2_container->Render();
  });
 
  auto layer_3_container = Container::Horizontal({item_action_dialog()});
  auto layer_3_renderer = Renderer(layer_3_container, [&] {
    return
      layer_3_container->Render();
  });
 
  do_refresh_select_category_list();
  auto layer_4_container = Container::Horizontal({copy_items_dialog()});
 
  auto layer_4_renderer = Renderer(layer_4_container, [&] {
    return layer_4_container->Render();
  });
 
// ---------- Renderer ----------
 
  auto layer_0_renderer = Renderer(layer_0_container, [&] {
 
    return
      vbox({
          hbox({
              button_container_wrap->Render(),
            }),
          hbox({
              category_container_wrap->Render() | vscroll_indicator | frame | border,
              item_container_wrap->Render() | vscroll_indicator | frame | border | xflex,
            }) | yflex,
        });
  });
 
  auto main_container = Container::Tab(
      {
        layer_0_renderer,
        layer_1_renderer,
        layer_2_renderer,
        layer_3_renderer,
        layer_4_renderer,
      },
      &layer);
 
  auto main_renderer = Renderer(main_container, [&] {
    Element document = layer_0_renderer->Render();
 
    switch (layer) {
      case 1:
        document = dbox({
            document,
            layer_1_renderer->Render() | clear_under | center,
          });
        break;
      case 2:
        document = dbox({
            document,
            layer_2_renderer->Render() | clear_under | center,
          });
        break;
      case 3:
        document = dbox({
            document,
            layer_3_renderer->Render() | clear_under | center,
          });
        break;
      case 4:
        document = dbox({
            document,
            layer_4_renderer->Render() | clear_under | center,
          });
        break;
    }
    return document;
  });
 
  screen.Loop(main_renderer);
  return 0;
 
}