GUIResourceManager.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 GUIRESOURCEMANAGER__H_
#define GUIRESOURCEMANAGER__H_
 
#include "eC_String.h"
#include "eC_TArray.h"
 
#include "GUIComponentManager.h"
#include "FntWrap.h"
 
#include "GUIFontResource.h"
#include "GUISoundResource.h"
#include "GUIImageResource.h"
#include "GUIGeneralResource.h"
#include "GUIColorResource.h"
 
#include "GUIImageData.h"
 
#include "GUIThread.h"
 
class CGUIObject;
 
#define GETRESMANAGER CGUIComponentManager::GetInstance().GetResourceManager()
 
const eC_Int DIALOG_FILE_VERSION = 1;
 
 
class CGUIResourceManager
{
    friend class CGUI; 
    friend class CGUIComponentManager; 
 
public:
    static void CreateInstance();
 
    static void DeleteInstance();
 
#ifdef GUILIANI_WRITE_GUI
    eC_Bool WriteImageResourcesToFile(const eC_String& kPath);
 
    eC_Bool WriteFontResourcesToFile(const eC_String& kPath);
 
    eC_Bool WriteSoundResourcesToFile(const eC_String& kPath);
 
    eC_Bool WriteGeneralResourcesToFile(const eC_String& rkPath);
 
    eC_Bool WriteColorResourcesToFile(const eC_String& rkPath);
 
    void WriteDialogToFile(const eC_String& pkStreamingFile, CGUIObject* pkDialog);
 
    void WriteDialogToFile(eC_File *pkFile, CGUIObject* pkDialog);
#endif
 
#ifdef GUILIANI_STREAM_GUI
    eC_Bool RegisterImageResourcesFromFile(const eC_String& rkPath);
    eC_Bool RegisterFontResourcesFromFile(const eC_String& rkPath);
 
    eC_Bool RegisterSoundResourcesFromFile(const eC_String& rkPath);
 
    eC_Bool RegisterGeneralResourcesFromFile(const eC_String& rkPath);
 
    eC_Bool RegisterColorResourcesFromFile(const eC_String& rkPath);
#endif
 
    ImageResource_t RegisterDynamicImage(
        const eC_String& kPath,
        const eC_Bool bPermanent=false);
 
    ImageResource_t RegisterDynamicImage(
        void* pkMemory,
        const eC_UInt& uiWidth,
        const eC_UInt& uiHeight,
        const eC_UInt& eImageType,
        const eC_Bool bPermanent = true);
 
    SoundResource_t RegisterDynamicSound(
        const eC_String& kPath,
        const eC_Bool bPermanent=false);
 
    FontResource_t RegisterDynamicFont(
        const eC_String& kPath,
        eC_UInt uiFontSize,
        const CFntWrap::GUIFont_t &eFontStyle,
        eC_Bool bPermanent=true);
 
    GeneralResource_t RegisterDynamicGeneralResource(
        const eC_String& rkPath,
        eC_Bool bPermanent = false);
 
    ColorResource_t RegisterDynamicColor(
        const eC_UInt& ruiValue);
 
    void KeepDynamicImages(eC_Bool bKeep);
 
    void OverwriteDynamicImages(eC_Bool bOverwrite);
 
    void DynamicImagesMustExist(eC_Bool bMustExist);
 
    void KeepDynamicSounds(eC_Bool bKeep);
 
    void OverwriteDynamicSounds(eC_Bool bOverwrite);
 
    void DynamicSoundsMustExist(eC_Bool bMustExist);
 
    void KeepDynamicFonts(eC_Bool bKeep);
 
    void OverwriteDynamicFonts(eC_Bool bOverwrite);
 
    void DynamicFontsMustExist(eC_Bool bMustExist);
 
    void KeepDynamicGeneralResources(eC_Bool bKeep);
 
    void OverwriteDynamicGeneralResources(eC_Bool bOverwrite);
 
    void DynamicGeneralResourcesMustExist(eC_Bool bMustExist);
 
    inline void EnablePreloading(const eC_Bool bPreLoadPermanentData){ m_bPreLoadPermanentData = bPreLoadPermanentData; }
 
    void AddToPrefetchQueue(const ImageResource_t eID);
 
    eC_Bool RemoveFromPrefetchQueue(const ImageResource_t eID);
 
