Slic3r::GUI::anonymous_namespace{HintNotification.cpp} Namespace Reference

Enumerations
enum	TagCheckResult { TagCheckAffirmative , TagCheckNegative , TagCheckNotCompatible }

Functions
void	push_style_color (ImGuiCol idx, const ImVec4 &col, bool fading_out, float current_fade_opacity)
void	write_used_binary (const std::vector< std::string > &ids)
void	read_used_binary (std::vector< std::string > &ids)
TagCheckResult	tag_check_mode (const std::string &tag)
TagCheckResult	tag_check_tech (const std::string &tag)
TagCheckResult	tag_check_system (const std::string &tag)
TagCheckResult	tag_check_material (const std::string &tag)
bool	tags_check (const std::string &disabled_tags, const std::string &enabled_tags)
void	launch_browser_if_allowed (const std::string &url)

Enumeration Type Documentation

TagCheckResult

enum Slic3r::GUI::anonymous_namespace{HintNotification.cpp}::TagCheckResult

Enumerator
TagCheckAffirmative
TagCheckNegative
TagCheckNotCompatible

  {
    TagCheckAffirmative,
    TagCheckNegative,
    TagCheckNotCompatible
  };

Function Documentation

launch_browser_if_allowed()

void Slic3r::GUI::anonymous_namespace{HintNotification.cpp}::launch_browser_if_allowed

(

const std::string &

url

)

  {
    wxGetApp().open_browser_with_warning_dialog(url);
  }

References launch_browser_if_allowed().

Referenced by launch_browser_if_allowed().

Here is the call graph for this function:

Here is the caller graph for this function:

push_style_color()

void Slic3r::GUI::anonymous_namespace{HintNotification.cpp}::push_style_color ( ImGuiCol idx, const ImVec4 & col, bool fading_out, float current_fade_opacity )

inline

  {
    if (fading_out)
      ImGui::PushStyleColor(idx, ImVec4(col.x, col.y, col.z, col.w * current_fade_opacity));
    else
      ImGui::PushStyleColor(idx, col);
  }

References push_style_color().

Referenced by push_style_color().

Here is the call graph for this function:

Here is the caller graph for this function:

read_used_binary()

void Slic3r::GUI::anonymous_namespace{HintNotification.cpp}::read_used_binary

(

std::vector< std::string > &

ids

)

  {
    boost::filesystem::path path(boost::filesystem::path(data_dir()) / "user" / "hints.cereal");
    if (!boost::filesystem::exists(path)) {
      BOOST_LOG_TRIVIAL(warning) << "Failed to load to hints.cereal. File does not exists. " << path.string();
      return;
    }
    boost::nowide::ifstream file(path.string());
    cereal::BinaryInputArchive archive(file);
    HintsCerealData cd;
    try
    {
      archive(cd);
    }
    catch (const std::exception& ex)
    {
      BOOST_LOG_TRIVIAL(error) << "Failed to load to hints.cereal. " << ex.what();
      return;
    }
    ids = cd.my_data;
  }

References Slic3r::data_dir(), HintsCerealData::my_data, and read_used_binary().

Referenced by read_used_binary().

Here is the call graph for this function:

Here is the caller graph for this function:

tag_check_material()

TagCheckResult Slic3r::GUI::anonymous_namespace{HintNotification.cpp}::tag_check_material

(

const std::string &

tag

)

  {
    if (const GUI::Tab* tab = wxGetApp().get_tab(Preset::Type::TYPE_FILAMENT)) {
      // search PrintConfig filament_type to find if allowed tag
      if (wxGetApp().app_config->get("filament_type").find(tag)) {
        const Preset& preset = tab->m_presets->get_edited_preset();
        const auto* opt = preset.config.opt<ConfigOptionStrings>("filament_type");
        if (opt->values[0] == tag)
          return TagCheckAffirmative;
        return TagCheckNegative;
      }
      return TagCheckNotCompatible;
    }
    /* TODO: SLA materials
    else if (const GUI::Tab* tab = wxGetApp().get_tab(Preset::Type::TYPE_SLA_MATERIAL)) {
      //if (wxGetApp().app_config->get("material_type").find(tag)) {
        const Preset& preset = tab->m_presets->get_edited_preset();
        const auto* opt = preset.config.opt<ConfigOptionStrings>("material_type");
        if (opt->values[0] == tag)
          return TagCheckAffirmative;
        return TagCheckNegative;
      //}
      return TagCheckNotCompatible;
    }*/
    return TagCheckNotCompatible;
  }

