The Tor Browser / file comparison

comparison: gfx/thebes/gfxWindowsSurface.cpp

gfx/thebes/gfxWindowsSurface.cpp

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:8ffa0e7b1ea6
1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2 * This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include "gfxWindowsSurface.h"
7 #include "gfxContext.h"
8 #include "gfxPlatform.h"
9
10 #include "cairo.h"
11 #include "cairo-win32.h"
12
13 #include "nsString.h"
14
15 gfxWindowsSurface::gfxWindowsSurface(HWND wnd, uint32_t flags) :
16 mOwnsDC(true), mForPrinting(false), mWnd(wnd)
17 {
18 mDC = ::GetDC(mWnd);
19 InitWithDC(flags);
20 }
21
22 gfxWindowsSurface::gfxWindowsSurface(HDC dc, uint32_t flags) :
23 mOwnsDC(false), mForPrinting(false), mDC(dc), mWnd(nullptr)
24 {
25 if (flags & FLAG_TAKE_DC)
26 mOwnsDC = true;
27
28 #ifdef NS_PRINTING
29 if (flags & FLAG_FOR_PRINTING) {
30 Init(cairo_win32_printing_surface_create(mDC));
31 mForPrinting = true;
32 } else
33 #endif
34 InitWithDC(flags);
35 }
36
37 gfxWindowsSurface::gfxWindowsSurface(IDirect3DSurface9 *surface, uint32_t flags) :
38 mOwnsDC(false), mForPrinting(false), mDC(0), mWnd(nullptr)
39 {
40 cairo_surface_t *surf = cairo_win32_surface_create_with_d3dsurface9(surface);
41 Init(surf);
42 }
43
44
45 void
46 gfxWindowsSurface::MakeInvalid(gfxIntSize& size)
47 {
48 size = gfxIntSize(-1, -1);
49 }
50
51 gfxWindowsSurface::gfxWindowsSurface(const gfxIntSize& realSize, gfxImageFormat imageFormat) :
52 mOwnsDC(false), mForPrinting(false), mWnd(nullptr)
53 {
54 gfxIntSize size(realSize);
55 if (!CheckSurfaceSize(size))
56 MakeInvalid(size);
57
58 cairo_surface_t *surf = cairo_win32_surface_create_with_dib((cairo_format_t)(int)imageFormat,
59 size.width, size.height);
60
61 Init(surf);
62
63 if (CairoStatus() == CAIRO_STATUS_SUCCESS) {
64 mDC = cairo_win32_surface_get_dc(CairoSurface());
65 RecordMemoryUsed(size.width * size.height * 4 + sizeof(gfxWindowsSurface));
66 } else {
67 mDC = nullptr;
68 }
69 }
70
71 gfxWindowsSurface::gfxWindowsSurface(HDC dc, const gfxIntSize& realSize, gfxImageFormat imageFormat) :
72 mOwnsDC(false), mForPrinting(false), mWnd(nullptr)
73 {
74 gfxIntSize size(realSize);
75 if (!CheckSurfaceSize(size))
76 MakeInvalid(size);
77
78 cairo_surface_t *surf = cairo_win32_surface_create_with_ddb(dc, (cairo_format_t)(int)imageFormat,
79 size.width, size.height);
80
81 Init(surf);
82
83 if (mSurfaceValid) {
84 // DDBs will generally only use 3 bytes per pixel when RGB24
85 int bytesPerPixel = ((imageFormat == gfxImageFormat::RGB24) ? 3 : 4);
86 RecordMemoryUsed(size.width * size.height * bytesPerPixel + sizeof(gfxWindowsSurface));
87 }
88
89 if (CairoStatus() == 0)
90 mDC = cairo_win32_surface_get_dc(CairoSurface());
91 else
92 mDC = nullptr;
93 }
94
95 gfxWindowsSurface::gfxWindowsSurface(cairo_surface_t *csurf) :
96 mOwnsDC(false), mForPrinting(false), mWnd(nullptr)
97 {
98 if (cairo_surface_status(csurf) == 0)
99 mDC = cairo_win32_surface_get_dc(csurf);
100 else
101 mDC = nullptr;
102
103 if (cairo_surface_get_type(csurf) == CAIRO_SURFACE_TYPE_WIN32_PRINTING)
104 mForPrinting = true;
105
106 Init(csurf, true);
107 }
108
109 void
110 gfxWindowsSurface::InitWithDC(uint32_t flags)
111 {
112 if (flags & FLAG_IS_TRANSPARENT) {
113 Init(cairo_win32_surface_create_with_alpha(mDC));
114 } else {
115 Init(cairo_win32_surface_create(mDC));
116 }
117 }
118
119 already_AddRefed<gfxASurface>
120 gfxWindowsSurface::CreateSimilarSurface(gfxContentType aContent,
121 const gfxIntSize& aSize)
122 {
123 if (!mSurface || !mSurfaceValid) {
124 return nullptr;
125 }
126
127 cairo_surface_t *surface;
128 if (!mForPrinting && GetContentType() == gfxContentType::COLOR_ALPHA) {
129 // When creating a similar surface to a transparent surface, ensure
130 // the new surface uses a DIB. cairo_surface_create_similar won't
131 // use a DIB for a gfxContentType::COLOR surface if this surface doesn't
132 // have a DIB (e.g. if we're a transparent window surface). But
133 // we need a DIB to perform well if the new surface is composited into
134 // a surface that's the result of create_similar(gfxContentType::COLOR_ALPHA)
135 // (e.g. a backbuffer for the window) --- that new surface *would*
136 // have a DIB.
137 surface =
138 cairo_win32_surface_create_with_dib((cairo_format_t)(int)gfxPlatform::GetPlatform()->OptimalFormatForContent(aContent),
139 aSize.width, aSize.height);
140 } else {
141 surface =
142 cairo_surface_create_similar(mSurface, (cairo_content_t)(int)aContent,
143 aSize.width, aSize.height);
144 }
145
146 if (cairo_surface_status(surface)) {
147 cairo_surface_destroy(surface);
148 return nullptr;
149 }
150
151 nsRefPtr<gfxASurface> result = Wrap(surface, aSize);
152 cairo_surface_destroy(surface);
153 return result.forget();
154 }
155
156 gfxWindowsSurface::~gfxWindowsSurface()
157 {
158 if (mOwnsDC) {
159 if (mWnd)
160 ::ReleaseDC(mWnd, mDC);
161 else
162 ::DeleteDC(mDC);
163 }
164 }
165
166 HDC
167 gfxWindowsSurface::GetDCWithClip(gfxContext *ctx)
168 {
169 return cairo_win32_get_dc_with_clip (ctx->GetCairo());
170 }
171
172 HDC
173 gfxWindowsSurface::GetDC()
174 {
175 return cairo_win32_surface_get_dc (CairoSurface());
176 }
177
178
179 already_AddRefed<gfxImageSurface>
180 gfxWindowsSurface::GetAsImageSurface()
181 {
182 if (!mSurfaceValid) {
183 NS_WARNING ("GetImageSurface on an invalid (null) surface; who's calling this without checking for surface errors?");
184 return nullptr;
185 }
186
187 NS_ASSERTION(CairoSurface() != nullptr, "CairoSurface() shouldn't be nullptr when mSurfaceValid is TRUE!");
188
189 if (mForPrinting)
190 return nullptr;
191
192 cairo_surface_t *isurf = cairo_win32_surface_get_image(CairoSurface());
193 if (!isurf)
194 return nullptr;
195
196 nsRefPtr<gfxImageSurface> result = gfxASurface::Wrap(isurf).downcast<gfxImageSurface>();
197 result->SetOpaqueRect(GetOpaqueRect());
198
199 return result.forget();
200 }
201
202 nsresult
203 gfxWindowsSurface::BeginPrinting(const nsAString& aTitle,
204 const nsAString& aPrintToFileName)
205 {
206 #ifdef NS_PRINTING
207 #define DOC_TITLE_LENGTH (MAX_PATH-1)
208 DOCINFOW docinfo;
209
210 nsString titleStr(aTitle);
211 if (titleStr.Length() > DOC_TITLE_LENGTH) {
212 titleStr.SetLength(DOC_TITLE_LENGTH-3);
213 titleStr.AppendLiteral("...");
214 }
215
216 nsString docName(aPrintToFileName);
217 docinfo.cbSize = sizeof(docinfo);
218 docinfo.lpszDocName = titleStr.Length() > 0 ? titleStr.get() : L"Mozilla Document";
219 docinfo.lpszOutput = docName.Length() > 0 ? docName.get() : nullptr;
220 docinfo.lpszDatatype = nullptr;
221 docinfo.fwType = 0;
222
223 ::StartDocW(mDC, &docinfo);
224
225 return NS_OK;
226 #else
227 return NS_ERROR_FAILURE;
228 #endif
229 }
230
231 nsresult
232 gfxWindowsSurface::EndPrinting()
233 {
234 #ifdef NS_PRINTING
235 int result = ::EndDoc(mDC);
236 if (result <= 0)
237 return NS_ERROR_FAILURE;
238
239 return NS_OK;
240 #else
241 return NS_ERROR_FAILURE;
242 #endif
243 }
244
245 nsresult
246 gfxWindowsSurface::AbortPrinting()
247 {
248 #ifdef NS_PRINTING
249 int result = ::AbortDoc(mDC);
250 if (result <= 0)
251 return NS_ERROR_FAILURE;
252 return NS_OK;
253 #else
254 return NS_ERROR_FAILURE;
255 #endif
256 }
257
258 nsresult
259 gfxWindowsSurface::BeginPage()
260 {
261 #ifdef NS_PRINTING
262 int result = ::StartPage(mDC);
263 if (result <= 0)
264 return NS_ERROR_FAILURE;
265 return NS_OK;
266 #else
267 return NS_ERROR_FAILURE;
268 #endif
269 }
270
271 nsresult
272 gfxWindowsSurface::EndPage()
273 {
274 #ifdef NS_PRINTING
275 if (mForPrinting)
276 cairo_surface_show_page(CairoSurface());
277 int result = ::EndPage(mDC);
278 if (result <= 0)
279 return NS_ERROR_FAILURE;
280 return NS_OK;
281 #else
282 return NS_ERROR_FAILURE;
283 #endif
284 }
285
286 int32_t
287 gfxWindowsSurface::GetDefaultContextFlags() const
288 {
289 if (mForPrinting)
290 return gfxContext::FLAG_SIMPLIFY_OPERATORS |
291 gfxContext::FLAG_DISABLE_SNAPPING |
292 gfxContext::FLAG_DISABLE_COPY_BACKGROUND;
293
294 return 0;
295 }
296
297 const gfxIntSize
298 gfxWindowsSurface::GetSize() const
299 {
300 if (!mSurfaceValid) {
301 NS_WARNING ("GetImageSurface on an invalid (null) surface; who's calling this without checking for surface errors?");
302 return gfxIntSize(-1, -1);
303 }
304
305 NS_ASSERTION(mSurface != nullptr, "CairoSurface() shouldn't be nullptr when mSurfaceValid is TRUE!");
306
307 return gfxIntSize(cairo_win32_surface_get_width(mSurface),
308 cairo_win32_surface_get_height(mSurface));
309 }
310
311 gfxMemoryLocation
312 gfxWindowsSurface::GetMemoryLocation() const
313 {
314 return gfxMemoryLocation::IN_PROCESS_NONHEAP;
315 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial