application.hpp

Go to the documentation of this file.

/*
    Copyright 2019-2021 natinusala
    Copyright 2019 p-sam
    Copyright 2021 XITRIX
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
 
        http://www.apache.org/licenses/LICENSE-2.0
 
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/
 
#pragma once
 
#include <deque>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#include <aurore/core/activity.hpp>
#include <aurore/core/audio.hpp>
#include <aurore/core/font.hpp>
#include <aurore/core/frame_context.hpp>
#include <aurore/core/logger.hpp>
#include <aurore/core/notification_manager.hpp>
#include <aurore/core/observable.hpp>
#include <aurore/core/platform.hpp>
#include <aurore/core/style.hpp>
#include <aurore/core/theme.hpp>
#include <aurore/core/view.hpp>
#include <aurore/views/label.hpp>
 
#ifdef __WINRT__
#ifdef main
#undef main
#endif
#define main SDL_main
#endif
 
namespace aurore
{
 
enum class InputType
{
    GAMEPAD, 
    TOUCH, 
};
 
class DebugLayer;
class EditTextDialog;
struct ThemeImage;
 
typedef std::function<View*(void)> XMLViewCreator;
 
class Application
{
  public:
    friend class EditTextDialog;
 
    static inline uint32_t ORIGINAL_WINDOW_WIDTH  = 1280; 
    static inline uint32_t ORIGINAL_WINDOW_HEIGHT = 720; 
    inline static std::string appId               = ""; 
 
    static bool init();
 
    static void setAppId(std::string appId) { Application::appId = std::move(appId); }
    static const std::string& getAppId() { return Application::appId; }
 
    static void setCadran(bool on) { Application::cadran = on; }
    static bool isCadran() { return Application::cadran; }
 
    static void createWindow(std::string title);
 
    static bool mainLoop();
 
    static Platform* getPlatform();
    static AudioPlayer* getAudioPlayer();
 
    static YGConfig* getYogaConfig();
 
    static NVGcontext* getNVGContext();
    inline static float contentWidth, contentHeight;
 
    inline static unsigned windowWidth, windowHeight;
 
    inline static int windowXPos, windowYPos;
 
    static void onWindowResized(int width, int height);
 
    static void setWindowSize(int width, int height);
 
    static void onWindowReposition(int xPos, int yPos);
 
    static void setWindowPosition(int xPos, int yPos);
 
    static std::vector<Activity*> getActivitiesStack();
 
    static void pushActivity(Activity* view, TransitionAnimation animation = TransitionAnimation::FADE);
 
    static void replaceActivity(Activity* activity, TransitionAnimation animation = TransitionAnimation::FADE);
 
    static bool popActivity(
        TransitionAnimation animation = TransitionAnimation::FADE, std::function<void(void)> cb = [] {}, bool free = true);
 
    static void giveFocus(View* view);
 
    static void forgetView(View* view);
 
    static void setHighlightIdleFade(bool fade);
 
    static void setFocusAnnouncer(std::function<void(const std::string&)> announcer);
 
    static void announce(const std::string& text);
    static const std::string& getLastAnnouncement() { return Application::lastAnnouncement; }
 
    static void setReduceMotion(bool reduce);
    static bool getReduceMotion();
    static bool isReduceMotionSet() { return Application::reduceMotion; }
 
    static Time getLastInputTime() { return Application::lastInputTime; }
 
    static void setTextScale(float scale);
    static float getTextScale();
 
    static void setDensity(float density) { aurore::setDensity(density); }
    static float getDensity() { return aurore::getDensity(); }
 
    static void registerModel(const std::string& name, DataModel* model);
    static void unregisterModel(const std::string& name);
    static DataModel* getModel(const std::string& name);
 
    static View* getHoveredView() { return Application::hoveredView; }
 
    inline static Style getStyle()
    {
        return aurore::getStyle();
    }
 
    static Theme getTheme();
    static ThemeVariant getThemeVariant();
 
    static Event<ThemeVariant>* getThemeChangedEvent();
 
    static bool hasThemeBackground();
 
    static void drawThemeBackground(NVGcontext* vg, float x, float y, float width, float height);
 
    static void drawThemeBackground(NVGcontext* vg, float x, float y, float width, float height, float radius);
 
    static ImeManager* getImeManager();
 
    static bool loadFontFromFile(std::string fontName, std::string filePath);
 
    static bool loadFontFromMemory(std::string fontName, void* data, size_t size, bool freeData);
 
    static bool loadFontFromMemory(std::string fontName, void* data, size_t size, bool freeData, int faceIndex);
 
    static int getFont(std::string fontName);
 
    static bool addFontFallback(const std::string& font, const std::string& fallback);
 
    static int getDefaultFont();
 
    static void notify(const std::string& text, View* leading = nullptr);
 
    static void onControllerButtonPressed(enum ControllerButton button, bool repeating);
 
    static void onKeyboardPressed(AuroreKeyCombination key, bool repeating);
 
    static void crash(std::string text);
 
    static void quit();
    static void clear();
 
    static void blockInputs(bool muteSounds = false);
 
    static void unblockInputs();
 
    static bool isInputBlocks();
 
    static const ControllerState& getControllerState();
 
    static void setCommonFooter(std::string footer);
    static std::string* getCommonFooter();
 
    inline static float windowScale;
    inline static float maximumUIScale = 0.0f; 
 
    static void setMaximumUIScale(float scale);
    static float getMaximumUIScale();
 
    static void setGlobalQuit(bool enabled);
 
    static void setFPSStatus(bool enabled);
    static bool getFPSStatus();
    static size_t getFPS();
 
    static void setLimitedFPS(size_t fps);
 
    static void setSwapInterval(int interval);
 
    static void setAutomaticDeactivation(bool value);
    static bool getAutomaticDeactivation();
    static bool hasActiveEvent();
    static void setActiveEvent(bool value);
    static void setDeactivatedTime(int millisecond);
    static void setDeactivatedFPS(int value);
    static int getDeactivatedFPS();
    static double getDeactivatedFrameTime();
 
    static void setRedrawOnDemand(bool enabled);
    static bool isRedrawOnDemand();
 
    static void requestRedraw();
 
    static uint64_t getDrawnFrameCount();
 
    static void setRedrawDebug(bool enabled);
    static bool isRedrawDebug();
 
    static uint64_t getMissedRedrawCount();
    static Rect getLastMissedRedrawArea();
 
    static GenericEvent* getGlobalFocusChangeEvent();
    static VoidEvent* getGlobalHintsUpdateEvent();
    static Event<InputType>* getGlobalInputTypeChangeEvent();
    static VoidEvent* getRunLoopEvent();
    static VoidEvent* getPostFrameEvent();
    static VoidEvent* getExitEvent();
    static VoidEvent* getExitDoneEvent();
    static VoidEvent* getWindowSizeChangedEvent();
    static VoidEvent* getWindowCreationDoneEvent();
    static VoidEvent* getWindowShouldCloseEvent();
    static Event<bool>* getWindowFocusChangedEvent();
 
    static View* getCurrentFocus();
 
    static std::string getTitle();
 
    static void registerXMLView(std::string name, XMLViewCreator creator);
 
    static bool XMLViewsRegisterContains(std::string name);
 
    static std::vector<std::string> getXMLViewNames();
    static XMLViewCreator getXMLViewCreator(std::string name);
 
    static std::string getLocale();
 
    static void addToFreeQueue(View* view);
 
    inline static InputType getInputType()
    {
        return inputType;
    }
 
    static void setInspectorEnabled(bool enabled);
    static bool isInspectorEnabled();
 
    static void setHotReload(bool enabled, const std::string& resourcesDir = "");
    static bool isHotReload();
 
    static bool rebuildActivity();
 
    inline static void enableDebuggingView(bool enable)
    {
        debuggingViewEnabled = enable;
    }
 
    inline static bool isDebuggingViewEnabled()
    {
        return debuggingViewEnabled;
    }
 
    static void setSwapInputKeys(bool swap);
 
    static void mapKey(AuroreKeyCombination key, ControllerButton button);
    static void unmapKey(AuroreKeyCombination key);
    static void clearKeyMap();
    static const std::vector<std::pair<AuroreKeyCombination, ControllerButton>>& getKeyMap();
 
    inline static bool isSwapInputKeys()
    {
        return swapInputKeys;
    }
 
    inline static void setDrawCoursor(bool draw)
    {
        drawCoursor = draw;
    }
 
    inline static bool isDrawCursor()
    {
        return drawCoursor;
    }
 
    inline static bool isHintsLiteMode()
    {
        return hintsLiteMode;
    }
 
    inline void static setHintsLiteMode(const bool value)
    {
        hintsLiteMode = value;
    }
 
    static void tryDeinitFirstResponder(View* view);
 
    static void addToWatchedKeys(const AuroreKeyCombination key);
 
    static void removeWatchedKeys(const AuroreKeyCombination key);
 
  private:
    static void updateHover(Point position, bool inside);
    static void announceFocus(View* oldFocus, View* newFocus);
 
    inline static std::function<void(const std::string&)> focusAnnouncer;
    inline static std::string lastAnnouncement;
    inline static bool reduceMotion = false;
    inline static std::unordered_map<std::string, DataModel*> models;
    inline static View* hoveredView = nullptr;
 
    inline static bool inited               = false;
    inline static bool cadran               = true;
    inline static bool quitRequested        = false;
    inline static bool debuggingViewEnabled = false;
    inline static bool swapInputKeys        = false;
    inline static bool drawCoursor          = false;
 
    inline static Platform* platform = nullptr;
 
    inline static std::string title;
 
    inline static FontStash fontStash;
 
    inline static std::vector<Activity*> activitiesStack;
    inline static std::vector<View*> focusStack;
    inline static std::deque<View*> deletionPool;
 
    inline static View* currentFocus = nullptr;
    inline static std::vector<TouchState> currentTouchState;
    inline static MouseState currentMouseState;
    inline static NotificationManager* notificationManager;
 
    static bool setInputType(InputType type);
 
    inline static InputType inputType = InputType::GAMEPAD;
    inline static std::vector<AuroreKeyState> watchedKeys;
    inline static std::vector<AuroreKeyState> oldWatchedKeys;
    inline static std::unordered_map<int, int> watchedKeysMap;
    static std::vector<std::pair<AuroreKeyCombination, ControllerButton>> keyMap;
    static void applyKeyMap(InputManager* inputManager, ControllerState* state);
    inline static ControllerState controllerState = {};
 
    inline static void processInput();
    inline static bool internalMainLoop();
 
    inline static void updateFPS();
 
    inline static unsigned blockInputsTokens = 0; 
    inline static bool muteSounds            = false;
 
    inline static std::string commonFooter;
 
    inline static bool globalQuitEnabled                = false;
    inline static ActionIdentifier gloablQuitIdentifier = ACTION_NONE;
    inline static bool globalFPSToggleEnabled           = false;
    inline static size_t globalFPS                      = 60;
    inline static Time limitedFrameTime                 = 0;
    inline static Time frameStartTime                   = 0;
    inline static bool hintsLiteMode                    = false;
 
    inline static bool deactivatedBehavior = false;
    inline static bool activeEvent         = false;
    inline static Time lastActiveTime      = 0;
    inline static Time lastInputTime       = 0;
    inline static bool highlightIdleFade   = false;
    inline static bool redrawOnDemand      = false;
    inline static int redrawFrames         = 2; 
    inline static Time lastDrawTime        = 0;
    inline static uint64_t drawnFrames     = 0;
    inline static bool redrawDebug         = false;
    inline static uint64_t missedRedraws   = 0;
    static Rect missedRedrawArea;
    inline static std::vector<unsigned char> presentedPixels;
    inline static int presentedWidth = 0, presentedHeight = 0;
    inline static int deactivatedFPS  = 5; 
    inline static int deactivatedTime = 5000000; 
 
    inline static View* repetitionOldFocus = nullptr;
 
    inline static GenericEvent globalFocusChangeEvent;
    inline static VoidEvent globalHintsUpdateEvent;
    inline static Event<InputType> globalInputTypeChangeEvent;
    inline static VoidEvent runLoopEvent;
    inline static VoidEvent postFrameEvent;
    inline static VoidEvent exitEvent;
    inline static VoidEvent exitDoneEvent;
    inline static VoidEvent windowSizeChangedEvent;
    inline static VoidEvent windowCreationDoneEvent;
    inline static VoidEvent windowShouldCloseEvent;
    inline static Event<bool> windowFocusChangedEvent;
    inline static Event<ThemeVariant> themeChangedEvent;
 
    inline static uint64_t themeGeneration  = 0;
    inline static ThemeVariant themeVariant = ThemeVariant::DARK;
    static void checkThemeChanged();
 
    inline static ThemeBackground themeBackgroundSpec;
    inline static std::shared_ptr<ThemeImage> themeBackground;
    inline static std::shared_ptr<ThemeImage> themeBackgroundLoading;
    static void loadThemeBackground();
    static void onThemeImageLoaded(const ThemeImage* image);
    static void drawThemeBackgroundImage(NVGcontext* vg, float x, float y, float width, float height, float radius = 0.0f);
 
    inline static std::unordered_map<std::string, XMLViewCreator> xmlViewsRegister;
 
    static void navigate(FocusDirection direction, bool repeating);
 
    static void frame(bool present = true);
    static void checkSkippedFrame();
    static void exit();
 
    static bool handleAction(ActionType type, int button, bool repeating);
 
    static void registerBuiltInXMLViews();
 
    inline static DebugLayer* debugLayer = nullptr;
};
 
} // namespace aurore