src/brush.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * brush.cpp: Brushes
   4  *
   5  * Contact:
   6  *   Moonlight List (moonlight-list@lists.ximian.com)
   7  *
   8  * Copyright 2007, 2008 Novell, Inc. (http://www.novell.com)
   9  *
  10  * See the LICENSE file included with the distribution for details.
  11  *
  12  */
  13
  14 #include <config.h>
  15
  16 #include <cairo.h>
  17 #include <glib.h>
  18
  19 #include "brush.h"
  20 #include "media.h"
  21 #include "mediaelement.h"
  22 #include "color.h"
  23 #include "transform.h"
  24 #include "mediaplayer.h"
  25 #include "bitmapimage.h"
  26 #include "uri.h"
  27
  28 //
  29 // SL-Cairo convertion and helper routines
  30 //
  31
  32 static cairo_extend_t
  33 convert_gradient_spread_method (GradientSpreadMethod method)
  34 {
  35         switch (method) {
  36         case GradientSpreadMethodPad:
  37                 return CAIRO_EXTEND_PAD;
  38         case GradientSpreadMethodReflect:
  39                 return CAIRO_EXTEND_REFLECT;
  40         // unknown (e.g. bad) values are considered to be Repeat by Silverlight
  41         // even if the default, i.e. *no* value) is Pad
  42         case GradientSpreadMethodRepeat:
  43         default:
  44                 return CAIRO_EXTEND_REPEAT;
  45         }
  46 }
  47
  48 static void
  49 brush_matrix_invert (cairo_matrix_t *matrix)
  50 {
  51         cairo_status_t status = cairo_matrix_invert (matrix);
  52         if (status != CAIRO_STATUS_SUCCESS) {
  53                 printf ("Moonlight: Error inverting matrix falling back\n");
  54                 cairo_matrix_init_identity (matrix);
  55         }
  56 }
  57
  58 //
  59 // Brush
  60 //
  61
  62
  63 Brush::Brush()
  64 {
  65         SetObjectType (Type::BRUSH);
  66 }
  67
  68 void
  69 Brush::SetupBrush (cairo_t *cr, const Rect &area)
  70 {
  71         g_warning ("Brush:SetupBrush has been called. The derived class should have overridden it.");
  72 }
  73
  74 void
  75 Brush::Fill (cairo_t *cr, bool preserve)
  76 {
  77         if (preserve)
  78                 cairo_fill_preserve (cr);
  79         else
  80                 cairo_fill (cr);
  81 }
  82
  83 void
  84 Brush::Stroke (cairo_t *cr, bool preserve)
  85 {
  86         if (preserve)
  87                 cairo_stroke_preserve (cr);
  88         else
  89                 cairo_stroke (cr);
  90 }
  91
  92 void
  93 Brush::OnSubPropertyChanged (DependencyProperty *prop, DependencyObject *obj, PropertyChangedEventArgs *subobj_args)
  94 {
  95         // if our transforms change in some fashion, we need to redraw
  96         // the element.
  97         NotifyListenersOfPropertyChange (Brush::ChangedProperty, NULL);
  98
  99         DependencyObject::OnSubPropertyChanged (prop, obj, subobj_args);
 100 }
 101
 102 bool
 103 Brush::IsOpaque ()
 104 {
 105         return !IS_TRANSLUCENT (GetOpacity ());
 106 }
 107
 108 bool
 109 Brush::IsAnimating ()
 110 {
 111         return FALSE;
 112 }
 113
 114 static void
 115 transform_get_absolute_transform (Transform *relative_transform, double width, double height, cairo_matrix_t *result)
 116 {
 117         cairo_matrix_t tm;
 118
 119         cairo_matrix_init_scale (result, width, height);
 120         relative_transform->GetTransform (&tm);
 121         cairo_matrix_multiply (result, &tm, result);
 122         cairo_matrix_scale (result, 1.0/width, 1.0/height);
 123 }
 124
 125
 126
 127 //
 128 // SolidColorBrush
 129 //
 130
 131 SolidColorBrush::SolidColorBrush ()
 132 {
 133         SetObjectType (Type::SOLIDCOLORBRUSH);
 134 }
 135
 136 SolidColorBrush::SolidColorBrush (const char *color)
 137 {
 138         SetObjectType (Type::SOLIDCOLORBRUSH);
 139         Color *c = color_from_str (color);
 140         SetColor (c);
 141         delete c;
 142 }
 143
 144 void
 145 SolidColorBrush::SetupBrush (cairo_t *cr, const Rect &area)
 146 {
 147         double opacity = GetOpacity ();
 148         Color *color = GetColor ();
 149
 150         cairo_set_source_rgba (cr, color->r, color->g, color->b, opacity * color->a);
 151 }
 152
 153 bool
 154 SolidColorBrush::IsOpaque ()
 155 {
 156         return Brush::IsOpaque () && !IS_TRANSLUCENT (GetColor ()->a);
 157 }
 158
 159
 160 //
 161 // GradientBrush
 162 //
 163
 164 GradientBrush::GradientBrush ()
 165 {
 166         SetObjectType (Type::GRADIENTBRUSH);
 167 }
 168
 169 GradientBrush::~GradientBrush ()
 170 {
 171 }
 172
 173 void
 174 GradientBrush::OnCollectionChanged (Collection *col, CollectionChangedEventArgs *args)
 175 {
 176         if (col != GetValue (GradientBrush::GradientStopsProperty)->AsCollection ()) {
 177                 Brush::OnCollectionChanged (col, args);
 178                 return;
 179         }
 180
 181         NotifyListenersOfPropertyChange (GradientBrush::GradientStopsProperty, NULL);
 182 }
 183
 184 void
 185 GradientBrush::OnCollectionItemChanged (Collection *col, DependencyObject *obj, PropertyChangedEventArgs *args)
 186 {
 187         if (col != GetValue (GradientBrush::GradientStopsProperty)->AsCollection ()) {
 188                 Brush::OnCollectionItemChanged (col, obj, args);
 189                 return;
 190         }
 191
 192         NotifyListenersOfPropertyChange (GradientBrush::GradientStopsProperty, NULL);
 193 }
 194
 195 void
 196 GradientBrush::SetupGradient (cairo_pattern_t *pattern, const Rect &area, bool single)
 197 {
 198         GradientStopCollection *children = GetGradientStops ();
 199         GradientSpreadMethod gsm = GetSpreadMethod ();
 200         double opacity = GetOpacity ();
 201         GradientStop *stop;
 202         double offset;
 203         int index;
 204
 205         cairo_pattern_set_extend (pattern, convert_gradient_spread_method (gsm));
 206
 207         // TODO - ColorInterpolationModeProperty is ignored (map to ?)
 208         if (single) {
 209                 // if a single color is shown (e.g. start == end point) Cairo will,
 210                 // by default, use the start color while SL use the end color
 211                 index = children->GetCount () - 1;
 212         } else {
 213                 index = 0;
 214         }
 215
 216         GradientStop *negative_stop = NULL;     //the biggest negative stop
 217         double neg_offset = 0.0;                //the cached associated offset
 218         GradientStop *first_stop = NULL;        //the smallest positive stop
 219         double first_offset = 0.0;              //idem
 220         GradientStop *last_stop = NULL;         //the biggest stop <= 1
 221         double last_offset = 0.0;               //idem
 222         GradientStop *outofbounds_stop = NULL;  //the smallest stop > 1
 223         double out_offset = 0.0;                //idem
 224
 225         for ( ; index < children->GetCount (); index++) {
 226                 stop = children->GetValueAt (index)->AsGradientStop ();
 227                 offset = stop->GetOffset ();
 228
 229                 if (offset >= 0.0 && offset <= 1.0) {
 230                         Color *color = stop->GetColor ();
 231
 232                         cairo_pattern_add_color_stop_rgba (pattern, offset, color->r, color->g, color->b, color->a * opacity);
 233
 234                         if (!first_stop || (first_offset != 0.0 && offset < first_offset)) {
 235                                 first_offset = offset;
 236                                 first_stop = stop;
 237                         }
 238
 239                         if (!last_stop || (last_offset != 1.0 && offset > last_offset)) {
 240                                 last_offset = offset;
 241                                 last_stop = stop;
 242                         }
 243                 } else if (offset < 0.0 && (!negative_stop || offset > neg_offset)) {
 244                         negative_stop = stop;
 245                         neg_offset = offset;
 246                 } else if (offset > 1.0 && (!outofbounds_stop || offset < out_offset)) {
 247                         outofbounds_stop = stop;
 248                         out_offset = offset;
 249                 }
 250         }
 251
 252         if (negative_stop && first_stop && first_offset != 0.0) { //take care of the negative stop
 253                 Color *neg_color = negative_stop->GetColor ();
 254                 Color *first_color = first_stop->GetColor ();
 255                 double ratio = neg_offset / (neg_offset - first_offset);
 256
 257                 cairo_pattern_add_color_stop_rgba (pattern, 0.0,
 258                         neg_color->r + ratio * (first_color->r - neg_color->r),
 259                         neg_color->g + ratio * (first_color->g - neg_color->g),
 260                         neg_color->b + ratio * (first_color->b - neg_color->b),
 261                         (neg_color->a + ratio * (first_color->a - neg_color->a)) * opacity);
 262         }
 263
 264         if (outofbounds_stop && last_stop && last_offset != 1.0) { //take care of the >1 stop
 265                 Color *last_color = last_stop->GetColor ();
 266                 Color *out_color = outofbounds_stop->GetColor ();
 267                 double ratio = (1.0 - last_offset) / (out_offset - last_offset);
 268
 269                 cairo_pattern_add_color_stop_rgba (pattern, 1.0,
 270                         last_color->r + ratio * (out_color->r - last_color->r),
 271                         last_color->g + ratio * (out_color->g - last_color->g),
 272                         last_color->b + ratio * (out_color->b - last_color->b),
 273                         (last_color->a + ratio * (out_color->a - last_color->a)) * opacity);
 274         }
 275
 276         if (negative_stop && outofbounds_stop && !first_stop && !last_stop) { //only 2 stops, one < 0, the other > 1
 277                 Color *neg_color = negative_stop->GetColor ();
 278                 Color *out_color = outofbounds_stop->GetColor ();
 279                 double ratio = neg_offset / (neg_offset - out_offset);
 280
 281                 cairo_pattern_add_color_stop_rgba (pattern, 0.0,
 282                         neg_color->r + ratio * (out_color->r - neg_color->r),
 283                         neg_color->g + ratio * (out_color->g - neg_color->g),
 284                         neg_color->b + ratio * (out_color->b - neg_color->b),
 285                         (neg_color->a + ratio * (out_color->a - neg_color->a)) * opacity);
 286
 287                 ratio = (1.0 - neg_offset) / (out_offset - neg_offset);
 288
 289                 cairo_pattern_add_color_stop_rgba (pattern, 1.0,
 290                         neg_color->r + ratio * (out_color->r - neg_color->r),
 291                         neg_color->g + ratio * (out_color->g - neg_color->g),
 292                         neg_color->b + ratio * (out_color->b - neg_color->b),
 293                         (neg_color->a + ratio * (out_color->a - neg_color->a)) * opacity);
 294         }
 295
 296         if (negative_stop && !outofbounds_stop && !first_stop && !last_stop) { //only negative stops
 297                 Color *color = negative_stop->GetColor ();
 298
 299                 cairo_pattern_add_color_stop_rgba (pattern, 0.0, color->r, color->g, color->b, color->a * opacity);
 300         }
 301
 302         if (outofbounds_stop && !negative_stop && !first_stop && !last_stop) { //only > 1 stops
 303                 Color *color = outofbounds_stop->GetColor ();
 304
 305                 cairo_pattern_add_color_stop_rgba (pattern, 1.0, color->r, color->g, color->b, color->a * opacity);
 306         }
 307 }
 308
 309 bool
 310 GradientBrush::IsOpaque ()
 311 {
 312         if (!Brush::IsOpaque ())
 313                 return false;
 314
 315         GradientStopCollection *stops = GetGradientStops ();
 316         GradientStop *stop;
 317         Color *c;
 318
 319         for (int i = 0; i < stops->GetCount (); i++) {
 320                 stop = stops->GetValueAt (i)->AsGradientStop ();
 321                 c = stop->GetColor ();
 322                 if (IS_TRANSLUCENT (c->a))
 323                         return false;
 324         }
 325
 326         return true;
 327 }
 328
 329 //
 330 // GradientStopCollection
 331 //
 332
 333 GradientStopCollection::GradientStopCollection ()
 334 {
 335         SetObjectType (Type::GRADIENTSTOP_COLLECTION);
 336 }
 337
 338 GradientStopCollection::~GradientStopCollection ()
 339 {
 340 }
 341
 342
 343 //
 344 // GradientStop
 345 //
 346
 347 GradientStop::GradientStop()
 348 {
 349         SetObjectType (Type::GRADIENTSTOP);
 350 }
 351
 352 GradientStop::~GradientStop()
 353 {
 354 }
 355
 356 //
 357 // LinearGradientBrush
 358 //
 359
 360 LinearGradientBrush::LinearGradientBrush ()
 361 {
 362         SetObjectType (Type::LINEARGRADIENTBRUSH);
 363 }
 364
 365 LinearGradientBrush::~LinearGradientBrush ()
 366 {
 367 }
 368
 369 void
 370 LinearGradientBrush::SetupBrush (cairo_t *cr, const Rect &area)
 371 {
 372         Point *start = GetStartPoint ();
 373         Point *end = GetEndPoint ();
 374         double x0, y0, x1, y1;
 375         cairo_matrix_t offset_matrix;
 376         Point p = area.GetTopLeft ();
 377
 378         switch (GetMappingMode ()) {
 379         // unknown (e.g. bad) values are considered to be Absolute to Silverlight
 380         // even if the default, i.e. *no* value) is RelativeToBoundingBox
 381         case BrushMappingModeAbsolute:
 382         default:
 383                 y0 = start ? start->y : 0.0;
 384                 x0 = start ? start->x : 0.0;
 385                 y1 = end ? end->y : area.height;
 386                 x1 = end ? end->x : area.width;
 387                 break;
 388         case BrushMappingModeRelativeToBoundingBox:
 389                 y0 = start ? (start->y * area.height) : 0.0;
 390                 x0 = start ? (start->x * area.width) : 0.0;
 391                 y1 = end ? (end->y * area.height) : area.height;
 392                 x1 = end ? (end->x * area.width) : area.width;
 393                 break;
 394         }
 395
 396         cairo_pattern_t *pattern = cairo_pattern_create_linear (x0, y0, x1, y1);
 397
 398         cairo_matrix_t matrix;
 399         cairo_matrix_init_identity (&matrix);
 400
 401         Transform *transform = GetTransform ();
 402         if (transform) {
 403                 cairo_matrix_t tm;
 404
 405                 transform->GetTransform (&tm);
 406                 // TODO - optimization, check for empty/identity matrix too ?
 407                 cairo_matrix_multiply (&matrix, &matrix, &tm);
 408         }
 409
 410         Transform *relative_transform = GetRelativeTransform ();
 411         if (relative_transform) {
 412                 cairo_matrix_t tm;
 413                 transform_get_absolute_transform (relative_transform, area.width, area.height, &tm);
 414                 cairo_matrix_multiply (&matrix, &matrix, &tm);
 415         }
 416
 417         if (p.x != 0.0 && p.y != 0.0) {
 418                 cairo_matrix_init_translate (&offset_matrix, p.x, p.y);
 419                 cairo_matrix_multiply (&matrix, &matrix, &offset_matrix);
 420         }
 421
 422         brush_matrix_invert (&matrix);
 423         cairo_pattern_set_matrix (pattern, &matrix);
 424
 425         bool only_start = (x0 == x1 && y0 == y1);
 426         GradientBrush::SetupGradient (pattern, area, only_start);
 427
 428         if (cairo_pattern_status (pattern) == CAIRO_STATUS_SUCCESS)
 429                 cairo_set_source (cr, pattern);
 430         else
 431                 cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.0);
 432
 433         cairo_pattern_destroy (pattern);
 434 }
 435
 436 //
 437 // RadialGradientBrush
 438 //
 439
 440 RadialGradientBrush::RadialGradientBrush ()
 441 {
 442         SetObjectType (Type::RADIALGRADIENTBRUSH);
 443 }
 444
 445 RadialGradientBrush::~RadialGradientBrush()
 446 {
 447 }
 448
 449 void
 450 RadialGradientBrush::SetupBrush (cairo_t *cr, const Rect &area)
 451 {
 452         Point *origin = GetGradientOrigin ();
 453         double ox = (origin ? origin->x : 0.5);
 454         double oy = (origin ? origin->y : 0.5);
 455         cairo_matrix_t offset_matrix;
 456
 457         Point *center = GetCenter ();
 458         double cx = (center ? center->x : 0.5);
 459         double cy = (center ? center->y : 0.5);
 460
 461         double rx = GetRadiusX ();
 462         double ry = GetRadiusY ();
 463
 464         cairo_pattern_t *pattern = cairo_pattern_create_radial (ox/rx, oy/ry, 0.0, cx/rx, cy/ry, 1);
 465
 466         cairo_matrix_t matrix;
 467         switch (GetMappingMode ()) {
 468         // unknown (e.g. bad) values are considered to be Absolute to Silverlight
 469         // even if the default, i.e. *no* value) is RelativeToBoundingBox
 470         case BrushMappingModeAbsolute:
 471         default:
 472                 cairo_matrix_init_translate (&matrix, cx, cy);
 473                 cairo_matrix_scale (&matrix, rx, ry);
 474                 cairo_matrix_translate (&matrix, -cx/rx, -cy/ry);
 475                 break;
 476         case BrushMappingModeRelativeToBoundingBox:
 477                 cairo_matrix_init_translate (&matrix, cx * area.width, cy * area.height);
 478                 cairo_matrix_scale (&matrix, area.width * rx, area.height * ry );
 479                 cairo_matrix_translate (&matrix, -cx/rx, -cy/ry);
 480                 break;
 481         }
 482
 483         Transform *transform = GetTransform ();
 484         if (transform) {
 485                 cairo_matrix_t tm;
 486
 487                 transform->GetTransform (&tm);
 488                 // TODO - optimization, check for empty/identity matrix too ?
 489                 cairo_matrix_multiply (&matrix, &matrix, &tm);
 490         }
 491
 492         Transform *relative_transform = GetRelativeTransform ();
 493         if (relative_transform) {
 494                 cairo_matrix_t tm;
 495                 transform_get_absolute_transform (relative_transform, area.width, area.height, &tm);
 496                 // TODO - optimization, check for empty/identity matrix too ?
 497                 cairo_matrix_multiply (&matrix, &matrix, &tm);
 498         }
 499
 500         if (area.x != 0.0 || area.y != 0.0) {
 501                 cairo_matrix_init_translate (&offset_matrix, area.x, area.y);
 502                 cairo_matrix_multiply (&matrix, &matrix, &offset_matrix);
 503         }
 504
 505         brush_matrix_invert (&matrix);
 506
 507         cairo_pattern_set_matrix (pattern, &matrix);
 508         GradientBrush::SetupGradient (pattern, area);
 509
 510         if (cairo_pattern_status (pattern) == CAIRO_STATUS_SUCCESS)
 511                 cairo_set_source (cr, pattern);
 512         else
 513                 cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.0);
 514
 515         cairo_pattern_destroy (pattern);
 516 }
 517
 518 //
 519 // ImageBrush
 520 //
 521
 522 ImageBrush::ImageBrush ()
 523 {
 524         SetObjectType (Type::IMAGEBRUSH);
 525 }
 526
 527 ImageBrush::~ImageBrush ()
 528 {
 529 }
 530
 531 void
 532 ImageBrush::Dispose ()
 533 {
 534         BitmapImage *source = (BitmapImage *) GetImageSource ();
 535
 536         if (source) {
 537                 source->RemoveHandler (BitmapImage::DownloadProgressEvent, download_progress, this);
 538                 source->RemoveHandler (BitmapImage::ImageOpenedEvent, image_opened, this);
 539                 source->RemoveHandler (BitmapImage::ImageFailedEvent, image_failed, this);
 540                 source->RemoveHandler (BitmapSource::PixelDataChangedEvent, source_pixel_data_changed, this);
 541         }
 542
 543         TileBrush::Dispose ();
 544 }
 545
 546 void
 547 ImageBrush::download_progress (EventObject *sender, EventArgs *calldata, gpointer closure)
 548 {
 549         ImageBrush *media = (ImageBrush *) closure;
 550
 551         media->DownloadProgress ();
 552 }
 553
 554 void
 555 ImageBrush::image_opened (EventObject *sender, EventArgs *calldata, gpointer closure)
 556 {
 557         ImageBrush *media = (ImageBrush *) closure;
 558
 559         media->ImageOpened ();
 560 }
 561
 562 void
 563 ImageBrush::image_failed (EventObject *sender, EventArgs *calldata, gpointer closure)
 564 {
 565         ImageBrush *media = (ImageBrush *) closure;
 566
 567         media->ImageFailed ((ImageErrorEventArgs*) calldata);
 568 }
 569
 570 void
 571 ImageBrush::source_pixel_data_changed (EventObject *sender, EventArgs *calldata, gpointer closure)
 572 {
 573         ImageBrush *media = (ImageBrush *) closure;
 574
 575         media->SourcePixelDataChanged ();
 576 }
 577
 578 void
 579 ImageBrush::DownloadProgress ()
 580 {
 581         BitmapImage *source = (BitmapImage *) GetImageSource ();
 582
 583         SetDownloadProgress (source->GetProgress ());
 584         Emit (DownloadProgressChangedEvent);
 585 }
 586
 587 void
 588 ImageBrush::ImageOpened ()
 589 {
 590         BitmapImage *source = (BitmapImage*)GetImageSource ();
 591
 592         source->RemoveHandler (BitmapImage::DownloadProgressEvent, download_progress, this);
 593         source->RemoveHandler (BitmapImage::ImageOpenedEvent, image_opened, this);
 594         source->RemoveHandler (BitmapImage::ImageFailedEvent, image_failed, this);
 595 }
 596
 597 void
 598 ImageBrush::ImageFailed (ImageErrorEventArgs *args)
 599 {
 600         BitmapImage *source = (BitmapImage*)GetImageSource ();
 601
 602         source->RemoveHandler (BitmapImage::DownloadProgressEvent, download_progress, this);
 603         source->RemoveHandler (BitmapImage::ImageOpenedEvent, image_opened, this);
 604         source->RemoveHandler (BitmapImage::ImageFailedEvent, image_failed, this);
 605
 606         args->ref (); // to counter the unref in Emit
 607         Emit (ImageFailedEvent, args);
 608 }
 609
 610 void
 611 ImageBrush::SourcePixelDataChanged ()
 612 {
 613         NotifyListenersOfPropertyChange (Brush::ChangedProperty, NULL);
 614 }
 615
 616 void
 617 ImageBrush::SetSource (Downloader *downloader, const char *PartName)
 618 {
 619         BitmapImage *source = (BitmapImage *) GetImageSource ();
 620
 621         if (source == NULL) {
 622                 source = new BitmapImage ();
 623                 SetImageSource (source);
 624         }
 625
 626         source->AddHandler (BitmapImage::DownloadProgressEvent, download_progress, this);
 627         source->AddHandler (BitmapImage::ImageOpenedEvent, image_opened, this);
 628         source->AddHandler (BitmapImage::ImageFailedEvent, image_failed, this);
 629
 630         source->SetDownloader (downloader, NULL, PartName);
 631 }
 632
 633 void
 634 ImageBrush::OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error)
 635 {
 636         if (args->GetProperty ()->GetOwnerType() != Type::IMAGEBRUSH) {
 637                 TileBrush::OnPropertyChanged (args, error);
 638                 return;
 639         } else if (args->GetId () == ImageSourceProperty) {
 640                 ImageSource *source = args->GetNewValue () ? args->GetNewValue ()->AsImageSource () : NULL;
 641                 ImageSource *old = args->GetOldValue () ? args->GetOldValue ()->AsImageSource () : NULL;
 642
 643                 if (old && old->Is(Type::BITMAPSOURCE)) {
 644                         old->RemoveHandler (BitmapSource::PixelDataChangedEvent, source_pixel_data_changed, this);
 645                 }
 646                 if (source && source->Is(Type::BITMAPSOURCE)) {
 647                         source->AddHandler (BitmapSource::PixelDataChangedEvent, source_pixel_data_changed, this);
 648                 }
 649
 650                 if (old && old->Is(Type::BITMAPIMAGE)) {
 651                         old->RemoveHandler (BitmapImage::DownloadProgressEvent, download_progress, this);
 652                         old->RemoveHandler (BitmapImage::ImageOpenedEvent, image_opened, this);
 653                         old->RemoveHandler (BitmapImage::ImageFailedEvent, image_failed, this);
 654                 }
 655                 if (source && source->Is(Type::BITMAPIMAGE)) {
 656                         BitmapImage *bitmap = (BitmapImage *) source;
 657                         Uri *uri = bitmap->GetUriSource ();
 658
 659                         source->AddHandler (BitmapImage::DownloadProgressEvent, download_progress, this);
 660                         source->AddHandler (BitmapImage::ImageOpenedEvent, image_opened, this);
 661                         source->AddHandler (BitmapImage::ImageFailedEvent, image_failed, this);
 662
 663                         // can uri ever be null?
 664                         if (uri != NULL) {
 665                                 ImageErrorEventArgs *args = NULL;
 666
 667                                 if (uri->IsInvalidPath ()) {
 668                                         args = new ImageErrorEventArgs (MoonError (MoonError::ARGUMENT_OUT_OF_RANGE, 0, "invalid path found in uri"));
 669                                 } else if (!bitmap->ValidateDownloadPolicy ()) {
 670                                         args = new ImageErrorEventArgs (MoonError (MoonError::ARGUMENT_OUT_OF_RANGE, 0, "Security Policy Violation"));
 671                                 }
 672
 673                                 if (args != NULL) {
 674                                         source->RemoveHandler (BitmapImage::ImageFailedEvent, image_failed, this);
 675                                         EmitAsync (ImageFailedEvent, args);
 676                                 }
 677                         }
 678                 }
 679                 SourcePixelDataChanged ();
 680         }
 681
 682         NotifyListenersOfPropertyChange (args, error);
 683 }
 684
 685 bool
 686 ImageBrush::IsOpaque ()
 687 {
 688         // XXX punt for now and return false here.
 689         return false;
 690 }
 691
 692 cairo_surface_t *
 693 image_brush_create_similar (cairo_t *cairo, int width, int height)
 694 {
 695 #if USE_OPT_IMAGE_ONLY
 696         return cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
 697 #else
 698         return cairo_surface_create_similar (cairo_get_group_target (cairo),
 699                                              CAIRO_CONTENT_COLOR_ALPHA,
 700                                              width,
 701                                              height);
 702 #endif
 703 }
 704
 705 void
 706 image_brush_compute_pattern_matrix (cairo_matrix_t *matrix, double width, double height, int sw, int sh,
 707         Stretch stretch, AlignmentX align_x, AlignmentY align_y, Transform *transform, Transform *relative_transform)
 708 {
 709         // scale required to "fit" for both axes
 710         double sx = sw / width;
 711         double sy = sh / height;
 712
 713
 714         if (width == 0)
 715                 sx = 1.0;
 716
 717         if (height == 0)
 718                 sy = 1.0;
 719
 720         // Fill is the simplest case because AlignementX and AlignmentY don't matter in this case
 721         if (stretch == StretchFill) {
 722                 // fill extents in both axes
 723                 cairo_matrix_init_scale (matrix, sx, sy);
 724         } else {
 725                 double scale = 1.0;
 726                 double dx = 0.0;
 727                 double dy = 0.0;
 728
 729                 switch (stretch) {
 730                 case StretchUniform:
 731                         // fill without cuting the image, center the other axes
 732                         scale = (sx < sy) ? sy : sx;
 733                         break;
 734                 case StretchUniformToFill:
 735                         // fill by, potentially, cuting the image on one axe, center on both axes
 736                         scale = (sx < sy) ? sx : sy;
 737                         break;
 738                 case StretchNone:
 739                         break;
 740                 default:
 741                         g_warning ("Invalid Stretch value (%d).", stretch);
 742                         break;
 743                 }
 744
 745                 switch (align_x) {
 746                 case AlignmentXLeft:
 747                         dx = 0.0;
 748                         break;
 749                 case AlignmentXCenter:
 750                         dx = (sw - (scale * width)) / 2;
 751                         break;
 752                 // Silverlight+Javascript default to AlignmentXRight for (some) invalid values (others results in an alert)
 753                 case AlignmentXRight:
 754                 default:
 755                         dx = (sw - (scale * width));
 756                         break;
 757                 }
 758
 759                 switch (align_y) {
 760                 case AlignmentYTop:
 761                         dy = 0.0;
 762                         break;
 763                 case AlignmentYCenter:
 764                         dy = (sh - (scale * height)) / 2;
 765                         break;
 766                 // Silverlight+Javascript default to AlignmentXBottom for (some) invalid values (others results in an alert)
 767                 case AlignmentYBottom:
 768                 default:
 769                         dy = (sh - (scale * height));
 770                         break;
 771                 }
 772
 773                 if (stretch == StretchNone) {
 774                         // no strech, no scale
 775                         cairo_matrix_init_translate (matrix, dx, dy);
 776                 } else {
 777                         // otherwise there's both a scale and translation to be done
 778                         cairo_matrix_init (matrix, scale, 0, 0, scale, dx, dy);
 779                 }
 780         }
 781
 782         if (transform || relative_transform) {
 783                 if (transform) {
 784                         cairo_matrix_t tm;
 785
 786                         transform->GetTransform (&tm);
 787                         brush_matrix_invert (&tm);
 788                         cairo_matrix_multiply (matrix, &tm, matrix);
 789                 }
 790
 791                 if (relative_transform) {
 792                         cairo_matrix_t tm;
 793
 794                         transform_get_absolute_transform (relative_transform, width, height, &tm);
 795                         brush_matrix_invert (&tm);
 796                         cairo_matrix_multiply (matrix, &tm, matrix);
 797                 }
 798         }
 799 }
 800
 801 static bool
 802 is_stretch_valid (Stretch stretch)
 803 {
 804         switch (stretch) {
 805         case StretchNone:
 806         case StretchFill:
 807         case StretchUniform:
 808         case StretchUniformToFill:
 809                 return true;
 810         default:
 811                 return false;
 812         }
 813 }
 814
 815 void
 816 ImageBrush::SetupBrush (cairo_t *cr, const Rect &area)
 817 {
 818         ImageSource *source = GetImageSource ();
 819         cairo_surface_t *surface;
 820         cairo_pattern_t *pattern;
 821         cairo_matrix_t matrix;
 822         Transform *transform;
 823         Transform *relative_transform;
 824         AlignmentX ax;
 825         AlignmentY ay;
 826         Stretch stretch;
 827
 828         if (!source) goto failed;
 829
 830         source->Lock ();
 831
 832         surface = source->GetSurface (cr);
 833
 834         stretch = GetStretch ();
 835
 836         if (!surface || !is_stretch_valid (stretch)) {
 837                 source->Unlock ();
 838                 goto failed;
 839         }
 840
 841         ax = GetAlignmentX ();
 842         ay = GetAlignmentY ();
 843
 844         transform = GetTransform ();
 845         relative_transform = GetRelativeTransform ();
 846
 847         pattern = cairo_pattern_create_for_surface (surface);
 848
 849         image_brush_compute_pattern_matrix (&matrix, area.width, area.height, source->GetPixelWidth (), source->GetPixelHeight (), stretch, ax, ay, transform, relative_transform);
 850         cairo_matrix_translate (&matrix, -area.x, -area.y);
 851         cairo_pattern_set_matrix (pattern, &matrix);
 852
 853         if (cairo_pattern_status (pattern) == CAIRO_STATUS_SUCCESS)
 854                 cairo_set_source (cr, pattern);
 855         else
 856                 cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.0);
 857
 858         cairo_pattern_destroy (pattern);
 859
 860         source->Unlock ();
 861
 862         return;
 863
 864 failed:
 865         cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.0);
 866         return;
 867 }
 868
 869 //
 870 // TileBrush
 871 //
 872
 873 TileBrush::TileBrush ()
 874 {
 875         SetObjectType (Type::TILEBRUSH);
 876 }
 877
 878 TileBrush::~TileBrush ()
 879 {
 880 }
 881
 882 void
 883 TileBrush::Fill (cairo_t *cr, bool preserve)
 884 {
 885         double opacity = GetOpacity ();
 886
 887         if (IS_INVISIBLE (opacity)) {
 888                 if (!preserve)
 889                         cairo_new_path (cr);
 890                 return;
 891         }
 892
 893         if (!IS_TRANSLUCENT (opacity)) {
 894                 Brush::Fill (cr, preserve);
 895                 return;
 896         }
 897
 898         cairo_save (cr);
 899         cairo_clip (cr);
 900         cairo_paint_with_alpha (cr, opacity);
 901         cairo_restore (cr);
 902
 903         if (!preserve)
 904                 cairo_new_path (cr);
 905 }
 906
 907 void
 908 TileBrush::Stroke (cairo_t *cr, bool preserve)
 909 {
 910         double opacity = GetOpacity ();
 911
 912         if (IS_INVISIBLE (opacity)) {
 913                 if (!preserve)
 914                         cairo_new_path (cr);
 915                 return;
 916         }
 917
 918         if (!IS_TRANSLUCENT (opacity)) {
 919                 Brush::Stroke (cr, preserve);
 920                 return;
 921         }
 922
 923         cairo_save (cr);
 924         cairo_push_group_with_content (cr, CAIRO_CONTENT_ALPHA);
 925         cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, opacity);
 926         cairo_stroke (cr);
 927
 928         cairo_pattern_t *mask = cairo_pop_group (cr);
 929         cairo_restore (cr);
 930         if (cairo_pattern_status (mask) == CAIRO_STATUS_SUCCESS) {
 931                 cairo_mask (cr, mask);
 932         }
 933         cairo_pattern_destroy (mask);
 934
 935         if (!preserve)
 936                 cairo_new_path (cr);
 937 }
 938
 939 //
 940 // VideoBrush
 941 //
 942
 943 VideoBrush::VideoBrush ()
 944 {
 945         SetObjectType (Type::VIDEOBRUSH);
 946         media = NULL;
 947 }
 948
 949 VideoBrush::~VideoBrush ()
 950 {
 951         if (media != NULL) {
 952                 media->RemovePropertyChangeListener (this);
 953                 media->RemoveHandler (MediaElement::MediaInvalidatedEvent, update_brush, this);
 954                 media->unref ();
 955         }
 956 }
 957
 958 void
 959 VideoBrush::SetupBrush (cairo_t *cr, const Rect &area)
 960 {
 961         Stretch stretch = GetStretch ();
 962         if (!is_stretch_valid (stretch)) {
 963                 // bad enum value for stretch, nothing should be drawn
 964                 // XXX Removing this _source_set at all?
 965                 cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.0);
 966                 return;
 967         }
 968
 969         MediaPlayer *mplayer = media ? media->GetMediaPlayer () : NULL;
 970         Transform *transform = GetTransform ();
 971         Transform *relative_transform = GetRelativeTransform ();
 972         AlignmentX ax = GetAlignmentX ();
 973         AlignmentY ay = GetAlignmentY ();
 974         cairo_surface_t *surface;
 975         cairo_pattern_t *pattern;
 976         cairo_matrix_t matrix;
 977
 978         if (media == NULL) {
 979                 DependencyObject *obj;
 980                 const char *name;
 981
 982                 name = GetSourceName ();
 983
 984                 if (name == NULL || *name == '\0')
 985                         return;
 986
 987                 if ((obj = FindName (name)) && obj->Is (Type::MEDIAELEMENT)) {
 988                         obj->AddPropertyChangeListener (this);
 989                         media = (MediaElement *) obj;
 990                         media->AddHandler (MediaElement::MediaInvalidatedEvent, update_brush, this);
 991                         mplayer = media->GetMediaPlayer ();
 992                         obj->ref ();
 993                 } else if (obj == NULL) {
 994                         printf ("could not find element `%s'\n", name);
 995                 } else {
 996                         printf ("obj %p is not of type MediaElement (it is %s)\n", obj,
 997                                 obj->GetTypeName ());
 998                 }
 999         }
