Slic3r::GUI::HintDatabase Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/HintNotification.hpp>

Collaboration diagram for Slic3r::GUI::HintDatabase:

Public Member Functions
	~HintDatabase ()
	HintDatabase (HintDatabase const &)=delete
void	operator= (HintDatabase const &)=delete
HintData *	get_hint (HintDataNavigation nav)
size_t	get_index ()
size_t	get_count ()
void	uninit ()
void	reinit ()

Static Public Member Functions
static HintDatabase &	get_instance ()

Private Member Functions
	HintDatabase ()
void	init ()
void	init_random_hint_id ()
void	load_hints_from_file (const boost::filesystem::path &path)
bool	is_used (const std::string &id)
void	set_used (const std::string &id)
void	clear_used ()
size_t	get_next_hint_id ()
size_t	get_prev_hint_id ()
size_t	get_random_next ()

Private Attributes
size_t	m_hint_id
bool	m_initialized { false }
std::vector< HintData >	m_loaded_hints
bool	m_sorted_hints { false }
std::vector< std::string >	m_used_ids
bool	m_used_ids_loaded { false }

Detailed Description

Constructor & Destructor Documentation

HintDatabase() [1/2]

Slic3r::GUI::HintDatabase::HintDatabase ( )

inlineprivate

    : m_hint_id(0)
  {}

References m_hint_id.

Referenced by HintDatabase(), get_instance(), and operator=().

Here is the caller graph for this function:

~HintDatabase()

Slic3r::GUI::HintDatabase::~HintDatabase

(

)

{
  if (m_initialized) {
    write_used_binary(m_used_ids);
  }
}

References m_initialized, and m_used_ids.

HintDatabase() [2/2]

Slic3r::GUI::HintDatabase::HintDatabase ( HintDatabase const & )

delete

References HintDatabase().

Here is the call graph for this function:

Member Function Documentation

clear_used()

void Slic3r::GUI::HintDatabase::clear_used ( )

private

{
  m_used_ids.clear();
}

References m_used_ids.

Referenced by get_random_next().

Here is the caller graph for this function:

get_count()

size_t Slic3r::GUI::HintDatabase::get_count ( )

inline

                        {
    if (!m_initialized)
      return 0;
    return m_loaded_hints.size();
  }

References m_initialized, and m_loaded_hints.

Referenced by Slic3r::GUI::DailyTipsPanel::render_controller_buttons().

Here is the caller graph for this function:

get_hint()

HintData * Slic3r::GUI::HintDatabase::get_hint

(

HintDataNavigation

nav

)

{
  if (!m_initialized) {
    init();
    nav = HintDataNavigation::Random;
  }
  if (m_loaded_hints.empty())
  {
    BOOST_LOG_TRIVIAL(error) << "There were no hints loaded from hints.ini file.";
    return nullptr;
  }
 
  try
  {
    if (nav == HintDataNavigation::Next)
      m_hint_id = get_next_hint_id();
    if(nav == HintDataNavigation::Prev)
      m_hint_id = get_prev_hint_id();
    if (nav == HintDataNavigation::Random)
      init_random_hint_id();
  }
  catch (const std::exception&)
  {
    return nullptr;
  }
 
  return &m_loaded_hints[m_hint_id];
}

References get_next_hint_id(), get_prev_hint_id(), init(), init_random_hint_id(), m_hint_id, m_initialized, m_loaded_hints, Slic3r::GUI::Next, Slic3r::GUI::Prev, and Slic3r::GUI::Random.

Referenced by Slic3r::GUI::NotificationManager::HintNotification::retrieve_data(), and Slic3r::GUI::DailyTipsPanel::retrieve_data_from_hint_database().

Here is the call graph for this function:

Here is the caller graph for this function:

get_index()

size_t Slic3r::GUI::HintDatabase::get_index ( )

inline

{ return m_hint_id; }

References m_hint_id.

Referenced by Slic3r::GUI::DailyTipsPanel::render_controller_buttons().

Here is the caller graph for this function:

get_instance()

