GUIComponentManager.h

/*
* Copyright (C) TES Electronic Solutions GmbH,
* All Rights Reserved.
* Contact: info@guiliani.de
*
* This file is part of the Guiliani HMI framework
* for the development of graphical user interfaces on embedded systems.
*/
 
#ifndef __GUICOMPONENTMANAGER_H__
#define __GUICOMPONENTMANAGER_H__
 
#include "eC_Types.h"
#include "eC_TArrayStack.h"
 
#include "GUIConfigDebug.h"
 
// wrappers
class CGfxEnv;
class CGfxWrap;
class CFntWrap;
class CGUIInputMedia;
class CSndWrap;
 
// streaming
#ifdef GUILIANI_STREAM_GUI
class CGUIStreamReader;
#endif
#ifdef GUILIANI_WRITE_GUI
class CGUIStreamWriter;
#endif
 
// other
class CGUIAnimationHandler;
class CGUIClipboard;
class CGUICommandHandler;
#ifdef GUILIANI_CONNECTION_ACTIVE
class CGUIConnectionHandler;
#endif
class CGUIEventHandler;
class CGUIFileSysWrap;
class CGUIFactoryManager;
class CGUIGeneralResourceManager;
class CGUIImageLoader;
class CGUILocalisationHandler;
#ifdef GUILIANI_USE_PERFMON
class CGUIPerfMon;
#endif
class CGUIProfiler;
class CGUIProperties;
class CGUIResourceFileHandler;
class CGUIResourceManager;
class CGUITimer;
class CGUITrace;
 
 
class CGUIComponentManager
{
public:
    static CGUIComponentManager& GetInstance();
 
    CGUIComponentManager();
 
    void SetInstances(CGUIComponentManager* pkComponentManager);
 
    void DeleteInstances();
 
    void SetGfxEnv(CGfxEnv* pkGfxEnv);
 
    CGfxEnv& GetGfxEnv();
 
    void DeleteGfxEnv();
 
    eC_Bool HasGfxEnv() const;
 
    void SetGfxWrap(CGfxWrap* pkGfxWrap);
 
    CGfxWrap& GetGfxWrap();
 
    void DeleteGfxWrap();
 
    eC_Bool HasGfxWrap() const;
 
    void SetFntWrap(CFntWrap* pkFntWrap);
 
    CFntWrap& GetFntWrap();
 
    void DeleteFntWrap();
 
    eC_Bool HasFntWrap() const;
 
    void SetInputMedia(CGUIInputMedia* pkInputMedia);
 
    CGUIInputMedia& GetInputMedia();
 
    void DeleteInputMedia();
 
    eC_Bool HasInputMedia() const;
 
    void SetSndWrap(CSndWrap* pkSndWrap);
 
    CSndWrap& GetSndWrap();
 
    void DeleteSndWrap();
 
    eC_Bool HasSndWrap() const;
 
#ifdef GUILIANI_STREAM_GUI
    void SetStreamReaderStack(eC_TArrayStack<CGUIStreamReader*>* pkStreamReaderStack);
 
    eC_TArrayStack<CGUIStreamReader*>* GetStreamReaderStack();
 
    CGUIStreamReader& GetStreamReader();
#endif
 
#ifdef GUILIANI_WRITE_GUI
    void SetStreamWriterStack(eC_TArrayStack<CGUIStreamWriter*>* pkStreamWriterStack);
 
    eC_TArrayStack<CGUIStreamWriter*>* GetStreamWriterStack();
 
    CGUIStreamWriter& GetStreamWriter();
#endif
 
    void SetAnimationHandler(CGUIAnimationHandler* pkAnimationHandler);
 
    CGUIAnimationHandler& GetAnimationHandler();
 
    void DeleteAnimationHandler();
 
    eC_Bool HasAnimationHandler() const;
 
    void SetClipboard(CGUIClipboard* pkClipboard);
 
    CGUIClipboard& GetClipboard();
 
    void DeleteClipboard();
 
    eC_Bool HasClipboard() const;
 
    void SetCommandHandler(CGUICommandHandler* pkCommandHandler);
 
    CGUICommandHandler& GetCommandHandler();
 
    void DeleteCommandHandler();
 
    eC_Bool HasCommandHandler() const;
 
#ifdef GUILIANI_CONNECTION_ACTIVE
    void SetConnectionHandler(CGUIConnectionHandler* pkConnectionHandler);
 
    CGUIConnectionHandler& GetConnectionHandler();
 
    void DeleteConnectionHandler();
 
    eC_Bool HasConnectionHandler() const;
#endif
 
    void SetEventHandler(CGUIEventHandler* pkEventHandler);
 
    CGUIEventHandler& GetEventHandler();
 
