app.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_APP_H
#define EGT_APP_H
 
#include <clocale>
#include <egt/asio.hpp>
#include <egt/detail/meta.h>
#include <egt/eventloop.h>
#include <egt/object.h>
#include <iosfwd>
#include <memory>
#include <ostream>
#include <string>
#include <vector>
 
namespace egt
{
inline namespace v1
{
 
class Screen;
class Input;
class Window;
class Timer;
 
class EGT_API Application
{
public:
    explicit Application(int argc = 0, char** argv = nullptr,
                         const std::string& name = {}, bool primary = true);
 
    Application(const Application&) = delete;
    Application& operator=(const Application&) = delete;
    Application(Application&&) = delete;
    Application& operator=(Application&&) = delete;
 
    static Application& instance();
 
    static bool check_instance();
 
    static void setup_search_paths(const std::vector<std::string>& extra_paths = {});
 
    EGT_NODISCARD bool is_composer() const;
 
    virtual int run();
 
    virtual void quit(int exit_value = 0);
 
    EventLoop& event() { return m_event; }
 
    EGT_NODISCARD Screen* screen() const { return m_screen.get(); }
 
    EGT_NODISCARD Window* main_window() const { return m_main_window; }
 
    EGT_NODISCARD Window* modal_window() const { return m_modal_window; }
 
    void set_modal_window(Window* window)
    {
        m_modal_window = window;
    }
 
    EGT_NODISCARD const std::vector<Window*>& windows() const { return m_windows; }
 
    void paint_to_file(const std::string& filename = {});
 
    void dump(std::ostream& out) const;
 
    void dump_timers(std::ostream& out) const;
 
    const std::vector<std::pair<std::string, std::string>>& get_input_devices();
 
    EGT_NODISCARD inline int argc() const { return m_argc; }
 
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
    EGT_NODISCARD inline const char** argv() const { return const_cast<const char**>(m_argv); }
 
    virtual ~Application() noexcept;
 
protected:
 
    static void setup_info();
    static void setup_logging();
    static void setup_locale(const std::string& name);
    void setup_backend(bool primary, const std::string& name);
    void setup_inputs();
    void setup_events();
 
    EventLoop m_event;
 
    int m_argc{0};
 
    char** m_argv{nullptr};
 
    asio::signal_set m_signals;
 
    std::vector<std::pair<std::string, std::string>> m_input_devices;
 
private:
 
    void signal_handler(const asio::error_code& error, int signum);
 
    std::unique_ptr<Screen> m_screen;
 
    std::vector<std::unique_ptr<Input>> m_inputs;
 
    Object::RegisterHandle m_handle{0};
 
    std::vector<Window*> m_windows;
 
    Window* m_main_window{nullptr};
 
    Window* m_modal_window{nullptr};
 
    std::vector<Timer*> m_timers;
 
    friend class Window;
    friend class Timer;
};
 
}
}
 
#endif