mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
c3970a73fb
Backed out changeset 85486c4aa3d8 (bug 936964) Backed out changeset 25312eb71998 (bug 936964) Backed out changeset 6dbb8333960c (bug 936964) Backed out changeset da6465ad476f (bug 936964) Backed out changeset a87ffc992f38 (bug 936964) Backed out changeset 4ae3a61182db (bug 936964) Backed out changeset 34e9c3137804 (bug 936964) Backed out changeset fd1459e71585 (bug 936964) Backed out changeset 3e8a701d8bdc (bug 943660) Landed on a CLOSED TREE --HG-- rename : content/canvas/src/WebGLMemoryTracker.h => content/canvas/src/WebGLMemoryReporterWrapper.h
309 lines
10 KiB
C++
309 lines
10 KiB
C++
/* -*- 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 <windows.h>
|
|
#include <objbase.h>
|
|
|
|
#ifdef CAIRO_HAS_D2D_SURFACE
|
|
#include <dxgi.h>
|
|
#endif
|
|
|
|
// This header is available in the June 2010 SDK and in the Win8 SDK
|
|
#include <d3dcommon.h>
|
|
// 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<D3D_FEATURE_LEVEL>(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<gfxASurface> aSurface = aContext->CurrentSurface();
|
|
NS_ASSERTION(aSurface || !aContext->IsCairo(), "DCFromContext: null surface");
|
|
if (aSurface &&
|
|
(aSurface->GetType() == gfxSurfaceTypeWin32 ||
|
|
aSurface->GetType() == gfxSurfaceTypeWin32Printing))
|
|
{
|
|
dc = static_cast<gfxWindowsSurface*>(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();
|
|
|
|
already_AddRefed<gfxASurface> CreateOffscreenSurface(const gfxIntSize& size,
|
|
gfxContentType contentType);
|
|
virtual already_AddRefed<gfxASurface>
|
|
CreateOffscreenImageSurface(const gfxIntSize& aSize,
|
|
gfxContentType aContentType);
|
|
|
|
virtual mozilla::TemporaryRef<mozilla::gfx::ScaledFont>
|
|
GetScaledFontForFont(mozilla::gfx::DrawTarget* aTarget, gfxFont *aFont);
|
|
virtual already_AddRefed<gfxASurface>
|
|
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
|
|
};
|
|
|
|
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<IDXGIAdapter1> &adapter1, int featureLevelIndex);
|
|
#endif
|
|
|
|
HDC GetScreenDC() { return mScreenDC; }
|
|
|
|
/**
|
|
* 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() {
|
|
return GetDeviceCaps(mScreenDC, LOGPIXELSY) / 96.0;
|
|
}
|
|
|
|
nsresult GetFontList(nsIAtom *aLangGroup,
|
|
const nsACString& aGenericFamily,
|
|
nsTArray<nsString>& aListOfFonts);
|
|
|
|
nsresult UpdateFontList();
|
|
|
|
virtual void GetCommonFallbackFonts(const uint32_t aCh,
|
|
int32_t aRunScript,
|
|
nsTArray<const char*>& 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<nsRefPtr<gfxFontEntry> > *array);
|
|
void SetPrefFontEntries(const nsCString& aLangGroup, nsTArray<nsRefPtr<gfxFontEntry> >& 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(const PRUnichar *aDLLPath, nsAString& aVersion);
|
|
|
|
// returns ClearType tuning information for each display
|
|
static void GetCleartypeParams(nsTArray<ClearTypeParameterInfo>& 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;
|
|
HDC mScreenDC;
|
|
|
|
private:
|
|
void Init();
|
|
IDXGIAdapter1 *GetDXGIAdapter();
|
|
|
|
bool mUseDirectWrite;
|
|
bool mUsingGDIFonts;
|
|
|
|
#ifdef CAIRO_HAS_DWRITE_FONT
|
|
nsRefPtr<IDWriteFactory> mDWriteFactory;
|
|
nsRefPtr<IDWriteTextAnalyzer> mDWriteAnalyzer;
|
|
nsRefPtr<IDWriteRenderingParams> mRenderingParams[TEXT_RENDERING_COUNT];
|
|
DWRITE_MEASURING_MODE mMeasuringMode;
|
|
#endif
|
|
#ifdef CAIRO_HAS_D2D_SURFACE
|
|
cairo_device_t *mD2DDevice;
|
|
#endif
|
|
mozilla::RefPtr<IDXGIAdapter1> mAdapter;
|
|
nsRefPtr<mozilla::layers::DeviceManagerD3D9> mDeviceManager;
|
|
mozilla::RefPtr<ID3D11Device> mD3D11Device;
|
|
bool mD3D11DeviceInitialized;
|
|
|
|
virtual qcms_profile* GetPlatformCMSOutputProfile();
|
|
|
|
// TODO: unify this with mPrefFonts (NB: holds families, not fonts) in gfxPlatformFontList
|
|
nsDataHashtable<nsCStringHashKey, nsTArray<nsRefPtr<gfxFontEntry> > > mPrefFonts;
|
|
|
|
nsIMemoryReporter* mGPUAdapterReporter;
|
|
};
|
|
|
|
#endif /* GFX_WINDOWS_PLATFORM_H */
|