src/uielement.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * uielement.cpp
   4  *
   5  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   6  *
   7  * See the LICENSE file included with the distribution for details.
   8  *
   9  */
  10
  11 #include <config.h>
  12
  13 #include <stdlib.h>
  14 #include <math.h>
  15
  16 #include "trigger.h"
  17 #include "uielement.h"
  18 #include "collection.h"
  19 #include "canvas.h"
  20 #include "brush.h"
  21 #include "transform.h"
  22 #include "runtime.h"
  23 #include "geometry.h"
  24 #include "shape.h"
  25 #include "dirty.h"
  26 #include "eventargs.h"
  27 #include "timemanager.h"
  28 #include "media.h"
  29 #include "resources.h"
  30 #include "popup.h"
  31 #include "provider.h"
  32
  33 //#define DEBUG_INVALIDATE 0
  34 #define MIN_FRONT_TO_BACK_COUNT 25
  35
  36 UIElement::UIElement ()
  37 {
  38         SetObjectType (Type::UIELEMENT);
  39
  40         visual_level = 0;
  41         visual_parent = NULL;
  42         subtree_object = NULL;
  43         opacityMask = NULL;
  44
  45         flags = UIElement::RENDER_VISIBLE | UIElement::HIT_TEST_VISIBLE;
  46
  47         hidden_desire = Size (-INFINITY, -INFINITY);
  48         bounds = Rect (0,0,0,0);
  49         cairo_matrix_init_identity (&absolute_xform);
  50
  51         emitting_loaded = false;
  52         dirty_flags = DirtyMeasure;
  53         up_dirty_node = down_dirty_node = NULL;
  54         force_invalidate_of_new_bounds = false;
  55         dirty_region = new Region ();
  56
  57         desired_size = Size (0, 0);
  58         render_size = Size (0, 0);
  59
  60         ComputeLocalTransform ();
  61         ComputeTotalRenderVisibility ();
  62         ComputeTotalHitTestVisibility ();
  63 }
  64
  65 UIElement::~UIElement()
  66 {
  67         delete dirty_region;
  68 }
  69
  70 bool
  71 UIElement::IsSubtreeLoaded (UIElement *element)
  72 {
  73         while (element && !element->IsLoaded ())
  74                 element = element->GetVisualParent ();
  75         return element;
  76 }
  77
  78 void
  79 UIElement::Dispose()
  80 {
  81         TriggerCollection *triggers = GetTriggers ();
  82
  83         if (triggers != NULL) {
  84                 for (int i = 0; i < triggers->GetCount (); i++)
  85                         triggers->GetValueAt (i)->AsEventTrigger ()->RemoveTarget (this);
  86         }
  87
  88         if (!IsDisposed ()) {
  89                 VisualTreeWalker walker (this);
  90                 while (UIElement *child = walker.Step ())
  91                         child->SetVisualParent (NULL);
  92         }
  93
  94         if (subtree_object) {
  95                 subtree_object->unref ();
  96                 subtree_object = NULL;
  97         }
  98
  99         DependencyObject::Dispose();
 100 }
 101
 102 void
 103 UIElement::SetSurface (Surface *s)
 104 {
 105         if (GetSurface() == s)
 106                 return;
 107
 108         if (s == NULL && GetSurface()) {
 109                 /* we're losing our surface, delete ourselves from the dirty list if we're on it */
 110                 GetSurface()->RemoveDirtyElement (this);
 111         }
 112
 113         if (subtree_object != NULL && subtree_object->Is(Type::UIELEMENT))
 114                 subtree_object->SetSurface (s);
 115
 116         DependencyObject::SetSurface (s);
 117 }
 118
 119 Rect
 120 UIElement::IntersectBoundsWithClipPath (Rect unclipped, bool transform)
 121 {
 122         Geometry *clip = GetClip ();
 123         Geometry *layout_clip = transform ? NULL : LayoutInformation::GetLayoutClip (this);
 124         Rect box;
 125
 126         if (!clip && !layout_clip)
 127                 return unclipped;
 128
 129         if (clip)
 130                 box = clip->GetBounds ();
 131         else
 132                 box = layout_clip->GetBounds ();
 133
 134         if (layout_clip)
 135                 box = box.Intersection (layout_clip->GetBounds());
 136
 137         if (!GetRenderVisible())
 138                 box = Rect (0,0,0,0);
 139
 140         if (transform)
 141                 box = box.Transform (&absolute_xform);
 142
 143         return box.Intersection (unclipped);
 144 }
 145
 146 void
 147 UIElement::RenderClipPath (cairo_t *cr, bool path_only)
 148 {
 149         cairo_new_path (cr);
 150         cairo_set_matrix (cr, &absolute_xform);
 151
 152         Geometry *geometry = GetClip();
 153         if (!geometry)
 154                 return;
 155
 156         geometry->Draw (cr);
 157         if (!path_only)
 158                 cairo_clip (cr);
 159 }
 160
 161 void
 162 UIElement::OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error)
 163 {
 164         if (args->GetProperty ()->GetOwnerType() != Type::UIELEMENT) {
 165                 DependencyObject::OnPropertyChanged (args, error);
 166                 return;
 167         }
 168
 169         if (args->GetId () == UIElement::OpacityProperty) {
 170                 InvalidateVisibility ();
 171         } else if (args->GetId () == UIElement::VisibilityProperty) {
 172                 // note: invalid enum values are only validated in 1.1 (managed code),
 173                 // the default value for VisibilityProperty is VisibilityCollapsed
 174                 // (see bug #340799 for more details)
 175                 if (args->GetNewValue()->AsInt32() == VisibilityVisible)
 176                         flags |= UIElement::RENDER_VISIBLE;
 177                 else
 178                         flags &= ~UIElement::RENDER_VISIBLE;
 179
 180                 InvalidateVisibility ();
 181                 InvalidateMeasure ();
 182                 if (GetVisualParent ())
 183                         GetVisualParent ()->InvalidateMeasure ();
 184         } else if (args->GetId () == UIElement::IsHitTestVisibleProperty) {
 185                 if (args->GetNewValue()->AsBool())
 186                         flags |= UIElement::HIT_TEST_VISIBLE;
 187                 else
 188                         flags &= ~UIElement::HIT_TEST_VISIBLE;
 189
 190                 UpdateTotalHitTestVisibility();
 191         } else if (args->GetId () == UIElement::ClipProperty) {
 192                 InvalidateClip ();
 193         } else if (args->GetId () == UIElement::OpacityMaskProperty) {
 194                 opacityMask = args->GetNewValue() ? args->GetNewValue()->AsBrush() : NULL;
 195                 InvalidateMask ();
 196         } else if (args->GetId () == UIElement::RenderTransformProperty
 197                    || args->GetId () == UIElement::RenderTransformOriginProperty) {
 198                 UpdateTransform ();
 199         }
 200         else if (args->GetId () == UIElement::TriggersProperty) {
 201                 if (args->GetOldValue()) {
 202                         // remove the old trigger targets
 203                         TriggerCollection *triggers = args->GetOldValue()->AsTriggerCollection();
 204                         for (int i = 0; i < triggers->GetCount (); i++)
 205                                 triggers->GetValueAt (i)->AsEventTrigger ()->RemoveTarget (this);
 206                 }
 207
 208                 if (args->GetNewValue()) {
 209                         // set the new ones
 210                         TriggerCollection *triggers = args->GetNewValue()->AsTriggerCollection();
 211                         for (int i = 0; i < triggers->GetCount (); i++)
 212                                 triggers->GetValueAt (i)->AsEventTrigger ()->SetTarget (this);
 213                 }
 214         } else if (args->GetId () == UIElement::UseLayoutRoundingProperty) {
 215                 InvalidateMeasure ();
 216                 InvalidateArrange ();
 217         }
 218
 219         NotifyListenersOfPropertyChange (args, error);
 220 }
 221
 222 void
 223 UIElement::OnCollectionChanged (Collection *col, CollectionChangedEventArgs *args)
 224 {
 225         if (col == GetTriggers ()) {
 226                 switch (args->GetChangedAction()) {
 227                 case CollectionChangedActionReplace:
 228                         args->GetOldItem()->AsEventTrigger ()->RemoveTarget (this);
 229                         // fall thru to Add
 230                 case CollectionChangedActionAdd:
 231                         args->GetNewItem()->AsEventTrigger ()->SetTarget (this);
 232                         break;
 233                 case CollectionChangedActionRemove:
 234                         args->GetOldItem()->AsEventTrigger ()->RemoveTarget (this);
 235                         break;
 236                 case CollectionChangedActionClearing:
 237                         for (int i = 0; i < col->GetCount (); i++)
 238                                 col->GetValueAt (i)->AsEventTrigger ()->RemoveTarget (this);
 239                         break;
 240                 case CollectionChangedActionCleared:
 241                         // nothing needed here.
 242                         break;
 243                 }
 244         }
 245         else {
 246                 DependencyObject::OnCollectionChanged (col, args);
 247         }
 248 }
 249
 250 #if 1
 251 int
 252 UIElement::DumpHierarchy (UIElement *obj)
 253 {
 254         if (obj == NULL)
 255                 return 0;
 256
 257         int n = DumpHierarchy (obj->GetVisualParent ());
 258         for (int i = 0; i < n; i++)
 259                 putchar (' ');
 260         printf ("%s (%p)\n", obj->GetTypeName(), obj);
 261         return n + 4;
 262 }
 263 #endif
 264
 265 void
 266 UIElement::UpdateBounds (bool force_redraw)
 267 {
 268         //InvalidateMeasure ();
 269         //InvalidateArrange ();
 270
 271         Surface *surface = GetSurface ();
 272         if (surface)
 273                 surface->AddDirtyElement (this, DirtyBounds);
 274
 275         force_invalidate_of_new_bounds |= force_redraw;
 276 }
 277
 278 void
 279 UIElement::UpdateTotalRenderVisibility ()
 280 {
 281         Surface *surface = GetSurface ();
 282         if (surface)
 283                 surface->AddDirtyElement (this, DirtyRenderVisibility);
 284 }
 285
 286 void
 287 UIElement::UpdateTotalHitTestVisibility ()
 288 {
 289         VisualTreeWalker walker (this);
 290         while (UIElement *child = walker.Step ())
 291                 child->UpdateTotalHitTestVisibility ();
 292
 293         if (GetSurface())
 294                 GetSurface ()->AddDirtyElement (this, DirtyHitTestVisibility);
 295 }
 296
 297 bool
 298 UIElement::GetActualTotalRenderVisibility ()
 299 {
 300         bool visible = (flags & UIElement::RENDER_VISIBLE) != 0;
 301         bool parent_visible = true;
 302
 303         total_opacity = GetOpacity ();
 304
 305         if (GetVisualParent ()) {
 306                 GetVisualParent ()->ComputeTotalRenderVisibility ();
 307                 parent_visible = visible && GetVisualParent ()->GetRenderVisible ();
 308                 total_opacity *= GetVisualParent ()->total_opacity;
 309         }
 310
 311         visible = visible && parent_visible;
 312
 313         return visible;
 314 }
 315
 316 void
 317 UIElement::ComputeTotalRenderVisibility ()
 318 {
 319         if (GetActualTotalRenderVisibility ())
 320                 flags |= UIElement::TOTAL_RENDER_VISIBLE;
 321         else
 322                 flags &= ~UIElement::TOTAL_RENDER_VISIBLE;
 323 }
 324
 325 bool
 326 UIElement::GetActualTotalHitTestVisibility ()
 327 {
 328         bool visible = (flags & UIElement::HIT_TEST_VISIBLE) != 0;
 329
 330         if (visible && GetVisualParent ()) {
 331                 GetVisualParent ()->ComputeTotalHitTestVisibility ();
 332                 visible = visible && GetVisualParent ()->GetHitTestVisible ();
 333         }
 334
 335         return visible;
 336 }
 337
 338 void
 339 UIElement::ComputeTotalHitTestVisibility ()
 340 {
 341         if (GetActualTotalHitTestVisibility ())
 342                 flags |= UIElement::TOTAL_HIT_TEST_VISIBLE;
 343         else
 344                 flags &= ~UIElement::TOTAL_HIT_TEST_VISIBLE;
 345 }
 346
 347 void
 348 UIElement::UpdateTransform ()
 349 {
 350         if (GetSurface()) {
 351                 GetSurface()->AddDirtyElement (this, DirtyLocalTransform);
 352         }
 353 }
 354
 355 void
 356 UIElement::ComputeLocalTransform ()
 357 {
 358         Transform *transform = GetRenderTransform ();
 359         Point transform_origin = GetTransformOrigin ();
 360         cairo_matrix_t render;
 361
 362         cairo_matrix_init_identity (&render);
 363         cairo_matrix_init_identity (&local_xform);
 364
 365         if (transform == NULL)
 366                 return;
 367
 368         transform->GetTransform (&render);
 369         cairo_matrix_translate (&local_xform, transform_origin.x, transform_origin.y);
 370         cairo_matrix_multiply (&local_xform, &render, &local_xform);
 371         cairo_matrix_translate (&local_xform, -transform_origin.x, -transform_origin.y);
 372 }
 373
 374 void
 375 UIElement::TransformBounds (cairo_matrix_t *old, cairo_matrix_t *current)
 376 {
 377         Rect updated;
 378
 379         cairo_matrix_t tween = *old;
 380         cairo_matrix_invert (&tween);
 381         cairo_matrix_multiply (&tween, &tween, current);
 382
 383         Point p0 (0,0);
 384         Point p1 (1,0);
 385         Point p2 (1,1);
 386         Point p3 (0,1);
 387
 388         p0 = p0 - p0.Transform (&tween);
 389         p1 = p1 - p1.Transform (&tween);
 390         p2 = p2 - p2.Transform (&tween);
 391         p3 = p3 - p3.Transform (&tween);
 392
 393         if (p0 == p1 && p1 == p2 && p2 == p3) {
 394                 //printf ("shifting position\n");
 395                 ShiftPosition (bounds.GetTopLeft ().Transform (&tween));
 396                 return;
 397         }
 398
 399         UpdateBounds ();
 400 }
 401
 402 void
 403 UIElement::ComputeTransform ()
 404 {
 405         cairo_matrix_t old = absolute_xform;
 406         cairo_matrix_init_identity (&absolute_xform);
 407
 408         if (GetVisualParent () != NULL) {
 409                 absolute_xform = GetVisualParent ()->absolute_xform;
 410         } else if (GetParent () != NULL && GetParent ()->Is (Type::POPUP)) {
 411                 // FIXME we shouldn't be examing a subclass type here but we'll do this
 412                 // for now to get popups in something approaching the right place while
 413                 // we figure out a cleaner way to handle it long term.
 414                 Popup *popup = (Popup *)GetParent ();
 415                 absolute_xform = popup->absolute_xform;
 416                 cairo_matrix_translate (&absolute_xform, popup->GetHorizontalOffset (), popup->GetVerticalOffset ());
 417         }
 418
 419         cairo_matrix_multiply (&absolute_xform, &layout_xform, &absolute_xform);
 420         cairo_matrix_multiply (&absolute_xform, &local_xform, &absolute_xform);
 421
 422         if (moonlight_flags & RUNTIME_INIT_USE_UPDATE_POSITION)
 423                 TransformBounds (&old, &absolute_xform);
 424         else {
 425                 UpdateBounds ();
 426         }
 427 }
 428
 429 void
 430 UIElement::ComputeBounds ()
 431 {
 432         g_warning ("UIElement:ComputeBounds has been called. The derived class %s should have overridden it.",
 433                    GetTypeName ());
 434 }
 435
 436 void
 437 UIElement::ShiftPosition (Point p)
 438 {
 439         bounds.x = p.x;
 440         bounds.y = p.y;
 441 }
 442
 443 void
 444 UIElement::OnSubPropertyChanged (DependencyProperty *prop, DependencyObject *obj, PropertyChangedEventArgs *subobj_args)
 445 {
 446         if (prop && prop->GetId () == UIElement::RenderTransformProperty) {
 447                 UpdateTransform ();
 448         }
 449         else if (prop && prop->GetId () == UIElement::ClipProperty) {
 450                 InvalidateClip ();
 451         }
 452         else if (prop && prop->GetId () == UIElement::OpacityMaskProperty) {
 453                 InvalidateMask ();
 454         }
 455
 456         DependencyObject::OnSubPropertyChanged (prop, obj, subobj_args);
 457 }
 458
 459 void
 460 UIElement::CacheInvalidateHint ()
 461 {
 462         VisualTreeWalker walker (this);
 463         while (UIElement *child = walker.Step ())
 464                 child->CacheInvalidateHint ();
 465 }
 466
 467 void
 468 UIElement::SetVisualParent (UIElement *visual_parent)
 469 {
 470         this->visual_parent = visual_parent;
 471
 472         if (visual_parent && visual_parent->GetSurface () != GetSurface())
 473                 SetSurface (visual_parent->GetSurface());
 474 }
 475
 476 void
 477 UIElement::SetSubtreeObject (DependencyObject *value)
 478 {
 479         if (subtree_object == value)
 480           return;
 481
 482         if (subtree_object)
 483           subtree_object->unref ();
 484
 485         subtree_object = value;
 486
 487         if (subtree_object)
 488           subtree_object->ref ();
 489 }
 490
 491 void
 492 UIElement::ElementRemoved (UIElement *item)
 493 {
 494         // Invalidate ourself in the size of the item's subtree
 495         Invalidate (item->GetSubtreeBounds());
 496
 497         if (GetSurface ())
 498                 GetSurface()->RemoveDirtyElement (item);
 499         item->SetVisualParent (NULL);
 500         item->CacheInvalidateHint ();
 501         item->ClearLoaded ();
 502
 503         Rect emptySlot (0,0,0,0);
 504         LayoutInformation::SetLayoutSlot (item, &emptySlot);
 505         item->ClearValue (LayoutInformation::LayoutClipProperty);
 506
 507         InvalidateMeasure ();
 508 }
 509
 510 void
 511 UIElement::ElementAdded (UIElement *item)
 512 {
 513         item->SetVisualLevel (GetVisualLevel() + 1);
 514         item->SetVisualParent (this);
 515         item->UpdateTotalRenderVisibility ();
 516         item->UpdateTotalHitTestVisibility ();
 517         //item->UpdateBounds (true);
 518         item->Invalidate ();
 519
 520         if (0 != (flags & (UIElement::IS_LOADED | UIElement::PENDING_LOADED))) {
 521                 InheritedPropertyValueProvider::PropagateInheritedPropertiesOnAddingToTree (item);
 522
 523                 bool post = false;
 524
 525                 item->WalkTreeForLoadedHandlers (&post, true, false);
 526
 527                 if (post)
 528                         Deployment::GetCurrent()->PostLoaded ();
 529         }
 530
 531         UpdateBounds (true);
 532
 533         InvalidateMeasure ();
 534         ClearValue (LayoutInformation::LayoutClipProperty);
 535         ClearValue (LayoutInformation::PreviousConstraintProperty);
 536         item->SetRenderSize (Size (0,0));
 537         item->UpdateTransform ();
 538         item->InvalidateMeasure ();
 539         item->InvalidateArrange ();
 540 }
 541
 542 void
 543 UIElement::InvalidateMeasure ()
 544 {
 545         //      g_print ("m(%s)", GetTypeName ());
 546
 547         dirty_flags |= DirtyMeasure;
 548
 549         Surface *surface;
 550         if ((surface = GetSurface ()))
 551                 surface->needs_measure = true;
 552
 553 }
 554
 555 void
 556 UIElement::InvalidateArrange ()
 557 {
 558         //g_print ("a(%s)", GetTypeName ());
 559
 560         dirty_flags |= DirtyArrange;
 561
 562         Surface *surface;
 563         if ((surface = GetSurface ()))
 564                 surface->needs_arrange = true;
 565 }
 566
 567 void
 568 UIElement::DoMeasure ()
 569 {
 570         Size *last = LayoutInformation::GetPreviousConstraint (this);
 571         UIElement *parent = GetVisualParent ();
 572         Size infinite (INFINITY, INFINITY);
 573
 574         if (!GetSurface () && !last && !parent && IsLayoutContainer ()) {
 575                 last = &infinite;
 576         }
 577
 578         if (last) {
 579                 Size previous_desired = GetDesiredSize ();
 580
 581                 // This will be a noop on non layout elements
 582                 Measure (*last);
 583
 584                 if (previous_desired == GetDesiredSize ())
 585                     return;
 586         }
 587
 588         // a canvas doesn't care about the child size changing like this
 589         if (parent)
 590                 parent->InvalidateMeasure ();
 591
 592         dirty_flags &= ~DirtyMeasure;
 593 }
 594
 595 void
 596 UIElement::DoArrange ()
 597 {
 598         Rect *last = LayoutInformation::GetLayoutSlot (this);
 599         Size previous_render = Size ();
 600         UIElement *parent = GetVisualParent ();
 601         Rect viewport;
 602
 603         if (!parent) {
 604                 Size desired = Size ();
 605                 Size available = Size ();
 606                 Surface *surface = GetSurface ();
 607
 608                 if (IsLayoutContainer ()) {
 609                         desired = GetDesiredSize ();
 610                         if (surface && surface->IsTopLevel (this) && !GetParent ()) {
 611                                 Size *measure = LayoutInformation::GetPreviousConstraint (this);
 612                                 if (measure)
 613                                         desired = desired.Max (*LayoutInformation::GetPreviousConstraint (this));
 614                                 else
 615                                         desired = Size (surface->GetWindow ()->GetWidth (), surface->GetWindow ()->GetHeight ());
 616                         }
 617                 } else {
 618                         FrameworkElement *fe = (FrameworkElement*)this;
 619                         desired = Size (fe->GetActualWidth (), fe->GetActualHeight ());
 620                 }
 621
 622                 viewport = Rect (Canvas::GetLeft (this),
 623                                  Canvas::GetTop (this),
 624                                  desired.width, desired.height);
 625
 626                 last = &viewport;
 627         }
 628
 629         if (last) {
 630                 Arrange (*last);
 631         } else {
 632                 if (parent)
 633                         parent->InvalidateArrange ();
 634         }
 635 }
 636
 637 bool
 638 UIElement::InsideClip (cairo_t *cr, double x, double y)
 639 {
 640         Geometry* clip;
 641         bool inside = true;
 642         double nx = x;
 643         double ny = y;
 644
 645         clip = GetClip ();
 646         if (!clip)
 647                 return true;
 648
 649         TransformPoint (&nx, &ny);
 650
 651         if (!clip->GetBounds ().PointInside (nx, ny))
 652                 return false;
 653
 654         cairo_save (cr);
 655         cairo_new_path (cr);
 656
 657         clip->Draw (cr);
 658         inside = cairo_in_fill (cr, nx, ny);
 659
 660         cairo_restore (cr);
 661
 662         return inside;
 663 }
 664
 665 bool
 666 UIElement::InsideObject (cairo_t *cr, double x, double y)
 667 {
 668         return InsideClip (cr, x, y);
 669 }
 670
 671 int
 672 UIElement::RemoveHandler (int event_id, EventHandler handler, gpointer data)
 673 {
 674         int token = DependencyObject::RemoveHandler (event_id, handler, data);
 675
 676         if (event_id == UIElement::LoadedEvent && token != -1)
 677                 Deployment::GetCurrent()->RemoveLoadedHandler (this, token);
 678
 679         return token;
 680 }
 681
 682 void
 683 UIElement::RemoveHandler (int event_id, int token)
 684 {
 685         DependencyObject::RemoveHandler (event_id, token);
 686
 687         if (event_id == UIElement::LoadedEvent)
 688                 Deployment::GetCurrent()->RemoveLoadedHandler (this, token);
 689 }
 690
 691 void
 692 UIElement::WalkTreeForLoadedHandlers (bool *post, bool only_unemitted, bool force_walk_up)
 693 {
 694         List *walk_list = new List();
 695         bool post_loaded = false;
 696         Deployment *deployment = GetDeployment ();
 697         Application *application = deployment->GetCurrentApplication ();
 698
 699         DeepTreeWalker *walker = new DeepTreeWalker (this);
 700
 701         // we need to make sure to apply the default style to all
 702         // controls in the subtree
 703         while (UIElement *element = (UIElement*)walker->Step ()) {
 704                 if (element->Is(Type::CONTROL)) {
 705                         Control *control = (Control*)element;
 706                         if (!control->default_style_applied) {
 707                                 ManagedTypeInfo *key = control->GetDefaultStyleKey ();
 708                                 if (key) {
 709                                         if (application == NULL)
 710                                                 g_warning ("attempting to use a null application when applying default style when emitting Loaded event.");
 711                                         else
 712                                                 application->ApplyDefaultStyle (control, key);
 713                                 }
 714                         }
 715
 716                         if (!control->GetTemplateRoot () /* we only need to worry about this if the template hasn't been expanded */
 717                             && control->GetTemplate())
 718                                 post_loaded = true; //control->ReadLocalValue (Control::TemplateProperty) == NULL;
 719                 }
 720
 721                 element->flags |= UIElement::PENDING_LOADED;
 722                 element->OnLoaded ();
 723                 if (element->HasHandlers (UIElement::LoadedEvent))
 724                         post_loaded = true;
 725         }
 726
 727         if (force_walk_up || !post_loaded || HasHandlers (UIElement::LoadedEvent)) {
 728                 // we need to walk back up to the root to collect all loaded events
 729                 UIElement *parent = this;
 730                 while (parent->GetVisualParent())
 731                         parent = parent->GetVisualParent();
 732                 delete walker;
 733                 walker = new DeepTreeWalker (parent, Logical/*Reverse*/);
 734         }
 735         else {
 736                 // otherwise we only copy the events from the subtree
 737                 delete walker;
 738                 walker = new DeepTreeWalker (this, Logical/*Reverse*/);
 739         }
 740
 741         while (UIElement *element = (UIElement*)walker->Step ()) {
 742                 walk_list->Prepend (new UIElementNode (element));
 743         }
 744
 745         while (UIElementNode *ui = (UIElementNode*)walk_list->First ()) {
 746                 // remove it from the walk list
 747                 walk_list->Unlink (ui);
 748
 749                 deployment->AddAllLoadedHandlers (ui->uielement, only_unemitted);
 750         }
 751
 752         if (post)
 753                 *post = post_loaded;
 754
 755         delete walker;
 756         delete walk_list;
 757 }
 758
 759
 760 void
 761 UIElement::OnLoaded ()
 762 {
 763         flags |= UIElement::IS_LOADED;
 764         flags &= ~UIElement::PENDING_LOADED;
 765 }
 766
 767 void
 768 UIElement::ClearLoaded ()
 769 {
 770         UIElement *e = NULL;
 771         Surface *s = Deployment::GetCurrent ()->GetSurface ();
 772         if (s->GetFocusedElement () == this)
 773                 s->FocusElement (NULL);
 774
 775         ClearForeachGeneration (UIElement::LoadedEvent);
 776
 777         if (!IsLoaded ())
 778                 return;
 779
 780         flags &= ~UIElement::IS_LOADED;
 781
 782         VisualTreeWalker walker (this);
 783         while ((e = walker.Step ()))
 784                 e->ClearLoaded ();
 785 }
 786
 787 bool
 788 UIElement::Focus (bool recurse)
 789 {
 790         return false;
 791 }
 792
 793 //
 794 // Queues the invalidate for the current region, performs any
 795 // updates to the RenderTransform (optional) and queues a
 796 // new redraw with the new bounding box
 797 //
 798 void
 799 UIElement::FullInvalidate (bool rendertransform)
 800 {
 801         Invalidate ();
 802         if (rendertransform)
 803                 UpdateTransform ();
 804         UpdateBounds (true /* force an invalidate here, even if the bounds don't change */);
 805 }
 806
 807 void
 808 UIElement::Invalidate (Rect r)
 809 {
 810         if (!GetRenderVisible() || IS_INVISIBLE(total_opacity))
 811                 return;
 812
 813 #ifdef DEBUG_INVALIDATE
 814         printf ("Requesting invalidate for object %p %s (%s) at %f %f - %f %f\n",
 815                 this, GetName(), GetTypeName(),
 816                 r.x, r.y,
 817                 r.w, r.h);
 818 #endif
 819
 820
 821         if (GetSurface ()) {
 822                 GetSurface()->AddDirtyElement (this, DirtyInvalidate);
 823
 824                 dirty_region->Union (r);
 825
 826                 GetSurface()->GetTimeManager()->NeedRedraw ();
 827
 828                 Emit (InvalidatedEvent);
 829         }
 830 }
 831
 832 void
 833 UIElement::Invalidate (Region *region)
 834 {
 835         if (!GetRenderVisible () || IS_INVISIBLE (total_opacity))
 836                 return;
 837
 838         if (GetSurface ()) {
 839                 GetSurface()->AddDirtyElement (this, DirtyInvalidate);
 840
 841                 dirty_region->Union (region);
 842
 843                 GetSurface()->GetTimeManager()->NeedRedraw ();
 844
 845                 Emit (InvalidatedEvent);
 846         }
 847 }
 848
 849 void
 850 UIElement::Invalidate ()
 851 {
 852         Invalidate (bounds);
 853 }
 854
 855 /*
 856 void
 857 UIElement::InvalidatePaint ()
 858 {
 859         Invalidate ();
 860 }
 861 */
 862
 863 void
 864 UIElement::InvalidateSubtreePaint ()
 865 {
 866         Invalidate (GetSubtreeBounds ());
 867 }
 868
 869 void
 870 UIElement::InvalidateClip ()
 871 {
 872         InvalidateSubtreePaint ();
 873         UpdateBounds (true);
 874 }
 875
 876 void
 877 UIElement::InvalidateMask ()
 878 {
 879         InvalidateSubtreePaint ();
 880 }
 881
 882 void
 883 UIElement::InvalidateVisibility ()
 884 {
 885         UpdateTotalRenderVisibility ();
 886         InvalidateSubtreePaint ();
 887 }
 888
 889 /*
 890 void
 891 UIElement::InvalidateIntrisicSize ()
 892 {
 893         InvalidateMeasure ();
 894         InvalidateArrange ();
 895         UpdateBounds (true);
 896 }
 897 */
 898
 899 void
 900 UIElement::HitTest (cairo_t *cr, Point p, List *uielement_list)
 901 {
 902         uielement_list->Prepend (new UIElementNode (this));
 903 }
 904
 905 void
 906 UIElement::HitTest (cairo_t *cr, Rect r, List *uielement_list)
 907 {
 908 }
 909
 910 void
 911 UIElement::FindElementsInHostCoordinates_p (Point p, HitTestCollection *uielement_list)
 912 {
 913         List *list = new List ();
 914         cairo_t *ctx = measuring_context_create ();
 915
 916         FindElementsInHostCoordinates (ctx, p, list);
 917
 918         UIElementNode *node = (UIElementNode *) list->First ();
 919         while (node) {
 920                 uielement_list->Add (new Value (node->uielement));
 921                 node = (UIElementNode *) node->next;
 922         }
 923
 924         delete list;
 925         measuring_context_destroy (ctx);
 926 }
 927
 928
 929 void
 930 UIElement::FindElementsInHostCoordinates (cairo_t *cr, Point P, List *uielement_list)
 931 {
 932         uielement_list->Prepend (new UIElementNode (this));
 933 }
 934
 935
 936 void
 937 UIElement::FindElementsInHostCoordinates_r (Rect r, HitTestCollection *uielement_list)
 938 {
 939         List *list = new List ();
 940         cairo_t *ctx = measuring_context_create ();
 941
 942         FindElementsInHostCoordinates (ctx, r, list);
 943
 944         UIElementNode *node = (UIElementNode *) list->First ();
 945         while (node) {
 946                 uielement_list->Add (new Value (node->uielement));
 947                 node = (UIElementNode *) node->next;
 948         }
 949
 950         delete list;
 951         measuring_context_destroy (ctx);
 952 }
 953
 954 void
 955 UIElement::FindElementsInHostCoordinates (cairo_t *cr, Rect r, List *uielement_list)
 956 {
 957         uielement_list->Prepend (new UIElementNode (this));
 958 }
 959
 960 bool
 961 UIElement::EmitKeyDown (GdkEventKey *event)
 962 {
 963         return Emit (KeyDownEvent, new KeyEventArgs (event));
 964 }
 965
 966 bool
 967 UIElement::EmitKeyUp (GdkEventKey *event)
 968 {
 969         return Emit (KeyUpEvent, new KeyEventArgs (event));
 970 }
 971
 972 bool
 973 UIElement::EmitGotFocus ()
 974 {
 975         return Emit (GotFocusEvent, new RoutedEventArgs (this));
 976 }
 977
 978 bool
 979 UIElement::EmitLostFocus ()
 980 {
 981         return Emit (LostFocusEvent, new RoutedEventArgs (this));
 982 }
 983
 984 bool
 985 UIElement::EmitLostMouseCapture ()
 986 {
 987         MouseEventArgs *e = new MouseEventArgs ();
 988         e->SetSource (this);
 989         return Emit (LostMouseCaptureEvent, e);
 990 }
 991
 992 bool
 993 UIElement::CaptureMouse ()
 994 {
 995         Surface *s = GetSurface ();
 996         if (s == NULL)
 997                 return false;
 998
 999         return s->SetMouseCapture (this);
1000 }
1001
1002 void
1003 UIElement::ReleaseMouseCapture ()
1004 {
1005         Surface *s = GetSurface ();
1006         if (s == NULL)
1007                 return;
1008
1009         s->ReleaseMouseCapture (this);
1010 }
1011
1012 void
1013 UIElement::DoRender (cairo_t *cr, Region *parent_region)
1014 {
1015         Region *region = new Region (GetSubtreeBounds ());
1016         region->Intersect (parent_region);
1017
1018         if (!GetRenderVisible() || IS_INVISIBLE (total_opacity) || region->IsEmpty ()) {
1019                 delete region;
1020                 return;
1021         }
1022
1023 #if FRONT_TO_BACK_STATS
1024         GetSurface()->uielements_rendered_back_to_front ++;
1025 #endif
1026
1027         STARTTIMER (UIElement_render, Type::Find (GetObjectType())->name);
1028
1029         PreRender (cr, region, false);
1030
1031         Render (cr, region);
1032
1033         PostRender (cr, region, false);
1034
1035         ENDTIMER (UIElement_render, Type::Find (GetObjectType())->name);
1036
1037         delete region;
1038 }
1039
1040 bool
1041 UIElement::UseBackToFront ()
1042 {
1043         return VisualTreeWalker (this).GetCount () < MIN_FRONT_TO_BACK_COUNT;
1044 }
1045
1046 void
1047 UIElement::FrontToBack (Region *surface_region, List *render_list)
1048 {
1049         double local_opacity = GetOpacity ();
1050
1051         if (surface_region->RectIn (GetSubtreeBounds().RoundOut()) == GDK_OVERLAP_RECTANGLE_OUT)
1052                 return;
1053
1054         if (!GetRenderVisible ()
1055             || IS_INVISIBLE (local_opacity))
1056                 return;
1057
1058         if (!UseBackToFront ()) {
1059                 Region *self_region = new Region (surface_region);
1060                 self_region->Intersect (GetSubtreeBounds().RoundOut());
1061
1062                 // we need to include our children in this one, since
1063                 // we'll be rendering them in the PostRender method.
1064                 if (!self_region->IsEmpty())
1065                         render_list->Prepend (new RenderNode (this, self_region, true,
1066                                                               UIElement::CallPreRender, UIElement::CallPostRender));
1067                 // don't remove the region from surface_region because
1068                 // there are likely holes in it
1069                 return;
1070         }
1071
1072         Region *region;
1073         bool delete_region;
1074         bool can_subtract_self;
1075
1076         if (!GetClip ()
1077             && !GetOpacityMask ()
1078             && !IS_TRANSLUCENT (GetOpacity ())) {
1079                 region = surface_region;
1080                 delete_region = false;
1081                 can_subtract_self = true;
1082         }
1083         else {
1084                 region = new Region (surface_region);
1085                 delete_region = true;
1086                 can_subtract_self = false;
1087         }
1088
1089         RenderNode *cleanup_node = new RenderNode (this, NULL, false, NULL, UIElement::CallPostRender);
1090
1091         render_list->Prepend (cleanup_node);
1092
1093         Region *self_region = new Region (region);
1094
1095         VisualTreeWalker walker (this, ZReverse);
1096         while (UIElement *child = walker.Step ())
1097                 child->FrontToBack (region, render_list);
1098
1099         if (!GetOpacityMask () && !IS_TRANSLUCENT (local_opacity)) {
1100                 delete self_region;
1101                 if (GetRenderBounds().IsEmpty ()) {  // empty bounds mean that this element draws nothing itself
1102                         self_region = new Region ();
1103                 }
1104                 else {
1105                         self_region = new Region (region);
1106                         self_region->Intersect (GetRenderBounds().RoundOut ()); // note the RoundOut
1107                 }
1108         } else {
1109                 self_region->Intersect (GetSubtreeBounds().RoundOut ()); // note the RoundOut
1110         }
1111
1112         if (self_region->IsEmpty() && render_list->First() == cleanup_node) {
1113                 /* we don't intersect the surface region, and none of
1114                    our children did either, remove the cleanup node */
1115                 render_list->Remove (render_list->First());
1116                 delete self_region;
1117                 if (delete_region)
1118                         delete region;
1119                 return;
1120         }
1121
1122         render_list->Prepend (new RenderNode (this, self_region, !self_region->IsEmpty(), UIElement::CallPreRender, NULL));
1123
1124         if (!self_region->IsEmpty()) {
1125                 if (((absolute_xform.yx == 0 && absolute_xform.xy == 0) /* no skew/rotation */
1126                      || (absolute_xform.xx == 0 && absolute_xform.yy == 0)) /* allow 90 degree rotations */
1127                     && can_subtract_self)
1128                         region->Subtract (GetCoverageBounds ());
1129         }
1130
1131         if (delete_region)
1132                 delete region;
1133 }
1134
1135 void
1136 UIElement::PreRender (cairo_t *cr, Region *region, bool skip_children)
1137 {
1138         double local_opacity = GetOpacity ();
1139
1140         cairo_save (cr);
1141
1142         cairo_set_matrix (cr, &absolute_xform);
1143         RenderClipPath (cr);
1144
1145         if (opacityMask || IS_TRANSLUCENT (local_opacity)) {
1146                 Rect r = GetSubtreeBounds ().RoundOut();
1147                 cairo_identity_matrix (cr);
1148
1149                 // we need this check because ::PreRender can (and
1150                 // will) be called for elements with empty regions.
1151                 //
1152                 // The region passed in here is the redraw region
1153                 // intersected with the render bounds of a given
1154                 // element.  For Panels with no width/height specified
1155                 // in the xaml, this region will be empty. (check
1156                 // panel.cpp::FrontToBack - we insert the ::PreRender
1157                 // calling node if either the panel background or any
1158                 // of the children intersect the redraw region.)  We
1159                 // can't clip to the empty region, obviously, as it
1160                 // will keep all descendents from drawing to the
1161                 // screen.
1162                 //
1163                 if (!region->IsEmpty()) {
1164                         region->Draw (cr);
1165                         cairo_clip (cr);
1166                 }
1167                 r.Draw (cr);
1168                 cairo_clip (cr);
1169         }
1170         cairo_set_matrix (cr, &absolute_xform);
1171
1172         /*
1173         if (ClipToExtents ()) {
1174                 extents.Draw (cr);
1175                 cairo_clip (cr);
1176         }
1177         */
1178
1179         if (IS_TRANSLUCENT (local_opacity))
1180                 cairo_push_group (cr);
1181
1182         if (opacityMask != NULL)
1183                 cairo_push_group (cr);
1184 }
1185
1186 void
1187 UIElement::PostRender (cairo_t *cr, Region *region, bool front_to_back)
1188 {
1189         // if we didn't render front to back, then render the children here
1190         if (!front_to_back) {
1191                 VisualTreeWalker walker (this, ZForward);
1192                 while (UIElement *child = walker.Step ())
1193                         child->DoRender (cr, region);
1194         }
1195
1196         double local_opacity = GetOpacity ();
1197
1198         if (opacityMask != NULL) {
1199                 cairo_pattern_t *mask;
1200                 cairo_pattern_t *data = cairo_pop_group (cr);
1201                 Point p = GetOriginPoint ();
1202                 Rect area = Rect (p.x, p.y, 0.0, 0.0);
1203                 GetSizeForBrush (cr, &(area.width), &(area.height));
1204                 opacityMask->SetupBrush (cr, area);
1205                 mask = cairo_get_source (cr);
1206                 cairo_pattern_reference (mask);
1207                 cairo_set_source (cr, data);
1208                 cairo_mask (cr, mask);
1209                 cairo_pattern_destroy (mask);
1210                 cairo_pattern_destroy (data);
1211         }
1212
1213         if (IS_TRANSLUCENT (local_opacity)) {
1214                 cairo_pop_group_to_source (cr);
1215                 cairo_paint_with_alpha (cr, local_opacity);
1216         }
1217
1218         cairo_restore (cr);
1219
1220         if (moonlight_flags & RUNTIME_INIT_SHOW_CLIPPING) {
1221                 cairo_save (cr);
1222                 cairo_new_path (cr);
1223                 cairo_set_matrix (cr, &absolute_xform);
1224                 cairo_set_line_width (cr, 1);
1225
1226                 Geometry *geometry = GetClip ();
1227                 if (geometry) {
1228                         geometry->Draw (cr);
1229                         cairo_set_source_rgba (cr, 0.0, 1.0, 1.0, 1.0);
1230                         cairo_stroke (cr);
1231                 }
1232
1233                 geometry = LayoutInformation::GetClip ((FrameworkElement *)this);
1234                 if (geometry) {
1235                         geometry->Draw (cr);
1236                         cairo_set_source_rgba (cr, 0.0, 0.0, 1.0, 1.0);
1237                         cairo_stroke (cr);
1238                 }
1239
1240                 cairo_restore (cr);
1241         }
1242
1243         if (moonlight_flags & RUNTIME_INIT_SHOW_BOUNDING_BOXES) {
1244                 cairo_save (cr);
1245                 cairo_new_path (cr);
1246                 //RenderClipPath (cr);
1247                 cairo_identity_matrix (cr);
1248                 cairo_set_source_rgba (cr, 1.0, 0.5, 0.2, 1.0);
1249                 cairo_set_line_width (cr, 1);
1250                 cairo_rectangle (cr, bounds.x + .5, bounds.y + .5, bounds.width - .5, bounds.height - .5);
1251                 cairo_stroke (cr);
1252                 cairo_restore (cr);
1253         }
1254 }
1255
1256 void
1257 UIElement::Paint (cairo_t *ctx,  Region *region, cairo_matrix_t *xform)
1258 {
1259         // FIXME xform is ignored for now
1260         if (xform)
1261                 g_warning ("passing a transform to UIElement::Paint is not yet supported");
1262
1263 #if FRONT_TO_BACK_STATS
1264         uielements_rendered_front_to_back = 0;
1265         uielements_rendered_back_to_front = 0;
1266 #endif
1267
1268         bool did_front_to_back = false;
1269         List *render_list = new List ();
1270
1271         if (moonlight_flags & RUNTIME_INIT_RENDER_FRONT_TO_BACK) {
1272                 Region *copy = new Region (region);
1273                 FrontToBack (copy, render_list);
1274
1275                 if (!render_list->IsEmpty ()) {
1276                         while (RenderNode *node = (RenderNode*)render_list->First()) {
1277 #if FRONT_TO_BACK_STATS
1278                                 uielements_rendered_front_to_back ++;
1279 #endif
1280                                 node->Render (ctx);
1281
1282                                 render_list->Remove (node);
1283                         }
1284
1285                         did_front_to_back = true;
1286                 }
1287
1288                 delete render_list;
1289                 delete copy;
1290         }
1291
1292         if (!did_front_to_back) {
1293                 DoRender (ctx, region);
1294         }
1295
1296 #if FRONT_TO_BACK_STATS
1297         printf ("UIElements rendered front-to-back for: %s(%p)\n", uielements_rendered_front_to_back, GetName (), this);
1298         printf ("UIElements rendered back-to-front for: %s(%p)\n", uielements_rendered_back_to_front, GetName (), this);
1299 #endif
1300 }
1301
1302 void
1303 UIElement::CallPreRender (cairo_t *cr, UIElement *element, Region *region, bool front_to_back)
1304 {
1305         element->PreRender (cr, region, front_to_back);
1306 }
1307
1308 void
1309 UIElement::CallPostRender (cairo_t *cr, UIElement *element, Region *region, bool front_to_back)
1310 {
1311         element->PostRender (cr, region, front_to_back);
1312 }
1313
1314 void
1315 UIElement::Render (cairo_t *cr, Region *region, bool path_only)
1316 {
1317         /* do nothing by default */
1318 }
1319
1320 void
1321 UIElement::GetSizeForBrush (cairo_t *cr, double *width, double *height)
1322 {
1323         g_warning ("UIElement:GetSizeForBrush has been called. The derived class %s should have overridden it.",
1324                    GetTypeName ());
1325         *height = *width = 0.0;
1326 }
1327
1328 TimeManager *
1329 UIElement::GetTimeManager ()
1330 {
1331         Surface *surface = GetSurface ();
1332         Deployment *deployment;
1333
1334         if (surface == NULL) {
1335                 deployment = GetDeployment ();
1336                 if (deployment != NULL)
1337                         surface = deployment->GetSurface ();
1338         }
1339
1340         return surface ? surface->GetTimeManager() : NULL;
1341 }
1342
1343 GeneralTransform *
1344 UIElement::GetTransformToUIElementWithError (UIElement *to_element, MoonError *error)
1345 {
1346         /* walk from this up to the root.  if we hit null before we hit the toplevel, it's an error */
1347         UIElement *visual = this;
1348         bool ok = false;
1349
1350         if (visual && GetSurface()) {
1351                 while (visual) {
1352                         if (GetSurface()->IsTopLevel (visual))
1353                                 ok = true;
1354                         visual = visual->GetVisualParent ();
1355                 }
1356         }
1357
1358         if (!ok || (to_element && !to_element->GetSurface ())) {
1359                 MoonError::FillIn (error, MoonError::ARGUMENT, 1001,
1360                                    "visual");
1361                 return NULL;
1362         }
1363
1364         if (to_element && !to_element->GetSurface()->IsTopLevel (to_element)) {
1365                 /* if @to_element is specified we also need to make sure there's a path to the root from it */
1366                 ok = false;
1367                 visual = to_element->GetVisualParent ();
1368                 if (visual && to_element->GetSurface()) {
1369                         while (visual) {
1370                                 if (to_element->GetSurface()->IsTopLevel (visual))
1371                                         ok = true;
1372                                 visual = visual->GetVisualParent ();
1373                         }
1374                 }
1375
1376                 if (!ok) {
1377                         MoonError::FillIn (error, MoonError::ARGUMENT, 1001,
1378                                            "visual");
1379                         return NULL;
1380                 }
1381         }
1382
1383         cairo_matrix_t result;
1384         // A = From, B = To, M = what we want
1385         // A = M * B
1386         // => M = A * inv (B)
1387         if (to_element) {
1388                 cairo_matrix_t inverse = to_element->absolute_xform;
1389                 cairo_matrix_invert (&inverse);
1390                 cairo_matrix_multiply (&result, &absolute_xform, &inverse);
1391         }
1392         else {
1393                 result = absolute_xform;
1394         }
1395
1396         Matrix *matrix  = new Matrix (&result);
1397
1398         MatrixTransform *transform = new MatrixTransform ();
1399         transform->SetValue (MatrixTransform::MatrixProperty, matrix);
1400         matrix->unref ();
1401
1402         return transform;
1403 }
1404
1405 void
1406 UIElement::TransformPoint (double *x, double *y)
1407 {
1408         cairo_matrix_t inverse = absolute_xform;
1409         cairo_matrix_invert (&inverse);
1410
1411         cairo_matrix_transform_point (&inverse, x, y);
1412 }
1413