HintDatabase & Slic3r::GUI::HintDatabase::get_instance ( )

inlinestatic

  {
    static HintDatabase    instance; // Guaranteed to be destroyed.
                      // Instantiated on first use.
    return instance;
  }

References HintDatabase().

Referenced by Slic3r::GUI::GUI_App::load_language(), Slic3r::GUI::DailyTipsPanel::render_controller_buttons(), Slic3r::GUI::NotificationManager::HintNotification::retrieve_data(), and Slic3r::GUI::DailyTipsPanel::retrieve_data_from_hint_database().

Here is the call graph for this function:

Here is the caller graph for this function:

get_next_hint_id()

size_t Slic3r::GUI::HintDatabase::get_next_hint_id ( )

private

{
  return m_hint_id < m_loaded_hints.size() - 1 ? m_hint_id + 1 : 0;
}

References m_hint_id, and m_loaded_hints.

Referenced by get_hint().

Here is the caller graph for this function:

get_prev_hint_id()

size_t Slic3r::GUI::HintDatabase::get_prev_hint_id ( )

private

{
  return m_hint_id > 0 ? m_hint_id - 1 : m_loaded_hints.size() - 1;
}

References m_hint_id, and m_loaded_hints.

Referenced by get_hint().

Here is the caller graph for this function:

get_random_next()

size_t Slic3r::GUI::HintDatabase::get_random_next ( )

private

{
  if (!m_sorted_hints)
  {
    auto compare_wieght = [](const HintData& a, const HintData& b) { return a.weight < b.weight; };
    std::sort(m_loaded_hints.begin(), m_loaded_hints.end(), compare_wieght);
    m_sorted_hints = true;
    srand(time(NULL));
  }
  std::vector<size_t> candidates; // index in m_loaded_hints
  // total weight
  size_t total_weight = 0;
  for (size_t i = 0; i < m_loaded_hints.size(); i++) {
    if (!m_loaded_hints[i].was_displayed && tags_check(m_loaded_hints[i].disabled_tags, m_loaded_hints[i].enabled_tags)) {
      candidates.emplace_back(i);
      total_weight += m_loaded_hints[i].weight;
    }
  }
  // all were shown
  if (total_weight == 0) {
    clear_used();
    for (size_t i = 0; i < m_loaded_hints.size(); i++) {
      m_loaded_hints[i].was_displayed = false;
      if (tags_check(m_loaded_hints[i].disabled_tags, m_loaded_hints[i].enabled_tags)) {
        candidates.emplace_back(i);
        total_weight += m_loaded_hints[i].weight;
      }
    }
  }
  if (total_weight == 0) {
    BOOST_LOG_TRIVIAL(error) << "Hint notification random number generator failed. No suitable hint was found.";
    throw std::exception();
  }
  size_t random_number = rand() % total_weight + 1;
  size_t current_weight = 0;
  for (size_t i = 0; i < candidates.size(); i++) {
    current_weight += m_loaded_hints[candidates[i]].weight;
    if (random_number <= current_weight) {
      set_used(m_loaded_hints[candidates[i]].id_string);
      m_loaded_hints[candidates[i]].was_displayed = true;
      return candidates[i];
    }
  }
  BOOST_LOG_TRIVIAL(error) << "Hint notification random number generator failed.";
  throw std::exception();
}

References clear_used(), m_loaded_hints, m_sorted_hints, set_used(), and Slic3r::GUI::HintData::weight.

Here is the call graph for this function:

init()

void Slic3r::GUI::HintDatabase::init ( )

private

{
  load_hints_from_file(std::move(boost::filesystem::path(resources_dir()) / "data" / "hints.ini"));
  m_initialized = true;
  init_random_hint_id();
}

References init_random_hint_id(), load_hints_from_file(), m_initialized, and Slic3r::resources_dir().

Referenced by get_hint(), and reinit().

Here is the call graph for this function:

Here is the caller graph for this function:

init_random_hint_id()

void Slic3r::GUI::HintDatabase::init_random_hint_id ( )

private

