Fully native C++ WinRT application example

//
// Fully native C++ WinRT application example
// Programmed by fincs
//

#include <windows.h>
#include <roapi.h>
#include <wchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wrl.h>

#include <Windows.UI.Xaml.h>
#include <Windows.UI.Xaml.Markup.h>
#include <Windows.ApplicationModel.Activation.h>

using namespace Microsoft::WRL;
using namespace Microsoft::WRL::Wrappers;
using namespace Windows::Foundation;
using namespace ABI::Windows::UI::Xaml;
using namespace ABI::Windows::UI::Xaml::Markup;
using namespace ABI::Windows::ApplicationModel::Activation;

//---------------------------------------------------------------------------
// Error handling
//---------------------------------------------------------------------------

// Even though this is officially unsupported and the corresponding declaration in
// the header files is left out for WinRT apps, it is actually possible to use these
// "forbidden" functions via manually including the declaration like as follows:
extern "C" int WINAPI MessageBoxW(HWND parent, LPCWSTR aText, LPCWSTR aTitle, int opt);

// Error checking helper
void CheckHRESULT(HRESULT hr, LPCWSTR message)
{
    if (FAILED(hr))
    {
        WCHAR aBuf[1024];
        swprintf_s(aBuf, L"Error 0x%08X during: %s", hr, message);
        MessageBoxW(NULL, aBuf, L"BareMetalMetroApp", MB_ICONERROR);
        exit(1);
    }
}

//---------------------------------------------------------------------------
// Application class
//---------------------------------------------------------------------------

class MyApp: public RuntimeClass<IApplicationOverrides>
{
    InspectableClass(L"BareMetalMetroApp.MyApp", BaseTrust);

protected:
    ComPtr<IApplicationOverrides> pBaseImpl;

public:
    void SetBase(IApplicationOverrides* _pBaseImpl)
    {
        pBaseImpl = _pBaseImpl;
    }

    STDMETHOD(OnActivated)(IActivatedEventArgs* args) { return pBaseImpl->OnActivated(args); }
    STDMETHOD(OnLaunched)(ILaunchActivatedEventArgs* args);
    STDMETHOD(OnFileActivated)(IFileActivatedEventArgs* args) { return pBaseImpl->OnFileActivated(args); }
    STDMETHOD(OnSearchActivated)(ISearchActivatedEventArgs* args) { return pBaseImpl->OnSearchActivated(args); }
    STDMETHOD(OnShareTargetActivated)(IShareTargetActivatedEventArgs* args) { return pBaseImpl->OnShareTargetActivated(args); }
    STDMETHOD(OnFileOpenPickerActivated)(IFileOpenPickerActivatedEventArgs* args) { return pBaseImpl->OnFileOpenPickerActivated(args); }
    STDMETHOD(OnFileSavePickerActivated)(IFileSavePickerActivatedEventArgs* args) { return pBaseImpl->OnFileSavePickerActivated(args); }
    STDMETHOD(OnCachedFileUpdaterActivated)(ICachedFileUpdaterActivatedEventArgs* args) { return pBaseImpl->OnCachedFileUpdaterActivated(args); }
};

//---------------------------------------------------------------------------
// OnLaunched event
//---------------------------------------------------------------------------

#define MARKUP_TO_LOAD \
    L"<Grid xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\">" \
    L"  <TextBlock Text=\"Hello, fully native world!\" VerticalAlignment=\"Center\" HorizontalAlignment=\"Center\" FontSize=\"48\" />" \
    L"</Grid>"

// TODO: find out how to listen to events coming from e.g. buttons
// L"  <Button Content=\"Click me\" VerticalAlignment=\"Center\" HorizontalAlignment=\"Center\" />"

/*
// This is what this function looks like under C++/CX:

void MyApp::OnLaunched(ILaunchActivatedEventArgs^ args)
{
    Window::Current->Content = XamlReader::Load(MARKUP_TO_LOAD);
}
*/