    void SetPrefetchDelay(eC_UInt uiDelay);
 
    void RequestImageResource(const ImageResource_t eImageID);
 
    void RequestFontResource(const FontResource_t eFontID);
 
    void RequestSoundResource(const SoundResource_t eSoundID);
 
    void RequestGeneralResource(const GeneralResource_t eResourceID);
 
    eC_Int GetImageRequestCount(const ImageResource_t& eImageID) const;
 
    eC_Int GetFontRequestCount(const FontResource_t& eFontID) const;
 
    eC_Int GetSoundRequestCount(const SoundResource_t& eSoundID) const;
 
    eC_Int GetGeneralResourceRequestCount(const GeneralResource_t& eGeneralResourceID) const;
 
    void FreeImageResource(const ImageResource_t eImageID);
 
    void FreeFontResource(const FontResource_t eFontID);
 
    void FreeSoundResource (const SoundResource_t eSoundID);
 
    void FreeGeneralResource(const GeneralResource_t eResourceID);
 
    void RegisterImageResource(
        const eC_String& kPath,
        const ImageResource_t eImageID,
        const eC_Bool bPermanent = false);
 
    void RegisterImageResource(
        void* pkMemory,
        const eC_UInt& uiWidth,
        const eC_UInt& uiHeight,
        const eC_UInt& eImageType,
        const ImageResource_t eImageID,
        const eC_Bool bPermanent);
 
    void RefreshImageResource(const ImageResource_t& eImageID, void* pkMemory);
 
    void RegisterFontResource(
        const eC_String& kPath,
        const FontResource_t eFontID,
        const eC_UInt uiFontSize,
        const CFntWrap::GUIFont_t &eFontStyle,
        const eC_Bool bPermanent = true);
 
    void RegisterSoundResource(
        const eC_String& pcPath,
        const SoundResource_t eSoundID,
        const eC_Bool bPermanent = false);
 
    void RegisterGeneralResource(
        const eC_String& rkPath,
        const GeneralResource_t eResourceID,
        eC_Bool bPermanent = false);
 
    void RegisterColorResource(
        const eC_UInt& uiValue,
        const ColorResource_t eColorID);
 
    eC_String GetImagePath (const ImageResource_t& eImageID) const;
 
    eC_UInt GetFontSize(const FontResource_t &eFontID) const;
 
    eC_String GetFontPath(const FontResource_t &eFontID) const;
 
    CFntWrap::GUIFont_t GetFontStyle(const FontResource_t &eFontID) const;
 
    void SetFontStyle(const FontResource_t &eFontID, const CFntWrap::GUIFont_t& eStyle);
 
    eC_String GetSoundPath(const SoundResource_t& eSoundID) const;
 
    eC_String GetGeneralResourcePath(const GeneralResource_t& eResourceID) const;
 
    eC_UInt GetColorValue(const ColorResource_t& eColorID) const;
 
    eC_Bool IsDynamicImage(ImageResource_t eImageID);
 
    eC_Bool IsDynamicFont(FontResource_t eFontID);
 
    eC_Bool IsDynamicSound(SoundResource_t eSoundID);
 
    eC_Bool IsDynamicGeneralResource(GeneralResource_t eResourceID);
 
    eC_Bool IsDynamicColor(ColorResource_t eColorID);
 
    eC_Bool IsImagePermanent(const ImageResource_t& eImageID) const;
 
    eC_Bool IsFontPermanent(const FontResource_t& eFontID) const;
 
    eC_Bool IsSoundPermanent(const SoundResource_t& eSoundID) const;
 
    eC_Bool IsGeneralResourcePermanent(const GeneralResource_t& eResourceID) const;
 
    eC_UInt GetNofImagesInPrefetchList();
 
    void PrintReloadCounts();
 
    void PrintRequestCounts();
 
    void SetGlobalColor(const ColorResource_t& eColorID, eC_UInt uiValue);
 
    void SetPredictResourceFileExtension(const eC_Bool& bPredictResourceFileExtension);
 
    eC_Bool GetPredictResourceFileExtension(void) const;
 
    void SetAddResourceFilePrefix(const eC_Bool& bAddResourceFilePrefix);
 
    eC_Bool GetAddResourceFilePrefix(void) const;
 