{
  srand(time(NULL));
  m_hint_id = rand() % m_loaded_hints.size();
}

References m_hint_id, and m_loaded_hints.

Referenced by get_hint(), and init().

Here is the caller graph for this function:

is_used()

bool Slic3r::GUI::HintDatabase::is_used ( const std::string & id )

private

{
  // load used ids from file
  if (!m_used_ids_loaded) {
    read_used_binary(m_used_ids);
    m_used_ids_loaded = true;
  }
  // check if id is in used
  for (const std::string& used_id : m_used_ids) {
    if (used_id == id)
    {
      return true;
    }
  }
  return false;
}

References m_used_ids, and m_used_ids_loaded.

Referenced by load_hints_from_file(), and set_used().

Here is the caller graph for this function:

load_hints_from_file()

void Slic3r::GUI::HintDatabase::load_hints_from_file ( const boost::filesystem::path & path )

private

{
  namespace pt = boost::property_tree;
  pt::ptree tree;
  boost::nowide::ifstream ifs(path.string());
  try {
    pt::read_ini(ifs, tree);
  }
  catch (const boost::property_tree::ini_parser::ini_parser_error& err) {
    throw Slic3r::RuntimeError(format("Failed loading hints file \"%1%\"\nError: \"%2%\" at line %3%", path, err.message(), err.line()).c_str());
  }
 
  for (const auto& section : tree) {
    if (boost::starts_with(section.first, "hint:")) {
      // create std::map with tree data 
      std::map<std::string, std::string> dict;
      for (const auto& data : section.second) {
        dict.emplace(data.first, data.second.data());
      }
      // unique id string [hint:id] (trim "hint:")
      std::string id_string = section.first.substr(5);
      id_string = std::to_string(std::hash<std::string>{}(id_string));
      // unescaping and translating all texts and saving all data common for all hint types 
      std::string fulltext;
      std::string text1;
      std::string hypertext_text;
      std::string follow_text;
      // tags
      std::string disabled_tags;
      std::string enabled_tags;
      // optional link to documentation (accessed from button)
      std::string documentation_link;
      std::string img_url;
      // randomized weighted order variables
      size_t      weight = 1;
      bool    was_displayed = is_used(id_string);
      //unescape text1
      unescape_string_cstyle(dict["text"], fulltext);
      fulltext = _utf8(fulltext);
#ifdef __APPLE__
      boost::replace_all(fulltext, "Ctrl+", "?");
#endif //__APPLE__
      // replace <b> and </b> for imgui markers
      std::string marker_s(1, ImGui::ColorMarkerStart);
      std::string marker_e(1, ImGui::ColorMarkerEnd);
      // start marker
      size_t marker_pos = fulltext.find(BOLD_MARKER_START);
      while (marker_pos != std::string::npos) {
        fulltext.replace(marker_pos, 3, marker_s);
        marker_pos = fulltext.find(BOLD_MARKER_START, marker_pos);
      }
      // end marker
      marker_pos = fulltext.find(BOLD_MARKER_END);
      while (marker_pos != std::string::npos) {
        fulltext.replace(marker_pos, 4, marker_e);
        marker_pos = fulltext.find(BOLD_MARKER_END, marker_pos);
      }
      // divide fulltext
      size_t hypertext_start = fulltext.find(HYPERTEXT_MARKER_START);
      if (hypertext_start != std::string::npos) {
        //hypertext exists
        fulltext.erase(hypertext_start, HYPERTEXT_MARKER_START.size());
        if (fulltext.find(HYPERTEXT_MARKER_START) != std::string::npos) {
          // This must not happen - only 1 hypertext allowed
          BOOST_LOG_TRIVIAL(error) << "Hint notification with multiple hypertexts: " << _utf8(dict["text"]);
          continue;
        }
        size_t hypertext_end = fulltext.find(HYPERTEXT_MARKER_END);
        if (hypertext_end == std::string::npos) {
          // hypertext was not correctly ended
          BOOST_LOG_TRIVIAL(error) << "Hint notification without hypertext end marker: " << _utf8(dict["text"]);
          continue;
        }
        fulltext.erase(hypertext_end, HYPERTEXT_MARKER_END.size());
        if (fulltext.find(HYPERTEXT_MARKER_END) != std::string::npos) {
          // This must not happen - only 1 hypertext end allowed
          BOOST_LOG_TRIVIAL(error) << "Hint notification with multiple hypertext end markers: " << _utf8(dict["text"]);
          continue;
        }
 
        text1 = fulltext.substr(0, hypertext_start);
        hypertext_text = fulltext.substr(hypertext_start, hypertext_end - hypertext_start);
        follow_text = fulltext.substr(hypertext_end);
      }
      else {
        text1 = fulltext;
      }
 
      if (dict.find("disabled_tags") != dict.end()) {
        disabled_tags = dict["disabled_tags"];
      }
      if (dict.find("enabled_tags") != dict.end()) {
        enabled_tags = dict["enabled_tags"];
      }
      if (dict.find("documentation_link") != dict.end()) {
        documentation_link = dict["documentation_link"];
      }
      if (dict.find("image") != dict.end()) {
        img_url = dict["image"];
      }
 
      if (dict.find("weight") != dict.end()) {
        weight = (size_t)std::max(1, std::atoi(dict["weight"].c_str()));
      }
 
      // create HintData
      if (dict.find("hypertext_type") != dict.end()) {
        //link to internet
        if (dict["hypertext_type"] == "link") {
          std::string hypertext_link = dict["hypertext_link"];
          HintData  hint_data{ id_string, text1, weight, was_displayed, hypertext_text, follow_text, disabled_tags, enabled_tags, false, documentation_link, img_url, [hypertext_link]() { launch_browser_if_allowed(hypertext_link); } };
          m_loaded_hints.emplace_back(hint_data);
          // highlight settings
        }
        else if (dict["hypertext_type"] == "settings") {
          std::string   opt = dict["hypertext_settings_opt"];
          Preset::Type  type = static_cast<Preset::Type>(std::atoi(dict["hypertext_settings_type"].c_str()));
          std::wstring  category = boost::nowide::widen(dict["hypertext_settings_category"]);
          HintData    hint_data{ id_string, text1, weight, was_displayed, hypertext_text, follow_text, disabled_tags, enabled_tags, true, documentation_link, img_url, [opt, type, category]() { GUI::wxGetApp().sidebar().jump_to_option(opt, type, category); } };
          m_loaded_hints.emplace_back(hint_data);
          // open preferences
        }
        else if (dict["hypertext_type"] == "preferences") {
          std::string item = dict["hypertext_preferences_item"];
          HintData  hint_data{ id_string, text1, weight, was_displayed, hypertext_text, follow_text, disabled_tags, enabled_tags, false, documentation_link, img_url, [item]() { wxGetApp().open_preferences(PreferencesTab::Control, item); } };
          m_loaded_hints.emplace_back(hint_data);
        }
        else if (dict["hypertext_type"] == "plater") {
          std::string item = dict["hypertext_plater_item"];
          HintData  hint_data{ id_string, text1, weight, was_displayed, hypertext_text, follow_text, disabled_tags, enabled_tags, true, documentation_link, img_url, [item]() { wxGetApp().plater()->canvas3D()->highlight_toolbar_item(item); } };
          m_loaded_hints.emplace_back(hint_data);
        }
        else if (dict["hypertext_type"] == "gizmo") {
          std::string item = dict["hypertext_gizmo_item"];
          HintData  hint_data{ id_string, text1, weight, was_displayed, hypertext_text, follow_text, disabled_tags, enabled_tags, true, documentation_link, img_url, [item]() { wxGetApp().plater()->canvas3D()->highlight_gizmo(item); } };
          m_loaded_hints.emplace_back(hint_data);
        }
        else if (dict["hypertext_type"] == "gallery") {
          HintData  hint_data{ id_string, text1, weight, was_displayed, hypertext_text, follow_text, disabled_tags, enabled_tags, false, documentation_link, img_url, []() {
            // Deselect all objects, otherwise gallery wont show.
            wxGetApp().plater()->canvas3D()->deselect_all();
            //wxGetApp().obj_list()->load_shape_object_from_gallery(); }
          } };
          m_loaded_hints.emplace_back(hint_data);
        }
        else if (dict["hypertext_type"] == "menubar") {
          wxString menu(_("&" + dict["hypertext_menubar_menu_name"]));
          wxString item(_(dict["hypertext_menubar_item_name"]));
          HintData  hint_data{ id_string, text1, weight, was_displayed, hypertext_text, follow_text, disabled_tags, enabled_tags, true, documentation_link, img_url, [menu, item]() { wxGetApp().mainframe->open_menubar_item(menu, item); } };
          m_loaded_hints.emplace_back(hint_data);
        }
      }
      else {
        // plain text without hypertext
        HintData hint_data{ id_string, text1, weight, was_displayed, hypertext_text, follow_text, disabled_tags, enabled_tags, false, documentation_link, img_url };
        m_loaded_hints.emplace_back(hint_data);
      }
    }
  }
}

