diff -r 000000000000 -r 6474c204b198 gfx/thebes/gfxWindowsPlatform.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gfx/thebes/gfxWindowsPlatform.h Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,304 @@ +/* -*- 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_WINDOWS_PLATFORM_H +#define GFX_WINDOWS_PLATFORM_H + + +/** + * XXX to get CAIRO_HAS_D2D_SURFACE, CAIRO_HAS_DWRITE_FONT + * and cairo_win32_scaled_font_select_font + */ +#include "cairo-win32.h" + +#include "gfxFontUtils.h" +#include "gfxWindowsSurface.h" +#include "gfxFont.h" +#ifdef CAIRO_HAS_DWRITE_FONT +#include "gfxDWriteFonts.h" +#endif +#include "gfxPlatform.h" +#include "gfxContext.h" + +#include "nsTArray.h" +#include "nsDataHashtable.h" + +#include "mozilla/RefPtr.h" + +#include +#include + +#ifdef CAIRO_HAS_D2D_SURFACE +#include +#endif + +// This header is available in the June 2010 SDK and in the Win8 SDK +#include +// Win 8.0 SDK types we'll need when building using older sdks. +#if !defined(D3D_FEATURE_LEVEL_11_1) // defined in the 8.0 SDK only +#define D3D_FEATURE_LEVEL_11_1 static_cast(0xb100) +#define D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION 2048 +#define D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION 4096 +#endif + +namespace mozilla { +namespace layers { +class DeviceManagerD3D9; +} +} +class IDirect3DDevice9; +class ID3D11Device; +class IDXGIAdapter1; + +class nsIMemoryReporter; + +// Utility to get a Windows HDC from a thebes context, +// used by both GDI and Uniscribe font shapers +struct DCFromContext { + DCFromContext(gfxContext *aContext) { + dc = nullptr; + nsRefPtr aSurface = aContext->CurrentSurface(); + NS_ASSERTION(aSurface || !aContext->IsCairo(), "DCFromContext: null surface"); + if (aSurface && + (aSurface->GetType() == gfxSurfaceType::Win32 || + aSurface->GetType() == gfxSurfaceType::Win32Printing)) + { + dc = static_cast(aSurface.get())->GetDC(); + needsRelease = false; + SaveDC(dc); + cairo_scaled_font_t* scaled = + cairo_get_scaled_font(aContext->GetCairo()); + cairo_win32_scaled_font_select_font(scaled, dc); + } + if (!dc) { + dc = GetDC(nullptr); + SetGraphicsMode(dc, GM_ADVANCED); + needsRelease = true; + } + } + + ~DCFromContext() { + if (needsRelease) { + ReleaseDC(nullptr, dc); + } else { + RestoreDC(dc, -1); + } + } + + operator HDC () { + return dc; + } + + HDC dc; + bool needsRelease; +}; + +// ClearType parameters set by running ClearType tuner +struct ClearTypeParameterInfo { + ClearTypeParameterInfo() : + gamma(-1), pixelStructure(-1), clearTypeLevel(-1), enhancedContrast(-1) + { } + + nsString displayName; // typically just 'DISPLAY1' + int32_t gamma; + int32_t pixelStructure; + int32_t clearTypeLevel; + int32_t enhancedContrast; +}; + +class gfxWindowsPlatform : public gfxPlatform { +public: + enum TextRenderingMode { + TEXT_RENDERING_NO_CLEARTYPE, + TEXT_RENDERING_NORMAL, + TEXT_RENDERING_GDI_CLASSIC, + TEXT_RENDERING_COUNT + }; + + gfxWindowsPlatform(); + virtual ~gfxWindowsPlatform(); + static gfxWindowsPlatform *GetPlatform() { + return (gfxWindowsPlatform*) gfxPlatform::GetPlatform(); + } + + virtual gfxPlatformFontList* CreatePlatformFontList(); + + virtual already_AddRefed + CreateOffscreenSurface(const IntSize& size, + gfxContentType contentType) MOZ_OVERRIDE; + virtual already_AddRefed + CreateOffscreenImageSurface(const gfxIntSize& aSize, + gfxContentType aContentType); + + virtual mozilla::TemporaryRef + GetScaledFontForFont(mozilla::gfx::DrawTarget* aTarget, gfxFont *aFont); + virtual already_AddRefed + GetThebesSurfaceForDrawTarget(mozilla::gfx::DrawTarget *aTarget); + + enum RenderMode { + /* Use GDI and windows surfaces */ + RENDER_GDI = 0, + + /* Use 32bpp image surfaces and call StretchDIBits */ + RENDER_IMAGE_STRETCH32, + + /* Use 32bpp image surfaces, and do 32->24 conversion before calling StretchDIBits */ + RENDER_IMAGE_STRETCH24, + + /* Use Direct2D rendering */ + RENDER_DIRECT2D, + + /* max */ + RENDER_MODE_MAX + }; + + int GetScreenDepth() const; + + RenderMode GetRenderMode() { return mRenderMode; } + void SetRenderMode(RenderMode rmode) { mRenderMode = rmode; } + + /** + * Updates render mode with relation to the current preferences and + * available devices. + */ + void UpdateRenderMode(); + + /** + * Verifies a D2D device is present and working, will attempt to create one + * it is non-functional or non-existant. + * + * \param aAttemptForce Attempt to force D2D cairo device creation by using + * cairo device creation routines. + */ + void VerifyD2DDevice(bool aAttemptForce); + +#ifdef CAIRO_HAS_D2D_SURFACE + HRESULT CreateDevice(nsRefPtr &adapter1, int featureLevelIndex); +#endif + + /** + * Return the resolution scaling factor to convert between "logical" or + * "screen" pixels as used by Windows (dependent on the DPI scaling option + * in the Display control panel) and actual device pixels. + */ + double GetDPIScale(); + + nsresult GetFontList(nsIAtom *aLangGroup, + const nsACString& aGenericFamily, + nsTArray& aListOfFonts); + + nsresult UpdateFontList(); + + virtual void GetCommonFallbackFonts(const uint32_t aCh, + int32_t aRunScript, + nsTArray& aFontList); + + nsresult ResolveFontName(const nsAString& aFontName, + FontResolverCallback aCallback, + void *aClosure, bool& aAborted); + + nsresult GetStandardFamilyName(const nsAString& aFontName, nsAString& aFamilyName); + + gfxFontGroup *CreateFontGroup(const nsAString &aFamilies, + const gfxFontStyle *aStyle, + gfxUserFontSet *aUserFontSet); + + /** + * Look up a local platform font using the full font face name (needed to support @font-face src local() ) + */ + virtual gfxFontEntry* LookupLocalFont(const gfxProxyFontEntry *aProxyEntry, + const nsAString& aFontName); + + /** + * Activate a platform font (needed to support @font-face src url() ) + */ + virtual gfxFontEntry* MakePlatformFont(const gfxProxyFontEntry *aProxyEntry, + const uint8_t *aFontData, + uint32_t aLength); + + /** + * Check whether format is supported on a platform or not (if unclear, returns true) + */ + virtual bool IsFontFormatSupported(nsIURI *aFontURI, uint32_t aFormatFlags); + + /* Find a FontFamily/FontEntry object that represents a font on your system given a name */ + gfxFontFamily *FindFontFamily(const nsAString& aName); + gfxFontEntry *FindFontEntry(const nsAString& aName, const gfxFontStyle& aFontStyle); + + bool GetPrefFontEntries(const nsCString& aLangGroup, nsTArray > *array); + void SetPrefFontEntries(const nsCString& aLangGroup, nsTArray >& array); + + void ClearPrefFonts() { mPrefFonts.Clear(); } + + // ClearType is not always enabled even when available (e.g. Windows XP) + // if either of these prefs are enabled and apply, use ClearType rendering + bool UseClearTypeForDownloadableFonts(); + bool UseClearTypeAlways(); + + static void GetDLLVersion(char16ptr_t aDLLPath, nsAString& aVersion); + + // returns ClearType tuning information for each display + static void GetCleartypeParams(nsTArray& aParams); + + virtual void FontsPrefsChanged(const char *aPref); + + void SetupClearTypeParams(); + +#ifdef CAIRO_HAS_DWRITE_FONT + IDWriteFactory *GetDWriteFactory() { return mDWriteFactory; } + inline bool DWriteEnabled() { return mUseDirectWrite; } + inline DWRITE_MEASURING_MODE DWriteMeasuringMode() { return mMeasuringMode; } + IDWriteTextAnalyzer *GetDWriteAnalyzer() { return mDWriteAnalyzer; } + + IDWriteRenderingParams *GetRenderingParams(TextRenderingMode aRenderMode) + { return mRenderingParams[aRenderMode]; } +#else + inline bool DWriteEnabled() { return false; } +#endif + void OnDeviceManagerDestroy(mozilla::layers::DeviceManagerD3D9* aDeviceManager); + mozilla::layers::DeviceManagerD3D9* GetD3D9DeviceManager(); + IDirect3DDevice9* GetD3D9Device(); +#ifdef CAIRO_HAS_D2D_SURFACE + cairo_device_t *GetD2DDevice() { return mD2DDevice; } + ID3D10Device1 *GetD3D10Device() { return mD2DDevice ? cairo_d2d_device_get_device(mD2DDevice) : nullptr; } +#endif + ID3D11Device *GetD3D11Device(); + + static bool IsOptimus(); + +protected: + RenderMode mRenderMode; + + int8_t mUseClearTypeForDownloadableFonts; + int8_t mUseClearTypeAlways; + +private: + void Init(); + IDXGIAdapter1 *GetDXGIAdapter(); + + bool mUseDirectWrite; + bool mUsingGDIFonts; + +#ifdef CAIRO_HAS_DWRITE_FONT + nsRefPtr mDWriteFactory; + nsRefPtr mDWriteAnalyzer; + nsRefPtr mRenderingParams[TEXT_RENDERING_COUNT]; + DWRITE_MEASURING_MODE mMeasuringMode; +#endif +#ifdef CAIRO_HAS_D2D_SURFACE + cairo_device_t *mD2DDevice; +#endif + mozilla::RefPtr mAdapter; + nsRefPtr mDeviceManager; + mozilla::RefPtr mD3D11Device; + bool mD3D11DeviceInitialized; + + virtual void GetPlatformCMSOutputProfile(void* &mem, size_t &size); + + // TODO: unify this with mPrefFonts (NB: holds families, not fonts) in gfxPlatformFontList + nsDataHashtable > > mPrefFonts; +}; + +#endif /* GFX_WINDOWS_PLATFORM_H */