    eC_String GetImagesFilename() const;
 
    eC_String GetSoundsFilename() const;
 
    eC_String GetFontsFilename() const;
 
    eC_String GetGeneralResourcesFilename() const;
 
private:
    class CGUIBackgroundImageLoader
    {
    public:
        class CGUIBackgroundImageLoaderThread : public CGUIThread
        {
        public:
            CGUIBackgroundImageLoaderThread(CGUIResourceManager::CGUIBackgroundImageLoader* pkBackgroundLoader);
 
            virtual void Execute(void *pArg);
 
            void SetDelay(const eC_UInt& uiDelay);
 
        private:
            CGUIResourceManager::CGUIBackgroundImageLoader* m_pkBackgroundLoader;
            eC_UInt m_uiDelay;
        };
 
    public:
        struct PrefetchImage_t
        {
            PrefetchImage_t(
                const ImageResource_t eID = DUMMY_IMAGE,
                const eC_String& rkPath = "") :
                m_eID(eID),
                m_kPath(rkPath)
            {}
 
            bool operator== (const PrefetchImage_t& rkCompare) const
            {
                if ((m_eID == rkCompare.m_eID) &&
                    (m_kPath == rkCompare.m_kPath))
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
 
            ImageResource_t m_eID; 
            eC_String m_kPath; 
        };
 
    public:
        CGUIBackgroundImageLoader();
 
        // private copy constructor
        CGUIBackgroundImageLoader(const CGUIBackgroundImageLoader& ref) {}
 
        ~CGUIBackgroundImageLoader();
 
        eC_Bool AddImageToPrefetchList(const ImageResource_t eID, const eC_String& kPath);
 
        eC_Bool RemoveImageFromPrefetchList(const ImageResource_t eID, const eC_String& kPath);
 
        void SetDelay(const eC_UInt& uiDelay);
 
        void SetUsedImageID(const ImageResource_t& eID)
        {
            m_eUsedImage = eID;
        }
 
        ImageResource_t GetUsedImagedID() const
        {
            return m_eUsedImage;
        }
 
        inline eC_UInt GetNOFImagesInPrefetchList() const
        {
            return m_kaPrefetchImageList.GetQuantity();
        }
 
        void LockList()
        {
            m_kPrefetchImageListSema.Enter();
        }
 
        void UnlockList()
        {
            m_kPrefetchImageListSema.Leave();
        }
 
        void LockThread()
        {
            m_kImageLoaderThreadSema.Enter();
        }
 
        void UnlockThread()
        {
            m_kImageLoaderThreadSema.Leave();
        }
 
        eC_Bool GetFirstImage(PrefetchImage_t& kImageToBePrefetched)
        {
            return m_kaPrefetchImageList.RemoveFront(kImageToBePrefetched);
        }
 
    private:
        // List of images which are to be prefetched
        eC_TListDoubleLinked< PrefetchImage_t> m_kaPrefetchImageList;
 
        // Semaphore for locking access to the internal list of images
        eC_Semaphore m_kPrefetchImageListSema;
 
        // Semaphore which is used for blocking / unlocking the thread if new images are added to the list.
        eC_Semaphore m_kImageLoaderThreadSema;
 
        // Pointer to the background thread instance.
        CGUIBackgroundImageLoaderThread* m_pBackgroundImageLoaderThread;
 
        // ID of the currently loading Image, if nothing is loaded DUMMY_IMAGE
        ImageResource_t m_eUsedImage;
    };
 
private:
    void UnloadImage(ImageResource_t eImageID);
 
    void DeInit();
 
    void Init();
 
    CGUIResourceManager();
 
    ~CGUIResourceManager();
 
    CGUIResourceManager(const CGUIResourceManager& kSource);
 
    CGUIResourceManager& operator=(const CGUIResourceManager& kSource);
 
    void PrefetchNow();
 
private:
    // Structures to hold Resource-information.
    // Yes, this is currently identical for some Resource-types, but still kept separate for future extensions.
    struct ImageEntry_t
    {
        eC_String* pkPath;
        eC_Int iRequestCount;
        eC_Bool bPermanent;
    };
 
    struct SoundEntry_t
    {
        eC_String* pkPath;
        eC_Int iRequestCount;
        eC_Bool bPermanent;
    };
 
