DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (b75acf965293)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef GFX_DWRITECOMMON_H
#define GFX_DWRITECOMMON_H

// Mozilla includes
#include "mozilla/MemoryReporting.h"
#include "mozilla/FontPropertyTypes.h"
#include "nscore.h"
#include "nsIServiceManager.h"
#include "nsCOMPtr.h"
#include "cairo-features.h"
#include "gfxFontConstants.h"
#include "nsTArray.h"
#include "gfxWindowsPlatform.h"
#include "nsIUUIDGenerator.h"

#include <windows.h>
#include <dwrite.h>

static inline DWRITE_FONT_STRETCH
DWriteFontStretchFromStretch(mozilla::FontStretch aStretch)
{
    if (aStretch == mozilla::FontStretch::UltraCondensed()) {
        return DWRITE_FONT_STRETCH_ULTRA_CONDENSED;
    }
    if (aStretch == mozilla::FontStretch::ExtraCondensed()) {
        return DWRITE_FONT_STRETCH_EXTRA_CONDENSED;
    }
    if (aStretch == mozilla::FontStretch::Condensed()) {
        return DWRITE_FONT_STRETCH_CONDENSED;
    }
    if (aStretch == mozilla::FontStretch::SemiCondensed()) {
        return DWRITE_FONT_STRETCH_SEMI_CONDENSED;
    }
    if (aStretch == mozilla::FontStretch::Normal()) {
        return DWRITE_FONT_STRETCH_NORMAL;
    }
    if (aStretch == mozilla::FontStretch::SemiExpanded()) {
        return DWRITE_FONT_STRETCH_SEMI_EXPANDED;
    }
    if (aStretch == mozilla::FontStretch::Expanded()) {
        return DWRITE_FONT_STRETCH_EXPANDED;
    }
    if (aStretch == mozilla::FontStretch::ExtraExpanded()) {
        return DWRITE_FONT_STRETCH_EXTRA_EXPANDED;
    }
    if (aStretch == mozilla::FontStretch::UltraExpanded()) {
        return DWRITE_FONT_STRETCH_ULTRA_EXPANDED;
    }
    return DWRITE_FONT_STRETCH_UNDEFINED;
}

static inline mozilla::FontStretch
FontStretchFromDWriteStretch(DWRITE_FONT_STRETCH aStretch)
{
    switch (aStretch) {
        case DWRITE_FONT_STRETCH_ULTRA_CONDENSED:
            return mozilla::FontStretch::UltraCondensed();
        case DWRITE_FONT_STRETCH_EXTRA_CONDENSED:
            return mozilla::FontStretch::ExtraCondensed();
        case DWRITE_FONT_STRETCH_CONDENSED:
            return mozilla::FontStretch::Condensed();
        case DWRITE_FONT_STRETCH_SEMI_CONDENSED:
            return mozilla::FontStretch::SemiCondensed();
        case DWRITE_FONT_STRETCH_NORMAL:
            return mozilla::FontStretch::Normal();
        case DWRITE_FONT_STRETCH_SEMI_EXPANDED:
            return mozilla::FontStretch::SemiExpanded();
        case DWRITE_FONT_STRETCH_EXPANDED:
            return mozilla::FontStretch::Expanded();
        case DWRITE_FONT_STRETCH_EXTRA_EXPANDED:
            return mozilla::FontStretch::ExtraExpanded();
        case DWRITE_FONT_STRETCH_ULTRA_EXPANDED:
            return mozilla::FontStretch::UltraExpanded();
        default:
            return mozilla::FontStretch::Normal();
    }
}

class gfxDWriteFontFileLoader : public IDWriteFontFileLoader
{
public:
    gfxDWriteFontFileLoader()
    {
    }

    // IUnknown interface
    IFACEMETHOD(QueryInterface)(IID const& iid, OUT void** ppObject)
    {
        if (iid == __uuidof(IDWriteFontFileLoader)) {
            *ppObject = static_cast<IDWriteFontFileLoader*>(this);
            return S_OK;
        } else if (iid == __uuidof(IUnknown)) {
            *ppObject = static_cast<IUnknown*>(this);
            return S_OK;
        } else {
            return E_NOINTERFACE;
        }
    }

    IFACEMETHOD_(ULONG, AddRef)()
    {
        return 1;
    }

    IFACEMETHOD_(ULONG, Release)()
    {
        return 1;
    }

    // IDWriteFontFileLoader methods
    /**
     * Important! Note the key here -has- to be a pointer to a uint64_t.
     */
    virtual HRESULT STDMETHODCALLTYPE 
        CreateStreamFromKey(void const* fontFileReferenceKey,
                            UINT32 fontFileReferenceKeySize,
                            OUT IDWriteFontFileStream** fontFileStream);

    /**
     * Gets the singleton loader instance. Note that when using this font
     * loader, the key must be a pointer to a unint64_t.
     */
    static IDWriteFontFileLoader* Instance()
    {
        if (!mInstance) {
            mInstance = new gfxDWriteFontFileLoader();
            mozilla::gfx::Factory::GetDWriteFactory()->
                RegisterFontFileLoader(mInstance);
        }
        return mInstance;
    }

    /**
     * Creates a IDWriteFontFile and IDWriteFontFileStream from aFontData.
     * The data from aFontData will be copied internally, so the caller
     * is free to dispose of it once this method returns.
     *
     * @param aFontData the font data for the custom font file
     * @param aLength length of the font data
     * @param aFontFile out param for the created font file
     * @param aFontFileStream out param for the corresponding stream
     * @return HRESULT of internal calls
     */
    static HRESULT CreateCustomFontFile(const uint8_t* aFontData,
                                        uint32_t aLength,
                                        IDWriteFontFile** aFontFile,
                                        IDWriteFontFileStream** aFontFileStream);

    size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;

private:
    static IDWriteFontFileLoader* mInstance;
}; 

#endif /* GFX_DWRITECOMMON_H */