STDMETHODIMP MyApp::OnLaunched(ILaunchActivatedEventArgs* args)
{
    // Prepare HSTRING versions of class names
    HStringReference WindowClsName(RuntimeClass_Windows_UI_Xaml_Window);
    HStringReference XamlReaderClsName(RuntimeClass_Windows_UI_Xaml_Markup_XamlReader);
    HStringReference MarkupData(MARKUP_TO_LOAD);

    // pCurWin = Window::Current
    ComPtr<IWindow> pCurWin;
    {
        ComPtr<IWindowStatics> pWinStatics;
        CheckHRESULT(GetActivationFactory(WindowClsName.Get(), &pWinStatics), L"IWinStatics");
        CheckHRESULT(pWinStatics->get_Current(&pCurWin), L"get_Current");
    }

    ComPtr<IUIElement> pContent;
    {
        ComPtr<IXamlReaderStatics> pXamlReaderStatics;
        ComPtr<IInspectable> pObj;

        // pContent = XamlReader::Load(MarkupData)
        CheckHRESULT(GetActivationFactory(XamlReaderClsName.Get(), &pXamlReaderStatics), L"IXamlReaderStatics");
        CheckHRESULT(pXamlReaderStatics->Load(MarkupData.Get(), &pObj), L"Markup loading failure");
        CheckHRESULT(pObj.As(&pContent), L"IUIElement");
    }

    // pCurWin->Content = pContent
    pCurWin->put_Content(pContent.Get());
    pCurWin->Activate();

    return S_OK;
}

//---------------------------------------------------------------------------
// Application initialization function
//---------------------------------------------------------------------------

/*
// This is what this function looks like under C++/CX:

static void InitApplication(IApplicationInitializationCallbackParams^ args)
{
    auto app = ref new MyApp();
}
*/

static STDMETHODIMP InitApplication(IApplicationInitializationCallbackParams* args)
{
    // Prepare HSTRING versions of class names
    HStringReference ApplicationClsName(RuntimeClass_Windows_UI_Xaml_Application);

    ComPtr<IApplicationFactory> pAppFactory;
    CheckHRESULT(GetActivationFactory(ApplicationClsName.Get(), &pAppFactory), L"IApplicationFactory");

    ComPtr<MyApp> pMyApp = Make<MyApp>();
    ComPtr<IApplication> pApp;
    {
        // This is done like this because pInner is set to a reference to the same object as the
        // return value (albeit with a different VTable (offset)), and the Microsoft guys *FORGOT*
        // to AddRef(). Therefore we need to throw out the pInner pointer.
        IInspectable* pInner;
        CheckHRESULT(pAppFactory->CreateInstance(pMyApp.Get(), &pInner, &pApp), L"CreateInstance");
    }

    // Set the inherited Application object
    ComPtr<IApplicationOverrides> pBaseImpl;
    CheckHRESULT(pApp.As(&pBaseImpl), L"IApplicationOverrides");
    pMyApp->SetBase(pBaseImpl.Get());

    return S_OK;
}

//---------------------------------------------------------------------------
// Application entrypoint
//---------------------------------------------------------------------------

/*
// This is what this function looks like under C++/CX:

int main()
{
    Application::Start(ref new ApplicationInitializationCallback(InitApplication));
    return 0;
}
*/

int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow)
{
    // Initialize WinRT
    RoInitializeWrapper init(RO_INIT_MULTITHREADED);
    CheckHRESULT(init, L"RoInitialize");

    ComPtr<IApplicationStatics> pAppStatics;
    HStringReference ApplicationClsName(RuntimeClass_Windows_UI_Xaml_Application);
    CheckHRESULT(GetActivationFactory(ApplicationClsName.Get(), &pAppStatics), L"IApplicationStatics");

    // Application::Start(AppMain)
    ComPtr<IApplicationInitializationCallback> pCallback = Callback<IApplicationInitializationCallback>(InitApplication);
    pAppStatics->Start(pCallback.Get());

    return 0;
}