    struct FontEntry_t
    {
        eC_String* pkFontName;
        eC_UInt uiFontSize;
        CFntWrap::GUIFont_t eFontStyle;
        eC_Int iRequestCount;
        eC_Bool bPermanent;
    };
 
    struct GeneralResourceEntry_t
    {
        eC_String* pkResourceFilePath;
        eC_Int iRequestCount;
        eC_Bool bPermanent;
    };
 
private:
    CGUIBackgroundImageLoader* m_pkBackgroundLoader;
 
    eC_TArray<ImageEntry_t> m_kaImageTable;
    eC_TArray<FontEntry_t>  m_kaFontTable;
    eC_TArray<SoundEntry_t> m_kaSoundTable;
    eC_TArray<GeneralResourceEntry_t> m_kaGeneralResTable;
    eC_TArray<eC_UInt> m_kaColorTable;
 
    eC_TListDoubleLinked<ImageResource_t> m_aeReleasedPreloadedImages;
 
    eC_Bool m_bPreLoadPermanentData;
 
    eC_String m_kImagesFilename;
 
    eC_Bool m_bKeepDynamicImages;
 
    eC_Bool m_bOverwriteDynamicImages;
 
    eC_Bool m_bDynamicImagesMustExist;
 
    eC_String m_kSoundsFilename;
 
    eC_Bool m_bKeepDynamicSounds;
 
    eC_Bool m_bOverwriteDynamicSounds;
 
    eC_Bool m_bDynamicSoundsMustExist;
 
    eC_String m_kFontsFilename;
 
    eC_Bool m_bKeepDynamicFonts;
 
    eC_Bool m_bOverwriteDynamicFonts;
 
    eC_Bool m_bDynamicFontsMustExist;
 
    eC_String m_kGeneralResourcesFilename;
 
    eC_Bool m_bKeepDynamicGeneralResources;
 
    eC_Bool m_bOverwriteDynamicGeneralResources;
 
    eC_Bool m_bDynamicGeneralResourcesMustExist;
 
    eC_Bool m_bPredictResourceFileExtension;
 
    eC_Bool m_bAddResourceFilePrefix;
 
#ifdef _DEBUG
    eC_TArray<eC_UInt> m_auiImageReloadCount; 
    eC_TArray<eC_Bool> m_abImageDeletedBefore; 
#endif
};
 
#ifndef GUILIANI_GUILIANILIB
#include "GUIPropertyResource.h"
 
inline void RegisterStaticResources()
{
// Register properties.
#define ENTRY(prop_name, prop_value, prop_type) GETPROPHDL.SetGlobalProperty(prop_name, prop_value, static_cast<CGUIValue::GUIValue_t>(prop_type)); 
    USER_PROPERTY_TABLE
#undef ENTRY
 
// Register images.
#define ENTRY(img, img_name, img_permanent)  GETRESMANAGER.RegisterImageResource(img_name, img, img_permanent);
    USER_IMAGE_TABLE
#undef ENTRY
        
// Register fonts.
#define ENTRY(fnt, fnt_name, fnt_size, fnt_style, fnt_permanent)  GETRESMANAGER.RegisterFontResource(fnt_name, fnt, fnt_size, static_cast<CFntWrap::GUIFont_t>(fnt_style), fnt_permanent);
    USER_FONT_TABLE
#undef ENTRY
 
// Register general resources.
#define ENTRY(res, res_name, res_permanent)  GETRESMANAGER.RegisterGeneralResource(res_name, res, res_permanent);
    USER_GENERAL_RESOURCES_TABLE
#undef ENTRY
 
// Register sounds.
#define ENTRY(snd, snd_name, snd_permanent)  GETRESMANAGER.RegisterSoundResource(snd_name, snd, snd_permanent);
    USER_SOUND_TABLE
#undef ENTRY
}
 
inline void RegisterGuilianiStandardImages()
{
#define ENTRY(img, img_name, img_permanent)  GETRESMANAGER.RegisterImageResource("GuilianiResources/"  img_name, img, img_permanent);
    IMAGE_TABLE
#undef ENTRY
}
#define REGISTER_GUI_STANDARDCONTROL_IMAGES RegisterGuilianiStandardImages();
#endif
 
#endif