src/provider.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * provider.cpp: an api for PropertyValue providers (for property inheritance)
   4  *
   5  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   6  *
   7  * See the LICENSE file included with the distribution for details.
   8  *
   9  */
  10
  11 #include <config.h>
  12
  13 #include "cbinding.h"
  14 #include "runtime.h"
  15 #include "provider.h"
  16 #include "control.h"
  17 #include "frameworkelement.h"
  18 #include "textblock.h"
  19 #include "style.h"
  20
  21 //
  22 // LocalPropertyValueProvider
  23 //
  24
  25 LocalPropertyValueProvider::LocalPropertyValueProvider (DependencyObject *obj, PropertyPrecedence precedence)
  26         : PropertyValueProvider (obj, precedence)
  27 {
  28         // XXX maybe move the "DependencyObject::current_values" hash table here?
  29 }
  30
  31 LocalPropertyValueProvider::~LocalPropertyValueProvider ()
  32 {
  33 }
  34
  35 Value *
  36 LocalPropertyValueProvider::GetPropertyValue (DependencyProperty *property)
  37 {
  38         return (Value *) g_hash_table_lookup (obj->GetLocalValues (), property);
  39 }
  40
  41
  42 //
  43 // StylePropertyValueProvider
  44 //
  45
  46 StylePropertyValueProvider::StylePropertyValueProvider (DependencyObject *obj, PropertyPrecedence precedence)
  47         : PropertyValueProvider (obj, precedence)
  48 {
  49         style_hash = g_hash_table_new_full (g_direct_hash, g_direct_equal,
  50                                             (GDestroyNotify)NULL,
  51                                             (GDestroyNotify)event_object_unref);
  52 }
  53
  54 void
  55 StylePropertyValueProvider::unlink_converted_value (gpointer key, gpointer value, gpointer data)
  56 {
  57         StylePropertyValueProvider *provider = (StylePropertyValueProvider*)data;
  58         Setter *s = (Setter*)value;
  59
  60         Value *v = s->GetValue(Setter::ConvertedValueProperty);
  61         if (v->Is(Type::DEPENDENCY_OBJECT)) {
  62                 DependencyObject *dob = v->AsDependencyObject();
  63                 if (dob->GetParent() == provider->obj)
  64                         dob->SetParent(NULL, NULL);
  65         }
  66 }
  67
  68 StylePropertyValueProvider::~StylePropertyValueProvider ()
  69 {
  70         g_hash_table_foreach (style_hash, StylePropertyValueProvider::unlink_converted_value, this);
  71         g_hash_table_destroy (style_hash);
  72 }
  73
  74 Value*
  75 StylePropertyValueProvider::GetPropertyValue (DependencyProperty *property)
  76 {
  77         Setter *setter = (Setter*)g_hash_table_lookup (style_hash, property);
  78
  79         if (!setter)
  80                 return NULL;
  81         else
  82                 return setter->GetValue (Setter::ConvertedValueProperty);
  83 }
  84
  85 void
  86 StylePropertyValueProvider::RecomputePropertyValue (DependencyProperty *prop)
  87 {
  88         Style *style = ((FrameworkElement*)obj)->GetStyle();
  89         if (!style)
  90                 return;
  91
  92         DependencyProperty *property = NULL;
  93         Value *value = NULL;
  94         SetterBaseCollection *setters = style->GetSetters ();
  95         if (!setters)
  96                 return;
  97
  98         CollectionIterator *iter = setters->GetIterator ();
  99         Value *setterBase;
 100         int err;
 101
 102         while (iter->Next () && (setterBase = iter->GetCurrent (&err))) {
 103                 if (err) {
 104                         // Something bad happened - what to do?
 105                         delete iter;
 106                         return;
 107                 }
 108
 109                 if (!setterBase->Is (Type::SETTER))
 110                         continue;
 111
 112                 Setter *setter = setterBase->AsSetter ();
 113                 if (!(value = setter->GetValue (Setter::PropertyProperty)))
 114                         continue;
 115
 116                 if (!(property = value->AsDependencyProperty ()))
 117                         continue;
 118
 119                 if (prop == property) {
 120                         // the hash holds a ref
 121                         setter->ref ();
 122                         g_hash_table_insert (style_hash, property, setter);
 123                         delete iter;
 124                         return;
 125                 }
 126         }
 127
 128         delete iter;
 129
 130 }
 131
 132 void
 133 StylePropertyValueProvider::SealStyle (Style *style)
 134 {
 135         style->Seal ();
 136
 137         SetterBaseCollection *setters = style->GetSetters ();
 138         if (!setters)
 139                 return;
 140
 141         CollectionIterator *iter = setters->GetIterator ();
 142         Value *setterBase;
 143         int err;
 144
 145         while (iter->Next () && (setterBase = iter->GetCurrent (&err))) {
 146                 if (err) {
 147                         // Something bad happened - what to do?
 148                         delete iter;
 149                         return;
 150                 }
 151
 152                 if (!setterBase->Is (Type::SETTER))
 153                         continue;
 154
 155                 Setter *setter = setterBase->AsSetter ();
 156
 157                 DependencyProperty *setter_property;
 158                 Value *value;
 159
 160                 if (!(value = setter->GetValue (Setter::PropertyProperty)))
 161                         continue;
 162
 163                 if (!(setter_property = value->AsDependencyProperty ()))
 164                         continue;
 165
 166                 Value *setter_value;
 167                 if (!(setter_value = setter->GetValue (Setter::ConvertedValueProperty)))
 168                         continue;
 169
 170                 // the hash holds a ref
 171                 setter->ref ();
 172                 g_hash_table_insert (style_hash, setter_property, setter);
 173
 174                 MoonError error;
 175                 obj->ProviderValueChanged (precedence, setter_property, NULL, setter_value, true, true, &error);
 176         }
 177
 178         delete iter;
 179 }
 180
 181
 182 //
 183 // InheritedPropertyValueProvider
 184 //
 185 Value*
 186 InheritedPropertyValueProvider::GetPropertyValue (DependencyProperty *property)
 187 {
 188         int propertyId = property->GetId ();
 189
 190         if (!IsPropertyInherited (propertyId))
 191                 return NULL;
 192
 193         int parentPropertyId = -1;
 194
 195         Types *types =  Deployment::GetCurrent()->GetTypes();
 196
 197 #define INHERIT_CTI_CTI(p) \
 198         G_STMT_START {                                                  \
 199         if (property->GetId () == Control::p ||                         \
 200             property->GetId () == TextBlock::p ||                       \
 201             property->GetId () == Inline::p) {                          \
 202                                                                         \
 203                 if (types->IsSubclassOf (parent->GetObjectType(), Type::CONTROL)) \
 204                         parentPropertyId = Control::p;                  \
 205                 else if (types->IsSubclassOf (parent->GetObjectType(), Type::TEXTBLOCK)) \
 206                         parentPropertyId = TextBlock::p;                \
 207         }                                                               \
 208         } G_STMT_END
 209
 210
 211 #define INHERIT_I_T(p) \
 212         G_STMT_START {                                                  \
 213         if (property->GetId () == Inline::p) {                          \
 214                 parentPropertyId = TextBlock::p;                        \
 215         }                                                               \
 216         } G_STMT_END
 217
 218 #define INHERIT_F_F(p) \
 219         G_STMT_START {                                                  \
 220         if (property->GetId () == FrameworkElement::p) {                \
 221                 parentPropertyId = FrameworkElement::p;                 \
 222         }                                                               \
 223         } G_STMT_END
 224
 225 #define INHERIT_U_U(p) \
 226         G_STMT_START {                                                  \
 227         if (property->GetId () == UIElement::p) {               \
 228                 parentPropertyId = UIElement::p;                        \
 229         }                                                               \
 230         } G_STMT_END
 231
 232         DependencyObject *parent = NULL;
 233
 234         if (types->IsSubclassOf (obj->GetObjectType(), Type::FRAMEWORKELEMENT)) {
 235                 // we loop up the visual tree
 236                 parent = ((FrameworkElement*)obj)->GetVisualParent();
 237                 if (parent) {
 238                         while (parent) {
 239                                 INHERIT_CTI_CTI (ForegroundProperty);
 240                                 INHERIT_CTI_CTI (FontFamilyProperty);
 241                                 INHERIT_CTI_CTI (FontStretchProperty);
 242                                 INHERIT_CTI_CTI (FontStyleProperty);
 243                                 INHERIT_CTI_CTI (FontWeightProperty);
 244                                 INHERIT_CTI_CTI (FontSizeProperty);
 245
 246                                 INHERIT_F_F (LanguageProperty);
 247                                 INHERIT_F_F (DataContextProperty);
 248
 249                                 INHERIT_U_U (UseLayoutRoundingProperty);
 250
 251                                 if (parentPropertyId != -1)
 252                                         return parent->GetValue (types->GetProperty (parentPropertyId));
 253
 254                                 parent = ((FrameworkElement*)parent)->GetVisualParent();
 255                         }
 256                 }
 257         }
 258         else if (types->IsSubclassOf (obj->GetObjectType(), Type::INLINE)) {
 259                 // skip collections
 260                 DependencyObject *new_parent = obj->GetParent();
 261                 while (new_parent && !types->IsSubclassOf (new_parent->GetObjectType(), Type::TEXTBLOCK))
 262                         new_parent = new_parent->GetParent ();
 263                 parent = new_parent;
 264
 265                 if (!parent)
 266                         return NULL;
 267
 268                 INHERIT_I_T (ForegroundProperty);
 269                 INHERIT_I_T (FontFamilyProperty);
 270                 INHERIT_I_T (FontStretchProperty);
 271                 INHERIT_I_T (FontStyleProperty);
 272                 INHERIT_I_T (FontWeightProperty);
 273                 INHERIT_I_T (FontSizeProperty);
 274
 275                 INHERIT_I_T (LanguageProperty);
 276                 INHERIT_I_T (TextDecorationsProperty);
 277
 278                 if (parentPropertyId != -1) {
 279                         return parent->GetValue (parentPropertyId);
 280                 }
 281         }
 282
 283         return NULL;
 284 }
 285
 286
 287 bool
 288 InheritedPropertyValueProvider::IsPropertyInherited (int propertyId)
 289 {
 290 #define PROP_CTI(p) G_STMT_START { \
 291         if (propertyId == Control::p) return true; \
 292         if (propertyId == TextBlock::p) return true; \
 293         if (propertyId == Inline::p) return true; \
 294         } G_STMT_END
 295
 296 #define PROP_F(p) G_STMT_START { \
 297         if (propertyId == FrameworkElement::p) return true; \
 298         } G_STMT_END
 299
 300 #define PROP_U(p) G_STMT_START { \
 301         if (propertyId == UIElement::p) return true; \
 302         } G_STMT_END
 303
 304 #define PROP_I(p) G_STMT_START { \
 305         if (propertyId == Inline::p) return true; \
 306         } G_STMT_END
 307
 308         PROP_CTI (ForegroundProperty);
 309         PROP_CTI (FontFamilyProperty);
 310         PROP_CTI (FontStretchProperty);
 311         PROP_CTI (FontStyleProperty);
 312         PROP_CTI (FontWeightProperty);
 313         PROP_CTI (FontSizeProperty);
 314
 315         PROP_U (UseLayoutRoundingProperty);
 316
 317         PROP_F (LanguageProperty);
 318         PROP_F (DataContextProperty);
 319
 320         PROP_I (LanguageProperty);
 321         PROP_I (TextDecorationsProperty);
 322
 323         return false;
 324 }
 325
 326 DependencyProperty*
 327 InheritedPropertyValueProvider::MapPropertyToDescendant (Types *types,
 328                                                          DependencyProperty *property,
 329                                                          Type::Kind descendantKind)
 330 {
 331 #define PROPAGATE_C_CT(p) G_STMT_START {                                \
 332                 if (property->GetId() == Control::p) {                  \
 333                         if (types->IsSubclassOf (descendantKind, Type::CONTROL)) \
 334                                 return types->GetProperty (Control::p); \
 335                         else if (types->IsSubclassOf (descendantKind, Type::TEXTBLOCK)) \
 336                                 return types->GetProperty (TextBlock::p); \
 337                 }                                                       \
 338         } G_STMT_END
 339
 340 #define PROPAGATE_T_I(p) G_STMT_START {                                 \
 341                 if (property->GetId() == TextBlock::p) {                \
 342                         /* we don't need the check here since we can do it once above all the PROPAGATE_I below */ \
 343                         /*if (types->IsSubclassOf (descendantKind, Type::INLINE))*/ \
 344                                 return types->GetProperty (Inline::p); \
 345                 }                                                       \
 346         } G_STMT_END
 347
 348         if (types->IsSubclassOf (property->GetOwnerType(), Type::CONTROL)) {
 349                 PROPAGATE_C_CT (ForegroundProperty);
 350                 PROPAGATE_C_CT (FontFamilyProperty);
 351                 PROPAGATE_C_CT (FontStretchProperty);
 352                 PROPAGATE_C_CT (FontStyleProperty);
 353                 PROPAGATE_C_CT (FontWeightProperty);
 354                 PROPAGATE_C_CT (FontSizeProperty);
 355         }
 356
 357         if (types->IsSubclassOf (property->GetOwnerType(), Type::TEXTBLOCK)) {
 358                 if (types->IsSubclassOf (descendantKind, Type::INLINE)) {
 359                         PROPAGATE_T_I (ForegroundProperty);
 360                         PROPAGATE_T_I (FontFamilyProperty);
 361                         PROPAGATE_T_I (FontStretchProperty);
 362                         PROPAGATE_T_I (FontStyleProperty);
 363                         PROPAGATE_T_I (FontWeightProperty);
 364                         PROPAGATE_T_I (FontSizeProperty);
 365
 366                         PROPAGATE_T_I (LanguageProperty);
 367                         PROPAGATE_T_I (TextDecorationsProperty);
 368                 }
 369         }
 370
 371         if (types->IsSubclassOf (property->GetOwnerType(), Type::FRAMEWORKELEMENT)) {
 372                 if (types->IsSubclassOf (descendantKind, Type::FRAMEWORKELEMENT)) {
 373                         if (property->GetId() == FrameworkElement::LanguageProperty
 374                             || property->GetId() == FrameworkElement::DataContextProperty)
 375                                 return property;
 376                 }
 377         }
 378
 379         if (types->IsSubclassOf (property->GetOwnerType(), Type::UIELEMENT)) {
 380                 if (types->IsSubclassOf (descendantKind, Type::UIELEMENT)) {
 381                         if (property->GetId() == UIElement::UseLayoutRoundingProperty)
 382                                 return property;
 383                 }
 384         }
 385
 386         return NULL;
 387 }
 388
 389 void
 390 InheritedPropertyValueProvider::PropagateInheritedProperty (DependencyObject *obj, DependencyProperty *property, Value *old_value, Value *new_value)
 391 {
 392         Types *types = obj->GetDeployment ()->GetTypes ();
 393
 394         if (types->IsSubclassOf (obj->GetObjectType(), Type::TEXTBLOCK)) {
 395                 InlineCollection *inlines = ((TextBlock*)obj)->GetInlines();
 396
 397                 // lift this out of the loop since we know all
 398                 // elements of InlinesProperty will be inlines.
 399                 DependencyProperty *child_property = MapPropertyToDescendant (types, property, Type::INLINE);
 400                 if (!child_property)
 401                         return;
 402
 403                 for (int i = 0; i < inlines->GetCount (); i++) {
 404                         Inline *item = inlines->GetValueAt (i)->AsInline ();
 405
 406                         MoonError error;
 407
 408                         item->ProviderValueChanged (PropertyPrecedence_Inherited, child_property,
 409                                                     old_value, new_value, false, false, &error);
 410
 411                         if (error.number) {
 412                                 // FIXME: what do we do here?  I'm guessing we continue propagating?
 413                         }
 414                 }
 415
 416         }
 417         else {
 418                 // for inherited properties, we need to walk down the
 419                 // subtree and call ProviderValueChanged on all
 420                 // elements that can inherit the property.
 421                 DeepTreeWalker walker ((UIElement*)obj, types);
 422
 423                 walker.Step (); // skip obj
 424
 425                 while (UIElement *element = walker.Step ()) {
 426                         DependencyProperty *child_property = MapPropertyToDescendant (types, property, element->GetObjectType());
 427                         if (!child_property)
 428                                 continue;
 429
 430                         MoonError error;
 431
 432                         element->ProviderValueChanged (PropertyPrecedence_Inherited, child_property,
 433                                                        old_value, new_value, true, true, &error);
 434
 435                         if (error.number) {
 436                                 // FIXME: what do we do here?  I'm guessing we continue propagating?
 437                         }
 438
 439                         walker.SkipBranch ();
 440                 }
 441         }
 442 }
 443
 444 #define FOREGROUND_PROP     (1<<0)
 445 #define FONTFAMILY_PROP     (1<<1)
 446 #define FONTSTRETCH_PROP    (1<<2)
 447 #define FONTSTYLE_PROP      (1<<3)
 448 #define FONTWEIGHT_PROP     (1<<4)
 449 #define FONTSIZE_PROP       (1<<5)
 450 #define LANGUAGE_PROP       (1<<6)
 451 #define DATACONTEXT_PROP    (1<<7)
 452 #define LAYOUTROUNDING_PROP (1<<8)
 453
 454 #define HAS_SEEN(s,p)  (((s) & (p))!=0)
 455 #define SEEN(s,p)      ((s)|=(p))
 456
 457 #define PROP_ADD(p,s) G_STMT_START {                                    \
 458         if (!HAS_SEEN (seen, s)) {                                      \
 459                 DependencyProperty *property = types->GetProperty (p);          \
 460                 Value *v = element->GetValue (property, PropertyPrecedence_Inherited, PropertyPrecedence_Inherited); \
 461                 if (v != NULL) {                                        \
 462                         element->ProviderValueChanged (PropertyPrecedence_Inherited, property, \
 463                                                        NULL, v,         \
 464                                                        true, true, &error); \
 465                         SEEN (seen, s);                                 \
 466                 }                                                       \
 467         }                                                               \
 468         } G_STMT_END
 469
 470 static void
 471 walk_tree (Types *types, UIElement *element, guint32 seen)
 472 {
 473         MoonError error;
 474
 475         if (types->IsSubclassOf (element->GetObjectType (), Type::CONTROL)) {
 476                 PROP_ADD (Control::ForegroundProperty, FOREGROUND_PROP);
 477                 PROP_ADD (Control::FontFamilyProperty, FONTFAMILY_PROP);
 478                 PROP_ADD (Control::FontStretchProperty, FONTSTRETCH_PROP);
 479                 PROP_ADD (Control::FontStyleProperty, FONTSTYLE_PROP);
 480                 PROP_ADD (Control::FontWeightProperty, FONTWEIGHT_PROP);
 481                 PROP_ADD (Control::FontSizeProperty, FONTSIZE_PROP);
 482         }
 483
 484         if (types->IsSubclassOf (element->GetObjectType (), Type::TEXTBLOCK)) {
 485                 PROP_ADD (TextBlock::ForegroundProperty, FOREGROUND_PROP);
 486                 PROP_ADD (TextBlock::FontFamilyProperty, FONTFAMILY_PROP);
 487                 PROP_ADD (TextBlock::FontStretchProperty, FONTSTRETCH_PROP);
 488                 PROP_ADD (TextBlock::FontStyleProperty, FONTSTYLE_PROP);
 489                 PROP_ADD (TextBlock::FontWeightProperty, FONTWEIGHT_PROP);
 490                 PROP_ADD (TextBlock::FontSizeProperty, FONTSIZE_PROP);
 491         }
 492
 493         if (types->IsSubclassOf (element->GetObjectType (), Type::FRAMEWORKELEMENT)) {
 494                 PROP_ADD (FrameworkElement::LanguageProperty, LANGUAGE_PROP);
 495                 PROP_ADD (FrameworkElement::DataContextProperty, DATACONTEXT_PROP);
 496         }
 497
 498
 499         PROP_ADD (UIElement::UseLayoutRoundingProperty, LAYOUTROUNDING_PROP);
 500
 501         VisualTreeWalker walker ((UIElement*)element, Logical, types);
 502
 503         while (UIElement *child = walker.Step ())
 504                 walk_tree (types, child, seen);
 505
 506 }
 507
 508 void
 509 InheritedPropertyValueProvider::PropagateInheritedPropertiesOnAddingToTree (UIElement *subtreeRoot)
 510 {
 511         Types *types = subtreeRoot->GetDeployment ()->GetTypes ();
 512
 513         walk_tree (types, subtreeRoot, 0);
 514 }
 515
 516 //
 517 // DefaultPropertyValueProvider
 518 //
 519
 520 Value *
 521 DefaultValuePropertyValueProvider::GetPropertyValue (DependencyProperty *property)
 522 {
 523         return property->GetDefaultValue ();
 524 }
 525
 526
 527 //
 528 // AutoPropertyValueProvider
 529 //
 530
 531 static gboolean
 532 dispose_value (gpointer key, gpointer value, gpointer data)
 533 {
 534         DependencyObject *obj = (DependencyObject *) data;
 535         Value *v = (Value *) value;
 536
 537         if (!value)
 538                 return true;
 539
 540         // detach from the existing value
 541         if (v->Is (Type::DEPENDENCY_OBJECT)) {
 542                 DependencyObject *dob = v->AsDependencyObject ();
 543
 544                 if (dob != NULL) {
 545                         if (obj == dob->GetParent ()) {
 546                                 // unset its logical parent
 547                                 dob->SetParent (NULL, NULL);
 548                         }
 549
 550                         // unregister from the existing value
 551                         dob->RemovePropertyChangeListener (obj, NULL);
 552                 }
 553         }
 554
 555         delete v;
 556
 557         return true;
 558 }
 559
 560 AutoCreatePropertyValueProvider::AutoCreatePropertyValueProvider (DependencyObject *obj, PropertyPrecedence precedence)
 561         : PropertyValueProvider (obj, precedence)
 562 {
 563         auto_values = g_hash_table_new (g_direct_hash, g_direct_equal);
 564 }
 565
 566 AutoCreatePropertyValueProvider::~AutoCreatePropertyValueProvider ()
 567 {
 568         g_hash_table_foreach_remove (auto_values, dispose_value, obj);
 569         g_hash_table_destroy (auto_values);
 570 }
 571
 572 Value *
 573 AutoCreatePropertyValueProvider::GetPropertyValue (DependencyProperty *property)
 574 {
 575         Value *value;
 576
 577         if (!property->IsAutoCreated ())
 578                 return NULL;
 579
 580         // return previously set auto value next
 581         if ((value = (Value *) g_hash_table_lookup (auto_values, property)))
 582                 return value;
 583
 584         value = (property->GetAutoCreator()) (obj, property);
 585
 586 #if SANITY
 587         if (!value->Is(property->GetPropertyType()))
 588                 g_warning ("autocreated value for property '%s' (type=%s) is of incompatible type %s\n",
 589                            property->GetName(),
 590                            Type::Find (property->GetPropertyType ())->GetName(),
 591                            Type::Find (value->GetKind())->GetName());
 592 #endif
 593
 594         g_hash_table_insert (auto_values, property, value);
 595
 596         MoonError error;
 597         obj->ProviderValueChanged (precedence, property, NULL, value, false, true, &error);
 598
 599         return value;
 600 }
 601
 602 Value *
 603 AutoCreatePropertyValueProvider::ReadLocalValue (DependencyProperty *property)
 604 {
 605         return (Value *) g_hash_table_lookup (auto_values, property);
 606 }
 607
 608 void
 609 AutoCreatePropertyValueProvider::ClearValue (DependencyProperty *property)
 610 {
 611         g_hash_table_remove (auto_values, property);
 612 }
 613
 614 Value*
 615 AutoCreators::default_autocreator (DependencyObject *instance, DependencyProperty *property)
 616 {
 617         Type *type = Type::Find (property->GetPropertyType ());
 618         if (!type)
 619                 return NULL;
 620
 621         return Value::CreateUnrefPtr (type->CreateInstance ());
 622 }
 623
 624 #define XAML_FONT_SIZE    14.666666984558105
 625 #define XAP_FONT_SIZE     11.0
 626
 627 Value *
 628 AutoCreators::CreateDefaultFontSize (DependencyObject *obj, DependencyProperty *property)
 629 {
 630         Deployment *deployment;
 631
 632         if ((deployment = Deployment::GetCurrent ()) && deployment->IsLoadedFromXap ())
 633                 return new Value (XAP_FONT_SIZE);
 634
 635         return new Value (XAML_FONT_SIZE);
 636 }
 637