src/xaml.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * xaml.cpp: xaml parser
   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
  14 #include <config.h>
  15
  16 #include <glib.h>
  17 #include <string.h>
  18 #include <malloc.h>
  19 #include <stdlib.h>
  20 #include <stdarg.h>
  21 #include <unistd.h>
  22 #include <fcntl.h>
  23 #include <errno.h>
  24
  25 #include <expat.h>
  26
  27 #include "xaml.h"
  28 #include "error.h"
  29 #include "shape.h"
  30 #include "animation.h"
  31 #include "bitmapimage.h"
  32 #include "geometry.h"
  33 #include "projection.h"
  34 #include "textblock.h"
  35 #include "glyphs.h"
  36 #include "media.h"
  37 #include "list.h"
  38 #include "rect.h"
  39 #include "point.h"
  40 #include "canvas.h"
  41 #include "color.h"
  42 #include "namescope.h"
  43 #include "stylus.h"
  44 #include "runtime.h"
  45 #include "utils.h"
  46 #include "control.h"
  47 #include "template.h"
  48 #include "style.h"
  49 #include "application.h"
  50 #include "thickness.h"
  51 #include "cornerradius.h"
  52 #include "deployment.h"
  53 #include "grid.h"
  54 #include "deepzoomimagetilesource.h"
  55 #include "managedtypeinfo.h"
  56
  57
  58 class XamlElementInfo;
  59 class XamlElementInstance;
  60 class XamlParserInfo;
  61 class XamlNamespace;
  62 class DefaultNamespace;
  63 class XNamespace;
  64 class XmlNamespace;
  65 class PrimitiveNamespace;
  66 class MCIgnorableNamespace;
  67 class XamlElementInfoNative;
  68 class XamlElementInstanceNative;
  69 class XamlElementInstanceValueType;
  70 class XamlElementInfoEnum;
  71 class XamlElementInstanceEnum;
  72 class XamlElementInfoManaged;
  73 class XamlElementInstanceManaged;
  74 class XamlElementInfoImportedManaged;
  75 class XamlElementInstanceTemplate;
  76
  77 #define INTERNAL_IGNORABLE_ELEMENT "MoonlightInternalIgnorableElement"
  78
  79 #define IS_NULL_OR_EMPTY(str)   (!str || (*str == 0))
  80
  81 static DefaultNamespace *default_namespace = NULL;
  82 static XNamespace *x_namespace = NULL;
  83 static XmlNamespace *xml_namespace = NULL;
  84
  85 static const char* default_namespace_names [] = {
  86         "http://schemas.microsoft.com/winfx/2006/xaml/presentation",
  87         "http://schemas.microsoft.com/client/2007",
  88         "http://schemas.microsoft.com/xps/2005/06",
  89         "http://schemas.microsoft.com/client/2007/deployment",
  90         NULL
  91 };
  92
  93 #define X_NAMESPACE_URI "http://schemas.microsoft.com/winfx/2006/xaml"
  94 #define XML_NAMESPACE_URI "http://www.w3.org/XML/1998/namespace"
  95 #define PRIMITIVE_NAMESPACE_URI "clr-namespace:System;assembly=mscorlib"
  96 #define MC_IGNORABLE_NAMESPACE_URI "http://schemas.openxmlformats.org/markup-compatibility/2006"
  97
  98
  99 static bool value_from_str_with_parser (XamlParserInfo *p, Type::Kind type, const char *prop_name, const char *str, Value **v, bool *v_set);
 100 static bool dependency_object_set_property (XamlParserInfo *p, XamlElementInstance *item, XamlElementInstance *property, XamlElementInstance *value, bool raise_errors);
 101 static bool set_managed_attached_property (XamlParserInfo *p, XamlElementInstance *item, XamlElementInstance *property, XamlElementInstance *value);
 102 static void dependency_object_add_child (XamlParserInfo *p, XamlElementInstance *parent, XamlElementInstance *child, bool fail_if_no_prop);
 103 static void dependency_object_set_attributes (XamlParserInfo *p, XamlElementInstance *item, const char **attr);
 104 static void value_type_set_attributes (XamlParserInfo *p, XamlElementInstance *item, const char **attr);
 105 static bool element_begins_buffering (Type::Kind kind);
 106 static bool is_managed_kind (Type::Kind kind);
 107 static bool kind_requires_managed_load (Type::Kind kind);
 108 static bool is_legal_top_level_kind (Type::Kind kind);
 109 static Value *lookup_resource_dictionary (ResourceDictionary *rd, const char *name, bool *exists);
 110 static void parser_error (XamlParserInfo *p, const char *el, const char *attr, int error_code, const char *format, ...);
 111 static gboolean namespace_for_prefix (gpointer key, gpointer value, gpointer user_data);
 112
 113 static XamlElementInfo *create_element_info_from_imported_managed_type (XamlParserInfo *p, const char *name, const char **attr, bool create);
 114 static void destroy_created_namespace (gpointer data, gpointer user_data);
 115
 116 enum BufferMode {
 117         BUFFER_MODE_TEMPLATE,
 118         BUFFER_MODE_IGNORE
 119 };
 120
 121
 122 class XamlNamespace {
 123  public:
 124         const char *name;
 125         bool is_ignored;
 126         GSList *prefixes;
 127
 128         XamlNamespace ()
 129         {
 130                 name = NULL;
 131                 prefixes = NULL;
 132                 is_ignored = false;
 133         }
 134
 135         ~XamlNamespace ()
 136         {
 137                 if (prefixes) {
 138                         GSList *w = prefixes;
 139
 140                         while (w) {
 141                                 char *p = (char *) w->data;
 142
 143                                 g_free (p);
 144                                 w = w->next;
 145                         }
 146
 147                         g_slist_free (prefixes);
 148                         prefixes = NULL;
 149                 }
 150         }
 151
 152         virtual XamlElementInfo* FindElement (XamlParserInfo *p, const char *el, const char **attr, bool create) = 0;
 153         virtual bool SetAttribute (XamlParserInfo *p, XamlElementInstance *item, const char *attr, const char *value) = 0;
 154
 155
 156         virtual const char* GetUri () = 0;
 157
 158         void AddPrefix (const char *prefix)
 159         {
 160                 prefixes = g_slist_append (prefixes, g_strdup (prefix));
 161         }
 162
 163         bool HasPrefix (const char *prefix)
 164         {
 165                 return g_slist_find_custom (prefixes, prefix, (GCompareFunc) strcmp) != NULL;
 166         }
 167
 168         GSList* GetPrefixes ()
 169         {
 170                 return prefixes;
 171         }
 172 };
 173
 174 void
 175 add_namespace_data (gpointer key, gpointer value, gpointer user_data)
 176 {
 177         XamlNamespace *ns = (XamlNamespace *) value;
 178         GHashTable *table = (GHashTable *) user_data;
 179
 180         if ((void *)ns != (void *)default_namespace) {
 181                 GSList *p = ns->GetPrefixes ();
 182
 183                 while (p) {
 184                         g_hash_table_insert (table, g_strdup ((char *)p->data), g_strdup (ns->GetUri ()));
 185
 186                         p = p->next;
 187                 }
 188         }
 189 }
 190
 191 void
 192 add_namespace_to_ignorable (gpointer key, gpointer value, gpointer user_data)
 193 {
 194         char *prefix = (char *) key;
 195         char *uri = (char *) value;
 196         GString *str = (GString *) user_data;
 197
 198         g_string_append_printf (str, "xmlns:%s=\"%s\" ", prefix, uri);
 199 }
 200
 201 class XamlContextInternal {
 202
 203  public:
 204         Value *top_element;
 205         FrameworkTemplate *template_parent;
 206         GHashTable *imported_namespaces;
 207         XamlLoaderCallbacks callbacks;
 208         GSList *resources;
 209         XamlContextInternal *parent_context;
 210
 211         DependencyObject *source;
 212
 213         XamlContextInternal (XamlLoaderCallbacks callbacks, Value *top_element, FrameworkTemplate *template_parent, GHashTable *namespaces, GSList *resources, XamlContextInternal *parent_context)
 214         {
 215                 this->callbacks = callbacks;
 216                 this->top_element = new Value (*top_element);
 217                 this->template_parent = template_parent;
 218                 this->resources = resources;
 219                 this->parent_context = parent_context;
 220
 221                 if (this->callbacks.create_gchandle)
 222                         this->callbacks.create_gchandle ();
 223                 imported_namespaces = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
 224                 g_hash_table_foreach (namespaces, add_namespace_data, imported_namespaces);
 225         }
 226
 227
 228         ~XamlContextInternal ()
 229         {
 230                 if (imported_namespaces)
 231                         g_hash_table_destroy (imported_namespaces);
 232                 if (resources)
 233                         g_slist_free (resources);
 234                 delete top_element;
 235         }
 236
 237         char *CreateIgnorableTagOpen ()
 238         {
 239                 GString *str = g_string_new ("<" INTERNAL_IGNORABLE_ELEMENT " ");
 240                 g_hash_table_foreach (imported_namespaces, add_namespace_to_ignorable, str);
 241
 242                 str = g_string_append (str, ">");
 243
 244                 char *res = str->str;
 245                 g_string_free (str, false);
 246
 247                 return res;
 248         }
 249
 250         char *CreateIgnorableTagClose ()
 251         {
 252                 return g_strdup ("</" INTERNAL_IGNORABLE_ELEMENT ">");
 253         }
 254
 255         bool LookupNamedItem (const char* name, Value **v)
 256         {
 257                 if (!resources)
 258                         return NULL;
 259
 260                 bool exists = false;
 261                 GSList *walk = resources;
 262                 while (walk) {
 263                         DependencyObject *dob = (DependencyObject*)walk->data;
 264                         if (dob->Is (Type::RESOURCE_DICTIONARY))
 265                                 *v = lookup_resource_dictionary ((ResourceDictionary *) walk->data, name, &exists);
 266                         else /* dob->Is (Type::FRAMEWORKELEMENT) */ {
 267                                 ResourceDictionary *rd = dob->GetValue (UIElement::ResourcesProperty)->AsResourceDictionary();
 268                                 *v = lookup_resource_dictionary (rd, name, &exists);
 269                         }
 270
 271                         if (exists)
 272                                 break;
 273                         walk = walk->next;
 274                 }
 275
 276                 if (exists)
 277                         return exists;
 278                 else if (!parent_context)
 279                         return false;
 280
 281                 return parent_context->LookupNamedItem (name, v);
 282         }
 283
 284         void SetTemplateBindingSource (DependencyObject *source)
 285         {
 286                 this->source = source;
 287         }
 288
 289         DependencyObject* GetTemplateBindingSource ()
 290         {
 291                 return source;
 292         }
 293 };
 294
 295
 296 XamlContext::XamlContext (XamlContextInternal *internal)
 297 {
 298         this->internal = internal;
 299 }
 300
 301 XamlContext::~XamlContext ()
 302 {
 303         delete internal;
 304 }
 305
 306 void
 307 XamlContext::SetTemplateBindingSource (DependencyObject *source)
 308 {
 309         internal->SetTemplateBindingSource (source);
 310 }
 311
 312 DependencyObject*
 313 XamlContext::GetTemplateBindingSource ()
 314 {
 315         return internal->GetTemplateBindingSource ();
 316 }
 317
 318 class XamlElementInfo {
 319  protected:
 320         Type::Kind kind;
 321         Type::Kind property_owner_kind;
 322         bool cdata_verbatim;
 323
 324  public:
 325         XamlElementInfo *parent;
 326         const char *name;
 327         const char *xmlns;
 328
 329         XamlElementInfo (const char *xmlns, const char *name, Type::Kind kind)
 330         {
 331                 this->parent = NULL;
 332                 this->kind = kind;
 333                 this->name = name;
 334                 this->xmlns = xmlns;
 335                 this->cdata_verbatim = false;
 336
 337                 this->property_owner_kind = Type::INVALID;
 338         }
 339
 340         ~XamlElementInfo ()
 341         {
 342         }
 343
 344         virtual Type::Kind GetKind () { return kind; }
 345
 346         virtual void SetPropertyOwnerKind (Type::Kind value) { property_owner_kind = value; }
 347         virtual Type::Kind GetPropertyOwnerKind () { return property_owner_kind; }
 348
 349         virtual const char *GetContentProperty (XamlParserInfo *p)
 350         {
 351                 Type *t = Type::Find (Deployment::GetCurrent (), kind);
 352                 if (t)
 353                         return t->GetContentPropertyName ();
 354                 return NULL;
 355         }
 356
 357         void SetIsCDataVerbatim (bool flag)
 358         {
 359                 cdata_verbatim = flag;
 360         }
 361
 362         bool IsCDataVerbatim ()
 363         {
 364                 return cdata_verbatim;
 365         }
 366
 367         virtual bool RequiresManagedSet () { return false; }
 368
 369         virtual XamlElementInstance *CreateElementInstance (XamlParserInfo *p) = 0;
 370         virtual XamlElementInstance *CreateWrappedElementInstance (XamlParserInfo *p, Value *o) = 0;
 371         virtual XamlElementInstance *CreatePropertyElementInstance (XamlParserInfo *p, const char *name) = 0;
 372 };
 373
 374
 375 struct DelayedProperty {
 376         char *xmlns;
 377         char *name;
 378         Value *value;
 379
 380         DelayedProperty (const char *xmlns, const char *name, const Value *value)
 381         {
 382                 this->xmlns = g_strdup (xmlns);
 383                 this->name = g_strdup (name);
 384                 this->value = new Value (*value);
 385         }
 386
 387         ~DelayedProperty ()
 388         {
 389                 g_free (xmlns);
 390                 g_free (name);
 391                 delete value;
 392         }
 393 };
 394
 395 static void
 396 free_property_list (GSList *list)
 397 {
 398         GSList *walk = list;
 399
 400         while (walk) {
 401                 DelayedProperty *prop = (DelayedProperty *) walk->data;
 402
 403                 delete prop;
 404                 walk = walk->next;
 405         }
 406
 407         g_slist_free (list);
 408 }
 409
 410 class XamlElementInstance : public List::Node {
 411
 412  protected:
 413         DependencyObject *item;
 414         Value *value;
 415         bool cleanup_value;
 416         GSList *delayed_properties;
 417
 418  public:
 419         const char *element_name;
 420         XamlElementInfo *info;
 421
 422         XamlElementInstance *parent;
 423         List *children;
 424
 425         enum ElementType {
 426                 ELEMENT,
 427                 PROPERTY,
 428                 INVALID
 429         };
 430
 431         int element_type;
 432         bool requires_managed;
 433         char *x_key;
 434         char *x_name;
 435
 436         GHashTable *set_properties;
 437
 438         XamlElementInstance (XamlElementInfo *info, const char* element_name, ElementType type, bool requires_managed = false)
 439         {
 440                 this->element_name = element_name;
 441                 this->set_properties = NULL;
 442                 this->element_type = type;
 443                 this->parent = NULL;
 444                 this->info = info;
 445                 this->item = NULL;
 446                 this->value = NULL;
 447                 this->x_key = NULL;
 448                 this->x_name = NULL;
 449                 this->cleanup_value = true;
 450                 this->requires_managed = requires_managed;
 451                 this->delayed_properties = NULL;
 452
 453                 children = new List ();
 454         }
 455
 456         virtual ~XamlElementInstance ()
 457         {
 458                 children->Clear (true);
 459                 delete children;
 460                 delete info;
 461
 462                 g_free (x_key);
 463                 g_free (x_name);
 464
 465                 if (cleanup_value)
 466                         delete value;
 467
 468                 if (set_properties)
 469                         g_hash_table_destroy (set_properties);
 470
 471                 if (element_name && element_type == PROPERTY)
 472                         g_free ((void*) element_name);
 473
 474                 free_property_list (delayed_properties);
 475         }
 476
 477         virtual bool SetProperty (XamlParserInfo *p, XamlElementInstance *property, XamlElementInstance *value) = 0;
 478         virtual bool SetProperty (XamlParserInfo *p, XamlElementInstance *property, const char* value) = 0;
 479         virtual void AddChild (XamlParserInfo *p, XamlElementInstance *child) = 0;
 480         virtual void SetAttributes (XamlParserInfo *p, const char **attr) = 0;
 481
 482         virtual bool TrySetContentProperty (XamlParserInfo *p, XamlElementInstance *value);
 483         virtual bool TrySetContentProperty (XamlParserInfo *p, const char *value);
 484
 485
 486         char *GetKey () { return x_key; }
 487         char *GetName () { return x_name; }
 488
 489         void SetName (XamlParserInfo *p, const char *name)
 490         {
 491                 this->x_name = g_strdup (name);
 492         }
 493
 494         void SetKey (XamlParserInfo *p, const char *key)
 495         {
 496                 this->x_key = g_strdup (key);
 497         }
 498
 499         virtual bool IsDependencyObject ()
 500         {
 501                 return true;
 502         }
 503
 504         virtual bool SetUnknownAttribute (XamlParserInfo *p, const char* name, const char* value);
 505
 506         void SetValue (Value *v)
 507         {
 508                 if (value && cleanup_value)
 509                         delete value;
 510                 value = v;
 511         }
 512
 513         virtual Value *GetAsValue ()
 514         {
 515                 if (!value) {
 516                         value = new Value (item);
 517                 }
 518                 return value;
 519         }
 520
 521         virtual DependencyObject *GetAsDependencyObject ()
 522         {
 523                 return item;
 524         }
 525
 526         virtual void SetDependencyObject (DependencyObject *value)
 527         {
 528                 item = value;
 529         }
 530
 531         virtual void* GetManagedPointer ()
 532         {
 533                 return item;
 534         }
 535
 536         virtual Value* GetParentPointer ()
 537         {
 538                 XamlElementInstance *walk = parent;
 539                 while (walk && walk->element_type != XamlElementInstance::ELEMENT)
 540                         walk = walk->parent;
 541
 542                 if (!walk)
 543                         return NULL;
 544
 545                 return walk->GetAsValue ();
 546         }
 547
 548         virtual bool IsTemplate ()
 549         {
 550                 return false;
 551         }
 552
 553         virtual XamlElementInfo* FindPropertyElement (XamlParserInfo *p, const char *el, const char *dot);
 554
 555         void SetDelayedProperties (XamlParserInfo *p);
 556
 557         void DelaySetProperty (const char *xmlns, const char *name, const Value *value)
 558         {
 559                 DelayedProperty *prop = new DelayedProperty (xmlns, name, value);
 560
 561                 delayed_properties = g_slist_append (delayed_properties, prop);
 562         }
 563
 564         bool IsPropertySet (const char *name)
 565         {
 566                 if (!set_properties)
 567                         return false;
 568
 569                 return g_hash_table_lookup (set_properties, name) != NULL;
 570         }
 571
 572         void MarkPropertyAsSet (const char *name)
 573         {
 574                 if (!set_properties)
 575                         set_properties = g_hash_table_new (g_str_hash, g_str_equal);
 576
 577                 g_hash_table_insert (set_properties, (void *) name, GINT_TO_POINTER (TRUE));
 578         }
 579 };
 580
 581 void
 582 unref_xaml_element (gpointer data, gpointer user_data)
 583 {
 584         DependencyObject* dob = (DependencyObject*) data;
 585         //printf ("unref_xaml_element: %i\n", dob->id);
 586         if (dob)
 587                 dob->unref ();
 588 }
 589
 590 class XamlParserInfo {
 591  public:
 592         XML_Parser parser;
 593
 594         const char *file_name;
 595
 596         NameScope *namescope;
 597         XamlElementInstance *top_element;
 598         XamlNamespace *current_namespace;
 599         XamlElementInstance *current_element;
 600         const char *next_element;
 601         Deployment *deployment;
 602
 603         GHashTable *namespace_map;
 604         bool cdata_content;
 605         GString *cdata;
 606
 607         bool implicit_default_namespace;
 608
 609         ParserErrorEventArgs *error_args;
 610
 611         XamlLoader *loader;
 612
 613
 614         //
 615         // If set, this is used to hydrate an existing object, not to create a new toplevel one
 616         //
 617         Value *hydrate_expecting;
 618         bool hydrating;
 619
 620         char* buffer_until_element;
 621         int buffer_depth;
 622         BufferMode buffer_mode;
 623         GString *buffer;
 624         bool validate_templates;
 625
 626  private:
 627         GList *created_elements;
 628         GList *created_namespaces;
 629         const char* xml_buffer;
 630         int multi_buffer_offset;
 631         int xml_buffer_start_index;
 632
 633  public:
 634         XamlParserInfo (XML_Parser parser, const char *file_name)
 635         {
 636                 this->deployment = Deployment::GetCurrent ();
 637                 this->parser = parser;
 638                 this->file_name = file_name;
 639                 this->namescope = new NameScope ();
 640
 641                 top_element = NULL;
 642                 current_namespace = NULL;
 643                 current_element = NULL;
 644                 cdata_content = false;
 645                 cdata = NULL;
 646                 implicit_default_namespace = false;
 647                 error_args = NULL;
 648                 loader = NULL;
 649                 created_elements = NULL;
 650                 created_namespaces = NULL;
 651                 hydrate_expecting = NULL;
 652                 hydrating = false;
 653
 654                 buffer_until_element = NULL;
 655                 buffer_depth = -1;
 656                 buffer = NULL;
 657                 xml_buffer = NULL;
 658                 multi_buffer_offset = 0;
 659                 validate_templates = false;
 660
 661                 namespace_map = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
 662         }
 663
 664         void AddCreatedElement (DependencyObject* element)
 665         {
 666                 // if we have a loader, set the surface and base resource location
 667                 if (loader) {
 668                         element->SetIsAttached (true); /* Some glyphs (DRT 0/Test5, 58) do not show up without this */
 669                         element->SetResourceBase (loader->GetResourceBase());
 670                 }
 671
 672                 // When instantiating a template, some elements are created which are not explicitly
 673                 // mentioned in the xaml. Therefore we need to keep walking up the tree until we find
 674                 // the last element which we set a value for Control::IsTemplateItem and propagate
 675                 // it from there.
 676                 XamlElementInstance *instance = current_element;
 677                 while (instance) {
 678                         if (!instance->IsDependencyObject () || !instance->GetAsDependencyObject ()) {
 679                                 instance = instance->parent;
 680                                 continue;
 681                         }
 682                         if (!instance->GetAsDependencyObject ()->ReadLocalValue (Control::IsTemplateItemProperty)) {
 683                                 instance = instance->parent;
 684                                 continue;
 685                         }
 686                         Control::SetIsTemplateItem (element, Control::GetIsTemplateItem (instance->GetAsDependencyObject ()));
 687                         if (DependencyObject *e = instance->GetAsDependencyObject ()->GetTemplateOwner ())
 688                                 element->SetTemplateOwner (e);
 689                         break;
 690                 }
 691
 692                 if (instance == NULL) {
 693                         Control::SetIsTemplateItem (element, loader->GetExpandingTemplate ());
 694                         element->SetTemplateOwner (loader->GetTemplateOwner ());
 695                 }
 696
 697                 if (Control::GetIsTemplateItem (element))
 698                         NameScope::SetNameScope (element, namescope);
 699                 created_elements = g_list_prepend (created_elements, element);
 700         }
 701
 702         void AddCreatedNamespace (XamlNamespace* ns)
 703         {
 704                 created_namespaces = g_list_prepend (created_namespaces, ns);
 705         }
 706
 707         void QueueBeginBuffering (char* buffer_until, BufferMode mode)
 708         {
 709                 buffer_until_element = buffer_until;
 710                 buffer_depth = 1;
 711                 buffer_mode = mode;
 712
 713                 xml_buffer_start_index = -1;
 714         }
 715
 716         void BeginBuffering ()
 717         {
 718                 xml_buffer_start_index = XML_GetCurrentByteIndex (parser) - multi_buffer_offset;
 719                 buffer = g_string_new (NULL);
 720         }
 721
 722         bool ShouldBeginBuffering ()
 723         {
 724                 return InBufferingMode () && xml_buffer_start_index == -1;
 725         }
 726
 727         bool InBufferingMode ()
 728         {
 729                 return buffer_until_element != NULL;
 730         }
 731
 732         void AppendCurrentXml ()
 733         {
 734                 if (!buffer)
 735                         return;
 736                 int pos = XML_GetCurrentByteIndex (parser) - multi_buffer_offset;
 737                 g_string_append_len (buffer, xml_buffer + xml_buffer_start_index, pos - xml_buffer_start_index);
 738         }
 739
 740         char* ClearBuffer ()
 741         {
 742                 AppendCurrentXml ();
 743
 744                 buffer_depth = 0;
 745                 buffer_until_element = NULL;
 746
 747                 if (!buffer)
 748                         return g_strdup ("");
 749
 750                 char* res = buffer->str;
 751                 g_string_free (buffer, FALSE);
 752                 buffer = NULL;
 753                 return res;
 754         }
 755
 756         void SetXmlBuffer (const char* xml_buffer)
 757         {
 758                 if (InBufferingMode ())
 759                         AppendCurrentXml ();
 760
 761                 if (this->xml_buffer)
 762                         multi_buffer_offset += strlen (this->xml_buffer);
 763
 764                 this->xml_buffer = xml_buffer;
 765                 xml_buffer_start_index = 0;
 766         }
 767
 768         void ValidateTemplate (const char* buffer, XamlContext* context, FrameworkTemplate *binding_source)
 769         {
 770                 XamlLoader *loader = new XamlLoader (NULL, buffer, NULL, context);
 771                 Type::Kind dummy;
 772
 773                 context->SetTemplateBindingSource (binding_source);
 774
 775                 loader->SetImportDefaultXmlns (true);
 776
 777                 MoonError error;
 778                 Value *result = loader->CreateFromStringWithError (buffer, true, &dummy, XamlLoader::IMPORT_DEFAULT_XMLNS | XamlLoader::VALIDATE_TEMPLATES, &error);
 779
 780                 delete result;
 781                 delete loader;
 782
 783                 if (error.number != MoonError::NO_ERROR) {
 784                         int line_number = error.line_number + XML_GetCurrentLineNumber (parser);
 785                         error_args = new ParserErrorEventArgs (error.message, file_name, line_number, error.char_position, error.code, NULL, NULL);
 786                 }
 787         }
 788
 789         FrameworkTemplate *GetTemplateParent (XamlElementInstance *item)
 790         {
 791                 XamlElementInstance *parent = item->parent;
 792
 793                 while (parent && !parent->IsTemplate ())
 794                         parent = parent->parent;
 795
 796                 if (parent)
 797                         return (FrameworkTemplate *) parent->GetManagedPointer ();
 798
 799                 if (!loader)
 800                         return NULL;
 801
 802                 XamlContext *context = loader->GetContext ();
 803                 if (!context)
 804                         return NULL;
 805
 806                 return context->internal->template_parent;
 807         }
 808
 809         Value *GetTopElementPtr ()
 810         {
 811                 XamlContext *context = loader->GetContext ();
 812                 if (context)
 813                         return context->internal->top_element;
 814
 815                 if (top_element)
 816                         return top_element->GetAsValue ();
 817
 818                 return NULL;
 819         }
 820
 821         ~XamlParserInfo ()
 822         {
 823                 created_elements = g_list_reverse (created_elements);
 824                 g_list_foreach (created_elements, unref_xaml_element, NULL);
 825                 g_list_free (created_elements);
 826
 827                 g_list_foreach (created_namespaces, destroy_created_namespace, NULL);
 828                 g_list_free (created_namespaces);
 829
 830                 g_hash_table_destroy (namespace_map);
 831
 832                 if (cdata)
 833                         g_string_free (cdata, TRUE);
 834                 if (top_element)
 835                         delete top_element;
 836                 namescope->unref ();
 837         }
 838
 839
 840 };
 841
 842
 843 class XamlElementInfoNative : public XamlElementInfo {
 844         Type *type;
 845
 846  public:
 847         XamlElementInfoNative (Type *t) : XamlElementInfo (NULL, t->GetName (), t->GetKind ())
 848         {
 849                 type = t;
 850         }
 851
 852         Type* GetType ()
 853         {
 854                 return type;
 855         }
 856
 857         const char* GetName ()
 858         {
 859                 return type->GetName ();
 860         }
 861
 862         const char* GetContentProperty (XamlParserInfo *p);
 863
 864         XamlElementInstance* CreateElementInstance (XamlParserInfo *p);
 865         XamlElementInstance* CreateWrappedElementInstance (XamlParserInfo *p, Value *o);
 866         XamlElementInstance* CreatePropertyElementInstance (XamlParserInfo *p, const char *name);
 867 };
 868
 869
 870 class XamlElementInstanceNative : public XamlElementInstance {
 871         XamlElementInfoNative *element_info;
 872         XamlParserInfo *parser_info;
 873
 874  public:
 875         XamlElementInstanceNative (XamlElementInfoNative *element_info, XamlParserInfo *parser_info, const char *name, ElementType type, bool create_item = true);
 876
 877         virtual DependencyObject *CreateItem ();
 878
 879         virtual XamlElementInfo* FindPropertyElement (XamlParserInfo *p, const char *el, const char *dot);
 880
 881         virtual bool SetProperty (XamlParserInfo *p, XamlElementInstance *property, XamlElementInstance *value);
 882         virtual bool SetProperty (XamlParserInfo *p, XamlElementInstance *property, const char* value);
 883         virtual void AddChild (XamlParserInfo *p, XamlElementInstance *child);
 884         virtual void SetAttributes (XamlParserInfo *p, const char **attr);
 885 };
 886
 887
 888 class XamlElementInstanceValueType : public XamlElementInstance {
 889         XamlElementInfoNative *element_info;
 890         XamlParserInfo *parser_info;
 891
 892  public:
 893         XamlElementInstanceValueType (XamlElementInfoNative *element_info, XamlParserInfo *parser_info, const char *name, ElementType type);
 894
 895         virtual bool IsDependencyObject ()
 896         {
 897                 return false;
 898         }
 899
 900         virtual Value *GetAsValue ()
 901         {
 902                 if (value == NULL) {
 903                         // we are an empty element (e.g.  <sys:String></sys:String>).  do type specific magic here.
 904                         CreateValueItemFromString ("");
 905                 }
 906
 907                 return value;
 908         }
 909
 910         bool CreateValueItemFromString (const char* str);
 911
 912         // A Value type doesn't really support anything. It's just here so people can do <SolidColorBrush.Color><Color>#FF00FF</Color></SolidColorBrush.Color>
 913         virtual DependencyObject *CreateItem () { return NULL; }
 914         virtual bool SetProperty (XamlParserInfo *p, XamlElementInstance *property, XamlElementInstance *value) { return false; }
 915         virtual bool SetProperty (XamlParserInfo *p, XamlElementInstance *property, const char *value) { return false; }
 916         virtual void AddChild (XamlParserInfo *p, XamlElementInstance *child) { }
 917         virtual void SetAttributes (XamlParserInfo *p, const char **attr);
 918
 919         virtual bool TrySetContentProperty (XamlParserInfo *p, XamlElementInstance *value) { return false; }
 920         virtual bool TrySetContentProperty (XamlParserInfo *p, const char *value) { return CreateValueItemFromString (value); }
 921 };
 922
 923 class XamlElementInfoEnum : public XamlElementInfo {
 924  public:
 925         XamlElementInfoEnum (const char *name) : XamlElementInfo (NULL, name, Type::INT32)
 926         {
 927         }
 928
 929         XamlElementInstance* CreateElementInstance (XamlParserInfo *p);
 930         XamlElementInstance* CreateWrappedElementInstance (XamlParserInfo *p, Value *o);
 931         XamlElementInstance* CreatePropertyElementInstance (XamlParserInfo *p, const char *name) { return NULL; }
 932 };
 933
 934 class XamlElementInstanceEnum : public XamlElementInstance {
 935
 936  public:
 937         XamlElementInstanceEnum (XamlElementInfoEnum *element_info, const char *name, ElementType type);
 938
 939         virtual bool IsDependencyObject ()
 940         {
 941                 return false;
 942         }
 943
 944         virtual Value *GetAsValue ()
 945         {
 946                 return value;
 947         }
 948
 949         bool CreateEnumFromString (const char* str);
 950
 951         // An enum type doesn't really support anything. It's just here so people can do <Visibility>Visible</Visibility>
 952         virtual DependencyObject *CreateItem () { return NULL; }
 953         virtual bool SetProperty (XamlParserInfo *p, XamlElementInstance *property, XamlElementInstance *value) { return false; }
 954         virtual bool SetProperty (XamlParserInfo *p, XamlElementInstance *property, const char *value) { return false; }
 955         virtual void AddChild (XamlParserInfo *p, XamlElementInstance *child) { }
 956         virtual void SetAttributes (XamlParserInfo *p, const char **attr);
 957
 958         virtual bool TrySetContentProperty (XamlParserInfo *p, XamlElementInstance *value) { return false; }
 959         virtual bool TrySetContentProperty (XamlParserInfo *p, const char *value) { return CreateEnumFromString (value); }
 960 };
 961
 962 class XamlElementInstanceTemplate : public XamlElementInstanceNative {
 963 public:
 964         XamlElementInstanceTemplate (XamlElementInfoNative *element_info, XamlParserInfo *parser_info, const char *name, ElementType type, bool create_item = true)
 965                 : XamlElementInstanceNative (element_info, parser_info, name, type, create_item)
 966         {
 967         }
 968
 969         virtual bool IsTemplate ()
 970         {
 971                 return true;
 972         }
 973 };
 974
 975
 976 class DefaultNamespace : public XamlNamespace {
 977  public:
 978         DefaultNamespace ()
 979         {
 980                 AddPrefix ("");
 981         }
 982
 983         virtual ~DefaultNamespace () { }
 984
 985         virtual XamlElementInfo* FindElement (XamlParserInfo *p, const char *el, const char **attr, bool create)
 986         {
 987                 Type* t = Type::Find (p->deployment, el, false);
 988                 if (t && !kind_requires_managed_load (t->GetKind ()))
 989                         return new XamlElementInfoNative (t);
 990
 991                 if (enums_is_enum_name (el))
 992                         return new XamlElementInfoEnum (g_strdup (el));
 993
 994                 XamlElementInfo* managed_element = create_element_info_from_imported_managed_type (p, el, attr, create);
 995                 if (managed_element)
 996                         return managed_element;
 997
 998                 return NULL;
 999
1000         }
1001
1002         virtual bool SetAttribute (XamlParserInfo *p, XamlElementInstance *item, const char *attr, const char *value)
1003         {
1004                 return false;
1005         }
1006
1007         virtual const char* GetUri () { return "http://schemas.microsoft.com/winfx/2006/xaml/presentation"; }
1008 };
1009
1010 class XmlNamespace : public XamlNamespace {
1011  public:
1012         XmlNamespace ()
1013         {
1014                 AddPrefix ("xml");
1015         }
1016
1017         virtual ~XmlNamespace () { }
1018
1019         virtual XamlElementInfo* FindElement (XamlParserInfo *p, const char *el, const char **attr, bool create)
1020         {
1021                 return NULL;
1022         }
1023
1024         virtual bool SetAttribute (XamlParserInfo *p, XamlElementInstance *item, const char *attr, const char *value)
1025         {
1026                 if (!strcmp ("lang", attr)) {
1027                         if (item->IsDependencyObject ()) {
1028                                 DependencyObject *dob = item->GetAsDependencyObject ();
1029                                 if (dob->Is(Type::FRAMEWORKELEMENT)) {
1030                                         ((FrameworkElement*)dob)->SetLanguage (value);
1031                                         return true;
1032                                 }
1033                         }
1034                 }
1035
1036                 return false;
1037         }
1038
1039         virtual const char* GetUri () { return "http://www.w3.org/XML/1998/namespace"; }
1040 };
1041
1042 class XNamespace : public XamlNamespace {
1043  public:
1044         XNamespace ()
1045         {
1046                 AddPrefix ("x");
1047         }
1048
1049         virtual ~XNamespace () { }
1050
1051         virtual XamlElementInfo* FindElement (XamlParserInfo *p, const char *el, const char **attr, bool create)
1052         {
1053                 return NULL;
1054         }
1055
1056         virtual char *FindTypeName (const char **attr, char **xmlns)
1057         {
1058                 char *res = NULL;
1059
1060                 if (!attr)
1061                         return NULL;
1062
1063                 for (int i = 0; attr [i]; i += 2) {
1064                         const char *ns = strchr (attr [i], '|');
1065                         if (!ns)
1066                                 continue;
1067
1068                         if (strncmp (GetUri (), attr [i], ns - attr [i]) || strcmp ("Class", ns + 1))
1069                                 continue;
1070
1071                         ns = strchr (attr [i + 1], ';');
1072                         if (!ns) {
1073                                 *xmlns = g_strdup ("");
1074                                 res = g_strdup (attr [i + 1]);
1075                         } else {
1076                                 *xmlns = g_strdup (ns + 1);
1077                                 res = g_strndup (attr [i + 1], attr [i + 1] - ns);
1078                         }
1079                         return res;
1080                 }
1081                 return NULL;
1082         }
1083
1084         bool IsParentResourceDictionary (XamlElementInstance *parent)
1085         {
1086                 if (parent == NULL)
1087                         return false;
1088
1089                 return Type::IsSubclassOf (Deployment::GetCurrent (), parent->info->GetKind (), Type::RESOURCE_DICTIONARY);
1090         }
1091
1092         virtual bool SetAttribute (XamlParserInfo *p, XamlElementInstance *item, const char *attr, const char *value)
1093         {
1094                 if (!strcmp ("Name", attr)) {
1095                         //
1096                         // Causes breakage in airlines
1097                         // Maybe x:Name overwrites but Name does not?
1098                         //
1099                         // if (p->namescope->FindName (value)) {
1100                         //      parser_error (p, p->current_element->element_name, "x:Name", 2028, "The name already exists in the tree: %s.", value);
1101                         //      return false;
1102                         // }
1103                         //
1104
1105                         if (IsParentResourceDictionary (p->current_element)) {
1106                                 if (item->GetKey ()) {
1107                                         // XXX don't know the proper values here...
1108                                         parser_error (p, item->element_name, NULL, 2028,
1109                                                       "The name already exists in the tree: %s.", value);
1110                                         return false;
1111                                 }
1112                         }
1113
1114                         if (item->GetName ()) {
1115                                 parser_error (p, item->element_name, NULL, 2016, "Cannot specify both Name and x:Name attributes.");
1116                                 return false;
1117                         }
1118
1119                         item->SetName (p, value);
1120
1121                         if (item->IsDependencyObject ()) {
1122                                 NameScope *scope = p->namescope;
1123                                 if (!item->GetAsDependencyObject ()->SetName (value, scope)) {
1124                                         if (IsParentResourceDictionary (p->current_element)) {
1125                                                 // FIXME: inside of a resource dictionary this has an extremly
1126                                                 // strange behavior.  this isn't exactly right, since not only
1127                                                 // does the exception get swallowed, but the name seems to also
1128                                                 // be unregistered.
1129                                         }
1130                                         else {
1131                                                 parser_error (p, item->element_name, NULL, 2028,
1132                                                               "The name already exists in the tree: %s.", value);
1133                                                 return false;
1134                                         }
1135                                 }
1136                                 return true;
1137                         }
1138
1139                         return false;
1140                 }
1141
1142                 if (!strcmp ("Key", attr)) {
1143                         if (item->GetKey () && IsParentResourceDictionary (p->current_element) && !Type::IsSubclassOf (p->deployment, item->info->GetKind (), Type::STORYBOARD)) {
1144                                 // XXX don't know the proper values here...
1145                                 parser_error (p, item->element_name, NULL, 2028,
1146                                               "The name already exists in the tree: %s.", value);
1147                                 return false;
1148                         }
1149                         item->SetKey (p, value);
1150                         return true;
1151                 }
1152
1153                 if (!strcmp ("Class", attr)) {
1154                         if (!is_legal_top_level_kind (item->info->GetKind ())) {
1155                                 // XXX don't know the proper values here...
1156                                 parser_error (p, item->element_name, attr, -1,
1157                                               "Cannot specify x:Class type '%s' on value type element (%s).", value, item->element_name);
1158                                 return false;
1159                         }
1160
1161                         if (p->top_element != item) {
1162                                 // HAH: what a useless error message
1163                                 parser_error (p, item->element_name, attr, 2012,
1164                                               "Unknown attribute %s on element %s.", attr, item->element_name);
1165                                 return false;
1166                         }
1167
1168                         // While hydrating, we do not need to create the toplevel class, its created already
1169                         if (p->hydrating)
1170                                 return true;
1171                         else {
1172                                 parser_error (p, item->element_name, attr, 4005,
1173                                               "Cannot specify x:Class in xaml files outside of a xap.");
1174                                 return false;
1175                         }
1176                 }
1177
1178                 return false;
1179         }
1180
1181         virtual const char* GetUri () { return X_NAMESPACE_URI; }
1182 };
1183
1184
1185 class PrimitiveNamespace : public XamlNamespace {
1186
1187  public:
1188         PrimitiveNamespace (char *prefix)
1189         {
1190                 AddPrefix (prefix);
1191         }
1192
1193         virtual ~PrimitiveNamespace ()
1194         {
1195         }
1196
1197         virtual XamlElementInfo* FindElement (XamlParserInfo *p, const char *el, const char **attr, bool create)
1198         {
1199                 if (!strcmp ("String", el)) {
1200                         Type* t = Type::Find (p->deployment, Type::STRING);
1201                         // it's not as easy in this case, because primitive clr strings require that the
1202                         // character data be read in verbatim, including all whitespace.
1203                         XamlElementInfo *info = new XamlElementInfoNative (t);
1204                         info->SetIsCDataVerbatim (true);
1205                         return info;
1206                 } else if (!strcmp ("Int32", el)) {
1207                         Type* t = Type::Find (p->deployment, Type::INT32);
1208                         return new XamlElementInfoNative (t);
1209                 } else if (!strcmp ("Double", el)) {
1210                         Type* t = Type::Find (p->deployment, Type::DOUBLE);
1211                         return new XamlElementInfoNative (t);
1212                 } else if (!strcmp ("Boolean", el)) {
1213                         Type* t = Type::Find (p->deployment, Type::BOOL);
1214                         return new XamlElementInfoNative (t);
1215                 } else if (!strcmp ("TimeSpan", el)) {
1216                         Type* t = Type::Find (p->deployment, Type::TIMESPAN);
1217                         return new XamlElementInfoNative (t);
1218                 }
1219
1220                 return NULL;
1221         }
1222
1223         virtual bool SetAttribute (XamlParserInfo *p, XamlElementInstance *item, const char *attr, const char *value)
1224         {
1225                 return false;
1226         }
1227
1228         virtual const char* GetUri () { return PRIMITIVE_NAMESPACE_URI; }
1229 };
1230
1231
1232 class MCIgnorableNamespace : public XamlNamespace {
1233
1234  public:
1235         MCIgnorableNamespace (char *prefix)
1236         {
1237                 AddPrefix (prefix);
1238         }
1239
1240         virtual ~MCIgnorableNamespace ()
1241         {
1242         }
1243
1244         virtual XamlElementInfo* FindElement (XamlParserInfo *p, const char *el, const char **attr, bool create)
1245         {
1246                 return NULL;
1247         }
1248
1249         virtual bool SetAttribute (XamlParserInfo *p, XamlElementInstance *item, const char *attr, const char *value)
1250         {
1251                 if (!strcmp ("Ignorable", attr)) {
1252                         const char *start = value;
1253                         do {
1254                                 const char *space = strchr (start, ' ');
1255                                 char *prefix;
1256                                 if (space) {
1257                                         prefix = g_strndup (start, space - start);
1258                                         start = space + 1;
1259                                 } else {
1260                                         prefix = g_strdup (start);
1261                                         start = NULL;
1262                                 }
1263
1264                                 XamlNamespace *ns = (XamlNamespace *) g_hash_table_find (p->namespace_map, namespace_for_prefix, prefix);
1265                                 if (ns)
1266                                         ns->is_ignored = true;
1267
1268                         } while (start);
1269
1270                         return true;
1271                 }
1272
1273                 return false;
1274         }
1275
1276         virtual const char* GetUri () { return MC_IGNORABLE_NAMESPACE_URI; }
1277 };
1278
1279
1280 static void
1281 destroy_created_namespace (gpointer data, gpointer user_data)
1282 {
1283         XamlNamespace* ns = (XamlNamespace *) data;
1284         delete ns;
1285 }
1286
1287
1288 class XamlElementInfoManaged : public XamlElementInfo {
1289  public:
1290         XamlElementInfoManaged (const char *xmlns, const char *name, XamlElementInfo *parent, Type::Kind dependency_type, Value *obj) : XamlElementInfo (xmlns, name, dependency_type)
1291         {
1292                 this->obj = obj;
1293         }
1294
1295         Value *obj;
1296
1297         const char* GetName () { return name; }
1298
1299         const char* GetContentProperty (XamlParserInfo *p);
1300
1301         virtual bool RequiresManagedSet () { return true; }
1302
1303         XamlElementInstance* CreateElementInstance (XamlParserInfo *p);
1304         XamlElementInstance* CreateWrappedElementInstance (XamlParserInfo *p, Value *o);
1305         XamlElementInstance* CreatePropertyElementInstance (XamlParserInfo *p, const char *name);
1306 };
1307
1308
1309 class XamlElementInstanceManaged : public XamlElementInstance {
1310  public:
1311         XamlElementInstanceManaged (XamlElementInfo *info, const char *name, ElementType type, Value *obj);
1312
1313         virtual bool IsDependencyObject ()
1314         {
1315                 return is_dependency_object;
1316         }
1317
1318         virtual bool SetProperty (XamlParserInfo *p, XamlElementInstance *property, XamlElementInstance *value);
1319         virtual bool SetProperty (XamlParserInfo *p, XamlElementInstance *property, const char* value);
1320         virtual void AddChild (XamlParserInfo *p, XamlElementInstance *child);
1321         virtual void SetAttributes (XamlParserInfo *p, const char **attr);
1322
1323         virtual bool TrySetContentProperty (XamlParserInfo *p, XamlElementInstance *value);
1324         virtual bool TrySetContentProperty (XamlParserInfo *p, const char *value);
1325
1326         virtual void* GetManagedPointer ();
1327         virtual Value* GetParentPointer ();
1328  private:
1329         bool is_dependency_object;
1330 };
1331
1332
1333 class XamlElementInfoImportedManaged : public XamlElementInfoManaged {
1334  public:
1335         XamlElementInfoImportedManaged (const char *name, XamlElementInfo *parent, Value *obj) : XamlElementInfoManaged (NULL, name, parent, obj->GetKind (), obj)
1336         {
1337         }
1338
1339         const char* GetContentProperty (XamlParserInfo *p);
1340
1341         XamlElementInstance* CreateElementInstance (XamlParserInfo *p);
1342         XamlElementInstance* CreateWrappedElementInstance (XamlParserInfo *p, Value *o);
1343         XamlElementInstance* CreatePropertyElementInstance (XamlParserInfo *p, const char *name);
1344 };
1345
1346
1347
1348 class ManagedNamespace : public XamlNamespace {
1349  public:
1350         char *xmlns;
1351
1352         ManagedNamespace (char *xmlns, char *prefix)
1353         {
1354                 this->xmlns = xmlns;
1355                 AddPrefix (prefix);
1356         }
1357
1358         virtual ~ManagedNamespace ()
1359         {
1360                 g_free (xmlns);
1361         }
1362
1363         virtual XamlElementInfo* FindElement (XamlParserInfo *p, const char *el, const char **attr, bool create)
1364         {
1365                 char* type_name = NULL;
1366                 char* type_xmlns = NULL;
1367                 const char* use_xmlns = xmlns;
1368
1369                 if (!p->loader)
1370                         return NULL;
1371
1372                 if (x_namespace) {
1373                         // We might have an x:Class attribute specified, so we need to use that for the
1374                         // type_name that we pass to LookupObject
1375                         if (strcmp ("Application", el)) {
1376                                 type_name = x_namespace->FindTypeName (attr, &type_xmlns);
1377                                 if (type_name) {
1378                                         el = type_name;
1379                                         use_xmlns = type_xmlns;
1380
1381                                         if (!p->hydrating) {
1382                                                 parser_error (p, el, "x:Class", 4005, "Cannot specify x:Class in xaml files outside of a xap.");
1383                                                 return NULL;
1384                                         }
1385                                 }
1386                         }
1387                 }
1388
1389                 Value *value = new Value ();
1390                 if (!p->loader->LookupObject (p, p->GetTopElementPtr (), p->current_element ? p->current_element->GetAsValue () : NULL, use_xmlns, el, create, false, value)) {
1391                         parser_error (p, el, NULL, 2007, "Unable to resolve managed type %s.", el);
1392                         delete value;
1393                         if (type_name)
1394                                 g_free (type_name);
1395                         if (type_xmlns)
1396                                 g_free (type_xmlns);
1397                         return  NULL;
1398                 }
1399
1400                 if (p->hydrate_expecting) {
1401                         //
1402                         // If we are hydrating a top level managed object, use the Value* passed
1403                         // to Hydrate as our value
1404                         //
1405                         Value *v = value;
1406                         value = p->hydrate_expecting;
1407                         delete v;
1408                 }
1409
1410                 XamlElementInfoManaged *info = new XamlElementInfoManaged (xmlns, g_strdup (el), NULL, value->GetKind (), value);
1411                 if (type_name)
1412                         g_free (type_name);
1413                 if (type_xmlns)
1414                         g_free (type_xmlns);
1415                 return info;
1416         }
1417
1418         virtual bool SetAttribute (XamlParserInfo *p, XamlElementInstance *item, const char *attr, const char *value)
1419         {
1420                 if (is_ignored)
1421                         return true;
1422
1423                 if (p->loader) {
1424                         Value v = Value (value);
1425                         return p->loader->SetProperty (p, p->GetTopElementPtr (), item->info->xmlns, item->GetAsValue (), item, item->GetParentPointer (), xmlns, attr, &v, NULL);
1426                 }
1427                 return false;
1428         }
1429
1430
1431         virtual const char* GetUri () { return xmlns; }
1432 };
1433
1434 bool
1435 XamlLoader::LookupObject (void *p, Value *top_level, Value *parent, const char* xmlns, const char* type_name, bool create, bool is_property, Value *value)
1436 {
1437         if (callbacks.lookup_object) {
1438                 if (!vm_loaded && !LoadVM ())
1439                         return false;
1440                 MoonError error;
1441                 XamlCallbackData data = XamlCallbackData (this, p, top_level);
1442                 bool res = callbacks.lookup_object (&data, parent, xmlns, type_name, create, is_property, value, &error);
1443                 return res;
1444         }
1445
1446         return false;
1447 }
1448
1449 const char *
1450 XamlLoader::GetContentPropertyName (void *p, Value *top_level, Value *object)
1451 {
1452         if (callbacks.get_content_property_name) {
1453                 MoonError error;
1454                 XamlCallbackData data = XamlCallbackData (this, p, top_level);
1455                 return callbacks.get_content_property_name (&data, object, &error);
1456         }
1457         return NULL;
1458 }
1459
1460 bool
1461 XamlLoader::SetProperty (void *p, Value *top_level, const char* xmlns, Value *target, void *target_data, Value *target_parent, const char* prop_xmlns, const char *name, Value *value, void* value_data, int flags)
1462 {
1463         if (callbacks.set_property) {
1464                 MoonError error;
1465                 XamlCallbackData data = XamlCallbackData (this, p, top_level, flags);
1466                 bool res = callbacks.set_property (&data, xmlns, target, target_data, target_parent, prop_xmlns, name, value, value_data, &error);
1467
1468                 if (error.number != MoonError::NO_ERROR) {
1469                         parser_error ((XamlParserInfo *) p, ((XamlElementInstance *) target_data)->element_name, NULL, error.code, error.message);
1470                         return false;
1471                 }
1472
1473                 return res;
1474         }
1475
1476         return false;
1477 }
1478
1479 bool
1480 XamlLoader::AddChild (void *p, Value *top_level, Value *parent_parent, bool parent_is_property, const char* parent_xmlns, Value *parent, void *parent_data, Value *child, void *child_data)
1481 {
1482         if (callbacks.add_child) {
1483                 MoonError error;
1484                 XamlCallbackData data = XamlCallbackData (this, p, top_level);
1485                 bool res = callbacks.add_child (&data, parent_parent, parent_is_property, parent_xmlns, parent, parent_data, child, child_data, &error);
1486
1487                 if (error.number != MoonError::NO_ERROR) {
1488                         parser_error ((XamlParserInfo *) p, ((XamlElementInstance *) child_data)->element_name, NULL, error.code, error.message);
1489                         return false;
1490                 }
1491
1492                 return res;
1493         }
1494         return false;
1495 }
1496
1497 XamlLoader::XamlLoader (const char *resourceBase, const char* filename, const char* str, Surface* surface, XamlContext *context)
1498 {
1499         Initialize (resourceBase, filename, str, surface, context);
1500 }
1501
1502 XamlLoader::XamlLoader (const char* filename, const char* str, Surface* surface, XamlContext *context)
1503 {
1504         Initialize (NULL, filename, str, surface, context);
1505 }
1506
1507 void
1508 XamlLoader::Initialize (const char *resourceBase, const char* filename, const char* str, Surface* surface, XamlContext *context)
1509 {
1510         this->filename = g_strdup (filename);
1511         this->resource_base = g_strdup (resourceBase);
1512         this->str = g_strdup (str);
1513         this->surface = surface;
1514         if (surface)
1515                 surface->ref ();
1516         this->context = context;
1517         this->vm_loaded = false;
1518         this->error_args = NULL;
1519         this->expanding_template = false;
1520         this->template_owner = NULL;
1521         this->import_default_xmlns = false;
1522
1523         if (context) {
1524                 callbacks = context->internal->callbacks;
1525                 this->vm_loaded = true;
1526         }
1527 #if DEBUG
1528         if (!surface && debug_flags & RUNTIME_DEBUG_XAML) {
1529                 printf ("XamlLoader::XamlLoader ('%s', '%s', %p): Initializing XamlLoader without a surface.\n",
1530                         filename, str, surface);
1531         }
1532 #endif
1533 }
1534
1535 XamlLoader::~XamlLoader ()
1536 {
1537         g_free (filename);
1538         g_free (resource_base);
1539         g_free (str);
1540         if (surface)
1541                 surface->unref ();
1542         surface = NULL;
1543         filename = NULL;
1544         str = NULL;
1545         if (error_args)
1546                 error_args->unref();
1547 }
1548
1549 bool
1550 XamlLoader::LoadVM ()
1551 {
1552         return false;
1553 }
1554
1555 XamlLoader*
1556 xaml_loader_new (const char *resourceBase, const char* filename, const char* str, Surface* surface)
1557 {
1558         return new XamlLoader (resourceBase, filename, str, surface);
1559 }
1560
1561 void
1562 xaml_loader_free (XamlLoader* loader)
1563 {
1564         delete loader;
1565 }
1566
1567 void
1568 xaml_loader_set_callbacks (XamlLoader* loader, XamlLoaderCallbacks callbacks)
1569 {
1570         if (!loader) {
1571                 LOG_XAML ("Trying to set callbacks for a null object\n");
1572                 return;
1573         }
1574
1575         loader->callbacks = callbacks;
1576         loader->vm_loaded = true;
1577 }
1578
1579 static gboolean
1580 namespace_for_prefix (gpointer key, gpointer value, gpointer user_data)
1581 {
1582         XamlNamespace *ns = (XamlNamespace *) value;
1583         const char *prefix = (const char *) user_data;
1584
1585         return ns->HasPrefix (prefix);
1586 }
1587
1588 char*
1589 xaml_uri_for_prefix (void *parser, char* prefix)
1590 {
1591         XamlParserInfo *p = (XamlParserInfo *) parser;
1592
1593         XamlNamespace *ns = (XamlNamespace *) g_hash_table_find (p->namespace_map, namespace_for_prefix, prefix);
1594         if (!ns)
1595                 return NULL;
1596
1597         return g_strdup (ns->GetUri ());
1598 }
1599
1600 //
1601 // Called when we encounter an error.  Note that memory ownership is taken for everything
1602 // except the message, this allows you to use g_strdup_printf when creating the error message
1603 //
1604 static void
1605 parser_error (XamlParserInfo *p, const char *el, const char *attr, int error_code, const char *format, ...)
1606 {
1607         char *message;
1608         va_list args;
1609
1610         // Already failed
1611         if (p->error_args)
1612                 return;
1613
1614         // if parsing fails too early it's not safe (i.e. sigsegv) to call some functions, e.g. XML_GetCurrentLineNumber
1615         bool report_line_col = (error_code != XML_ERROR_XML_DECL);
1616         int line_number = report_line_col ? XML_GetCurrentLineNumber (p->parser) : 0;
1617         int char_position = report_line_col ? XML_GetCurrentColumnNumber (p->parser) : 0;
1618
1619         va_start (args, format);
1620         message = g_strdup_vprintf (format, args);
1621         va_end (args);
1622
1623         p->error_args = new ParserErrorEventArgs (message, p->file_name, line_number, char_position, error_code, el, attr);
1624
1625         g_free (message);
1626
1627         LOG_XAML ("PARSER ERROR, STOPPING PARSING:  (%d) %s  line: %d   char: %d\n", error_code, message,
1628                   line_number, char_position);
1629
1630         XML_StopParser (p->parser, FALSE);
1631 }
1632
1633 void
1634 expat_parser_error (XamlParserInfo *p, XML_Error expat_error)
1635 {
1636         // Already had an error
1637         if (p->error_args)
1638                 return;
1639
1640         LOG_XAML ("expat error is:  %d\n", expat_error);
1641
1642         switch (expat_error) {
1643         case XML_ERROR_DUPLICATE_ATTRIBUTE:
1644                 parser_error (p, NULL, NULL, 7031, "wfc: unique attribute spec");
1645                 break;
1646         case XML_ERROR_UNBOUND_PREFIX:
1647                 parser_error (p, NULL, NULL, 7055, "undeclared prefix");
1648                 break;
1649         case XML_ERROR_NO_ELEMENTS:
1650                 parser_error (p, NULL, NULL, 7000, "unexpected end of input");
1651                 break;
1652         case XML_ERROR_SYNTAX:
1653                 parser_error (p, NULL, NULL, 2103, "syntax error");
1654                 break;
1655         default:
1656                 parser_error (p, NULL, NULL, expat_error, "Unhandled XML error %s", XML_ErrorString (expat_error));
1657                 break;
1658         }
1659 }
1660
1661 static void
1662 start_element (void *data, const char *el, const char **attr)
1663 {
1664         XamlParserInfo *p = (XamlParserInfo *) data;
1665         XamlElementInfo *elem = NULL;
1666         XamlElementInstance *inst;
1667         Types *types = Deployment::GetCurrent ()->GetTypes ();
1668
1669         if (!strcmp (el, INTERNAL_IGNORABLE_ELEMENT))
1670                 return;
1671
1672         if (p->ShouldBeginBuffering ()) {
1673                 p->BeginBuffering ();
1674                 return;
1675         }
1676
1677         if (p->InBufferingMode ()) {
1678                 if (!strcmp (p->buffer_until_element, el))
1679                         p->buffer_depth++;
1680                 return;
1681         }
1682
1683         const char *dot = strchr (el, '.');
1684         if (!dot)
1685                 elem = p->current_namespace->FindElement (p, el, attr, p->hydrate_expecting == NULL);
1686
1687         if (p->error_args)
1688                 return;
1689
1690
1691         if (elem) {
1692                 if (p->hydrate_expecting){
1693                         /*
1694                         Type::Kind expecting_type =  p->hydrate_expecting->GetObjectType ();
1695
1696                         if (!types->IsSubclassOf (expecting_type, elem->GetKind ())) {
1697                                 parser_error (p, el, NULL, -1, "Invalid top-level element found %s, expecting %s", el,
1698                                               types->Find (expecting_type)->GetName ());
1699                                 return;
1700                         }
1701                         */
1702
1703                         inst = elem->CreateWrappedElementInstance (p, p->hydrate_expecting);
1704                         p->hydrate_expecting = NULL;
1705                 } else
1706                         inst = elem->CreateElementInstance (p);
1707
1708                 if (!inst)
1709                         return;
1710
1711                 inst->parent = p->current_element;
1712
1713                 if (!p->top_element) {
1714                         p->top_element = inst;
1715                         if (inst->GetAsDependencyObject ())
1716                                 NameScope::SetNameScope (inst->GetAsDependencyObject (), p->namescope);
1717                 }
1718
1719                 if (inst->GetAsDependencyObject ())
1720                         inst->GetAsDependencyObject ()->SetIsBeingParsed (true);
1721
1722                 inst->SetAttributes (p, attr);
1723                 if (p->error_args)
1724                         return;
1725
1726                 if (inst->IsDependencyObject ()) {
1727                         if (p->current_element){
1728                                 if (p->current_element->info) {
1729                                         p->current_element->AddChild (p, inst);
1730                                         if (p->error_args)
1731                                                 return;
1732                                 }
1733                         }
1734                 }
1735         } else {
1736                 // it's actually valid (from SL point of view) to have <Ellipse.Triggers> inside a <Rectangle>
1737                 // however we can't add properties to something bad, like a <Recta.gle> element
1738                 XamlElementInfo *prop_info = NULL;
1739                 if (dot) {
1740                         gchar *prop_elem = g_strndup (el, dot - el);
1741                         prop_info = p->current_element->FindPropertyElement (p, el, dot);
1742                         g_free (prop_elem);
1743                 }
1744
1745                 if (prop_info != NULL) {
1746                         inst = prop_info->CreatePropertyElementInstance (p, g_strdup (el));
1747                         inst->parent = p->current_element;
1748
1749                         if (attr [0] != NULL) {
1750                                 // It appears there is a bug in the error string but it matches the MS runtime
1751                                 parser_error (p, el, NULL, 2018, "The element %s does not support attributes.", attr[0]);
1752                                 return;
1753                         }
1754
1755                         if (prop_info && !strcmp (el, "TextBox.Text"))
1756                                 prop_info->SetIsCDataVerbatim (true);
1757
1758                         if (!p->top_element) {
1759                                 if (types->IsSubclassOf (prop_info->GetKind (), Type::COLLECTION)) {
1760                                         XamlElementInstance *wrap = prop_info->CreateElementInstance (p);
1761                                         NameScope::SetNameScope (wrap->GetAsDependencyObject (), p->namescope);
1762                                         p->top_element = wrap;
1763                                         p->current_element = wrap;
1764                                         return;
1765                                 }
1766                         }
1767                 } else {
1768                         g_warning ("Unknown element: %s.", el);
1769                         parser_error (p, el, NULL, 2007, "Unknown element: %s.", el);
1770                         return;
1771                 }
1772         }
1773
1774         if (p->current_element) {
1775                 p->current_element->children->Append (inst);
1776         }
1777         p->current_element = inst;
1778
1779         if (elem && element_begins_buffering (elem->GetKind ())) {
1780                 p->QueueBeginBuffering (g_strdup (el), BUFFER_MODE_TEMPLATE);
1781         }
1782 }
1783
1784 static bool
1785 allow_value_from_str_in_flush (XamlParserInfo *p, XamlElementInstance *parent)
1786 {
1787         if (parent == NULL || parent->element_type != XamlElementInstance::PROPERTY || parent->parent == NULL || !parent->parent->IsDependencyObject ())
1788                 return false;
1789
1790         if (parent->info->GetKind () == Type::OBJECT)
1791                 return true;
1792
1793         return false;
1794 }
1795
1796 static void
1797 flush_char_data (XamlParserInfo *p)
1798 {
1799         if (p->InBufferingMode ())
1800                 return;
1801
1802         if (!p->cdata || !p->current_element)
1803                 return;
1804
1805         if (p->current_element->info->IsCDataVerbatim()) {
1806                 p->cdata->str = g_strstrip (p->cdata->str);
1807         }
1808
1809         if (p->current_element->element_type == XamlElementInstance::ELEMENT) {
1810                 if (!p->current_element->TrySetContentProperty (p, p->cdata->str) && p->cdata_content) {
1811                         if (allow_value_from_str_in_flush (p, p->current_element->parent)) {
1812                                 Value *v;
1813                                 if (value_from_str (p->current_element->info->GetKind (), NULL, p->cdata->str, &v)) {
1814                                         p->current_element->SetValue (v);
1815                                         goto cleanup;
1816                                 }
1817                         }
1818                         parser_error (p, p->current_element->element_name, NULL, 2011,
1819                                       "%s does not support text content.", p->current_element->element_name);
1820                 }
1821         } else if (p->current_element->element_type == XamlElementInstance::PROPERTY) {
1822                 if (p->cdata_content && p->current_element->parent && !p->current_element->parent->SetProperty (p, p->current_element, p->cdata->str)) {
1823                         parser_error (p, p->current_element->element_name, NULL, 2011,
1824                                       "%s does not support text content.", p->current_element->element_name);
1825                 }
1826         }
1827
1828 cleanup:
1829         if (p->cdata) {
1830                 g_string_free (p->cdata, TRUE);
1831                 p->cdata_content = false;
1832                 p->cdata = NULL;
1833         }
1834 }
1835
1836 static bool
1837 element_begins_buffering (Type::Kind kind)
1838 {
1839         return Type::IsSubclassOf (Deployment::GetCurrent (), kind, Type::FRAMEWORKTEMPLATE);
1840 }
1841
1842 static gboolean
1843 is_default_namespace (gpointer key, gpointer value, gpointer user_data)
1844 {
1845         return value == default_namespace;
1846 }
1847
1848 static void
1849 start_element_handler (void *data, const char *el, const char **attr)
1850 {
1851         XamlParserInfo *p = (XamlParserInfo *) data;
1852
1853         if (p->error_args)
1854                 return;
1855
1856         char **name = g_strsplit (el, "|",  -1);
1857         XamlNamespace *next_namespace = NULL;
1858         char *element = NULL;
1859
1860         if (g_strv_length (name) == 2) {
1861                 // Find the proper namespace for our next element
1862                 next_namespace = (XamlNamespace *) g_hash_table_lookup (p->namespace_map, name [0]);
1863                 element = name [1];
1864         }
1865
1866         if (!next_namespace && p->implicit_default_namespace) {
1867                 // Use the default namespace for the next element
1868                 next_namespace = default_namespace;
1869                 element = name [0];
1870         } else if (!next_namespace) {
1871                 if (!g_hash_table_find (p->namespace_map, is_default_namespace, NULL))
1872                         return parser_error (p, el, NULL, 2263, "AG_E_PARSER_MISSING_DEFAULT_NAMESPACE");
1873         }
1874
1875         if (next_namespace && next_namespace->is_ignored) {
1876                 p->current_namespace = next_namespace;
1877                 if (!p->InBufferingMode ())
1878                         p->QueueBeginBuffering (g_strdup (element), BUFFER_MODE_IGNORE);
1879
1880                 start_element (data, element, attr); // This will force the buffering to start/build depth if needed
1881                 return;
1882         }
1883
1884         p->next_element = element;
1885
1886         flush_char_data (p);
1887
1888         // Now update our namespace
1889         p->current_namespace = next_namespace;
1890
1891         if (!p->current_namespace && !p->InBufferingMode ()) {
1892                 if (name[1])
1893                         parser_error (p, name[1], NULL, -1, "No handlers available for namespace: '%s' (%s)\n", name[0], el);
1894                 else
1895                         parser_error (p, name[1], NULL, -1, "No namespace mapping available for element: '%s'\n", el);
1896
1897                 g_strfreev (name);
1898                 return;
1899         }
1900
1901         p->next_element = NULL;
1902         start_element (data, element, attr);
1903
1904         g_strfreev (name);
1905 }
1906
1907 static char*
1908 get_element_name (XamlParserInfo* p, const char *el)
1909 {
1910         char **names = g_strsplit (el, "|",  -1);
1911         char *name = g_strdup (names [g_strv_length (names) - 1]);
1912
1913         g_strfreev (names);
1914
1915         return name;
1916 }
1917
1918 static GSList *
1919 create_resource_list (XamlParserInfo *p)
1920 {
1921         GSList *list = NULL;
1922         XamlElementInstance *walk = p->current_element;
1923
1924         Types * types = Deployment::GetCurrent ()->GetTypes ();
1925         while (walk) {
1926                 if (walk->element_type == XamlElementInstance::ELEMENT && types->IsSubclassOf (walk->info->GetKind (), Type::FRAMEWORKELEMENT)) {
1927                         FrameworkElement *fwe = (FrameworkElement *)walk->GetAsDependencyObject ();
1928                         if (g_slist_index (list, fwe) == -1)
1929                                 list = g_slist_prepend (list, fwe);
1930                 }
1931                 if (walk->element_type == XamlElementInstance::ELEMENT && types->IsSubclassOf (walk->info->GetKind (), Type::RESOURCE_DICTIONARY)) {
1932                         ResourceDictionary *rd = (ResourceDictionary *) walk->GetAsDependencyObject ();
1933                         if (g_slist_index (list, rd) == -1)
1934                                 list = g_slist_prepend (list, walk->GetAsDependencyObject ());
1935                 }
1936                 walk = walk->parent;
1937         }
1938
1939         list = g_slist_reverse (list);
1940         return list;
1941 }
1942
1943 static XamlContext *
1944 create_xaml_context (XamlParserInfo *p, FrameworkTemplate *template_, XamlContext *parent_context)
1945 {
1946         GSList *resources = create_resource_list (p);
1947         XamlContextInternal *ic =  new XamlContextInternal (p->loader->callbacks, p->GetTopElementPtr (), template_, p->namespace_map, resources, parent_context ? parent_context->internal : NULL);
1948         return new XamlContext (ic);
1949 }
1950
1951 static void
1952 end_element_handler (void *data, const char *el)
1953 {
1954         XamlParserInfo *p = (XamlParserInfo *) data;
1955         DependencyObject *obj;
1956
1957         if (!strcmp (el, INTERNAL_IGNORABLE_ELEMENT))
1958                 return;
1959
1960         if (p->error_args)
1961                 return;
1962
1963         if (!p->current_element) {
1964                 g_warning ("p->current_element == NULL, current_element = %p (%s)\n",
1965                            p->current_element, p->current_element ? p->current_element->element_name : "<NULL>");
1966                 return;
1967         }
1968
1969         if (p->InBufferingMode ()) {
1970                 char* name = get_element_name (p, el);
1971                 if (!strcmp (p->buffer_until_element, name)) {
1972                         p->buffer_depth--;
1973
1974                         if (p->buffer_depth == 0) {
1975                                 if (p->buffer_mode == BUFFER_MODE_TEMPLATE) {
1976                                         // OK we are done buffering, the element we are buffering for
1977                                         FrameworkTemplate* template_ = (FrameworkTemplate *) p->current_element->GetAsDependencyObject ();
1978
1979                                         char* buffer = p->ClearBuffer ();
1980
1981                                         XamlContext *context = create_xaml_context (p, template_, p->loader->GetContext());
1982
1983                                         if (p->validate_templates) {
1984                                                 p->ValidateTemplate (buffer, context, template_);
1985
1986                                                 if (p->error_args)
1987                                                         return;
1988                                         }
1989
1990                                         template_->SetXamlBuffer (context, buffer);
1991                                         p->current_element = p->current_element->parent;
1992                                 } else if (p->buffer_mode == BUFFER_MODE_IGNORE) {
1993                                         // For now we'll actually keep/clear this buffer because it makes testing easier
1994                                         char *buffer = p->ClearBuffer ();
1995                                         g_free (buffer);
1996                                 }
1997                         }
1998                 }
1999
2000                 g_free (name);
2001                 return;
2002         }
2003
2004         switch (p->current_element->element_type) {
2005         case XamlElementInstance::ELEMENT:
2006
2007                 p->current_element->SetDelayedProperties (p);
2008                 flush_char_data (p);
2009
2010                 // according to http://blogs.msdn.com/devdave/archive/2008/10/11/control-lifecycle.aspx
2011                 // default styles are apply when the end tag is read.
2012                 //
2013                 if (p->current_element->IsDependencyObject () &&
2014                     p->current_element->GetAsDependencyObject() &&
2015                     p->current_element->GetAsDependencyObject()->Is(Type::CONTROL)) {
2016
2017                         Control *control = (Control*)p->current_element->GetAsDependencyObject();
2018                         ManagedTypeInfo *key = control->GetDefaultStyleKey ();
2019
2020                         if (key) {
2021                                 if (Application::GetCurrent () == NULL)
2022                                         g_warning ("attempting to use a null application applying default style while parsing.");
2023                                 else
2024                                         Application::GetCurrent()->ApplyDefaultStyle (control, key);
2025                         }
2026                 }
2027                 else if (!p->current_element->IsDependencyObject ()) {
2028
2029                         if (p->current_element->parent)
2030                                 p->current_element->parent->AddChild (p, p->current_element);
2031                 }
2032                 break;
2033         case XamlElementInstance::PROPERTY: {
2034                 List::Node *walk = p->current_element->children->First ();
2035                 while (walk) {
2036                         XamlElementInstance *child = (XamlElementInstance *) walk;
2037                         if (p->current_element->parent) {
2038                                 p->current_element->parent->SetProperty (p, p->current_element, child);
2039                         }
2040                         walk = walk->next;
2041                 }
2042                 flush_char_data (p);
2043                 break;
2044         }
2045         }
2046
2047         if ((obj = p->current_element->GetAsDependencyObject ()))
2048                 obj->SetIsBeingParsed (false);
2049
2050         p->current_element = p->current_element->parent;
2051 }
2052
2053 static void
2054 char_data_handler (void *data, const char *in, int inlen)
2055 {
2056         XamlParserInfo *p = (XamlParserInfo *) data;
2057         register const char *inptr = in;
2058         const char *inend = in + inlen;
2059         const char *start;
2060
2061         if (p->InBufferingMode ())
2062                 return;
2063
2064         if (p->error_args)
2065                 return;
2066
2067         if (p->current_element && p->current_element->info->IsCDataVerbatim()) {
2068                 if (!p->cdata)
2069                         p->cdata = g_string_new ("");
2070
2071                 g_string_append_len (p->cdata, inptr, inlen);
2072                 p->cdata_content = true;
2073                 return;
2074         }
2075
2076         if (!p->cdata) {
2077                 p->cdata = g_string_new ("");
2078
2079                 if (g_ascii_isspace (*inptr)) {
2080                         g_string_append_c (p->cdata, ' ');
2081                         inptr++;
2082
2083                         while (inptr < inend && g_ascii_isspace (*inptr))
2084                                 inptr++;
2085                 }
2086
2087                 if (inptr == inend)
2088                         return;
2089         } else if (g_ascii_isspace (p->cdata->str[p->cdata->len - 1])) {
2090                 // previous cdata chunk ended with lwsp, skip over leading lwsp for this chunk
2091                 while (inptr < inend && g_ascii_isspace (*inptr))
2092                         inptr++;
2093         }
2094
2095         while (inptr < inend) {
2096                 start = inptr;
2097                 while (inptr < inend && !g_ascii_isspace (*inptr))
2098                         inptr++;
2099
2100                 if (inptr > start) {
2101                         g_string_append_len (p->cdata, start, inptr - start);
2102                         p->cdata_content = true;
2103                 }
2104
2105                 if (inptr < inend) {
2106                         g_string_append_c (p->cdata, ' ');
2107                         inptr++;
2108
2109                         while (inptr < inend && g_ascii_isspace (*inptr))
2110                                 inptr++;
2111                 }
2112         }
2113 }
2114
2115 static void
2116 start_namespace_handler (void *data, const char *prefix, const char *uri)
2117 {
2118         XamlParserInfo *p = (XamlParserInfo *) data;
2119
2120         if (p->InBufferingMode ())
2121                 return;
2122
2123         if (p->error_args)
2124                 return;
2125
2126         if (p->loader != NULL && p->loader->callbacks.import_xaml_xmlns != NULL) {
2127                 MoonError error;
2128                 XamlCallbackData data = XamlCallbackData (p->loader, p, p->GetTopElementPtr ());
2129                 if (!p->loader->callbacks.import_xaml_xmlns (&data, uri, &error))
2130                         return parser_error (p, p->current_element ? p->current_element->element_name : NULL, prefix, 2005, "Unknown namespace %s", uri);
2131         }
2132
2133         for (int i = 0; default_namespace_names [i]; i++) {
2134                 if (!strcmp (default_namespace_names [i], uri)) {
2135                         g_hash_table_insert (p->namespace_map, g_strdup (uri), default_namespace);
2136                         return;
2137                 }
2138         }
2139
2140         if (!strcmp (X_NAMESPACE_URI, uri)){
2141                 g_hash_table_insert (p->namespace_map, g_strdup (uri), x_namespace);
2142         } else if (!strcmp (PRIMITIVE_NAMESPACE_URI, uri)) {
2143                 PrimitiveNamespace *pn = new PrimitiveNamespace (g_strdup (prefix));
2144                 g_hash_table_insert (p->namespace_map, g_strdup (uri), pn);
2145                 p->AddCreatedNamespace (pn);
2146         } else if (!strcmp (MC_IGNORABLE_NAMESPACE_URI, uri)) {
2147                 MCIgnorableNamespace *mc = new MCIgnorableNamespace (g_strdup (prefix));
2148                 g_hash_table_insert (p->namespace_map, g_strdup (uri), mc);
2149                 p->AddCreatedNamespace (mc);
2150         } else {
2151                 if (!p->loader) {
2152                         return parser_error (p, (p->current_element ? p->current_element->element_name : NULL), prefix, -1,
2153                                              "No managed element callback installed to handle %s", uri);
2154                 }
2155
2156                 if (!prefix) {
2157                         parser_error (p, (p->current_element ? p->current_element->element_name : NULL), NULL, 2262,
2158                                       "AG_E_PARSER_NAMESPACE_NOT_SUPPORTED");
2159                         return;
2160                 }
2161
2162                 XamlNamespace *ns = (XamlNamespace *) g_hash_table_lookup (p->namespace_map, uri);
2163
2164                 if (ns) {
2165                         ns->AddPrefix (prefix);
2166                         return;
2167                 }
2168
2169                 ManagedNamespace *c = new ManagedNamespace (g_strdup (uri), g_strdup (prefix));
2170                 g_hash_table_insert (p->namespace_map, g_strdup (c->xmlns), c);
2171                 p->AddCreatedNamespace (c);
2172         }
2173 }
2174
2175 static void
2176 start_doctype_handler (void *data,
2177                 const XML_Char *doctype_name,
2178                 const XML_Char *sysid,
2179                 const XML_Char *pubid,
2180                 int has_internal_subset)
2181 {
2182         XamlParserInfo *p = (XamlParserInfo *) data;
2183
2184         if (p->InBufferingMode ())
2185                 return;
2186
2187         if (sysid)
2188                 return parser_error (p, NULL, NULL, 7050, "DTD was found but is prohibited");
2189
2190         if (doctype_name)
2191                 return parser_error (p, NULL, NULL, 7016, "incorrect document syntax.");
2192 }
2193
2194 static void
2195 add_default_namespaces (XamlParserInfo *p, bool sl_xmlns)
2196 {
2197         if (sl_xmlns) {
2198                 p->implicit_default_namespace = true;
2199                 g_hash_table_insert (p->namespace_map, g_strdup ("http://schemas.microsoft.com/winfx/2006/xaml/presentation"), default_namespace);
2200                 g_hash_table_insert (p->namespace_map, g_strdup (X_NAMESPACE_URI), x_namespace);
2201         }
2202         g_hash_table_insert (p->namespace_map, g_strdup (XML_NAMESPACE_URI), xml_namespace);
2203 }
2204
2205 static void
2206 print_tree (XamlElementInstance *el, int depth)
2207 {
2208 #if DEBUG
2209         if (debug_flags & RUNTIME_DEBUG_XAML) {
2210                 for (int i = 0; i < depth; i++)
2211                         printf ("\t");
2212
2213                 const char *name = NULL;
2214
2215                 if (!el) {
2216                         printf (" -null- \n");
2217                         return;
2218                 }
2219
2220                 if (el->element_type == XamlElementInstance::ELEMENT && el->IsDependencyObject ())
2221                         name = el->GetAsDependencyObject ()->GetName ();
2222                 printf ("%s  (%s)  (%p) (%s)\n", el->element_name, name ? name : "-no name-", el->parent, el->element_type == XamlElementInstance::PROPERTY ? "PROPERTY" : "ELEMENT");
2223
2224                 for (List::Node *walk = el->children->First (); walk != NULL; walk = walk->next) {
2225                         XamlElementInstance *el = (XamlElementInstance *) walk;
2226                         print_tree (el, depth + 1);
2227                 }
2228         }
2229 #endif
2230 }
2231
2232 void
2233 xaml_parse_xmlns (const char* xmlns, char** type_name, char** ns, char** assembly)
2234 {
2235         const char delimiters[]  = ";";
2236         char* decl;
2237         char* buffer = g_strdup (xmlns);
2238
2239         *type_name = NULL;
2240         *ns = NULL;
2241         *assembly = NULL;
2242
2243         decl = strtok (buffer, delimiters);
2244         while (decl != NULL) {
2245                 if (strstr (decl, "clr-namespace:") == decl) {
2246                         if (*ns)
2247                                 g_free (*ns);
2248                         *ns = g_strdup (decl + 14);
2249                 } else if (strstr (decl, "assembly=") == decl) {
2250                         if (*assembly)
2251                                 g_free (*assembly);
2252                         *assembly = g_strdup (decl + 9);
2253                 } else {
2254                         if (*type_name)
2255                                 g_free (*type_name);
2256                         *type_name = g_strdup (decl);
2257                 }
2258
2259                 decl = strtok (NULL, delimiters);
2260         }
2261         g_free (buffer);
2262 }
2263
2264 Value *
2265 XamlLoader::CreateFromFile (const char *xaml_file, bool create_namescope,
2266                             Type::Kind *element_type)
2267 {
2268         Value *res = NULL;
2269         XamlParserInfo *parser_info = NULL;
2270         XML_Parser p = NULL;
2271         bool first_read = true;
2272         const char *inptr, *inend;
2273         TextStream *stream;
2274         char buffer[4096];
2275         ssize_t nread, n;
2276
2277         LOG_XAML ("attemtping to load xaml file: %s\n", xaml_file);
2278
2279         stream = new TextStream ();
2280         if (!stream->OpenFile (xaml_file, false)) {
2281                 LOG_XAML ("can not open file\n");
2282                 goto cleanup_and_return;
2283         }
2284
2285         if (!(p = XML_ParserCreateNS ("UTF-8", '|'))) {
2286                 LOG_XAML ("can not create parser\n");
2287                 goto cleanup_and_return;
2288         }
2289
2290         parser_info = new XamlParserInfo (p, xaml_file);
2291
2292         parser_info->namescope->SetTemporary (!create_namescope);
2293
2294         parser_info->loader = this;
2295
2296         // TODO: This is just in here temporarily, to make life less difficult for everyone
2297         // while we are developing.
2298         add_default_namespaces (parser_info, false);
2299
2300         XML_SetUserData (p, parser_info);
2301
2302         XML_SetElementHandler (p, start_element_handler, end_element_handler);
2303         XML_SetCharacterDataHandler (p, char_data_handler);
2304         XML_SetNamespaceDeclHandler(p, start_namespace_handler, NULL);
2305         XML_SetDoctypeDeclHandler(p, start_doctype_handler, NULL);
2306
2307         /*
2308         XML_SetProcessingInstructionHandler (p, proc_handler);
2309         */
2310
2311         while ((nread = stream->Read (buffer, sizeof (buffer))) >= 0) {
2312                 inptr = buffer;
2313                 n = nread;
2314
2315                 if (first_read && nread > 0) {
2316                         // Remove preceding white space
2317                         inend = buffer + nread;
2318
2319                         while (inptr < inend && g_ascii_isspace (*inptr))
2320                                 inptr++;
2321
2322                         if (inptr == inend)
2323                                 continue;
2324
2325                         n = (inend - inptr);
2326                         first_read = false;
2327                 }
2328
2329                 parser_info->SetXmlBuffer (inptr);
2330                 if (!XML_Parse (p, inptr, n, nread == 0)) {
2331                         expat_parser_error (parser_info, XML_GetErrorCode (p));
2332                         goto cleanup_and_return;
2333                 }
2334
2335                 if (nread == 0)
2336                         break;
2337         }
2338
2339         print_tree (parser_info->top_element, 0);
2340
2341         if (parser_info->top_element) {
2342                 res = parser_info->top_element->GetAsValue ();
2343                 // We want a copy because the old one is going to be deleted
2344                 res = new Value (*res);
2345
2346                 if (element_type)
2347                         *element_type = parser_info->top_element->info->GetKind ();
2348
2349                 if (parser_info->error_args) {
2350                         *element_type = Type::INVALID;
2351                         goto cleanup_and_return;
2352                 }
2353         }
2354
2355  cleanup_and_return:
2356
2357         if (!parser_info)
2358                 error_args = new ParserErrorEventArgs ("Error opening xaml file", xaml_file, 0, 0, 1, "", "");
2359         else if (parser_info->error_args) {
2360                 error_args = parser_info->error_args;
2361                 error_args->ref ();
2362         }
2363
2364         delete stream;
2365
2366         if (p)
2367                 XML_ParserFree (p);
2368
2369         if (parser_info)
2370                 delete parser_info;
2371
2372         return res;
2373 }
2374
2375 Value *
2376 XamlLoader::CreateFromString (const char *xaml, bool create_namescope, Type::Kind *element_type, int flags)
2377 {
2378         return HydrateFromString (xaml, NULL, create_namescope, element_type, flags);
2379 }
2380
2381 DependencyObject *
2382 value_to_dependency_object (Value *value)
2383 {
2384         if (!value || !value->Is (Deployment::GetCurrent (), Type::DEPENDENCY_OBJECT))
2385                 return NULL;
2386         return value->AsDependencyObject ();
2387 }
2388
2389 DependencyObject *
2390 XamlLoader::CreateDependencyObjectFromFile (const char *xaml, bool create_namescope, Type::Kind *element_type)
2391 {
2392         return value_to_dependency_object (CreateFromFile (xaml, create_namescope, element_type));
2393 }
2394
2395 DependencyObject *
2396 XamlLoader::CreateDependencyObjectFromString (const char *xaml, bool create_namescope, Type::Kind *element_type)
2397 {
2398         return value_to_dependency_object (CreateFromString (xaml, create_namescope, element_type, IMPORT_DEFAULT_XMLNS));
2399 }
2400
2401 /**
2402  * Hydrates an existing DependencyObject (@object) with the contents from the @xaml
2403  * data
2404  */
2405 Value *
2406 XamlLoader::HydrateFromString (const char *xaml, Value *object, bool create_namescope, Type::Kind *element_type, int flags)
2407 {
2408         XML_Parser p = XML_ParserCreateNS ("utf-8", '|');
2409         XamlParserInfo *parser_info = NULL;
2410         Value *res = NULL;
2411         char *start = (char*)xaml;
2412         char *prepend = NULL;
2413         char *append = NULL;
2414         char * inputs [4] = {NULL, NULL, NULL, NULL};
2415
2416         inputs [0] = start;
2417
2418         if (!p) {
2419                 LOG_XAML ("can not create parser\n");
2420                 goto cleanup_and_return;
2421         }
2422
2423 #if 0
2424         if (true) {
2425                 static int id = 0;
2426                 char filename[64];
2427                 FILE *fp;
2428
2429                 sprintf (filename, "createFromXaml.%d.xaml", id++);
2430                 if ((fp = fopen (filename, "wt")) != NULL) {
2431                         fwrite (xaml, strlen (xaml), 1, fp);
2432                         fclose (fp);
2433                 }
2434         }
2435 #endif
2436
2437         parser_info = new XamlParserInfo (p, NULL);
2438
2439         parser_info->namescope->SetTemporary (!create_namescope);
2440
2441         parser_info->loader = this;
2442         parser_info->validate_templates = (flags & VALIDATE_TEMPLATES) == VALIDATE_TEMPLATES;
2443
2444         //
2445         // If we are hydrating, we are not null
2446         //
2447         if (object != NULL) {
2448                 parser_info->hydrate_expecting = object;
2449                 parser_info->hydrating = true;
2450                 if (Type::IsSubclassOf (parser_info->deployment, object->GetKind (), Type::DEPENDENCY_OBJECT)) {
2451                         DependencyObject *dob = object->AsDependencyObject ();
2452                         dob->SetIsAttached (true);
2453                         dob->SetResourceBase (GetResourceBase());
2454                 }
2455         } else {
2456                 parser_info->hydrate_expecting = NULL;
2457                 parser_info->hydrating = false;
2458         }
2459
2460         // from_str gets the default namespaces implictly added
2461         add_default_namespaces (parser_info, (flags & IMPORT_DEFAULT_XMLNS) == IMPORT_DEFAULT_XMLNS);
2462
2463         XML_SetUserData (p, parser_info);
2464
2465         XML_SetElementHandler (p, start_element_handler, end_element_handler);
2466         XML_SetCharacterDataHandler (p, char_data_handler);
2467         XML_SetNamespaceDeclHandler(p, start_namespace_handler, NULL);
2468         XML_SetDoctypeDeclHandler(p, start_doctype_handler, NULL);
2469
2470         /*
2471         XML_SetProcessingInstructionHandler (p, proc_handler);
2472         */
2473
2474         if (context) {
2475                 prepend = context->internal->CreateIgnorableTagOpen ();
2476                 append = context->internal->CreateIgnorableTagClose ();
2477
2478                 inputs [0] = prepend;
2479                 inputs [1] = start;
2480                 inputs [2] = append;
2481         }
2482
2483         for (int i = 0; inputs [i]; i++) {
2484                 char *start = inputs [i];
2485
2486                 // don't freak out if the <?xml ... ?> isn't on the first line (see #328907)
2487                 while (g_ascii_isspace (*start))
2488                         start++;
2489
2490                 parser_info->SetXmlBuffer (start);
2491                 if (!XML_Parse (p, start, strlen (start), inputs [i + 1] == NULL)) {
2492                         expat_parser_error (parser_info, XML_GetErrorCode (p));
2493                         LOG_XAML ("error parsing:  %s\n\n", xaml);
2494                         goto cleanup_and_return;
2495                 }
2496         }
2497
2498         print_tree (parser_info->top_element, 0);
2499
2500         if (parser_info->top_element) {
2501                 if (is_legal_top_level_kind (parser_info->top_element->info->GetKind ())) {
2502                         res = parser_info->top_element->GetAsValue ();
2503                         res = new Value (*res);
2504                         if (res->Is (parser_info->deployment, Type::DEPENDENCY_OBJECT) && object) {
2505                                 DependencyObject *dob = res->AsDependencyObject ();
2506                                 dob->unref ();
2507                                 dob->SetIsHydratedFromXaml (parser_info->hydrating);
2508                         }
2509                 }
2510
2511                 if (element_type)
2512                         *element_type = parser_info->top_element->info->GetKind ();
2513
2514                 if (!res && !parser_info->error_args)
2515                         parser_info->error_args = new ParserErrorEventArgs ("No DependencyObject found", "", 0, 0, 1, "", "");
2516
2517                 if (parser_info->error_args) {
2518                         delete res;
2519                         res = NULL;
2520                         if (element_type)
2521                                 *element_type = Type::INVALID;
2522                         goto cleanup_and_return;
2523                 }
2524         }
2525
2526  cleanup_and_return:
2527
2528         if (parser_info->error_args) {
2529                 error_args = parser_info->error_args;
2530                 printf ("Could not parse element %s, attribute %s, error: %s\n",
2531                         error_args->xml_element,
2532                         error_args->xml_attribute,
2533                         error_args->GetErrorMessage());
2534         }
2535
2536         if (p)
2537                 XML_ParserFree (p);
2538         if (parser_info)
2539                 delete parser_info;
2540         if (prepend)
2541                 g_free (prepend);
2542         if (append)
2543                 g_free (append);
2544
2545         return res;
2546 }
2547
2548 Value *
2549 XamlLoader::CreateFromFileWithError (const char *xaml_file, bool create_namescope, Type::Kind *element_type, MoonError *error)
2550 {
2551         Value *res = CreateFromFile (xaml_file, create_namescope, element_type);
2552         if (error_args && error_args->GetErrorCode () != -1)
2553                 MoonError::FillIn (error, error_args);
2554         return res;
2555 }
2556
2557 Value *
2558 XamlLoader::CreateFromStringWithError  (const char *xaml, bool create_namescope, Type::Kind *element_type, int flags, MoonError *error)
2559 {
2560         Value *res = CreateFromString (xaml, create_namescope, element_type, flags);
2561         if (error_args && error_args->GetErrorCode () != -1)
2562                 MoonError::FillIn (error, error_args);
2563         return res;
2564 }
2565
2566 Value *
2567 XamlLoader::HydrateFromStringWithError (const char *xaml, Value *object, bool create_namescope, Type::Kind *element_type, int flags, MoonError *error)
2568 {
2569         Value *res = HydrateFromString (xaml, object, create_namescope, element_type, flags);
2570         if (error_args && error_args->GetErrorCode () != -1)
2571                 MoonError::FillIn (error, error_args);
2572         return res;
2573 }
2574
2575 static int
2576 parse_int (const char **pp, const char *end)
2577 {
2578         const char *p = *pp;
2579 #if 0
2580         if (optional && AtEnd)
2581                 return 0;
2582 #endif
2583
2584         int res = 0;
2585         int count = 0;
2586
2587         while (p <= end && g_ascii_isdigit (*p)) {
2588                 res = res * 10 + *p - '0';
2589                 p++;
2590                 count++;
2591         }
2592
2593 #if 0
2594         if (count == 0)
2595                 formatError = true;
2596 #endif
2597
2598         *pp = p;
2599         return res;
2600 }
2601
2602 static gint64
2603 parse_ticks (const char **pp, const char *end)
2604 {
2605         gint64 mag = 1000000;
2606         gint64 res = 0;
2607         bool digitseen = false;
2608
2609         const char *p = *pp;
2610
2611         while (mag > 0 && p <= end && g_ascii_isdigit (*p)) {
2612                 res = res + (*p - '0') * mag;
2613                 p++;
2614                 mag = mag / 10;
2615                 digitseen = true;
2616         }
2617
2618 #if 0
2619         if (!digitseen)
2620                 formatError = true;
2621 #endif
2622
2623         *pp = p;
2624         return res;
2625 }
2626
2627 bool
2628 time_span_from_str (const char *str, TimeSpan *res)
2629 {
2630         const char *end = str + strlen (str);
2631         const char *p;
2632
2633         bool negative = false;
2634         int days;
2635         int hours;
2636         int minutes;
2637         int seconds;
2638         gint64 ticks;
2639
2640         p = str;
2641
2642         if (*p == '-') {
2643                 p++;
2644                 negative = true;
2645         }
2646
2647         days = parse_int (&p, end);
2648
2649         if (*p == '.') {
2650                 p++;
2651                 hours = parse_int (&p, end);
2652         }
2653         else {
2654                 hours = days;
2655                 days = 0;
2656         }
2657
2658         if (*p == ':') p++;
2659         minutes = parse_int (&p, end);
2660         if (*p == ':') p++;
2661         seconds = parse_int (&p, end);
2662         if (*p == '.') {
2663                 p++;
2664                 ticks = parse_ticks (&p, end);
2665         }
2666         else {
2667                 ticks = 0;
2668         }
2669
2670         gint64 t = (days * 86400) + (hours * 3600) + (minutes * 60) + seconds;
2671         t *= 10000000L;
2672
2673         *res = negative ? (-t - ticks) : (t + ticks);
2674
2675         return true;
2676 }
2677
2678 bool
2679 repeat_behavior_from_str (const char *str, RepeatBehavior *res)
2680 {
2681         if (!g_ascii_strcasecmp ("Forever", str)) {
2682                 *res = RepeatBehavior::Forever;
2683                 return true;
2684         }
2685
2686         // check for "<float>x".
2687
2688         // XXX more validation work is needed here.. but how do we
2689         // report an error?
2690         const char *x = strchr (str, 'x');
2691         if (x) {
2692                 if (*(x + 1) != '\0') {
2693                         return false;
2694                 }
2695                 else {
2696                         char *endptr;
2697                         errno = 0;
2698                         double d = g_ascii_strtod (str, &endptr);
2699
2700                         if (errno || endptr == str)
2701                                 return false;
2702
2703                         *res = RepeatBehavior (d);
2704                         return true;
2705                 }
2706         }
2707
2708         /* XXX RepeatBehavior='XX:XX:XX' syntax is NOT correctly supported by
2709            Silverlight 1.0 (most likely a bug). It works fine in Silverlight 2.0
2710            though. We currently stick to the 2.0 behavior, not replicating the bug
2711            from 1.0.
2712         */
2713         TimeSpan t;
2714         if (!time_span_from_str (str, &t))
2715                 return false;
2716
2717         *res = RepeatBehavior (t);
2718
2719         return true;
2720 }
2721
2722 bool
2723 duration_from_str (const char *str, Duration *res)
2724 {
2725         if (!g_ascii_strcasecmp ("Automatic", str)) {
2726                 *res = Duration::Automatic;
2727                 return true;
2728         }
2729
2730         if (!g_ascii_strcasecmp ("Forever", str)) {
2731                 *res = Duration::Forever;
2732                 return true;
2733         }
2734
2735         TimeSpan ts;
2736         if (!time_span_from_str (str, &ts))
2737                 return false;
2738
2739         *res = Duration (ts);
2740         return true;
2741 }
2742
2743 bool
2744 keytime_from_str (const char *str, KeyTime *res)
2745 {
2746         if (!g_ascii_strcasecmp ("Uniform", str)) {
2747                 *res = KeyTime::Uniform;
2748                 return true;
2749         }
2750
2751         if (!g_ascii_strcasecmp ("Paced", str)) {
2752                 *res = KeyTime::Paced;
2753                 return true;
2754         }
2755
2756         /* check for a percentage first */
2757         const char *last = str + strlen(str) - 1;
2758         if (*last == '%') {
2759                 char *ep;
2760                 double pct = g_ascii_strtod (str, &ep);
2761                 if (ep == last) {
2762                         *res = KeyTime (pct);
2763                         return true;
2764                 }
2765         }
2766
2767         TimeSpan ts;
2768         if (!time_span_from_str (str, &ts))
2769                 return false;
2770
2771         *res = KeyTime (ts);
2772         return true;
2773 }
2774
2775 bool
2776 key_spline_from_str (const char *str, KeySpline **res)
2777 {
2778         PointCollection *pts = PointCollection::FromStr (str);
2779
2780         if (!pts)
2781                 return false;
2782
2783         if (pts->GetCount () != 2) {
2784                 pts->unref ();
2785                 return false;
2786         }
2787
2788         *res = new KeySpline (*pts->GetValueAt (0)->AsPoint (), *pts->GetValueAt (1)->AsPoint ());
2789
2790         pts->unref ();
2791
2792         return true;
2793 }
2794
2795 Matrix *
2796 matrix_from_str (const char *str)
2797 {
2798         if (!g_ascii_strcasecmp ("Identity", str)) {
2799                 return new Matrix ();
2800         }
2801
2802         DoubleCollection *values = DoubleCollection::FromStr (str);
2803         Matrix *matrix;
2804
2805         if (!values)
2806                 return new Matrix ();
2807
2808         if (values->GetCount () < 6) {
2809                 values->unref ();
2810                 return NULL;
2811         }
2812
2813         matrix = new Matrix ();
2814         matrix->SetM11 (values->GetValueAt (0)->AsDouble ());
2815         matrix->SetM12 (values->GetValueAt (1)->AsDouble ());
2816         matrix->SetM21 (values->GetValueAt (2)->AsDouble ());
2817         matrix->SetM22 (values->GetValueAt (3)->AsDouble ());
2818         matrix->SetOffsetX (values->GetValueAt (4)->AsDouble ());
2819         matrix->SetOffsetY (values->GetValueAt (5)->AsDouble ());
2820
2821         values->unref ();
2822
2823         return matrix;
2824 }
2825
2826 Matrix3D *
2827 matrix3d_from_str (const char *str)
2828 {
2829         if (!g_ascii_strcasecmp ("Identity", str)) {
2830                 return new Matrix3D ();
2831         }
2832
2833         DoubleCollection *values = DoubleCollection::FromStr (str);
2834         Matrix3D *matrix;
2835
2836         if (!values)
2837                 return new Matrix3D ();
2838
2839         if (values->GetCount () < 12) {
2840                 values->unref ();
2841                 return NULL;
2842         }
2843
2844         matrix = new Matrix3D ();
2845         matrix->SetM11 (values->GetValueAt (0)->AsDouble ());
2846         matrix->SetM12 (values->GetValueAt (1)->AsDouble ());
2847         matrix->SetM13 (values->GetValueAt (2)->AsDouble ());
2848         matrix->SetM13 (values->GetValueAt (3)->AsDouble ());
2849         matrix->SetM21 (values->GetValueAt (4)->AsDouble ());
2850         matrix->SetM22 (values->GetValueAt (5)->AsDouble ());
2851         matrix->SetM23 (values->GetValueAt (6)->AsDouble ());
2852         matrix->SetM24 (values->GetValueAt (7)->AsDouble ());
2853         matrix->SetM31 (values->GetValueAt (8)->AsDouble ());
2854         matrix->SetM32 (values->GetValueAt (9)->AsDouble ());
2855         matrix->SetM33 (values->GetValueAt (10)->AsDouble ());
2856         matrix->SetM34 (values->GetValueAt (11)->AsDouble ());
2857         matrix->SetOffsetX (values->GetValueAt (12)->AsDouble ());
2858         matrix->SetOffsetY (values->GetValueAt (13)->AsDouble ());
2859         matrix->SetOffsetZ (values->GetValueAt (14)->AsDouble ());
2860         matrix->SetM44 (values->GetValueAt (15)->AsDouble ());
2861
2862         values->unref ();
2863
2864         return matrix;
2865 }
2866
2867 bool
2868 grid_length_from_str (const char *str, GridLength *grid_length)
2869 {
2870         if (IS_NULL_OR_EMPTY (str)) {
2871                 *grid_length = GridLength (0.0, GridUnitTypePixel);
2872                 return true;
2873         }
2874
2875         if (str [0] == '*') {
2876                 *grid_length = GridLength (1.0, GridUnitTypeStar);
2877                 return true;
2878         }
2879
2880         // unit tests shows that "Auto", "auto", "aUtO"... all works
2881         if (!g_ascii_strcasecmp (str, "Auto")) {
2882                 *grid_length = GridLength ();
2883                 return true;
2884         }
2885
2886         char *endptr;
2887         errno = 0;
2888         double d = g_ascii_strtod (str, &endptr);
2889
2890         if (errno || endptr == str)
2891                 return false;
2892
2893         *grid_length = GridLength (d, *endptr == '*' ? GridUnitTypeStar : GridUnitTypePixel);
2894         return true;
2895 }
2896
2897 static void
2898 advance (char **in)
2899 {
2900         char *inptr = *in;
2901
2902         while (*inptr && !g_ascii_isalnum (*inptr) && *inptr != '.' && *inptr != '-' && *inptr != '+')
2903                 inptr = g_utf8_next_char (inptr);
2904
2905         *in = inptr;
2906 }
2907
2908 static bool
2909 get_point (Point *p, char **in)
2910 {
2911         char *end, *inptr = *in;
2912         double x, y;
2913
2914         x = g_ascii_strtod (inptr, &end);
2915         if (end == inptr)
2916                 return false;
2917
2918         inptr = end;
2919         while (g_ascii_isspace (*inptr))
2920                 inptr++;
2921
2922         if (*inptr == ',')
2923                 inptr++;
2924
2925         while (g_ascii_isspace (*inptr))
2926                 inptr++;
2927
2928         y = g_ascii_strtod (inptr, &end);
2929         if (end == inptr)
2930                 return false;
2931
2932         p->x = x;
2933         p->y = y;
2934
2935         *in = end;
2936
2937         return true;
2938 }
2939
2940 static void
2941 make_relative (const Point *cp, Point *mv)
2942 {
2943         mv->x += cp->x;
2944         mv->y += cp->y;
2945 }
2946
2947 static bool
2948 more_points_available (char **in)
2949 {
2950         char *inptr = *in;
2951
2952         while (g_ascii_isspace (*inptr) || *inptr == ',')
2953                 inptr++;
2954
2955         *in = inptr;
2956
2957         return (g_ascii_isdigit (*inptr) || *inptr == '.' || *inptr == '-' || *inptr == '+');
2958 }
2959
2960 Geometry *
2961 geometry_from_str (const char *str)
2962 {
2963         char *inptr = (char *) str;
2964         Point cp = Point (0, 0);
2965         Point cp1, cp2, cp3;
2966         Point start;
2967         char *end;
2968         PathGeometry *pg = NULL;
2969         FillRule fill_rule = FillRuleEvenOdd;
2970         bool cbz = false; // last figure is a cubic bezier curve
2971         bool qbz = false; // last figure is a quadratic bezier curve
2972         Point cbzp, qbzp; // points needed to create "smooth" beziers
2973
2974         moon_path *path = moon_path_new (10);
2975
2976         while (*inptr) {
2977                 if (g_ascii_isspace (*inptr))
2978                         inptr++;
2979
2980                 if (!inptr[0])
2981                         break;
2982
2983                 bool relative = false;
2984
2985                 char c = *inptr;
2986                 inptr = g_utf8_next_char (inptr);
2987
2988                 switch (c) {
2989                 case 'f':
2990                 case 'F':
2991                         advance (&inptr);
2992
2993                         if (*inptr == '0')
2994                                 fill_rule = FillRuleEvenOdd;
2995                         else if (*inptr == '1')
2996                                 fill_rule = FillRuleNonzero;
2997                         else
2998                                 // FIXME: else it's a bad value and nothing should be rendered
2999                                 goto bad_pml; // partial: only this Path won't be rendered
3000
3001                         inptr = g_utf8_next_char (inptr);
3002                         break;
3003                 case 'm':
3004                         relative = true;
3005                 case 'M':
3006                         if (!get_point (&cp1, &inptr))
3007                                 break;
3008
3009                         if (relative)
3010                                 make_relative (&cp, &cp1);
3011
3012                         // start point
3013                         moon_move_to (path, cp1.x, cp1.y);
3014
3015                         start.x = cp.x = cp1.x;
3016                         start.y = cp.y = cp1.y;
3017
3018                         advance (&inptr);
3019                         while (more_points_available (&inptr)) {
3020                                 if (!get_point (&cp1, &inptr))
3021                                         break;
3022
3023                                 if (relative)
3024                                         make_relative (&cp, &cp1);
3025
3026                                 moon_line_to (path, cp1.x, cp1.y);
3027                         }
3028
3029                         cp.x = cp1.x;
3030                         cp.y = cp1.y;
3031                         cbz = qbz = false;
3032                         break;
3033
3034                 case 'l':
3035                         relative = true;
3036                 case 'L':
3037                 {
3038                         while (more_points_available (&inptr)) {
3039                                 if (!get_point (&cp1, &inptr))
3040                                         break;
3041
3042                                 if (relative)
3043                                         make_relative (&cp, &cp1);
3044
3045                                 moon_line_to (path, cp1.x, cp1.y);
3046
3047                                 cp.x = cp1.x;
3048                                 cp.y = cp1.y;
3049
3050                                 advance (&inptr);
3051                         }
3052                         cbz = qbz = false;
3053                         break;
3054                 }
3055
3056                 case 'h':
3057                         relative = true;
3058                 case 'H':
3059                 {
3060                         double x = g_ascii_strtod (inptr, &end);
3061                         if (end == inptr)
3062                                 break;
3063
3064                         inptr = end;
3065
3066                         if (relative)
3067                                 x += cp.x;
3068                         cp = Point (x, cp.y);
3069
3070                         moon_line_to (path, cp.x, cp.y);
3071                         cbz = qbz = false;
3072                         break;
3073                 }
3074
3075                 case 'v':
3076                         relative = true;
3077                 case 'V':
3078                 {
3079                         double y = g_ascii_strtod (inptr, &end);
3080                         if (end == inptr)
3081                                 break;
3082
3083                         inptr = end;
3084
3085                         if (relative)
3086                                 y += cp.y;
3087                         cp = Point (cp.x, y);
3088
3089                         moon_line_to (path, cp.x, cp.y);
3090                         cbz = qbz = false;
3091                         break;
3092                 }
3093
3094                 case 'c':
3095                         relative = true;
3096                 case 'C':
3097                 {
3098                         while (more_points_available (&inptr)) {
3099                                 if (!get_point (&cp1, &inptr))
3100                                         break;
3101
3102                                 if (relative)
3103                                         make_relative (&cp, &cp1);
3104
3105                                 advance (&inptr);
3106
3107                                 if (!get_point (&cp2, &inptr))
3108                                         break;
3109
3110                                 if (relative)
3111                                         make_relative (&cp, &cp2);
3112
3113                                 advance (&inptr);
3114
3115                                 if (!get_point (&cp3, &inptr))
3116                                         break;
3117
3118                                 if (relative)
3119                                         make_relative (&cp, &cp3);
3120
3121                                 advance (&inptr);
3122
3123                                 moon_curve_to (path, cp1.x, cp1.y, cp2.x, cp2.y, cp3.x, cp3.y);
3124
3125                                 cp1.x = cp3.x;
3126                                 cp1.y = cp3.y;
3127                         }
3128                         cp.x = cp3.x;
3129                         cp.y = cp3.y;
3130                         cbz = true;
3131                         cbzp.x = cp2.x;
3132                         cbzp.y = cp2.y;
3133                         qbz = false;
3134                         break;
3135                 }
3136                 case 's':
3137                         relative = true;
3138                 case 'S':
3139                 {
3140                         while (more_points_available (&inptr)) {
3141                                 if (!get_point (&cp2, &inptr))
3142                                         break;
3143
3144                                 if (relative)
3145                                         make_relative (&cp, &cp2);
3146
3147                                 advance (&inptr);
3148
3149                                 if (!get_point (&cp3, &inptr))
3150                                         break;
3151
3152                                 if (relative)
3153                                         make_relative (&cp, &cp3);
3154
3155                                 if (cbz) {
3156                                         cp1.x = 2 * cp.x - cbzp.x;
3157                                         cp1.y = 2 * cp.y - cbzp.y;
3158                                 } else
3159                                         cp1 = cp;
3160
3161                                 moon_curve_to (path, cp1.x, cp1.y, cp2.x, cp2.y, cp3.x, cp3.y);
3162                                 cbz = true;
3163                                 cbzp.x = cp2.x;
3164                                 cbzp.y = cp2.y;
3165
3166                                 cp.x = cp3.x;
3167                                 cp.y = cp3.y;
3168
3169                                 advance (&inptr);
3170                         }
3171                         qbz = false;
3172                         break;
3173                 }
3174                 case 'q':
3175                         relative = true;
3176                 case 'Q':
3177                 {
3178                         while (more_points_available (&inptr)) {
3179                                 if (!get_point (&cp1, &inptr))
3180                                         break;
3181
3182                                 if (relative)
3183                                         make_relative (&cp, &cp1);
3184
3185                                 advance (&inptr);
3186
3187                                 if (!get_point (&cp2, &inptr))
3188                                         break;
3189
3190                                 if (relative)
3191                                         make_relative (&cp, &cp2);
3192
3193                                 advance (&inptr);
3194
3195                                 moon_quad_curve_to (path, cp1.x, cp1.y, cp2.x, cp2.y);
3196
3197                                 cp.x = cp2.x;
3198                                 cp.y = cp2.y;
3199                         }
3200                         qbz = true;
3201                         qbzp.x = cp1.x;
3202                         qbzp.y = cp1.y;
3203                         cbz = false;
3204                         break;
3205                 }
3206                 case 't':
3207                         relative = true;
3208                 case 'T':
3209                 {
3210                         while (more_points_available (&inptr)) {
3211                                 if (!get_point (&cp2, &inptr))
3212                                         break;
3213
3214                                 if (relative)
3215                                         make_relative (&cp, &cp2);
3216
3217                                 if (qbz) {
3218                                         cp1.x = 2 * cp.x - qbzp.x;
3219                                         cp1.y = 2 * cp.y - qbzp.y;
3220                                 } else
3221                                         cp1 = cp;
3222
3223                                 moon_quad_curve_to (path, cp1.x, cp1.y, cp2.x, cp2.y);
3224                                 qbz = true;
3225                                 qbzp.x = cp1.x;
3226                                 qbzp.y = cp1.y;
3227
3228                                 cp.x = cp2.x;
3229                                 cp.y = cp2.y;
3230
3231                                 advance (&inptr);
3232                         }
3233                         cbz = false;
3234                         break;
3235                 }
3236                 case 'a':
3237                         relative = true;
3238                 case 'A':
3239                 {
3240                         while (more_points_available (&inptr)) {
3241                                 if (!get_point (&cp1, &inptr))
3242                                         break;
3243
3244                                 advance (&inptr);
3245
3246                                 double angle = g_ascii_strtod (inptr, &end);
3247                                 if (end == inptr)
3248                                         break;
3249
3250                                 inptr = end;
3251                                 advance (&inptr);
3252
3253                                 int is_large = strtol (inptr, &end, 10);
3254                                 if (end == inptr)
3255                                         break;
3256
3257                                 inptr = end;
3258                                 advance (&inptr);
3259
3260                                 int sweep = strtol (inptr, &end, 10);
3261                                 if (end == inptr)
3262                                         break;
3263
3264                                 inptr = end;
3265                                 advance (&inptr);
3266
3267                                 if (!get_point (&cp2, &inptr))
3268                                         break;
3269
3270                                 if (relative)
3271                                         make_relative (&cp, &cp2);
3272
3273                                 moon_arc_to (path, cp1.x, cp1.y, angle, is_large, sweep, cp2.x, cp2.y);
3274
3275                                 cp.x = cp2.x;
3276                                 cp.y = cp2.y;
3277
3278                                 advance (&inptr);
3279                         }
3280                         cbz = qbz = false;
3281                         break;
3282                 }
3283                 case 'z':
3284                 case 'Z':
3285                         moon_line_to (path, start.x, start.y);
3286                         moon_close_path (path);
3287                         moon_move_to (path, start.x, start.y);
3288
3289                         cp.x = start.x;
3290                         cp.y = start.y;
3291                         cbz = qbz = false;
3292                         break;
3293                 default:
3294                         break;
3295                 }
3296         }
3297
3298         pg = new PathGeometry (path);
3299         pg->SetFillRule (fill_rule);
3300         return pg;
3301
3302 bad_pml:
3303         moon_path_destroy (path);
3304         return NULL;
3305 }
3306
3307 static bool
3308 value_is_explicit_null (const char *str)
3309 {
3310         return !strcmp ("{x:Null}", str);
3311 }
3312
3313 static bool
3314 is_managed_kind (Type::Kind kind)
3315 {
3316
3317         if (kind == Type::MANAGED ||
3318             kind == Type::OBJECT ||
3319             kind == Type::URI ||
3320             kind == Type::MANAGEDTYPEINFO ||
3321             kind == Type::DEPENDENCYPROPERTY)
3322                 return true;
3323
3324         return false;
3325 }
3326
3327 static bool
3328 kind_requires_managed_load (Type::Kind kind)
3329 {
3330         if (kind == Type::USERCONTROL) {
3331                 return true;
3332         }
3333
3334         return false;
3335 }
3336
3337 static bool
3338 is_legal_top_level_kind (Type::Kind kind)
3339 {
3340         if (kind == Type::MANAGED || kind == Type::OBJECT || Type::IsSubclassOf (Deployment::GetCurrent (), kind, Type::DEPENDENCY_OBJECT))
3341                 return true;
3342         return false;
3343 }
3344
3345 // NOTE: Keep definition in sync with class/System.Windows/Mono/NativeMethods.cs
3346 bool
3347 value_from_str_with_typename (const char *type_name, const char *prop_name, const char *str, Value **v)
3348 {
3349         Type *t = Type::Find (Deployment::GetCurrent (), type_name);
3350         if (!t)
3351                 return false;
3352
3353         return value_from_str (t->GetKind (), prop_name, str, v);
3354 }
3355
3356 char *
3357 expand_property_path (XamlParserInfo *p, PropertyPath *path)
3358 {
3359         if (!path->path)
3360                 return NULL;
3361
3362         bool expanded = false;
3363         GString *res = g_string_new (path->path);
3364
3365         int len = strlen (res->str);
3366         for (int i = 0; i < len; i++) {
3367                 if (res->str [i] == ':') {
3368                         int e = i;
3369                         int s = i - 1;
3370                         int te = i + 1;
3371                         for ( ; s > 0; s--) {
3372                                 if (!g_ascii_isalnum (res->str [s]))
3373                                         break;
3374                         }
3375
3376                         for ( ; te < len; te++) {
3377                                 if (!g_ascii_isalpha (res->str [te]) || res->str [te] == '_')
3378                                         break;
3379                         }
3380
3381                         char *prefix = g_strndup (res->str + s + 1, e - s - 1);
3382                         char *type = g_strndup (res->str + e + 1, te - e - 1);
3383
3384                         res = g_string_erase (res, s + 1, te - s - 1);
3385
3386                         XamlNamespace *ns = (XamlNamespace *) g_hash_table_find (p->namespace_map, namespace_for_prefix, prefix);
3387                         if (!ns) {
3388                                 g_free (prefix);
3389                                 g_free (type);
3390                                 g_string_free (res, true);
3391                                 return NULL;
3392                         }
3393
3394                         XamlElementInfo *info = ns->FindElement (p, type, NULL, false);
3395
3396                         if (!info) {
3397                                 g_free (prefix);
3398                                 g_free (type);
3399                                 g_string_free (res, true);
3400                                 return NULL;
3401                         }
3402
3403                         char *uri = g_strdup_printf ("'%s'", Type::Find (p->deployment, info->GetKind ())->GetName ());
3404
3405                         res = g_string_insert (res, s + 1, uri);
3406                         i = s + 1 + strlen (uri);
3407                         len = strlen (res->str);
3408
3409                         delete info;
3410                         g_free (uri);
3411                         g_free (prefix);
3412                         g_free (type);
3413
3414                         expanded = true;
3415                 }
3416         }
3417
3418         if (!expanded) {
3419                 g_string_free (res, true);
3420                 return NULL;
3421         }
3422
3423         char *expanded_str = res->str;
3424         g_string_free (res, false);
3425
3426         return expanded_str;
3427 }
3428
3429 bool
3430 value_from_str (Type::Kind type, const char *prop_name, const char *str, Value **v)
3431 {
3432         bool v_set = false;
3433
3434         value_from_str_with_parser (NULL, type, prop_name, str, v, &v_set);
3435
3436         return v_set;
3437 }
3438
3439 bool
3440 xaml_bool_from_str (const char *s, bool *res)
3441 {
3442         bool b;
3443         char *endptr;
3444
3445         if (!g_ascii_strcasecmp ("true", s))
3446                 b = true;
3447         else if (!g_ascii_strcasecmp ("false", s))
3448                 b = false;
3449         else {
3450                 // Check if it's a string representing a decimal value
3451                 gint64 l;
3452
3453                 errno = 0;
3454                 l = strtol (s, &endptr, 10);
3455
3456                 if (errno || endptr == s || *endptr || l > G_MAXINT32 || l < G_MININT32)
3457                         return false;;
3458
3459                 if (l == 0)
3460                         b = false;
3461                 else
3462                         b = true;
3463         }
3464
3465         *res = b;
3466         return true;
3467 }
3468
3469 static bool
3470 value_from_str_with_parser (XamlParserInfo *p, Type::Kind type, const char *prop_name, const char *str, Value **v, bool *v_set)
3471 {
3472         char *endptr;
3473         *v = NULL;
3474
3475         if (value_is_explicit_null (str)) {
3476                 *v = NULL;
3477                 *v_set = true;
3478                 return true;
3479         }
3480
3481         char *s = g_strdup (str);
3482
3483         if (type == Type::OBJECT || type == Type::STRING) {
3484                 // object and string use the literal string
3485         }
3486         else {
3487                 // everything else depends on the string being stripped
3488                 s = g_strstrip (s);
3489         }
3490
3491         switch (type) {
3492         case Type::OBJECT: {
3493                 // not much more can do here, unless we want to try to
3494                 // probe str to see if it's actually meant to be a
3495                 // specific type.  just assume it's a string.
3496                 *v = new Value (s);
3497                 *v_set = true;
3498                 break;
3499         }
3500
3501         case Type::BOOL: {
3502                 bool b;
3503
3504                 if (!xaml_bool_from_str (s, &b))
3505                         break;
3506
3507                 *v = new Value (b);
3508                 *v_set = true;
3509                 break;
3510         }
3511         case Type::DOUBLE: {
3512                 double d;
3513
3514                 // empty string should not reset default values with 0
3515                 //
3516                 // FIXME: this causes a 2.0 unit test to fail (PrimitiveTest.ParseEmptyDouble)
3517                 if (IS_NULL_OR_EMPTY(s)) {
3518                         g_free (s);
3519                         return false;
3520                 }
3521
3522                 bool is_nan = false;
3523                 if (!g_ascii_strcasecmp (s, "NAN"))
3524                         is_nan = true;
3525                 else {
3526                         errno = 0;
3527                         d = g_ascii_strtod (s, &endptr);
3528                 }
3529
3530                 if (is_nan || errno || endptr == s || *endptr) {
3531                         if (prop_name
3532                             && (!strcmp (prop_name, "Width") || !strcmp (prop_name, "Height"))
3533                             && (!g_ascii_strcasecmp (s, "Auto") || is_nan))
3534                                 d = NAN;
3535                         else
3536                                 break;
3537                 }
3538
3539                 *v = new Value (d);
3540                 *v_set = true;
3541                 break;
3542         }
3543         case Type::INT64: {
3544                 gint64 l;
3545
3546                 errno = 0;
3547                 l = strtol (s, &endptr, 10);
3548
3549                 if (errno || endptr == s)
3550                         break;
3551
3552                 *v = new Value (l, Type::INT64);
3553                 *v_set = true;
3554                 break;
3555         }
3556         case Type::TIMESPAN: {
3557                 TimeSpan ts;
3558
3559                 if (!time_span_from_str (s, &ts))
3560                         break;
3561
3562                 *v = new Value (ts, Type::TIMESPAN);
3563                 *v_set = true;
3564                 break;
3565         }
3566         case Type::INT32: {
3567                 int i;
3568
3569                 if (IS_NULL_OR_EMPTY(s))
3570                         i = 0;
3571                 else if (g_ascii_isalpha (s[0]) && prop_name) {
3572                         i = enums_str_to_int (prop_name, s);
3573                         if (i == -1) {
3574 //                              g_warning ("'%s' enum is not valid on '%s' property", str, prop_name);
3575                                 break;
3576                         }
3577                 } else {
3578                         errno = 0;
3579                         long l = strtol (s, &endptr, 10);
3580
3581                         if (errno || endptr == s)
3582                                 break;
3583
3584                         i = (int) l;
3585                 }
3586
3587                 *v = new Value (i);
3588                 *v_set = true;
3589                 break;
3590         }
3591         case Type::CHAR: {
3592                 gunichar unichar = g_utf8_get_char_validated (str, -1);
3593                 const char *next;
3594
3595                 if ((int) unichar < 0)
3596                         break;
3597
3598                 if (!(next = g_utf8_next_char (str)) || *next != '\0')
3599                         break;
3600
3601                 *v = new Value (unichar, Type::CHAR);
3602                 *v_set = true;
3603                 break;
3604         }
3605         case Type::STRING: {
3606                 *v = new Value (str);
3607                 *v_set = true;
3608                 break;
3609         }
3610         case Type::COLOR: {
3611                 Color *c = color_from_str (s);
3612                 if (c == NULL)
3613                         break;
3614                 *v = new Value (*c);
3615                 *v_set = true;
3616                 delete c;
3617                 break;
3618         }
3619         case Type::REPEATBEHAVIOR: {
3620                 RepeatBehavior rb = RepeatBehavior::Forever;
3621
3622                 if (!repeat_behavior_from_str (s, &rb))
3623                         break;
3624
3625                 *v = new Value (rb);
3626                 *v_set = true;
3627                 break;
3628         }
3629         case Type::DURATION: {
3630                 Duration d = Duration::Forever;
3631
3632                 if (!duration_from_str (s, &d))
3633                         break;
3634
3635                 *v = new Value (d);
3636                 *v_set = true;
3637                 break;
3638         }
3639         case Type::KEYTIME: {
3640                 KeyTime kt = KeyTime::Paced;
3641
3642                 if (!keytime_from_str (s, &kt))
3643                         break;
3644
3645                 *v = new Value (kt);
3646                 *v_set = true;
3647                 break;
3648         }
3649         case Type::KEYSPLINE: {
3650                 KeySpline *ks;
3651
3652                 if (!key_spline_from_str (s, &ks))
3653                         break;
3654
3655                 *v = Value::CreateUnrefPtr (ks);
3656                 *v_set = true;
3657                 break;
3658         }
3659         case Type::BRUSH:
3660         case Type::SOLIDCOLORBRUSH: {
3661                 // Only solid color brushes can be specified using attribute syntax
3662                 Color *c = color_from_str (s);
3663
3664                 if (c == NULL)
3665                         break;
3666
3667                 SolidColorBrush *scb = new SolidColorBrush ();
3668
3669                 scb->SetColor (c);
3670                 delete c;
3671
3672                 *v = Value::CreateUnrefPtr (scb);
3673                 *v_set = true;
3674                 break;
3675         }
3676         case Type::POINT: {
3677                 Point p;
3678
3679                 if (!Point::FromStr (s, &p))
3680                         break;
3681
3682                 *v = new Value (p);
3683                 *v_set = true;
3684                 break;
3685         }
3686         case Type::SIZE: {
3687                 Size size;
3688
3689                 if (!Size::FromStr (s, &size))
3690                         break;
3691
3692                 *v = new Value (size);
3693                 *v_set = true;
3694                 break;
3695         }
3696         case Type::RECT: {
3697                 Rect rect;
3698
3699                 if (!Rect::FromStr (s, &rect))
3700                         break;
3701
3702                 *v = new Value (rect);
3703                 *v_set = true;
3704                 break;
3705         }
3706         case Type::URI: {
3707                 Uri uri;
3708
3709                 if (!uri.Parse (s)) {
3710                         break;
3711                 }
3712
3713                 *v = new Value (uri);
3714                 *v_set = true;
3715                 break;
3716         }
3717         case Type::DOUBLE_COLLECTION: {
3718                 DoubleCollection *doubles = DoubleCollection::FromStr (s);
3719                 if (!doubles) {
3720                         *v = Value::CreateUnrefPtr (new DoubleCollection ());
3721                         *v_set = true;
3722                         break;
3723                 }
3724
3725                 *v = Value::CreateUnrefPtr (doubles);
3726                 *v_set = true;
3727                 break;
3728         }
3729         case Type::POINT_COLLECTION: {
3730                 PointCollection *points = PointCollection::FromStr (s);
3731                 if (!points) {
3732                         *v = Value::CreateUnrefPtr (new PointCollection ());
3733                         *v_set = true;
3734                         break;
3735                 }
3736
3737                 *v = Value::CreateUnrefPtr (points);
3738                 *v_set = true;
3739                 break;
3740         }
3741         case Type::TRANSFORMGROUP: {
3742                 if (IS_NULL_OR_EMPTY(s))
3743                         break;
3744
3745                 Matrix *mv = matrix_from_str (s);
3746                 if (!mv)
3747                         break;
3748
3749                 TransformGroup *tg = new TransformGroup ();
3750                 MatrixTransform *t = new MatrixTransform ();
3751                 t->SetValue (MatrixTransform::MatrixProperty, Value (mv));
3752
3753                 tg->GetChildren()->Add (t);
3754                 t->unref ();
3755
3756                 *v = new Value (tg);
3757                 *v_set = true;
3758                 tg->unref ();
3759                 mv->unref ();
3760                 break;
3761         }
3762         case Type::TRANSFORM:
3763
3764                 if (!g_ascii_strcasecmp ("Identity", str)) {
3765                         *v = NULL;
3766                         *v_set = true;
3767                         break;
3768                 }
3769
3770                 // Intentional fall through, you can create a matrix from a TRANSFORM property, but not using Identity
3771         case Type::MATRIXTRANSFORM:
3772         {
3773                 if (IS_NULL_OR_EMPTY(s))
3774                         break;
3775
3776                 Matrix *mv = matrix_from_str (s);
3777                 if (!mv)
3778                         break;
3779
3780                 MatrixTransform *t = new MatrixTransform ();
3781                 t->SetValue (MatrixTransform::MatrixProperty, Value (mv));
3782
3783                 *v = new Value (t);
3784                 *v_set = true;
3785                 t->unref ();
3786                 mv->unref ();
3787                 break;
3788         }
3789         case Type::UNMANAGEDMATRIX:
3790         case Type::MATRIX: {
3791                 // note: unlike TRANSFORM this creates an empty, identity, matrix for an empty string
3792                 Matrix *matrix = matrix_from_str (s);
3793                 if (!matrix)
3794                         break;
3795
3796                 *v = new Value (matrix);
3797                 *v_set = true;
3798                 matrix->unref ();
3799                 break;
3800         }
3801         case Type::PROJECTION:
3802
3803                 if (!g_ascii_strcasecmp ("Identity", str)) {
3804                         *v = NULL;
3805                         *v_set = true;
3806                         break;
3807                 }
3808
3809                 // Intentional fall through, you can create a matrix from a PROJECTION property, but not using Identity
3810         case Type::MATRIX3DPROJECTION:
3811         {
3812                 if (IS_NULL_OR_EMPTY(s))
3813                         break;
3814
3815                 Matrix3D *mv = matrix3d_from_str (s);
3816                 if (!mv)
3817                         break;
3818
3819                 Matrix3DProjection *p = new Matrix3DProjection ();
3820                 p->SetValue (Matrix3DProjection::ProjectionMatrixProperty, Value (mv));
3821
3822                 *v = new Value (p);
3823                 *v_set = true;
3824                 p->unref ();
3825                 mv->unref ();
3826                 break;
3827         }
3828         case Type::UNMANAGEDMATRIX3D:
3829         case Type::MATRIX3D: {
3830                 Matrix3D *matrix = matrix3d_from_str (s);
3831                 if (!matrix)
3832                         break;
3833
3834                 *v = new Value (matrix);
3835                 *v_set = true;
3836                 matrix->unref ();
3837                 break;
3838         }
3839         case Type::PATHGEOMETRY:
3840         case Type::GEOMETRY: {
3841                 Geometry *geometry = geometry_from_str (s);
3842
3843                 if (!geometry)
3844                         break;
3845
3846                 *v = new Value (geometry);
3847                 *v_set = true;
3848                 geometry->unref ();
3849                 break;
3850         }
3851         case Type::THICKNESS: {
3852                 Thickness t;
3853
3854                 if (!Thickness::FromStr (s, &t))
3855                         break;
3856
3857                 *v = new Value (t);
3858                 *v_set = true;
3859                 break;
3860         }
3861         case Type::CORNERRADIUS: {
3862                 CornerRadius c;
3863
3864                 if (!CornerRadius::FromStr (s, &c))
3865                         break;
3866
3867                 *v = new Value (c);
3868                 *v_set = true;
3869                 break;
3870         }
3871         case Type::GRIDLENGTH: {
3872                 GridLength grid_length;
3873
3874                 if (!grid_length_from_str (s, &grid_length))
3875                         break;
3876
3877                 *v = new Value (grid_length);
3878                 *v_set = true;
3879                 break;
3880         }
3881         case Type::IMAGESOURCE:
3882         case Type::BITMAPIMAGE: {
3883                 Uri uri;
3884
3885                 if (!uri.Parse (s))
3886                         break;
3887
3888                 BitmapImage *bi = new BitmapImage ();
3889
3890                 bi->SetUriSource (&uri);
3891
3892                 *v = Value::CreateUnrefPtr (bi);
3893                 *v_set = true;
3894
3895                 break;
3896         }
3897         case Type::MULTISCALETILESOURCE:
3898         case Type::DEEPZOOMIMAGETILESOURCE: {
3899                 // As far as I know the only thing you can create here is a URI based DeepZoomImageTileSource
3900                 Uri uri;
3901                 if (!uri.Parse (s))
3902                         break;
3903                 *v = Value::CreateUnrefPtr (new DeepZoomImageTileSource (&uri));
3904                 *v_set = true;
3905
3906                 break;
3907         }
3908         case Type::FONTFAMILY: {
3909                 *v = new Value (FontFamily (s));
3910                 *v_set = true;
3911                 break;
3912         }
3913         case Type::FONTWEIGHT: {
3914                 int fw = enums_str_to_int ("FontWeight", s);
3915                 if (fw != -1) {
3916                         *v = new Value (FontWeight ((FontWeights)fw));
3917                         *v_set = true;
3918                 }
3919                 break;
3920         }
3921         case Type::FONTSTYLE: {
3922                 int fs = enums_str_to_int ("FontStyle", s);
3923                 if (fs != -1) {
3924                         *v = new Value (FontStyle ((FontStyles)fs));
3925                         *v_set = true;
3926                 }
3927                 break;
3928         }
3929         case Type::FONTSTRETCH: {
3930                 int fs = enums_str_to_int ("FontStretch", s);
3931                 if (fs != -1) {
3932                         *v = new Value (FontStretch ((FontStretches)fs));
3933                         *v_set = true;
3934                 }
3935                 break;
3936         }
3937         case Type::PROPERTYPATH: {
3938                 PropertyPath path (s);
3939                 path.expanded_path = expand_property_path (p, &path);
3940                 *v = new Value (path);
3941                 *v_set = true;
3942                 break;
3943         }
3944         default:
3945                 // we don't care about NULL or empty values
3946                 if (!IS_NULL_OR_EMPTY (s)) {
3947                         g_free (s);
3948                         return true;
3949                 }
3950         }
3951
3952         g_free (s);
3953         return true;
3954 }
3955
3956 bool
3957 XamlElementInstance::TrySetContentProperty (XamlParserInfo *p, XamlElementInstance *value)
3958 {
3959         const char* prop_name = info->GetContentProperty (p);
3960
3961         if (!prop_name)
3962                 return false;
3963
3964         DependencyProperty *dep = DependencyProperty::GetDependencyProperty (Type::Find (p->deployment, info->GetKind ()), prop_name);
3965         if (!dep)
3966                 return false;
3967
3968         bool is_collection = Type::IsSubclassOf (p->deployment, dep->GetPropertyType(), Type::DEPENDENCY_OBJECT_COLLECTION);
3969
3970         if (!is_collection && Type::IsSubclassOf (p->deployment, value->info->GetKind (), dep->GetPropertyType())) {
3971                 MoonError err;
3972                 if (!item->SetValueWithError (dep, value->GetAsValue (), &err)) {
3973                     parser_error (p, value->element_name, NULL, err.code, err.message);
3974                     return false;
3975                 }
3976                 return true;
3977         }
3978
3979         // We only want to enter this if statement if we are NOT dealing with the content property element,
3980         // otherwise, attempting to use explicit property setting, would add the content property element
3981         // to the content property element collection
3982         if (is_collection && dep->GetPropertyType() != value->info->GetKind ()) {
3983                 Value *col_v = item->GetValue (dep);
3984                 Collection *col;
3985
3986                 if (!col_v) {
3987                         col = collection_new (dep->GetPropertyType ());
3988                         item->SetValue (dep, Value (col));
3989                         col->unref ();
3990                 } else {
3991                         col = (Collection *) col_v->AsCollection ();
3992                 }
3993
3994                 MoonError err;
3995                 if (-1 == col->AddWithError (value->GetAsValue (), &err)) {
3996                         parser_error (p, value->element_name, NULL, err.code, err.message);
3997                         return false;
3998                 }
3999
4000                 return true;
4001         }
4002
4003         return false;
4004 }
4005
4006 bool
4007 XamlElementInstance::TrySetContentProperty (XamlParserInfo *p, const char *value)
4008 {
4009         const char* prop_name = info->GetContentProperty (p);
4010
4011         if (!prop_name) {
4012                 if (info->GetKind () == Type::ICON) {
4013                         prop_name = "Source";
4014                 } else
4015                         return false;
4016         }
4017
4018         Type::Kind prop_type = p->current_element->info->GetKind ();
4019         DependencyProperty *content = DependencyProperty::GetDependencyProperty (Type::Find (p->deployment, prop_type), prop_name);
4020
4021         // TODO: There might be other types that can be specified here,
4022         // but string is all i have found so far.  If you can specify other
4023         // types, i should pull the property setting out of set_attributes
4024         // and use that code
4025
4026         if (content && (content->GetPropertyType ()) == Type::STRING && value) {
4027                 item->SetValue (content, Value (g_strstrip (p->cdata->str)));
4028                 return true;
4029         } else if (content && (content->GetPropertyType ()) == Type::URI && value) {
4030                 Uri uri;
4031
4032                 if (!uri.Parse (g_strstrip (p->cdata->str)))
4033                         return false;
4034
4035                 item->SetValue (content, Value (uri));
4036                 return true;
4037         } else if (Type::IsSubclassOf (p->deployment, info->GetKind (), Type::TEXTBLOCK)) {
4038                 TextBlock *textblock = (TextBlock *) item;
4039                 InlineCollection *inlines = textblock->GetInlines ();
4040                 Inline *last = NULL;
4041
4042                 if (inlines && inlines->GetCount () > 0)
4043                         last = inlines->GetValueAt (inlines->GetCount () - 1)->AsInline ();
4044
4045                 if (!p->cdata_content) {
4046                         if (p->next_element && !strcmp (p->next_element, "Run") && last && last->GetObjectType () == Type::RUN &&
4047                             !last->GetAutogenerated ()) {
4048                                 // LWSP between <Run> elements is to be treated as a single-SPACE <Run> element
4049                                 // Note: p->cdata is already canonicalized
4050                         } else {
4051                                 // This is one of the following cases:
4052                                 //
4053                                 // 1. LWSP before the first <Run> element
4054                                 // 2. LWSP after the last <Run> element
4055                                 // 3. LWSP between <Run> and <LineBreak> elements
4056                                 return true;
4057                         }
4058                 } else {
4059                         if (!p->next_element || !strcmp (p->next_element, "LineBreak"))
4060                                 g_strchomp (p->cdata->str);
4061
4062                         if (!last || last->GetObjectType () != Type::RUN || last->GetAutogenerated ())
4063                                 g_strchug (p->cdata->str);
4064                 }
4065
4066                 Run *run = new Run ();
4067                 run->SetText (p->cdata->str);
4068
4069                 if (!inlines) {
4070                         inlines = new InlineCollection ();
4071                         textblock->SetInlines (inlines);
4072                         inlines->unref ();
4073                 }
4074
4075                 inlines->Add (run);
4076                 run->unref ();
4077                 return true;
4078         }
4079
4080         return false;
4081 }
4082
4083 bool
4084 XamlElementInstance::SetUnknownAttribute (XamlParserInfo *p, const char *name, const char *value)
4085 {
4086         if (!p->loader)
4087                 return false;
4088
4089         Value v = Value (value);
4090         if (!p->loader->SetProperty (p, p->GetTopElementPtr (), info->xmlns, GetAsValue (), this, GetParentPointer (), NULL, name, &v, NULL)) {
4091                 return false;
4092         }
4093         return true;
4094 }
4095
4096 void
4097 XamlElementInstance::SetDelayedProperties (XamlParserInfo *p)
4098 {
4099         GSList *walk = delayed_properties;
4100
4101         while (walk) {
4102                 DelayedProperty *prop = (DelayedProperty *) walk->data;
4103
4104                 if (!p->loader->SetProperty (p, p->GetTopElementPtr (), info->xmlns, GetAsValue (), this, GetParentPointer (), prop->xmlns, prop->name, prop->value, NULL, XamlCallbackData::SETTING_DELAYED_PROPERTY)) {
4105                         parser_error (p, element_name, prop->name, 2012,
4106                                         "Unknown property %s on element %s.",
4107                                         prop->name, element_name);
4108                         return;
4109                 }
4110
4111                 walk = walk->next;
4112         }
4113
4114 }
4115
4116 XamlElementInfo *
4117 XamlElementInstance::FindPropertyElement (XamlParserInfo *p, const char *el, const char *dot)
4118 {
4119         // We didn't find anything so try looking up in managed
4120         if (!p->loader)
4121                 return NULL;
4122
4123         Value *v = new Value ();
4124         if (p->loader->LookupObject (p, p->GetTopElementPtr (), GetAsValue (), p->current_namespace->GetUri (), el, false, true, v)) {
4125                 char *type_name = g_strndup (el, dot - el);
4126
4127                 XamlElementInfoManaged *res = new XamlElementInfoManaged (g_strdup (p->current_namespace->GetUri ()), el, info, v->GetKind (), v);
4128                 XamlElementInfo *container = p->current_namespace->FindElement (p, type_name, NULL, false);
4129                 info->SetPropertyOwnerKind (container->GetKind ());
4130                 g_free (type_name);
4131                 return res;
4132         }
4133
4134         delete v;
4135         return NULL;
4136 }
4137
4138 static XamlElementInfo *
4139 create_element_info_from_imported_managed_type (XamlParserInfo *p, const char *name, const char **attr, bool create)
4140 {
4141         if (!p->loader)
4142                 return NULL;
4143
4144         char* type_name = NULL;
4145         char* type_xmlns = NULL;
4146         const char* use_xmlns = NULL;
4147
4148         if (x_namespace) {
4149                 // We might have an x:Class attribute specified, so we need to use that for the
4150                 // type_name that we pass to LookupObject
4151                 if (strcmp ("Application", name)) {
4152                         type_name = x_namespace->FindTypeName (attr, &type_xmlns);
4153                         if (type_name) {
4154                                 name = type_name;
4155                                 use_xmlns = type_xmlns;
4156
4157                                 if (!p->hydrating) {
4158                                         parser_error (p, name, "x:Class", 4005, "Cannot specify x:Class in xaml files outside of a xap.");
4159                                         return NULL;
4160                                 }
4161                         }
4162                 }
4163         }
4164
4165         Value *v = new Value ();
4166         if (!p->loader->LookupObject (p, use_xmlns ? p->GetTopElementPtr () : NULL, NULL, use_xmlns, name, create, false, v)) {
4167                 delete v;
4168                 if (type_name)
4169                         g_free (type_name);
4170                 if (type_xmlns)
4171                         g_free (type_xmlns);
4172                 return NULL;
4173         }
4174
4175         XamlElementInfoImportedManaged *info = new  XamlElementInfoImportedManaged (g_strdup (name), NULL, v);
4176
4177         if (create) {
4178                 if (v->Is (p->deployment, Type::DEPENDENCY_OBJECT))
4179                         p->AddCreatedElement (v->AsDependencyObject());
4180         }
4181
4182         return info;
4183 }
4184
4185
4186 const char *
4187 XamlElementInfoNative::GetContentProperty (XamlParserInfo *p)
4188 {
4189         return type->GetContentPropertyName ();
4190 }
4191
4192 XamlElementInstance *
4193 XamlElementInfoNative::CreateElementInstance (XamlParserInfo *p)
4194 {
4195         if (type->IsValueType ())
4196                 return new XamlElementInstanceValueType (this, p, GetName (), XamlElementInstance::ELEMENT);
4197         else if (type->IsSubclassOf (Type::FRAMEWORKTEMPLATE))
4198                 return new XamlElementInstanceTemplate (this, p, GetName (), XamlElementInstance::ELEMENT);
4199         else
4200                 return new XamlElementInstanceNative (this, p, GetName (), XamlElementInstance::ELEMENT);
4201 }
4202
4203 XamlElementInstance *
4204 XamlElementInfoNative::CreateWrappedElementInstance (XamlParserInfo *p, Value *o)
4205 {
4206         XamlElementInstance *res = new XamlElementInstanceNative (this, p, GetName (), XamlElementInstance::ELEMENT, false);
4207         res->SetDependencyObject (o->AsDependencyObject ());
4208
4209         return res;
4210 }
4211
4212 XamlElementInfo *
4213 XamlElementInstanceNative::FindPropertyElement (XamlParserInfo *p, const char *el, const char *dot)
4214 {
4215         if (IsDependencyObject ()) {
4216                 const char *prop_name = dot + 1;
4217                 DependencyProperty *prop = DependencyProperty::GetDependencyProperty (Type::Find (p->deployment, info->GetKind ()), prop_name);
4218                 if (prop) {
4219                         XamlElementInfoNative *info = new XamlElementInfoNative (Type::Find (p->deployment, prop->GetPropertyType ()));
4220                         info->SetPropertyOwnerKind (prop->GetOwnerType ());
4221                         return info;
4222                 }
4223         }
4224
4225         return XamlElementInstance::FindPropertyElement (p, el, dot);
4226 }
4227
4228 XamlElementInstance *
4229 XamlElementInfoNative::CreatePropertyElementInstance (XamlParserInfo *p, const char *name)
4230 {
4231         return new XamlElementInstanceNative (this, p, name, XamlElementInstance::PROPERTY, false);
4232 }
4233
4234 XamlElementInstanceNative::XamlElementInstanceNative (XamlElementInfoNative *element_info, XamlParserInfo *parser_info, const char *name, ElementType type, bool create_item) :
4235         XamlElementInstance (element_info, name, type)
4236 {
4237         this->element_info = element_info;
4238         this->parser_info = parser_info;
4239         if (create_item)
4240                 SetDependencyObject (CreateItem ());
4241 }
4242
4243
4244
4245 DependencyObject *
4246 XamlElementInstanceNative::CreateItem ()
4247 {
4248         XamlElementInstance *walk = parser_info->current_element;
4249         Type *type = element_info->GetType ();
4250
4251         DependencyObject *item = NULL;
4252         DependencyProperty *dep = NULL;
4253
4254         if (type->IsSubclassOf (Type::COLLECTION) || type->IsSubclassOf (Type::RESOURCE_DICTIONARY)) {
4255                 // If we are creating a collection, try walking up the element tree,
4256                 // to find the parent that we belong to and using that instance for
4257                 // our collection, instead of creating a new one
4258
4259                 // We attempt to advance past the property setter, because we might be dealing with a
4260                 // content element
4261
4262                 if (walk && walk->element_type == XamlElementInstance::PROPERTY) {
4263                         char **prop_name = g_strsplit (walk->element_name, ".", -1);
4264
4265                         walk = walk->parent;
4266                         dep = DependencyProperty::GetDependencyProperty (Type::Find (parser_info->deployment, walk->info->GetKind ()), prop_name [1]);
4267
4268                         g_strfreev (prop_name);
4269                 } else if (walk && walk->info->GetContentProperty (parser_info)) {
4270                         dep = DependencyProperty::GetDependencyProperty (Type::Find (parser_info->deployment, walk->info->GetKind ()),
4271                                         (char *) walk->info->GetContentProperty (parser_info));
4272                 }
4273
4274                 if (dep && Type::IsSubclassOf (parser_info->deployment, dep->GetPropertyType(), type->GetKind ())) {
4275                         Value *v = ((DependencyObject * ) walk->GetAsDependencyObject ())->GetValue (dep);
4276                         if (v) {
4277                                 item = v->AsDependencyObject ();
4278                                 dep = NULL;
4279                         }
4280                         // note: if !v then the default collection is NULL (e.g. PathFigureCollection)
4281                 }
4282         }
4283
4284         if (!item) {
4285                 item = element_info->GetType()->IsCtorVisible() ? element_info->GetType ()->CreateInstance () : NULL;
4286
4287                 if (item) {
4288                         parser_info->AddCreatedElement (item);
4289
4290                         // in case we must store the collection into the parent
4291                         if (dep && dep->GetPropertyType() == type->GetKind ()) {
4292                                 MoonError err;
4293                                 Value item_value (item);
4294                                 if (!((DependencyObject * ) walk->GetAsDependencyObject ())->SetValueWithError (dep, &item_value, &err))
4295                                         parser_error (parser_info, element_name, NULL, err.code, err.message);
4296                         }
4297                 } else {
4298                         parser_error (parser_info, element_name, NULL, 2007, "Unknown element: %s.", element_name);
4299                 }
4300         }
4301
4302         return item;
4303 }
4304
4305 bool
4306 XamlElementInstanceNative::SetProperty (XamlParserInfo *p, XamlElementInstance *property, XamlElementInstance *value)
4307 {
4308         if (property->info->RequiresManagedSet () || value->info->RequiresManagedSet ())
4309                 return p->loader->SetProperty (p, p->GetTopElementPtr (), NULL, GetAsValue (), this, GetParentPointer (), property->info->xmlns, property->element_name, value->GetAsValue (), NULL);
4310
4311         return dependency_object_set_property (p, this, property, value, true);
4312 }
4313
4314 bool
4315 XamlElementInstanceNative::SetProperty (XamlParserInfo *p, XamlElementInstance *property, const char *value)
4316 {
4317         char **prop_name = g_strsplit (property->element_name, ".", -1);
4318         Type *owner = Type::Find (p->deployment, prop_name [0]);
4319         DependencyProperty *dep;
4320
4321         if (!owner)
4322                 return false;
4323
4324         dep = DependencyProperty::GetDependencyProperty (Type::Find (p->deployment, owner->GetKind ()), prop_name [1]);
4325         if (!dep)
4326                 return false;
4327
4328         return xaml_set_property_from_str (item, dep, value, NULL/*XXX*/);
4329 }
4330
4331 void
4332 XamlElementInstanceNative::AddChild (XamlParserInfo *p, XamlElementInstance *child)
4333 {
4334         dependency_object_add_child (p, this, child, true);
4335 }
4336
4337 void
4338 XamlElementInstanceNative::SetAttributes (XamlParserInfo *p, const char **attr)
4339 {
4340         dependency_object_set_attributes (p, this, attr);
4341 }
4342
4343
4344 XamlElementInstanceValueType::XamlElementInstanceValueType (XamlElementInfoNative *element_info, XamlParserInfo *parser_info, const char *name, ElementType type) :
4345         XamlElementInstance (element_info, name, type)
4346 {
4347         this->element_info = element_info;
4348         this->parser_info = parser_info;
4349 }
4350
4351 bool
4352 XamlElementInstanceValueType::CreateValueItemFromString (const char* str)
4353 {
4354
4355         bool res = value_from_str (element_info->GetType ()->GetKind (), NULL, str, &value);
4356         return res;
4357 }
4358
4359 void
4360 XamlElementInstanceValueType::SetAttributes (XamlParserInfo *p, const char **attr)
4361 {
4362         value_type_set_attributes (p, this, attr);
4363 }
4364
4365 XamlElementInstanceEnum::XamlElementInstanceEnum (XamlElementInfoEnum *element_info, const char *name, ElementType type) :
4366         XamlElementInstance (element_info, name, type)
4367 {
4368 }
4369
4370 bool
4371 XamlElementInstanceEnum::CreateEnumFromString (const char* str)
4372 {
4373         int i = enums_str_to_int (element_name, str);
4374         if (i == -1)
4375                 return false;
4376
4377         value = new Value (i);
4378         return true;
4379 }
4380
4381 void
4382 XamlElementInstanceEnum::SetAttributes (XamlParserInfo *p, const char **attr)
4383 {
4384         value_type_set_attributes (p, this, attr);
4385 }
4386
4387 XamlElementInstance *
4388 XamlElementInfoEnum::CreateElementInstance (XamlParserInfo *p)
4389 {
4390         return new XamlElementInstanceEnum (this, name, XamlElementInstance::ELEMENT);
4391 }
4392
4393 XamlElementInstance *
4394 XamlElementInfoEnum::CreateWrappedElementInstance (XamlParserInfo *p, Value *o)
4395 {
4396         XamlElementInstance *res = new XamlElementInstanceEnum (this, name, XamlElementInstance::ELEMENT);
4397         return res;
4398 }
4399
4400 const char *
4401 XamlElementInfoManaged::GetContentProperty (XamlParserInfo *p)
4402 {
4403         if (!p->loader)
4404                 return NULL;
4405
4406         // TODO: We could cache this, but for now lets keep things as simple as possible.
4407         const char *res = p->loader->GetContentPropertyName (p, p->GetTopElementPtr (), obj);
4408         if (res)
4409                 return res;
4410         return XamlElementInfo::GetContentProperty (p);
4411 }
4412
4413 XamlElementInstance *
4414 XamlElementInfoManaged::CreateElementInstance (XamlParserInfo *p)
4415 {
4416         XamlElementInstanceManaged *inst = new XamlElementInstanceManaged (this, GetName (), XamlElementInstance::ELEMENT, obj);
4417
4418         if (obj->Is (p->deployment, Type::DEPENDENCY_OBJECT))
4419                 p->AddCreatedElement (inst->GetAsDependencyObject ());
4420
4421         return inst;
4422 }
4423
4424 XamlElementInstance *
4425 XamlElementInfoManaged::CreateWrappedElementInstance (XamlParserInfo *p, Value *o)
4426 {
4427         XamlElementInstanceManaged *inst = new XamlElementInstanceManaged (this, GetName (), XamlElementInstance::ELEMENT, o);
4428
4429         return inst;
4430 }
4431
4432 XamlElementInstance *
4433 XamlElementInfoManaged::CreatePropertyElementInstance (XamlParserInfo *p, const char *name)
4434 {
4435         XamlElementInstanceManaged *inst = new XamlElementInstanceManaged (this, name, XamlElementInstance::PROPERTY, obj);
4436
4437         return inst;
4438 }
4439
4440 XamlElementInstanceManaged::XamlElementInstanceManaged (XamlElementInfo *info, const char *name, ElementType type, Value *obj) :
4441         XamlElementInstance (info, name, type)
4442 {
4443         // The managed code owns our Value objects
4444         cleanup_value = false;
4445
4446         this->value = obj;
4447
4448         if (obj->Is (Deployment::GetCurrent (), Type::DEPENDENCY_OBJECT)) {
4449                 this->is_dependency_object = true;
4450                 this->SetDependencyObject (obj->AsDependencyObject ());
4451         }
4452         else
4453                 this->is_dependency_object = false;
4454 }
4455
4456 void *
4457 XamlElementInstanceManaged::GetManagedPointer ()
4458 {
4459         if (value->Is (Deployment::GetCurrent (), Type::DEPENDENCY_OBJECT))
4460                 return value->AsDependencyObject ();
4461         return value->AsManagedObject ();
4462 }
4463
4464 Value *
4465 XamlElementInstanceManaged::GetParentPointer ()
4466 {
4467         XamlElementInstance *walk = parent;
4468         while (walk && walk->element_type != XamlElementInstance::ELEMENT)
4469                 walk = walk->parent;
4470
4471         if (!walk) {
4472                 return NULL;
4473         }
4474
4475         return walk->GetAsValue ();
4476 }
4477
4478 bool
4479 XamlElementInstanceManaged::SetProperty (XamlParserInfo *p, XamlElementInstance *property, XamlElementInstance *value)
4480 {
4481         if (GetAsDependencyObject () != NULL && dependency_object_set_property (p, this, property, value, false))
4482                 return true;
4483         return p->loader->SetProperty (p, p->GetTopElementPtr (), info->xmlns, GetAsValue (), this, GetParentPointer (), property->info->xmlns, property->element_name, value->GetAsValue (), value);
4484 }
4485
4486 bool
4487 XamlElementInstanceManaged::SetProperty (XamlParserInfo *p, XamlElementInstance *property, const char *value)
4488 {
4489         Value v = Value (value);
4490         return p->loader->SetProperty (p, p->GetTopElementPtr (), info->xmlns, GetAsValue (), this, GetParentPointer (), property->info->xmlns, property->element_name, &v, NULL);
4491 }
4492
4493 void
4494 XamlElementInstanceManaged::AddChild (XamlParserInfo *p, XamlElementInstance *child)
4495 {
4496         if (element_type == XamlElementInstance::PROPERTY) {
4497                 Value *prop = new Value (element_name);
4498                 p->loader->AddChild (p, p->GetTopElementPtr (), GetParentPointer (), true, info->xmlns, prop, this, child->GetAsValue (), child);
4499                 delete prop;
4500                 return;
4501         }
4502
4503         p->loader->AddChild (p, p->GetTopElementPtr (), GetParentPointer (), false, info->xmlns, GetAsValue (), this, child->GetAsValue (), child);
4504 }
4505
4506 void
4507 XamlElementInstanceManaged::SetAttributes (XamlParserInfo *p, const char **attr)
4508 {
4509         dependency_object_set_attributes (p, this, attr);
4510 }
4511
4512 bool
4513 XamlElementInstanceManaged::TrySetContentProperty (XamlParserInfo *p, XamlElementInstance *value)
4514 {
4515         Value *v = value->GetAsValue ();
4516         const char* prop_name = info->GetContentProperty (p);
4517
4518         return p->loader->SetProperty (p, p->GetTopElementPtr (), info->xmlns, GetAsValue (), this, GetParentPointer (), NULL, prop_name, v, value);
4519 }
4520
4521 bool
4522 XamlElementInstanceManaged::TrySetContentProperty (XamlParserInfo *p, const char *value)
4523 {
4524         if (Type::IsSubclassOf (p->deployment, info->GetKind (), Type::CONTENTCONTROL)) {
4525                 // Content controls are not allowed to have their content set as text, they need to have a child element
4526                 // if you want to set the content of a contentcontrol to text you need to use attribute syntax
4527                 return false;
4528         }
4529
4530         if (!XamlElementInstance::TrySetContentProperty (p, value)) {
4531                 const char* prop_name = info->GetContentProperty (p);
4532                 if (!p->cdata_content)
4533                         return false;
4534                 Value v = Value (value);
4535                 bool res = p->loader->SetProperty (p, p->GetTopElementPtr (), info->xmlns, GetAsValue (), this, GetParentPointer (), NULL, prop_name, &v, NULL);
4536                 return res;
4537         }
4538
4539         return false;
4540 }
4541
4542 XamlElementInstance *
4543 XamlElementInfoImportedManaged::CreateElementInstance (XamlParserInfo *p)
4544 {
4545         XamlElementInstanceManaged *inst = new XamlElementInstanceManaged (this, name, XamlElementInstance::ELEMENT, obj);
4546
4547         return inst;
4548 }
4549
4550 const char *
4551 XamlElementInfoImportedManaged::GetContentProperty (XamlParserInfo *p)
4552 {
4553         if (!p->loader)
4554                 return NULL;
4555
4556         // TODO: Test, it's possible that managed objects that aren't DOs are allowed to have content properties.
4557         if (!obj->Is (p->deployment, Type::DEPENDENCY_OBJECT))
4558                 return XamlElementInfo::GetContentProperty (p);
4559
4560
4561         // TODO: We could cache this, but for now lets keep things as simple as possible.
4562         const char *res = p->loader->GetContentPropertyName (p, p->GetTopElementPtr (), obj);
4563         if (res)
4564                 return res;
4565
4566         return XamlElementInfo::GetContentProperty (p);
4567 }
4568
4569 XamlElementInstance *
4570 XamlElementInfoImportedManaged::CreateWrappedElementInstance (XamlParserInfo *p, Value *o)
4571 {
4572         XamlElementInstanceManaged *inst = new XamlElementInstanceManaged (this, Type::Find (p->deployment, o->GetKind ())->GetName (), XamlElementInstance::ELEMENT, o);
4573
4574         return inst;
4575 }
4576
4577 XamlElementInstance *
4578 XamlElementInfoImportedManaged::CreatePropertyElementInstance (XamlParserInfo *p, const char *name)
4579 {
4580         XamlElementInstanceManaged *inst = new XamlElementInstanceManaged (this, name, XamlElementInstance::PROPERTY, obj);
4581
4582         return inst;
4583 }
4584
4585
4586 ///
4587 /// Add Child funcs
4588 ///
4589
4590 static const char*
4591 get_key_from_child (XamlElementInstance *child)
4592 {
4593         const char *key = child->GetKey ();
4594         if (key)
4595                 return key;
4596
4597         key = child->GetName ();
4598         if (key)
4599                 return key;
4600
4601         if (child->IsDependencyObject ()) {
4602                 DependencyObject *c = child->GetAsDependencyObject();
4603
4604                 if (Type::IsSubclassOf (c->GetDeployment (), Type::STYLE, child->info->GetKind ())) {
4605                         Value *v = c->GetValue (Style::TargetTypeProperty);
4606                         if (v && v->GetKind () == Type::MANAGEDTYPEINFO)
4607                                 key = v->AsManagedTypeInfo ()->full_name;
4608
4609                         if (key)
4610                                 return key;
4611                 }
4612         }
4613
4614         return NULL;
4615 }
4616
4617 static void
4618 dependency_object_add_child (XamlParserInfo *p, XamlElementInstance *parent, XamlElementInstance *child, bool fail_if_no_prop)
4619 {
4620         Types *types = Deployment::GetCurrent ()->GetTypes ();
4621         if (parent->element_type == XamlElementInstance::PROPERTY) {
4622
4623                 if (parent->info->RequiresManagedSet ())
4624                         return;
4625
4626                 char **prop_name = g_strsplit (parent->element_name, ".", -1);
4627                 Type *owner = types->Find (prop_name [0]);
4628
4629                 if (owner) {
4630                         DependencyProperty *dep = DependencyProperty::GetDependencyProperty (Type::Find (p->deployment, owner->GetKind ()), prop_name [1]);
4631
4632                         g_strfreev (prop_name);
4633
4634                         if (!dep) {
4635                                 g_warning ("Unknown element: %s.", parent->element_name);
4636                                 if (fail_if_no_prop)
4637                                         parser_error (p, parent->element_name, NULL, 2007, "Unknown element: %s.", parent->element_name);
4638                                 return;
4639                         }
4640
4641                         // XamlElementInfoEnum has Type::INVALID as
4642                         // its kind, which is why that first check is
4643                         // here.
4644                         if (child->info->GetKind() != Type::MANAGED &&
4645                             !types->Find (child->info->GetKind())->IsCtorVisible()) {
4646                                 // we can't instantiate this type
4647                                 return parser_error (p, child->element_name, NULL, 2007,
4648                                                      "Unknown element: %s.", child->element_name);
4649                         }
4650
4651                         // Don't add the child element, if it is the entire collection
4652                         if (dep->GetPropertyType() == child->info->GetKind ())
4653                                 return;
4654
4655                         Type::Kind prop_type = dep->GetPropertyType ();
4656                         if (!types->IsSubclassOf (prop_type, Type::DEPENDENCY_OBJECT_COLLECTION)
4657                             && !types->IsSubclassOf (prop_type, Type::RESOURCE_DICTIONARY))
4658                                 return;
4659
4660                         // Most common case, we will have a parent that we can snag the collection from
4661                         DependencyObject *obj = (DependencyObject *) parent->parent->GetAsDependencyObject ();
4662                         if (!obj)
4663                                 return;
4664
4665                         Value *col_v = obj->GetValue (dep);
4666                         if (!col_v) {
4667                                 Type *col_type = types->Find (prop_type);
4668                                 DependencyObject *c_obj = col_type->CreateInstance ();
4669                                 obj->SetValue (dep, Value::CreateUnrefPtr (c_obj));
4670                                 col_v = obj->GetValue (dep);
4671                                 c_obj->unref ();
4672                         }
4673                         Collection *col = col_v->AsCollection ();
4674                         MoonError err;
4675
4676                         if (types->IsSubclassOf (prop_type, Type::DEPENDENCY_OBJECT_COLLECTION)) {
4677                                 Value child_val (child->GetAsDependencyObject ());
4678                                 if (-1 == col->AddWithError (&child_val, &err))
4679                                         return parser_error (p, child->element_name, NULL, err.code, err.message);
4680                         }
4681                         else if (types->IsSubclassOf (prop_type, Type::RESOURCE_DICTIONARY)) {
4682                                 ResourceDictionary *dict = (ResourceDictionary *)col;
4683
4684                                 const char *key = get_key_from_child (child);
4685
4686                                 if (key == NULL) {
4687                                         // XXX don't know the proper values here...
4688                                         return parser_error (p, child->element_name, NULL, 2007,
4689                                                              "You must specify an x:Key or x:Name for elements in a ResourceDictionary");
4690                                 }
4691
4692                                 Value *child_as_value = child->GetAsValue ();
4693
4694                                 if (!child_as_value) {
4695                                         // XXX don't know the proper values here...
4696                                         return parser_error (p, child->element_name, NULL, 2007,
4697                                                              "Error adding child to ResourceDictionary");
4698                                 }
4699
4700                                 bool added = dict->AddWithError (key, child_as_value, &err);
4701                                 if (!added)
4702                                         return parser_error (p, child->element_name, NULL, err.code, err.message);
4703                         }
4704
4705                         return;
4706                 }
4707
4708                 return;
4709         }
4710
4711         if (types->IsSubclassOf (parent->info->GetKind (), Type::DEPENDENCY_OBJECT_COLLECTION)) {
4712                 Collection *col = (Collection *) parent->GetAsDependencyObject ();
4713                 MoonError err;
4714                 Value child_val ((DependencyObject*)child->GetAsDependencyObject ());
4715
4716                 if (-1 == col->AddWithError (&child_val, &err))
4717                         return parser_error (p, child->element_name, NULL, err.code, err.message);
4718                 return;
4719         }
4720         else if (types->IsSubclassOf (parent->info->GetKind (), Type::RESOURCE_DICTIONARY)) {
4721                 ResourceDictionary *dict = (ResourceDictionary *) parent->GetAsDependencyObject ();
4722
4723                 MoonError err;
4724                 const char *key = get_key_from_child (child);
4725
4726                 if (key == NULL) {
4727                         // XXX don't know the proper values here...
4728                         return parser_error (p, child->element_name, NULL, 2007,
4729                                              "You must specify an x:Key or x:Name for elements in a ResourceDictionary");
4730                 }
4731
4732                 Value *child_as_value = child->GetAsValue ();
4733                 bool added = dict->AddWithError (key, child_as_value, &err);
4734                 if (!added)
4735                         return parser_error (p, child->element_name, NULL, err.code, err.message);
4736         }
4737
4738
4739         if (parent->element_type != XamlElementInstance::PROPERTY) {
4740                 parent->TrySetContentProperty (p, child);
4741         }
4742
4743         // Do nothing if we aren't adding to a collection, or a content property collection
4744 }
4745
4746
4747 ///
4748 /// set property funcs
4749 ///
4750
4751 // these are just a bunch of special cases
4752 static void
4753 dependency_object_missed_property (XamlElementInstance *item, XamlElementInstance *prop, XamlElementInstance *value, char **prop_name)
4754 {
4755
4756 }
4757
4758 static bool
4759 set_managed_attached_property (XamlParserInfo *p, XamlElementInstance *item, XamlElementInstance *prop, XamlElementInstance *value)
4760 {
4761         if (!p->loader)
4762                 return false;
4763
4764         return p->loader->SetProperty (p, p->GetTopElementPtr (), item->info->xmlns, item->GetAsValue (), item, item->GetParentPointer (), prop->info->xmlns, prop->element_name, value->GetAsValue (), value);
4765 }
4766
4767 static bool
4768 dependency_object_set_property (XamlParserInfo *p, XamlElementInstance *item, XamlElementInstance *property, XamlElementInstance *value, bool raise_errors)
4769 {
4770         char **prop_name = g_strsplit (property->element_name, ".", -1);
4771         DependencyObject *dep = item->GetAsDependencyObject ();
4772         DependencyProperty *prop = NULL;
4773         bool res;
4774         Types *types = Deployment::GetCurrent ()->GetTypes ();
4775
4776         if (types->Find (item->info->GetKind ())->IsValueType ()) {
4777                 if (raise_errors) parser_error (p, item->element_name, NULL, -1, "Value types (%s) do not have properties.", property->element_name);
4778                 g_strfreev (prop_name);
4779                 return false;
4780         }
4781
4782         if (types->Find (property->info->GetPropertyOwnerKind ())->IsCustomType ()) {
4783                 g_strfreev (prop_name);
4784                 return set_managed_attached_property (p, item, property, value);
4785         }
4786
4787         if (!dep) {
4788                 // FIXME is this really where this check should live
4789                 if (raise_errors)
4790                         parser_error (p, item->element_name, NULL, 2030,
4791                               "Property element %s cannot be used inside another property element.",
4792                               property->element_name);
4793
4794                 g_strfreev (prop_name);
4795                 return false;
4796         }
4797
4798         prop = DependencyProperty::GetDependencyProperty (Type::Find (p->deployment, item->info->GetKind ()), prop_name [1]);
4799
4800         if (prop) {
4801                 if (prop->IsReadOnly ()) {
4802                         if (raise_errors)
4803                                 parser_error (p, item->element_name, NULL, 2014,
4804                                         "The attribute %s is read only and cannot be set.", prop->GetName ());
4805                         res = false;
4806                 } else if (types->IsSubclassOf (value->info->GetKind (), prop->GetPropertyType())) {
4807                         // an empty collection can be NULL and valid
4808                         if (item->IsPropertySet (prop->GetName())) {
4809                                 if (raise_errors)
4810                                         parser_error (p, item->element_name, NULL, 2033,
4811                                                 "Cannot specify the value multiple times for property: %s.",
4812                                                 property->element_name);
4813                                 res = false;
4814                         } else {
4815                                 MoonError err;
4816
4817                                 // HACK - since the Setter is added to the collection *before* its properties are set
4818                                 // we find ourselves with a sealed Setter - which should not be possible at the parse time
4819                                 SetterBase *sb = NULL;
4820                                 if (types->IsSubclassOf (dep->GetObjectType (), Type::SETTERBASE)) {
4821                                         sb = (SetterBase*) dep;
4822                                         sb->SetIsSealed (false);
4823                                 }
4824
4825                                 if (!is_managed_kind (value->info->GetKind ()) && !value->info->RequiresManagedSet()) {
4826                                         if (!dep->SetValueWithError (prop, value->GetAsValue (), &err)) {
4827                                                 if (raise_errors)
4828                                                         parser_error (p, item->element_name, NULL, err.code, err.message);
4829                                                 res = false;
4830                                                 goto cleanup;
4831                                         }
4832
4833                                 } else {
4834                                         if (!p->loader->SetProperty (p, p->GetTopElementPtr (), NULL, item->GetAsValue (), item, item->GetParentPointer (), NULL, prop_name [1], value->GetAsValue (), NULL)) {
4835                                                 if (raise_errors)
4836                                                         parser_error (p, item->element_name, NULL, err.code, err.message);
4837                                                 res = false;
4838                                                 goto cleanup;
4839                                         }
4840                                 }
4841
4842
4843                                 // re-seal the Setter (end-HACK)
4844                                 if (sb)
4845                                         sb->SetIsSealed (true);
4846
4847                                 item->MarkPropertyAsSet (prop->GetName());
4848                                 res = true;
4849                         }
4850                 } else if (types->IsSubclassOf (prop->GetPropertyType (), Type::COLLECTION) || types->IsSubclassOf (prop->GetPropertyType (), Type::RESOURCE_DICTIONARY)) {
4851                         // The items were added in add_child
4852                         return true;
4853                 } else {
4854                         if (raise_errors)
4855                                 parser_error (p, item->element_name, NULL, 2010, "does not support %s as content.", value->element_name);
4856                         res = false;
4857                 }
4858         } else {
4859                 dependency_object_missed_property (item, property, value, prop_name);
4860                 res = false;
4861         }
4862
4863 cleanup:
4864         g_strfreev (prop_name);
4865         return res;
4866 }
4867
4868 bool
4869 xaml_set_property_from_str (DependencyObject *obj, DependencyProperty *prop, const char *value, MoonError *error)
4870 {
4871         Value *v = NULL;
4872         bool rv = true;
4873
4874         if (!value_from_str (prop->GetPropertyType(), prop->GetName(), value, &v))
4875                 return false;
4876
4877         // it's possible for (a valid) value to be NULL (and we must keep the default value)
4878         if (v) {
4879                 rv = obj->SetValueWithError (prop, v, error);
4880                 delete v;
4881         }
4882
4883         return rv;
4884 }
4885
4886 bool
4887 xaml_is_valid_event_name (Deployment *deployment, Type::Kind kind, const char *name, bool allow_desktop_events)
4888 {
4889         Type *type = Type::Find (deployment, kind);
4890         if (!type)
4891                 return false;
4892
4893         int event_id = type->LookupEvent (name);
4894         if (event_id == -1)
4895                 return false;
4896
4897         if (!allow_desktop_events || (moonlight_flags & RUNTIME_INIT_DESKTOP_EXTENSIONS) == 0) {
4898                 // if we're not allowing desktop-only events, or if the user hasn't allowed them,
4899                 // return false if the name corresponds to one of them.
4900                 if (!strcmp (name, "MouseRightButtonDown") ||
4901                     !strcmp (name, "MouseRightButtonUp") ||
4902                     !strcmp (name, "MouseWheel"))
4903                 return false;
4904         }
4905
4906         return true;
4907 }
4908
4909 static void
4910 value_type_set_attributes (XamlParserInfo *p, XamlElementInstance *item, const char **attr)
4911 {
4912         // the only attributes value on value types seem to be x:Key
4913         // and x:Name, but reuse the generic namespace attribute stuff
4914         // anyway.
4915         //
4916         for (int i = 0; attr [i]; i += 2) {
4917                 // Skip empty attrs
4918                 if (attr[i + 1] == NULL || attr[i + 1][0] == '\0')
4919                         continue;
4920
4921                 char **attr_name = g_strsplit (attr [i], "|", -1);
4922
4923                 if (attr_name [1]) {
4924
4925                         XamlNamespace *ns = (XamlNamespace *) g_hash_table_lookup (p->namespace_map, attr_name [0]);
4926
4927                         if (!ns)
4928                                 return parser_error (p, item->element_name, attr[i], 7055, "undeclared prefix");
4929
4930                         ns->SetAttribute (p, item, attr_name [1], attr [i + 1]);
4931
4932                         g_strfreev (attr_name);
4933
4934                         // Setting managed attributes can cause errors galore
4935                         if (p->error_args)
4936                                 return;
4937
4938                         continue;
4939                 }
4940
4941                 g_strfreev (attr_name);
4942         }
4943 }
4944
4945 static void
4946 dependency_object_set_attributes (XamlParserInfo *p, XamlElementInstance *item, const char **attr)
4947 {
4948         Types *types = Deployment::GetCurrent ()->GetTypes ();
4949         GList *delay_att = NULL;
4950
4951         for (int i = 0; attr [i]; i += 2) {
4952
4953                 if (p->error_args)
4954                         return;
4955
4956                 // Setting attributes like x:Class can change item->item, so we
4957                 // need to make sure we have an up to date pointer
4958                 DependencyObject *dep = item->GetAsDependencyObject ();
4959                 char **attr_name = g_strsplit (attr [i], "|", -1);
4960
4961                 if (attr_name [1]) {
4962                         XamlNamespace *ns = (XamlNamespace *) g_hash_table_lookup (p->namespace_map, attr_name [0]);
4963
4964                         if (ns != x_namespace) {
4965                                 delay_att = g_list_append (delay_att, GINT_TO_POINTER (i));
4966                                 g_strfreev (attr_name);
4967                                 continue;
4968                         }
4969
4970                         if (!ns) {
4971                                 g_strfreev (attr_name);
4972                                 return parser_error (p, item->element_name, attr[i], 5055, "undeclared prefix");
4973                         }
4974
4975                         ns->SetAttribute (p, item, attr_name [1], attr [i + 1]);
4976
4977                         g_strfreev (attr_name);
4978
4979                         // Setting managed attributes can cause errors galore
4980                         if (p->error_args)
4981                                 return;
4982
4983                         continue;
4984                 }
4985
4986                 g_strfreev (attr_name);
4987
4988                 const char *pname = attr [i];
4989                 char *atchname = NULL;
4990                 for (int a = 0; attr [i][a]; a++) {
4991                         if (attr [i][a] != '.')
4992                                 continue;
4993                         atchname = g_strndup (attr [i], a);
4994                         pname = attr [i] + a + 1;
4995                         break;
4996                 }
4997
4998                 DependencyProperty *prop = NULL;
4999                 if (atchname) {
5000                         Type *attached_type = types->Find (atchname);
5001                         if (attached_type)
5002                                 prop = DependencyProperty::GetDependencyProperty (attached_type, pname);
5003                 } else {
5004                         prop = DependencyProperty::GetDependencyProperty (Type::Find (p->deployment, item->info->GetKind ()), pname);
5005                 }
5006
5007                 if (prop) {
5008                         if (prop->GetId () == DependencyObject::NameProperty) {
5009
5010                                 if (item->GetName ()) {
5011                                         parser_error (p, item->element_name, NULL, 2016, "Cannot specify both Name and x:Name attributes.");
5012                                         return;
5013                                 }
5014
5015                                 // XXX toshok - I don't like doing this here... but it fixes airlines.
5016                                 item->SetKey (p, attr[i+1]);
5017
5018                                 NameScope *scope = p->namescope;
5019                                 if (!item->GetAsDependencyObject ()->SetName (attr [i+1], scope)) {
5020                                         parser_error (p, item->element_name, NULL, 2028,
5021                                                       "The name already exists in the tree: %s.", attr [i+1]);
5022                                         g_free (atchname);
5023                                         g_list_free (delay_att);
5024                                         return;
5025                                 }
5026                                 continue;
5027                         }
5028
5029                         if (prop->IsReadOnly ()) {
5030                                 parser_error (p, item->element_name, NULL, 2014,
5031                                               "The attribute %s is read only and cannot be set.", prop->GetName ());
5032                                 g_free (atchname);
5033                                 g_list_free (delay_att);
5034                                 return;
5035                         }
5036
5037                         if (item->IsPropertySet (prop->GetName())) {
5038                                 parser_error (p, item->element_name, attr [i], 2033,
5039                                               "Cannot specify the value multiple times for property: %s.", prop->GetName ());
5040                                 g_free (atchname);
5041                                 g_list_free (delay_att);
5042                                 return;
5043                         }
5044
5045                         Value *v = NULL;
5046                         bool v_set = false;
5047                         char *attr_value = g_strdup (attr [i+1]);
5048
5049                         bool need_managed = false;
5050                         if (attr[i+1][0] == '{') {
5051                                 if (attr[i+1][1] == '}') {
5052                                         // {} is an escape sequence so you can have strings like {StaticResource}
5053                                         char *nv = attr_value;
5054                                         attr_value = g_strdup (attr_value + 2);
5055                                         g_free (nv);
5056                                 }
5057                                 else if (attr[i+1][strlen(attr[i+1]) - 1] == '}') {
5058                                         need_managed = true;
5059                                 }
5060                         }
5061
5062                         if (!need_managed) {
5063                                 if (!value_from_str_with_parser (p, prop->GetPropertyType(), prop->GetName(), attr_value, &v, &v_set)) {
5064                                         delete v;
5065                                         g_free (attr_value);
5066                                         continue;
5067                                 }
5068                         }
5069
5070                         Type::Kind propKind = prop->GetPropertyType ();
5071
5072                         if (need_managed || is_managed_kind (propKind) || types->Find (prop->GetOwnerType ())->IsCustomType () || (v && is_managed_kind (v->GetKind ()))) {
5073                                 bool str_value = false;
5074                                 if (!v_set) {
5075                                         v = new Value (attr [i + 1]); // Note that we passed the non escaped value, not attr_value
5076                                         v_set = true;
5077                                         str_value = true;
5078                                 }
5079
5080 //                              printf ("setting managed property: %s::%s to %s=%s\n", dep->GetType ()->GetName (), prop->GetName (), attr [i], attr [i + 1]);
5081                                 if (p->loader->SetProperty (p, p->GetTopElementPtr (), NULL, item->GetAsValue (), item, item->GetParentPointer (), NULL, g_strdup (attr [i]), v, NULL)) {
5082                                         delete v;
5083                                         g_free (attr_value);
5084                                         continue;
5085                                 } else {
5086                                         if (str_value) {
5087                                                 delete v;
5088                                                 v = NULL;
5089                                         }
5090                                         if (!value_from_str_with_parser (p, prop->GetPropertyType(), prop->GetName(), attr_value, &v, &v_set)) {
5091                                                 delete v;
5092                                                 g_free (attr_value);
5093                                                 continue;
5094                                         }
5095                                 }
5096
5097                         }
5098
5099                         if (!v_set && !value_is_explicit_null (attr [i + 1])) { // Check the non escaped value
5100                                 parser_error (p, item->element_name, attr [i], 2024, "Invalid attribute value %s for property %s.", attr [i+1], attr [i]);
5101
5102                                 g_free (attr_value);
5103                                 g_free (atchname);
5104                                 g_list_free (delay_att);
5105                                 return;
5106                         }
5107
5108                         MoonError err;
5109 //                      printf ("settng:  %s  %s  value type:  %s    prop type:  %s\n", attr [i], attr [i+1], v ? Type::Find (v->GetKind ())->GetName () : "--null--", Type::Find (prop->GetPropertyType ())->GetName ());
5110                         if (!dep->SetValueWithError (prop, v, &err))
5111                                 parser_error (p, item->element_name, attr [i], err.code, err.message);
5112                         else
5113                                 item->MarkPropertyAsSet (prop->GetName());
5114
5115                         delete v;
5116                         g_free (attr_value);
5117                 } else {
5118                         delay_att = g_list_append (delay_att, GINT_TO_POINTER (i));
5119                 }
5120
5121                 if (atchname)
5122                         g_free (atchname);
5123         }
5124
5125         GList *walk = g_list_first (delay_att);
5126         while (walk) {
5127                 int i = GPOINTER_TO_INT (walk->data);
5128
5129                 if (p->error_args)
5130                         return;
5131
5132                 char **attr_name = g_strsplit (attr [i], "|", -1);
5133
5134                 if (attr_name [1]) {
5135                         XamlNamespace *ns = (XamlNamespace *) g_hash_table_lookup (p->namespace_map, attr_name [0]);
5136
5137                         if (ns == x_namespace) {
5138                                 // Skip these, they are handled earlier
5139                                 g_strfreev (attr_name);
5140                                 walk = walk->prev;
5141                         }
5142
5143                         if (!ns) {
5144                                 g_strfreev (attr_name);
5145                                 parser_error (p, item->element_name, attr[i], 5055, "undeclared prefix");
5146                                 break;
5147                         }
5148
5149                         ns->SetAttribute (p, item, attr_name [1], attr [i + 1]);
5150
5151                         g_strfreev (attr_name);
5152
5153                         // Setting managed attributes can cause errors galore
5154                         if (p->error_args)
5155                                 break;
5156                 } else {
5157                         if (!item->SetUnknownAttribute (p, attr [i], attr [i + 1])) {
5158                                 parser_error (p, item->element_name, attr [i], 2012,
5159                                                 "Unknown attribute %s on element %s.",
5160                                                 attr [i], item->element_name);
5161                                 break;
5162                         }
5163                 }
5164
5165                 walk = walk->next;
5166         }
5167
5168         g_list_free (delay_att);
5169 }
5170
5171
5172 static Value *
5173 lookup_named_item (XamlElementInstance *top, const char *name)
5174 {
5175         Types *types = Deployment::GetCurrent ()->GetTypes ();
5176         XamlElementInstance *inst = top;
5177
5178         while (inst) {
5179                 if (inst->element_type == XamlElementInstance::ELEMENT) {
5180                         ResourceDictionary *rd = NULL;
5181                         Type::Kind kind = inst->info->GetKind ();
5182
5183                         if (types->IsSubclassOf (kind, Type::FRAMEWORKELEMENT)) {
5184                                 rd = inst->GetAsDependencyObject ()->GetValue (UIElement::ResourcesProperty)->AsResourceDictionary ();
5185                         } else if (types->IsSubclassOf (kind, Type::RESOURCE_DICTIONARY)) {
5186                                 rd = (ResourceDictionary*) inst->GetAsDependencyObject ();
5187                         }
5188
5189                         if (rd) {
5190                                 bool exists;
5191                                 Value *res = lookup_resource_dictionary (rd, name, &exists);
5192                                 if (exists)
5193                                         return res;
5194                         }
5195                 }
5196
5197                 inst = inst->parent;
5198         }
5199
5200         return NULL;
5201 }
5202
5203 static Value *
5204 lookup_resource_dictionary (ResourceDictionary *rd, const char *name, bool *exists)
5205 {
5206         *exists = false;
5207         Value *resource_value = rd->Get (name, exists);
5208         return *exists ? new Value (*resource_value) : NULL;
5209 }
5210
5211 Value *
5212 xaml_lookup_named_item (void *parser, void *instance, const char* name)
5213 {
5214         XamlParserInfo *p = (XamlParserInfo *) parser;
5215         XamlElementInstance *inst = (XamlElementInstance *) instance;
5216         Value *res = NULL;
5217
5218         if (inst)
5219                 res = lookup_named_item (inst, name);
5220
5221         XamlContext *context = p->loader->GetContext ();
5222         if (!res && context)
5223                 context->internal->LookupNamedItem (name, &res);
5224
5225         if (!res) {
5226                 Application *app = Application::GetCurrent ();
5227                 if (app) {
5228                         ResourceDictionary *rd = app->GetResources ();
5229
5230                         bool exists = false;
5231                         res = lookup_resource_dictionary (rd, name, &exists);
5232
5233                         if (res && Type::IsSubclassOf (p->deployment, res->GetKind (), Type::DEPENDENCY_OBJECT)) {
5234                                 DependencyObject *dob = res->AsDependencyObject ();
5235                                 NameScope::SetNameScope (dob, dob->FindNameScope ());
5236                         }
5237                 }
5238         }
5239
5240         return res;
5241 }
5242
5243 void *
5244 xaml_get_template_parent (void *parser, void *element_instance)
5245 {
5246         XamlParserInfo *p = (XamlParserInfo *) parser;
5247         XamlElementInstance *item = (XamlElementInstance *) element_instance;
5248
5249         return p->GetTemplateParent (item);
5250 }
5251
5252 char *
5253 xaml_get_element_key (void *parser, void *element_instance)
5254 {
5255         XamlElementInstance *item = (XamlElementInstance *) element_instance;
5256         const char *key = item->GetKey ();
5257         if (!key)
5258                 key = item->GetName ();
5259         return g_strdup (key);
5260 }
5261
5262 char *
5263 xaml_get_element_name (void *parser, void *element_instance)
5264 {
5265         XamlElementInstance *item = (XamlElementInstance *) element_instance;
5266         return g_strdup (item->element_name);
5267 }
5268
5269 bool
5270 xaml_is_property_set (void *parser, void *element_instance, char *name)
5271 {
5272         XamlElementInstance *item = (XamlElementInstance *) element_instance;
5273         return item->IsPropertySet (name);
5274 }
5275
5276 void
5277 xaml_mark_property_as_set (void *parser, void *element_instance, char *name)
5278 {
5279         XamlElementInstance *item = (XamlElementInstance *) element_instance;
5280         item->MarkPropertyAsSet (g_strdup (name));
5281 }
5282
5283 void
5284 xaml_delay_set_property (void *parser, void *element_instance, const char *xmlns, const char *name, const Value *value)
5285 {
5286         XamlElementInstance *item = (XamlElementInstance *) element_instance;
5287         item->DelaySetProperty (xmlns, name, value);
5288 }
5289
5290 void
5291 xaml_init (void)
5292 {
5293         default_namespace = new DefaultNamespace ();
5294         x_namespace = new XNamespace ();
5295         xml_namespace = new XmlNamespace ();
5296 }