git.maemo.org Git - fillmore/blob - src/marina/marina/UndoManager.c

   1 /* UndoManager.c generated by valac, the Vala compiler
   2  * generated from UndoManager.vala, do not modify */
   3
   4 /* Copyright 2009 Yorba Foundation
   5  *
   6  * This software is licensed under the GNU Lesser General Public License
   7  * (version 2.1 or later).  See the COPYING file in this distribution.
   8  */
   9
  10 #include <glib.h>
  11 #include <glib-object.h>
  12 #include <gee.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <gobject/gvaluecollector.h>
  16
  17
  18 #define MODEL_TYPE_UNDO_MANAGER (model_undo_manager_get_type ())
  19 #define MODEL_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManager))
  20 #define MODEL_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass))
  21 #define MODEL_IS_UNDO_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_UNDO_MANAGER))
  22 #define MODEL_IS_UNDO_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_UNDO_MANAGER))
  23 #define MODEL_UNDO_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerClass))
  24
  25 typedef struct _ModelUndoManager ModelUndoManager;
  26 typedef struct _ModelUndoManagerClass ModelUndoManagerClass;
  27 typedef struct _ModelUndoManagerPrivate ModelUndoManagerPrivate;
  28
  29 #define MODEL_TYPE_COMMAND (model_command_get_type ())
  30 #define MODEL_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_COMMAND, ModelCommand))
  31 #define MODEL_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_COMMAND, ModelCommandClass))
  32 #define MODEL_IS_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_COMMAND))
  33 #define MODEL_IS_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_COMMAND))
  34 #define MODEL_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_COMMAND, ModelCommandClass))
  35
  36 typedef struct _ModelCommand ModelCommand;
  37 typedef struct _ModelCommandClass ModelCommandClass;
  38 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  39
  40 #define MODEL_TYPE_TRANSACTION_COMMAND (model_transaction_command_get_type ())
  41 #define MODEL_TRANSACTION_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommand))
  42 #define MODEL_TRANSACTION_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommandClass))
  43 #define MODEL_IS_TRANSACTION_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MODEL_TYPE_TRANSACTION_COMMAND))
  44 #define MODEL_IS_TRANSACTION_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MODEL_TYPE_TRANSACTION_COMMAND))
  45 #define MODEL_TRANSACTION_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MODEL_TYPE_TRANSACTION_COMMAND, ModelTransactionCommandClass))
  46
  47 typedef struct _ModelTransactionCommand ModelTransactionCommand;
  48 typedef struct _ModelTransactionCommandClass ModelTransactionCommandClass;
  49 #define _model_command_unref0(var) ((var == NULL) ? NULL : (var = (model_command_unref (var), NULL)))
  50 typedef struct _ModelParamSpecUndoManager ModelParamSpecUndoManager;
  51
  52 struct _ModelUndoManager {
  53         GTypeInstance parent_instance;
  54         volatile int ref_count;
  55         ModelUndoManagerPrivate * priv;
  56 };
  57
  58 struct _ModelUndoManagerClass {
  59         GTypeClass parent_class;
  60         void (*finalize) (ModelUndoManager *self);
  61 };
  62
  63 struct _ModelUndoManagerPrivate {
  64         gint saved_index;
  65         gboolean _in_undo;
  66         GeeArrayList* command_list;
  67 };
  68
  69 struct _ModelParamSpecUndoManager {
  70         GParamSpec parent_instance;
  71 };
  72
  73
  74 static gpointer model_undo_manager_parent_class = NULL;
  75
  76 gpointer model_undo_manager_ref (gpointer instance);
  77 void model_undo_manager_unref (gpointer instance);
  78 GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
  79 void model_value_set_undo_manager (GValue* value, gpointer v_object);
  80 void model_value_take_undo_manager (GValue* value, gpointer v_object);
  81 gpointer model_value_get_undo_manager (const GValue* value);
  82 GType model_undo_manager_get_type (void);
  83 gpointer model_command_ref (gpointer instance);
  84 void model_command_unref (gpointer instance);
  85 GParamSpec* model_param_spec_command (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
  86 void model_value_set_command (GValue* value, gpointer v_object);
  87 void model_value_take_command (GValue* value, gpointer v_object);
  88 gpointer model_value_get_command (const GValue* value);
  89 GType model_command_get_type (void);
  90 #define MODEL_UNDO_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEL_TYPE_UNDO_MANAGER, ModelUndoManagerPrivate))
  91 enum  {
  92         MODEL_UNDO_MANAGER_DUMMY_PROPERTY
  93 };
  94 ModelUndoManager* model_undo_manager_new (void);
  95 ModelUndoManager* model_undo_manager_construct (GType object_type);
  96 void model_undo_manager_reset (ModelUndoManager* self);
  97 void model_undo_manager_mark_clean (ModelUndoManager* self);
  98 ModelTransactionCommand* model_transaction_command_new (gboolean open, const char* transaction_description);
  99 ModelTransactionCommand* model_transaction_command_construct (GType object_type, gboolean open, const char* transaction_description);
 100 GType model_transaction_command_get_type (void);
 101 void model_undo_manager_start_transaction (ModelUndoManager* self, const char* description);
 102 void model_undo_manager_end_transaction (ModelUndoManager* self, const char* description);
 103 gboolean model_undo_manager_get_in_undo (ModelUndoManager* self);
 104 void model_command_apply (ModelCommand* self);
 105 static ModelCommand* model_undo_manager_get_current_command (ModelUndoManager* self);
 106 gboolean model_command_merge (ModelCommand* self, ModelCommand* command);
 107 gboolean model_undo_manager_get_can_undo (ModelUndoManager* self);
 108 void model_undo_manager_do_command (ModelUndoManager* self, ModelCommand* the_command);
 109 static void model_undo_manager_set_in_undo (ModelUndoManager* self, gboolean value);
 110 gboolean model_transaction_command_in_transaction (ModelTransactionCommand* self);
 111 void model_command_undo (ModelCommand* self);
 112 gboolean model_undo_manager_get_is_dirty (ModelUndoManager* self);
 113 void model_undo_manager_undo (ModelUndoManager* self);
 114 char* model_command_description (ModelCommand* self);
 115 char* model_undo_manager_get_undo_title (ModelUndoManager* self);
 116 static void model_undo_manager_finalize (ModelUndoManager* obj);
 117
 118
 119
 120 #line 19 "UndoManager.vala"
 121 ModelUndoManager* model_undo_manager_construct (GType object_type) {
 122 #line 123 "UndoManager.c"
 123         ModelUndoManager* self;
 124         self = (ModelUndoManager*) g_type_create_instance (object_type);
 125         return self;
 126 }
 127
 128
 129 #line 19 "UndoManager.vala"
 130 ModelUndoManager* model_undo_manager_new (void) {
 131 #line 19 "UndoManager.vala"
 132         return model_undo_manager_construct (MODEL_TYPE_UNDO_MANAGER);
 133 #line 134 "UndoManager.c"
 134 }
 135
 136
 137 #line 22 "UndoManager.vala"
 138 void model_undo_manager_reset (ModelUndoManager* self) {
 139 #line 22 "UndoManager.vala"
 140         g_return_if_fail (MODEL_IS_UNDO_MANAGER (self));
 141 #line 23 "UndoManager.vala"
 142         gee_abstract_collection_clear (GEE_ABSTRACT_COLLECTION (self->priv->command_list));
 143 #line 24 "UndoManager.vala"
 144         self->priv->saved_index = 0;
 145 #line 25 "UndoManager.vala"
 146         g_signal_emit_by_name (self, "undo-changed", FALSE);
 147 #line 148 "UndoManager.c"
 148 }
 149
 150
 151 #line 28 "UndoManager.vala"
 152 void model_undo_manager_mark_clean (ModelUndoManager* self) {
 153 #line 28 "UndoManager.vala"
 154         g_return_if_fail (MODEL_IS_UNDO_MANAGER (self));
 155 #line 29 "UndoManager.vala"
 156         self->priv->saved_index = gee_collection_get_size (GEE_COLLECTION (self->priv->command_list));
 157 #line 30 "UndoManager.vala"
 158         g_signal_emit_by_name (self, "dirty-changed", FALSE);
 159 #line 160 "UndoManager.c"
 160 }
 161
 162
 163 #line 33 "UndoManager.vala"
 164 void model_undo_manager_start_transaction (ModelUndoManager* self, const char* description) {
 165 #line 166 "UndoManager.c"
 166         ModelTransactionCommand* command;
 167 #line 33 "UndoManager.vala"
 168         g_return_if_fail (MODEL_IS_UNDO_MANAGER (self));
 169 #line 33 "UndoManager.vala"
 170         g_return_if_fail (description != NULL);
 171 #line 34 "UndoManager.vala"
 172         command = model_transaction_command_new (FALSE, description);
 173 #line 35 "UndoManager.vala"
 174         gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->command_list), MODEL_COMMAND (command));
 175 #line 36 "UndoManager.vala"
 176         g_signal_emit_by_name (self, "undo-changed", TRUE);
 177 #line 178 "UndoManager.c"
 178         _model_command_unref0 (command);
 179 }
 180
 181
 182 #line 39 "UndoManager.vala"
 183 void model_undo_manager_end_transaction (ModelUndoManager* self, const char* description) {
 184 #line 185 "UndoManager.c"
 185         ModelTransactionCommand* command;
 186 #line 39 "UndoManager.vala"
 187         g_return_if_fail (MODEL_IS_UNDO_MANAGER (self));
 188 #line 39 "UndoManager.vala"
 189         g_return_if_fail (description != NULL);
 190 #line 40 "UndoManager.vala"
 191         command = model_transaction_command_new (TRUE, description);
 192 #line 41 "UndoManager.vala"
 193         gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->command_list), MODEL_COMMAND (command));
 194 #line 42 "UndoManager.vala"
 195         g_signal_emit_by_name (self, "undo-changed", TRUE);
 196 #line 197 "UndoManager.c"
 197         _model_command_unref0 (command);
 198 }
 199
 200
 201 #line 45 "UndoManager.vala"
 202 void model_undo_manager_do_command (ModelUndoManager* self, ModelCommand* the_command) {
 203 #line 45 "UndoManager.vala"
 204         g_return_if_fail (MODEL_IS_UNDO_MANAGER (self));
 205 #line 45 "UndoManager.vala"
 206         g_return_if_fail (MODEL_IS_COMMAND (the_command));
 207 #line 46 "UndoManager.vala"
 208         if (!model_undo_manager_get_in_undo (self)) {
 209 #line 210 "UndoManager.c"
 210                 ModelCommand* current_command;
 211                 gboolean _tmp0_ = FALSE;
 212 #line 47 "UndoManager.vala"
 213                 model_command_apply (the_command);
 214 #line 48 "UndoManager.vala"
 215                 current_command = model_undo_manager_get_current_command (self);
 216 #line 49 "UndoManager.vala"
 217                 if (current_command == NULL) {
 218 #line 49 "UndoManager.vala"
 219                         _tmp0_ = TRUE;
 220 #line 221 "UndoManager.c"
 221                 } else {
 222 #line 49 "UndoManager.vala"
 223                         _tmp0_ = !model_command_merge (current_command, the_command);
 224 #line 225 "UndoManager.c"
 225                 }
 226 #line 49 "UndoManager.vala"
 227                 if (_tmp0_) {
 228 #line 50 "UndoManager.vala"
 229                         gee_abstract_collection_add (GEE_ABSTRACT_COLLECTION (self->priv->command_list), the_command);
 230 #line 231 "UndoManager.c"
 231                 }
 232 #line 52 "UndoManager.vala"
 233                 g_signal_emit_by_name (self, "dirty-changed", TRUE);
 234 #line 53 "UndoManager.vala"
 235                 g_signal_emit_by_name (self, "undo-changed", model_undo_manager_get_can_undo (self));
 236 #line 237 "UndoManager.c"
 237                 _model_command_unref0 (current_command);
 238         }
 239 }
 240
 241
 242 #line 57 "UndoManager.vala"
 243 static ModelCommand* model_undo_manager_get_current_command (ModelUndoManager* self) {
 244 #line 245 "UndoManager.c"
 245         ModelCommand* result = NULL;
 246         gint index;
 247 #line 57 "UndoManager.vala"
 248         g_return_val_if_fail (MODEL_IS_UNDO_MANAGER (self), NULL);
 249 #line 58 "UndoManager.vala"
 250         index = gee_collection_get_size (GEE_COLLECTION (self->priv->command_list)) - 1;
 251 #line 59 "UndoManager.vala"
 252         if (index >= 0) {
 253 #line 254 "UndoManager.c"
 254                 result = (ModelCommand*) gee_abstract_list_get (GEE_ABSTRACT_LIST (self->priv->command_list), index);
 255 #line 60 "UndoManager.vala"
 256                 return result;
 257 #line 258 "UndoManager.c"
 258         } else {
 259                 result = NULL;
 260 #line 62 "UndoManager.vala"
 261                 return result;
 262 #line 263 "UndoManager.c"
 263         }
 264 }
 265
 266
 267 static gpointer _model_command_ref0 (gpointer self) {
 268         return self ? model_command_ref (self) : NULL;
 269 }
 270
 271
 272 #line 66 "UndoManager.vala"
 273 void model_undo_manager_undo (ModelUndoManager* self) {
 274 #line 275 "UndoManager.c"
 275         gint in_transaction;
 276 #line 66 "UndoManager.vala"
 277         g_return_if_fail (MODEL_IS_UNDO_MANAGER (self));
 278 #line 67 "UndoManager.vala"
 279         g_assert (model_undo_manager_get_in_undo (self) == FALSE);
 280 #line 68 "UndoManager.vala"
 281         model_undo_manager_set_in_undo (self, TRUE);
 282 #line 69 "UndoManager.vala"
 283         in_transaction = 0;
 284 #line 285 "UndoManager.c"
 285         {
 286                 gboolean _tmp0_;
 287 #line 70 "UndoManager.vala"
 288                 _tmp0_ = TRUE;
 289 #line 70 "UndoManager.vala"
 290                 while (TRUE) {
 291 #line 292 "UndoManager.c"
 292                         ModelCommand* the_command;
 293 #line 70 "UndoManager.vala"
 294                         if (!_tmp0_) {
 295 #line 87 "UndoManager.vala"
 296                                 if (!(in_transaction > 0)) {
 297 #line 87 "UndoManager.vala"
 298                                         break;
 299 #line 300 "UndoManager.c"
 300                                 }
 301                         }
 302 #line 70 "UndoManager.vala"
 303                         _tmp0_ = FALSE;
 304 #line 71 "UndoManager.vala"
 305                         the_command = model_undo_manager_get_current_command (self);
 306 #line 72 "UndoManager.vala"
 307                         if (the_command != NULL) {
 308 #line 309 "UndoManager.c"
 309                                 ModelCommand* _tmp1_;
 310                                 ModelTransactionCommand* transaction_command;
 311 #line 73 "UndoManager.vala"
 312                                 gee_abstract_collection_remove (GEE_ABSTRACT_COLLECTION (self->priv->command_list), the_command);
 313 #line 74 "UndoManager.vala"
 314                                 transaction_command = _model_command_ref0 ((_tmp1_ = the_command, MODEL_IS_TRANSACTION_COMMAND (_tmp1_) ? ((ModelTransactionCommand*) _tmp1_) : NULL));
 315 #line 75 "UndoManager.vala"
 316                                 if (transaction_command != NULL) {
 317 #line 76 "UndoManager.vala"
 318                                         if (model_transaction_command_in_transaction (transaction_command)) {
 319 #line 77 "UndoManager.vala"
 320                                                 in_transaction++;
 321 #line 322 "UndoManager.c"
 322                                         } else {
 323 #line 79 "UndoManager.vala"
 324                                                 in_transaction--;
 325 #line 326 "UndoManager.c"
 326                                         }
 327                                 } else {
 328 #line 82 "UndoManager.vala"
 329                                         model_command_undo (the_command);
 330 #line 331 "UndoManager.c"
 331                                 }
 332                                 _model_command_unref0 (transaction_command);
 333                         } else {
 334                                 _model_command_unref0 (the_command);
 335 #line 85 "UndoManager.vala"
 336                                 break;
 337 #line 338 "UndoManager.c"
 338                         }
 339                         _model_command_unref0 (the_command);
 340                 }
 341         }
 342 #line 88 "UndoManager.vala"
 343         g_signal_emit_by_name (self, "dirty-changed", model_undo_manager_get_is_dirty (self));
 344 #line 89 "UndoManager.vala"
 345         g_signal_emit_by_name (self, "undo-changed", model_undo_manager_get_can_undo (self));
 346 #line 90 "UndoManager.vala"
 347         model_undo_manager_set_in_undo (self, FALSE);
 348 #line 349 "UndoManager.c"
 349 }
 350
 351
 352 #line 93 "UndoManager.vala"
 353 char* model_undo_manager_get_undo_title (ModelUndoManager* self) {
 354 #line 355 "UndoManager.c"
 355         char* result = NULL;
 356         ModelCommand* the_command;
 357 #line 93 "UndoManager.vala"
 358         g_return_val_if_fail (MODEL_IS_UNDO_MANAGER (self), NULL);
 359 #line 94 "UndoManager.vala"
 360         the_command = model_undo_manager_get_current_command (self);
 361 #line 95 "UndoManager.vala"
 362         if (the_command != NULL) {
 363 #line 364 "UndoManager.c"
 364                 result = model_command_description (the_command);
 365                 _model_command_unref0 (the_command);
 366 #line 96 "UndoManager.vala"
 367                 return result;
 368 #line 369 "UndoManager.c"
 369         } else {
 370                 result = g_strdup ("");
 371                 _model_command_unref0 (the_command);
 372 #line 98 "UndoManager.vala"
 373                 return result;
 374 #line 375 "UndoManager.c"
 375         }
 376         _model_command_unref0 (the_command);
 377 }
 378
 379
 380 gboolean model_undo_manager_get_is_dirty (ModelUndoManager* self) {
 381         gboolean result;
 382         g_return_val_if_fail (MODEL_IS_UNDO_MANAGER (self), FALSE);
 383         result = self->priv->saved_index != gee_collection_get_size (GEE_COLLECTION (self->priv->command_list));
 384 #line 12 "UndoManager.vala"
 385         return result;
 386 #line 387 "UndoManager.c"
 387 }
 388
 389
 390 gboolean model_undo_manager_get_can_undo (ModelUndoManager* self) {
 391         gboolean result;
 392         g_return_val_if_fail (MODEL_IS_UNDO_MANAGER (self), FALSE);
 393         result = gee_collection_get_size (GEE_COLLECTION (self->priv->command_list)) > 0;
 394 #line 13 "UndoManager.vala"
 395         return result;
 396 #line 397 "UndoManager.c"
 397 }
 398
 399
 400 gboolean model_undo_manager_get_in_undo (ModelUndoManager* self) {
 401         gboolean result;
 402         g_return_val_if_fail (MODEL_IS_UNDO_MANAGER (self), FALSE);
 403         result = self->priv->_in_undo;
 404 #line 14 "UndoManager.vala"
 405         return result;
 406 #line 407 "UndoManager.c"
 407 }
 408
 409
 410 static void model_undo_manager_set_in_undo (ModelUndoManager* self, gboolean value) {
 411         g_return_if_fail (MODEL_IS_UNDO_MANAGER (self));
 412 #line 14 "UndoManager.vala"
 413         self->priv->_in_undo = value;
 414 #line 415 "UndoManager.c"
 415 }
 416
 417
 418 static void model_value_undo_manager_init (GValue* value) {
 419         value->data[0].v_pointer = NULL;
 420 }
 421
 422
 423 static void model_value_undo_manager_free_value (GValue* value) {
 424         if (value->data[0].v_pointer) {
 425                 model_undo_manager_unref (value->data[0].v_pointer);
 426         }
 427 }
 428
 429
 430 static void model_value_undo_manager_copy_value (const GValue* src_value, GValue* dest_value) {
 431         if (src_value->data[0].v_pointer) {
 432                 dest_value->data[0].v_pointer = model_undo_manager_ref (src_value->data[0].v_pointer);
 433         } else {
 434                 dest_value->data[0].v_pointer = NULL;
 435         }
 436 }
 437
 438
 439 static gpointer model_value_undo_manager_peek_pointer (const GValue* value) {
 440         return value->data[0].v_pointer;
 441 }
 442
 443
 444 static gchar* model_value_undo_manager_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 445         if (collect_values[0].v_pointer) {
 446                 ModelUndoManager* object;
 447                 object = collect_values[0].v_pointer;
 448                 if (object->parent_instance.g_class == NULL) {
 449                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 450                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
 451                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 452                 }
 453                 value->data[0].v_pointer = model_undo_manager_ref (object);
 454         } else {
 455                 value->data[0].v_pointer = NULL;
 456         }
 457         return NULL;
 458 }
 459
 460
 461 static gchar* model_value_undo_manager_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 462         ModelUndoManager** object_p;
 463         object_p = collect_values[0].v_pointer;
 464         if (!object_p) {
 465                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 466         }
 467         if (!value->data[0].v_pointer) {
 468                 *object_p = NULL;
 469         } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
 470                 *object_p = value->data[0].v_pointer;
 471         } else {
 472                 *object_p = model_undo_manager_ref (value->data[0].v_pointer);
 473         }
 474         return NULL;
 475 }
 476
 477
 478 GParamSpec* model_param_spec_undo_manager (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
 479         ModelParamSpecUndoManager* spec;
 480         g_return_val_if_fail (g_type_is_a (object_type, MODEL_TYPE_UNDO_MANAGER), NULL);
 481         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
 482         G_PARAM_SPEC (spec)->value_type = object_type;
 483         return G_PARAM_SPEC (spec);
 484 }
 485
 486
 487 gpointer model_value_get_undo_manager (const GValue* value) {
 488         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_UNDO_MANAGER), NULL);
 489         return value->data[0].v_pointer;
 490 }
 491
 492
 493 void model_value_set_undo_manager (GValue* value, gpointer v_object) {
 494         ModelUndoManager* old;
 495         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_UNDO_MANAGER));
 496         old = value->data[0].v_pointer;
 497         if (v_object) {
 498                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_UNDO_MANAGER));
 499                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 500                 value->data[0].v_pointer = v_object;
 501                 model_undo_manager_ref (value->data[0].v_pointer);
 502         } else {
 503                 value->data[0].v_pointer = NULL;
 504         }
 505         if (old) {
 506                 model_undo_manager_unref (old);
 507         }
 508 }
 509
 510
 511 void model_value_take_undo_manager (GValue* value, gpointer v_object) {
 512         ModelUndoManager* old;
 513         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MODEL_TYPE_UNDO_MANAGER));
 514         old = value->data[0].v_pointer;
 515         if (v_object) {
 516                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MODEL_TYPE_UNDO_MANAGER));
 517                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 518                 value->data[0].v_pointer = v_object;
 519         } else {
 520                 value->data[0].v_pointer = NULL;
 521         }
 522         if (old) {
 523                 model_undo_manager_unref (old);
 524         }
 525 }
 526
 527
 528 static void model_undo_manager_class_init (ModelUndoManagerClass * klass) {
 529         model_undo_manager_parent_class = g_type_class_peek_parent (klass);
 530         MODEL_UNDO_MANAGER_CLASS (klass)->finalize = model_undo_manager_finalize;
 531         g_type_class_add_private (klass, sizeof (ModelUndoManagerPrivate));
 532         g_signal_new ("undo_changed", MODEL_TYPE_UNDO_MANAGER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
 533         g_signal_new ("dirty_changed", MODEL_TYPE_UNDO_MANAGER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
 534 }
 535
 536
 537 static void model_undo_manager_instance_init (ModelUndoManager * self) {
 538         self->priv = MODEL_UNDO_MANAGER_GET_PRIVATE (self);
 539         self->priv->saved_index = 0;
 540         self->priv->_in_undo = FALSE;
 541         self->priv->command_list = gee_array_list_new (MODEL_TYPE_COMMAND, (GBoxedCopyFunc) model_command_ref, model_command_unref, NULL);
 542         self->ref_count = 1;
 543 }
 544
 545
 546 static void model_undo_manager_finalize (ModelUndoManager* obj) {
 547         ModelUndoManager * self;
 548         self = MODEL_UNDO_MANAGER (obj);
 549         _g_object_unref0 (self->priv->command_list);
 550 }
 551
 552
 553 GType model_undo_manager_get_type (void) {
 554         static volatile gsize model_undo_manager_type_id__volatile = 0;
 555         if (g_once_init_enter (&model_undo_manager_type_id__volatile)) {
 556                 static const GTypeValueTable g_define_type_value_table = { model_value_undo_manager_init, model_value_undo_manager_free_value, model_value_undo_manager_copy_value, model_value_undo_manager_peek_pointer, "p", model_value_undo_manager_collect_value, "p", model_value_undo_manager_lcopy_value };
 557                 static const GTypeInfo g_define_type_info = { sizeof (ModelUndoManagerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) model_undo_manager_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ModelUndoManager), 0, (GInstanceInitFunc) model_undo_manager_instance_init, &g_define_type_value_table };
 558                 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
 559                 GType model_undo_manager_type_id;
 560                 model_undo_manager_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ModelUndoManager", &g_define_type_info, &g_define_type_fundamental_info, 0);
 561                 g_once_init_leave (&model_undo_manager_type_id__volatile, model_undo_manager_type_id);
 562         }
 563         return model_undo_manager_type_id__volatile;
 564 }
 565
 566
 567 gpointer model_undo_manager_ref (gpointer instance) {
 568         ModelUndoManager* self;
 569         self = instance;
 570         g_atomic_int_inc (&self->ref_count);
 571         return instance;
 572 }
 573
 574
 575 void model_undo_manager_unref (gpointer instance) {
 576         ModelUndoManager* self;
 577         self = instance;
 578         if (g_atomic_int_dec_and_test (&self->ref_count)) {
 579                 MODEL_UNDO_MANAGER_GET_CLASS (self)->finalize (self);
 580                 g_type_free_instance ((GTypeInstance *) self);
 581         }
 582 }
 583
 584
 585
 586