src/dependencyproperty.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * dependencypropery.h:
   4  *
   5  * Copyright 2007-2008 Novell, Inc. (http://www.novell.com)
   6  *
   7  * See the LICENSE file included with the distribution for details.
   8  *
   9  */
  10
  11 #include <config.h>
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <pthread.h>
  16
  17 #include "dependencyproperty.h"
  18 #include "animation.h"
  19 #include "runtime.h"
  20 #include "validators.h"
  21
  22 /*
  23  *      DependencyProperty
  24  */
  25 DependencyProperty::DependencyProperty (Type::Kind owner_type, const char *name, Value *default_value, Type::Kind property_type, bool attached, bool readonly, bool always_change, PropertyChangeHandler changed_callback, ValueValidator *validator, AutoCreator* autocreator, bool is_custom)
  26 {
  27         this->owner_type = owner_type;
  28         this->hash_key = NULL;
  29         this->name = g_strdup (name);
  30         this->default_value = default_value;
  31         this->property_type = property_type;
  32         this->is_nullable = false;
  33         this->is_attached = attached;
  34         this->is_readonly = readonly;
  35         this->always_change = always_change;
  36         this->changed_callback = changed_callback;
  37         this->validator = validator ? validator : Validators::default_validator;
  38         this->autocreator = autocreator;
  39         this->is_custom = is_custom;
  40 }
  41
  42 DependencyProperty::~DependencyProperty ()
  43 {
  44         g_free (name);
  45         if (default_value != NULL)
  46                 delete default_value;
  47         g_free (hash_key);
  48 }
  49
  50 const char *
  51 DependencyProperty::GetHashKey ()
  52 {
  53         if (hash_key == NULL)
  54                 hash_key = g_ascii_strdown (name, -1);
  55
  56         return hash_key;
  57 }
  58
  59 DependencyProperty *
  60 DependencyProperty::GetDependencyProperty (Type::Kind type, const char *name)
  61 {
  62         return GetDependencyProperty (type, name, true);
  63 }
  64
  65 DependencyProperty *
  66 DependencyProperty::GetDependencyProperty (Type::Kind type, const char *name, bool inherits)
  67 {
  68         return GetDependencyProperty (Type::Find (type), name, inherits);
  69 }
  70
  71 DependencyProperty *
  72 DependencyProperty::GetDependencyPropertyFull (Type::Kind type, const char *name, bool inherits)
  73 {
  74         DependencyProperty *property;
  75
  76         property = GetDependencyProperty (type, name, inherits);
  77
  78         if (property == NULL) {
  79                 Type *t = Type::Find (type);
  80                 if (t == NULL)
  81                         return NULL;
  82
  83                 property = GetDependencyProperty (t, name, false);
  84                 if (property == NULL && t->GetParent () != Type::INVALID)
  85                         return GetDependencyPropertyFull (t->GetParent (), name, inherits);
  86         }
  87
  88         return property;
  89 }
  90
  91 DependencyProperty *
  92 DependencyProperty::GetDependencyProperty (Type *type, const char *name, bool inherits)
  93 {
  94         DependencyProperty *property = NULL;
  95
  96         if (type == NULL)
  97                 return NULL;
  98
  99         property = type->LookupProperty (name);
 100
 101         if (property)
 102                 return property;
 103
 104         if (!inherits)
 105                 return NULL;
 106
 107         if (type->GetParent () == Type::INVALID)
 108                 return NULL;
 109
 110         return GetDependencyProperty (Type::Find (type->GetParent ()), name, inherits);
 111 }
 112
 113 //
 114 // Use this for values that can be null
 115 //
 116 int
 117 DependencyProperty::Register (Types *types, Type::Kind type, const char *name, bool is_custom, Type::Kind vtype)
 118 {
 119         return RegisterFull (types, type, name, is_custom, NULL, vtype, false, false, false, NULL, NULL, NULL, false);
 120 }
 121
 122 //
 123 // DependencyObject takes ownership of the Value * for default_value
 124 //
 125 int
 126 DependencyProperty::Register (Types *types, Type::Kind type, const char *name, bool is_custom, Value *default_value)
 127 {
 128         g_return_val_if_fail (default_value != NULL, NULL);
 129
 130         return RegisterFull (types, type, name, is_custom, default_value, default_value->GetKind (), false, false, false, NULL, NULL, NULL, false);
 131 }
 132
 133 //
 134 // DependencyObject takes ownership of the Value * for default_value
 135 // This overload can be used to set the type of the property to a different type
 136 // than the default value (the default value can for instance be a SolidColorBrush
 137 // while the property type can be a Brush).
 138 //
 139 int
 140 DependencyProperty::Register (Types *types, Type::Kind type, const char *name, bool is_custom, Value *default_value, Type::Kind vtype)
 141 {
 142         return RegisterFull (types, type, name, is_custom, default_value, vtype, false, false, false, NULL, NULL, NULL, false);
 143 }
 144
 145 DependencyProperty *
 146 DependencyProperty::RegisterCoreProperty (const char *name, Type::Kind property_type, Type::Kind owner_type, Value *default_value, bool attached, bool readonly, PropertyChangeHandler callback)
 147 {
 148         Types *types = Deployment::GetCurrent ()->GetTypes ();
 149         int id;
 150
 151         if (default_value && default_value->GetKind () == Type::INVALID)
 152                 default_value = NULL;
 153         else
 154                 default_value = new Value (*default_value);
 155
 156         id = DependencyProperty::RegisterFull (types, owner_type, name, false, default_value, property_type, attached, readonly, false, callback, NULL, NULL, false);
 157
 158         return types->GetProperty (id);
 159 }
 160
 161 DependencyProperty *
 162 DependencyProperty::RegisterCustomProperty (const char *name, Type::Kind property_type, Type::Kind owner_type, Value *default_value, bool attached, bool readonly, PropertyChangeHandler callback)
 163 {
 164         Types *types = Deployment::GetCurrent ()->GetTypes ();
 165         int id;
 166
 167         if (default_value && default_value->GetKind () == Type::INVALID)
 168                 default_value = NULL;
 169         else
 170                 default_value = new Value (*default_value);
 171
 172         id = DependencyProperty::RegisterFull (types, owner_type, name, true, default_value, property_type, attached, readonly, false, callback, NULL, NULL, false);
 173
 174         return types->GetProperty (id);
 175 }
 176
 177 //
 178 // Register the dependency property that belongs to @type with the name @name
 179 // The default value is @default_value (if provided) and the type that can be
 180 // stored in the dependency property is of type @vtype
 181 //
 182 int
 183 DependencyProperty::RegisterFull (Types *types, Type::Kind type, const char *name, bool is_custom, Value *default_value, Type::Kind vtype, bool attached, bool readonly, bool always_change, PropertyChangeHandler changed_callback, ValueValidator *validator, AutoCreator* autocreator, bool is_nullable)
 184 {
 185         DependencyProperty *property;
 186
 187         g_return_val_if_fail (types != NULL, NULL);
 188         g_return_val_if_fail (type != Type::INVALID, NULL);
 189         g_return_val_if_fail (name != NULL, NULL);
 190
 191         if (!is_custom && default_value && types->IsSubclassOf (default_value->GetKind (), Type::DEPENDENCY_OBJECT))
 192                 default_value->AsDependencyObject ()->Freeze();
 193
 194         property = new DependencyProperty (type, name, default_value, vtype, attached, readonly, always_change, changed_callback, validator, autocreator, is_custom);
 195         property->is_nullable = is_nullable;
 196
 197         types->AddProperty (property);
 198
 199         return property->GetId ();
 200 }
 201
 202 bool
 203 DependencyProperty::Validate (DependencyObject *instance, Value *value, MoonError *error)
 204 {
 205         return validator (instance, this, value, error);
 206 }
 207
 208 void
 209 DependencyProperty::SetPropertyChangedCallback (PropertyChangeHandler changed_callback)
 210 {
 211         this->changed_callback = changed_callback;
 212 }
 213
 214 Type *
 215 lookup_type (DependencyObject *lu, const char* name)
 216 {
 217         Type *t = Type::Find (name);
 218
 219         if (t)
 220                 return t;
 221
 222         //
 223         // If we are dealing with a managed type and we don't have the full namespace
 224         // we just verify that the type name matches the lookup type.
 225         //
 226
 227         const char *tname = strchr (name, ':');
 228         if (!tname || ! *(++tname))
 229                 return NULL;
 230
 231         const char *luname = lu->GetTypeName ();
 232         int lulen = strlen (luname);
 233         int tlen = strlen (tname);
 234
 235         if (lulen < tlen || strcmp (luname + lulen - tlen, tname))
 236                 return NULL;
 237
 238         return lu->GetType ();
 239 }
 240
 241 //
 242 // Everything inside of a ( ) resolves to a DependencyProperty, if there is a
 243 // '.' after the property, we get the object, and continue resolving from there
 244 // if there is a [n] after the property, we convert the property to a collection
 245 // and grab the nth item.
 246 //
 247 // Dependency properties can be specified as (PropertyName) of the current object
 248 // or they can be specified as (DependencyObject.PropertyName).
 249 //
 250 // Returns NULL on any error
 251 //
 252 DependencyProperty *
 253 resolve_property_path (DependencyObject **o, PropertyPath *propertypath, GHashTable *promoted_values)
 254 {
 255         g_return_val_if_fail (o != NULL, NULL);
 256         g_return_val_if_fail (propertypath != NULL, NULL);
 257         g_return_val_if_fail (propertypath->path != NULL || propertypath->property != NULL, NULL);
 258
 259         if (propertypath->property)
 260                 return propertypath->property;
 261
 262         const char *path = propertypath->path;
 263         if (propertypath->expanded_path)
 264                 path = propertypath->expanded_path;
 265
 266         const char *inend = path + strlen (path);
 267         register const char *inptr = path;
 268         const char *start, *prop = path;
 269         bool expression_found = false;
 270         DependencyProperty *res = NULL;
 271         DependencyObject *lu = *o;
 272         Collection *collection;
 273         char *p, *name = NULL;
 274         Value *value;
 275         Type *type = NULL;
 276         int index;
 277         bool paren_open = false;
 278         bool tick_open = false;
 279         bool cloned = false;
 280
 281         while (inptr < inend) {
 282                 switch (*inptr++) {
 283                 case '(':
 284                         paren_open = true;
 285                         break;
 286                 case ')':
 287                         paren_open = false;
 288                         break;
 289                 case '\'':
 290                         // Ticks are only legal in expanded paths, so we should just fail here
 291                         if (!propertypath->expanded_path) {
 292                                 g_warning ("The ' character is not legal in property paths.");
 293                                 break;
 294                         }
 295
 296                         tick_open = !tick_open;
 297                         break;
 298                 case '.':
 299                         if (tick_open)
 300                                 continue;
 301
 302                         // resolve the dependency property
 303                         if (res) {
 304                                 DependencyObject *new_lu;
 305
 306                                 // make sure that we are getting what we expect
 307                                 if (!(value = lu->GetValue (res)))
 308                                         goto error;
 309
 310                                 if (!(new_lu = value->AsDependencyObject ()))
 311                                         goto error;
 312
 313                                 if (!cloned && !g_hash_table_lookup (promoted_values, value) && !value->Is (Type::UIELEMENT)) {
 314                                         // we need to clone the value here so that we deep copy any
 315                                         // DO subclasses (such as brushes, etc) that we're promoting
 316                                         // from a shared space (Styles, default values)
 317                                         Value *cloned_value = Value::Clone (value);
 318                                         lu->SetValue (res, cloned_value);
 319                                         new_lu = cloned_value->AsDependencyObject();
 320                                         delete cloned_value;
 321
 322                                         cloned_value = lu->GetValue (res);
 323                                         g_hash_table_insert (promoted_values, cloned_value, cloned_value);
 324                                 }
 325
 326                                 lu = new_lu;
 327                         }
 328
 329                         expression_found = false;
 330                         prop = inptr;
 331                         break;
 332                 case '[':
 333                         // Need to be a little more loving
 334                         if (*inptr == '\0')
 335                                 break;
 336
 337                         index = strtol (inptr, &p, 10);
 338                         if (*p != ']' || *(p + 1) != '.')
 339                                 break;
 340
 341                         inptr = p + 2;
 342                         prop = inptr;
 343
 344                         if (expression_found) {
 345                                 expression_found = false;
 346                                 if (!(value = lu->GetValue (res)))
 347                                         goto error;
 348                         }
 349
 350                         if (!(collection = value->AsCollection ()))
 351                                 goto error;
 352
 353                         if (!(value = collection->GetValueAt (index)))
 354                                 goto error;
 355
 356                         if (!(lu = value->AsDependencyObject ()))
 357                                 goto error;
 358
 359                         break;
 360
 361                 default:
 362                         expression_found = true;
 363                         start = inptr - 1;
 364
 365                         while (inptr < inend && (*inptr != '.' || tick_open) && (!paren_open || *inptr != ')') && *inptr != '[') {
 366                                 if (*inptr == '\'') {
 367                                         tick_open = !tick_open;
 368                                         if (!tick_open) {
 369                                                 inptr++;
 370                                                 break;
 371                                         }
 372                                 }
 373                                 inptr++;
 374                         }
 375
 376                         if (inptr == start)
 377                                 goto error;
 378
 379                         if (*inptr == '.') {
 380                                 // we found a type name, now we need to find the property name
 381                                 if ((inptr - start) == 11 && !g_ascii_strncasecmp (start, "TextElement", 11)) {
 382                                         // Some Beta versions of Blend had a bug where they would save the TextBlock
 383                                         // properties as TextElement instead. Since Silverlight 1.0 works around this
 384                                         // bug, we should too. Fixes http://silverlight.timovil.com and
 385                                         // http://election.msn.com/podium08.aspx.
 386                                         type = Type::Find ("TextBlock");
 387                                 } else {
 388                                         const char *s = inptr;
 389                                         if (*(inptr -1) == '\'' && !tick_open) {
 390                                                 s = inptr - 1;
 391                                         }
 392                                         name = g_strndup (start, s - start);
 393                                         type = lookup_type (lu, name);
 394                                         g_free (name);
 395                                 }
 396
 397                                 inptr++;
 398                                 start = inptr;
 399                                 while (inptr < inend && (!paren_open || *inptr != ')') && (*inptr != '.' || tick_open)) {
 400                                         if (*inptr == '\'') {
 401                                                 tick_open = !tick_open;
 402                                                 if (!tick_open) {
 403                                                         inptr++;
 404                                                         break;
 405                                                 }
 406                                         }
 407                                         inptr++;
 408                                 }
 409
 410                                 if (inptr == start)
 411                                         goto error;
 412                         } else {
 413                                 type = Type::Find (lu->GetObjectType ());
 414                         }
 415
 416                         if ((*inptr != ')' && paren_open) || !type)
 417                                 goto error;
 418
 419                         name = g_strndup (start, inptr - start);
 420                         if (!(res = DependencyProperty::GetDependencyProperty (type->GetKind (), name))) {
 421                                 g_free (name);
 422                                 goto error;
 423                         }
 424
 425                         if (!res->IsAttached () && !lu->Is (type->GetKind ())) {
 426                                 // We try to be gracefull here and do something smart...
 427                                 if (!(res = DependencyProperty::GetDependencyProperty (lu->GetObjectType (), name))) {
 428                                         g_free (name);
 429                                         goto error;
 430                                 }
 431                         }
 432
 433                         if (res->IsAttached () && !paren_open)
 434                                 goto error;
 435
 436                         g_free (name);
 437                         break;
 438                 }
 439         }
 440
 441         *o = lu;
 442         return res;
 443
 444  error:
 445         *o = NULL;
 446         return NULL;
 447 }