Resource Management APIs for all project types about windowsappsdk HOT 15 CLOSED

DECLARE_HANDLE(MrmManagerHandle);
DECLARE_HANDLE(MrmContextHandle);
DECLARE_HANDLE(MrmMapHandle);

enum MrmType
{
    MrmType_Unknown,
    MrmType_String,
    MrmType_Path,
    MrmType_Embedded
};

struct MrmResourceData
{
    UINT32 size;
    void*  data;
};

STDAPI MrmCreateResourceManager(_In_ PCWSTR priFileName, _Out_ MrmManagerHandle* resourceManager);    
STDAPI_(void) MrmDestroyResourceManager(_In_opt_ MrmManagerHandle resourceManager);

STDAPI MrmCreateResourceContext(_In_ MrmManagerHandle resourceManager, _Out_ MrmContextHandle* resourceContext);
STDAPI_(void) MrmFreeQualifierNames(UINT32 size, _In_reads_(size) PWSTR* names);
STDAPI MrmGetAllQualifierNames(_In_ MrmContextHandle resourceContext, _Out_ UINT32* size, _Outptr_result_buffer_(*size) PWSTR** names);
STDAPI MrmGetQualifier(_In_ MrmContextHandle resourceContext, _In_ PCWSTR qualifierName, _Outptr_ PWSTR* qualifierValue);
STDAPI MrmSetQualifier(_In_ MrmContextHandle resourceContext, _In_ PCWSTR qualifierName, _In_ PCWSTR qualifierValue);
STDAPI_(void) MrmDestroyResourceContext(_In_opt_ MrmContextHandle resourceContext);

// Resource maps are owned by the resource manager and so do not need to be destroyed.
STDAPI MrmGetChildResourceMap(
    _In_ MrmManagerHandle resourceManager,
    _In_opt_ MrmMapHandle resourceMap,
    _In_ PCWSTR childResourceMapName,
    _Out_ MrmMapHandle* childResourceMap);

STDAPI MrmGetResourceCount(
    _In_ MrmManagerHandle resourceManager,
    _In_opt_ MrmMapHandle resourceMap,
    _Out_ UINT32* count);

STDAPI MrmLoadStringResource(
    _In_ MrmManagerHandle resourceManager,
    _In_opt_ MrmContextHandle resourceContext,
    _In_opt_ MrmMapHandle resourceMap,
    _In_ PCWSTR resourceId,
    _Outptr_ PWSTR* resourceString);

STDAPI MrmLoadStringResourceFromResourceUri(
    _In_ MrmManagerHandle resourceManager,
    _In_opt_ MrmContextHandle resourceContext,
    _In_ PCWSTR resourceUri,
    _Outptr_ PWSTR* resourceString);

STDAPI MrmLoadEmbeddedResource(
    _In_ MrmManagerHandle resourceManager,
    _In_opt_ MrmContextHandle resourceContext,
    _In_opt_ MrmMapHandle resourceMap,
    _In_ PCWSTR resourceId,
    _Out_ MrmResourceData* data);

STDAPI MrmLoadEmbeddedResourceFromResourceUri(
    _In_ MrmManagerHandle resourceManager,
    _In_opt_ MrmContextHandle resourceContext,
    _In_ PCWSTR resourceUri,
    _Out_ MrmResourceData* data);

STDAPI MrmLoadStringOrEmbeddedResource(
    _In_ MrmManagerHandle resourceManager,
    _In_opt_ MrmContextHandle resourceContext,
    _In_opt_ MrmMapHandle resourceMap,
    _In_ PCWSTR resourceId,
    _Out_ MrmType* resourceType,
    _Outptr_result_maybenull_ PWSTR* resourceString,
    _Out_ MrmResourceData* data);

STDAPI MrmLoadStringOrEmbeddedFromResourceUri(
    _In_ MrmManagerHandle resourceManager,
    _In_opt_ MrmContextHandle resourceContext,
    _In_ PCWSTR resourceUri,
    _Out_ MrmType* resourceType,
    _Outptr_result_maybenull_ PWSTR* resourceString,
    _Out_ MrmResourceData* data);

STDAPI MrmLoadStringOrEmbeddedResourceByIndex(
    _In_ MrmManagerHandle resourceManager,
    _In_opt_ MrmContextHandle resourceContext,
    _In_opt_ MrmMapHandle resourceMap,
    UINT32 index,
    _Out_ MrmType* resourceType,
    _Outptr_ PWSTR* resourceName,
    _Outptr_result_maybenull_ PWSTR* resourceString,
    _Out_ MrmResourceData* data);

STDAPI_(void*) MrmAllocateBuffer(size_t size); 
STDAPI_(void) MrmFreeResource(_In_opt_ void* resource);

