src/resources.cpp

   1 /*
   2  * resources.cpp
   3  *
   4  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   5  *
   6  * See the LICENSE file included with the distribution for details.
   7  *
   8  */
   9
  10 #include <config.h>
  11 #include <stdlib.h>
  12
  13 #include "runtime.h"
  14 #include "resources.h"
  15 #include "namescope.h"
  16 #include "error.h"
  17
  18 static void
  19 free_value (Value *value)
  20 {
  21         delete value;
  22 }
  23
  24 ResourceDictionary::ResourceDictionary ()
  25 {
  26         SetObjectType (Type::RESOURCE_DICTIONARY);
  27         hash = g_hash_table_new_full (g_str_hash,
  28                                       g_str_equal,
  29                                       (GDestroyNotify)g_free,
  30                                       (GDestroyNotify)free_value);
  31         from_resource_dictionary_api = false;
  32 }
  33
  34 ResourceDictionary::~ResourceDictionary ()
  35 {
  36         g_hash_table_destroy (hash);
  37 }
  38
  39 bool
  40 ResourceDictionary::CanAdd (Value *value)
  41 {
  42         return true;
  43 }
  44
  45 bool
  46 ResourceDictionary::Add (const char* key, Value *value)
  47 {
  48         MoonError err;
  49         return AddWithError (key, value, &err);
  50 }
  51
  52 bool
  53 ResourceDictionary::AddWithError (const char* key, Value *value, MoonError *error)
  54 {
  55         if (!key) {
  56                 MoonError::FillIn (error, MoonError::ARGUMENT_NULL, "key was null");
  57                 return false;
  58         }
  59
  60         if (ContainsKey (key)) {
  61                 MoonError::FillIn (error, MoonError::ARGUMENT, "An item with the same key has already been added");
  62                 return false;
  63         }
  64
  65         Value *v = new Value (*value);
  66
  67         from_resource_dictionary_api = true;
  68         bool result = Collection::AddWithError (v, error) != -1;
  69         from_resource_dictionary_api = false;
  70         if (result)
  71                 g_hash_table_insert (hash, g_strdup (key), v);
  72         return result;
  73 }
  74
  75 bool
  76 ResourceDictionary::Clear ()
  77 {
  78 #if GLIB_CHECK_VERSION(2,12,0)
  79         if (glib_check_version (2,12,0))
  80                 g_hash_table_remove_all (hash);
  81         else
  82 #endif
  83         g_hash_table_foreach_remove (hash, (GHRFunc) gtk_true, NULL);
  84
  85         from_resource_dictionary_api = true;
  86         bool rv = Collection::Clear ();
  87         from_resource_dictionary_api = false;
  88
  89         return rv;
  90 }
  91
  92 bool
  93 ResourceDictionary::ContainsKey (const char *key)
  94 {
  95         if (!key)
  96                 return false;
  97
  98         gpointer orig_value;
  99         gpointer orig_key;
 100
 101         return g_hash_table_lookup_extended (hash, key,
 102                                              &orig_key, &orig_value);
 103 }
 104
 105 bool
 106 ResourceDictionary::Remove (const char *key)
 107 {
 108         if (!key)
 109                 return false;
 110
 111         /* check if the item exists first */
 112         Value* orig_value;
 113         gpointer orig_key;
 114
 115         if (!g_hash_table_lookup_extended (hash, key,
 116                                            &orig_key, (gpointer*)&orig_value))
 117                 return false;
 118
 119         from_resource_dictionary_api = true;
 120         Collection::Remove (orig_value);
 121         from_resource_dictionary_api = false;
 122
 123         g_hash_table_remove (hash, key);
 124
 125         return true;
 126 }
 127
 128 bool
 129 ResourceDictionary::Set (const char *key, Value *value)
 130 {
 131         Value *v = new Value (*value);
 132
 133         /* check if the item exists first */
 134         Value* orig_value;
 135         gpointer orig_key;
 136
 137         if (g_hash_table_lookup_extended (hash, key,
 138                                           &orig_key, (gpointer*)&orig_value)) {
 139                 return false;
 140         }
 141
 142         from_resource_dictionary_api = true;
 143         Collection::Remove (orig_value);
 144         Collection::Add (v);
 145         from_resource_dictionary_api = false;
 146
 147         g_hash_table_replace (hash, g_strdup (key), v);
 148
 149         return true; // XXX
 150 }
 151
 152 Value*
 153 ResourceDictionary::Get (const char *key, bool *exists)
 154 {
 155         Value *v = NULL;
 156         gpointer orig_key;
 157
 158         *exists = g_hash_table_lookup_extended (hash, key,
 159                                                 &orig_key, (gpointer*)&v);
 160
 161         return v;
 162 }
 163
 164 // XXX this was (mostly, except for the type check) c&p from DependencyObjectCollection
 165 bool
 166 ResourceDictionary::AddedToCollection (Value *value, MoonError *error)
 167 {
 168         if (value->Is(Type::DEPENDENCY_OBJECT)) {
 169                 DependencyObject *obj = value->AsDependencyObject ();
 170                 DependencyObject *parent = obj ? obj->GetParent () : NULL;
 171                 // Call SetSurface() /before/ setting the logical parent
 172                 // because Storyboard::SetSurface() needs to be able to
 173                 // distinguish between the two cases.
 174
 175                 if (parent) {
 176                         MoonError::FillIn (error, MoonError::INVALID_OPERATION, "Element is already a child of another element.");
 177                         return false;
 178                 }
 179
 180                 obj->SetSurface (GetSurface ());
 181                 obj->SetParent (this, error);
 182                 if (error->number)
 183                         return false;
 184
 185                 obj->AddPropertyChangeListener (this);
 186
 187                 if (!from_resource_dictionary_api) {
 188                         const char *key = obj->GetName();
 189
 190                         if (!key) {
 191                                 MoonError::FillIn (error, MoonError::ARGUMENT_NULL, "key was null");
 192                                 return false;
 193                         }
 194
 195                         if (ContainsKey (key)) {
 196                                 MoonError::FillIn (error, MoonError::ARGUMENT, "An item with the same key has already been added");
 197                                 return false;
 198                         }
 199                 }
 200         }
 201
 202         bool rv = Collection::AddedToCollection (value, error);
 203
 204         if (rv && !from_resource_dictionary_api && value->Is(Type::DEPENDENCY_OBJECT)) {
 205                 DependencyObject *obj = value->AsDependencyObject ();
 206                 const char *key = obj->GetName();
 207
 208                 g_hash_table_insert (hash, g_strdup (key), new Value (obj));
 209         }
 210
 211         return rv;
 212 }
 213
 214 static gboolean
 215 remove_from_hash_by_value (gpointer  key,
 216                            gpointer  value,
 217                            gpointer  user_data)
 218 {
 219         Value *v = (Value*)value;
 220
 221         return (v->Is (Type::DEPENDENCY_OBJECT) && v->AsDependencyObject() == user_data);
 222 }
 223
 224 // XXX this was (mostly, except for the type check) c&p from DependencyObjectCollection
 225 void
 226 ResourceDictionary::RemovedFromCollection (Value *value)
 227 {
 228         if (value->Is (Type::DEPENDENCY_OBJECT)) {
 229                 DependencyObject *obj = value->AsDependencyObject ();
 230
 231                 obj->RemovePropertyChangeListener (this);
 232                 obj->SetParent (NULL, NULL);
 233                 obj->SetSurface (NULL);
 234
 235                 Collection::RemovedFromCollection (value);
 236
 237                 if (!from_resource_dictionary_api)
 238                         g_hash_table_foreach_remove (hash, remove_from_hash_by_value, value->AsDependencyObject ());
 239         }
 240 }
 241
 242 // XXX this was (mostly, except for the type check) c&p from DependencyObjectCollection
 243 void
 244 ResourceDictionary::SetSurface (Surface *surface)
 245 {
 246         if (GetSurface() == surface)
 247                 return;
 248
 249         Value *value;
 250
 251         for (guint i = 0; i < array->len; i++) {
 252                 value = (Value *) array->pdata[i];
 253                 if (value->Is (Type::DEPENDENCY_OBJECT)) {
 254                         DependencyObject *obj = value->AsDependencyObject ();
 255                         obj->SetSurface (surface);
 256                 }
 257         }
 258
 259         Collection::SetSurface (surface);
 260 }
 261
 262 // XXX this was (mostly, except for the type check) c&p from DependencyObjectCollection
 263 void
 264 ResourceDictionary::UnregisterAllNamesRootedAt (NameScope *from_ns)
 265 {
 266         Value *value;
 267
 268         for (guint i = 0; i < array->len; i++) {
 269                 value = (Value *) array->pdata[i];
 270                 if (value->Is (Type::DEPENDENCY_OBJECT)) {
 271                         DependencyObject *obj = value->AsDependencyObject ();
 272                         obj->UnregisterAllNamesRootedAt (from_ns);
 273                 }
 274         }
 275
 276         Collection::UnregisterAllNamesRootedAt (from_ns);
 277 }
 278
 279 // XXX this was (mostly, except for the type check) c&p from DependencyObjectCollection
 280 void
 281 ResourceDictionary::RegisterAllNamesRootedAt (NameScope *to_ns, MoonError *error)
 282 {
 283         Value *value;
 284
 285         for (guint i = 0; i < array->len; i++) {
 286                 if (error->number)
 287                         break;
 288
 289                 value = (Value *) array->pdata[i];
 290                 if (value->Is (Type::DEPENDENCY_OBJECT)) {
 291                         DependencyObject *obj = value->AsDependencyObject ();
 292                         obj->RegisterAllNamesRootedAt (to_ns, error);
 293                 }
 294         }
 295
 296         Collection::RegisterAllNamesRootedAt (to_ns, error);
 297 }