src/dirty.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * dirty.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 <glib.h>
  16
  17 #include "canvas.h"
  18 #include "uielement.h"
  19 #include "panel.h"
  20 #include "control.h"
  21 #include "runtime.h"
  22 #include "clock.h"
  23 #include "dirty.h"
  24 #include "list.h"
  25 #include "deployment.h"
  26
  27 class DirtyNode : public List::Node {
  28 public:
  29         DirtyNode (UIElement *element)
  30         {
  31                 this->element = element;
  32         }
  33         UIElement *element;
  34 };
  35
  36 class DirtyList : public List::Node
  37 {
  38 public:
  39         DirtyList (int level)
  40         {
  41                 this->level = level;
  42                 dirty_list = new List();
  43         }
  44
  45         ~DirtyList ()
  46         {
  47                 delete dirty_list;
  48         }
  49
  50         List* GetDirtyNodes ()
  51         {
  52                 return dirty_list;
  53         }
  54
  55         int GetLevel ()
  56         {
  57                 return level;
  58         }
  59 private:
  60         List *dirty_list;
  61         int level;
  62 };
  63
  64 DirtyLists::DirtyLists (bool ascending)
  65 {
  66         this->ascending = ascending;
  67         this->lists = new List();
  68 }
  69
  70 DirtyLists::~DirtyLists ()
  71 {
  72         delete lists;
  73 }
  74
  75 DirtyList*
  76 DirtyLists::GetList (int level, bool create)
  77 {
  78         DirtyList *dl;
  79
  80         for (dl = (DirtyList*)lists->First(); dl; dl = (DirtyList*)dl->next) {
  81                 if (dl->GetLevel() == level)
  82                         return dl;
  83                 else if (dl->GetLevel() > level)
  84                         break;
  85         }
  86
  87         if (create) {
  88                 DirtyList *new_dl = new DirtyList (level);
  89                 lists->InsertBefore (new_dl, dl);
  90                 return new_dl;
  91         }
  92
  93         return NULL;
  94 }
  95
  96 void
  97 DirtyLists::RemoveList (int level)
  98 {
  99         DirtyList *dl = (DirtyList*)GetList (level, false);
 100         if (!dl)
 101                 return;
 102         lists->Remove (dl);
 103 }
 104
 105 void
 106 DirtyLists::AddDirtyNode (int level, List::Node *node)
 107 {
 108         DirtyList *dl = (DirtyList*)GetList (level, true);
 109         dl->GetDirtyNodes()->Append(node);
 110 }
 111
 112 void
 113 DirtyLists::RemoveDirtyNode (int level, List::Node *node)
 114 {
 115         DirtyList *dl = (DirtyList*)GetList (level, false);
 116         if (!dl)
 117                 return;
 118         dl->GetDirtyNodes()->Remove(node);
 119         if (dl->GetDirtyNodes()->IsEmpty())
 120                 lists->Remove (dl);
 121 }
 122
 123 List::Node*
 124 DirtyLists::GetFirst ()
 125 {
 126         DirtyList *dl;
 127
 128         if (ascending) {
 129                 dl = (DirtyList*)lists->First();
 130         }
 131         else {
 132                 dl = (DirtyList*)lists->Last ();
 133         }
 134
 135         if (!dl)
 136                 return NULL;
 137
 138         return dl->GetDirtyNodes()->First();
 139 }
 140
 141 bool
 142 DirtyLists::IsEmpty ()
 143 {
 144         return lists->IsEmpty();
 145 }
 146
 147 void
 148 DirtyLists::Clear (bool freeNodes)
 149 {
 150         lists->Clear (freeNodes);
 151 }
 152
 153 void
 154 Surface::AddDirtyElement (UIElement *element, DirtyType dirt)
 155 {
 156         // there's no point in adding an element to the dirty list if it
 157         // isn't in the hierarchy.  it will be added to the dirty list when
 158         // it's added to the hierarchy anyway.
 159         if (element->GetVisualParent() == NULL && !IsTopLevel(element))
 160                 return;
 161
 162         // XXX this should really be here...
 163 //      if (element->dirty_flags & dirt)
 164 //              return;
 165
 166         element->dirty_flags |= dirt;
 167
 168         //printf ("adding element %p (%s) to the dirty list\n", element, element->GetTypeName());
 169
 170         if (dirt & DownDirtyState) {
 171                 if (element->down_dirty_node)
 172                         return;
 173                 element->down_dirty_node = new DirtyNode (element);
 174
 175                 down_dirty->AddDirtyNode (element->GetVisualLevel (), element->down_dirty_node);
 176         }
 177
 178         if (dirt & UpDirtyState) {
 179                 if (element->up_dirty_node)
 180                         return;
 181                 element->up_dirty_node = new DirtyNode (element);
 182
 183                 up_dirty->AddDirtyNode (element->GetVisualLevel (), element->up_dirty_node);
 184         }
 185 }
 186
 187 void
 188 Surface::RemoveDirtyElement (UIElement *element)
 189 {
 190         if (element->up_dirty_node)
 191                 up_dirty->RemoveDirtyNode (element->GetVisualLevel(), element->up_dirty_node);
 192         if (element->down_dirty_node)
 193                 down_dirty->RemoveDirtyNode (element->GetVisualLevel(), element->down_dirty_node);
 194
 195         element->down_dirty_node = NULL;
 196         element->up_dirty_node = NULL;
 197 }
 198
 199
 200 /*
 201 ** There are 2 types of changes that need to propagate around the
 202 ** tree.
 203 **
 204 ** 1. Those changes that needs to be propagated from parent to children
 205 **    (transformation, opacity).  We call these Downward Changes, and
 206 **    the elements are placed in the down_dirty list.
 207 **
 208 ** 2. Those changes that need to be propagated from children to parent
 209 **    (bounds, invalidation).  We call these Upward Changes, and the
 210 **    elements are placed in the up_dirty list.
 211 **
 212 **
 213 ** Downward Changes can result in new Upward changes (when an
 214 ** element's transform changes, usually its bounds change), so when
 215 ** processing the dirty list we push changes down the tree before
 216 ** handling the Upward Changes.
 217 **
 218 */
 219
 220 void
 221 Surface::PropagateDirtyFlagToChildren (UIElement *el, DirtyType flags)
 222 {
 223         VisualTreeWalker walker = VisualTreeWalker (el);
 224         while (UIElement *child = walker.Step ())
 225                 AddDirtyElement (child, flags);
 226 }
 227
 228 void
 229 Surface::ProcessDownDirtyElements ()
 230 {
 231         /* push down the transforms opacity, and visibility changes first */
 232         while (DirtyNode *node = (DirtyNode*)down_dirty->GetFirst()) {
 233                 UIElement* el = (UIElement*)node->element;
 234
 235                 if (el->dirty_flags & DirtyRenderVisibility) {
 236                         el->dirty_flags &= ~DirtyRenderVisibility;
 237
 238                         el->UpdateBounds ();
 239
 240                         // Since we are not included in our parents subtree when we
 241                         // are collapsed we need to notify our parent that things may
 242                         // have changed
 243                         if (el->GetVisualParent ())
 244                                 el->GetVisualParent ()->UpdateBounds ();
 245
 246                         el->ComputeTotalRenderVisibility ();
 247
 248                         if (!el->GetRenderVisible ())
 249                                 el->CacheInvalidateHint ();
 250
 251                         AddDirtyElement (el, DirtyNewBounds);
 252
 253                         PropagateDirtyFlagToChildren (el, DirtyRenderVisibility);
 254                 }
 255
 256                 if (el->dirty_flags & DirtyHitTestVisibility) {
 257                         el->dirty_flags &= ~DirtyHitTestVisibility;
 258
 259                         el->ComputeTotalHitTestVisibility ();
 260
 261                         PropagateDirtyFlagToChildren (el, DirtyHitTestVisibility);
 262                 }
 263                 /*
 264                 ** since we cache N's local (from N's parent to N)
 265                 ** transform, we need to catch if we're changing
 266                 ** something about that local transform and recompute
 267                 ** it.
 268                 **
 269                 ** DirtyLocalTransform implies DirtyTransform, since
 270                 ** changing N's local transform requires updating the
 271                 ** transform of all descendents in the subtree rooted
 272                 ** at N.
 273                 */
 274                 if (el->dirty_flags & DirtyLocalTransform) {
 275                         el->dirty_flags &= ~DirtyLocalTransform;
 276
 277                         el->dirty_flags |= DirtyTransform;
 278
 279                         el->ComputeLocalTransform ();
 280                 }
 281
 282                 if (el->dirty_flags & DirtyTransform) {
 283                         el->dirty_flags &= ~DirtyTransform;
 284
 285                         el->Invalidate ();
 286                         el->ComputeTransform ();
 287
 288                         if (el->GetVisualParent ())
 289                                 el->GetVisualParent ()->UpdateBounds ();
 290
 291                         AddDirtyElement (el, DirtyNewBounds);
 292                         PropagateDirtyFlagToChildren (el, DirtyTransform);
 293                 }
 294
 295                 if (el->dirty_flags & DirtyLocalClip) {
 296                         el->dirty_flags &= ~DirtyLocalClip;
 297                         el->dirty_flags |= DirtyClip;
 298
 299                         // XXX el->ComputeLocalClip ();
 300                 }
 301
 302                 if (el->dirty_flags & DirtyClip) {
 303                         el->dirty_flags &= ~DirtyTransform;
 304
 305                         // XXX el->ComputeClip ();
 306                         // XXX el->UpdateBounds ();
 307
 308                         PropagateDirtyFlagToChildren (el, DirtyClip);
 309                 }
 310
 311                 if (el->dirty_flags & DirtyChildrenZIndices) {
 312                         el->dirty_flags &= ~DirtyChildrenZIndices;
 313                         if (!el->Is(Type::PANEL)) {
 314                                 g_warning ("DirtyChildrenZIndices is only applicable to Panel subclasses");
 315                         }
 316                         else {
 317                                 ((Panel*)el)->GetChildren ()->ResortByZIndex();
 318                         }
 319
 320                 }
 321
 322                 if (!(el->dirty_flags & DownDirtyState)) {
 323                         down_dirty->RemoveDirtyNode (el->GetVisualLevel (), el->down_dirty_node);
 324                         el->down_dirty_node = NULL;
 325                 }
 326         }
 327
 328         if (!down_dirty->IsEmpty())
 329                 g_warning ("after down dirty pass, down dirty list is not empty");
 330 }
 331
 332 /*
 333 ** Note that since this calls GDK invalidation functions
 334 ** it's a good idea to call it with a GDK lock held (all gtk callbacks
 335 ** are automatically protected except for timeouts and idle)
 336 */
 337 void
 338 Surface::ProcessUpDirtyElements ()
 339 {
 340         while (DirtyNode *node = (DirtyNode*)up_dirty->GetFirst()) {
 341                 UIElement* el = (UIElement*)node->element;
 342
 343 //              printf ("up processing element element %p (%s)\n", el, el->GetName());
 344 //              printf ("el->parent = %p\n", el->parent);
 345
 346                 if (el->dirty_flags & DirtyBounds) {
 347 //                      printf (" + bounds\n");
 348                         el->dirty_flags &= ~DirtyBounds;
 349
 350                         Rect obounds = el->GetBounds ();
 351                         Rect osubtreebounds = el->GetSubtreeBounds ();
 352                         bool parent_bounds_updated = false;
 353
 354                         el->ComputeBounds ();
 355
 356 //                              printf (" + + obounds = %f %f %f %f, nbounds = %f %f %f %f\n",
 357 //                                      obounds.x, obounds.y, obounds.w, obounds.h,
 358 //                                      el->GetBounds().x, el->GetBounds().y, el->GetBounds().w, el->GetBounds().h);
 359
 360                         if (osubtreebounds != el->GetSubtreeBounds ()) {
 361                                 if (el->GetVisualParent ()) {
 362                                         el->GetVisualParent ()->UpdateBounds ();
 363                                         parent_bounds_updated = true;
 364                                 }
 365                         }
 366
 367                         if (obounds != el->GetBounds()) {
 368                                 if (el->GetVisualParent ()) {
 369 //                                              printf (" + + + calling UpdateBounds and Invalidate on parent\n");
 370                                         if (!parent_bounds_updated)
 371                                                 el->GetVisualParent ()->UpdateBounds();
 372
 373                                         Region oregion = Region (obounds);
 374                                         el->GetVisualParent ()->Invalidate (&oregion);
 375                                 }
 376                                 el->Invalidate ();
 377                         }
 378
 379                         if (el->force_invalidate_of_new_bounds) {
 380                                 el->force_invalidate_of_new_bounds = false;
 381                                 // Invalidate everything including the
 382                                 // visible area of our children.
 383                                 el->InvalidateSubtreePaint ();
 384                         }
 385                 }
 386                 if (el->dirty_flags & DirtyNewBounds) {
 387                         el->Invalidate ();
 388                         el->dirty_flags &= ~DirtyNewBounds;
 389                 }
 390                 if (el->dirty_flags & DirtyInvalidate) {
 391 //                      printf (" + invalidating %p (%s) %s, %f %f %f %f\n",
 392 //                              el, el->GetTypeName(), el->GetName(), el->dirty_rect.x, el->dirty_rect.y, el->dirty_rect.w, el->dirty_rect.h);
 393
 394                         el->dirty_flags &= ~DirtyInvalidate;
 395
 396                         Region *dirty = el->dirty_region;
 397
 398                         GdkRectangle *rects;
 399                         int count;
 400                         dirty->GetRectangles (&rects, &count);
 401                         Surface *surface = el->GetDeployment ()->GetSurface ();
 402                         if (el->IsAttached ()) {
 403                                 while (count--) {
 404                                         Rect r = Rect ((double)rects [count].x,
 405                                                        (double)rects [count].y,
 406                                                        (double)rects [count].width,
 407                                                        (double)rects [count].height);
 408                                         //printf (" + + invalidating parent (%f,%f,%f,%f)\n",
 409                                         //      r.x,
 410                                         //      r.y,
 411                                         //      r.w,
 412                                         //      r.h);
 413
 414                                         surface->Invalidate (r);
 415                                 }
 416                                 g_free (rects);
 417                         }
 418
 419                         delete el->dirty_region;
 420                         el->dirty_region = new Region ();
 421                 }
 422
 423                 if (!(el->dirty_flags & UpDirtyState)) {
 424                         up_dirty->RemoveDirtyNode (el->GetVisualLevel (), el->up_dirty_node);
 425                         el->up_dirty_node = NULL;
 426                 }
 427         }
 428
 429         if (!up_dirty->IsEmpty())
 430                 g_warning ("after up dirty pass, up dirty list is not empty");
 431 }
 432
 433 void
 434 Surface::UpdateLayout ()
 435 {
 436         for (int i = 0; i < layers->GetCount (); i++) {
 437                 UIElement *layer = layers->GetValueAt (i)->AsUIElement ();
 438                 if (!layer->HasFlag (UIElement::DIRTY_MEASURE_HINT) && !layer->HasFlag (UIElement::DIRTY_ARRANGE_HINT))
 439                         continue;
 440
 441                 // This is a hack to make sure the elements understand the currnet
 442                 // size of the surface until it is moved to a proper location.
 443                 Size *last = LayoutInformation::GetPreviousConstraint (layer);
 444                 Size available = Size (active_window->GetWidth (), active_window->GetHeight ());
 445                 if (layer->IsContainer () && (!last || (*last != available))) {
 446                         layer->InvalidateMeasure ();
 447                         LayoutInformation::SetPreviousConstraint (layer, &available);
 448                 }
 449
 450                 layer->UpdateLayout ();
 451         }
 452 }
 453
 454 bool
 455 Surface::ProcessDirtyElements ()
 456 {
 457         UpdateLayout ();
 458         bool dirty = down_dirty->IsEmpty() || !up_dirty->IsEmpty();
 459         ProcessDownDirtyElements ();
 460         ProcessUpDirtyElements ();
 461         return dirty;
 462 }