├── test ├── int_test │ ├── sys.ini │ ├── config.ini │ └── xml │ │ ├── section1.xml │ │ ├── sectionobj.xml │ │ └── section2.xml ├── config_lock.ini ├── dummy.ini ├── expect_line.hpp ├── section_test.cpp ├── option_wrapper_test.cpp ├── option_base_test.cpp ├── meson.build ├── config_manager_test.cpp ├── log_test.cpp ├── number_locale_test.cpp ├── duration_test.cpp ├── option_test.cpp ├── file_test.cpp └── xml_test.cpp ├── meson_options.txt ├── src ├── section-impl.hpp ├── option-impl.hpp ├── option.cpp ├── section.cpp ├── config-manager.cpp ├── log.cpp ├── compound-option.cpp ├── duration.cpp ├── xml.cpp └── file.cpp ├── include ├── meson.build └── wayfire │ ├── config │ ├── option-types.hpp │ ├── config-manager.hpp │ ├── section.hpp │ ├── xml.hpp │ ├── file.hpp │ ├── option-wrapper.hpp │ ├── option.hpp │ ├── compound-option.hpp │ └── types.hpp │ ├── util │ ├── stringify.hpp │ ├── log.hpp │ └── duration.hpp │ └── nonstd │ └── safe-list.hpp ├── .github └── workflows │ └── ci.yaml ├── LICENSE └── meson.build /test/int_test/sys.ini: -------------------------------------------------------------------------------- 1 | [section2] 2 | option5 = Option5Sys 3 | -------------------------------------------------------------------------------- /test/config_lock.ini: -------------------------------------------------------------------------------- 1 | 2 | [section1] 3 | 4 | option1 = 12 5 | 6 | [section2] 7 | 8 | option2 = opt2 9 | -------------------------------------------------------------------------------- /test/dummy.ini: -------------------------------------------------------------------------------- 1 | [section1] 2 | option1 = 4 3 | option2 = 45 \# 46 \\ 4 | 5 | [section2] 6 | bey_k1 = 1.200000 7 | hey_k1 = 1 8 | option1 = 4.250000 9 | 10 | -------------------------------------------------------------------------------- /test/int_test/config.ini: -------------------------------------------------------------------------------- 1 | 2 | [section1] 3 | 4 | option1 = 12 5 | 6 | [section2] 7 | 8 | option2 = opt2 9 | option3 = DoesNotExistInXML \# \\ 10 | 11 | [sectionobj:objtest] 12 | 13 | option6 = 11 14 | -------------------------------------------------------------------------------- /meson_options.txt: -------------------------------------------------------------------------------- 1 | option('tests', type: 'feature', value: 'auto', description: 'Enable unit tests') 2 | option('locale_test', type : 'boolean', value : false, description: 'Test number to string conversions with de_DE locale (must be installed)') 3 | -------------------------------------------------------------------------------- /test/int_test/xml/section1.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | General 5 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /test/int_test/xml/sectionobj.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 |

