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 (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         // Call SetSurface() /before/ setting the logical parent
 351         // because Storyboard::SetSurface() needs to be able to
 352         // distinguish between the two cases.
 353         obj->SetSurface (GetSurface ());
 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         return Collection::AddedToCollection (value, error);
 370 }
 371
 372 void
 373 DependencyObjectCollection::RemovedFromCollection (Value *value)
 374 {
 375         DependencyObject *obj = value->AsDependencyObject ();
 376
 377         obj->RemovePropertyChangeListener (this);
 378         obj->SetParent (NULL, NULL);
 379         obj->SetSurface (NULL);
 380
 381         Collection::RemovedFromCollection (value);
 382 }
 383
 384 void
 385 DependencyObjectCollection::SetSurface (Surface *surface)
 386 {
 387         if (GetSurface() == surface)
 388                 return;
 389
 390         DependencyObject *obj;
 391         Value *value;
 392
 393         for (guint i = 0; i < array->len; i++) {
 394                 value = (Value *) array->pdata[i];
 395                 obj = value->AsDependencyObject ();
 396                 obj->SetSurface (surface);
 397         }
 398
 399         Collection::SetSurface (surface);
 400 }
 401
 402 void
 403 DependencyObjectCollection::OnSubPropertyChanged (DependencyProperty *prop, DependencyObject *obj, PropertyChangedEventArgs *subobj_args)
 404 {
 405         EmitItemChanged (obj, subobj_args->GetProperty(), subobj_args->GetNewValue(), subobj_args->GetOldValue());
 406 }
 407
 408 void
 409 DependencyObjectCollection::UnregisterAllNamesRootedAt (NameScope *from_ns)
 410 {
 411         DependencyObject *obj;
 412         Value *value;
 413
 414         Types *types = Deployment::GetCurrent ()->GetTypes ();
 415         for (guint i = 0; i < array->len; i++) {
 416                 value = (Value *) array->pdata[i];
 417                 obj = value->AsDependencyObject (types);
 418                 obj->UnregisterAllNamesRootedAt (from_ns);
 419         }
 420
 421         Collection::UnregisterAllNamesRootedAt (from_ns);
 422 }
 423
 424 void
 425 DependencyObjectCollection::RegisterAllNamesRootedAt (NameScope *to_ns, MoonError *error)
 426 {
 427         DependencyObject *obj;
 428         Value *value;
 429
 430         Types *types = Deployment::GetCurrent ()->GetTypes ();
 431         for (guint i = 0; i < array->len; i++) {
 432                 if (error->number)
 433                         break;
 434
 435                 value = (Value *) array->pdata[i];
 436                 obj = value->AsDependencyObject (types);
 437                 obj->RegisterAllNamesRootedAt (to_ns, error);
 438         }
 439
 440         Collection::RegisterAllNamesRootedAt (to_ns, error);
 441 }
 442
 443 //
 444 // InlineCollection
 445 //
 446
 447 InlineCollection::InlineCollection ()
 448 {
 449         SetObjectType (Type::INLINE_COLLECTION);
 450 }
 451
 452 InlineCollection::~InlineCollection ()
 453 {
 454 }
 455
 456 bool
 457 InlineCollection::Equals (InlineCollection *inlines)
 458 {
 459         Inline *run0, *run1;
 460
 461         if (inlines->array->len != array->len)
 462                 return false;
 463
 464         Types *types = Deployment::GetCurrent ()->GetTypes ();
 465         for (guint i = 0; i < array->len; i++) {
 466                 run1 = ((Value *) inlines->array->pdata[i])->AsInline (types);
 467                 run0 = ((Value *) array->pdata[i])->AsInline (types);
 468
 469                 if (!run0->Equals (run1))
 470                         return false;
 471         }
 472
 473         return true;
 474 }
 475
 476
 477 //
 478 // UIElementCollection
 479 //
 480
 481 UIElementCollection::UIElementCollection ()
 482 {
 483         SetObjectType (Type::UIELEMENT_COLLECTION);
 484         z_sorted = g_ptr_array_new ();
 485 }
 486
 487 UIElementCollection::~UIElementCollection ()
 488 {
 489         g_ptr_array_free (z_sorted, true);
 490 }
 491
 492 static int
 493 UIElementZIndexComparer (gconstpointer ui1, gconstpointer ui2)
 494 {
 495         int z1 = Canvas::GetZIndex (*((UIElement **) ui1));
 496         int z2 = Canvas::GetZIndex (*((UIElement **) ui2));
 497
 498         return z1 - z2;
 499 }
 500
 501 void
 502 UIElementCollection::ResortByZIndex ()
 503 {
 504         g_ptr_array_set_size (z_sorted, array->len);
 505
 506         if (array->len == 0)
 507                 return;
 508
 509         Types *types = Deployment::GetCurrent ()->GetTypes ();
 510         for (guint i = 0; i < array->len; i++)
 511                 z_sorted->pdata[i] = ((Value *) array->pdata[i])->AsUIElement (types);
 512
 513         if (array->len > 1)
 514                 g_ptr_array_sort (z_sorted, UIElementZIndexComparer);
 515 }
 516
 517 bool
 518 UIElementCollection::Clear ()
 519 {
 520         g_ptr_array_set_size (z_sorted, 0);
 521         return DependencyObjectCollection::Clear ();
 522 }
 523
 524 //
 525 // HitTestCollection
 526 //
 527
 528 HitTestCollection::HitTestCollection ()
 529 {
 530 }
 531
 532 //
 533 // DoubleCollection
 534 //
 535
 536 DoubleCollection::DoubleCollection ()
 537 {
 538         SetObjectType (Type::DOUBLE_COLLECTION);
 539 }
 540
 541 DoubleCollection::~DoubleCollection ()
 542 {
 543 }
 544
 545 DoubleCollection *
 546 DoubleCollection::FromStr (const char *s)
 547 {
 548         GArray *values = double_garray_from_str (s, 0);
 549
 550         if (values->len == 0) {
 551                 g_array_free (values, true);
 552                 return NULL;
 553         }
 554
 555         DoubleCollection *doubles = new DoubleCollection ();
 556         for (guint i = 0; i < values->len; i ++)
 557                 doubles->Add (Value (g_array_index (values, double, i)));
 558         g_array_free (values, true);
 559
 560         return doubles;
 561 }
 562
 563 //
 564 // Point Collection
 565 //
 566
 567 PointCollection::PointCollection ()
 568 {
 569         SetObjectType (Type::POINT_COLLECTION);
 570 }
 571
 572 PointCollection::~PointCollection ()
 573 {
 574 }
 575
 576 PointCollection *
 577 PointCollection::FromStr (const char *s)
 578 {
 579         int i, j, n = 0;
 580         GArray *values = double_garray_from_str (s, 0);
 581
 582         n = values->len / 2;
 583         if (n == 0 || n % 1 == 1) {
 584                 g_array_free (values, true);
 585                 return NULL;
 586         }
 587
 588         PointCollection *points = new PointCollection();
 589         for (i = 0, j = 0; j < n; j++) {
 590                 double x = g_array_index (values, double, i++);
 591                 double y = g_array_index (values, double, i++);
 592
 593                 points->Add (Point (x, y));
 594         }
 595
 596         g_array_free (values, true);
 597         return points;
 598 }
 599
 600 //
 601 // Item Collection
 602 //
 603
 604 ItemCollection::ItemCollection ()
 605 {
 606         SetObjectType (Type::ITEM_COLLECTION);
 607 }
 608
 609 ItemCollection::~ItemCollection ()
 610 {
 611 }
 612
 613 //
 614 // Trigger Collection
 615 //
 616
 617 TriggerCollection::TriggerCollection ()
 618 {
 619         SetObjectType (Type::TRIGGER_COLLECTION);
 620 }
 621
 622 TriggerCollection::~TriggerCollection ()
 623 {
 624 }
 625
 626 //
 627 // TriggerAction Collection
 628 //
 629
 630 TriggerActionCollection::TriggerActionCollection ()
 631 {
 632         SetObjectType (Type::TRIGGERACTION_COLLECTION);
 633 }
 634
 635 TriggerActionCollection::~TriggerActionCollection ()
 636 {
 637 }
 638
 639 //
 640 // MultiScaleSubImage Collection
 641 //
 642 MultiScaleSubImageCollection::MultiScaleSubImageCollection ()
 643 {
 644         SetObjectType (Type::MULTISCALESUBIMAGE_COLLECTION);
 645         z_sorted = g_ptr_array_new ();
 646 }
 647
 648 MultiScaleSubImageCollection::~MultiScaleSubImageCollection ()
 649 {
 650         g_ptr_array_free (z_sorted, true);
 651 }
 652
 653 static int
 654 MultiScaleSubImageZIndexComparer (gconstpointer msisi1, gconstpointer msisi2)
 655 {
 656         int z1 = (*((MultiScaleSubImage**)msisi1))->GetZIndex ();
 657         int z2 = (*((MultiScaleSubImage**)msisi2))->GetZIndex ();
 658
 659         return z1 - z2;
 660 }
 661
 662 void
 663 MultiScaleSubImageCollection::ResortByZIndex ()
 664 {
 665         g_ptr_array_set_size (z_sorted, array->len);
 666
 667         if (array->len == 0)
 668                 return;
 669
 670         Types *types = Deployment::GetCurrent ()->GetTypes ();
 671         for (guint i = 0; i < array->len; i++)
 672                 z_sorted->pdata[i] = ((Value *) array->pdata[i])->AsMultiScaleSubImage (types);
 673
 674         if (array->len > 1)
 675                 g_ptr_array_sort (z_sorted, MultiScaleSubImageZIndexComparer);
 676 }
 677
 678 bool
 679 MultiScaleSubImageCollection::Clear ()
 680 {
 681         g_ptr_array_set_size (z_sorted, 0);
 682         return DependencyObjectCollection::Clear ();
 683 }
 684
 685 //
 686 // ResourceDictionaryCollection
 687 //
 688
 689 ResourceDictionaryCollection::ResourceDictionaryCollection ()
 690 {
 691         SetObjectType (Type::RESOURCE_DICTIONARY_COLLECTION);
 692 }
 693
 694 ResourceDictionaryCollection::~ResourceDictionaryCollection ()
 695 {
 696 }
 697
 698 //
 699 // CollectionIterator
 700 //
 701
 702 CollectionIterator::CollectionIterator (Collection *c)
 703 {
 704         generation = c->Generation ();
 705         collection = c;
 706         collection->ref ();
 707         index = -1;
 708 }
 709
 710 CollectionIterator::~CollectionIterator ()
 711 {
 712         collection->unref ();
 713 }
 714
 715 int
 716 CollectionIterator::Next ()
 717 {
 718         if (generation != collection->Generation ())
 719                 return -1;
 720
 721         index++;
 722
 723         if (index >= collection->GetCount ())
 724                 return 0;
 725
 726         return 1;
 727 }
 728
 729 bool
 730 CollectionIterator::Reset()
 731 {
 732         if (generation != collection->Generation ())
 733                 return false;
 734
 735         index = -1;
 736
 737         return true;
 738 }
 739
 740 Value *
 741 CollectionIterator::GetCurrent (int *error)
 742 {
 743         if (generation != collection->Generation ()) {
 744                 *error = 1;
 745                 return NULL;
 746         }
 747
 748         if (index < 0) {
 749                 *error = 1;
 750                 return NULL;
 751         }
 752
 753         *error = 0;
 754
 755         return collection->GetValueAt (index);
 756 }
 757
 758 void
 759 CollectionIterator::Destroy (CollectionIterator *iterator)
 760 {
 761         delete iterator;
 762 }
 763
 764
 765 //
 766 // VisualTreeWalker
 767 //
 768
 769 VisualTreeWalker::VisualTreeWalker (UIElement *obj, VisualTreeWalkerDirection dir, Types *cached)
 770 {
 771         index = 0;
 772         collection = NULL;
 773         content = obj->GetSubtreeObject ();
 774         direction = dir;
 775         types = (cached == NULL) ? Deployment::GetCurrent ()->GetTypes () : cached;
 776
 777         if (content != NULL) {
 778                 if (types->IsSubclassOf (content->GetObjectType (), Type::COLLECTION)) {
 779                         collection = (Collection *)content;
 780
 781                         if (!types->IsSubclassOf (content->GetObjectType (), Type::UIELEMENT_COLLECTION))
 782                                 direction = Logical;
 783                 }
 784
 785                 content->ref ();
 786         }
 787 }
 788
 789 UIElement *
 790 VisualTreeWalker::Step ()
 791 {
 792         UIElement *result = NULL;
 793
 794         if (collection) {
 795                 UIElementCollection *uiecollection = NULL;
 796                 int count = -1;
 797
 798                 if (direction != Logical) {
 799                         uiecollection = (UIElementCollection *)collection;
 800                         count = GetCount ();
 801                         if (count < 0 || index >= count)
 802                                 return NULL;
 803
 804                         if (count == 1 && index == 0) {
 805                                 index ++;
 806                                 return collection->GetValueAt (0)->AsUIElement(types);
 807                         }
 808
 809                         if ((int)uiecollection->z_sorted->len != count) {
 810                                 g_warning ("VisualTreeWalker: unexpectedly got an unsorted UIElementCollection");
 811                                 uiecollection->ResortByZIndex ();
 812                         }
 813                 }
 814
 815                 switch (direction) {
 816                 case ZForward:
 817                         result = (UIElement*)uiecollection->z_sorted->pdata[index];
 818                         break;
 819                 case ZReverse:
 820                         result = (UIElement *)uiecollection->z_sorted->pdata[count - (index + 1)];
 821                         break;
 822                 default:
 823                         Value *v = collection->GetValueAt (index);
 824                         result = v == NULL ? NULL : v->AsUIElement (types);
 825                 }
 826
 827                 index++;
 828         } else {
 829                 if (index == 0) {
 830                         index++;
 831                         result = (UIElement *)content;
 832                 } else {
 833                         result = NULL;
 834                 }
 835         }
 836
 837         return result;
 838 }
 839
 840 int
 841 VisualTreeWalker::GetCount ()
 842 {
 843         if (!content)
 844                 return 0;
 845
 846         if (!collection)
 847                 return 1;
 848
 849         return collection->GetCount ();
 850 }
 851
 852 VisualTreeWalker::~VisualTreeWalker()
 853 {
 854         if (content)
 855                 content->unref ();
 856 }
 857
 858
 859 class UnsafeUIElementNode : public List::Node {
 860 public:
 861         UIElement *uielement;
 862
 863         UnsafeUIElementNode (UIElement *el) { uielement = el; }
 864 };
 865
 866 DeepTreeWalker::DeepTreeWalker (UIElement *top, Types *types)
 867 {
 868         walk_list = new List ();
 869         walk_list->Append (new UnsafeUIElementNode (top));
 870         last = NULL;
 871         this->types = types ? types : Deployment::GetCurrent ()->GetTypes ();
 872 }
 873
 874 UIElement *
 875 DeepTreeWalker::Step ()
 876 {
 877         if (last) {
 878                 VisualTreeWalker walker (last, Logical, types);
 879                 //VisualTreeWalker walker (last, ZForward, types);
 880                 UnsafeUIElementNode *prepend = (UnsafeUIElementNode *) walk_list->First ();
 881                 while (UIElement *child = walker.Step ())
 882                         walk_list->InsertBefore (new UnsafeUIElementNode (child), prepend);
 883         }
 884
 885         UnsafeUIElementNode *next = (UnsafeUIElementNode*)walk_list->First ();
 886
 887         if (!next) {
 888                 last = NULL;
 889                 return NULL;
 890         }
 891
 892         UIElement *current = next->uielement;
 893         walk_list->Unlink (next);
 894         delete next;
 895         last = current;
 896
 897         return current;
 898 }
 899
 900 void
 901 DeepTreeWalker::SkipBranch ()
 902 {
 903         last = NULL;
 904 }
 905
 906 DeepTreeWalker::~DeepTreeWalker ()
 907 {
 908         delete walk_list;
 909 }
 910
 911 //
 912 // Manual C-Bindings
 913 //
 914 Collection *
 915 collection_new (Type::Kind kind)
 916 {
 917         Type *t = Type::Find (kind);
 918
 919         if (!t->IsSubclassOf (Type::COLLECTION)) {
 920                 g_warning ("create_collection passed non-collection type");
 921                 return NULL;
 922         }
 923
 924         return (Collection *) t->CreateInstance();
 925 }