    void DeleteEventHandler();
 
    eC_Bool HasEventHandler() const;
 
    void SetFactoryManager(CGUIFactoryManager* pkFactoryManager);
 
    CGUIFactoryManager& GetFactoryManager();
 
    void DeleteFactoryManager();
 
    eC_Bool HasFactoryManager() const;
 
    void SetFileSystem(CGUIFileSysWrap* pkFileSystem);
 
    CGUIFileSysWrap& GetFileSystem();
 
    void DeleteFileSystem();
 
    eC_Bool HasFileSystem() const;
 
    void SetGeneralResourceManager(CGUIGeneralResourceManager* pkGeneralResourceManager);
 
    CGUIGeneralResourceManager& GetGeneralResourceManager();
 
    void DeleteGeneralResourceManager();
 
    eC_Bool HasGeneralResourceManager() const;
 
    void SetImageLoader(CGUIImageLoader* pkImageLoader);
 
    CGUIImageLoader& GetImageLoader();
 
    void DeleteImageLoader();
 
    eC_Bool HasImageLoader() const;
 
    void SetLocalisationHandler(CGUILocalisationHandler* pkLocalisationHandler);
 
    CGUILocalisationHandler& GetLocalisationHandler();
 
    void DeleteLocalisationHandler();
 
    eC_Bool HasLocalisationHandler() const;
 
#ifdef GUILIANI_USE_PERFMON
    void SetPerfMon(CGUIPerfMon* pkPerfMon);
 
    CGUIPerfMon& GetPerfMon();
 
    void DeletePerfMon();
 
    eC_Bool HasPerfMon() const;
#endif
 
    void SetProfiler(CGUIProfiler* pkProfiler);
 
    CGUIProfiler& GetProfiler();
 
    void DeleteProfiler();
 
    eC_Bool HasProfiler() const;
 
    void SetProperties(CGUIProperties* pkProperties);
 
    CGUIProperties& GetProperties();
 
    void DeleteProperties();
 
    eC_Bool HasProperties() const;
 
    void SetResourceFileHandler(CGUIResourceFileHandler* pkResourceFileHandler);
 
    CGUIResourceFileHandler& GetResourceFileHandler();
 
    void DeleteResourceFileHandler();
 
    eC_Bool HasResourceFileHandler() const;
 
    void SetResourceManager(CGUIResourceManager* pkResourceManager);
 
    CGUIResourceManager& GetResourceManager();
 
    void DeleteResourceManager();
 
    eC_Bool HasResourceManager() const;
 
    void SetTimer(CGUITimer* pkTimer);
 
    CGUITimer& GetTimer();
 
    void DeleteTimer();
 
    eC_Bool HasTimer() const;
 
    void SetTrace(CGUITrace* pkTrace);
 
    CGUITrace& GetTrace();
 
    void DeleteTrace();
 
    eC_Bool HasTrace() const;
 
private:
    // wrappers
    CGfxEnv* m_pkGfxEnv;
    CGfxWrap* m_pkGfxWrap;
    CFntWrap* m_pkFntWrap;
    CGUIInputMedia* m_pkInputMedia;
    CSndWrap* m_pkSndWrap;
 
    // streaming
#ifdef GUILIANI_STREAM_GUI
    eC_TArrayStack<CGUIStreamReader*>* m_pkStreamReaderStack;
#endif
 
#ifdef GUILIANI_WRITE_GUI
    eC_TArrayStack<CGUIStreamWriter*>* m_pkStreamWriterStack;
#endif
 
    CGUIAnimationHandler* m_pkAnimationHandler;
    CGUIClipboard* m_pkClipboard;
    CGUICommandHandler* m_pkCommandHandler;
#ifdef GUILIANI_CONNECTION_ACTIVE
    CGUIConnectionHandler* m_pkConnectionHandler;
#endif
    CGUIEventHandler* m_pkEventHandler;
    CGUIFactoryManager* m_pkFactoryManager;
    CGUIFileSysWrap* m_pkFileSystem;
    CGUIGeneralResourceManager* m_pkGeneralResourceManager;
    CGUIImageLoader* m_pkImageLoader;
    CGUILocalisationHandler* m_pkLocalisationHandler;
#ifdef GUILIANI_USE_PERFMON
    CGUIPerfMon* m_pkPerfMon;
#endif
    CGUIProfiler* m_pkProfiler;
    CGUIProperties* m_pkProperties;
    CGUIResourceFileHandler* m_pkResourceFileHandler;
    CGUIResourceManager* m_pkResourceManager;
    CGUITimer* m_pkTimer;
    CGUITrace* m_pkTrace;
 
    static CGUIComponentManager* ms_pkInstance;
};
 
#endif