References Slic3r::Preset::config, Slic3r::DynamicConfig::opt(), tag_check_material(), TagCheckAffirmative, TagCheckNegative, TagCheckNotCompatible, and Slic3r::Preset::TYPE_FILAMENT.

Referenced by tag_check_material(), and tags_check().

Here is the call graph for this function:

Here is the caller graph for this function:

tag_check_mode()

TagCheckResult Slic3r::GUI::anonymous_namespace{HintNotification.cpp}::tag_check_mode

(

const std::string &

tag

)

  {
    std::vector<std::string> allowed_tags = { "simple", "advanced", "expert" };
    if (std::find(allowed_tags.begin(), allowed_tags.end(), tag) != allowed_tags.end())
    {
      ConfigOptionMode config_mode = wxGetApp().get_mode();
      if (config_mode == ConfigOptionMode::comSimple)        return (tag == "simple" ? TagCheckAffirmative : TagCheckNegative);
      else if (config_mode == ConfigOptionMode::comAdvanced) return (tag == "advanced" ? TagCheckAffirmative : TagCheckNegative);
      else if (config_mode == ConfigOptionMode::comExpert || config_mode == ConfigOptionMode::comDevelop)
        return (tag == "expert" ? TagCheckAffirmative : TagCheckNegative);
    }
    return TagCheckNotCompatible;
  }

References Slic3r::comAdvanced, Slic3r::comDevelop, Slic3r::comExpert, Slic3r::comSimple, tag_check_mode(), TagCheckAffirmative, TagCheckNegative, and TagCheckNotCompatible.

Referenced by tag_check_mode(), and tags_check().

Here is the call graph for this function:

Here is the caller graph for this function:

tag_check_system()

TagCheckResult Slic3r::GUI::anonymous_namespace{HintNotification.cpp}::tag_check_system

(

const std::string &

tag

)

  {
    std::vector<std::string> allowed_tags = { "Windows", "Linux", "OSX" };
    if (std::find(allowed_tags.begin(), allowed_tags.end(), tag) != allowed_tags.end()) {
      if (tag == "Windows")
#ifdef WIN32
        return TagCheckAffirmative;
#else 
        return TagCheckNegative;
#endif // WIN32
 
      if (tag == "Linux")
#ifdef __linux__
        return TagCheckAffirmative;
#else 
        return TagCheckNegative;
#endif // __linux__
 
      if (tag == "OSX")
#ifdef __APPLE__
        return TagCheckAffirmative;
#else 
        return TagCheckNegative;
#endif // __apple__
    }
    return TagCheckNotCompatible;
  }

References tag_check_system(), TagCheckAffirmative, TagCheckNegative, and TagCheckNotCompatible.

Referenced by tag_check_system(), and tags_check().

Here is the call graph for this function:

Here is the caller graph for this function:

tag_check_tech()

TagCheckResult Slic3r::GUI::anonymous_namespace{HintNotification.cpp}::tag_check_tech

(

const std::string &

tag

)

  {
    std::vector<std::string> allowed_tags = { "FFF", "MMU", "SLA" };
    if (std::find(allowed_tags.begin(), allowed_tags.end(), tag) != allowed_tags.end()) {
      const PrinterTechnology tech = wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology();
      if (tech == ptFFF) {
        // MMU / FFF
        bool is_mmu = wxGetApp().extruders_edited_cnt() > 1;
        if (tag == "MMU") return (is_mmu ? TagCheckAffirmative : TagCheckNegative);
        return (tag == "FFF" ? TagCheckAffirmative : TagCheckNegative);
      }
      else {
        // SLA
        return (tag == "SLA" ? TagCheckAffirmative : TagCheckNegative);
      }
    }
    return TagCheckNotCompatible;
  }

References Slic3r::ptFFF, tag_check_tech(), TagCheckAffirmative, TagCheckNegative, and TagCheckNotCompatible.

Referenced by tag_check_tech(), and tags_check().