11 | 12 | -------------------------------------------------------------------------------- /src/section-impl.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | struct wf::config::section_t::impl 8 | { 9 | public: 10 | std::map> options; 11 | std::string name; 12 | 13 | // Associated XML node 14 | xmlNode *xml = NULL; 15 | }; 16 | -------------------------------------------------------------------------------- /test/int_test/xml/section2.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | General 5 | 8 | 11 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /test/expect_line.hpp: -------------------------------------------------------------------------------- 1 | auto EXPECT_LINE = [] (std::istream& log, std::string expect) 2 | { 3 | auto tolower = [] (std::string s) 4 | { 5 | for (auto& c : s) 6 | { 7 | c = std::tolower(c); 8 | } 9 | 10 | return s; 11 | }; 12 | 13 | bool found = false; 14 | 15 | std::string line; 16 | while (!found && std::getline(log, line)) 17 | { 18 | /* Case-insensitive matching */ 19 | line = tolower(line); 20 | expect = tolower(expect); 21 | found |= (line.find(expect) != std::string::npos); 22 | } 23 | 24 | CHECK(found); 25 | }; 26 | -------------------------------------------------------------------------------- /include/meson.build: -------------------------------------------------------------------------------- 1 | headers_config = [ 2 | 'wayfire/config/xml.hpp', 3 | 'wayfire/config/config-manager.hpp', 4 | 'wayfire/config/section.hpp', 5 | 'wayfire/config/option-types.hpp', 6 | 'wayfire/config/types.hpp', 7 | 'wayfire/config/file.hpp', 8 | 'wayfire/config/option.hpp', 9 | 'wayfire/config/option-wrapper.hpp', 10 | 'wayfire/config/compound-option.hpp', 11 | ] 12 | 13 | headers_util = [ 14 | 'wayfire/util/log.hpp', 15 | 'wayfire/util/stringify.hpp', 16 | 'wayfire/util/duration.hpp' 17 | ] 18 | 19 | headers_nonstd = [ 20 | 'wayfire/nonstd/safe-list.hpp' 21 | ] 22 | 23 | install_headers(headers_config, subdir: 'wayfire/config') 24 | install_headers(headers_util, subdir: 'wayfire/util') 25 | install_headers(headers_nonstd, subdir: 'wayfire/nonstd') 26 | -------------------------------------------------------------------------------- /include/wayfire/config/option-types.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace wf 7 | { 8 | namespace option_type 9 | { 10 | /** 11 | * To create an option of a given type, from_string must be specialized for 12 | * parsing the type. 13 | * 14 | * @param string The string representation of the value. 15 | * @return The parsed value, if the string was valid. 16 | */ 17 | template 18 | std::optional from_string( 19 | const std::string& string); 20 | 21 | /** 22 | * To create an option of a given type, to_string must be specialized for 23 | * converting the type to string. 24 | * @return The string representation of a value. 25 | * It is expected that from_string(to_string(value)) == value. 26 | */ 27 | template 28 | std::string to_string(const Type& value); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /.github/workflows/ci.yaml: -------------------------------------------------------------------------------- 1 | name: CI 2 | 3 | on: [push, pull_request] 4 | jobs: 5 | test_code_style: 6 | name: "Check code style with uncrustify" 7 | runs-on: ubuntu-latest 8 | steps: 9 | - run: sudo apt-get update 10 | - run: sudo apt-get install -y git cmake gcc make 11 | - uses: actions/checkout@v1 12 | - run: git clone http://github.com/ammen99/uncrustify 13 | - run: cd uncrustify && mkdir build && cd build && cmake ../ && make && cd ../../ 14 | - run: curl https://raw.githubusercontent.com/WayfireWM/wayfire/master/uncrustify.ini > uncrustify.ini 15 | - run: git ls-files | grep "hpp$\|cpp$" | xargs ./uncrustify/build/uncrustify -c uncrustify.ini --check 16 | run_tests: 17 | name: "Check that tests do not break" 18 | runs-on: ubuntu-latest 19 | steps: 20 | - run: sudo apt-get update 21 | - run: sudo apt-get install -y cmake git gcc meson doctest-dev libevdev-dev libxml2-dev libglm-dev 22 | - uses: actions/checkout@v1 23 | - run: meson build 24 | - run: ninja -C build test 25 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2018-2019 Ilia Bozhinov 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /include/wayfire/util/stringify.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace wf 7 | { 8 | namespace log 9 | { 10 | /** 11 | * Convert the given parameter to a string which can be logged. 12 | * This function can be specialized for custom types. 13 | */ 14 | template 15 | std::string to_string(T arg) 16 | { 17 | std::ostringstream out; 18 | out << arg; 19 | return out.str(); 20 | } 21 | 22 | /** Specialization for boolean arguments - print true or false. */ 23 | template<> 24 | std::string to_string(bool arg); 25 | 26 | /* Specialization for pointers - print the address */ 27 | template 28 | std::string to_string(T *arg) 29 | { 30 | if (!arg) 31 | { 32 | return "(null)"; 33 | } 34 | 35 | return to_string(arg); 36 | } 37 | 38 | namespace detail 39 | { 40 | /** 41 | * Convert each argument to a string and then concatenate them. 42 | */ 43 | template 44 | std::string format_concat(First arg) 45 | { 46 | return wf::log::to_string(arg); 47 | } 48 | 49 | template 50 | std::string format_concat(First first, Args... args) 51 | { 52 | return format_concat(first) + format_concat(args...); 53 | } 54 | } 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /src/option-impl.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | namespace wf 10 | { 11 | namespace config 12 | { 13 | /** 14 | * Update the value of a compound option option by reading options from the section. 15 | * The format is as described in the compound option constructor docstring. 16 | * 17 | * Note: options which have been created from XML are ignored, and only 18 | * options which have been created from parsing a string/file with wf-config 19 | * are taken into account. 20 | */ 21 | void update_compound_from_section(compound_option_t& option, 22 | const std::shared_ptr& section); 23 | } 24 | } 25 | 26 | struct wf::config::option_base_t::impl 27 | { 28 | std::string name; 29 | wf::safe_list_t updated_handlers; 30 | 31 | // Number of times the option has been locked 32 | int32_t lock_count = 0; 33 | 34 | // Associated XML node 35 | xmlNode *xml = nullptr; 36 | 37 | // Is option in config file? 38 | bool option_in_config_file = false; 39 | 40 | // Is option part of a successfully parsed compound option? 41 | bool is_part_compound = false; 42 | // Does this option match a compound option in part at least? 43 | bool could_be_compound = false; 44 | }; 45 | -------------------------------------------------------------------------------- /src/option.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "option-impl.hpp" 6 | #include "wayfire/util/log.hpp" 7 | 8 | const std::string& wf::config::option_base_t::get_name() const 9 | { 10 | return this->priv->name; 11 | } 12 | 13 | void wf::config::option_base_t::add_updated_handler( 14 | updated_callback_t *callback) 15 | { 16 | this->priv->updated_handlers.push_back(callback); 17 | } 18 | 19 | void wf::config::option_base_t::rem_updated_handler( 20 | updated_callback_t *callback) 21 | { 22 | priv->updated_handlers.remove_all(callback); 23 | } 24 | 25 | wf::config::option_base_t::option_base_t(const std::string& name) 26 | { 27 | this->priv = std::make_unique(); 28 | this->priv->name = name; 29 | } 30 | 31 | wf::config::option_base_t::~option_base_t() = default; 32 | 33 | void wf::config::option_base_t::notify_updated() const 34 | { 35 | priv->updated_handlers.for_each([] (updated_callback_t *call) 36 | { 37 | (*call)(); 38 | }); 39 | } 40 | 41 | void wf::config::option_base_t::set_locked(bool locked) 42 | { 43 | this->priv->lock_count += (locked ? 1 : -1); 44 | if (priv->lock_count < 0) 45 | { 46 | LOGE("Lock counter for option ", this->get_name(), " dropped below zero!"); 47 | } 48 | } 49 | 50 | bool wf::config::option_base_t::is_locked() const 51 | { 52 | return this->priv->lock_count > 0; 53 | } 54 | 55 | void wf::config::option_base_t::init_clone(option_base_t& other) const 56 | { 57 | other.priv->xml = this->priv->xml; 58 | other.priv->name = this->priv->name; 59 | } 60 | -------------------------------------------------------------------------------- /meson.build: -------------------------------------------------------------------------------- 1 | project( 2 | 'wf-config', 3 | 'cpp', 4 | version: '0.11.0', 5 | license: 'MIT', 6 | meson_version: '>=0.47.0', 7 | default_options: [ 8 | 'cpp_std=c++17', 9 | 'warning_level=2', 10 | 'werror=false', 11 | ], 12 | ) 13 | 14 | add_project_arguments(['-Wno-deprecated-declarations'], language: ['cpp']) 15 | 16 | glm = dependency('glm', required: false) 17 | if not glm.found() and not meson.get_compiler('cpp').check_header('glm/glm.hpp') 18 | error('GLM not found, and directly using the header \'glm/glm.hpp\' is not possible.') 19 | endif 20 | 21 | evdev = dependency('libevdev') 22 | libxml2 = dependency('libxml-2.0') 23 | 24 | sources = [ 25 | 'src/types.cpp', 26 | 'src/option.cpp', 27 | 'src/section.cpp', 28 | 'src/log.cpp', 29 | 'src/xml.cpp', 30 | 'src/config-manager.cpp', 31 | 'src/file.cpp', 32 | 'src/duration.cpp', 33 | 'src/compound-option.cpp', 34 | ] 35 | 36 | wfconfig_inc = include_directories('include') 37 | 38 | lib_wfconfig = library('wf-config', 39 | sources, 40 | dependencies: [evdev, glm, libxml2], 41 | include_directories: wfconfig_inc, 42 | install: true, 43 | version: meson.project_version(), 44 | soversion: '1') 45 | 46 | pkgconfig = import('pkgconfig') 47 | pkgconfig.generate( 48 | libraries: lib_wfconfig, 49 | version: meson.project_version(), 50 | filebase: meson.project_name(), 51 | name: meson.project_name(), 52 | description: 'Dynamic file-based configuration library for Wayfire') 53 | 54 | install_headers([], subdir: 'wayfire/config') 55 | 56 | wfconfig = declare_dependency(link_with: lib_wfconfig, 57 | include_directories: wfconfig_inc, 58 | dependencies: glm) 59 | 60 | # Install headers 61 | subdir('include') 62 | 63 | # Unit tests 64 | doctest = dependency('doctest', required: get_option('tests')) 65 | 66 | if doctest.found() 67 | subdir('test') 68 | endif 69 | -------------------------------------------------------------------------------- /test/section_test.cpp: -------------------------------------------------------------------------------- 1 | #define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN 2 | #include 3 | 4 | #include 5 | #include 6 | #include "../src/section-impl.hpp" 7 | 8 | TEST_CASE("wf::config::section_t") 9 | { 10 | using namespace wf; 11 | using namespace wf::config; 12 | 13 | section_t section{"Test_Section-12.34"}; 14 | CHECK(section.get_name() == "Test_Section-12.34"); 15 | CHECK(section.get_registered_options().empty()); 16 | CHECK(section.get_option_or("non_existing") == nullptr); 17 | 18 | auto intopt = std::make_shared>("IntOption", 123); 19 | section.register_new_option(intopt); 20 | 21 | CHECK(section.get_option("IntOption") == intopt); 22 | CHECK(section.get_option_or("IntOption") == intopt); 23 | CHECK(section.get_option_or("DoubleOption") == nullptr); 24 | 25 | auto reg_opts = section.get_registered_options(); 26 | REQUIRE(reg_opts.size() == 1); 27 | CHECK(reg_opts.back() == intopt); 28 | 29 | auto intopt2 = std::make_shared>("IntOption", 125); 30 | section.register_new_option(intopt2); // overwrite 31 | CHECK(section.get_option_or("IntOption") == intopt2); 32 | 33 | reg_opts = section.get_registered_options(); 34 | REQUIRE(reg_opts.size() == 1); 35 | CHECK(reg_opts.back() == intopt2); 36 | section.unregister_option(intopt2); 37 | CHECK(section.get_registered_options().empty()); 38 | 39 | section.register_new_option(intopt); 40 | section.priv->xml = (xmlNode*)0x123; 41 | auto clone = section.clone_with_name("Cloned_Section"); 42 | CHECK(clone->get_name() == "Cloned_Section"); 43 | CHECK(clone->priv->xml == (xmlNode*)0x123); 44 | CHECK(clone->get_option_or("IntOption") != intopt); 45 | CHECK(clone->get_option_or("IntOption")->get_name() == intopt->get_name()); 46 | CHECK(clone->get_option_or( 47 | "IntOption")->get_value_str() == intopt->get_value_str()); 48 | } 49 | -------------------------------------------------------------------------------- /include/wayfire/config/config-manager.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace wf 6 | { 7 | namespace config 8 | { 9 | /** 10 | * Manages the whole configuration of a program. 11 | * The configuration consists of a list of sections with their options. 12 | */ 13 | class config_manager_t 14 | { 15 | public: 16 | /** 17 | * Add the given config section to the configuration. 18 | * If the section already exists, each new option will be added to the 19 | * existing section, and already existing options will be overwritten. 20 | * 21 | * @param section The section to add, must be non-null. 22 | */ 23 | void merge_section(std::shared_ptr section); 24 | 25 | /** 26 | * Find the configuration section with the given name. 27 | * @return nullptr if the section doesn't exist. 28 | */ 29 | std::shared_ptr get_section(const std::string& name) const; 30 | 31 | /** 32 | * @return A list of all sections currently in the config manager. 33 | */ 34 | std::vector> get_all_sections() const; 35 | 36 | /** 37 | * Get the option with the given name. 38 | * The name consists of the name of the option section, followed by a '/', 39 | * then followed by the actual name of the option in the option section, 40 | * for example 'core/plugins'. 41 | * 42 | * If the option doesn't exist, nullptr is returned. 43 | */ 44 | std::shared_ptr get_option(const std::string& name) const; 45 | 46 | /** 47 | * Get the option with the given name. Same semantics as 48 | * get_option(std::string), but casts the result to the appropriate type. 49 | */ 50 | template 51 | std::shared_ptr> get_option(const std::string& name) const 52 | { 53 | return std::dynamic_pointer_cast>(get_option(name)); 54 | } 55 | 56 | config_manager_t(); 57 | config_manager_t(config_manager_t&& other); 58 | config_manager_t& operator =(config_manager_t&& other); 59 | 60 | virtual ~config_manager_t(); 61 | 62 | private: 63 | struct impl; 64 | std::unique_ptr priv; 65 | }; 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /include/wayfire/config/section.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace wf 8 | { 9 | namespace config 10 | { 11 | /** 12 | * Represents a section in the config file. 13 | * Each section has a list of options. 14 | */ 15 | class section_t 16 | { 17 | public: 18 | /** 19 | * Create a new empty section. 20 | * 21 | * The section name can be arbitrary, however when reading config from a 22 | * file there are additional restrictions. 23 | */ 24 | section_t(const std::string& name); 25 | virtual ~section_t(); 26 | 27 | /** @return The name of the config section. */ 28 | std::string get_name() const; 29 | 30 | /** @return A deep copy of the config section with a new name. */ 31 | std::shared_ptr clone_with_name(const std::string name) const; 32 | 33 | /** 34 | * @return The option with the given name, or nullptr if no such option 35 | * has been added yet. 36 | */ 37 | std::shared_ptr get_option_or(const std::string& name); 38 | 39 | /** 40 | * @return The option with the given name. 41 | * @throws std::invalid_argument if the option hasn't been added. 42 | */ 43 | std::shared_ptr get_option(const std::string& name); 44 | 45 | using option_list_t = std::vector>; 46 | /** 47 | * @return A list of all available options in this config section. 48 | */ 49 | option_list_t get_registered_options() const; 50 | 51 | /** 52 | * Register a new option, which means it is marked as belonging to this 53 | * section and it will show up in the list of get_registered_options(). 54 | * 55 | * If an option with the same name already exists, it will be overwritten. 56 | */ 57 | void register_new_option(std::shared_ptr option); 58 | 59 | /** 60 | * Remove an option from the registered options in this section. 61 | * No-op if the option is not part of the section, or if option is null. 62 | */ 63 | void unregister_option(std::shared_ptr option); 64 | 65 | struct impl; 66 | std::unique_ptr priv; 67 | }; 68 | } 69 | } 70 | -------------------------------------------------------------------------------- /test/option_wrapper_test.cpp: -------------------------------------------------------------------------------- 1 | #define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN 2 | #include 3 | 4 | #include 5 | #include 6 | 7 | static wf::config::config_manager_t config; 8 | 9 | template 10 | class wrapper_t : public wf::base_option_wrapper_t 11 | { 12 | public: 13 | wrapper_t() : wf::base_option_wrapper_t() 14 | {} 15 | wrapper_t(const std::string& option) : 16 | wf::base_option_wrapper_t() 17 | { 18 | this->load_option(option); 19 | } 20 | 21 | protected: 22 | std::shared_ptr load_raw_option( 23 | const std::string& name) override 24 | { 25 | return config.get_option(name); 26 | } 27 | }; 28 | 29 | TEST_CASE("wf::base_option_wrapper_t") 30 | { 31 | using namespace wf; 32 | using namespace wf::config; 33 | 34 | auto section = std::make_shared("Test"); 35 | auto opt = std::make_shared>("Option1", 5); 36 | 37 | compound_option_t::entries_t entries; 38 | entries.push_back(std::make_unique>("hey_")); 39 | entries.push_back(std::make_unique>("bey_")); 40 | 41 | auto coptr = new compound_option_t{"Option2", std::move(entries)}; 42 | auto copt = std::shared_ptr(coptr); 43 | 44 | section->register_new_option(opt); 45 | section->register_new_option(copt); 46 | ::config.merge_section(section); 47 | 48 | wrapper_t wrapper{"Test/Option1"}; 49 | CHECK((option_sptr_t)wrapper == opt); 50 | CHECK(wrapper == 5); 51 | 52 | wrapper_t> wrapper2{"Test/Option2"}; 53 | CHECK((std::shared_ptr)wrapper2 == copt); 54 | bool value_in_compound_list_is_ok = 55 | (wrapper2.value() == compound_list_t{}); 56 | CHECK(value_in_compound_list_is_ok); 57 | 58 | bool updated = false; 59 | wrapper.set_callback([&] () 60 | { 61 | updated = true; 62 | }); 63 | opt->set_value(6); 64 | CHECK(updated); 65 | 66 | /* Check move operations */ 67 | wrapper_t wrapper1{"Test/Option1"}; 68 | CHECK((option_sptr_t)wrapper1 == opt); 69 | } 70 | -------------------------------------------------------------------------------- /test/option_base_test.cpp: -------------------------------------------------------------------------------- 1 | #define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN 2 | #include 3 | #include 4 | 5 | class option_base_stub_t : public wf::config::option_base_t 6 | { 7 | public: 8 | option_base_stub_t(std::string name) : 9 | option_base_t(name) 10 | {} 11 | 12 | std::shared_ptr clone_option() const override 13 | { 14 | return nullptr; 15 | } 16 | 17 | bool set_default_value_str(const std::string&) override 18 | { 19 | return true; 20 | } 21 | 22 | bool set_value_str(const std::string&) override 23 | { 24 | return false; 25 | } 26 | 27 | void reset_to_default() override 28 | {} 29 | std::string get_value_str() const override 30 | { 31 | return ""; 32 | } 33 | 34 | std::string get_default_value_str() const override 35 | { 36 | return ""; 37 | } 38 | 39 | public: 40 | void notify_updated() const 41 | { 42 | option_base_t::notify_updated(); 43 | } 44 | }; 45 | 46 | 47 | TEST_CASE("wf::option_base_t") 48 | { 49 | option_base_stub_t option{"string"}; 50 | CHECK(option.get_name() == "string"); 51 | 52 | int callback_called = 0; 53 | int callback2_called = 0; 54 | 55 | wf::config::option_base_t::updated_callback_t callback, callback2; 56 | callback = [&] () { callback_called++; }; 57 | callback2 = [&] () { callback2_called++; }; 58 | 59 | option.add_updated_handler(&callback); 60 | option.notify_updated(); 61 | CHECK(callback_called == 1); 62 | CHECK(callback2_called == 0); 63 | 64 | option.add_updated_handler(&callback); 65 | option.add_updated_handler(&callback2); 66 | option.notify_updated(); 67 | CHECK(callback_called == 3); 68 | CHECK(callback2_called == 1); 69 | 70 | option.rem_updated_handler(&callback); 71 | option.notify_updated(); 72 | CHECK(callback_called == 3); 73 | CHECK(callback2_called == 2); 74 | 75 | option.rem_updated_handler(&callback2); 76 | option.notify_updated(); 77 | CHECK(callback_called == 3); 78 | CHECK(callback2_called == 2); 79 | 80 | option.set_locked(); 81 | CHECK(option.is_locked()); 82 | option.set_locked(); 83 | option.set_locked(false); 84 | CHECK(option.is_locked()); 85 | option.set_locked(false); 86 | CHECK(option.is_locked() == false); 87 | } 88 | -------------------------------------------------------------------------------- /src/section.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "section-impl.hpp" 3 | 4 | wf::config::section_t::section_t(const std::string& name) 5 | { 6 | this->priv = std::make_unique(); 7 | this->priv->name = name; 8 | } 9 | 10 | wf::config::section_t::~section_t() = default; 11 | 12 | std::string wf::config::section_t::get_name() const 13 | { 14 | return this->priv->name; 15 | } 16 | 17 | std::shared_ptr wf::config::section_t::clone_with_name( 18 | const std::string name) const 19 | { 20 | auto result = std::make_shared(name); 21 | for (auto& option : priv->options) 22 | { 23 | result->register_new_option(option.second->clone_option()); 24 | } 25 | 26 | result->priv->xml = this->priv->xml; 27 | return result; 28 | } 29 | 30 | std::shared_ptr wf::config::section_t::get_option_or( 31 | const std::string& name) 32 | { 33 | if (this->priv->options.count(name)) 34 | { 35 | return this->priv->options[name]; 36 | } 37 | 38 | return nullptr; 39 | } 40 | 41 | std::shared_ptr wf::config::section_t::get_option( 42 | const std::string& name) 43 | { 44 | auto option = get_option_or(name); 45 | if (!option) 46 | { 47 | throw std::invalid_argument("Non-existing option " + name + 48 | " in config section " + this->get_name()); 49 | } 50 | 51 | return option; 52 | } 53 | 54 | wf::config::section_t::option_list_t wf::config::section_t::get_registered_options() 55 | const 56 | { 57 | option_list_t list; 58 | for (auto& option : priv->options) 59 | { 60 | list.push_back(option.second); 61 | } 62 | 63 | return list; 64 | } 65 | 66 | void wf::config::section_t::register_new_option( 67 | std::shared_ptr option) 68 | { 69 | if (!option) 70 | { 71 | throw std::invalid_argument( 72 | "Cannot add null option to section " + this->get_name()); 73 | } 74 | 75 | this->priv->options[option->get_name()] = option; 76 | } 77 | 78 | void wf::config::section_t::unregister_option( 79 | std::shared_ptr option) 80 | { 81 | if (!option) 82 | { 83 | return; 84 | } 85 | 86 | auto it = this->priv->options.find(option->get_name()); 87 | if ((it != this->priv->options.end()) && (it->second == option)) 88 | { 89 | this->priv->options.erase(it); 90 | } 91 | } 92 | -------------------------------------------------------------------------------- /test/meson.build: -------------------------------------------------------------------------------- 1 | types_test = executable( 2 | 'types_test', 3 | 'types_test.cpp', 4 | dependencies: [wfconfig, doctest], 5 | install: false) 6 | test('Types test', types_test) 7 | 8 | option_base_test = executable( 9 | 'option_base_test', 10 | 'option_base_test.cpp', 11 | dependencies: [wfconfig, doctest], 12 | install: false) 13 | test('OptionBase test', option_base_test) 14 | 15 | option_test = executable( 16 | 'option_test', 17 | 'option_test.cpp', 18 | dependencies: [wfconfig, doctest, libxml2], 19 | install: false) 20 | test('Option test', option_test) 21 | 22 | option_wrapper_test = executable( 23 | 'option_wrapper_test', 24 | 'option_wrapper_test.cpp', 25 | dependencies: [wfconfig, doctest], 26 | install: false) 27 | test('Option wrapper test', option_wrapper_test) 28 | 29 | section_test = executable( 30 | 'section_test', 31 | 'section_test.cpp', 32 | dependencies: [wfconfig, doctest, libxml2], 33 | install: false) 34 | test('Section test', section_test) 35 | 36 | xml_test = executable( 37 | 'xml_test', 38 | 'xml_test.cpp', 39 | include_directories: wfconfig_inc, 40 | dependencies: [wfconfig, doctest, libxml2], 41 | install: false) 42 | test('XML test', xml_test) 43 | 44 | config_manager_test = executable( 45 | 'config_manager_test', 46 | 'config_manager_test.cpp', 47 | dependencies: [wfconfig, doctest], 48 | install: false) 49 | test('ConfigManager test', config_manager_test) 50 | 51 | file_parse_test = executable( 52 | 'file_test', 53 | 'file_test.cpp', 54 | dependencies: [wfconfig, doctest, libxml2], 55 | install: false, 56 | cpp_args: '-DTEST_SOURCE="' + meson.current_source_dir() + '"') 57 | test('File parsing test', file_parse_test) 58 | 59 | # Utils 60 | log_test = executable( 61 | 'log_test', 62 | 'log_test.cpp', 63 | dependencies: [wfconfig, doctest], 64 | install: false) 65 | test('Log test', log_test) 66 | 67 | duration_test = executable( 68 | 'duration_test', 69 | 'duration_test.cpp', 70 | dependencies: [wfconfig, doctest], 71 | install: false) 72 | test('Duration test', duration_test) 73 | 74 | number_locale_test = executable( 75 | 'number_locale_test', 76 | 'number_locale_test.cpp', 77 | dependencies: [wfconfig, doctest], 78 | install: false) 79 | # enable locale test only on request 80 | if get_option('locale_test') 81 | test('Number locale test', number_locale_test) 82 | endif 83 | -------------------------------------------------------------------------------- /include/wayfire/config/xml.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | /** 3 | * This file contains definitions related to parsing XML files and turning them 4 | * into config options and sections. 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | #include 11 | #include 12 | 13 | namespace wf 14 | { 15 | namespace config 16 | { 17 | namespace xml 18 | { 19 | /** 20 | * Create a new option from the given data in the xmlNode. 21 | * Errors are printed to the log (see wayfire/util/log.hpp). 22 | * 23 | * If the operation is successful, the xmlNodePtr should not be freed, because 24 | * an internal reference will be taken. 25 | * 26 | * @param node The xmlNode which corresponds to the option. 27 | * The attributes used are name and type, as well as the child. 28 | * 29 | * @return The generated option, if the xmlNode contained a valid option, and 30 | * nullptr otherwise. The dynamic type of the option is 31 | * wf::config::option_t, depending on the type attribute of the xmlNode. 32 | */ 33 | std::shared_ptr create_option_from_xml_node( 34 | xmlNodePtr node); 35 | 36 | /** 37 | * Create a new section from the given xmlNode and add each successfully parsed 38 | * child as an option in the section. 39 | * Errors are printed to the log (see wayfire/util/log.hpp). 40 | * 41 | * If the operation is successful, the xmlNodePtr should not be freed, because 42 | * an internal reference will be taken. 43 | * 44 | * @param node the xmlNode which corresponds to the section node. The only 45 | * attribute of @node used is name, and it determines the name of the generated 46 | * section. 47 | * 48 | * @return nullptr if section name is missing from the xmlNode, and the 49 | * generated config section otherwise. 50 | */ 51 | std::shared_ptr create_section_from_xml_node(xmlNodePtr node); 52 | 53 | /** 54 | * Get the XML node which was used to create @option with 55 | * create_option_from_xml_node. 56 | * 57 | * @return The xmlNodePtr or NULL if the option wasn't created from an xml node. 58 | */ 59 | xmlNodePtr get_option_xml_node( 60 | std::shared_ptr option); 61 | 62 | /** 63 | * Get the XML node which was used to create @section with 64 | * create_section_from_xml_node. 65 | * 66 | * @return The xmlNodePtr or NULL if the section wasn't created from an xml 67 | * node. 68 | */ 69 | xmlNodePtr get_section_xml_node(std::shared_ptr section); 70 | } 71 | } 72 | } 73 | -------------------------------------------------------------------------------- /include/wayfire/util/log.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | /** 4 | * Utilities for logging to a selected output stream. 5 | */ 6 | #include 7 | 8 | namespace wf 9 | { 10 | namespace log 11 | { 12 | enum log_level_t 13 | { 14 | /** Lowest level, gray if colors are enabled. */ 15 | LOG_LEVEL_DEBUG = 0, 16 | /** Information level, no coloring. */ 17 | LOG_LEVEL_INFO = 1, 18 | /** Warning level, yellow/orange. */ 19 | LOG_LEVEL_WARN = 2, 20 | /** Error level, red. */ 21 | LOG_LEVEL_ERROR = 3, 22 | }; 23 | 24 | enum color_mode_t 25 | { 26 | /** Color codes are on */ 27 | LOG_COLOR_MODE_ON = 1, 28 | /** Color codes are off */ 29 | LOG_COLOR_MODE_OFF = 2, 30 | }; 31 | 32 | /** 33 | * (Re-)Initialize the logging system. 34 | * The log output after this call will go to the indicated output stream. 35 | * 36 | * @param minimum_level The minimum severity that a log message needs to have so 37 | * that it can get published. 38 | * 39 | * @param color_mode Whether to enable coloring of the output. 40 | * 41 | * @param strip_path The prefix of file path to strip when debugging with the 42 | * helper macros LOG(D,I,W,E) 43 | */ 44 | void initialize_logging(std::ostream& output_stream, log_level_t minimum_level, 45 | color_mode_t color_mode, std::string strip_path = ""); 46 | 47 | /** 48 | * Log a plain message to the given output stream. 49 | * The output format is: 50 | * 51 | * LL DD-MM-YY HH:MM:SS.MSS - [source:line] message 52 | * 53 | * @param level The log level of the passed message. 54 | * @param contents The message to be printed. 55 | * @param source The file where the message originates from. The prefix 56 | * strip_path specified in initialize_logging will be removed, if it exists. 57 | * If source is empty, no file/line information will be printed. 58 | * @param line The line number of @source 59 | */ 60 | void log_plain(log_level_t level, const std::string& contents, 61 | const std::string& source = "", int line = 0); 62 | } 63 | } 64 | 65 | /** 66 | * A convenience wrapper around log_plain 67 | */ 68 | #define LOG(level, ...) \ 69 | wf::log::log_plain(level, \ 70 | wf::log::detail::format_concat(__VA_ARGS__), __FILE__, __LINE__) 71 | 72 | /** Log a debug message */ 73 | #define LOGD(...) LOG(wf::log::LOG_LEVEL_DEBUG, __VA_ARGS__) 74 | /** Log an info message */ 75 | #define LOGI(...) LOG(wf::log::LOG_LEVEL_INFO, __VA_ARGS__) 76 | /** Log a warning message */ 77 | #define LOGW(...) LOG(wf::log::LOG_LEVEL_WARN, __VA_ARGS__) 78 | /** Log an error message */ 79 | #define LOGE(...) LOG(wf::log::LOG_LEVEL_ERROR, __VA_ARGS__) 80 | -------------------------------------------------------------------------------- /src/config-manager.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | struct wf::config::config_manager_t::impl 6 | { 7 | std::map> sections; 8 | }; 9 | 10 | void wf::config::config_manager_t::merge_section( 11 | std::shared_ptr section) 12 | { 13 | assert(section); 14 | if (this->priv->sections.count(section->get_name()) == 0) 15 | { 16 | /* Did not exist previously, just add the new section */ 17 | this->priv->sections[section->get_name()] = section; 18 | return; 19 | } 20 | 21 | /* Merge with existing config section */ 22 | auto existing_section = get_section(section->get_name()); 23 | auto merging_options = section->get_registered_options(); 24 | for (auto& option : merging_options) 25 | { 26 | auto existing_option = 27 | existing_section->get_option_or(option->get_name()); 28 | 29 | if (existing_option) 30 | { 31 | existing_option->set_value_str(option->get_value_str()); 32 | } else 33 | { 34 | existing_section->register_new_option(option); 35 | } 36 | } 37 | } 38 | 39 | std::shared_ptr wf::config::config_manager_t::get_section( 40 | const std::string& name) const 41 | { 42 | if (this->priv->sections.count(name)) 43 | { 44 | return this->priv->sections.at(name); 45 | } 46 | 47 | return nullptr; 48 | } 49 | 50 | std::vector> wf::config::config_manager_t::get_all_sections() const 51 | { 52 | std::vector> list; 53 | for (auto& section : this->priv->sections) 54 | { 55 | list.push_back(section.second); 56 | } 57 | 58 | return list; 59 | } 60 | 61 | std::shared_ptr wf::config::config_manager_t::get_option( 62 | const std::string& name) const 63 | { 64 | size_t splitter = name.find_first_of("/"); 65 | if (splitter == std::string::npos) 66 | { 67 | return nullptr; 68 | } 69 | 70 | auto section_name = name.substr(0, splitter); 71 | auto option_name = name.substr(splitter + 1); 72 | if (section_name.empty() || option_name.empty()) 73 | { 74 | return nullptr; 75 | } 76 | 77 | auto section_ptr = get_section(section_name); 78 | if (section_ptr) 79 | { 80 | return section_ptr->get_option_or(option_name); 81 | } 82 | 83 | return nullptr; 84 | } 85 | 86 | wf::config::config_manager_t::config_manager_t() 87 | { 88 | this->priv = std::make_unique(); 89 | } 90 | 91 | /** Default move operations */ 92 | wf::config::config_manager_t::config_manager_t( 93 | config_manager_t&& other) = default; 94 | wf::config::config_manager_t& wf::config::config_manager_t::operator =( 95 | config_manager_t&& other) = default; 96 | 97 | wf::config::config_manager_t::~config_manager_t() = default; 98 | -------------------------------------------------------------------------------- /test/config_manager_test.cpp: -------------------------------------------------------------------------------- 1 | #define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN 2 | #include 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | TEST_CASE("wf::config::config_manager_t") 9 | { 10 | using namespace wf; 11 | using namespace wf::config; 12 | using namespace option_type; 13 | 14 | config_manager_t config{}; 15 | auto expect_sections = [&] (std::set names) 16 | { 17 | auto all = config.get_all_sections(); 18 | CHECK(all.size() == names.size()); 19 | 20 | std::set present; 21 | std::transform(all.begin(), all.end(), 22 | std::inserter(present, present.end()), 23 | [] (const auto& section) { return section->get_name(); }); 24 | CHECK(present == names); 25 | }; 26 | 27 | expect_sections({}); 28 | 29 | CHECK(config.get_option("no_such_option") == nullptr); 30 | CHECK(config.get_option("section/nonexistent") == nullptr); 31 | CHECK(config.get_option("section/nonexist/ent") == nullptr); 32 | 33 | CHECK(config.get_section("FirstSection") == nullptr); 34 | config.merge_section(std::make_shared("FirstSection")); 35 | expect_sections({"FirstSection"}); 36 | 37 | auto section = config.get_section("FirstSection"); 38 | REQUIRE(section != nullptr); 39 | CHECK(section->get_name() == "FirstSection"); 40 | CHECK(section->get_registered_options().empty()); 41 | 42 | CHECK(config.get_option("FirstSection/FirstOption") == nullptr); 43 | 44 | auto color = option_type::from_string("#FFFF").value(); 45 | auto option = std::make_shared>("ColorOption", color); 46 | section->register_new_option(option); 47 | 48 | CHECK(config.get_option( 49 | "FirstSection/ColorOption")->get_value() == color); 50 | CHECK(config.get_option("FirstSection/ColorOption") == option); 51 | 52 | auto section2 = config.get_section("SecondSection"); 53 | CHECK(section2 == nullptr); 54 | 55 | auto section_overwrite = std::make_shared("FirstSection"); 56 | section_overwrite->register_new_option( 57 | std::make_shared>( 58 | "ColorOption", from_string("#CCCC").value())); 59 | section_overwrite->register_new_option( 60 | std::make_shared>("IntOption", 5)); 61 | 62 | section2 = std::make_shared("SecondSection"); 63 | section2->register_new_option( 64 | std::make_shared>("IntOption", 6)); 65 | 66 | config.merge_section(section_overwrite); 67 | CHECK(config.get_section("FirstSection") == section); // do not overwrite 68 | expect_sections({"FirstSection"}); 69 | 70 | auto stored_color_opt = 71 | config.get_option("FirstSection/ColorOption"); 72 | REQUIRE(stored_color_opt != nullptr); 73 | CHECK(stored_color_opt->get_value_str() == "#CCCCCCCC"); 74 | 75 | auto stored_int_opt = 76 | config.get_option("FirstSection/IntOption"); 77 | REQUIRE(stored_int_opt); 78 | CHECK(stored_int_opt->get_value_str() == "5"); 79 | 80 | config.merge_section(section2); 81 | expect_sections({"FirstSection", "SecondSection"}); 82 | 83 | stored_int_opt = config.get_option("FirstSection/IntOption"); 84 | REQUIRE(stored_int_opt); 85 | CHECK(stored_int_opt->get_value_str() == "5"); // remains same 86 | 87 | stored_int_opt = config.get_option("SecondSection/IntOption"); 88 | REQUIRE(stored_int_opt); 89 | CHECK(stored_int_opt->get_value_str() == "6"); 90 | } 91 | -------------------------------------------------------------------------------- /include/wayfire/config/file.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace wf 6 | { 7 | namespace config 8 | { 9 | /** 10 | * Parse a multi-line string as a configuration file. 11 | * The string consists of multiple sections of the following format: 12 | * 13 | * [section_name] 14 | * option1 = value1 15 | * option2 = value2 16 | * ... 17 | * 18 | * Blank lines and whitespace characters around the '=' sign are ignored, as 19 | * well as whitespaces at the beginning or at the end of each line. 20 | * 21 | * When a line contains a '#', the line from this point on is considered a 22 | * comment except when it is immediately preceded by a '\'. 23 | * 24 | * When a line ends in '\', it automatically joined with the next line, except 25 | * if it isn't escaped with another '\'. 26 | * 27 | * Each valid parsed option is used to set the value of the corresponding option 28 | * in @manager. Each line which contains errors is reported on the log and then 29 | * ignored. 30 | * 31 | * @param manager The config manager to update. 32 | * @param source The multi-line string representing the source 33 | * @param source_name The name to be used when reporting errors to the log 34 | */ 35 | void load_configuration_options_from_string(config_manager_t& manager, 36 | const std::string& source, const std::string& source_name = ""); 37 | 38 | /** 39 | * Create a string which conttains all the sections and the options in the given 40 | * configuration manager. The format is the same one as the one described in 41 | * load_configuration_options_from_string() 42 | * 43 | * @return The string representation of the config manager. 44 | */ 45 | std::string save_configuration_options_to_string( 46 | const config_manager_t& manager); 47 | 48 | /** 49 | * Load the options from the given config file. 50 | * 51 | * This is roughly equivalent to reading the file to a string, and then calling 52 | * load_configuration_options_from_string(), but this function also tries to get 53 | * a shared lock on the config file, and does not do anything if another process 54 | * already holds an exclusive lock. 55 | * 56 | * @param manager The config manager to update. 57 | * @param file The config file to use. 58 | * 59 | * @return True if the config file was reloaded, false if file could not be 60 | * opened or a lock could not be acquired. 61 | */ 62 | bool load_configuration_options_from_file(config_manager_t& manager, 63 | const std::string& file); 64 | 65 | /** 66 | * Writes the options in the given configuration to the given file. 67 | * It is roughly equivalent to calling serialize_configuration_manager() and 68 | * then replacing the file contents with the resulting string, but this function 69 | * waits until it can get an exclusive lock on the config file. 70 | */ 71 | void save_configuration_to_file(const config_manager_t& manager, 72 | const std::string& file); 73 | 74 | /** 75 | * Build a configuration for the given program from the files on the filesystem. 76 | * 77 | * The following steps are performed: 78 | * 1. Each of the XML files in each of @xmldirs are read, and options there 79 | * are used to build a configuration. Note that the XML nodes which are 80 | * allocated will not be freed. 81 | * 2. The @sysconf file is used to overwrite default values from XML files. 82 | * 3. The @userconf file is used to determine the actual values of options. 83 | * 84 | * If any of the steps results in an error, the error will be reported to the 85 | * command line and the process will continue. 86 | */ 87 | config_manager_t build_configuration(const std::vector& xmldirs, 88 | const std::string& sysconf, const std::string& userconf); 89 | } 90 | } 91 | -------------------------------------------------------------------------------- /test/log_test.cpp: -------------------------------------------------------------------------------- 1 | #define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN 2 | #include 3 | #include 4 | 5 | #include 6 | 7 | struct test_struct 8 | { 9 | int x, y; 10 | }; 11 | 12 | namespace wf 13 | { 14 | namespace log 15 | { 16 | template<> 17 | std::string to_string(test_struct str) 18 | { 19 | return "(" + std::to_string(str.x) + "," + std::to_string(str.y) + ")"; 20 | } 21 | } 22 | } 23 | 24 | TEST_CASE("wf::log::detail::format_concat()") 25 | { 26 | using namespace wf::log; 27 | 28 | CHECK(detail::format_concat("test", 123) == "test123"); 29 | CHECK(detail::format_concat("test ", 123, " ", false, 30 | true) == "test 123 falsetrue"); 31 | int *p = (int*)0xfff; 32 | int *null = nullptr; 33 | CHECK(detail::format_concat("test ", p) == "test 0xfff"); 34 | CHECK(detail::format_concat("test ", null) == "test (null)"); 35 | CHECK(detail::format_concat("$", test_struct{1, 2}, "$") == "$(1,2)$"); 36 | 37 | char *t = nullptr; 38 | CHECK(detail::format_concat(t, "$") == "(null)$"); 39 | } 40 | 41 | TEST_CASE("wf::log::log_plain()") 42 | { 43 | using namespace wf::log; 44 | std::stringstream out; 45 | 46 | auto check_line = [&out] (std::string expect) 47 | { 48 | std::string line; 49 | std::getline(out, line); 50 | 51 | /* Remove date and current time, because it isn't reproducible. */ 52 | int time_start_index = 2; 53 | int time_length = 1 + 10 + 1 + 12; /* space + date + space + time */ 54 | 55 | REQUIRE(line.length() >= time_start_index + time_length); 56 | line.erase(time_start_index, time_length); 57 | 58 | CHECK(line == expect); 59 | }; 60 | 61 | initialize_logging(out, LOG_LEVEL_DEBUG, LOG_COLOR_MODE_OFF, "/test/strip/"); 62 | 63 | log_plain(LOG_LEVEL_DEBUG, "Test log", "/test/strip/main.cpp", 5); 64 | check_line("DD - [main.cpp:5] Test log"); 65 | 66 | log_plain(LOG_LEVEL_INFO, "Test no source"); 67 | check_line("II - Test no source"); 68 | 69 | log_plain(LOG_LEVEL_INFO, "Test log", "/test/strip/main.cpp", 56789); 70 | check_line("II - [main.cpp:56789] Test log"); 71 | 72 | log_plain(LOG_LEVEL_WARN, "Test log", "test/strip/main.cpp", 5); 73 | check_line("WW - [test/strip/main.cpp:5] Test log"); 74 | 75 | log_plain(LOG_LEVEL_ERROR, "Test error", "/test/strip//test/strip/main.cpp", 5); 76 | check_line("EE - [/test/strip/main.cpp:5] Test error"); 77 | 78 | initialize_logging(out, LOG_LEVEL_ERROR, LOG_COLOR_MODE_OFF, "/test/strip/"); 79 | 80 | /* Ignore non-error messages */ 81 | log_plain(LOG_LEVEL_WARN, "Test log", "test/strip/main.cpp", 5); 82 | log_plain(LOG_LEVEL_DEBUG, "Test log", "/test/strip/main.cpp", 5); 83 | log_plain(LOG_LEVEL_INFO, "Test log", "/test/strip/main.cpp", 56789); 84 | /* Show just errors */ 85 | log_plain(LOG_LEVEL_ERROR, "Test error", "main.cpp", 5); 86 | check_line("EE - [main.cpp:5] Test error"); 87 | 88 | /* Stream shouldn't have any more characters */ 89 | char dummy; 90 | out >> dummy; 91 | CHECK(out.eof()); 92 | } 93 | 94 | TEST_CASE("wf::log::log_plain(color_on)") 95 | { 96 | using namespace wf::log; 97 | std::stringstream stream; 98 | initialize_logging(stream, LOG_LEVEL_DEBUG, LOG_COLOR_MODE_ON); 99 | 100 | auto check_line = [&stream] (std::string set_color) 101 | { 102 | std::string line; 103 | std::getline(stream, line); 104 | /* Check that line begins with the proper color code and ends with 105 | * color reset */ 106 | 107 | const std::string reset = "\033[0m"; 108 | 109 | REQUIRE(line.length() >= set_color.length() + reset.length()); 110 | 111 | CHECK(line.find(set_color) == 0); 112 | CHECK(line.rfind(reset) == line.length() - reset.length()); 113 | }; 114 | 115 | LOGD("test"); 116 | check_line("\033[0m"); 117 | LOGI("test"); 118 | check_line("\033[0;34m"); 119 | LOGW("test"); 120 | check_line("\033[0;33m"); 121 | LOGE("test"); 122 | check_line("\033[1;31m"); 123 | } 124 | -------------------------------------------------------------------------------- /src/log.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | template<> 10 | std::string wf::log::to_string(void *arg) 11 | { 12 | if (!arg) 13 | { 14 | return "(null)"; 15 | } 16 | 17 | std::ostringstream out; 18 | out << arg; 19 | return out.str(); 20 | } 21 | 22 | template<> 23 | std::string wf::log::to_string(bool arg) 24 | { 25 | return arg ? "true" : "false"; 26 | } 27 | 28 | /** 29 | * A singleton to hold log configuration. 30 | */ 31 | struct log_global_t 32 | { 33 | std::reference_wrapper out = std::ref(std::cout); 34 | 35 | wf::log::log_level_t level = wf::log::LOG_LEVEL_INFO; 36 | wf::log::color_mode_t color_mode = wf::log::LOG_COLOR_MODE_OFF; 37 | std::string strip_path = ""; 38 | 39 | std::string clear_color = ""; 40 | 41 | static log_global_t& get() 42 | { 43 | static log_global_t instance; 44 | return instance; 45 | } 46 | 47 | private: 48 | log_global_t() 49 | {} 50 | }; 51 | 52 | void wf::log::initialize_logging(std::ostream& output_stream, 53 | log_level_t minimum_level, color_mode_t color_mode, std::string strip_path) 54 | { 55 | auto& state = log_global_t::get(); 56 | state.out = std::ref(output_stream); 57 | state.level = minimum_level; 58 | state.color_mode = color_mode; 59 | state.strip_path = strip_path; 60 | 61 | if (state.color_mode == LOG_COLOR_MODE_ON) 62 | { 63 | state.clear_color = "\033[0m"; 64 | } else 65 | { 66 | state.clear_color = ""; 67 | } 68 | } 69 | 70 | /** Get the line prefix for the given log level */ 71 | static std::string get_level_prefix(wf::log::log_level_t level) 72 | { 73 | bool color = log_global_t::get().color_mode == wf::log::LOG_COLOR_MODE_ON; 74 | static std::map color_codes = 75 | { 76 | {wf::log::LOG_LEVEL_DEBUG, "\033[0m"}, 77 | {wf::log::LOG_LEVEL_INFO, "\033[0;34m"}, 78 | {wf::log::LOG_LEVEL_WARN, "\033[0;33m"}, 79 | {wf::log::LOG_LEVEL_ERROR, "\033[1;31m"}, 80 | }; 81 | 82 | static std::map line_prefix = 83 | { 84 | {wf::log::LOG_LEVEL_DEBUG, "DD"}, 85 | {wf::log::LOG_LEVEL_INFO, "II"}, 86 | {wf::log::LOG_LEVEL_WARN, "WW"}, 87 | {wf::log::LOG_LEVEL_ERROR, "EE"}, 88 | }; 89 | 90 | if (color) 91 | { 92 | return color_codes[level] + line_prefix[level]; 93 | } 94 | 95 | return line_prefix[level]; 96 | } 97 | 98 | /** Get the current time and date in a suitable format. */ 99 | static std::string get_formatted_date_time() 100 | { 101 | using namespace std::chrono; 102 | auto now = system_clock::now(); 103 | auto tt = system_clock::to_time_t(now); 104 | auto ms = duration_cast(now.time_since_epoch()) % 1000; 105 | 106 | std::ostringstream out; 107 | 108 | struct tm buffer; 109 | localtime_r(&tt, &buffer); 110 | out << std::put_time(&buffer, "%Y-%m-%d %H:%M:%S."); 111 | out << std::setfill('0') << std::setw(3) << ms.count(); 112 | return out.str(); 113 | } 114 | 115 | /** Strip the strip_path from the given path. */ 116 | static std::string strip_path(const std::string& path) 117 | { 118 | auto prefix = log_global_t::get().strip_path; 119 | if ((prefix.length() > 0) && (path.find(prefix) == 0)) 120 | { 121 | return path.substr(prefix.length()); 122 | } 123 | 124 | std::string skip_chars = "./"; 125 | size_t idx = path.find_first_not_of(skip_chars); 126 | if (idx != std::string::npos) 127 | { 128 | return path.substr(idx); 129 | } 130 | 131 | return path; 132 | } 133 | 134 | /** 135 | * Log a plain message to the given output stream. 136 | * The output format is: 137 | * 138 | * LL DD-MM-YY HH:MM:SS.MSS - [source:line] message 139 | * 140 | * @param level The log level of the passed message. 141 | * @param contents The message to be printed. 142 | * @param source The file where the message originates from. The prefix 143 | * strip_path specified in initialize_logging will be removed, if it exists. 144 | * @param line The line number of @source 145 | */ 146 | void wf::log::log_plain(log_level_t level, const std::string& contents, 147 | const std::string& source, int line_nr) 148 | { 149 | auto& state = log_global_t::get(); 150 | if (state.level > level) 151 | { 152 | return; 153 | } 154 | 155 | std::string path_info; 156 | if (!source.empty()) 157 | { 158 | path_info = wf::log::detail::format_concat( 159 | "[", strip_path(source), ":", line_nr, "] "); 160 | } 161 | 162 | state.out.get() << 163 | wf::log::detail::format_concat( 164 | get_level_prefix(level), " ", 165 | get_formatted_date_time(), 166 | " - ", path_info, contents) << 167 | state.clear_color << std::endl; 168 | } 169 | -------------------------------------------------------------------------------- /include/wayfire/nonstd/safe-list.hpp: -------------------------------------------------------------------------------- 1 | #ifndef WF_SAFE_LIST_HPP 2 | #define WF_SAFE_LIST_HPP 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | namespace wf 12 | { 13 | /** 14 | * The safe list is a trimmed down version of std::list. 15 | * 16 | * It supports adding an item to the end of a list, iterating over it and erasing elements. 17 | * The important advantage is that elements can be callbacks, which may be executed during the iteration, 18 | * and the callbacks can then add or remove elements from the list safely. 19 | * 20 | * The typical usage of safe list is for bindings and signal handlers. 21 | */ 22 | template 23 | class safe_list_t 24 | { 25 | static_assert(std::is_move_constructible_v>, "T must be moveable!"); 26 | 27 | public: 28 | safe_list_t() 29 | {} 30 | 31 | T& back() 32 | { 33 | auto it = list.rbegin(); 34 | assert((it != list.rend()) && "back() on an empty list!"); 35 | 36 | while (!((*it).has_value())) 37 | { 38 | ++it; 39 | assert((it != list.rend()) && "back() on an empty list!"); 40 | } 41 | 42 | return **it; 43 | } 44 | 45 | size_t size() const 46 | { 47 | if (!is_dirty) 48 | { 49 | return list.size(); 50 | } 51 | 52 | return std::count_if(list.begin(), list.end(), [] (const auto& elem) { return elem.has_value(); }); 53 | } 54 | 55 | /* Push back by copying */ 56 | void push_back(T value) 57 | { 58 | list.push_back({std::move(value)}); 59 | } 60 | 61 | /* Call func for each non-erased element of the list */ 62 | void for_each(std::function func) 63 | { 64 | _start_iter(); 65 | 66 | // Important: make sure we do not iterate over additional values in the list which are added 67 | // afterwards. 68 | size_t size = list.size(); 69 | for (size_t i = 0; i < size; i++) 70 | { 71 | if (list[i]) 72 | { 73 | func(*list[i]); 74 | } 75 | } 76 | 77 | _stop_iter(); 78 | } 79 | 80 | /* Call func for each non-erased element of the list in reversed order */ 81 | void for_each_reverse(std::function func) 82 | { 83 | _start_iter(); 84 | for (size_t i = list.size(); i > 0; i--) 85 | { 86 | if (list[i - 1]) 87 | { 88 | func(*list[i - 1]); 89 | } 90 | } 91 | 92 | _stop_iter(); 93 | } 94 | 95 | /* Safely remove all elements equal to value */ 96 | void remove_all(const T& value) 97 | { 98 | remove_if([=] (const T& el) { return el == value; }); 99 | } 100 | 101 | /* Remove all elements from the list */ 102 | void clear() 103 | { 104 | remove_if([] (const T&) { return true; }); 105 | } 106 | 107 | /* Remove all elements satisfying a given condition. 108 | * This function resets their pointers and scheduling a cleanup operation */ 109 | void remove_if(std::function predicate) 110 | { 111 | _start_iter(); 112 | 113 | const size_t size = list.size(); 114 | for (size_t i = 0; i < size; i++) 115 | { 116 | if (list[i] && predicate(*list[i])) 117 | { 118 | /* First reset the element in the list, and then free resources */ 119 | auto value = std::move(list[i]); 120 | list[i].reset(); 121 | is_dirty = true; 122 | 123 | // Call destructor 124 | value.reset(); 125 | } 126 | } 127 | 128 | _stop_iter(); 129 | _try_cleanup(); 130 | } 131 | 132 | private: 133 | /** 134 | * A vector containing the values of the list. 135 | * To make sure we can iterate over the list and erase any elements from it during iteration, the 'erase' 136 | * operation simply resets the optional value in the list. 137 | * 138 | * After all iterations are done, the list is 'cleaned up', that is, empty elements are removed from it. 139 | */ 140 | std::vector> list; 141 | 142 | int iteration_counter = 0; 143 | bool is_dirty = false; 144 | 145 | /* Remove all invalidated elements in the list */ 146 | void _try_cleanup() 147 | { 148 | if ((iteration_counter > 0) || !is_dirty) 149 | { 150 | // There is an active iteration. 151 | return; 152 | } 153 | 154 | auto it = std::remove_if(list.begin(), list.end(), 155 | [&] (const std::optional& elem) { return !elem.has_value(); }); 156 | list.erase(it, list.end()); 157 | is_dirty = false; 158 | } 159 | 160 | void _start_iter() 161 | { 162 | ++iteration_counter; 163 | } 164 | 165 | void _stop_iter() 166 | { 167 | --iteration_counter; 168 | _try_cleanup(); 169 | } 170 | }; 171 | } 172 | 173 | #endif /* end of include guard: WF_SAFE_LIST_HPP */ 174 | -------------------------------------------------------------------------------- /test/number_locale_test.cpp: -------------------------------------------------------------------------------- 1 | #define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN 2 | #include 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | #include 9 | 10 | #define WF_CONFIG_DOUBLE_EPS 0.01 11 | 12 | using namespace wf; 13 | using namespace wf::option_type; 14 | 15 | 16 | void setup_test_locale() 17 | { 18 | // requires glibc-langpack-de 19 | // changes std::to_string output 20 | std::setlocale(LC_NUMERIC, "fr_FR.UTF-8"); 21 | } 22 | 23 | TEST_CASE("wf::option_type::to_string") 24 | { 25 | setup_test_locale(); 26 | 27 | std::string str = wf::option_type::to_string(3.14); 28 | CHECK(str == "3.140000"); 29 | CHECK(wf::option_type::to_string(3140) == "3140"); 30 | } 31 | 32 | TEST_CASE("wf::bool_wrapper_t locale") 33 | { 34 | setup_test_locale(); 35 | 36 | setup_test_locale(); 37 | CHECK(from_string("True").value()); 38 | setup_test_locale(); 39 | CHECK(from_string("true").value()); 40 | setup_test_locale(); 41 | CHECK(from_string("1").value()); 42 | 43 | setup_test_locale(); 44 | CHECK(from_string("False").value() == false); 45 | setup_test_locale(); 46 | CHECK(from_string("false").value() == false); 47 | setup_test_locale(); 48 | CHECK(from_string("0").value() == false); 49 | setup_test_locale(); 50 | 51 | setup_test_locale(); 52 | CHECK(!from_string("vrai")); 53 | setup_test_locale(); 54 | CHECK(!from_string("faux")); 55 | setup_test_locale(); 56 | 57 | setup_test_locale(); 58 | CHECK(from_string(to_string(true)).value()); 59 | setup_test_locale(); 60 | CHECK(from_string(to_string(false)).value() == false); 61 | setup_test_locale(); 62 | } 63 | 64 | TEST_CASE("wf::int_wrapper_t locale") 65 | { 66 | setup_test_locale(); 67 | 68 | setup_test_locale(); 69 | CHECK(from_string("1456").value() == 1456); 70 | setup_test_locale(); 71 | CHECK(from_string("-89").value() == -89); 72 | 73 | int32_t max = std::numeric_limits::max(); 74 | int32_t min = std::numeric_limits::min(); 75 | setup_test_locale(); 76 | CHECK(from_string(wf::option_type::to_string(max)).value() == max); 77 | setup_test_locale(); 78 | CHECK(from_string(wf::option_type::to_string(min)).value() == min); 79 | 80 | setup_test_locale(); 81 | CHECK(!from_string("1e4")); 82 | setup_test_locale(); 83 | CHECK(!from_string("")); 84 | setup_test_locale(); 85 | CHECK(!from_string("1234567890000")); 86 | 87 | setup_test_locale(); 88 | CHECK(from_string(to_string(456)).value() == 456); 89 | setup_test_locale(); 90 | CHECK(from_string(to_string(0)).value() == 0); 91 | } 92 | 93 | TEST_CASE("wf::double_wrapper_t locale") 94 | { 95 | setup_test_locale(); 96 | CHECK(from_string("0.378000").value() == doctest::Approx(0.378)); 97 | setup_test_locale(); 98 | CHECK(from_string("-89.1847").value() == doctest::Approx(-89.1847)); 99 | 100 | double max = std::numeric_limits::max(); 101 | double min = std::numeric_limits::min(); 102 | 103 | setup_test_locale(); 104 | CHECK(from_string(wf::option_type::to_string( 105 | max)).value() == doctest::Approx(max)); 106 | setup_test_locale(); 107 | CHECK(from_string(wf::option_type::to_string( 108 | min)).value() == doctest::Approx(min)); 109 | 110 | setup_test_locale(); 111 | CHECK(!from_string("1u4")); 112 | setup_test_locale(); 113 | CHECK(!from_string("")); 114 | setup_test_locale(); 115 | CHECK(!from_string("abc")); 116 | 117 | setup_test_locale(); 118 | CHECK(from_string(to_string(-4.56)).value() == 119 | doctest::Approx(-4.56)); 120 | setup_test_locale(); 121 | CHECK(from_string(to_string(0.0)).value() == doctest::Approx(0)); 122 | } 123 | 124 | /* Test that various wf::color_t constructors work */ 125 | TEST_CASE("wf::color_t") 126 | { 127 | using namespace wf; 128 | using namespace option_type; 129 | 130 | setup_test_locale(); 131 | 132 | setup_test_locale(); 133 | CHECK(!from_string("#FFF")); 134 | setup_test_locale(); 135 | CHECK(!from_string("0C1A")); 136 | setup_test_locale(); 137 | CHECK(!from_string("")); 138 | setup_test_locale(); 139 | CHECK(!from_string("#ZYXUIOPQ")); 140 | setup_test_locale(); 141 | CHECK(!from_string("#AUIO")); // invalid color 142 | setup_test_locale(); 143 | CHECK(!from_string("1.0 0.5 0.5 1.0 1.0")); // invalid color 144 | setup_test_locale(); 145 | CHECK(!from_string("1.0 0.5 0.5 1.0 asdf")); // invalid color 146 | setup_test_locale(); 147 | CHECK(!from_string("1.0 0.5")); // invalid color 148 | 149 | setup_test_locale(); 150 | CHECK(to_string(color_t{0, 0, 0, 0}) == "#00000000"); 151 | setup_test_locale(); 152 | CHECK(to_string(color_t{0.4, 0.8, 0.3686274, 153 | 0.9686274}) == "#66CC5EF7"); 154 | setup_test_locale(); 155 | CHECK(to_string(color_t{1, 1, 1, 1}) == "#FFFFFFFF"); 156 | } 157 | -------------------------------------------------------------------------------- /include/wayfire/config/option-wrapper.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace wf 9 | { 10 | template 11 | using option_sptr_t = std::shared_ptr>; 12 | 13 | /** 14 | * Create an option which has a static value. 15 | */ 16 | template 17 | option_sptr_t create_option(T value) 18 | { 19 | return std::make_shared>("Static", value); 20 | } 21 | 22 | /** 23 | * Create an option which has a static value, 24 | * from the given string description. 25 | */ 26 | template 27 | option_sptr_t create_option_string(const std::string& value) 28 | { 29 | return std::make_shared>("Static", 30 | wf::option_type::from_string(value).value()); 31 | } 32 | 33 | /** 34 | * A helper to check whether the given type is a specialization of std::vector 35 | */ 36 | template 37 | struct is_std_vector : public std::false_type {}; 38 | 39 | template 40 | struct is_std_vector> : public std::true_type {}; 41 | 42 | template 43 | void get_value_from_compound_option( 44 | config::compound_option_t *opt, config::compound_list_t& list) 45 | { 46 | list = opt->get_value(); 47 | } 48 | 49 | /** 50 | * A simple wrapper around a config option. 51 | * 52 | * This is a base class. Each application which uses it needs to subclass it 53 | * and override the load_raw_option() method. 54 | */ 55 | template 56 | class base_option_wrapper_t 57 | { 58 | public: 59 | using OptionType = std::conditional_t< 60 | is_std_vector::value, 61 | config::compound_option_t, 62 | config::option_t>; 63 | 64 | public: 65 | base_option_wrapper_t(const base_option_wrapper_t& other) = delete; 66 | base_option_wrapper_t& operator =( 67 | const base_option_wrapper_t& other) = delete; 68 | 69 | base_option_wrapper_t(base_option_wrapper_t&& other) = delete; 70 | base_option_wrapper_t& operator =( 71 | base_option_wrapper_t&& other) = delete; 72 | 73 | /** 74 | * Load the option with the given name from the config. 75 | * @throws logic_error if the option wrapper already has an option loaded. 76 | * @throws runtime_error if the given option does not exist or does not 77 | * match the type of the option wrapper. 78 | */ 79 | void load_option(const std::string& name) 80 | { 81 | _load_option(load_raw_option(name), name); 82 | } 83 | 84 | void load_option(std::shared_ptr section, const std::string& name) 85 | { 86 | _load_option(section->get_option_or(name), section->get_name() + "/" + name); 87 | } 88 | 89 | virtual ~base_option_wrapper_t() 90 | { 91 | if (raw_option) 92 | { 93 | raw_option->rem_updated_handler(&option_update_listener); 94 | } 95 | } 96 | 97 | /** Implicitly convertible to the value of the option */ 98 | operator decltype(auto)() const WF_LIFETIMEBOUND 99 | { 100 | return this->value(); 101 | } 102 | 103 | decltype(auto) value() const WF_LIFETIMEBOUND 104 | { 105 | if constexpr (is_std_vector::value) 106 | { 107 | Type list; 108 | get_value_from_compound_option(this->raw_option.get(), list); 109 | return list; 110 | } else 111 | { 112 | return raw_option->get_value(); 113 | } 114 | } 115 | 116 | operator std::shared_ptr() const 117 | { 118 | return raw_option; 119 | } 120 | 121 | /** Set a callback to execute when the option value changes. */ 122 | void set_callback(std::function callback) 123 | { 124 | this->on_update = callback; 125 | } 126 | 127 | protected: 128 | std::function on_update; 129 | wf::config::option_base_t::updated_callback_t option_update_listener; 130 | 131 | /** The actual option wrapped by the option wrapper */ 132 | std::shared_ptr raw_option; 133 | 134 | /** 135 | * Initialize the option wrapper. 136 | */ 137 | base_option_wrapper_t() 138 | { 139 | option_update_listener = [=] () 140 | { 141 | if (this->on_update) 142 | { 143 | this->on_update(); 144 | } 145 | }; 146 | } 147 | 148 | /** 149 | * Load the option with the given name from the application configuration. 150 | */ 151 | virtual std::shared_ptr load_raw_option( 152 | const std::string& name) = 0; 153 | 154 | void _load_option(std::shared_ptr _option, const std::string& name) 155 | { 156 | if (raw_option) 157 | { 158 | throw std::logic_error( 159 | "Loading an option into option wrapper twice!"); 160 | } 161 | 162 | if (_option == nullptr) 163 | { 164 | throw std::runtime_error("No such option: " + std::string(name)); 165 | } 166 | 167 | raw_option = std::dynamic_pointer_cast(_option); 168 | if (raw_option == nullptr) 169 | { 170 | throw std::runtime_error("Bad option type: " + name); 171 | } 172 | 173 | raw_option->add_updated_handler(&option_update_listener); 174 | } 175 | }; 176 | } 177 | -------------------------------------------------------------------------------- /test/duration_test.cpp: -------------------------------------------------------------------------------- 1 | #define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN 2 | #include 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace wf; 9 | using namespace wf::config; 10 | using namespace wf::animation; 11 | 12 | TEST_CASE("wf::animation::duration_t") 13 | { 14 | duration_t duration; 15 | 16 | auto check_lifetime = [&] () 17 | { 18 | CHECK(duration.running() == false); 19 | CHECK(duration.progress() == doctest::Approx{1.0}); 20 | 21 | duration.start(); 22 | CHECK(duration.running()); 23 | CHECK(duration.progress() == doctest::Approx{0.0}); 24 | 25 | usleep(50000); 26 | CHECK(duration.progress() == doctest::Approx{0.5}.epsilon(0.1)); 27 | CHECK(duration.running()); 28 | CHECK(duration.running()); 29 | usleep(60000); 30 | 31 | /* At this point, duration must be finished */ 32 | CHECK(duration.progress() == doctest::Approx{1.0}.epsilon(0.01)); 33 | CHECK(duration.running()); // one last time 34 | CHECK(duration.running() == false); 35 | CHECK(duration.running() == false); 36 | }; 37 | 38 | SUBCASE("Int option") 39 | { 40 | auto length = std::make_shared>("length", 100); 41 | duration = duration_t{length, smoothing::linear}; 42 | } 43 | 44 | SUBCASE("Animation option") 45 | { 46 | auto length = std::make_shared>("length", 47 | wf::animation_description_t{ 48 | .length_ms = 100, 49 | .easing = smoothing::linear, 50 | .easing_name = "linear", 51 | }); 52 | duration = duration_t{length}; 53 | } 54 | 55 | /* Check twice, so that we can test restarting */ 56 | check_lifetime(); 57 | check_lifetime(); 58 | 59 | auto check_reverse_duration = [&] () 60 | { 61 | auto direction = duration.get_direction(); 62 | CHECK(duration.running() == false); 63 | CHECK(duration.progress() == doctest::Approx{direction ? 1.0 : 0.0}); 64 | 65 | duration.start(); 66 | CHECK(duration.running()); 67 | CHECK(duration.progress() == doctest::Approx{direction ? 0.0 : 1.0}); 68 | 69 | usleep(75000); 70 | CHECK(duration.progress() == doctest::Approx{direction ? 0.75 : 0.25}.epsilon( 71 | 0.1)); 72 | duration.reverse(); 73 | usleep(50000); 74 | CHECK(duration.progress() == doctest::Approx{direction ? 0.25 : 0.75}.epsilon( 75 | 0.1)); 76 | CHECK(duration.running()); 77 | CHECK(duration.running()); 78 | usleep(35000); 79 | 80 | /* At this point, duration must be finished */ 81 | CHECK(duration.progress() == 82 | doctest::Approx{direction ? 0.0 : 1.0}.epsilon(0.01)); 83 | CHECK(duration.running()); // one last time 84 | CHECK(duration.running() == false); 85 | CHECK(duration.running() == false); 86 | }; 87 | 88 | /* Check twice, so that we can test direction */ 89 | check_reverse_duration(); 90 | check_reverse_duration(); 91 | } 92 | 93 | TEST_CASE("wf::animation::timed_transition_t") 94 | { 95 | const double start = 1.0; 96 | const double end = 2.0; 97 | const double overend = 3.0; 98 | const double middle = (start + end) / 2.0; 99 | 100 | auto length = std::make_shared>("length", 100); 101 | duration_t duration{length, smoothing::linear}; 102 | timed_transition_t transition{duration}; 103 | timed_transition_t transition2{duration, start, end}; 104 | transition.set(start, end); 105 | CHECK(transition.start == doctest::Approx(start)); 106 | CHECK(transition.end == doctest::Approx(end)); 107 | 108 | duration.start(); 109 | CHECK((double)transition == doctest::Approx(start)); 110 | usleep(50000); 111 | CHECK((double)transition == doctest::Approx(middle).epsilon(0.1)); 112 | CHECK((double)transition2 == doctest::Approx(middle).epsilon(0.1)); 113 | transition.restart_with_end(overend); 114 | transition2.restart_same_end(); 115 | CHECK(transition.start == doctest::Approx(middle).epsilon(0.1)); 116 | CHECK(transition2.start == doctest::Approx(middle).epsilon(0.1)); 117 | CHECK(transition.end == doctest::Approx(overend)); 118 | CHECK(transition2.end == doctest::Approx(end)); 119 | usleep(60000); 120 | CHECK((double)transition == doctest::Approx(overend).epsilon(0.1)); 121 | 122 | transition.flip(); 123 | CHECK(transition.start == doctest::Approx(3.0).epsilon(0.1)); 124 | CHECK(transition.end == doctest::Approx(middle).epsilon(0.1)); 125 | } 126 | 127 | TEST_CASE("wf::animation::simple_animation_t") 128 | { 129 | auto length = std::make_shared>("length", 10); 130 | simple_animation_t anim{length, smoothing::linear}; 131 | 132 | auto cycle_through = [&] (double s, double e, bool x1, bool x2) 133 | { 134 | if (!x1 && !x2) 135 | { 136 | anim.animate(s, e); 137 | } else if (!x2) 138 | { 139 | anim.animate(e); 140 | } else if (!x1) 141 | { 142 | anim.animate(); 143 | } 144 | 145 | CHECK(anim.running()); 146 | CHECK((double)anim == doctest::Approx(s)); 147 | usleep(5000); 148 | CHECK((double)anim == doctest::Approx((s + e) / 2).epsilon(0.1)); 149 | CHECK(anim.running()); 150 | usleep(5500); 151 | CHECK((double)anim == doctest::Approx(e)); 152 | CHECK(anim.running()); 153 | CHECK(!anim.running()); 154 | }; 155 | 156 | cycle_through(1, 2, false, false); 157 | cycle_through(2, 3, true, false); 158 | cycle_through(3, 3, false, true); 159 | 160 | simple_animation_t sa; 161 | sa = simple_animation_t{length}; 162 | sa.animate(1, 2); 163 | CHECK((double)sa == doctest::Approx(1.0)); 164 | } 165 | -------------------------------------------------------------------------------- /src/compound-option.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "option-impl.hpp" 4 | 5 | using namespace wf::config; 6 | 7 | static bool begins_with(const std::string& a, const std::string& b) 8 | { 9 | return a.substr(0, b.size()) == b; 10 | } 11 | 12 | compound_option_t::compound_option_t(const std::string& name, 13 | entries_t&& entries, std::string type_hint) : option_base_t(name), 14 | list_type_hint( 15 | type_hint) 16 | { 17 | this->entries = std::move(entries); 18 | } 19 | 20 | void wf::config::update_compound_from_section( 21 | compound_option_t& compound, 22 | const std::shared_ptr& section) 23 | { 24 | const auto& options = section->get_registered_options(); 25 | 26 | const auto& should_ignore_option = [] (const std::shared_ptr& opt) 27 | { 28 | return xml::get_option_xml_node(opt) || !opt->priv->option_in_config_file; 29 | }; 30 | 31 | const auto& entries = compound.get_entries(); 32 | 33 | std::map> new_values; 34 | 35 | // find possible suffixes 36 | for (const auto& opt : options) 37 | { 38 | if (should_ignore_option(opt)) 39 | { 40 | continue; 41 | } 42 | 43 | // iterating from the end ta handle cases where there is a prefix which is a prefix of another prefix 44 | // for instance, if there are entries with prefixes `prefix_` and `prefix_smth_` (in that order), 45 | // then option with name `prefix_smth_suffix` will be recognised with prefix `prefix_smth_`. 46 | for (auto it = entries.rbegin(); it != entries.rend(); ++it) 47 | { 48 | const auto& entry = *it; 49 | if (begins_with(opt->get_name(), entry->get_prefix())) 50 | { 51 | new_values.emplace(opt->get_name().substr(entry->get_prefix().size()), entries.size() + 1); 52 | break; 53 | } 54 | } 55 | } 56 | 57 | compound_option_t::stored_type_t stored_value; 58 | for (auto& [suffix, value] : new_values) 59 | { 60 | value[0] = suffix; 61 | for (size_t i = 0; i < entries.size(); ++i) 62 | { 63 | if (const auto & entry_option = section->get_option_or(entries[i]->get_prefix() + suffix); 64 | entry_option && !should_ignore_option(entry_option)) 65 | { 66 | entry_option->priv->could_be_compound = true; 67 | if (entries[i]->is_parsable(entry_option->get_value_str())) 68 | { 69 | value[i + 1] = entry_option->get_value_str(); 70 | continue; 71 | } else 72 | { 73 | LOGE("Failed parsing option ", 74 | section->get_name() + "/" + entry_option->get_name(), 75 | " as part of the list option ", 76 | section->get_name() + "/" + compound.get_name(), 77 | ". Trying to use the default value."); 78 | } 79 | } 80 | 81 | if (const auto& default_value = entries[i]->get_default_value()) 82 | { 83 | value[i + 1] = *default_value; 84 | } else 85 | { 86 | value.clear(); 87 | break; 88 | } 89 | } 90 | 91 | if (!value.empty()) 92 | { 93 | stored_value.push_back(std::move(value)); 94 | for (size_t i = 0; i < entries.size(); ++i) 95 | { 96 | if (auto entry_option = section->get_option_or(entries[i]->get_prefix() + suffix)) 97 | { 98 | // The option was used as part of the compound option, do not issue warning for it! 99 | entry_option->priv->is_part_compound = true; 100 | } 101 | } 102 | } 103 | } 104 | 105 | compound.set_value_untyped(stored_value); 106 | } 107 | 108 | compound_option_t::stored_type_t compound_option_t::get_value_untyped() 109 | { 110 | return this->value; 111 | } 112 | 113 | bool compound_option_t::set_value_untyped(stored_type_t value) 114 | { 115 | for (auto& e : value) 116 | { 117 | if (e.size() != this->entries.size() + 1) 118 | { 119 | return false; 120 | } 121 | 122 | for (size_t i = 1; i <= this->entries.size(); i++) 123 | { 124 | if (!entries[i - 1]->is_parsable(e[i])) 125 | { 126 | return false; 127 | } 128 | } 129 | } 130 | 131 | this->value = value; 132 | notify_updated(); 133 | return true; 134 | } 135 | 136 | const compound_option_t::entries_t& compound_option_t::get_entries() const 137 | { 138 | return this->entries; 139 | } 140 | 141 | /* --------------------------- option_base_t impl --------------------------- */ 142 | std::shared_ptr compound_option_t::clone_option() const 143 | { 144 | entries_t cloned; 145 | for (auto& e : this->entries) 146 | { 147 | cloned.push_back( 148 | std::unique_ptr(e->clone())); 149 | } 150 | 151 | auto result = std::make_shared(get_name(), std::move(cloned)); 152 | result->value = this->value; 153 | return result; 154 | } 155 | 156 | bool wf::config::compound_option_t::set_value_str(const std::string&) 157 | { 158 | // XXX: not supported yet 159 | return false; 160 | } 161 | 162 | void wf::config::compound_option_t::reset_to_default() 163 | { 164 | this->value.clear(); 165 | } 166 | 167 | bool wf::config::compound_option_t::set_default_value_str(const std::string&) 168 | { 169 | // XXX: not supported yet 170 | return false; 171 | } 172 | 173 | std::string wf::config::compound_option_t::get_value_str() const 174 | { 175 | // XXX: not supported yet 176 | return ""; 177 | } 178 | 179 | std::string wf::config::compound_option_t::get_default_value_str() const 180 | { 181 | // XXX: not supported yet 182 | return ""; 183 | } 184 | -------------------------------------------------------------------------------- /include/wayfire/util/duration.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | namespace wf 8 | { 9 | namespace animation 10 | { 11 | namespace smoothing 12 | { 13 | /** 14 | * A smooth function is a function which takes a double in [0, 1] and returns another double in R. Both ranges 15 | * represent percentage of a progress of an animation. 16 | */ 17 | using smooth_function = std::function; 18 | 19 | /** linear smoothing function, i.e x -> x */ 20 | extern smooth_function linear; 21 | /** "circle" smoothing function, i.e x -> sqrt(2x - x*x) */ 22 | extern smooth_function circle; 23 | /** "sigmoid" smoothing function, i.e x -> 1.0 / (1 + exp(-12 * x + 6)) */ 24 | extern smooth_function sigmoid; 25 | /** custom cubic-bezier as in CSS */ 26 | extern smooth_function get_cubic_bezier(double x1, double y1, double x2, double y2); 27 | 28 | std::vector get_available_smooth_functions(); 29 | } 30 | } 31 | 32 | struct animation_description_t 33 | { 34 | int length_ms; 35 | animation::smoothing::smooth_function easing; 36 | std::string easing_name; 37 | 38 | bool operator ==(const animation_description_t& other) const; 39 | }; 40 | 41 | namespace option_type 42 | { 43 | /** 44 | * Parse the string as an animation description. 45 | */ 46 | template<> 47 | std::optional from_string(const std::string& value); 48 | 49 | /** 50 | * Convert the given animation description to a string. 51 | */ 52 | template<> 53 | std::string to_string(const animation_description_t& value); 54 | } 55 | 56 | namespace animation 57 | { 58 | /** 59 | * A transition from start to end. 60 | */ 61 | struct transition_t 62 | { 63 | double start, end; 64 | }; 65 | 66 | /** 67 | * duration_t is a class which can be used to track progress over a specific time interval. 68 | */ 69 | class duration_t 70 | { 71 | public: 72 | /** 73 | * Construct a new duration. Initially, the duration is not running and its progress is 1. 74 | * 75 | * @param length The length of the duration in milliseconds. 76 | * @param smooth The smoothing function for transitions. 77 | */ 78 | duration_t(std::shared_ptr> length = nullptr, 79 | smoothing::smooth_function smooth = smoothing::circle); 80 | 81 | duration_t(std::shared_ptr> length); 82 | 83 | /* Copy-constructor */ 84 | duration_t(const duration_t& other); 85 | /* Copy-assignment */ 86 | duration_t& operator =(const duration_t& other); 87 | 88 | /* Move-constructor */ 89 | duration_t(duration_t&& other) = default; 90 | /* Move-assignment */ 91 | duration_t& operator =(duration_t&& other) = default; 92 | 93 | /** 94 | * Start the duration. This means that the progress will get reset to 0. 95 | */ 96 | void start(); 97 | 98 | /** 99 | * Get the progress of the duration in percentage. The progress will be smoothed using the smoothing 100 | * function. 101 | * 102 | * @return The current progress after smoothing. It is guaranteed that when the duration starts, progress 103 | * will be close to 0, and when it is finished, it will be close to 1. 104 | */ 105 | double progress() const; 106 | 107 | /** 108 | * Check if the duration is still running. Note that even when the duration first finishes, this function 109 | * will still return that the function is running one time. 110 | * 111 | * @return Whether the duration still has not elapsed. 112 | */ 113 | bool running(); 114 | 115 | /** 116 | * Reverse the duration. The progress will remain the same but the direction will reverse toward the 117 | * opposite start or end point. 118 | */ 119 | void reverse(); 120 | 121 | /** 122 | * Get duration direction. 123 | * 0: reverse 1: forward 124 | */ 125 | int get_direction(); 126 | 127 | class impl; 128 | /** Implementation details. */ 129 | std::shared_ptr priv; 130 | }; 131 | 132 | /** 133 | * A timed transition is a transition between two states which happens over a period of time. 134 | * 135 | * During the transition, the current state is smoothly interpolated between start and end. 136 | */ 137 | struct timed_transition_t : public transition_t 138 | { 139 | /** 140 | * Construct a new timed transition using the given duration to measure progress. 141 | * 142 | * @duration The duration to use for time measurement 143 | * @start The start state. 144 | * @end The end state. 145 | */ 146 | timed_transition_t(const duration_t& duration, 147 | double start = 0, double end = 0); 148 | 149 | /** 150 | * Set the transition start to the current state and the end to the given 151 | * @new_end. 152 | */ 153 | void restart_with_end(double new_end); 154 | 155 | /** 156 | * Set the transition start to the current state, and don't change the end. 157 | */ 158 | void restart_same_end(); 159 | 160 | /** 161 | * Set the transition start and end state. 162 | * @param start The start of the transition. 163 | * @param end The end of the transition. 164 | */ 165 | void set(double start, double end); 166 | 167 | /** 168 | * Swap start and end values. 169 | */ 170 | void flip(); 171 | 172 | /** 173 | * Implicitly convert the transition to its current state. 174 | */ 175 | operator double() const; 176 | 177 | private: 178 | std::shared_ptr duration; 179 | }; 180 | 181 | class simple_animation_t : public duration_t, public timed_transition_t 182 | { 183 | public: 184 | simple_animation_t( 185 | std::shared_ptr> length = nullptr, 186 | smoothing::smooth_function smooth = smoothing::circle); 187 | 188 | simple_animation_t(std::shared_ptr> length); 189 | 190 | /** 191 | * Set the start and the end of the animation and start the duration. 192 | */ 193 | void animate(double start, double end); 194 | 195 | /** 196 | * Animate from the current progress to the given end, and start the duration. 197 | */ 198 | void animate(double end); 199 | 200 | /** 201 | * Animate from the current progress to the current end, and start the duration. 202 | */ 203 | void animate(); 204 | }; 205 | } 206 | } 207 | -------------------------------------------------------------------------------- /include/wayfire/config/option.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | #include 8 | 9 | #ifdef __clang__ 10 | #define WF_LIFETIMEBOUND [[clang::lifetimebound]] 11 | #else 12 | #define WF_LIFETIMEBOUND 13 | #endif 14 | 15 | namespace wf 16 | { 17 | namespace config 18 | { 19 | /** 20 | * A base class for all option types. 21 | */ 22 | class option_base_t 23 | { 24 | public: 25 | virtual ~option_base_t(); 26 | option_base_t(const option_base_t& other) = delete; 27 | option_base_t& operator =(const option_base_t& other) = delete; 28 | 29 | /** @return The name of the option */ 30 | const std::string& get_name() const WF_LIFETIMEBOUND; 31 | 32 | /** @return A copy of the option */ 33 | virtual std::shared_ptr clone_option() const = 0; 34 | 35 | /** 36 | * Set the option value from the given string. 37 | * Invalid values are ignored. 38 | * 39 | * @return true if the option value was updated. 40 | */ 41 | virtual bool set_value_str(const std::string& value) = 0; 42 | 43 | /** Reset the option to its default value. */ 44 | virtual void reset_to_default() = 0; 45 | 46 | /** 47 | * Change the default value of an option. Note that this will not change the 48 | * option value, only its default value. 49 | * 50 | * If the new default value is invalid, the request will be ignored. 51 | * @return true if the default value was updated. 52 | */ 53 | virtual bool set_default_value_str(const std::string& default_value) = 0; 54 | 55 | /** Get the option value in string format */ 56 | virtual std::string get_value_str() const = 0; 57 | 58 | /** Get the default option value in string format */ 59 | virtual std::string get_default_value_str() const = 0; 60 | 61 | /** 62 | * A function to be executed when the option value changes. 63 | */ 64 | using updated_callback_t = std::function; 65 | 66 | /** 67 | * Register a new callback to execute when the option value changes. 68 | */ 69 | void add_updated_handler(updated_callback_t *callback); 70 | 71 | /** 72 | * Unregister a callback to execute when the option value changes. 73 | * If the same callback has been registered multiple times, this unregister 74 | * all registered instances. 75 | */ 76 | void rem_updated_handler(updated_callback_t *callback); 77 | 78 | /** 79 | * Set the lock status of an option, this is reference-counted. 80 | * 81 | * An option is unlocked by default. When an option is locked, the option 82 | * should not be modified by any config backend (for ex. when reading from 83 | * a file). 84 | * 85 | * Note that changing the value of the option manually still works. 86 | */ 87 | void set_locked(bool locked = true); 88 | 89 | /** 90 | * Get the current locked status. 91 | */ 92 | bool is_locked() const; 93 | 94 | struct impl; 95 | std::unique_ptr priv; 96 | 97 | protected: 98 | /** Construct a new option with the given name. */ 99 | option_base_t(const std::string& name); 100 | 101 | /** Notify all watchers */ 102 | void notify_updated() const; 103 | 104 | /** Initialize a cloned version of this option. */ 105 | void init_clone(option_base_t& clone) const; 106 | }; 107 | 108 | /** 109 | * A base class for options which can have minimum and maximum. 110 | * By default, no bounding checks are enabled. 111 | */ 112 | template 113 | class bounded_option_base_t 114 | { 115 | protected: 116 | Type closest_valid_value(const Type& value) const 117 | { 118 | return value; 119 | } 120 | }; 121 | 122 | /** 123 | * Specialization for option types which do support bounded values. 124 | */ 125 | template 126 | class bounded_option_base_t 127 | { 128 | public: 129 | /** @return The minimal permissible value for this option, if it is set. */ 130 | std::optional get_minimum() const 131 | { 132 | return minimum; 133 | } 134 | 135 | /** @return The maximal permissible value for this option, if it is set. */ 136 | std::optional get_maximum() const 137 | { 138 | return maximum; 139 | } 140 | 141 | protected: 142 | std::optional minimum; 143 | std::optional maximum; 144 | 145 | /** 146 | * @return The closest possible value 147 | */ 148 | Type closest_valid_value(const Type& value) const 149 | { 150 | auto real_minimum = 151 | minimum.value_or(std::numeric_limits::lowest()); 152 | auto real_maximum = 153 | maximum.value_or(std::numeric_limits::max()); 154 | 155 | if (value < real_minimum) 156 | { 157 | return real_minimum; 158 | } 159 | 160 | if (value > real_maximum) 161 | { 162 | return real_maximum; 163 | } 164 | 165 | return value; 166 | } 167 | }; 168 | 169 | namespace detail 170 | { 171 | template using boundable_type_only = 172 | std::enable_if_t::value, Result>; 173 | } 174 | 175 | /** 176 | * Represents an option of the given type. 177 | */ 178 | template 179 | class option_t : public option_base_t, 180 | public bounded_option_base_t::value> 181 | { 182 | public: 183 | /** 184 | * Create a new option with the given name and default value. 185 | */ 186 | option_t(const std::string& name, Type def_value) : 187 | option_base_t(name), default_value(def_value), value(default_value) 188 | {} 189 | 190 | /** 191 | * Create a copy of the option. 192 | */ 193 | virtual std::shared_ptr clone_option() const override 194 | { 195 | auto result = std::make_shared(get_name(), get_default_value()); 196 | result->set_value(get_value()); 197 | if constexpr (std::is_arithmetic::value) 198 | { 199 | result->minimum = this->minimum; 200 | result->maximum = this->maximum; 201 | } 202 | 203 | init_clone(*result); 204 | return result; 205 | } 206 | 207 | /** 208 | * Set the value of the option from the given string. 209 | * The value will be auto-clamped to the defined bounds, if they exist. 210 | * If the value actually changes, the updated handlers will be called. 211 | */ 212 | virtual bool set_value_str(const std::string& new_value_str) override 213 | { 214 | auto new_value = option_type::from_string(new_value_str); 215 | if (new_value) 216 | { 217 | set_value(new_value.value()); 218 | return true; 219 | } 220 | 221 | return false; 222 | } 223 | 224 | /** 225 | * Reset the option to its default value. 226 | */ 227 | virtual void reset_to_default() override 228 | { 229 | set_value(default_value); 230 | } 231 | 232 | /** 233 | * Change the default value of the function, if possible. 234 | */ 235 | virtual bool set_default_value_str(const std::string& defvalue) override 236 | { 237 | auto parsed = option_type::from_string(defvalue); 238 | if (parsed) 239 | { 240 | this->default_value = parsed.value(); 241 | return true; 242 | } 243 | 244 | return false; 245 | } 246 | 247 | /** 248 | * Set the value of the option. 249 | * The value will be auto-clamped to the defined bounds, if they exist. 250 | * If the value actually changes, the updated handlers will be called. 251 | */ 252 | void set_value(const Type& new_value) 253 | { 254 | auto real_value = this->closest_valid_value(new_value); 255 | if (!(this->value == real_value)) 256 | { 257 | this->value = real_value; 258 | this->notify_updated(); 259 | } 260 | } 261 | 262 | const Type& get_value() const WF_LIFETIMEBOUND 263 | { 264 | return value; 265 | } 266 | 267 | const Type& get_default_value() const WF_LIFETIMEBOUND 268 | { 269 | return default_value; 270 | } 271 | 272 | virtual std::string get_value_str() const override 273 | { 274 | return option_type::to_string(get_value()); 275 | } 276 | 277 | virtual std::string get_default_value_str() const override 278 | { 279 | return option_type::to_string(get_default_value()); 280 | } 281 | 282 | public: 283 | /** 284 | * Set the minimum permissible value for arithmetic type options. 285 | * An attempt to set the value to a value below the minimum will set the 286 | * value of the option to the minimum. 287 | */ 288 | template 289 | detail::boundable_type_only set_minimum(Type min) 290 | { 291 | this->minimum = {min}; 292 | this->value = this->closest_valid_value(this->value); 293 | } 294 | 295 | /** 296 | * Set the maximum permissible value for arithmetic type options. 297 | * An attempt to set the value to a value above the maximum will set the 298 | * value of the option to the maximum. 299 | */ 300 | template 301 | detail::boundable_type_only set_maximum(Type max) 302 | { 303 | this->maximum = {max}; 304 | this->value = this->closest_valid_value(this->value); 305 | } 306 | 307 | protected: 308 | Type default_value; /* default value */ 309 | Type value; /* current value */ 310 | }; 311 | } 312 | } 313 | -------------------------------------------------------------------------------- /include/wayfire/config/compound-option.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | namespace wf 14 | { 15 | namespace config 16 | { 17 | template 18 | using compound_list_t = 19 | std::vector>; 20 | 21 | template 22 | using simple_list_t = 23 | std::vector>; 24 | 25 | template 26 | std::tuple pop_first(const std::tuple& tuple) 27 | { 28 | return std::apply([] (auto&&, const auto&... args) 29 | { 30 | return std::tie(args...); 31 | }, tuple); 32 | } 33 | 34 | template 35 | std::tuple push_first(const T1& t, const std::tuple& tuple) 36 | { 37 | return std::tuple_cat(std::tie(t), tuple); 38 | } 39 | 40 | /** 41 | * A base class containing information about an entry in a tuple. 42 | */ 43 | class compound_option_entry_base_t 44 | { 45 | public: 46 | 47 | virtual ~compound_option_entry_base_t() = default; 48 | 49 | /** @return The prefix of the tuple entry. */ 50 | const std::string& get_prefix() const WF_LIFETIMEBOUND 51 | { 52 | return prefix; 53 | } 54 | 55 | /** @return The name of the tuple entry. */ 56 | const std::string& get_name() const WF_LIFETIMEBOUND 57 | { 58 | return name; 59 | } 60 | 61 | /** @return The untyped default value of the tuple entry. */ 62 | const std::optional& get_default_value() const WF_LIFETIMEBOUND 63 | { 64 | return default_value; 65 | } 66 | 67 | /** 68 | * Try to parse the given value. 69 | * 70 | * @param update Whether to override the stored value. 71 | */ 72 | virtual bool is_parsable(const std::string&) const = 0; 73 | 74 | /** Clone this entry */ 75 | virtual compound_option_entry_base_t *clone() const = 0; 76 | 77 | protected: 78 | compound_option_entry_base_t() = default; 79 | std::string prefix; 80 | std::string name; 81 | std::optional default_value; 82 | }; 83 | 84 | template 85 | class compound_option_entry_t : public compound_option_entry_base_t 86 | { 87 | public: 88 | compound_option_entry_t(const std::string& prefix, const std::string& name = "", 89 | const std::optional& default_value = std::nullopt) 90 | { 91 | this->prefix = prefix; 92 | this->name = name; 93 | this->default_value = default_value; 94 | assert(!this->default_value || is_parsable(this->default_value.value())); 95 | } 96 | 97 | compound_option_entry_base_t *clone() const override 98 | { 99 | return new compound_option_entry_t(*this); 100 | } 101 | 102 | /** 103 | * Try to parse the given value. 104 | * 105 | * @param update Whether to override the stored value. 106 | */ 107 | bool is_parsable(const std::string& str) const override 108 | { 109 | return option_type::from_string(str).has_value(); 110 | } 111 | }; 112 | 113 | /** 114 | * Compound options are a special class of options which can hold multiple 115 | * string-tagged tuples. They are constructed from multiple untyped options 116 | * in the config file. 117 | */ 118 | 119 | class compound_option_t : public option_base_t 120 | { 121 | public: 122 | using entries_t = std::vector>; 123 | /** 124 | * Construct a new compound option, with the types given in the template 125 | * arguments. 126 | * 127 | * @param name The name of the option. 128 | * @param prefixes The prefixes used for grouping in the config file. 129 | * Example: Consider a compound option with type and two 130 | * prefixes {"prefix1_", "prefix2_"}. In the config file, the options are: 131 | * 132 | * prefix1_key1 = v11 133 | * prefix2_key1 = v21 134 | * prefix1_key2 = v12 135 | * prefix2_key2 = v22 136 | * 137 | * Options are grouped by suffixes (key1 and key2), and the tuples then 138 | * are formed by taking the values of the options with each prefix. 139 | * So, the tuples contained in the compound option in the end are: 140 | * 141 | * (key1, v11, v21) 142 | * (key2, v12, v22) 143 | * @param type_hint What type of dynamic-list is this option. This stores 144 | * the type-hint attribute of the option specified in the xml. Currently, 145 | * the valid types are plain, dict and tuple (default). Type-hint is 146 | * mainly used as hint to save the config option in a "pretty" way. 147 | * Config formats are free to ignore this type hint. 148 | */ 149 | compound_option_t(const std::string& name, entries_t&& entries, 150 | std::string type_hint = "tuple"); 151 | 152 | /** 153 | * Parse the compound option with the given types. 154 | * 155 | * Throws an exception in case of wrong template types. 156 | */ 157 | template 158 | compound_list_t get_value() const 159 | { 160 | compound_list_t result; 161 | result.resize(value.size()); 162 | build_recursive<0, Args...>(result); 163 | return result; 164 | } 165 | 166 | template 167 | simple_list_t get_value_simple() const 168 | { 169 | auto list = get_value(); 170 | simple_list_t result; 171 | for (const auto& val : list) 172 | { 173 | result.push_back(pop_first(val)); 174 | } 175 | 176 | return result; 177 | } 178 | 179 | /** 180 | * Set the value of the option. 181 | * 182 | * Throws an exception in case of wrong template types. 183 | */ 184 | template 185 | void set_value(const compound_list_t& value) 186 | { 187 | assert(sizeof...(Args) == this->entries.size()); 188 | this->value.assign(value.size(), {}); 189 | push_recursive<0>(value); 190 | notify_updated(); 191 | } 192 | 193 | /** 194 | * Set the value of the option. 195 | * 196 | * Throws an exception in case of wrong template types. 197 | */ 198 | template 199 | void set_value_simple(const simple_list_t& value) 200 | { 201 | compound_list_t list; 202 | for (int i = 0; i < (int)value.size(); i++) 203 | { 204 | list.push_back(push_first(std::to_string(i), value[i])); 205 | } 206 | 207 | this->set_value(list); 208 | } 209 | 210 | using stored_type_t = std::vector>; 211 | /** 212 | * Get the string data stored in the compound option. 213 | */ 214 | stored_type_t get_value_untyped(); 215 | 216 | /** 217 | * Set the data contained in the option, from a vector containing 218 | * strings which describe the individual elements. 219 | * 220 | * @return True if the operation was successful. 221 | */ 222 | bool set_value_untyped(stored_type_t value); 223 | 224 | /** 225 | * Get the type information about entries in the option. 226 | */ 227 | const entries_t& get_entries() const WF_LIFETIMEBOUND; 228 | 229 | /** 230 | * Check if this compound option has named tuples. 231 | */ 232 | const std::string& get_type_hint() const WF_LIFETIMEBOUND 233 | { 234 | return list_type_hint; 235 | } 236 | 237 | private: 238 | /** 239 | * Current value stored in the option. 240 | * The first element is the name of the tuple, followed by the string values 241 | * of each element. 242 | */ 243 | stored_type_t value; 244 | 245 | /** Entry types with which the option was created. */ 246 | entries_t entries; 247 | 248 | /** What type of dynamic-list is this: plain, dics, tuple */ 249 | std::string list_type_hint; 250 | 251 | /** 252 | * Set the n-th element in the result tuples by reading from the stored 253 | * values in this option. 254 | */ 255 | template 256 | void build_recursive(compound_list_t& result) const 257 | { 258 | for (size_t i = 0; i < result.size(); i++) 259 | { 260 | using type_t = typename std::tuple_element>::type; 262 | 263 | std::get(result[i]) = option_type::from_string( 264 | this->value[i][n]).value(); 265 | } 266 | 267 | // Recursively build the (N+1)'th entries 268 | if constexpr (n < sizeof...(Args)) 269 | { 270 | build_recursive(result); 271 | } 272 | } 273 | 274 | template 275 | void push_recursive(const compound_list_t& new_value) 276 | { 277 | for (size_t i = 0; i < new_value.size(); i++) 278 | { 279 | using type_t = typename std::tuple_element>::type; 281 | 282 | this->value[i].push_back(option_type::to_string( 283 | std::get(new_value[i]))); 284 | } 285 | 286 | // Recursively build the (N+1)'th entries 287 | if constexpr (n < sizeof...(Args)) 288 | { 289 | push_recursive(new_value); 290 | } 291 | } 292 | 293 | public: // Implementation of option_base_t 294 | std::shared_ptr clone_option() const override; 295 | bool set_value_str(const std::string&) override; 296 | void reset_to_default() override; 297 | bool set_default_value_str(const std::string&) override; 298 | std::string get_value_str() const override; 299 | std::string get_default_value_str() const override; 300 | }; 301 | } 302 | } 303 | -------------------------------------------------------------------------------- /src/duration.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | double bezier_helper(double t, double p0, double p1, double p2, double p3) 12 | { 13 | const double u = 1 - t; 14 | return u * u * u * p0 + 3 * u * u * t * p1 + 3 * u * t * t * p2 + t * t * t * p3; 15 | } 16 | 17 | inline bool epsilon_comparison(double a, double b) 18 | { 19 | return std::fabs(a - b) <= std::numeric_limits::epsilon() * std::fabs(a + b); 20 | } 21 | 22 | namespace wf 23 | { 24 | namespace animation 25 | { 26 | namespace smoothing 27 | { 28 | smooth_function linear = 29 | [] (double x) -> double { return x; }; 30 | smooth_function circle = 31 | [] (double x) -> double { return std::sqrt(2 * x - x * x); }; 32 | 33 | const double sigmoid_max = 1 + std::exp(-6); 34 | smooth_function sigmoid = 35 | [] (double x) -> double { return sigmoid_max / (1 + exp(-12 * x + 6)); }; 36 | 37 | smooth_function get_cubic_bezier(double x1, double y1, double x2, double y2) 38 | { 39 | // https://en.wikipedia.org/wiki/Newton%27s_method 40 | return [=] (double x) 41 | { 42 | double t = x; 43 | for (int i = 0; i < 10; ++i) 44 | { 45 | const double f = bezier_helper(t, 0, x1, x2, 1) - x; 46 | const double df = 3 * (1 - t) * (1 - t) * x1 + 6 * (1 - t) * t * (x2 - x1) + 3 * t * t * (1 - x2); 47 | if (std::abs(f) < 1e-6) 48 | { 49 | break; 50 | } 51 | 52 | t -= f / df; 53 | } 54 | 55 | return bezier_helper(t, 0, y1, y2, 1); 56 | }; 57 | } 58 | } 59 | } // namespace animation 60 | } 61 | 62 | bool wf::animation_description_t::operator ==(const animation_description_t & other) const 63 | { 64 | if (easing_name == other.easing_name) 65 | { 66 | return (length_ms == other.length_ms); 67 | } 68 | 69 | // Cubic-bezier easings need parsing to handle epsilon 70 | std::stringstream easing_a(easing_name); 71 | std::stringstream easing_b(easing_name); 72 | std::string easing_type_a, easing_type_b; 73 | easing_a >> easing_type_a; 74 | easing_b >> easing_type_b; 75 | if ((easing_type_a != "cubic-bezier") || (easing_type_b != "cubic-bezier")) 76 | { 77 | return false; 78 | } 79 | 80 | double x1_a, y1_a, x2_a, y2_a, x1_b, y1_b, x2_b, y2_b; 81 | easing_a >> x1_a >> y1_a >> x2_a >> y2_a; 82 | easing_b >> x1_b >> y1_b >> x2_b >> y2_b; 83 | return epsilon_comparison(x1_a, x1_b) && 84 | epsilon_comparison(y1_a, y1_b) && 85 | epsilon_comparison(x2_a, x2_b) && 86 | epsilon_comparison(y2_b, y2_b); 87 | } 88 | 89 | class wf::animation::duration_t::impl 90 | { 91 | public: 92 | decltype(std::chrono::system_clock::now()) start_point; 93 | 94 | std::shared_ptr> length; 95 | std::shared_ptr> descr; 96 | 97 | smoothing::smooth_function smooth_function; 98 | bool is_running = false; 99 | bool reverse = false; 100 | 101 | int64_t get_elapsed() const 102 | { 103 | using namespace std::chrono; 104 | auto now = system_clock::now(); 105 | return duration_cast(now - start_point).count(); 106 | } 107 | 108 | int get_duration() const 109 | { 110 | if (descr) 111 | { 112 | return std::max(1, descr->get_value().length_ms); 113 | } 114 | 115 | if (length) 116 | { 117 | return std::max(1, length->get_value()); 118 | } 119 | 120 | LOGD("Calling methods on wf::animation::duration_t without a length"); 121 | return 1; 122 | } 123 | 124 | bool is_ready() const 125 | { 126 | return get_elapsed() >= get_duration(); 127 | } 128 | 129 | double get_progress_percentage() const 130 | { 131 | if ((!length && !descr) || is_ready()) 132 | { 133 | return 1.0; 134 | } 135 | 136 | auto progress = 1.0 * get_elapsed() / get_duration(); 137 | if (reverse) 138 | { 139 | progress = 1.0 - progress; 140 | } 141 | 142 | return std::clamp(progress, 0.0, 1.0); 143 | } 144 | 145 | double progress() const 146 | { 147 | if (is_ready()) 148 | { 149 | return reverse ? 0.0 : 1.0; 150 | } 151 | 152 | if (descr) 153 | { 154 | return descr->get_value().easing(get_progress_percentage()); 155 | } else 156 | { 157 | return smooth_function(get_progress_percentage()); 158 | } 159 | } 160 | }; 161 | 162 | wf::animation::duration_t::duration_t( 163 | std::shared_ptr> length, 164 | smoothing::smooth_function smooth) 165 | { 166 | this->priv = std::make_shared(); 167 | this->priv->length = length; 168 | this->priv->smooth_function = smooth; 169 | } 170 | 171 | wf::animation::duration_t::duration_t( 172 | std::shared_ptr> length) 173 | { 174 | this->priv = std::make_shared(); 175 | this->priv->descr = length; 176 | } 177 | 178 | wf::animation::duration_t::duration_t(const duration_t& other) 179 | { 180 | this->priv = std::make_shared(*other.priv); 181 | } 182 | 183 | wf::animation::duration_t& wf::animation::duration_t::operator =( 184 | const duration_t& other) 185 | { 186 | if (&other != this) 187 | { 188 | this->priv = std::make_shared(*other.priv); 189 | } 190 | 191 | return *this; 192 | } 193 | 194 | void wf::animation::duration_t::start() 195 | { 196 | this->priv->is_running = 1; 197 | this->priv->start_point = std::chrono::system_clock::now(); 198 | } 199 | 200 | double wf::animation::duration_t::progress() const 201 | { 202 | return this->priv->progress(); 203 | } 204 | 205 | bool wf::animation::duration_t::running() 206 | { 207 | if (this->priv->is_ready()) 208 | { 209 | bool was_running = this->priv->is_running; 210 | this->priv->is_running = false; 211 | return was_running; 212 | } 213 | 214 | return true; 215 | } 216 | 217 | void wf::animation::duration_t::reverse() 218 | { 219 | auto total_duration = this->priv->get_duration(); 220 | auto elapsed = std::min(this->priv->get_elapsed(), (int64_t)total_duration); 221 | auto remaining = std::chrono::milliseconds(total_duration - elapsed); 222 | this->priv->start_point = std::chrono::system_clock::now() - remaining; 223 | this->priv->reverse = !this->priv->reverse; 224 | } 225 | 226 | int wf::animation::duration_t::get_direction() 227 | { 228 | return !this->priv->reverse; 229 | } 230 | 231 | wf::animation::timed_transition_t::timed_transition_t( 232 | const duration_t& dur, double start, double end) : duration(dur.priv) 233 | { 234 | this->set(start, end); 235 | } 236 | 237 | void wf::animation::timed_transition_t::restart_with_end(double new_end) 238 | { 239 | this->start = (double)*this; 240 | this->end = new_end; 241 | } 242 | 243 | void wf::animation::timed_transition_t::restart_same_end() 244 | { 245 | this->start = (double)*this; 246 | } 247 | 248 | void wf::animation::timed_transition_t::set(double start, double end) 249 | { 250 | this->start = start; 251 | this->end = end; 252 | } 253 | 254 | void wf::animation::timed_transition_t::flip() 255 | { 256 | std::swap(this->start, this->end); 257 | } 258 | 259 | wf::animation::timed_transition_t::operator double() const 260 | { 261 | double alpha = this->duration->progress(); 262 | return (1 - alpha) * start + alpha * end; 263 | } 264 | 265 | wf::animation::simple_animation_t::simple_animation_t( 266 | std::shared_ptr> length, 267 | smoothing::smooth_function smooth) : 268 | duration_t(length, smooth), 269 | timed_transition_t((duration_t&)*this) 270 | {} 271 | 272 | wf::animation::simple_animation_t::simple_animation_t( 273 | std::shared_ptr> length) : 274 | duration_t(length), timed_transition_t((duration_t&)*this) 275 | {} 276 | 277 | void wf::animation::simple_animation_t::animate(double start, double end) 278 | { 279 | this->set(start, end); 280 | this->duration_t::start(); 281 | } 282 | 283 | void wf::animation::simple_animation_t::animate(double end) 284 | { 285 | this->restart_with_end(end); 286 | this->duration_t::start(); 287 | } 288 | 289 | void wf::animation::simple_animation_t::animate() 290 | { 291 | this->restart_same_end(); 292 | this->duration_t::start(); 293 | } 294 | 295 | namespace wf 296 | { 297 | namespace animation 298 | { 299 | namespace smoothing 300 | { 301 | // Thanks https://github.com/MrRobinOfficial/EasingFunctions 302 | smooth_function ease_out_elastic = [] (double x) -> double 303 | { 304 | float d = 1.0f; 305 | float p = d * 0.6f; 306 | float s; 307 | float a = 0; 308 | 309 | if (x == 0) 310 | { 311 | return 0; 312 | } 313 | 314 | if ((x /= d) == 1) 315 | { 316 | return 1; 317 | } 318 | 319 | if ((a == 0.0f) || (a < std::abs(1.0))) 320 | { 321 | a = 1.0; 322 | s = p * 0.25f; 323 | } else 324 | { 325 | s = p / (2 * std::acos(-1)) * std::asin(1.0 / a); 326 | } 327 | 328 | return (a * std::pow(2, -10 * x) * std::sin((x * d - s) * (2 * std::acos(-1)) / p) + 1.0); 329 | }; 330 | 331 | static const std::map easing_map = { 332 | {"linear", animation::smoothing::linear}, 333 | {"circle", animation::smoothing::circle}, 334 | {"sigmoid", animation::smoothing::sigmoid}, 335 | {"easeOutElastic", animation::smoothing::ease_out_elastic}, 336 | }; 337 | 338 | std::vector get_available_smooth_functions() 339 | { 340 | std::vector result; 341 | for (auto& func : easing_map) 342 | { 343 | result.push_back(func.first); 344 | } 345 | 346 | return result; 347 | } 348 | } // namespace smoothing 349 | } 350 | 351 | namespace option_type 352 | { 353 | template<> 354 | std::optional from_string(const std::string& value) 355 | { 356 | // Format 1: N (backwards compatible fallback) 357 | if (auto val = from_string(value)) 358 | { 359 | return animation_description_t{ 360 | .length_ms = *val, 361 | .easing = animation::smoothing::circle, 362 | .easing_name = "circle" 363 | }; 364 | } 365 | 366 | // Format 2: N 367 | std::istringstream stream(value); 368 | double N; 369 | std::string suffix, easing; 370 | if (!(stream >> N >> suffix)) 371 | { 372 | return {}; 373 | } 374 | 375 | animation_description_t result; 376 | if ((suffix != "ms") && (suffix != "s")) 377 | { 378 | return {}; 379 | } 380 | 381 | if (!(stream >> result.easing_name)) 382 | { 383 | result.easing_name = "circle"; 384 | } 385 | 386 | if (animation::smoothing::easing_map.count(result.easing_name)) 387 | { 388 | result.easing = animation::smoothing::easing_map.at(result.easing_name); 389 | } else if (result.easing_name == "cubic-bezier") 390 | { 391 | double x1 = 0, y1 = 0, x2 = 1, y2 = 1; 392 | stream >> x1 >> y1 >> x2 >> y2; 393 | result.easing = animation::smoothing::get_cubic_bezier(x1, y1, x2, y2); 394 | result.easing_name = "cubic-bezier " + 395 | to_string(x1) + 396 | " " + to_string(y1) + 397 | " " + to_string(x2) + 398 | " " + to_string(y2); 399 | } else 400 | { 401 | return {}; 402 | } 403 | 404 | std::string tmp; 405 | if (stream >> tmp) 406 | { 407 | // Trailing data 408 | return {}; 409 | } 410 | 411 | if (suffix == "s") 412 | { 413 | result.length_ms = N * 1000; 414 | } else 415 | { 416 | result.length_ms = N; 417 | } 418 | 419 | return result; 420 | } 421 | 422 | template<> 423 | std::string to_string(const animation_description_t& value) 424 | { 425 | return to_string(value.length_ms) + "ms " + to_string(value.easing_name); 426 | } 427 | } 428 | } 429 | -------------------------------------------------------------------------------- /test/option_test.cpp: -------------------------------------------------------------------------------- 1 | #define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN 2 | #include 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include "../src/option-impl.hpp" 10 | 11 | /** 12 | * A struct to check whether the maximum and minimum methods are enabled on the 13 | * template parameter class. 14 | */ 15 | template 16 | struct are_bounds_enabled 17 | { 18 | private: 19 | template 20 | static constexpr bool has_bounds( 21 | decltype(&V::template set_maximum<>), 22 | decltype(&V::template set_minimum<>), 23 | decltype(&V::get_maximum), 24 | decltype(&V::get_minimum)) 25 | { 26 | return true; 27 | } 28 | 29 | template 30 | static constexpr bool has_bounds(...) 31 | { 32 | return false; 33 | } 34 | 35 | public: 36 | enum 37 | { 38 | value = has_bounds(nullptr, 39 | nullptr, 40 | nullptr, 41 | nullptr), 42 | }; 43 | }; 44 | 45 | TEST_CASE("wf::config::option_t") 46 | { 47 | using namespace wf; 48 | using namespace wf::config; 49 | 50 | const wf::keybinding_t binding1{KEYBOARD_MODIFIER_ALT, KEY_E}; 51 | const wf::keybinding_t binding2{KEYBOARD_MODIFIER_LOGO, KEY_T}; 52 | 53 | option_t opt("test123", binding1); 54 | CHECK(opt.get_name() == "test123"); 55 | CHECK(opt.get_value() == binding1); 56 | 57 | opt.set_value(binding2); 58 | CHECK(opt.get_value() == binding2); 59 | 60 | opt.set_value(binding1); 61 | CHECK(opt.get_value() == binding1); 62 | CHECK(opt.set_value_str("KEY_T")); 63 | CHECK(opt.get_value() == binding2); 64 | CHECK(!opt.set_value_str("garbage")); 65 | CHECK(opt.get_value() == binding2); 66 | opt.set_value_str("