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 <windows.h>
7 
8 #include "nsMathUtils.h"
9 
10 #include "gfxWindowsNativeDrawing.h"
11 #include "gfxWindowsSurface.h"
12 #include "gfxAlphaRecovery.h"
13 #include "gfxPattern.h"
14 #include "mozilla/gfx/2D.h"
15 #include "mozilla/gfx/Helpers.h"
16 #include "gfx2DGlue.h"
17 
18 #include "cairo.h"
19 #include "cairo-win32.h"
20 
21 using namespace mozilla;
22 using namespace mozilla::gfx;
23 
24 enum {
25   RENDER_STATE_INIT,
26 
27   RENDER_STATE_NATIVE_DRAWING,
28   RENDER_STATE_NATIVE_DRAWING_DONE,
29 
30   RENDER_STATE_ALPHA_RECOVERY_BLACK,
31   RENDER_STATE_ALPHA_RECOVERY_BLACK_DONE,
32   RENDER_STATE_ALPHA_RECOVERY_WHITE,
33   RENDER_STATE_ALPHA_RECOVERY_WHITE_DONE,
34 
35   RENDER_STATE_DONE
36 };
37 
gfxWindowsNativeDrawing(gfxContext * ctx,const gfxRect & nativeRect,uint32_t nativeDrawFlags)38 gfxWindowsNativeDrawing::gfxWindowsNativeDrawing(gfxContext* ctx,
39                                                  const gfxRect& nativeRect,
40                                                  uint32_t nativeDrawFlags)
41     : mContext(ctx),
42       mNativeRect(nativeRect),
43       mNativeDrawFlags(nativeDrawFlags),
44       mRenderState(RENDER_STATE_INIT) {}
45 
BeginNativeDrawing()46 HDC gfxWindowsNativeDrawing::BeginNativeDrawing() {
47   if (mRenderState == RENDER_STATE_INIT) {
48     RefPtr<gfxASurface> surf;
49     DrawTarget* drawTarget = mContext->GetDrawTarget();
50     cairo_t* cairo = nullptr;
51     if (drawTarget->GetBackendType() == BackendType::CAIRO) {
52       cairo = static_cast<cairo_t*>(
53           drawTarget->GetNativeSurface(NativeSurfaceType::CAIRO_CONTEXT));
54       if (cairo) {
55         cairo_surface_t* s = cairo_get_group_target(cairo);
56         if (s) {
57           mDeviceOffset = mContext->GetDeviceOffset();
58           double sdx, sdy;
59           cairo_surface_get_device_offset(s, &sdx, &sdy);
60           mDeviceOffset.x -= sdx;
61           mDeviceOffset.y -= sdy;
62           surf = gfxASurface::Wrap(s);
63         }
64       }
65     }
66 
67     if (surf && surf->CairoStatus() != 0) return nullptr;
68 
69     gfxMatrix m = mContext->CurrentMatrixDouble();
70     if (!m.HasNonTranslation())
71       mTransformType = TRANSLATION_ONLY;
72     else if (m.HasNonAxisAlignedTransform())
73       mTransformType = COMPLEX;
74     else
75       mTransformType = AXIS_ALIGNED_SCALE;
76 
77     // if this is a native win32 surface, we don't have to
78     // redirect rendering to our own HDC; in some cases,
79     // we may be able to use the HDC from the surface directly.
80     if (surf && ((surf->GetType() == gfxSurfaceType::Win32 ||
81                   surf->GetType() == gfxSurfaceType::Win32Printing) &&
82                  (surf->GetContentType() == gfxContentType::COLOR ||
83                   (surf->GetContentType() == gfxContentType::COLOR_ALPHA &&
84                    (mNativeDrawFlags & CAN_DRAW_TO_COLOR_ALPHA))))) {
85       // grab the DC. This can fail if there is a complex clipping path,
86       // in which case we'll have to fall back.
87       mWinSurface = static_cast<gfxWindowsSurface*>(
88           static_cast<gfxASurface*>(surf.get()));
89       mDC = cairo_win32_get_dc_with_clip(cairo);
90 
91       if (mDC) {
92         if (mTransformType == TRANSLATION_ONLY) {
93           mRenderState = RENDER_STATE_NATIVE_DRAWING;
94 
95           mTranslation = m.GetTranslation();
96         } else if (((mTransformType == AXIS_ALIGNED_SCALE) &&
97                     (mNativeDrawFlags & CAN_AXIS_ALIGNED_SCALE)) ||
98                    (mNativeDrawFlags & CAN_COMPLEX_TRANSFORM)) {
99           mWorldTransform.eM11 = (FLOAT)m._11;
100           mWorldTransform.eM12 = (FLOAT)m._12;
101           mWorldTransform.eM21 = (FLOAT)m._21;
102           mWorldTransform.eM22 = (FLOAT)m._22;
103           mWorldTransform.eDx = (FLOAT)m._31;
104           mWorldTransform.eDy = (FLOAT)m._32;
105 
106           mRenderState = RENDER_STATE_NATIVE_DRAWING;
107         }
108       }
109     }
110 
111     // If we couldn't do native drawing, then we have to do two-buffer drawing
112     // and do alpha recovery
113     if (mRenderState == RENDER_STATE_INIT) {
114       mRenderState = RENDER_STATE_ALPHA_RECOVERY_BLACK;
115 
116       // We round out our native rect here, that way the snapping will
117       // happen correctly.
118       mNativeRect.RoundOut();
119 
120       // we only do the scale bit if we can do an axis aligned
121       // scale; otherwise we scale (if necessary) after
122       // rendering with cairo.  Note that if we're doing alpha recovery,
123       // we cannot do a full complex transform with win32 (I mean, we could, but
124       // it would require more code that's not here.)
125       if (mTransformType == TRANSLATION_ONLY ||
126           !(mNativeDrawFlags & CAN_AXIS_ALIGNED_SCALE)) {
127         mScale = gfxSize(1.0, 1.0);
128 
129         // Add 1 to the surface size; it's guaranteed to not be incorrect,
130         // and it fixes bug 382458
131         // There's probably a better fix, but I haven't figured out
132         // the root cause of the problem.
133         mTempSurfaceSize = IntSize((int32_t)ceil(mNativeRect.Width() + 1),
134                                    (int32_t)ceil(mNativeRect.Height() + 1));
135       } else {
136         // figure out the scale factors
137         mScale = m.ScaleFactors(true);
138 
139         mWorldTransform.eM11 = (FLOAT)mScale.width;
140         mWorldTransform.eM12 = 0.0f;
141         mWorldTransform.eM21 = 0.0f;
142         mWorldTransform.eM22 = (FLOAT)mScale.height;
143         mWorldTransform.eDx = 0.0f;
144         mWorldTransform.eDy = 0.0f;
145 
146         // See comment above about "+1"
147         mTempSurfaceSize =
148             IntSize((int32_t)ceil(mNativeRect.Width() * mScale.width + 1),
149                     (int32_t)ceil(mNativeRect.Height() * mScale.height + 1));
150       }
151     }
152   }
153 
154   if (mRenderState == RENDER_STATE_NATIVE_DRAWING) {
155     // we can just do native drawing directly to the context's surface
156 
157     // do we need to use SetWorldTransform?
158     if (mTransformType != TRANSLATION_ONLY) {
159       SetGraphicsMode(mDC, GM_ADVANCED);
160       GetWorldTransform(mDC, &mOldWorldTransform);
161       SetWorldTransform(mDC, &mWorldTransform);
162     }
163     GetViewportOrgEx(mDC, &mOrigViewportOrigin);
164     SetViewportOrgEx(mDC, mOrigViewportOrigin.x - (int)mDeviceOffset.x,
165                      mOrigViewportOrigin.y - (int)mDeviceOffset.y, nullptr);
166 
167     return mDC;
168   } else if (mRenderState == RENDER_STATE_ALPHA_RECOVERY_BLACK ||
169              mRenderState == RENDER_STATE_ALPHA_RECOVERY_WHITE) {
170     // we're going to use mWinSurface to create our temporary surface here
171 
172     // get us a RGB24 DIB; DIB is important, because
173     // we can later call GetImageSurface on it.
174     mWinSurface = new gfxWindowsSurface(mTempSurfaceSize);
175     mDC = mWinSurface->GetDC();
176 
177     RECT r = {0, 0, mTempSurfaceSize.width, mTempSurfaceSize.height};
178     if (mRenderState == RENDER_STATE_ALPHA_RECOVERY_BLACK)
179       FillRect(mDC, &r, (HBRUSH)GetStockObject(BLACK_BRUSH));
180     else
181       FillRect(mDC, &r, (HBRUSH)GetStockObject(WHITE_BRUSH));
182 
183     if ((mTransformType != TRANSLATION_ONLY) &&
184         (mNativeDrawFlags & CAN_AXIS_ALIGNED_SCALE)) {
185       SetGraphicsMode(mDC, GM_ADVANCED);
186       SetWorldTransform(mDC, &mWorldTransform);
187     }
188 
189     return mDC;
190   } else {
191     NS_ERROR("Bogus render state!");
192     return nullptr;
193   }
194 }
195 
ShouldRenderAgain()196 bool gfxWindowsNativeDrawing::ShouldRenderAgain() {
197   switch (mRenderState) {
198     case RENDER_STATE_NATIVE_DRAWING_DONE:
199       return false;
200 
201     case RENDER_STATE_ALPHA_RECOVERY_BLACK_DONE:
202       mRenderState = RENDER_STATE_ALPHA_RECOVERY_WHITE;
203       return true;
204 
205     case RENDER_STATE_ALPHA_RECOVERY_WHITE_DONE:
206       return false;
207 
208     default:
209       NS_ERROR(
210           "Invalid RenderState in gfxWindowsNativeDrawing::ShouldRenderAgain");
211       break;
212   }
213 
214   return false;
215 }
216 
EndNativeDrawing()217 void gfxWindowsNativeDrawing::EndNativeDrawing() {
218   if (mRenderState == RENDER_STATE_NATIVE_DRAWING) {
219     // we drew directly to the HDC in the context; undo our changes
220     SetViewportOrgEx(mDC, mOrigViewportOrigin.x, mOrigViewportOrigin.y,
221                      nullptr);
222 
223     if (mTransformType != TRANSLATION_ONLY)
224       SetWorldTransform(mDC, &mOldWorldTransform);
225 
226     mWinSurface->MarkDirty();
227 
228     mRenderState = RENDER_STATE_NATIVE_DRAWING_DONE;
229   } else if (mRenderState == RENDER_STATE_ALPHA_RECOVERY_BLACK) {
230     mBlackSurface = mWinSurface;
231     mWinSurface = nullptr;
232 
233     mRenderState = RENDER_STATE_ALPHA_RECOVERY_BLACK_DONE;
234   } else if (mRenderState == RENDER_STATE_ALPHA_RECOVERY_WHITE) {
235     mWhiteSurface = mWinSurface;
236     mWinSurface = nullptr;
237 
238     mRenderState = RENDER_STATE_ALPHA_RECOVERY_WHITE_DONE;
239   } else {
240     NS_ERROR(
241         "Invalid RenderState in gfxWindowsNativeDrawing::EndNativeDrawing");
242   }
243 }
244 
PaintToContext()245 void gfxWindowsNativeDrawing::PaintToContext() {
246   if (mRenderState == RENDER_STATE_NATIVE_DRAWING_DONE) {
247     // nothing to do, it already went to the context
248     mRenderState = RENDER_STATE_DONE;
249   } else if (mRenderState == RENDER_STATE_ALPHA_RECOVERY_WHITE_DONE) {
250     RefPtr<gfxImageSurface> black = mBlackSurface->GetAsImageSurface();
251     RefPtr<gfxImageSurface> white = mWhiteSurface->GetAsImageSurface();
252     if (!gfxAlphaRecovery::RecoverAlpha(black, white)) {
253       NS_ERROR("Alpha recovery failure");
254       return;
255     }
256     RefPtr<DataSourceSurface> source = Factory::CreateWrappingDataSourceSurface(
257         black->Data(), black->Stride(), black->GetSize(),
258         SurfaceFormat::B8G8R8A8);
259     {
260       DrawTarget* dt = mContext->GetDrawTarget();
261       AutoRestoreTransform autoRestoreTransform(dt);
262 
263       Matrix newTransform = dt->GetTransform();
264       newTransform.PreTranslate(ToPoint(mNativeRect.TopLeft()));
265       dt->SetTransform(newTransform);
266 
267       Rect rect(Point(0.0, 0.0), ToSize(mNativeRect.Size()));
268       Matrix m = Matrix::Scaling(1.0 / mScale.width, 1.0 / mScale.height);
269       SamplingFilter filter = (mNativeDrawFlags & DO_NEAREST_NEIGHBOR_FILTERING)
270                                   ? SamplingFilter::LINEAR
271                                   : SamplingFilter::GOOD;
272       SurfacePattern pat(source, ExtendMode::CLAMP, m, filter);
273       dt->FillRect(rect, pat);
274     }
275 
276     mRenderState = RENDER_STATE_DONE;
277   } else {
278     NS_ERROR("Invalid RenderState in gfxWindowsNativeDrawing::PaintToContext");
279   }
280 }
281 
TransformToNativeRect(const gfxRect & r,RECT & rout)282 void gfxWindowsNativeDrawing::TransformToNativeRect(const gfxRect& r,
283                                                     RECT& rout) {
284   /* If we're doing native drawing, then we're still in the coordinate space
285    * of the context; otherwise, we're in our own little world,
286    * relative to the passed-in nativeRect.
287    */
288 
289   gfxRect roundedRect(r);
290 
291   if (mRenderState == RENDER_STATE_NATIVE_DRAWING) {
292     if (mTransformType == TRANSLATION_ONLY) {
293       roundedRect.MoveBy(mTranslation);
294     }
295   } else {
296     roundedRect.MoveBy(-mNativeRect.TopLeft());
297   }
298 
299   roundedRect.Round();
300 
301   rout.left = LONG(roundedRect.X());
302   rout.right = LONG(roundedRect.XMost());
303   rout.top = LONG(roundedRect.Y());
304   rout.bottom = LONG(roundedRect.YMost());
305 }
306