app.h

Go to the documentation of this file.

 
#ifndef APP_H
#define APP_H
 
#include <memory>
#include <string>
#include <vector>
#include <atomic>
#include <mutex>
#include <thread>
#include <condition_variable>
#include <SDL_events.h>
#include "iapp.h"
#include "config/iconfig_service.h"
#include "config/ui/config_ui.h"
#include "keybinds/iinput_manager.h"
#include "render/irenderer.h"
#include "render/iasset_manager.h"
#include "launcher/itable_launcher.h"
#include "tables/itable_loader.h"
#include "tables/itable_callbacks.h"
#include "tables/table_data.h"
#include "tables/overrides/table_override_editor.h"
#include "tables/overrides/table_override_manager.h"
#include "tables/vpsdb/vpsdb_catalog_manager.h"
#include "tables/vpsdb/vpsdb_catalog_table.h" // Added for VpsdbJsonLoader
#include "sound/isound_manager.h"
#include "capture/iscreenshot_manager.h"
#include "iwindow_manager.h"
#include "joystick_manager.h"
#include "ui/playfield_overlay.h"
#include "ui/imgui_manager.h"
#include "dependency_factory.h"
#include "iapp_callbacks.h"
#include "ui/loading_progress.h"
#include "ui/loading_screen.h"
struct Mix_Chunk;
 
class App : public IApp, public IAppCallbacks {
public:
    ISoundManager* getSoundManager() override; // Changed to ISoundManager*
    App(const std::string& configPath, bool forceSoftwareRenderer = false);
 
    ~App();
 
    void run();
 
    void reloadFont(bool isStandalone = false) override;
 
    void reloadWindows() override;
 
    void reloadAssetsAndRenderers() override;
 
    void reloadTablesAndTitle() override;
 
    void reloadOverlaySettings() override;
 
private:
    bool forceSoftwareRenderer_ = false; 
    std::string exeDir_;                        
    std::string configPath_;                    
    bool showConfig_ = false;                   
    std::unique_ptr<TableOverrideEditor> overrideEditor_; 
    TableOverrideManager overrideManager_; 
    bool showEditor_ = false;
    std::unique_ptr<vpsdb::VpsdbCatalog> vpsdbCatalog_;
    std::unique_ptr<vpsdb::VpsdbJsonLoader> vpsdbJsonLoader_; // Added for JSON loading
    bool showVpsdb_ = false;
    size_t currentIndex_ = 0;                   
    size_t lastTableIndex_; 
    std::unique_ptr<TTF_Font, void(*)(TTF_Font*)> font_; 
    std::unique_ptr<JoystickManager> joystickManager_;   
    std::unique_ptr<IWindowManager> windowManager_;      
    std::unique_ptr<ImGuiManager> imGuiManager_;             
    std::unique_ptr<ISoundManager> soundManager_;        
    std::unique_ptr<IKeybindProvider> keybindProvider_; 
    std::unique_ptr<IConfigService> configManager_;      
    std::unique_ptr<ConfigUI> configEditor_;             
    std::unique_ptr<IRenderer> renderer_;                
    std::unique_ptr<IAssetManager> assets_;              
    std::unique_ptr<IScreenshotManager> screenshotManager_; 
    std::unique_ptr<ITableLauncher> tableLauncher_;
    std::unique_ptr<IInputManager> inputManager_;        
    std::unique_ptr<ITableLoader> tableLoader_;          
    std::unique_ptr<ITableCallbacks> tableCallbacks_;
    std::vector<TableData> tables_;                      
    std::unique_ptr<PlayfieldOverlay> playfieldOverlay_; 
    bool prevShowConfig_ = false;                        
    std::atomic<bool> isLoadingTables_{false};          
    std::mutex tablesMutex_;                            
    std::shared_ptr<LoadingProgress> loadingProgress_; 
    std::unique_ptr<LoadingScreen> loadingScreen_;     
    std::thread loadingThread_;              // Added to store the loading thread
    std::mutex loadingMutex_;                // Added for synchronizing loading state
    std::condition_variable loadingCV_;      // Added to signal loading completion
 
    std::string getExecutableDir();
 
    bool isConfigValid();
 
    void loadTables();
 
    void loadFont();
 
    void handleEvents();
 
    void update();
 
    void render();
 
    void cleanup();
 
    void initializeDependencies();
 
    void loadTablesThreaded(size_t oldIndex = 0); // Helper for threaded loading
};
 
#endif // APP_H