STDAPI MrmGetFilePathFromName(_In_ PCWSTR filename, _Outptr_ PWSTR* filePath);

namespace Microsoft.ApplicationModel.Resources
{
    [contractversion(1.0)]
    apicontract MrtContract{};

    [contract(MrtContract, 1.0)]
    [default_interface]
    runtimeclass ResourceLoader
    {
        ResourceLoader();
        ResourceLoader(String fileName);
        ResourceLoader(String fileName, String resourceMap);

        static String GetDefaultResourceFilePath();

        String GetString(String resourceId);
        String GetStringForUri(Windows.Foundation.Uri resourceUri);
    }

    [contract(MrtContract, 1.0)]
    runtimeclass ResourceNotFoundEventArgs
    {
        ResourceContext Context { get; };
        String Name { get; };
        void SetResolvedCandidate(ResourceCandidate candidate);
    }

    [contract(MrtContract, 1.0)]
    runtimeclass ResourceManager
    {
        ResourceManager();
        ResourceManager(String fileName);

        ResourceMap MainResourceMap { get; };
        ResourceContext DefaultResourceContext { get; };

        event Windows.Foundation.TypedEventHandler<ResourceManager, ResourceNotFoundEventArgs> ResourceNotFound;
    }

    [contract(MrtContract, 1.0)]
    runtimeclass ResourceMap
    {
        UInt32 ResourceCount { get; }; 

        ResourceMap GetSubtree(String reference);
        ResourceCandidate GetValue(String resource);
        ResourceCandidate GetValue(ResourceContext context, String resource);
        Windows.Foundation.Collections.IKeyValuePair<String, ResourceCandidate> GetValueByIndex(UInt32 index);
        Windows.Foundation.Collections.IKeyValuePair<String, ResourceCandidate> GetValueByIndex(ResourceContext context, UInt32 index);
    }

    [contract(MrtContract, 1.0)]
    runtimeclass ResourceContext
    {
        Windows.Foundation.Collections.IMap<String, String> QualifierValues { get; };
    }

    [contract(MrtContract, 1.0)]
    enum ResourceCandidateKind
    {
        Unknown = 0,
        String,
        FilePath,
        EmbeddedData,
    };

    [contract(MrtContract, 1.0)]
    runtimeclass ResourceCandidate
    {
        ResourceCandidate(ResourceCandidateKind kind, String data);
        ResourceCandidate(byte[] data);

        String ValueAsString { get; };
        byte[] ValueAsBytes { get; };
        ResourceCandidateKind Kind { get; };
    }
} // namespace Microsoft.ApplicationModel.Resources

MrmManagerHandle resourceManager; 
MrmCreateResourceManager(L"resources.pri", &resourceManager); 
  
MrmContextHandle resourceContext; 
MrmCreateResourceContext(resourceManager, &resourceContext); 
  
MrmSetQualifier(resourceContext, L"Contrast", L"WHITE"); 
MrmSetQualifier(resourceContext, L"TargetSize", L"96"); 
  
// Load the asset file path
wchar_t* resourceString; 
MrmLoadStringResource( 
    resourceManager,  
    resourceContext,  
    nullptr,  
    L"Files/Assets/AppList.png",  
    &resourceString);  
MrmFreeResource(resourceString); 
  
MrmMapHandle childResourceMap; 
MrmGetChildResourceMap( 
    resourceManager,  
    nullptr,  
    L"Files",  
    &childResourceMap); 
  
MrmMapHandle childChildResourceMap; 
MrmGetChildResourceMap( 
    resourceManager,  
    childResourceMap,  
    L"Assets",  
    &childChildResourceMap); 
  
// Load the asset file path
MrmLoadStringResource( 
    resourceManager,  
    resourceContext,  
    childChildResourceMap,  
    L"AppList.png",  
    &resourceString); 
MrmFreeResource(resourceString); 
  
MrmDestroyResourceContext(resourceContext); 
MrmDestroyResourceManager(resourceManager); 

var resourceManager = new ResourceManager();
var candidate = resourceManager.MainResourceMap.GetValue("resources/IDS_MANIFEST_MUSIC_APP_NAME");
var value = candidate.ValueAsString;

var resourceContext = resourceManager.DefaultResourceContext;
resourceContext.QualifierValues["Language"] = "fr-FR";
candidate = resourceManager.MainResourceMap.GetValue(resourceContext, "resources/IDS_MANIFEST_MUSIC_APP_NAME");

some\picture.png
some\picture.scale-200.png
some\strings.resjson
some\strings.lang-de.resjson
some\other_image.lang-de_scale-125.png