References _, _utf8, Slic3r::GUI::BOLD_MARKER_END, Slic3r::GUI::BOLD_MARKER_START, Slic3r::GUI::Control, Slic3r::GUI::format(), Slic3r::GUI::HYPERTEXT_MARKER_END, Slic3r::GUI::HYPERTEXT_MARKER_START, is_used(), m_loaded_hints, and Slic3r::unescape_string_cstyle().

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

void Slic3r::GUI::HintDatabase::operator= ( HintDatabase const & )

delete

References HintDatabase().

Here is the call graph for this function:

reinit()

void Slic3r::GUI::HintDatabase::reinit

(

)

{
  if (m_initialized)
    uninit();
  init();
}

References init(), m_initialized, and uninit().

Here is the call graph for this function:

set_used()

void Slic3r::GUI::HintDatabase::set_used ( const std::string & id )

private

{
  // check needed?
  if (!is_used(id))
  {
    m_used_ids.emplace_back(id);
  }
}

References is_used(), and m_used_ids.

Referenced by get_random_next().

Here is the call graph for this function:

Here is the caller graph for this function:

uninit()

void Slic3r::GUI::HintDatabase::uninit

(

)

{
  if (m_initialized) {
    write_used_binary(m_used_ids);
  }
  m_initialized = false;
  m_loaded_hints.clear();
  m_sorted_hints = false;
  m_used_ids.clear();
  m_used_ids_loaded = false;
}

