Application.hpp

 
#pragma once
#include <memory>
#include <stack>
#include <functional>
#include <Covellite/Events/Events.hpp>
#include <Covellite/App/IApplication.hpp>
 
class Application_test;
 
namespace covellite
{
 
namespace app
{
 
class IWindow;
 
class Application :
  public IApplication
{
  using Windows_t = ::std::stack<::std::shared_ptr<IWindow>>;
  using Run_t = ::std::function<void(void)>;
  using CreateApp_t = ::std::function<::std::unique_ptr<Application>(void)>;
 
public:
  class Continuous {}; 
  class EventBased {}; 
 
public:
  // Итерфейс IApplication:
  operator Events_t (void) const final { return m_Events; }
 
public:
  template<class>
  static void Main(void *) noexcept;
  ::std::string GetCommandLine(void) const;
  const Run_t Run;
 
protected:
  template<class TWindow, class ... TArgs>
  TWindow & MakeWindow(TArgs && ...);
 
private:
  static void Main(CreateApp_t, void *) noexcept;
  VIRTUAL_MOCK bool PostCommand(bool);
 
protected:
  events::Events  m_Events;
 
private:
  bool            m_IsFocused = false;
  Windows_t       m_Windows;
 
private:
  explicit Application(const Run_t &);
 
public:
  explicit Application(Continuous);
  explicit Application(EventBased);
  virtual ~Application(void) noexcept;
 
private:
  friend Application_test;
  FRIEND_TEST(Application_test, /*DISABLED_*/Test_MakeWindow);
  FRIEND_TEST(Application_android_test, /*DISABLED_*/Test_OnTermWindow);
  FRIEND_TEST(Application_android_test, /*DISABLED_*/Test_PostCommand);
};
 
} // namespace app
 
} // namespace covellite
 
#include <Covellite\App\Application.inl>