gfx/thebes/src/gfxContext.cpp

   1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  * ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is Oracle Corporation code.
  16  *
  17  * The Initial Developer of the Original Code is Oracle Corporation.
  18  * Portions created by the Initial Developer are Copyright (C) 2005
  19  * the Initial Developer. All Rights Reserved.
  20  *
  21  * Contributor(s):
  22  *   Stuart Parmenter <pavlov@pavlov.net>
  23  *   Vladimir Vukicevic <vladimir@pobox.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #ifdef _MSC_VER
  40 #define _USE_MATH_DEFINES
  41 #endif
  42 #include <math.h>
  43
  44 #ifndef M_PI
  45 #define M_PI 3.14159265358979323846
  46 #endif
  47
  48 #include "cairo.h"
  49 #include "lcms.h"
  50
  51 #include "gfxContext.h"
  52
  53 #include "gfxColor.h"
  54 #include "gfxMatrix.h"
  55 #include "gfxASurface.h"
  56 #include "gfxPattern.h"
  57 #include "gfxPlatform.h"
  58
  59
  60 gfxContext::gfxContext(gfxASurface *surface) :
  61     mSurface(surface)
  62 {
  63     mCairo = cairo_create(surface->CairoSurface());
  64     mFlags = surface->GetDefaultContextFlags();
  65 }
  66 gfxContext::~gfxContext()
  67 {
  68     cairo_destroy(mCairo);
  69 }
  70
  71 gfxASurface *
  72 gfxContext::OriginalSurface()
  73 {
  74     return mSurface;
  75 }
  76
  77 already_AddRefed<gfxASurface>
  78 gfxContext::CurrentSurface(gfxFloat *dx, gfxFloat *dy)
  79 {
  80     cairo_surface_t *s = cairo_get_group_target(mCairo);
  81     if (s == mSurface->CairoSurface()) {
  82         if (dx && dy)
  83             cairo_surface_get_device_offset(s, dx, dy);
  84         gfxASurface *ret = mSurface;
  85         NS_ADDREF(ret);
  86         return ret;
  87     }
  88
  89     if (dx && dy)
  90         cairo_surface_get_device_offset(s, dx, dy);
  91     return gfxASurface::Wrap(s);
  92 }
  93
  94 void
  95 gfxContext::Save()
  96 {
  97     cairo_save(mCairo);
  98 }
  99
 100 void
 101 gfxContext::Restore()
 102 {
 103     cairo_restore(mCairo);
 104 }
 105
 106 // drawing
 107 void
 108 gfxContext::NewPath()
 109 {
 110     cairo_new_path(mCairo);
 111 }
 112
 113 void
 114 gfxContext::ClosePath()
 115 {
 116     cairo_close_path(mCairo);
 117 }
 118
 119 already_AddRefed<gfxPath> gfxContext::CopyPath() const
 120 {
 121     nsRefPtr<gfxPath> path = new gfxPath(cairo_copy_path(mCairo));
 122     return path.forget();
 123 }
 124
 125 void gfxContext::AppendPath(gfxPath* path)
 126 {
 127     if (path->mPath->status == CAIRO_STATUS_SUCCESS && path->mPath->num_data != 0)
 128         cairo_append_path(mCairo, path->mPath);
 129 }
 130
 131 gfxPoint
 132 gfxContext::CurrentPoint() const
 133 {
 134     double x, y;
 135     cairo_get_current_point(mCairo, &x, &y);
 136     return gfxPoint(x, y);
 137 }
 138
 139 void
 140 gfxContext::Stroke()
 141 {
 142     cairo_stroke_preserve(mCairo);
 143 }
 144
 145 void
 146 gfxContext::Fill()
 147 {
 148     cairo_fill_preserve(mCairo);
 149 }
 150
 151 void
 152 gfxContext::MoveTo(const gfxPoint& pt)
 153 {
 154     cairo_move_to(mCairo, pt.x, pt.y);
 155 }
 156
 157 void
 158 gfxContext::NewSubPath()
 159 {
 160     cairo_new_sub_path(mCairo);
 161 }
 162
 163 void
 164 gfxContext::LineTo(const gfxPoint& pt)
 165 {
 166     cairo_line_to(mCairo, pt.x, pt.y);
 167 }
 168
 169 void
 170 gfxContext::CurveTo(const gfxPoint& pt1, const gfxPoint& pt2, const gfxPoint& pt3)
 171 {
 172     cairo_curve_to(mCairo, pt1.x, pt1.y, pt2.x, pt2.y, pt3.x, pt3.y);
 173 }
 174
 175 void
 176 gfxContext::QuadraticCurveTo(const gfxPoint& pt1, const gfxPoint& pt2)
 177 {
 178     double cx, cy;
 179     cairo_get_current_point(mCairo, &cx, &cy);
 180     cairo_curve_to(mCairo,
 181                    (cx + pt1.x * 2.0) / 3.0,
 182                    (cy + pt1.y * 2.0) / 3.0,
 183                    (pt1.x * 2.0 + pt2.x) / 3.0,
 184                    (pt1.y * 2.0 + pt2.y) / 3.0,
 185                    pt2.x,
 186                    pt2.y);
 187 }
 188
 189 void
 190 gfxContext::Arc(const gfxPoint& center, gfxFloat radius,
 191                 gfxFloat angle1, gfxFloat angle2)
 192 {
 193     cairo_arc(mCairo, center.x, center.y, radius, angle1, angle2);
 194 }
 195
 196 void
 197 gfxContext::NegativeArc(const gfxPoint& center, gfxFloat radius,
 198                         gfxFloat angle1, gfxFloat angle2)
 199 {
 200     cairo_arc_negative(mCairo, center.x, center.y, radius, angle1, angle2);
 201 }
 202
 203 void
 204 gfxContext::Line(const gfxPoint& start, const gfxPoint& end)
 205 {
 206     MoveTo(start);
 207     LineTo(end);
 208 }
 209
 210 // XXX snapToPixels is only valid when snapping for filled
 211 // rectangles and for even-width stroked rectangles.
 212 // For odd-width stroked rectangles, we need to offset x/y by
 213 // 0.5...
 214 void
 215 gfxContext::Rectangle(const gfxRect& rect, PRBool snapToPixels)
 216 {
 217     if (snapToPixels) {
 218         gfxRect snappedRect(rect);
 219
 220 #ifdef MOZ_GFX_OPTIMIZE_MOBILE
 221         if (UserToDevicePixelSnapped(snappedRect, PR_TRUE))
 222 #else
 223         if (UserToDevicePixelSnapped(snappedRect))
 224 #endif
 225         {
 226             cairo_matrix_t mat;
 227             cairo_get_matrix(mCairo, &mat);
 228             cairo_identity_matrix(mCairo);
 229             Rectangle(snappedRect);
 230             cairo_set_matrix(mCairo, &mat);
 231
 232             return;
 233         }
 234     }
 235
 236     cairo_rectangle(mCairo, rect.pos.x, rect.pos.y, rect.size.width, rect.size.height);
 237 }
 238
 239 void
 240 gfxContext::Ellipse(const gfxPoint& center, const gfxSize& dimensions)
 241 {
 242     gfxSize halfDim = dimensions / 2.0;
 243     gfxRect r(center - halfDim, dimensions);
 244     gfxCornerSizes c(halfDim, halfDim, halfDim, halfDim);
 245
 246     RoundedRectangle (r, c);
 247 }
 248
 249 void
 250 gfxContext::Polygon(const gfxPoint *points, PRUint32 numPoints)
 251 {
 252     if (numPoints == 0)
 253         return;
 254
 255     cairo_move_to(mCairo, points[0].x, points[0].y);
 256     for (PRUint32 i = 1; i < numPoints; ++i) {
 257         cairo_line_to(mCairo, points[i].x, points[i].y);
 258     }
 259 }
 260
 261 void
 262 gfxContext::DrawSurface(gfxASurface *surface, const gfxSize& size)
 263 {
 264     cairo_save(mCairo);
 265     cairo_set_source_surface(mCairo, surface->CairoSurface(), 0, 0);
 266     cairo_new_path(mCairo);
 267
 268     // pixel-snap this
 269     Rectangle(gfxRect(gfxPoint(0.0, 0.0), size), PR_TRUE);
 270
 271     cairo_fill(mCairo);
 272     cairo_restore(mCairo);
 273 }
 274
 275 // transform stuff
 276 void
 277 gfxContext::Translate(const gfxPoint& pt)
 278 {
 279     cairo_translate(mCairo, pt.x, pt.y);
 280 }
 281
 282 void
 283 gfxContext::Scale(gfxFloat x, gfxFloat y)
 284 {
 285     cairo_scale(mCairo, x, y);
 286 }
 287
 288 void
 289 gfxContext::Rotate(gfxFloat angle)
 290 {
 291     cairo_rotate(mCairo, angle);
 292 }
 293
 294 void
 295 gfxContext::Multiply(const gfxMatrix& matrix)
 296 {
 297     const cairo_matrix_t& mat = reinterpret_cast<const cairo_matrix_t&>(matrix);
 298     cairo_transform(mCairo, &mat);
 299 }
 300
 301 void
 302 gfxContext::SetMatrix(const gfxMatrix& matrix)
 303 {
 304     const cairo_matrix_t& mat = reinterpret_cast<const cairo_matrix_t&>(matrix);
 305     cairo_set_matrix(mCairo, &mat);
 306 }
 307
 308 void
 309 gfxContext::IdentityMatrix()
 310 {
 311     cairo_identity_matrix(mCairo);
 312 }
 313
 314 gfxMatrix
 315 gfxContext::CurrentMatrix() const
 316 {
 317     cairo_matrix_t mat;
 318     cairo_get_matrix(mCairo, &mat);
 319     return gfxMatrix(*reinterpret_cast<gfxMatrix*>(&mat));
 320 }
 321
 322 gfxPoint
 323 gfxContext::DeviceToUser(const gfxPoint& point) const
 324 {
 325     gfxPoint ret = point;
 326     cairo_device_to_user(mCairo, &ret.x, &ret.y);
 327     return ret;
 328 }
 329
 330 gfxSize
 331 gfxContext::DeviceToUser(const gfxSize& size) const
 332 {
 333     gfxSize ret = size;
 334     cairo_device_to_user_distance(mCairo, &ret.width, &ret.height);
 335     return ret;
 336 }
 337
 338 gfxRect
 339 gfxContext::DeviceToUser(const gfxRect& rect) const
 340 {
 341     gfxRect ret = rect;
 342     cairo_device_to_user(mCairo, &ret.pos.x, &ret.pos.y);
 343     cairo_device_to_user_distance(mCairo, &ret.size.width, &ret.size.height);
 344     return ret;
 345 }
 346
 347 gfxPoint
 348 gfxContext::UserToDevice(const gfxPoint& point) const
 349 {
 350     gfxPoint ret = point;
 351     cairo_user_to_device(mCairo, &ret.x, &ret.y);
 352     return ret;
 353 }
 354
 355 gfxSize
 356 gfxContext::UserToDevice(const gfxSize& size) const
 357 {
 358     gfxSize ret = size;
 359     cairo_user_to_device_distance(mCairo, &ret.width, &ret.height);
 360     return ret;
 361 }
 362
 363 gfxRect
 364 gfxContext::UserToDevice(const gfxRect& rect) const
 365 {
 366     double xmin, ymin, xmax, ymax;
 367     xmin = rect.pos.x;
 368     ymin = rect.pos.y;
 369     xmax = rect.pos.x + rect.size.width;
 370     ymax = rect.pos.y + rect.size.height;
 371
 372     double x[3], y[3];
 373     x[0] = xmin;  y[0] = ymax;
 374     x[1] = xmax;  y[1] = ymax;
 375     x[2] = xmax;  y[2] = ymin;
 376
 377     cairo_user_to_device(mCairo, &xmin, &ymin);
 378     xmax = xmin;
 379     ymax = ymin;
 380     for (int i = 0; i < 3; i++) {
 381         cairo_user_to_device(mCairo, &x[i], &y[i]);
 382         xmin = PR_MIN(xmin, x[i]);
 383         xmax = PR_MAX(xmax, x[i]);
 384         ymin = PR_MIN(ymin, y[i]);
 385         ymax = PR_MAX(ymax, y[i]);
 386     }
 387
 388     return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);
 389 }
 390
 391 PRBool
 392 gfxContext::UserToDevicePixelSnapped(gfxRect& rect, PRBool ignoreScale) const
 393 {
 394     if (GetFlags() & FLAG_DISABLE_SNAPPING)
 395         return PR_FALSE;
 396
 397     // if we're not at 1.0 scale, don't snap, unless we're
 398     // ignoring the scale.  If we're not -just- a scale,
 399     // never snap.
 400     cairo_matrix_t mat;
 401     cairo_get_matrix(mCairo, &mat);
 402     if ((!ignoreScale && (mat.xx != 1.0 || mat.yy != 1.0)) ||
 403         (mat.xy != 0.0 || mat.yx != 0.0))
 404         return PR_FALSE;
 405
 406     gfxPoint p1 = UserToDevice(rect.pos);
 407     gfxPoint p2 = UserToDevice(rect.pos + rect.size);
 408
 409     gfxPoint p3 = UserToDevice(rect.pos + gfxSize(rect.size.width, 0.0));
 410     gfxPoint p4 = UserToDevice(rect.pos + gfxSize(0.0, rect.size.height));
 411
 412     // rectangle is no longer axis-aligned after transforming, so we can't snap
 413     if (p1.x != p4.x ||
 414         p2.x != p3.x ||
 415         p1.y != p3.y ||
 416         p2.y != p4.y)
 417         return PR_FALSE;
 418
 419     p1.Round();
 420     p2.Round();
 421
 422     gfxPoint pd = p2 - p1;
 423
 424     rect.pos = p1;
 425     rect.size = gfxSize(pd.x, pd.y);
 426
 427     return PR_TRUE;
 428 }
 429
 430 PRBool
 431 gfxContext::UserToDevicePixelSnapped(gfxPoint& pt, PRBool ignoreScale) const
 432 {
 433     if (GetFlags() & FLAG_DISABLE_SNAPPING)
 434         return PR_FALSE;
 435
 436     // if we're not at 1.0 scale, don't snap, unless we're
 437     // ignoring the scale.  If we're not -just- a scale,
 438     // never snap.
 439     cairo_matrix_t mat;
 440     cairo_get_matrix(mCairo, &mat);
 441     if ((!ignoreScale && (mat.xx != 1.0 || mat.yy != 1.0)) ||
 442         (mat.xy != 0.0 || mat.yx != 0.0))
 443         return PR_FALSE;
 444
 445     pt = UserToDevice(pt);
 446     pt.Round();
 447     return PR_TRUE;
 448 }
 449
 450 void
 451 gfxContext::PixelSnappedRectangleAndSetPattern(const gfxRect& rect,
 452                                                gfxPattern *pattern)
 453 {
 454     gfxRect r(rect);
 455
 456     // Bob attempts to pixel-snap the rectangle, and returns true if
 457     // the snapping succeeds.  If it does, we need to set up an
 458     // identity matrix, because the rectangle given back is in device
 459     // coordinates.
 460     //
 461     // We then have to call a translate to dr.pos afterwards, to make
 462     // sure the image lines up in the right place with our pixel
 463     // snapped rectangle.
 464     //
 465     // If snapping wasn't successful, we just translate to where the
 466     // pattern would normally start (in app coordinates) and do the
 467     // same thing.
 468
 469     gfxMatrix mat = CurrentMatrix();
 470     if (UserToDevicePixelSnapped(r)) {
 471         IdentityMatrix();
 472     }
 473
 474     Translate(r.pos);
 475     r.pos.x = r.pos.y = 0;
 476     Rectangle(r);
 477     SetPattern(pattern);
 478
 479     SetMatrix(mat);
 480 }
 481
 482 void
 483 gfxContext::SetAntialiasMode(AntialiasMode mode)
 484 {
 485     if (mode == MODE_ALIASED) {
 486         cairo_set_antialias(mCairo, CAIRO_ANTIALIAS_NONE);
 487     } else if (mode == MODE_COVERAGE) {
 488         cairo_set_antialias(mCairo, CAIRO_ANTIALIAS_DEFAULT);
 489     }
 490 }
 491
 492 gfxContext::AntialiasMode
 493 gfxContext::CurrentAntialiasMode() const
 494 {
 495     cairo_antialias_t aa = cairo_get_antialias(mCairo);
 496     if (aa == CAIRO_ANTIALIAS_NONE)
 497         return MODE_ALIASED;
 498     return MODE_COVERAGE;
 499 }
 500
 501 void
 502 gfxContext::SetDash(gfxLineType ltype)
 503 {
 504     static double dash[] = {5.0, 5.0};
 505     static double dot[] = {1.0, 1.0};
 506
 507     switch (ltype) {
 508         case gfxLineDashed:
 509             SetDash(dash, 2, 0.0);
 510             break;
 511         case gfxLineDotted:
 512             SetDash(dot, 2, 0.0);
 513             break;
 514         case gfxLineSolid:
 515         default:
 516             SetDash(nsnull, 0, 0.0);
 517             break;
 518     }
 519 }
 520
 521 void
 522 gfxContext::SetDash(gfxFloat *dashes, int ndash, gfxFloat offset)
 523 {
 524     cairo_set_dash(mCairo, dashes, ndash, offset);
 525 }
 526 //void getDash() const;
 527
 528 void
 529 gfxContext::SetLineWidth(gfxFloat width)
 530 {
 531     cairo_set_line_width(mCairo, width);
 532 }
 533
 534 gfxFloat
 535 gfxContext::CurrentLineWidth() const
 536 {
 537     return cairo_get_line_width(mCairo);
 538 }
 539
 540 void
 541 gfxContext::SetOperator(GraphicsOperator op)
 542 {
 543     if (mFlags & FLAG_SIMPLIFY_OPERATORS) {
 544         if (op != OPERATOR_SOURCE &&
 545             op != OPERATOR_CLEAR &&
 546             op != OPERATOR_OVER)
 547             op = OPERATOR_OVER;
 548     }
 549
 550     cairo_set_operator(mCairo, (cairo_operator_t)op);
 551 }
 552
 553 gfxContext::GraphicsOperator
 554 gfxContext::CurrentOperator() const
 555 {
 556     return (GraphicsOperator)cairo_get_operator(mCairo);
 557 }
 558
 559 void
 560 gfxContext::SetLineCap(GraphicsLineCap cap)
 561 {
 562     cairo_set_line_cap(mCairo, (cairo_line_cap_t)cap);
 563 }
 564
 565 gfxContext::GraphicsLineCap
 566 gfxContext::CurrentLineCap() const
 567 {
 568     return (GraphicsLineCap)cairo_get_line_cap(mCairo);
 569 }
 570
 571 void
 572 gfxContext::SetLineJoin(GraphicsLineJoin join)
 573 {
 574     cairo_set_line_join(mCairo, (cairo_line_join_t)join);
 575 }
 576
 577 gfxContext::GraphicsLineJoin
 578 gfxContext::CurrentLineJoin() const
 579 {
 580     return (GraphicsLineJoin)cairo_get_line_join(mCairo);
 581 }
 582
 583 void
 584 gfxContext::SetMiterLimit(gfxFloat limit)
 585 {
 586     cairo_set_miter_limit(mCairo, limit);
 587 }
 588
 589 gfxFloat
 590 gfxContext::CurrentMiterLimit() const
 591 {
 592     return cairo_get_miter_limit(mCairo);
 593 }
 594
 595 void
 596 gfxContext::SetFillRule(FillRule rule)
 597 {
 598     cairo_set_fill_rule(mCairo, (cairo_fill_rule_t)rule);
 599 }
 600
 601 gfxContext::FillRule
 602 gfxContext::CurrentFillRule() const
 603 {
 604     return (FillRule)cairo_get_fill_rule(mCairo);
 605 }
 606
 607 // clipping
 608 void
 609 gfxContext::Clip(const gfxRect& rect)
 610 {
 611     cairo_new_path(mCairo);
 612     cairo_rectangle(mCairo, rect.pos.x, rect.pos.y, rect.size.width, rect.size.height);
 613     cairo_clip(mCairo);
 614 }
 615
 616 void
 617 gfxContext::Clip()
 618 {
 619     cairo_clip_preserve(mCairo);
 620 }
 621
 622 void
 623 gfxContext::ResetClip()
 624 {
 625     cairo_reset_clip(mCairo);
 626 }
 627
 628 void
 629 gfxContext::UpdateSurfaceClip()
 630 {
 631     NewPath();
 632     Rectangle(gfxRect(0,0,0,0));
 633     Fill();
 634 }
 635
 636 gfxRect
 637 gfxContext::GetClipExtents()
 638 {
 639     double xmin, ymin, xmax, ymax;
 640     cairo_clip_extents(mCairo, &xmin, &ymin, &xmax, &ymax);
 641     return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);
 642 }
 643
 644 // rendering sources
 645
 646 void
 647 gfxContext::SetColor(const gfxRGBA& c)
 648 {
 649     if (gfxPlatform::GetCMSMode() == eCMSMode_All) {
 650
 651         gfxRGBA cms;
 652         gfxPlatform::TransformPixel(c, cms, gfxPlatform::GetCMSRGBTransform());
 653
 654         // Use the original alpha to avoid unnecessary float->byte->float
 655         // conversion errors
 656         cairo_set_source_rgba(mCairo, cms.r, cms.g, cms.b, c.a);
 657     }
 658     else
 659         cairo_set_source_rgba(mCairo, c.r, c.g, c.b, c.a);
 660 }
 661
 662 void
 663 gfxContext::SetDeviceColor(const gfxRGBA& c)
 664 {
 665     cairo_set_source_rgba(mCairo, c.r, c.g, c.b, c.a);
 666 }
 667
 668 PRBool
 669 gfxContext::GetDeviceColor(gfxRGBA& c)
 670 {
 671     return cairo_pattern_get_rgba(cairo_get_source(mCairo),
 672                                   &c.r,
 673                                   &c.g,
 674                                   &c.b,
 675                                   &c.a) == CAIRO_STATUS_SUCCESS;
 676 }
 677
 678 void
 679 gfxContext::SetSource(gfxASurface *surface, const gfxPoint& offset)
 680 {
 681     cairo_set_source_surface(mCairo, surface->CairoSurface(), offset.x, offset.y);
 682 }
 683
 684 void
 685 gfxContext::SetPattern(gfxPattern *pattern)
 686 {
 687     cairo_set_source(mCairo, pattern->CairoPattern());
 688 }
 689
 690 already_AddRefed<gfxPattern>
 691 gfxContext::GetPattern()
 692 {
 693     cairo_pattern_t *pat = cairo_get_source(mCairo);
 694     NS_ASSERTION(pat, "I was told this couldn't be null");
 695
 696     gfxPattern *wrapper = nsnull;
 697     if (pat)
 698         wrapper = new gfxPattern(pat);
 699     else
 700         wrapper = new gfxPattern(gfxRGBA(0,0,0,0));
 701
 702     NS_IF_ADDREF(wrapper);
 703     return wrapper;
 704 }
 705
 706
 707 // masking
 708
 709 void
 710 gfxContext::Mask(gfxPattern *pattern)
 711 {
 712     cairo_mask(mCairo, pattern->CairoPattern());
 713 }
 714
 715 void
 716 gfxContext::Mask(gfxASurface *surface, const gfxPoint& offset)
 717 {
 718     cairo_mask_surface(mCairo, surface->CairoSurface(), offset.x, offset.y);
 719 }
 720
 721 void
 722 gfxContext::Paint(gfxFloat alpha)
 723 {
 724     cairo_paint_with_alpha(mCairo, alpha);
 725 }
 726
 727 // groups
 728
 729 void
 730 gfxContext::PushGroup(gfxASurface::gfxContentType content)
 731 {
 732     cairo_push_group_with_content(mCairo, (cairo_content_t) content);
 733 }
 734
 735 already_AddRefed<gfxPattern>
 736 gfxContext::PopGroup()
 737 {
 738     cairo_pattern_t *pat = cairo_pop_group(mCairo);
 739     gfxPattern *wrapper = new gfxPattern(pat);
 740     cairo_pattern_destroy(pat);
 741     NS_IF_ADDREF(wrapper);
 742     return wrapper;
 743 }
 744
 745 void
 746 gfxContext::PopGroupToSource()
 747 {
 748     cairo_pop_group_to_source(mCairo);
 749 }
 750
 751 PRBool
 752 gfxContext::PointInFill(const gfxPoint& pt)
 753 {
 754     return cairo_in_fill(mCairo, pt.x, pt.y);
 755 }
 756
 757 PRBool
 758 gfxContext::PointInStroke(const gfxPoint& pt)
 759 {
 760     return cairo_in_stroke(mCairo, pt.x, pt.y);
 761 }
 762
 763 gfxRect
 764 gfxContext::GetUserPathExtent()
 765 {
 766     double xmin, ymin, xmax, ymax;
 767     cairo_path_extents(mCairo, &xmin, &ymin, &xmax, &ymax);
 768     return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);
 769 }
 770
 771 gfxRect
 772 gfxContext::GetUserFillExtent()
 773 {
 774     double xmin, ymin, xmax, ymax;
 775     cairo_fill_extents(mCairo, &xmin, &ymin, &xmax, &ymax);
 776     return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);
 777 }
 778
 779 gfxRect
 780 gfxContext::GetUserStrokeExtent()
 781 {
 782     double xmin, ymin, xmax, ymax;
 783     cairo_stroke_extents(mCairo, &xmin, &ymin, &xmax, &ymax);
 784     return gfxRect(xmin, ymin, xmax - xmin, ymax - ymin);
 785 }
 786
 787 already_AddRefed<gfxFlattenedPath>
 788 gfxContext::GetFlattenedPath()
 789 {
 790     gfxFlattenedPath *path =
 791         new gfxFlattenedPath(cairo_copy_path_flat(mCairo));
 792     NS_IF_ADDREF(path);
 793     return path;
 794 }
 795
 796 PRBool
 797 gfxContext::HasError()
 798 {
 799      return cairo_status(mCairo) != CAIRO_STATUS_SUCCESS;
 800 }
 801
 802 void
 803 gfxContext::RoundedRectangle(const gfxRect& rect,
 804                              const gfxCornerSizes& corners,
 805                              PRBool draw_clockwise)
 806 {
 807     //
 808     // For CW drawing, this looks like:
 809     //
 810     //  ...******0**      1    C
 811     //              ****
 812     //                  ***    2
 813     //                     **
 814     //                       *
 815     //                        *
 816     //                         3
 817     //                         *
 818     //                         *
 819     //
 820     // Where 0, 1, 2, 3 are the control points of the Bezier curve for
 821     // the corner, and C is the actual corner point.
 822     //
 823     // At the start of the loop, the current point is assumed to be
 824     // the point adjacent to the top left corner on the top
 825     // horizontal.  Note that corner indices start at the top left and
 826     // continue clockwise, whereas in our loop i = 0 refers to the top
 827     // right corner.
 828     //
 829     // When going CCW, the control points are swapped, and the first
 830     // corner that's drawn is the top left (along with the top segment).
 831     //
 832     // There is considerable latitude in how one chooses the four
 833     // control points for a Bezier curve approximation to an ellipse.
 834     // For the overall path to be continuous and show no corner at the
 835     // endpoints of the arc, points 0 and 3 must be at the ends of the
 836     // straight segments of the rectangle; points 0, 1, and C must be
 837     // collinear; and points 3, 2, and C must also be collinear.  This
 838     // leaves only two free parameters: the ratio of the line segments
 839     // 01 and 0C, and the ratio of the line segments 32 and 3C.  See
 840     // the following papers for extensive discussion of how to choose
 841     // these ratios:
 842     //
 843     //   Dokken, Tor, et al. "Good approximation of circles by
 844     //      curvature-continuous Bezier curves."  Computer-Aided
 845     //      Geometric Design 7(1990) 33--41.
 846     //   Goldapp, Michael. "Approximation of circular arcs by cubic
 847     //      polynomials." Computer-Aided Geometric Design 8(1991) 227--238.
 848     //   Maisonobe, Luc. "Drawing an elliptical arc using polylines,
 849     //      quadratic, or cubic Bezier curves."
 850     //      http://www.spaceroots.org/documents/ellipse/elliptical-arc.pdf
 851     //
 852     // We follow the approach in section 2 of Goldapp (least-error,
 853     // Hermite-type approximation) and make both ratios equal to
 854     //
 855     //          2   2 + n - sqrt(2n + 28)
 856     //  alpha = - * ---------------------
 857     //          3           n - 4
 858     //
 859     // where n = 3( cbrt(sqrt(2)+1) - cbrt(sqrt(2)-1) ).
 860     //
 861     // This is the result of Goldapp's equation (10b) when the angle
 862     // swept out by the arc is pi/2, and the parameter "a-bar" is the
 863     // expression given immediately below equation (21).
 864     //
 865     // Using this value, the maximum radial error for a circle, as a
 866     // fraction of the radius, is on the order of 0.2 x 10^-3.
 867     // Neither Dokken nor Goldapp discusses error for a general
 868     // ellipse; Maisonobe does, but his choice of control points
 869     // follows different constraints, and Goldapp's expression for
 870     // 'alpha' gives much smaller radial error, even for very flat
 871     // ellipses, than Maisonobe's equivalent.
 872     //
 873     // For the various corners and for each axis, the sign of this
 874     // constant changes, or it might be 0 -- it's multiplied by the
 875     // appropriate multiplier from the list before using.
 876     const gfxFloat alpha = 0.55191497064665766025;
 877
 878     typedef struct { gfxFloat a, b; } twoFloats;
 879
 880     twoFloats cwCornerMults[4] = { { -1,  0 },
 881                                    {  0, -1 },
 882                                    { +1,  0 },
 883                                    {  0, +1 } };
 884     twoFloats ccwCornerMults[4] = { { +1,  0 },
 885                                     {  0, -1 },
 886                                     { -1,  0 },
 887                                     {  0, +1 } };
 888
 889     twoFloats *cornerMults = draw_clockwise ? cwCornerMults : ccwCornerMults;
 890
 891     gfxPoint pc, p0, p1, p2, p3;
 892
 893     if (draw_clockwise)
 894         cairo_move_to(mCairo, rect.pos.x + corners[gfxCorner::TOP_LEFT].width, rect.pos.y);
 895     else
 896         cairo_move_to(mCairo, rect.pos.x + rect.size.width - corners[gfxCorner::TOP_RIGHT].width, rect.pos.y);
 897
 898     for (int i = 0; i < gfxCorner::NUM_CORNERS; i++) {
 899         // the corner index -- either 1 2 3 0 (cw) or 0 3 2 1 (ccw)
 900         int c = draw_clockwise ? ((i+1) % 4) : ((4-i) % 4);
 901
 902         // i+2 and i+3 respectively.  These are used to index into the corner
 903         // multiplier table, and were deduced by calculating out the long form
 904         // of each corner and finding a pattern in the signs and values.
 905         int i2 = (i+2) % 4;
 906         int i3 = (i+3) % 4;
 907
 908         pc = rect.Corner(c);
 909
 910         if (corners[c].width > 0.0 && corners[c].height > 0.0) {
 911             p0.x = pc.x + cornerMults[i].a * corners[c].width;
 912             p0.y = pc.y + cornerMults[i].b * corners[c].height;
 913
 914             p3.x = pc.x + cornerMults[i3].a * corners[c].width;
 915             p3.y = pc.y + cornerMults[i3].b * corners[c].height;
 916
 917             p1.x = p0.x + alpha * cornerMults[i2].a * corners[c].width;
 918             p1.y = p0.y + alpha * cornerMults[i2].b * corners[c].height;
 919
 920             p2.x = p3.x - alpha * cornerMults[i3].a * corners[c].width;
 921             p2.y = p3.y - alpha * cornerMults[i3].b * corners[c].height;
 922
 923             cairo_line_to (mCairo, p0.x, p0.y);
 924             cairo_curve_to (mCairo,
 925                             p1.x, p1.y,
 926                             p2.x, p2.y,
 927                             p3.x, p3.y);
 928         } else {
 929             cairo_line_to (mCairo, pc.x, pc.y);
 930         }
 931     }
 932
 933     cairo_close_path (mCairo);
 934 }