Here is the call graph for this function:

Here is the caller graph for this function:

tags_check()

bool Slic3r::GUI::anonymous_namespace{HintNotification.cpp}::tags_check	(	const std::string &	disabled_tags,
		const std::string &	enabled_tags )

  {
    if (disabled_tags.empty() && enabled_tags.empty())
      return true;
    // enabled tags must ALL return affirmative or check fails
    if (!enabled_tags.empty()) {
      std::string tag;
      for (size_t i = 0; i < enabled_tags.size(); i++) {
        if (enabled_tags[i] == ' ') {
          tag.erase();
          continue;
        }
        if (enabled_tags[i] != ';') {
          tag += enabled_tags[i];
        }
        if (enabled_tags[i] == ';' || i == enabled_tags.size() - 1) {
          if (!tag.empty()) {
            TagCheckResult result;
            result = tag_check_mode(tag);
            if (result == TagCheckResult::TagCheckNegative)
              return false;
            if (result == TagCheckResult::TagCheckAffirmative)
              continue;
            result = tag_check_tech(tag);
            if (result == TagCheckResult::TagCheckNegative)
              return false;
            if (result == TagCheckResult::TagCheckAffirmative)
              continue;
            result = tag_check_system(tag);
            if (result == TagCheckResult::TagCheckNegative)
              return false;
            if (result == TagCheckResult::TagCheckAffirmative)
              continue;
            result = tag_check_material(tag);
            if (result == TagCheckResult::TagCheckNegative)
              return false;
            if (result == TagCheckResult::TagCheckAffirmative)
              continue;
            BOOST_LOG_TRIVIAL(error) << "Hint Notification: Tag " << tag << " in enabled_tags not compatible.";
            // non compatible in enabled means return false since all enabled must be affirmative.
            return false;
          }
        }
      }
    }
    // disabled tags must all NOT return affirmative or check fails
    if (!disabled_tags.empty()) {
      std::string tag;
      for (size_t i = 0; i < disabled_tags.size(); i++) {
        if (disabled_tags[i] == ' ') {
          tag.erase();
          continue;
        }
        if (disabled_tags[i] != ';') {
          tag += disabled_tags[i];
        }
        if (disabled_tags[i] == ';' || i == disabled_tags.size() - 1) {
          if (!tag.empty()) {
            TagCheckResult result;
            result = tag_check_mode(tag);
            if (result == TagCheckResult::TagCheckNegative)
              continue;
            if (result == TagCheckResult::TagCheckAffirmative)
              return false;
            result = tag_check_tech(tag);
            if (result == TagCheckResult::TagCheckNegative)
              continue;
            if (result == TagCheckResult::TagCheckAffirmative)
              return false;
            result = tag_check_system(tag);
            if (result == TagCheckResult::TagCheckAffirmative)
              return false;
            if (result == TagCheckResult::TagCheckNegative)
              continue;
            result = tag_check_material(tag);
            if (result == TagCheckResult::TagCheckAffirmative)
              return false;
            if (result == TagCheckResult::TagCheckNegative)
              continue;
            BOOST_LOG_TRIVIAL(error) << "Hint Notification: Tag " << tag << " in disabled_tags not compatible.";
          }
        }
      }
    }
    return true;
  }

References tag_check_material(), tag_check_mode(), tag_check_system(), tag_check_tech(), TagCheckAffirmative, TagCheckNegative, and tags_check().

Referenced by tags_check().

Here is the call graph for this function:

Here is the caller graph for this function:

write_used_binary()

void Slic3r::GUI::anonymous_namespace{HintNotification.cpp}::write_used_binary

(

const std::vector< std::string > &

ids

)

  {
    boost::nowide::ofstream file((boost::filesystem::path(data_dir()) / "user" / "hints.cereal").string(), std::ios::binary);
    cereal::BinaryOutputArchive archive(file);
    HintsCerealData cd{ ids };
    try
    {
      archive(cd);
    }
    catch (const std::exception& ex)
    {
      BOOST_LOG_TRIVIAL(error) << "Failed to write to hints.cereal. " << ex.what();
    }
  }

References Slic3r::data_dir(), and write_used_binary().

Referenced by write_used_binary().

Here is the call graph for this function:

Here is the caller graph for this function: