src/collection.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * collection.cpp: different types of collections
   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 <glib.h>
  14
  15 #include "cbinding.h"
  16 #include "canvas.h"
  17 #include "collection.h"
  18 #include "geometry.h"
  19 #include "transform.h"
  20 #include "frameworkelement.h"
  21 #include "namescope.h"
  22 #include "textblock.h"
  23 #include "utils.h"
  24 #include "error.h"
  25 #include "deployment.h"
  26 #include "multiscalesubimage.h"
  27
  28 //
  29 // Collection
  30 //
  31
  32 Collection::Collection ()
  33 {
  34         SetObjectType (Type::COLLECTION);
  35         array = g_ptr_array_new ();
  36         generation = 0;
  37 }
  38
  39 void
  40 Collection::CloneCore (Types* types, DependencyObject* fromObj)
  41 {
  42         DependencyObject::CloneCore (types, fromObj);
  43
  44         Collection *c = (Collection*)fromObj;
  45
  46         for (guint i = 0; i < c->array->len; i++) {
  47                 Value *value = Value::Clone ((Value *) c->array->pdata[i]);
  48                 Add (value);
  49                 delete value;
  50         }
  51 }
  52
  53 Collection::~Collection ()
  54 {
  55         g_ptr_array_free (array, true);
  56 }
  57
  58 void
  59 Collection::Dispose ()
  60 {
  61         Value *value;
  62
  63         for (guint i = 0; i < array->len; i++) {
  64                 value = (Value *) array->pdata[i];
  65                 RemovedFromCollection (value);
  66                 delete value;
  67         }
  68         g_ptr_array_set_size (array, 0);
  69
  70         DependencyObject::Dispose ();
  71 }
  72
  73 CollectionIterator *
  74 Collection::GetIterator ()
  75 {
  76         return new CollectionIterator (this);
  77 }
  78
  79 int
  80 Collection::Add (Value *value)
  81 {
  82         MoonError error;
  83         return AddWithError (value, &error);
  84 }
  85
  86 int
  87 Collection::Add (Value value)
  88 {
  89         return Add (&value);
  90 }
  91
  92 int
  93 Collection::AddWithError (Value *value, MoonError *error)
  94 {
  95         bool rv = InsertWithError (array->len, value, error);
  96         return rv ? array->len - 1 : -1;
  97 }
  98
  99 bool
 100 Collection::Clear ()
 101 {
 102         EmitChanged (CollectionChangedActionClearing, NULL, NULL, -1);
 103
 104         guint len = array->len;
 105         Value** vals = new Value*[len];
 106         memmove (vals, array->pdata, len * sizeof(Value*));
 107
 108         g_ptr_array_set_size (array, 0);
 109         generation++;
 110
 111         SetCount (0);
 112
 113         for (guint i = 0; i < len; i++) {
 114                 RemovedFromCollection (vals[i]);
 115                 delete vals[i];
 116         }
 117         delete[] vals;
 118
 119         EmitChanged (CollectionChangedActionCleared, NULL, NULL, -1);
 120
 121         return true;
 122 }
 123
 124 bool
 125 Collection::Contains (Value *value)
 126 {
 127         return IndexOf (value) != -1;
 128 }
 129
 130 int
 131 Collection::IndexOf (Value *value)
 132 {
 133         Value *v;
 134
 135         for (guint i = 0; i < array->len; i++) {
 136                 v = (Value *) array->pdata[i];
 137                 if (*v == *value)
 138                         return i;
 139         }
 140
 141         return -1;
 142 }
 143
 144 bool
 145 Collection::Insert (int index, Value value)
 146 {
 147         return Insert (index, &value);
 148 }
 149
 150 bool
 151 Collection::InsertWithError (int index, Value *value, MoonError *error)
 152 {
 153         Value *added;
 154
 155         // Check that the item can be added to our collection
 156         if (!CanAdd (value))
 157                 return false;
 158
 159         // bounds check
 160         if (index < 0)
 161                 return false;
 162
 163         int count = GetCount ();
 164         if (index > count)
 165                 index = count;
 166
 167         added = new Value (*value);
 168
 169         if (AddedToCollection (added, error)) {
 170                 g_ptr_array_insert (array, index, added);
 171
 172                 SetCount ((int) array->len);
 173
 174                 Value *added_copy = new Value (*added);
 175
 176                 EmitChanged (CollectionChangedActionAdd, added_copy, NULL, index);
 177
 178                 delete added_copy;
 179
 180                 return true;
 181         }
 182         else {
 183                 delete added;
 184                 return false;
 185         }
 186 }
 187
 188 bool
 189 Collection::Insert (int index, Value *value)
 190 {
 191         MoonError error;
 192         return InsertWithError (index, value, &error);
 193 }
 194
 195 bool
 196 Collection::Remove (Value value)
 197 {
 198         return Remove (&value);
 199 }
 200
 201 bool
 202 Collection::Remove (Value *value)
 203 {
 204         int index;
 205
 206         if ((index = IndexOf (value)) == -1)
 207                 return false;
 208
 209         return RemoveAt (index);
 210 }
 211
 212 bool
 213 Collection::RemoveAt (int index)
 214 {
 215         Value *value;
 216
 217         // check bounds
 218         if (index < 0 || (guint) index >= array->len)
 219                 return false;
 220
 221         value = (Value *) array->pdata[index];
 222
 223         g_ptr_array_remove_index (array, index);
 224         SetCount ((int) array->len);
 225         generation++;
 226
 227         RemovedFromCollection (value);
 228
 229         EmitChanged (CollectionChangedActionRemove, NULL, value, index);
 230
 231         delete value;
 232
 233         return true;
 234 }
 235
 236 bool
 237 Collection::RemoveAtWithError (int index, MoonError *error)
 238 {
 239         // check bounds
 240         if (index < 0 || (guint) index >= array->len) {
 241                 MoonError::FillIn (error, MoonError::ARGUMENT_OUT_OF_RANGE, "");
 242                 return false;
 243         }
 244
 245         return RemoveAt (index);
 246 }
 247
 248 Value *
 249 Collection::GetValueAt (int index)
 250 {
 251         if (index < 0 || (guint) index >= array->len)
 252                 return NULL;
 253
 254         return (Value *) array->pdata[index];
 255 }
 256
 257 Value *
 258 Collection::GetValueAtWithError (int index, MoonError *error)
 259 {
 260         // check array bounds
 261         if (index < 0 || (guint) index >= array->len) {
 262                 MoonError::FillIn (error, MoonError::ARGUMENT_OUT_OF_RANGE, "");
 263                 return NULL;
 264         }
 265
 266         return GetValueAt (index);
 267 }
 268
 269 bool
 270 Collection::SetValueAt (int index, Value *value)
 271 {
 272         MoonError error;
 273         return SetValueAtWithError (index, value, &error);
 274 }
 275
 276 bool
 277 Collection::SetValueAtWithError (int index, Value *value, MoonError *error)
 278 {
 279         Value *added, *removed;
 280
 281         // Check that the value can be added to our collection
 282         if (!CanAdd (value)) {
 283                 MoonError::FillIn (error, MoonError::ARGUMENT, "");
 284                 return false;
 285         }
 286
 287         // check array bounds
 288         if (index < 0 || (guint) index >= array->len) {
 289                 MoonError::FillIn (error, MoonError::ARGUMENT_OUT_OF_RANGE, "");
 290                 return false;
 291         }
 292
 293         removed = (Value *) array->pdata[index];
 294         added = new Value (*value);
 295
 296         if (AddedToCollection (added, error)) {
 297                 array->pdata[index] = added;
 298
 299                 RemovedFromCollection (removed);
 300
 301                 EmitChanged (CollectionChangedActionReplace, added, removed, index);
 302
 303                 delete removed;
 304
 305                 return true;
 306         }
 307         else
 308                 return false;
 309 }
 310
 311 void
 312 Collection::EmitChanged (CollectionChangedAction action, Value *new_value, Value *old_value, int index)
 313 {
 314         Emit (Collection::ChangedEvent, new CollectionChangedEventArgs (action, new_value, old_value, index));
 315 }
 316
 317 void
 318 Collection::EmitItemChanged (DependencyObject *object, DependencyProperty *property, Value *newValue, Value *oldValue)
 319 {
 320         Emit (Collection::ItemChangedEvent, new CollectionItemChangedEventArgs (object, property, oldValue, newValue));
 321 }
 322
 323 bool
 324 Collection::CanAdd (Value *value)
 325 {
 326         return value->Is (GetDeployment (), GetElementType ());
 327 }
 328
 329
 330 //
 331 // DependencyObjectCollection
 332 //
 333
 334 DependencyObjectCollection::DependencyObjectCollection ()
 335 {
 336         SetObjectType (Type::DEPENDENCY_OBJECT_COLLECTION);
 337 }
 338
 339 DependencyObjectCollection::~DependencyObjectCollection ()
 340 {
 341 }
 342
 343 bool
 344 DependencyObjectCollection::AddedToCollection (Value *value, MoonError *error)
 345 {
 346         DependencyObject *obj = value->AsDependencyObject ();
 347
 348         DependencyObject *parent = obj->GetParent();
 349
 350         // Attach /before/ setting the logical parent
 351         // because Storyboard::SetIsAttached () needs to be able to
 352         // distinguish between the two cases.
 353         obj->SetIsAttached (IsAttached ());
 354
 355         if (parent) {
 356                 if (parent->Is(Type::COLLECTION) && !obj->PermitsMultipleParents ()) {
 357                         MoonError::FillIn (error, MoonError::INVALID_OPERATION, "Element is already a child of another element.");
 358                         return false;
 359                 }
 360         }
 361         else {
 362                 obj->SetParent (this, error);
 363                 if (error->number)
 364                         return false;
 365         }
 366
 367         obj->AddPropertyChangeListener (this);
 368
 369         bool rv = Collection::AddedToCollection (value, error);
 370
 371         if (!rv && parent == NULL) {
 372                 /* If we set the parent, but the object wasn't added to the collection, make sure we clear the parent */
 373                 obj->SetParent (NULL, error);
 374         }
 375
 376         return rv;
 377 }
 378
 379 void
 380 DependencyObjectCollection::RemovedFromCollection (Value *value)
 381 {
 382         DependencyObject *obj = value->AsDependencyObject ();
 383
 384         obj->RemovePropertyChangeListener (this);
 385         obj->SetParent (NULL, NULL);
 386         obj->SetIsAttached (false);
 387
 388         Collection::RemovedFromCollection (value);
 389 }
 390
 391 void
 392 DependencyObjectCollection::SetIsAttached (bool attached)
 393 {
 394         if (IsAttached () == attached)
 395                 return;
 396
 397         DependencyObject *obj;
 398         Value *value;
 399
 400         for (guint i = 0; i < array->len; i++) {
 401                 value = (Value *) array->pdata[i];
 402                 obj = value->AsDependencyObject ();
 403                 obj->SetIsAttached (attached);
 404         }
 405
 406         Collection::SetIsAttached (attached);
 407 }
 408
 409 void
 410 DependencyObjectCollection::OnSubPropertyChanged (DependencyProperty *prop, DependencyObject *obj, PropertyChangedEventArgs *subobj_args)
 411 {
 412         EmitItemChanged (obj, subobj_args->GetProperty(), subobj_args->GetNewValue(), subobj_args->GetOldValue());
 413 }
 414
 415 void
 416 DependencyObjectCollection::UnregisterAllNamesRootedAt (NameScope *from_ns)
 417 {
 418         DependencyObject *obj;
 419         Value *value;
 420
 421         Types *types = Deployment::GetCurrent ()->GetTypes ();
 422         for (guint i = 0; i < array->len; i++) {
 423                 value = (Value *) array->pdata[i];
 424                 obj = value->AsDependencyObject (types);
 425                 obj->UnregisterAllNamesRootedAt (from_ns);
 426         }
 427
 428         Collection::UnregisterAllNamesRootedAt (from_ns);
 429 }
 430
 431 void
 432 DependencyObjectCollection::RegisterAllNamesRootedAt (NameScope *to_ns, MoonError *error)
 433 {
 434         DependencyObject *obj;
 435         Value *value;
 436
 437         Types *types = Deployment::GetCurrent ()->GetTypes ();
 438         for (guint i = 0; i < array->len; i++) {
 439                 if (error->number)
 440                         break;
 441
 442                 value = (Value *) array->pdata[i];
 443                 obj = value->AsDependencyObject (types);
 444                 obj->RegisterAllNamesRootedAt (to_ns, error);
 445         }
 446
 447         Collection::RegisterAllNamesRootedAt (to_ns, error);
 448 }
 449
 450 //
 451 // InlineCollection
 452 //
 453
 454 InlineCollection::InlineCollection ()
 455 {
 456         SetObjectType (Type::INLINE_COLLECTION);
 457 }
 458
 459 InlineCollection::~InlineCollection ()
 460 {
 461 }
 462
 463 bool
 464 InlineCollection::Equals (InlineCollection *inlines)
 465 {
 466         Inline *run0, *run1;
 467
 468         if (inlines->array->len != array->len)
 469                 return false;
 470
 471         Types *types = Deployment::GetCurrent ()->GetTypes ();
 472         for (guint i = 0; i < array->len; i++) {
 473                 run1 = ((Value *) inlines->array->pdata[i])->AsInline (types);
 474                 run0 = ((Value *) array->pdata[i])->AsInline (types);
 475
 476                 if (!run0->Equals (run1))
 477                         return false;
 478         }
 479
 480         return true;
 481 }
 482
 483
 484 //
 485 // UIElementCollection
 486 //
 487
 488 UIElementCollection::UIElementCollection ()
 489 {
 490         SetObjectType (Type::UIELEMENT_COLLECTION);
 491         z_sorted = g_ptr_array_new ();
 492 }
 493
 494 UIElementCollection::~UIElementCollection ()
 495 {
 496         g_ptr_array_free (z_sorted, true);
 497 }
 498
 499 static int
 500 UIElementZIndexComparer (gconstpointer ui1, gconstpointer ui2)
 501 {
 502         int z1 = Canvas::GetZIndex (*((UIElement **) ui1));
 503         int z2 = Canvas::GetZIndex (*((UIElement **) ui2));
 504
 505         return z1 - z2;
 506 }
 507
 508 void
 509 UIElementCollection::ResortByZIndex ()
 510 {
 511         g_ptr_array_set_size (z_sorted, array->len);
 512
 513         if (array->len == 0)
 514                 return;
 515
 516         Types *types = Deployment::GetCurrent ()->GetTypes ();
 517         for (guint i = 0; i < array->len; i++)
 518                 z_sorted->pdata[i] = ((Value *) array->pdata[i])->AsUIElement (types);
 519
 520         if (array->len > 1)
 521                 g_ptr_array_sort (z_sorted, UIElementZIndexComparer);
 522 }
 523
 524 bool
 525 UIElementCollection::Clear ()
 526 {
 527         g_ptr_array_set_size (z_sorted, 0);
 528         return DependencyObjectCollection::Clear ();
 529 }
 530
 531 //
 532 // HitTestCollection
 533 //
 534
 535 HitTestCollection::HitTestCollection ()
 536 {
 537 }
 538
 539 //
 540 // DoubleCollection
 541 //
 542
 543 DoubleCollection::DoubleCollection ()
 544 {
 545         SetObjectType (Type::DOUBLE_COLLECTION);
 546 }
 547
 548 DoubleCollection::~DoubleCollection ()
 549 {
 550 }
 551
 552 DoubleCollection *
 553 DoubleCollection::FromStr (const char *s)
 554 {
 555         GArray *values = double_garray_from_str (s, 0);
 556
 557         if (values->len == 0) {
 558                 g_array_free (values, true);
 559                 return NULL;
 560         }
 561
 562         DoubleCollection *doubles = new DoubleCollection ();
 563         for (guint i = 0; i < values->len; i ++)
 564                 doubles->Add (Value (g_array_index (values, double, i)));
 565         g_array_free (values, true);
 566
 567         return doubles;
 568 }
 569
 570 //
 571 // Point Collection
 572 //
 573
 574 PointCollection::PointCollection ()
 575 {
 576         SetObjectType (Type::POINT_COLLECTION);
 577 }
 578
 579 PointCollection::~PointCollection ()
 580 {
 581 }
 582
 583 PointCollection *
 584 PointCollection::FromStr (const char *s)
 585 {
 586         int i, j, n = 0;
 587         GArray *values = double_garray_from_str (s, 0);
 588
 589         n = values->len / 2;
 590         if (n == 0 || n % 1 == 1) {
 591                 g_array_free (values, true);
 592                 return NULL;
 593         }
 594
 595         PointCollection *points = new PointCollection();
 596         for (i = 0, j = 0; j < n; j++) {
 597                 double x = g_array_index (values, double, i++);
 598                 double y = g_array_index (values, double, i++);
 599
 600                 points->Add (Point (x, y));
 601         }
 602
 603         g_array_free (values, true);
 604         return points;
 605 }
 606
 607 //
 608 // Item Collection
 609 //
 610
 611 ItemCollection::ItemCollection ()
 612 {
 613         SetObjectType (Type::ITEM_COLLECTION);
 614 }
 615
 616 ItemCollection::~ItemCollection ()
 617 {
 618 }
 619
 620 //
 621 // Trigger Collection
 622 //
 623
 624 TriggerCollection::TriggerCollection ()
 625 {
 626         SetObjectType (Type::TRIGGER_COLLECTION);
 627 }
 628
 629 TriggerCollection::~TriggerCollection ()
 630 {
 631 }
 632
 633 //
 634 // TriggerAction Collection
 635 //
 636
 637 TriggerActionCollection::TriggerActionCollection ()
 638 {
 639         SetObjectType (Type::TRIGGERACTION_COLLECTION);
 640 }
 641
 642 TriggerActionCollection::~TriggerActionCollection ()
 643 {
 644 }
 645
 646 //
 647 // MultiScaleSubImage Collection
 648 //
 649 MultiScaleSubImageCollection::MultiScaleSubImageCollection ()
 650 {
 651         SetObjectType (Type::MULTISCALESUBIMAGE_COLLECTION);
 652         z_sorted = g_ptr_array_new ();
 653 }
 654
 655 MultiScaleSubImageCollection::~MultiScaleSubImageCollection ()
 656 {
 657         g_ptr_array_free (z_sorted, true);
 658 }
 659
 660 static int
 661 MultiScaleSubImageZIndexComparer (gconstpointer msisi1, gconstpointer msisi2)
 662 {
 663         int z1 = (*((MultiScaleSubImage**)msisi1))->GetZIndex ();
 664         int z2 = (*((MultiScaleSubImage**)msisi2))->GetZIndex ();
 665
 666         return z1 - z2;
 667 }
 668
 669 void
 670 MultiScaleSubImageCollection::ResortByZIndex ()
 671 {
 672         g_ptr_array_set_size (z_sorted, array->len);
 673
 674         if (array->len == 0)
 675                 return;
 676
 677         Types *types = Deployment::GetCurrent ()->GetTypes ();
 678         for (guint i = 0; i < array->len; i++)
 679                 z_sorted->pdata[i] = ((Value *) array->pdata[i])->AsMultiScaleSubImage (types);
 680
 681         if (array->len > 1)
 682                 g_ptr_array_sort (z_sorted, MultiScaleSubImageZIndexComparer);
 683 }
 684
 685 bool
 686 MultiScaleSubImageCollection::Clear ()
 687 {
 688         g_ptr_array_set_size (z_sorted, 0);
 689         return DependencyObjectCollection::Clear ();
 690 }
 691
 692 //
 693 // ResourceDictionaryCollection
 694 //
 695
 696 ResourceDictionaryCollection::ResourceDictionaryCollection ()
 697 {
 698         SetObjectType (Type::RESOURCE_DICTIONARY_COLLECTION);
 699 }
 700
 701 ResourceDictionaryCollection::~ResourceDictionaryCollection ()
 702 {
 703 }
 704
 705 //
 706 // CollectionIterator
 707 //
 708
 709 CollectionIterator::CollectionIterator (Collection *c)
 710 {
 711         generation = c->Generation ();
 712         collection = c;
 713         collection->ref ();
 714         index = -1;
 715 }
 716
 717 CollectionIterator::~CollectionIterator ()
 718 {
 719         collection->unref ();
 720 }
 721
 722 bool
 723 CollectionIterator::Next (MoonError *err)
 724 {
 725         if (generation != collection->Generation ()) {
 726                 MoonError::FillIn (err, MoonError::INVALID_OPERATION, "The underlying collection has mutated");
 727                 return false;
 728         }
 729
 730         index++;
 731
 732         return index < collection->GetCount ();
 733 }
 734
 735 bool
 736 CollectionIterator::Reset ()
 737 {
 738         if (generation != collection->Generation ())
 739                 return false;
 740
 741         index = -1;
 742
 743         return true;
 744 }
 745
 746 Value *
 747 CollectionIterator::GetCurrent (MoonError *err)
 748 {
 749         if (generation != collection->Generation ()) {
 750                 MoonError::FillIn (err, MoonError::INVALID_OPERATION, "The underlying collection has mutated");
 751                 return NULL;
 752         }
 753
 754         if (index < 0 || index >= collection->GetCount ()) {
 755                 MoonError::FillIn (err, MoonError::INVALID_OPERATION, "Index out of bounds");
 756                 return NULL;
 757         }
 758
 759         return collection->GetValueAt (index);
 760 }
 761
 762 void
 763 CollectionIterator::Destroy (CollectionIterator *iterator)
 764 {
 765         delete iterator;
 766 }
 767
 768
 769 //
 770 // VisualTreeWalker
 771 //
 772
 773 VisualTreeWalker::VisualTreeWalker (UIElement *obj, VisualTreeWalkerDirection dir, Types *cached)
 774 {
 775         index = 0;
 776         collection = NULL;
 777         content = obj->GetSubtreeObject ();
 778         direction = dir;
 779         types = (cached == NULL) ? obj->GetDeployment ()->GetTypes () : cached;
 780
 781         if (content != NULL) {
 782                 if (types->IsSubclassOf (content->GetObjectType (), Type::COLLECTION)) {
 783                         collection = (Collection *)content;
 784
 785                         if (!types->IsSubclassOf (content->GetObjectType (), Type::UIELEMENT_COLLECTION))
 786                                 direction = Logical;
 787                 }
 788
 789                 content->ref ();
 790         }
 791 }
 792
 793 UIElement *
 794 VisualTreeWalker::Step ()
 795 {
 796         UIElement *result = NULL;
 797
 798         if (collection) {
 799                 UIElementCollection *uiecollection = NULL;
 800                 int count = GetCount ();
 801
 802                 if (count < 0 || index >= count)
 803                         return NULL;
 804
 805                 if (count == 1 && index == 0) {
 806                         index ++;
 807                         return collection->GetValueAt (0)->AsUIElement(types);
 808                 }
 809
 810                 if (direction == ZForward || direction == ZReverse) {
 811                         uiecollection = (UIElementCollection *)collection;
 812
 813                         if ((int)uiecollection->z_sorted->len != count) {
 814                                 g_warning ("VisualTreeWalker: unexpectedly got an unsorted UIElementCollection");
 815                                 uiecollection->ResortByZIndex ();
 816                         }
 817                 }
 818
 819                 switch (direction) {
 820                 case ZForward:
 821                         result = (UIElement*)uiecollection->z_sorted->pdata[index];
 822                         break;
 823                 case ZReverse:
 824                         result = (UIElement *)uiecollection->z_sorted->pdata[count - (index + 1)];
 825                         break;
 826                 case Logical: {
 827                         Value *v = collection->GetValueAt (index);
 828                         result = v == NULL ? NULL : v->AsUIElement (types);
 829                         break;
 830                 }
 831                 case LogicalReverse: {
 832                         Value *v = collection->GetValueAt (count - (index + 1));
 833                         result = v == NULL ? NULL : v->AsUIElement (types);
 834                         break;
 835                 }
 836                 }
 837
 838                 index++;
 839         } else {
 840                 if (index == 0) {
 841                         index++;
 842                         result = (UIElement *)content;
 843                 } else {
 844                         result = NULL;
 845                 }
 846         }
 847
 848         return result;
 849 }
 850
 851 int
 852 VisualTreeWalker::GetCount ()
 853 {
 854         if (!content)
 855                 return 0;
 856
 857         if (!collection)
 858                 return 1;
 859
 860         return collection->GetCount ();
 861 }
 862
 863 VisualTreeWalker::~VisualTreeWalker()
 864 {
 865         if (content)
 866                 content->unref ();
 867 }
 868
 869
 870 class UnsafeUIElementNode : public List::Node {
 871 public:
 872         UIElement *uielement;
 873
 874         UnsafeUIElementNode (UIElement *el) { uielement = el; }
 875 };
 876
 877 DeepTreeWalker::DeepTreeWalker (UIElement *top, VisualTreeWalkerDirection direction, Types *types)
 878 {
 879         walk_list = new List ();
 880         walk_list->Append (new UnsafeUIElementNode (top));
 881         last = NULL;
 882         this->types = types ? types : top->GetDeployment ()->GetTypes ();
 883         this->direction = direction;
 884 }
 885
 886 UIElement *
 887 DeepTreeWalker::Step ()
 888 {
 889         if (last) {
 890                 VisualTreeWalker walker (last, direction, types);
 891                 //VisualTreeWalker walker (last, ZForward, types);
 892                 UnsafeUIElementNode *prepend = (UnsafeUIElementNode *) walk_list->First ();
 893                 while (UIElement *child = walker.Step ())
 894                         walk_list->InsertBefore (new UnsafeUIElementNode (child), prepend);
 895         }
 896
 897         UnsafeUIElementNode *next = (UnsafeUIElementNode*)walk_list->First ();
 898
 899         if (!next) {
 900                 last = NULL;
 901                 return NULL;
 902         }
 903
 904         UIElement *current = next->uielement;
 905         walk_list->Unlink (next);
 906         delete next;
 907         last = current;
 908
 909         return current;
 910 }
 911
 912 void
 913 DeepTreeWalker::SkipBranch ()
 914 {
 915         last = NULL;
 916 }
 917
 918 DeepTreeWalker::~DeepTreeWalker ()
 919 {
 920         delete walk_list;
 921 }
 922
 923 //
 924 // Manual C-Bindings
 925 //
 926 Collection *
 927 collection_new (Type::Kind kind)
 928 {
 929         Type *t = Type::Find (Deployment::GetCurrent (), kind);
 930
 931         if (!t->IsSubclassOf (Type::COLLECTION)) {
 932                 g_warning ("create_collection passed non-collection type");
 933                 return NULL;
 934         }
 935
 936         return (Collection *) t->CreateInstance();
 937 }