src/textblock.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * textblock.cpp:
   4  *
   5  * Contact:
   6  *   Moonlight List (moonlight-list@lists.ximian.com)
   7  *
   8  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   9  *
  10  * See the LICENSE file included with the distribution for details.
  11  */
  12
  13 #include <config.h>
  14
  15 #include <cairo.h>
  16
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <unistd.h>
  20 #include <errno.h>
  21
  22 #include "file-downloader.h"
  23 #include "textblock.h"
  24 #include "control.h"
  25 #include "runtime.h"
  26 #include "color.h"
  27 #include "utils.h"
  28 #include "debug.h"
  29 #include "uri.h"
  30 #include "geometry.h"
  31
  32 // Unicode Line Separator (\u2028)
  33 static const char utf8_linebreak[3] = { 0xe2, 0x80, 0xa8 };
  34 #define utf8_linebreak_len 3
  35
  36
  37 //
  38 // Inline
  39 //
  40
  41 Inline::Inline ()
  42 {
  43         SetObjectType (Type::INLINE);
  44         font = new TextFontDescription ();
  45         downloaders = g_ptr_array_new ();
  46         autogen = false;
  47 }
  48
  49 Inline::~Inline ()
  50 {
  51         CleanupDownloaders ();
  52         g_ptr_array_free (downloaders, true);
  53         delete font;
  54 }
  55
  56 void
  57 Inline::CleanupDownloaders ()
  58 {
  59         Downloader *downloader;
  60         guint i;
  61
  62         for (i = 0; i < downloaders->len; i++) {
  63                 downloader = (Downloader *) downloaders->pdata[i];
  64                 downloader->RemoveHandler (Downloader::CompletedEvent, downloader_complete, this);
  65                 downloader->Abort ();
  66                 downloader->unref ();
  67         }
  68
  69         g_ptr_array_set_size (downloaders, 0);
  70 }
  71
  72 void
  73 Inline::AddFontSource (Downloader *downloader)
  74 {
  75         downloader->AddHandler (downloader->CompletedEvent, downloader_complete, this);
  76         g_ptr_array_add (downloaders, downloader);
  77         downloader->ref ();
  78
  79         if (downloader->Started () || downloader->Completed ()) {
  80                 if (downloader->Completed ())
  81                         DownloaderComplete (downloader);
  82         } else {
  83                 // This is what actually triggers the download
  84                 downloader->Send ();
  85         }
  86 }
  87
  88 void
  89 Inline::AddFontResource (const char *resource)
  90 {
  91         FontManager *manager = Deployment::GetCurrent ()->GetFontManager ();
  92         Application *application = Application::GetCurrent ();
  93         Downloader *downloader;
  94         Surface *surface;
  95         char *path;
  96         Uri *uri;
  97
  98         uri = new Uri ();
  99
 100         if (!application || !uri->Parse (resource) || !(path = application->GetResourceAsPath (GetResourceBase(), uri))) {
 101                 if ((surface = GetSurface ()) && (downloader = surface->CreateDownloader ())) {
 102                         downloader->Open ("GET", resource, FontPolicy);
 103                         AddFontSource (downloader);
 104                         downloader->unref ();
 105                 }
 106
 107                 delete uri;
 108
 109                 return;
 110         }
 111
 112         manager->AddResource (resource, path);
 113         g_free (path);
 114         delete uri;
 115 }
 116
 117 void
 118 Inline::OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error)
 119 {
 120         if (args->GetProperty ()->GetOwnerType () != Type::INLINE) {
 121                 DependencyObject::OnPropertyChanged (args, error);
 122                 return;
 123         }
 124
 125         if (args->GetId () == Inline::FontFamilyProperty) {
 126                 FontFamily *family = args->GetNewValue () ? args->GetNewValue ()->AsFontFamily () : NULL;
 127                 char **families, *fragment;
 128                 int i;
 129
 130                 CleanupDownloaders ();
 131
 132                 if (family && family->source) {
 133                         families = g_strsplit (family->source, ",", -1);
 134                         for (i = 0; families[i]; i++) {
 135                                 g_strstrip (families[i]);
 136                                 if ((fragment = strchr (families[i], '#'))) {
 137                                         // the first portion of this string is the resource name...
 138                                         *fragment = '\0';
 139                                         AddFontResource (families[i]);
 140                                 }
 141                         }
 142                         g_strfreev (families);
 143                 }
 144         }
 145
 146         NotifyListenersOfPropertyChange (args, error);
 147 }
 148
 149 void
 150 Inline::OnSubPropertyChanged (DependencyProperty *prop, DependencyObject *obj, PropertyChangedEventArgs *subobj_args)
 151 {
 152         if (prop && prop->GetId () == Inline::ForegroundProperty) {
 153                 // this isn't exactly what we want, I don't
 154                 // think... but it'll have to do.
 155                 NotifyListenersOfPropertyChange (prop, NULL);
 156         } else {
 157                 DependencyObject::OnSubPropertyChanged (prop, obj, subobj_args);
 158         }
 159 }
 160
 161 bool
 162 Inline::Equals (Inline *item)
 163 {
 164         const char *lang0, *lang1;
 165
 166         if (item->GetObjectType () != GetObjectType ())
 167                 return false;
 168
 169         if (*item->GetFontFamily () != *GetFontFamily ())
 170                 return false;
 171
 172         if (item->GetFontSize () != GetFontSize ())
 173                 return false;
 174
 175         if (item->GetFontStyle () != GetFontStyle ())
 176                 return false;
 177
 178         if (item->GetFontWeight () != GetFontWeight ())
 179                 return false;
 180
 181         if (item->GetFontStretch () != GetFontStretch ())
 182                 return false;
 183
 184         if (item->GetTextDecorations () != GetTextDecorations ())
 185                 return false;
 186
 187         lang0 = item->GetLanguage ();
 188         lang1 = GetLanguage ();
 189
 190         if ((lang0 && !lang1) || (!lang0 && lang1))
 191                 return false;
 192
 193         if (lang0 && lang1 && strcmp (lang0, lang1) != 0)
 194                 return false;
 195
 196         // this isn't really correct - we should be checking
 197         // the innards of the foreground brushes, but we're
 198         // guaranteed to never have a false positive here.
 199         if (item->GetForeground () != GetForeground ())
 200                 return false;
 201
 202         // OK, as best we can tell - they are equal
 203         return true;
 204 }
 205
 206 bool
 207 Inline::UpdateFontDescription (const char *source, bool force)
 208 {
 209         FontFamily *family = GetFontFamily ();
 210         bool changed = false;
 211
 212         if (font->SetSource (source))
 213                 changed = true;
 214
 215         if (font->SetFamily (family ? family->source : NULL))
 216                 changed = true;
 217
 218         if (font->SetStretch (GetFontStretch ()->stretch))
 219                 changed = true;
 220
 221         if (font->SetWeight (GetFontWeight ()->weight))
 222                 changed = true;
 223
 224         if (font->SetStyle (GetFontStyle ()->style))
 225                 changed = true;
 226
 227         if (font->SetSize (GetFontSize ()))
 228                 changed = true;
 229
 230         if (font->SetLanguage (GetLanguage ()))
 231                 changed = true;
 232
 233         if (force) {
 234                 font->Reload ();
 235                 return true;
 236         }
 237
 238         return changed;
 239 }
 240
 241 void
 242 Inline::downloader_complete (EventObject *sender, EventArgs *calldata, gpointer closure)
 243 {
 244         ((Inline *) closure)->DownloaderComplete ((Downloader *) sender);
 245 }
 246
 247 void
 248 Inline::DownloaderComplete (Downloader *downloader)
 249 {
 250         FontManager *manager = Deployment::GetCurrent ()->GetFontManager ();
 251         char *resource, *filename;
 252         InternalDownloader *idl;
 253         const char *path;
 254         Uri *uri;
 255
 256         // get the downloaded file path (enforces a mozilla workaround for files smaller than 64k)
 257         if (!(filename = downloader->GetDownloadedFilename (NULL)))
 258                 return;
 259
 260         g_free (filename);
 261
 262         if (!(idl = downloader->GetInternalDownloader ()))
 263                 return;
 264
 265         if (!(idl->GetObjectType () == Type::FILEDOWNLOADER))
 266                 return;
 267
 268         uri = downloader->GetUri ();
 269
 270         // If the downloaded file was a zip file, this'll get the path to the
 271         // extracted zip directory, else it will simply be the path to the
 272         // downloaded file.
 273         if (!(path = ((FileDownloader *) idl)->GetUnzippedPath ()))
 274                 return;
 275
 276         resource = uri->ToString ((UriToStringFlags) (UriHidePasswd | UriHideQuery | UriHideFragment));
 277         manager->AddResource (resource, path);
 278         g_free (resource);
 279 }
 280
 281
 282 //
 283 // Run
 284 //
 285
 286 bool
 287 Run::Equals (Inline *item)
 288 {
 289         const char *text, *itext;
 290
 291         if (!Inline::Equals (item))
 292                 return false;
 293
 294         itext = ((Run *) item)->GetText ();
 295         text = GetText ();
 296
 297         // compare the text
 298         if (text && itext && strcmp (text, itext) != 0)
 299                 return false;
 300         else if ((text && !itext) || (!text && itext))
 301                 return false;
 302
 303         return true;
 304 }
 305
 306
 307 //
 308 // TextBlock
 309 //
 310
 311 TextBlock::TextBlock ()
 312 {
 313         SetObjectType (Type::TEXTBLOCK);
 314
 315         font = new TextFontDescription ();
 316
 317         downloaders = g_ptr_array_new ();
 318         layout = new TextLayout ();
 319         font_source = NULL;
 320         source = NULL;
 321
 322         actual_height = 0.0;
 323         actual_width = 0.0;
 324         setvalue = true;
 325         was_set = false;
 326         dirty = true;
 327 }
 328
 329 TextBlock::~TextBlock ()
 330 {
 331         CleanupDownloaders (true);
 332         g_ptr_array_free (downloaders, true);
 333
 334         delete layout;
 335         delete font;
 336 }
 337
 338 void
 339 TextBlock::CleanupDownloaders (bool all)
 340 {
 341         Downloader *downloader;
 342         guint i;
 343
 344         for (i = 0; i < downloaders->len; i++) {
 345                 downloader = (Downloader *) downloaders->pdata[i];
 346
 347                 if (all || downloader != source) {
 348                         downloader->RemoveHandler (Downloader::CompletedEvent, downloader_complete, this);
 349                         downloader->Abort ();
 350                         downloader->unref ();
 351                 }
 352         }
 353
 354         g_ptr_array_set_size (downloaders, 0);
 355
 356         if (source && !all) {
 357                 g_ptr_array_add (downloaders, source);
 358         } else {
 359                 source = NULL;
 360         }
 361
 362         if (all) {
 363                 g_free (font_source);
 364                 font_source = NULL;
 365         }
 366 }
 367
 368 void
 369 TextBlock::AddFontSource (Downloader *downloader)
 370 {
 371         downloader->AddHandler (downloader->CompletedEvent, downloader_complete, this);
 372         g_ptr_array_add (downloaders, downloader);
 373         downloader->ref ();
 374
 375         if (downloader->Started () || downloader->Completed ()) {
 376                 if (downloader->Completed ())
 377                         DownloaderComplete (downloader);
 378         } else {
 379                 // This is what actually triggers the download
 380                 downloader->Send ();
 381         }
 382 }
 383
 384 void
 385 TextBlock::SetFontSource (Downloader *downloader)
 386 {
 387         CleanupDownloaders (true);
 388         source = downloader;
 389
 390         if (downloader) {
 391                 font_source = downloader->GetUri ()->ToString ((UriToStringFlags) (UriHidePasswd | UriHideQuery | UriHideFragment));
 392                 AddFontSource (downloader);
 393                 return;
 394         }
 395
 396         UpdateFontDescriptions (true);
 397         UpdateBounds (true);
 398         Invalidate ();
 399         dirty = true;
 400 }
 401
 402 void
 403 TextBlock::AddFontResource (const char *resource)
 404 {
 405         FontManager *manager = Deployment::GetCurrent ()->GetFontManager ();
 406         Application *application = Application::GetCurrent ();
 407         Downloader *downloader;
 408         Surface *surface;
 409         char *path;
 410         Uri *uri;
 411
 412         uri = new Uri ();
 413
 414         if (!application || !uri->Parse (resource) || !(path = application->GetResourceAsPath (GetResourceBase(), uri))) {
 415                 if ((surface = GetSurface ()) && (downloader = surface->CreateDownloader ())) {
 416                         downloader->Open ("GET", resource, FontPolicy);
 417                         AddFontSource (downloader);
 418                         downloader->unref ();
 419                 }
 420
 421                 delete uri;
 422
 423                 return;
 424         }
 425
 426         manager->AddResource (resource, path);
 427         g_free (path);
 428         delete uri;
 429 }
 430
 431 void
 432 TextBlock::Render (cairo_t *cr, Region *region, bool path_only)
 433 {
 434         cairo_save (cr);
 435         cairo_set_matrix (cr, &absolute_xform);
 436
 437         if (!path_only)
 438                 RenderLayoutClip (cr);
 439
 440         Paint (cr);
 441
 442         cairo_restore (cr);
 443 }
 444
 445 void
 446 TextBlock::ComputeBounds ()
 447 {
 448         Size actual (GetActualWidth (), GetActualHeight ());
 449         Size framework = ApplySizeConstraints (actual);
 450
 451         framework = framework.Max (actual);
 452
 453         Rect extents = Rect (0,0,framework.width, framework.height);
 454
 455         bounds = bounds_with_children = IntersectBoundsWithClipPath (extents, false).Transform (&absolute_xform);
 456 }
 457
 458 void
 459 TextBlock::GetSizeForBrush (cairo_t *cr, double *width, double *height)
 460 {
 461         *width = actual_width;
 462         *height = actual_height;
 463 }
 464
 465 Point
 466 TextBlock::GetTransformOrigin ()
 467 {
 468         Point *user_xform_origin = GetRenderTransformOrigin ();
 469         return Point (actual_width * user_xform_origin->x,
 470                       actual_height * user_xform_origin->y);
 471 }
 472
 473 Size
 474 TextBlock::ComputeActualSize ()
 475 {
 476         Thickness padding = *GetPadding ();
 477         Size result = FrameworkElement::ComputeActualSize ();
 478
 479         if (!LayoutInformation::GetPreviousConstraint (this)) {
 480                 Size constraint = Size (INFINITY, INFINITY);
 481
 482                 constraint = ApplySizeConstraints (constraint);
 483
 484                 constraint = constraint.GrowBy (-padding);
 485                 Layout (constraint);
 486         }
 487
 488         result = Size (actual_width, actual_height);
 489         result = result.GrowBy (padding);
 490
 491         return result;
 492 };
 493
 494 Size
 495 TextBlock::MeasureOverride (Size availableSize)
 496 {
 497         Thickness padding = *GetPadding ();
 498         Size constraint;
 499         Size desired;
 500
 501         constraint = availableSize.GrowBy (-padding);
 502         Layout (constraint);
 503
 504         desired = Size (actual_width, actual_height).GrowBy (padding);
 505
 506         SetActualHeight (desired.height);
 507         SetActualWidth (desired.width);
 508
 509         if (GetUseLayoutRounding ())
 510                 desired.width = ceil (desired.width);
 511
 512         desired = desired.Min (availableSize);
 513
 514         return desired;
 515 }
 516
 517 Size
 518 TextBlock::ArrangeOverride (Size finalSize)
 519 {
 520         Thickness padding = *GetPadding ();
 521         Size constraint;
 522         Size arranged;
 523
 524         constraint = finalSize.GrowBy (-padding);
 525         Layout (constraint);
 526
 527         arranged = Size (actual_width, actual_height).GrowBy (padding);
 528
 529         arranged = arranged.Max (finalSize);
 530         arranged = ApplySizeConstraints (arranged);
 531
 532         layout->SetAvailableWidth (arranged.GrowBy (-padding).width);
 533
 534         return arranged;
 535 }
 536
 537 void
 538 TextBlock::UpdateLayoutAttributes ()
 539 {
 540         InlineCollection *inlines = GetInlines ();
 541         TextLayoutAttributes *attrs;
 542         const char *text;
 543         int length = 0;
 544         Inline *item;
 545         List *runs;
 546
 547         InvalidateMeasure ();
 548         InvalidateArrange ();
 549         runs = new List ();
 550
 551         UpdateFontDescription (false);
 552
 553         if (inlines != NULL) {
 554                 for (int i = 0; i < inlines->GetCount (); i++) {
 555                         item = inlines->GetValueAt (i)->AsInline ();
 556                         item->UpdateFontDescription (font_source, false);
 557
 558                         switch (item->GetObjectType ()) {
 559                         case Type::RUN:
 560                                 text = ((Run *) item)->GetText ();
 561
 562                                 if (text && text[0]) {
 563                                         attrs = new TextLayoutAttributes ((ITextAttributes *) item, length);
 564                                         runs->Append (attrs);
 565
 566                                         length += strlen (text);
 567                                 }
 568
 569                                 break;
 570                         case Type::LINEBREAK:
 571                                 attrs = new TextLayoutAttributes ((ITextAttributes *) item, length);
 572                                 runs->Append (attrs);
 573
 574                                 length += utf8_linebreak_len;
 575                                 break;
 576                         default:
 577                                 break;
 578                         }
 579                 }
 580
 581                 if (inlines->GetCount () > 0)
 582                         was_set = true;
 583         }
 584
 585         layout->SetText (GetText (), length);
 586         layout->SetTextAttributes (runs);
 587 }
 588
 589 bool
 590 TextBlock::UpdateFontDescription (bool force)
 591 {
 592         FontFamily *family = GetFontFamily ();
 593         bool changed = false;
 594
 595         if (font->SetSource (font_source))
 596                 changed = true;
 597
 598         if (font->SetFamily (family ? family->source : NULL))
 599                 changed = true;
 600
 601         if (font->SetStretch (GetFontStretch ()->stretch))
 602                 changed = true;
 603
 604         if (font->SetWeight (GetFontWeight ()->weight))
 605                 changed = true;
 606
 607         if (font->SetStyle (GetFontStyle ()->style))
 608                 changed = true;
 609
 610         if (font->SetSize (GetFontSize ()))
 611                 changed = true;
 612
 613         if (font->SetLanguage (GetLanguage ()))
 614                 changed = true;
 615
 616         if (force) {
 617                 font->Reload ();
 618                 changed = true;
 619         }
 620
 621         if (changed)
 622                 layout->SetBaseFont (font->GetFont ());
 623
 624         return changed;
 625 }
 626
 627 bool
 628 TextBlock::UpdateFontDescriptions (bool force)
 629 {
 630         InlineCollection *inlines = GetInlines ();
 631         bool changed = false;
 632         Inline *item;
 633
 634         changed = UpdateFontDescription (force);
 635
 636         if (inlines != NULL) {
 637                 for (int i = 0; i < inlines->GetCount (); i++) {
 638                         item = inlines->GetValueAt (i)->AsInline ();
 639                         if (item->UpdateFontDescription (font_source, force))
 640                                 changed = true;
 641                 }
 642
 643                 if (changed)
 644                         layout->ResetState ();
 645         }
 646
 647         if (changed) {
 648                 InvalidateMeasure ();
 649                 InvalidateArrange ();
 650                 UpdateBounds (true);
 651                 dirty = true;
 652         }
 653
 654         return changed;
 655 }
 656
 657 void
 658 TextBlock::Layout (Size constraint)
 659 {
 660         if (was_set && !GetValueNoDefault (TextBlock::TextProperty)) {
 661                 // If the Text property had been set once upon a time,
 662                 // but is currently empty, Silverlight seems to set
 663                 // the ActualHeight property to the font height. See
 664                 // bug #405514 for details.
 665                 TextFontDescription *desc = new TextFontDescription ();
 666                 FontFamily *family = GetFontFamily ();
 667                 TextFont *font;
 668
 669                 desc->SetFamily (family ? family->source : NULL);
 670                 desc->SetStretch (GetFontStretch ()->stretch);
 671                 desc->SetWeight (GetFontWeight ()->weight);
 672                 desc->SetStyle (GetFontStyle ()->style);
 673                 desc->SetSize (GetFontSize ());
 674
 675                 font = desc->GetFont ();
 676                 actual_height = font->Height ();
 677                 actual_width = 0.0;
 678                 delete desc;
 679         } else if (!was_set) {
 680                 // If the Text property has never been set, then its
 681                 // extents should both be 0.0. See bug #435798 for
 682                 // details.
 683                 actual_height = 0.0;
 684                 actual_width = 0.0;
 685         } else {
 686                 layout->SetMaxWidth (constraint.width);
 687                 layout->Layout ();
 688
 689                 layout->GetActualExtents (&actual_width, &actual_height);
 690         }
 691
 692         dirty = false;
 693 }
 694
 695 void
 696 TextBlock::Paint (cairo_t *cr)
 697 {
 698         Thickness *padding = GetPadding ();
 699         Point offset (padding->left, padding->top);
 700
 701         cairo_set_matrix (cr, &absolute_xform);
 702         layout->Render (cr, GetOriginPoint (), offset);
 703
 704         if (moonlight_flags & RUNTIME_INIT_SHOW_TEXTBOXES) {
 705                 cairo_set_source_rgba (cr, 0.0, 1.0, 0.0, 1.0);
 706                 cairo_set_line_width (cr, 1);
 707                 cairo_rectangle (cr, padding->left, padding->top, actual_width, actual_height);
 708                 cairo_stroke (cr);
 709         }
 710 }
 711
 712 char *
 713 TextBlock::GetTextInternal (InlineCollection *inlines)
 714 {
 715         const char *text;
 716         GString *block;
 717         Inline *item;
 718         char *str;
 719
 720         if (!inlines)
 721                 return g_strdup ("");
 722
 723         block = g_string_new ("");
 724
 725         for (int i = 0; i < inlines->GetCount (); i++) {
 726                 item = inlines->GetValueAt (i)->AsInline ();
 727
 728                 switch (item->GetObjectType ()) {
 729                 case Type::RUN:
 730                         text = ((Run *) item)->GetText ();
 731
 732                         if (text && text[0])
 733                                 g_string_append (block, text);
 734                         break;
 735                 case Type::LINEBREAK:
 736                         g_string_append_len (block, utf8_linebreak, utf8_linebreak_len);
 737                         break;
 738                 default:
 739                         break;
 740                 }
 741         }
 742
 743         str = block->str;
 744         g_string_free (block, false);
 745
 746         return str;
 747 }
 748
 749 void
 750 TextBlock::SetTextInternal (const char *text)
 751 {
 752         InlineCollection *inlines;
 753         Value *value;
 754         Run *run;
 755
 756         // Note: calling GetValue() may cause the InlineCollection to be
 757         // autocreated, so we need to prevent reentrancy here.
 758         setvalue = false;
 759
 760         value = GetValue (TextBlock::InlinesProperty);
 761         inlines = value->AsInlineCollection ();
 762         inlines->Clear ();
 763
 764         if (text) {
 765                 run = new Run ();
 766                 run->SetAutogenerated (true);
 767                 run->SetText (text);
 768                 inlines->Add (run);
 769                 run->unref ();
 770         } else {
 771                 // setting text to null results in String.Empty
 772                 SetValue (TextBlock::TextProperty, Value (""));
 773         }
 774
 775         setvalue = true;
 776 }
 777
 778 void
 779 TextBlock::OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error)
 780 {
 781         bool invalidate = true;
 782
 783         if (args->GetProperty ()->GetOwnerType () != Type::TEXTBLOCK) {
 784                 FrameworkElement::OnPropertyChanged (args, error);
 785
 786                 if (args->GetId () == FrameworkElement::LanguageProperty) {
 787                         // a change in xml:lang might change font characteristics
 788                         if (UpdateFontDescriptions (false)) {
 789                                 InvalidateMeasure ();
 790                                 InvalidateArrange ();
 791                                 UpdateBounds (true);
 792                                 dirty = true;
 793                         }
 794                 }
 795
 796                 /*
 797                 if (args->GetId () == FrameworkElement::WidthProperty) {
 798                         //if (layout->SetMaxWidth (args->GetNewValue()->AsDouble ()))
 799                         //      dirty = true;
 800
 801                         UpdateBounds (true);
 802                 }
 803                 */
 804                 return;
 805         }
 806
 807         if (args->GetId () == TextBlock::FontFamilyProperty) {
 808                 FontFamily *family = args->GetNewValue () ? args->GetNewValue ()->AsFontFamily () : NULL;
 809                 char **families, *fragment;
 810                 int i;
 811
 812                 CleanupDownloaders (false);
 813
 814                 if (family && family->source) {
 815                         families = g_strsplit (family->source, ",", -1);
 816                         for (i = 0; families[i]; i++) {
 817                                 g_strstrip (families[i]);
 818                                 if ((fragment = strchr (families[i], '#'))) {
 819                                         // the first portion of this string is the resource name...
 820                                         *fragment = '\0';
 821                                         AddFontResource (families[i]);
 822                                 }
 823                         }
 824                         g_strfreev (families);
 825                 }
 826
 827                 if (UpdateFontDescriptions (false))
 828                         dirty = true;
 829         } else if (args->GetId () == TextBlock::FontSizeProperty) {
 830                 if (UpdateFontDescriptions (false))
 831                         dirty = true;
 832         } else if (args->GetId () == TextBlock::FontStretchProperty) {
 833                 if (UpdateFontDescriptions (false))
 834                         dirty = true;
 835         } else if (args->GetId () == TextBlock::FontStyleProperty) {
 836                 if (UpdateFontDescriptions (false))
 837                         dirty = true;
 838         } else if (args->GetId () == TextBlock::FontWeightProperty) {
 839                 if (UpdateFontDescriptions (false))
 840                         dirty = true;
 841         } else if (args->GetId () == TextBlock::TextProperty) {
 842                 if (setvalue) {
 843                         // result of a change to the TextBlock.Text property
 844                         const char *text = args->GetNewValue() ? args->GetNewValue()->AsString () : NULL;
 845
 846                         SetTextInternal (text);
 847                         UpdateLayoutAttributes ();
 848                         dirty = true;
 849                 } else {
 850                         // result of a change to the TextBlock.Inlines property
 851                         UpdateLayoutAttributes ();
 852                         invalidate = false;
 853                 }
 854         } else if (args->GetId () == TextBlock::TextDecorationsProperty) {
 855                 dirty = true;
 856         } else if (args->GetId () == TextBlock::TextWrappingProperty) {
 857                 dirty = layout->SetTextWrapping ((TextWrapping) args->GetNewValue()->AsInt32 ());
 858         } else if (args->GetId () == TextBlock::InlinesProperty) {
 859                 if (setvalue) {
 860                         // result of a change to the TextBlock.Inlines property
 861                         InlineCollection *inlines = args->GetNewValue() ? args->GetNewValue()->AsInlineCollection () : NULL;
 862
 863                         setvalue = false;
 864                         SetValue (TextBlock::TextProperty, Value (GetTextInternal (inlines), true));
 865                         setvalue = true;
 866
 867                         UpdateLayoutAttributes ();
 868                         dirty = true;
 869                 } else {
 870                         // this should be the result of Inlines being autocreated
 871                         UpdateLayoutAttributes ();
 872                         invalidate = false;
 873                 }
 874         } else if (args->GetId () == TextBlock::LineStackingStrategyProperty) {
 875                 dirty = layout->SetLineStackingStrategy ((LineStackingStrategy) args->GetNewValue()->AsInt32 ());
 876         } else if (args->GetId () == TextBlock::LineHeightProperty) {
 877                 dirty = layout->SetLineHeight (args->GetNewValue()->AsDouble ());
 878         } else if (args->GetId () == TextBlock::TextAlignmentProperty) {
 879                 dirty = layout->SetTextAlignment ((TextAlignment) args->GetNewValue()->AsInt32 ());
 880         } else if (args->GetId () == TextBlock::PaddingProperty) {
 881                 dirty = true;
 882         } else if (args->GetId () == TextBlock::FontSourceProperty) {
 883                 FontSource *source = args->GetNewValue () ? args->GetNewValue ()->AsFontSource () : NULL;
 884                 FontManager *manager = Deployment::GetCurrent ()->GetFontManager ();
 885
 886                 // FIXME: ideally we'd remove the old item from the cache (or,
 887                 // rather, 'unref' it since some other textblocks/boxes might
 888                 // still be using it).
 889
 890                 g_free (font_source);
 891
 892                 if (source && source->stream)
 893                         font_source = manager->AddResource (source->stream);
 894                 else
 895                         font_source = NULL;
 896
 897                 UpdateFontDescriptions (true);
 898                 dirty = true;
 899         }
 900
 901         if (invalidate) {
 902                 if (dirty) {
 903                         InvalidateMeasure ();
 904                         InvalidateArrange ();
 905                         UpdateBounds (true);
 906                 }
 907
 908                 Invalidate ();
 909         }
 910
 911         NotifyListenersOfPropertyChange (args, error);
 912 }
 913
 914 void
 915 TextBlock::OnSubPropertyChanged (DependencyProperty *prop, DependencyObject *obj, PropertyChangedEventArgs *subobj_args)
 916 {
 917         if (prop && prop->GetId () == TextBlock::ForegroundProperty) {
 918                 Invalidate ();
 919         } else {
 920                 FrameworkElement::OnSubPropertyChanged (prop, obj, subobj_args);
 921         }
 922 }
 923
 924 void
 925 TextBlock::OnCollectionChanged (Collection *col, CollectionChangedEventArgs *args)
 926 {
 927         InlineCollection *inlines = GetInlines ();
 928
 929         if (col != inlines) {
 930                 FrameworkElement::OnCollectionChanged (col, args);
 931                 return;
 932         }
 933
 934         if (args->GetChangedAction () == CollectionChangedActionClearing)
 935                 return;
 936
 937         if (!setvalue) {
 938                 // changes being handled elsewhere...
 939                 return;
 940         }
 941
 942         setvalue = false;
 943         SetValue (TextBlock::TextProperty, Value (GetTextInternal (inlines), true));
 944         setvalue = true;
 945
 946         UpdateLayoutAttributes ();
 947         InvalidateMeasure ();
 948         InvalidateArrange ();
 949         UpdateBounds (true);
 950         Invalidate ();
 951 }
 952
 953 void
 954 TextBlock::OnCollectionItemChanged (Collection *col, DependencyObject *obj, PropertyChangedEventArgs *args)
 955 {
 956         InlineCollection *inlines = GetInlines ();
 957
 958         if (col != inlines) {
 959                 FrameworkElement::OnCollectionItemChanged (col, obj, args);
 960                 return;
 961         }
 962
 963         if (args->GetId () != Inline::ForegroundProperty) {
 964                 if (args->GetId () == Run::TextProperty) {
 965                         // update our TextProperty
 966                         setvalue = false;
 967                         SetValue (TextBlock::TextProperty, Value (GetTextInternal (inlines), true));
 968                         setvalue = true;
 969
 970                         UpdateLayoutAttributes ();
 971                 } else {
 972                         // likely a font property change...
 973                         ((Inline *) obj)->UpdateFontDescription (font_source, true);
 974                 }
 975
 976                 // All non-Foreground property changes require
 977                 // recalculating layout which can change the bounds.
 978                 InvalidateMeasure ();
 979                 InvalidateArrange ();
 980                 UpdateBounds (true);
 981                 dirty = true;
 982         } else {
 983                 // A simple Foreground brush change does not require
 984                 // recalculating layout. Invalidate() and we're done.
 985         }
 986
 987         Invalidate ();
 988 }
 989
 990 void
 991 TextBlock::downloader_complete (EventObject *sender, EventArgs *calldata, gpointer closure)
 992 {
 993         ((TextBlock *) closure)->DownloaderComplete ((Downloader *) sender);
 994 }
 995
 996 void
 997 TextBlock::DownloaderComplete (Downloader *downloader)
 998 {
 999         FontManager *manager = Deployment::GetCurrent ()->GetFontManager ();
1000         char *resource, *filename;
1001         InternalDownloader *idl;
1002         const char *path;
1003         Uri *uri;
1004
1005         dirty = true;
1006         InvalidateMeasure ();
1007         InvalidateArrange ();
1008
1009         // get the downloaded file path (enforces a mozilla workaround for files smaller than 64k)
1010         if (!(filename = downloader->GetDownloadedFilename (NULL)))
1011                 return;
1012
1013         g_free (filename);
1014
1015         if (!(idl = downloader->GetInternalDownloader ()))
1016                 return;
1017
1018         if (!(idl->GetObjectType () == Type::FILEDOWNLOADER))
1019                 return;
1020
1021         uri = downloader->GetUri ();
1022
1023         // If the downloaded file was a zip file, this'll get the path to the
1024         // extracted zip directory, else it will simply be the path to the
1025         // downloaded file.
1026         if (!(path = ((FileDownloader *) idl)->GetUnzippedPath ()))
1027                 return;
1028
1029         resource = uri->ToString ((UriToStringFlags) (UriHidePasswd | UriHideQuery | UriHideFragment));
1030         manager->AddResource (resource, path);
1031         g_free (resource);
1032
1033         if (UpdateFontDescriptions (true)) {
1034                 dirty = true;
1035
1036                 UpdateBounds (true);
1037                 Invalidate ();
1038         }
1039 }