1000
1001         if (!mplayer || !(surface = mplayer->GetCairoSurface ())) {
1002                 // not yet available, draw gray-ish shadow where the brush should be applied
1003                 cairo_set_source_rgba (cr, 0.5, 0.5, 0.5, 0.5);
1004                 return;
1005         }
1006
1007         pattern = cairo_pattern_create_for_surface (surface);
1008         cairo_filter_t filter;
1009         switch (media ? media->GetQualityLevel (0, 3) : 0) {
1010         case 0: filter = CAIRO_FILTER_FAST; break;
1011         case 1: filter = CAIRO_FILTER_GOOD; break;
1012         case 2: filter = CAIRO_FILTER_BILINEAR; break;
1013         default: filter = CAIRO_FILTER_BEST; break;
1014         }
1015         cairo_pattern_set_filter (pattern, filter);
1016
1017         image_brush_compute_pattern_matrix (&matrix, area.width, area.height, mplayer->GetVideoWidth (),
1018                                             mplayer->GetVideoHeight (), stretch, ax, ay,
1019                                             transform, relative_transform);
1020
1021         cairo_matrix_translate (&matrix, -area.x, -area.y);
1022         cairo_pattern_set_matrix (pattern, &matrix);
1023
1024         if (cairo_pattern_status (pattern) == CAIRO_STATUS_SUCCESS)
1025                 cairo_set_source (cr, pattern);
1026         else
1027                 cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.0);
1028
1029         cairo_pattern_destroy (pattern);
1030 }
1031
1032 void
1033 VideoBrush::OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error)
1034 {
1035         if (args->GetProperty ()->GetOwnerType() != Type::VIDEOBRUSH) {
1036                 TileBrush::OnPropertyChanged (args, error);
1037                 return;
1038         }
1039
1040         if (args->GetId () == VideoBrush::SourceNameProperty) {
1041                 char *name = args->GetNewValue() ? args->GetNewValue()->AsString () : NULL;
1042                 DependencyObject *obj;
1043
1044                 if (media != NULL) {
1045                         media->RemovePropertyChangeListener (this);
1046                         media->RemoveHandler (MediaElement::MediaInvalidatedEvent, update_brush, this);
1047                         media->unref ();
1048                         media = NULL;
1049                 }
1050
1051                 if (name && (obj = FindName (name)) && obj->Is (Type::MEDIAELEMENT)) {
1052                         obj->AddPropertyChangeListener (this);
1053                         media = (MediaElement *) obj;
1054                         media->AddHandler (MediaElement::MediaInvalidatedEvent, update_brush, this);
1055                         obj->ref ();
1056                 } else {
1057                         // Note: This may have failed because the parser hasn't set the
1058                         // toplevel element yet, we'll try again in SetupBrush()
1059                 }
1060         }
1061
1062         NotifyListenersOfPropertyChange (args, error);
1063 }
1064
1065 void
1066 VideoBrush::OnSubPropertyChanged (DependencyProperty *prop, DependencyObject *obj, PropertyChangedEventArgs *subobj_args)
1067 {
1068         /* this is being handled in the base class */
1069         /*
1070         if (subobj_args->GetId () == MediaElement::PositionProperty) {
1071                 // We to changes in this MediaElement property so we
1072                 // can notify whoever is using us to paint that they
1073                 // need to redraw themselves.
1074                 NotifyListenersOfPropertyChange (Brush::ChangedProperty);
1075         }
1076         */
1077
1078         TileBrush::OnSubPropertyChanged (prop, obj, subobj_args);
1079 }
1080
1081 void
1082 VideoBrush::SetSource (MediaElement *source)
1083 {
1084         if (source) {
1085                 source->ref ();
1086                 source->AddHandler (MediaElement::MediaInvalidatedEvent, update_brush, this);
1087         }
1088
1089         SetSourceName ("");
1090
1091         if (media != NULL) {
1092                 media->RemovePropertyChangeListener (this);
1093                 media->RemoveHandler (MediaElement::MediaInvalidatedEvent, update_brush, this);
1094                 media->unref ();
1095                 media = NULL;
1096         }
1097
1098         media = source;
1099 }
1100
1101 bool
1102 VideoBrush::IsOpaque ()
1103 {
1104         // XXX punt for now and return false here.
1105         return false;
1106 }
1107
1108 bool
1109 VideoBrush::IsAnimating ()
1110 {
1111         if (media && media->IsPlaying ())
1112                 return true;
1113
1114         return TileBrush::IsAnimating ();
1115 }
1116
1117 void
1118 VideoBrush::update_brush (EventObject *, EventArgs *, gpointer closure)
1119 {
1120         VideoBrush *b = (VideoBrush*)closure;
1121         b->NotifyListenersOfPropertyChange (Brush::ChangedProperty, NULL);
1122 }
1123
1124 //
1125 // VisualBrush
1126 //
1127
1128 VisualBrush::VisualBrush ()
1129 {
1130         SetObjectType (Type::VISUALBRUSH);
1131 }
1132
1133 VisualBrush::~VisualBrush ()
1134 {
1135 }
1136
1137 void
1138 VisualBrush::SetupBrush (cairo_t *cr, const Rect &area)
1139 {
1140         UIElement *ui = (UIElement *) GetVisual ();
1141         if (!ui) {
1142                 // not yet available, draw gray-ish shadow where the brush should be applied
1143                 cairo_set_source_rgba (cr, 0.5, 0.5, 0.5, 0.5);
1144                 return;
1145         }
1146
1147         // XXX we should cache the surface so that it can be
1148         // used multiple times without having to re-render each time.
1149         Rect bounds = ui->GetSubtreeBounds().RoundOut ();
1150
1151         surface = image_brush_create_similar (cr, (int) bounds.width, (int) bounds.height);
1152
1153         cairo_t *surface_cr = cairo_create (surface);
1154         Region region = Region (0, 0, bounds.width, bounds.height);
1155         ui->Render (surface_cr, &region);
1156         cairo_destroy (surface_cr);
1157
1158         Stretch stretch = GetStretch ();
1159
1160         AlignmentX ax = GetAlignmentX ();
1161         AlignmentY ay = GetAlignmentY ();
1162
1163         Transform *transform = GetTransform ();
1164         Transform *relative_transform = GetRelativeTransform ();
1165
1166         cairo_pattern_t *pattern = cairo_pattern_create_for_surface (surface);
1167         cairo_matrix_t matrix;
1168         image_brush_compute_pattern_matrix (&matrix, area.width, area.height,
1169                                             (int) bounds.width, (int) bounds.height,
1170                                             stretch, ax, ay, transform, relative_transform);
1171
1172         cairo_matrix_translate (&matrix, -area.x, -area.y);
1173         cairo_pattern_set_matrix (pattern, &matrix);
1174
1175         cairo_set_source (cr, pattern);
1176         cairo_pattern_destroy (pattern);
1177
1178         cairo_surface_destroy (surface);
1179 }
1180
1181 void
1182 VisualBrush::update_brush (EventObject *, EventArgs *, gpointer closure)
1183 {
1184         VisualBrush *b = (VisualBrush*)closure;
1185         b->NotifyListenersOfPropertyChange (Brush::ChangedProperty, NULL);
1186 }
1187
1188 void
1189 VisualBrush::OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error)
1190 {
1191         if (args->GetProperty ()->GetOwnerType() != Type::VISUALBRUSH) {
1192                 TileBrush::OnPropertyChanged (args, error);
1193                 return;
1194         }
1195
1196         if (args->GetId () == VisualBrush::VisualProperty) {
1197                 // XXX we really need a way to disconnect from the preview visual
1198                 UIElement *v = args->GetNewValue()->AsUIElement();
1199                 v->AddHandler (((UIElement*)v)->InvalidatedEvent, update_brush, this);
1200         }
1201
1202         NotifyListenersOfPropertyChange (args, error);
1203 }
1204
1205 bool
1206 VisualBrush::IsOpaque ()
1207 {
1208         // XXX punt for now and return false here.
1209         return false;
1210 }