References m_initialized, m_loaded_hints, m_sorted_hints, m_used_ids, and m_used_ids_loaded.

Referenced by reinit().

Here is the caller graph for this function:

Member Data Documentation

m_hint_id

size_t Slic3r::GUI::HintDatabase::m_hint_id

private

Referenced by HintDatabase(), get_hint(), get_index(), get_next_hint_id(), get_prev_hint_id(), and init_random_hint_id().

m_initialized

bool Slic3r::GUI::HintDatabase::m_initialized { false }

private

{ false };

Referenced by ~HintDatabase(), get_count(), get_hint(), init(), reinit(), and uninit().

m_loaded_hints

std::vector<HintData> Slic3r::GUI::HintDatabase::m_loaded_hints

private

Referenced by get_count(), get_hint(), get_next_hint_id(), get_prev_hint_id(), get_random_next(), init_random_hint_id(), load_hints_from_file(), and uninit().

m_sorted_hints

bool Slic3r::GUI::HintDatabase::m_sorted_hints { false }

private

{ false };

Referenced by get_random_next(), and uninit().

m_used_ids

std::vector<std::string> Slic3r::GUI::HintDatabase::m_used_ids

private

Referenced by ~HintDatabase(), clear_used(), is_used(), set_used(), and uninit().

m_used_ids_loaded

bool Slic3r::GUI::HintDatabase::m_used_ids_loaded { false }

private

{ false };

Referenced by is_used(), and uninit().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/HintNotification.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/HintNotification.cpp