app/undo.c

   1 /* Dia -- an diagram creation/manipulation program
   2  * Copyright (C) 1999 Alexander Larsson
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17  */
  18
  19 #include <config.h>
  20
  21 #include "undo.h"
  22 #include "object_ops.h"
  23 #include "properties.h"
  24 #include "connectionpoint_ops.h"
  25 #include "focus.h"
  26 #include "group.h"
  27 #include "preferences.h"
  28 #include "diagram_tree_window.h"
  29 #include "textedit.h"
  30
  31 #if 0
  32 #define DEBUG_PRINTF(args) printf args
  33 #else
  34 #define DEBUG_PRINTF(args)
  35 #endif
  36
  37 static void
  38 transaction_point_pointer(Change *change, Diagram *dia)
  39 {
  40   /* Empty function used to track transactionpoints. */
  41 }
  42
  43 static int
  44 is_transactionpoint(Change *change)
  45 {
  46   return change->apply == transaction_point_pointer;
  47 }
  48
  49 static Change *
  50 new_transactionpoint(void)
  51 {
  52   Change *transaction = g_new0(Change, 1);
  53
  54   if (transaction) {
  55     transaction->apply = transaction_point_pointer;
  56     transaction->revert = transaction_point_pointer;
  57     transaction->free = NULL;
  58   }
  59
  60   return transaction;
  61 }
  62
  63 UndoStack *
  64 new_undo_stack(Diagram *dia)
  65 {
  66   UndoStack *stack;
  67   Change *transaction;
  68
  69   stack = g_new(UndoStack, 1);
  70   if (stack!=NULL){
  71     stack->dia = dia;
  72     transaction = new_transactionpoint();
  73     transaction->next = transaction->prev = NULL;
  74     stack->last_change = transaction;
  75     stack->current_change = transaction;
  76     stack->last_save = transaction;
  77     stack->depth = 0;
  78   }
  79   return stack;
  80 }
  81
  82 void
  83 undo_destroy(UndoStack *stack)
  84 {
  85   undo_clear(stack);
  86   g_free(stack->current_change); /* Free first transaction point. */
  87   g_free(stack);
  88 }
  89
  90
  91
  92 static void
  93 undo_remove_redo_info(UndoStack *stack)
  94 {
  95   Change *change;
  96   Change *next_change;
  97
  98   DEBUG_PRINTF(("UNDO: Removing redo info\n"));
  99
 100   change = stack->current_change->next;
 101   stack->current_change->next = NULL;
 102   stack->last_change = stack->current_change;
 103
 104   while (change != NULL) {
 105     next_change = change->next;
 106     if (change->free)
 107       (change->free)(change);
 108     g_free(change);
 109     change = next_change;
 110   }
 111 }
 112
 113 void
 114 undo_push_change(UndoStack *stack, Change *change)
 115 {
 116   if (stack->current_change != stack->last_change)
 117     undo_remove_redo_info(stack);
 118
 119   DEBUG_PRINTF(("UNDO: Push new change at %d\n", depth(stack)));
 120
 121   change->prev = stack->last_change;
 122   change->next = NULL;
 123   stack->last_change->next = change;
 124   stack->last_change = change;
 125   stack->current_change = change;
 126 }
 127
 128 static void
 129 undo_delete_lowest_transaction(UndoStack *stack)
 130 {
 131   Change *change;
 132   Change *next_change;
 133
 134   /* Find the lowest change: */
 135   change = stack->current_change;
 136   while (change->prev != NULL) {
 137     change = change->prev;
 138   }
 139
 140   /* Remove changes from the bottom until (and including)
 141    * the first transactionpoint.
 142    * Stop if we reach current_change or NULL.
 143    */
 144   do {
 145     if ( (change == NULL) || (change == stack->current_change))
 146       break;
 147
 148     next_change = change->next;
 149     DEBUG_PRINTF(("freeing one change from the bottom.\n"));
 150     if (change->free)
 151       (change->free)(change);
 152     g_free(change);
 153     change = next_change;
 154   } while (!is_transactionpoint(change));
 155
 156   if (is_transactionpoint(change)) {
 157     stack->depth--;
 158     DEBUG_PRINTF(("Decreasing stack depth to: %d\n", stack->depth));
 159   }
 160   change->prev = NULL;
 161 }
 162
 163 void
 164 undo_set_transactionpoint(UndoStack *stack)
 165 {
 166   Change *transaction;
 167
 168   if (is_transactionpoint(stack->current_change))
 169     return;
 170
 171   DEBUG_PRINTF(("UNDO: Push new transactionpoint at %d\n", depth(stack)));
 172
 173   transaction = new_transactionpoint();
 174
 175   undo_push_change(stack, transaction);
 176   stack->depth++;
 177   DEBUG_PRINTF(("Increasing stack depth to: %d\n", stack->depth));
 178
 179   if (prefs.undo_depth > 0) {
 180     while (stack->depth > prefs.undo_depth){
 181       undo_delete_lowest_transaction(stack);
 182     }
 183   }
 184 }
 185
 186 void
 187 undo_revert_to_last_tp(UndoStack *stack)
 188 {
 189   Change *change;
 190   Change *prev_change;
 191
 192   if (stack->current_change->prev == NULL)
 193     return; /* Can't revert first transactionpoint */
 194
 195   change = stack->current_change;
 196   do {
 197     prev_change = change->prev;
 198     (change->revert)(change, stack->dia);
 199     change = prev_change;
 200   } while (!is_transactionpoint(change));
 201   stack->current_change  = change;
 202   stack->depth--;
 203   DEBUG_PRINTF(("Decreasing stack depth to: %d\n", stack->depth));
 204 }
 205
 206 void
 207 undo_apply_to_next_tp(UndoStack *stack)
 208 {
 209   Change *change;
 210   Change *next_change;
 211
 212   change = stack->current_change;
 213
 214   if (change->next == NULL)
 215     return /* Already at top. */;
 216
 217   do {
 218     next_change = change->next;
 219     (change->apply)(change, stack->dia);
 220     change = next_change;
 221   } while ( (change != NULL) &&
 222             (!is_transactionpoint(change)) );
 223   if (change == NULL)
 224     change = stack->last_change;
 225   stack->current_change = change;
 226   stack->depth++;
 227   DEBUG_PRINTF(("Increasing stack depth to: %d\n", stack->depth));
 228 }
 229
 230
 231 void
 232 undo_clear(UndoStack *stack)
 233 {
 234   Change *change;
 235
 236   DEBUG_PRINTF(("undo_clear()\n"));
 237
 238   change = stack->current_change;
 239
 240   while (change->prev != NULL) {
 241     change = change->prev;
 242   }
 243
 244   stack->current_change = change;
 245   stack->depth = 0;
 246   undo_remove_redo_info(stack);
 247 }
 248
 249 /** Marks the undo stack at the time of a save.
 250  */
 251 void
 252 undo_mark_save(UndoStack *stack)
 253 {
 254   stack->last_save = stack->current_change;
 255 }
 256
 257 /** Returns true if the diagram is undo-wise in the same state as at
 258  * last save, i.e. the current change is the same as it was at last save.
 259  */
 260 gboolean
 261 undo_is_saved(UndoStack *stack)
 262 {
 263   return stack->last_save == stack->current_change;
 264 }
 265
 266
 267
 268 /****************************************************************/
 269 /****************************************************************/
 270 /*****************                          *********************/
 271 /***************** Specific undo functions: *********************/
 272 /*****************                          *********************/
 273 /****************************************************************/
 274 /****************************************************************/
 275
 276 /******** Move object list: */
 277
 278 struct MoveObjectsChange {
 279   Change change;
 280
 281   Point *orig_pos;
 282   Point *dest_pos;
 283   GList *obj_list;
 284 };
 285
 286 static void
 287 move_objects_apply(struct MoveObjectsChange *change, Diagram *dia)
 288 {
 289   GList *list;
 290   int i;
 291   DiaObject *obj;
 292
 293   object_add_updates_list(change->obj_list, dia);
 294
 295   list = change->obj_list;
 296   i=0;
 297   while (list != NULL) {
 298     obj = (DiaObject *)  list->data;
 299
 300     obj->ops->move(obj, &change->dest_pos[i]);
 301
 302     list = g_list_next(list); i++;
 303   }
 304
 305   list = change->obj_list;
 306   while (list!=NULL) {
 307     obj = (DiaObject *) list->data;
 308
 309     diagram_update_connections_object(dia, obj, TRUE);
 310
 311     list = g_list_next(list);
 312   }
 313
 314   object_add_updates_list(change->obj_list, dia);
 315 }
 316
 317 static void
 318 move_objects_revert(struct MoveObjectsChange *change, Diagram *dia)
 319 {
 320   GList *list;
 321   int i;
 322   DiaObject *obj;
 323
 324   object_add_updates_list(change->obj_list, dia);
 325
 326   list = change->obj_list;
 327   i=0;
 328   while (list != NULL) {
 329     obj = (DiaObject *)  list->data;
 330
 331     obj->ops->move(obj, &change->orig_pos[i]);
 332
 333     list = g_list_next(list); i++;
 334   }
 335
 336   list = change->obj_list;
 337   while (list!=NULL) {
 338     obj = (DiaObject *) list->data;
 339
 340     diagram_update_connections_object(dia, obj, TRUE);
 341
 342     list = g_list_next(list);
 343   }
 344
 345   object_add_updates_list(change->obj_list, dia);
 346 }
 347
 348 static void
 349 move_objects_free(struct MoveObjectsChange *change)
 350 {
 351   g_free(change->orig_pos);
 352   g_free(change->dest_pos);
 353   g_list_free(change->obj_list);
 354 }
 355
 356 extern Change *
 357 undo_move_objects(Diagram *dia, Point *orig_pos, Point *dest_pos,
 358                   GList *obj_list)
 359 {
 360   struct MoveObjectsChange *change;
 361
 362   change = g_new0(struct MoveObjectsChange, 1);
 363
 364   change->change.apply = (UndoApplyFunc) move_objects_apply;
 365   change->change.revert = (UndoRevertFunc) move_objects_revert;
 366   change->change.free = (UndoFreeFunc) move_objects_free;
 367
 368   change->orig_pos = orig_pos;
 369   change->dest_pos = dest_pos;
 370   change->obj_list = obj_list;
 371
 372   DEBUG_PRINTF(("UNDO: Push new move objects at %d\n", depth(dia->undo)));
 373   undo_push_change(dia->undo, (Change *) change);
 374   return (Change *)change;
 375 }
 376
 377 /********** Move handle: */
 378
 379 struct MoveHandleChange {
 380   Change change;
 381
 382   Point orig_pos;
 383   Point dest_pos;
 384   Handle *handle;
 385   DiaObject *obj;
 386 };
 387
 388 static void
 389 move_handle_apply(struct MoveHandleChange *change, Diagram *dia)
 390 {
 391   object_add_updates(change->obj, dia);
 392   change->obj->ops->move_handle(change->obj, change->handle,
 393                                 &change->dest_pos, NULL,
 394                                 HANDLE_MOVE_USER_FINAL, 0);
 395   object_add_updates(change->obj, dia);
 396   diagram_update_connections_object(dia, change->obj, TRUE);
 397 }
 398
 399 static void
 400 move_handle_revert(struct MoveHandleChange *change, Diagram *dia)
 401 {
 402   object_add_updates(change->obj, dia);
 403   change->obj->ops->move_handle(change->obj, change->handle,
 404                                 &change->orig_pos, NULL,
 405                                 HANDLE_MOVE_USER_FINAL, 0);
 406   object_add_updates(change->obj, dia);
 407   diagram_update_connections_object(dia, change->obj, TRUE);
 408 }
 409
 410 static void
 411 move_handle_free(struct MoveHandleChange *change)
 412 {
 413 }
 414
 415
 416 Change *
 417 undo_move_handle(Diagram *dia,
 418                  Handle *handle, DiaObject *obj,
 419                  Point orig_pos, Point dest_pos)
 420 {
 421   struct MoveHandleChange *change;
 422
 423   change = g_new0(struct MoveHandleChange, 1);
 424
 425   change->change.apply = (UndoApplyFunc) move_handle_apply;
 426   change->change.revert = (UndoRevertFunc) move_handle_revert;
 427   change->change.free = (UndoFreeFunc) move_handle_free;
 428
 429   change->orig_pos = orig_pos;
 430   change->dest_pos = dest_pos;
 431   change->handle = handle;
 432   change->obj = obj;
 433
 434   DEBUG_PRINTF(("UNDO: Push new move handle at %d\n", depth(dia->undo)));
 435
 436   undo_push_change(dia->undo, (Change *) change);
 437   return (Change *)change;
 438 }
 439
 440 /***************** Connect object: */
 441
 442 struct ConnectChange {
 443   Change change;
 444
 445   DiaObject *obj;
 446   Handle *handle;
 447   ConnectionPoint *connectionpoint;
 448   Point handle_pos;
 449 };
 450
 451 static void
 452 connect_apply(struct ConnectChange *change, Diagram *dia)
 453 {
 454   object_connect(change->obj, change->handle, change->connectionpoint);
 455
 456   object_add_updates(change->obj, dia);
 457   change->obj->ops->move_handle(change->obj, change->handle ,
 458                                 &change->connectionpoint->pos,
 459                                 change->connectionpoint,
 460                                 HANDLE_MOVE_CONNECTED, 0);
 461
 462   object_add_updates(change->obj, dia);
 463 }
 464
 465 static void
 466 connect_revert(struct ConnectChange *change, Diagram *dia)
 467 {
 468   object_unconnect(change->obj, change->handle);
 469
 470   object_add_updates(change->obj, dia);
 471   change->obj->ops->move_handle(change->obj, change->handle ,
 472                                 &change->handle_pos, NULL,
 473                                 HANDLE_MOVE_CONNECTED, 0);
 474
 475   object_add_updates(change->obj, dia);
 476 }
 477
 478 static void
 479 connect_free(struct ConnectChange *change)
 480 {
 481 }
 482
 483 extern Change *
 484 undo_connect(Diagram *dia, DiaObject *obj, Handle *handle,
 485              ConnectionPoint *connectionpoint)
 486 {
 487   struct ConnectChange *change;
 488
 489   change = g_new0(struct ConnectChange, 1);
 490
 491   change->change.apply = (UndoApplyFunc) connect_apply;
 492   change->change.revert = (UndoRevertFunc) connect_revert;
 493   change->change.free = (UndoFreeFunc) connect_free;
 494
 495   change->obj = obj;
 496   change->handle = handle;
 497   change->handle_pos = handle->pos;
 498   change->connectionpoint = connectionpoint;
 499
 500   DEBUG_PRINTF(("UNDO: Push new connect at %d\n", depth(dia->undo)));
 501   undo_push_change(dia->undo, (Change *) change);
 502   return (Change *)change;
 503 }
 504
 505 /*************** Unconnect object: */
 506
 507 struct UnconnectChange {
 508   Change change;
 509
 510   DiaObject *obj;
 511   Handle *handle;
 512   ConnectionPoint *connectionpoint;
 513 };
 514
 515 static void
 516 unconnect_apply(struct UnconnectChange *change, Diagram *dia)
 517 {
 518   object_unconnect(change->obj, change->handle);
 519
 520   object_add_updates(change->obj, dia);
 521 }
 522
 523 static void
 524 unconnect_revert(struct UnconnectChange *change, Diagram *dia)
 525 {
 526   object_connect(change->obj, change->handle, change->connectionpoint);
 527
 528   object_add_updates(change->obj, dia);
 529 }
 530
 531 static void
 532 unconnect_free(struct UnconnectChange *change)
 533 {
 534 }
 535
 536 extern Change *
 537 undo_unconnect(Diagram *dia, DiaObject *obj, Handle *handle)
 538 {
 539   struct UnconnectChange *change;
 540
 541   change = g_new0(struct UnconnectChange, 1);
 542
 543   change->change.apply = (UndoApplyFunc) unconnect_apply;
 544   change->change.revert = (UndoRevertFunc) unconnect_revert;
 545   change->change.free = (UndoFreeFunc) unconnect_free;
 546
 547   change->obj = obj;
 548   change->handle = handle;
 549   change->connectionpoint = handle->connected_to;
 550
 551   DEBUG_PRINTF(("UNDO: Push new unconnect at %d\n", depth(dia->undo)));
 552   undo_push_change(dia->undo, (Change *) change);
 553   return (Change *)change;
 554 }
 555
 556
 557 /******** Delete object list: */
 558
 559 struct DeleteObjectsChange {
 560   Change change;
 561
 562   Layer *layer;
 563   GList *obj_list; /* Owning reference when applied */
 564   GList *original_objects;
 565   int applied;
 566 };
 567
 568 static void
 569 delete_objects_apply(struct DeleteObjectsChange *change, Diagram *dia)
 570 {
 571   GList *list;
 572
 573   DEBUG_PRINTF(("delete_objects_apply()\n"));
 574   change->applied = 1;
 575   diagram_unselect_objects(dia, change->obj_list);
 576   layer_remove_objects(change->layer, change->obj_list);
 577   object_add_updates_list(change->obj_list, dia);
 578
 579   list = change->obj_list;
 580   while (list != NULL) {
 581     DiaObject *obj = (DiaObject *)list->data;
 582
 583   /* Have to hide any open properties dialog
 584      if it contains some object in cut_list */
 585     properties_hide_if_shown(dia, obj);
 586
 587     if (obj->parent) /* Lose references to deleted object */
 588       obj->parent->children = g_list_remove(obj->parent->children, obj);
 589
 590     list = g_list_next(list);
 591   }
 592
 593   diagram_tree_remove_objects(diagram_tree(), change->obj_list);
 594 }
 595
 596 static void
 597 delete_objects_revert(struct DeleteObjectsChange *change, Diagram *dia)
 598 {
 599   GList *list;
 600   DEBUG_PRINTF(("delete_objects_revert()\n"));
 601   change->applied = 0;
 602   layer_set_object_list(change->layer,
 603                         g_list_copy(change->original_objects));
 604   object_add_updates_list(change->obj_list, dia);
 605
 606  list = change->obj_list;
 607  while (list)
 608  {
 609    DiaObject *obj = (DiaObject *) list->data;
 610    if (obj->parent) /* Restore child references */
 611         obj->parent->children = g_list_append(obj->parent->children, obj);
 612
 613   list = g_list_next(list);
 614  }
 615
 616   diagram_tree_add_objects(diagram_tree(), dia, change->obj_list);
 617 }
 618
 619 static void
 620 delete_objects_free(struct DeleteObjectsChange *change)
 621 {
 622   DEBUG_PRINTF(("delete_objects_free()\n"));
 623   if (change->applied)
 624     destroy_object_list(change->obj_list);
 625   else
 626     g_list_free(change->obj_list);
 627   g_list_free(change->original_objects);
 628 }
 629
 630 /*
 631   This function deletes specified objects along with any children
 632   they might have.
 633   undo_delete_objects() only deletes the objects that are specified.
 634 */
 635 Change *
 636 undo_delete_objects_children(Diagram *dia, GList *obj_list)
 637 {
 638   return undo_delete_objects(dia, parent_list_affected(obj_list));
 639 }
 640
 641 Change *
 642 undo_delete_objects(Diagram *dia, GList *obj_list)
 643 {
 644   struct DeleteObjectsChange *change;
 645
 646   change = g_new0(struct DeleteObjectsChange, 1);
 647
 648   change->change.apply = (UndoApplyFunc) delete_objects_apply;
 649   change->change.revert = (UndoRevertFunc) delete_objects_revert;
 650   change->change.free = (UndoFreeFunc) delete_objects_free;
 651
 652   change->layer = dia->data->active_layer;
 653   change->obj_list = obj_list;
 654   change->original_objects = g_list_copy(dia->data->active_layer->objects);
 655   change->applied = 0;
 656
 657   DEBUG_PRINTF(("UNDO: Push new delete objects at %d\n", depth(dia->undo)));
 658   undo_push_change(dia->undo, (Change *) change);
 659   return (Change *)change;
 660 }
 661
 662 /******** Insert object list: */
 663
 664 struct InsertObjectsChange {
 665   Change change;
 666
 667   Layer *layer;
 668   GList *obj_list; /* Owning reference when not applied */
 669   int applied;
 670 };
 671
 672 static void
 673 insert_objects_apply(struct InsertObjectsChange *change, Diagram *dia)
 674 {
 675   DEBUG_PRINTF(("insert_objects_apply()\n"));
 676   change->applied = 1;
 677   layer_add_objects(change->layer, g_list_copy(change->obj_list));
 678   object_add_updates_list(change->obj_list, dia);
 679   diagram_tree_add_objects(diagram_tree(), dia, change->obj_list);
 680 }
 681
 682 static void
 683 insert_objects_revert(struct InsertObjectsChange *change, Diagram *dia)
 684 {
 685   GList *list;
 686
 687   DEBUG_PRINTF(("insert_objects_revert()\n"));
 688   change->applied = 0;
 689   diagram_unselect_objects(dia, change->obj_list);
 690   layer_remove_objects(change->layer, change->obj_list);
 691   object_add_updates_list(change->obj_list, dia);
 692
 693   list = change->obj_list;
 694   while (list != NULL) {
 695     DiaObject *obj = (DiaObject *)list->data;
 696
 697   /* Have to hide any open properties dialog
 698      if it contains some object in cut_list */
 699     properties_hide_if_shown(dia, obj);
 700
 701     list = g_list_next(list);
 702   }
 703
 704   diagram_tree_remove_objects(diagram_tree(), change->obj_list);
 705 }
 706
 707 static void
 708 insert_objects_free(struct InsertObjectsChange *change)
 709 {
 710   DEBUG_PRINTF(("insert_objects_free()\n"));
 711   if (!change->applied)
 712     destroy_object_list(change->obj_list);
 713   else
 714     g_list_free(change->obj_list);
 715 }
 716
 717 Change *
 718 undo_insert_objects(Diagram *dia, GList *obj_list, int applied)
 719 {
 720   struct InsertObjectsChange *change;
 721
 722   change = g_new0(struct InsertObjectsChange, 1);
 723
 724   change->change.apply = (UndoApplyFunc) insert_objects_apply;
 725   change->change.revert = (UndoRevertFunc) insert_objects_revert;
 726   change->change.free = (UndoFreeFunc) insert_objects_free;
 727
 728   change->layer = dia->data->active_layer;
 729   change->obj_list = obj_list;
 730   change->applied = applied;
 731
 732   DEBUG_PRINTF(("UNDO: Push new insert objects at %d\n", depth(dia->undo)));
 733   undo_push_change(dia->undo, (Change *) change);
 734   return (Change *)change;
 735 }
 736
 737 /******** Reorder object list: */
 738
 739 struct ReorderObjectsChange {
 740   Change change;
 741
 742   Layer *layer;
 743   GList *changed_list; /* Owning reference when applied */
 744   GList *original_objects;
 745   GList *reordered_objects;
 746 };
 747
 748 static void
 749 reorder_objects_apply(struct ReorderObjectsChange *change, Diagram *dia)
 750 {
 751   DEBUG_PRINTF(("reorder_objects_apply()\n"));
 752   layer_set_object_list(change->layer,
 753                         g_list_copy(change->reordered_objects));
 754   object_add_updates_list(change->changed_list, dia);
 755 }
 756
 757 static void
 758 reorder_objects_revert(struct ReorderObjectsChange *change, Diagram *dia)
 759 {
 760   DEBUG_PRINTF(("reorder_objects_revert()\n"));
 761   layer_set_object_list(change->layer,
 762                         g_list_copy(change->original_objects));
 763   object_add_updates_list(change->changed_list, dia);
 764 }
 765
 766 static void
 767 reorder_objects_free(struct ReorderObjectsChange *change)
 768 {
 769   DEBUG_PRINTF(("reorder_objects_free()\n"));
 770   g_list_free(change->changed_list);
 771   g_list_free(change->original_objects);
 772   g_list_free(change->reordered_objects);
 773 }
 774
 775 Change *
 776 undo_reorder_objects(Diagram *dia, GList *changed_list, GList *orig_list)
 777 {
 778   struct ReorderObjectsChange *change;
 779
 780   change = g_new0(struct ReorderObjectsChange, 1);
 781
 782   change->change.apply = (UndoApplyFunc) reorder_objects_apply;
 783   change->change.revert = (UndoRevertFunc) reorder_objects_revert;
 784   change->change.free = (UndoFreeFunc) reorder_objects_free;
 785
 786   change->layer = dia->data->active_layer;
 787   change->changed_list = changed_list;
 788   change->original_objects = orig_list;
 789   change->reordered_objects = g_list_copy(dia->data->active_layer->objects);
 790
 791   DEBUG_PRINTF(("UNDO: Push new reorder objects at %d\n", depth(dia->undo)));
 792   undo_push_change(dia->undo, (Change *) change);
 793   return (Change *)change;
 794 }
 795
 796 /******** ObjectChange: */
 797
 798 struct ObjectChangeChange {
 799   Change change;
 800
 801   DiaObject *obj;
 802   ObjectChange *obj_change;
 803 };
 804
 805
 806 static void
 807 object_change_apply(struct ObjectChangeChange *change,
 808                     Diagram *dia)
 809 {
 810   object_add_updates(change->obj, dia);
 811   change->obj_change->apply(change->obj_change, change->obj);
 812   { /* Make sure object updates its data: */
 813     Point p = change->obj->position;
 814     (change->obj->ops->move)(change->obj,&p);
 815   }
 816   object_add_updates(change->obj, dia);
 817
 818   diagram_update_connections_object(dia, change->obj, TRUE);
 819
 820   properties_update_if_shown(dia, change->obj);
 821 }
 822
 823 static void
 824 object_change_revert(struct ObjectChangeChange *change,
 825                      Diagram *dia)
 826 {
 827   object_add_updates(change->obj, dia);
 828   change->obj_change->revert(change->obj_change, change->obj);
 829   { /* Make sure object updates its data: */
 830     Point p = change->obj->position;
 831     (change->obj->ops->move)(change->obj,&p);
 832   }
 833   object_add_updates(change->obj, dia);
 834
 835   diagram_update_connections_object(dia, change->obj, TRUE);
 836
 837   properties_update_if_shown(dia, change->obj);
 838 }
 839
 840 static void
 841 object_change_free(struct ObjectChangeChange *change)
 842 {
 843   DEBUG_PRINTF(("state_change_free()\n"));
 844   if (change->obj_change->free)
 845     (*change->obj_change->free)(change->obj_change);
 846   g_free(change->obj_change);
 847 }
 848
 849 Change *
 850 undo_object_change(Diagram *dia, DiaObject *obj,
 851                    ObjectChange *obj_change)
 852 {
 853   struct ObjectChangeChange *change;
 854
 855   change = g_new0(struct ObjectChangeChange, 1);
 856
 857   change->change.apply = (UndoApplyFunc) object_change_apply;
 858   change->change.revert = (UndoRevertFunc) object_change_revert;
 859   change->change.free = (UndoFreeFunc) object_change_free;
 860
 861   change->obj = obj;
 862   change->obj_change = obj_change;
 863
 864   DEBUG_PRINTF(("UNDO: Push new obj_change at %d\n", depth(dia->undo)));
 865   undo_push_change(dia->undo, (Change *) change);
 866   return (Change *)change;
 867 }
 868
 869 /******** Group object list: */
 870
 871 /** Grouping and ungrouping are two subtly different changes:  While
 872  * ungrouping preserves the front/back position, grouping cannot do that,
 873  * since the act of grouping destroys positions for the members of the
 874  * group, and those positions have to be restored in the undo.
 875  */
 876
 877 struct GroupObjectsChange {
 878   Change change;
 879
 880   Layer *layer;
 881   DiaObject *group;   /* owning reference if not applied */
 882   GList *obj_list; /* The list of objects in this group.  Owned by the
 883                       group */
 884   GList *orig_list; /* A copy of the original list of all objects,
 885                        from before the group was created.  Owned by
 886                        the group */
 887   int applied;
 888 };
 889
 890 static void
 891 group_objects_apply(struct GroupObjectsChange *change, Diagram *dia)
 892 {
 893   GList *list;
 894
 895   DEBUG_PRINTF(("group_objects_apply()\n"));
 896
 897   change->applied = 1;
 898
 899   diagram_unselect_objects(dia, change->obj_list);
 900   layer_remove_objects(change->layer, change->obj_list);
 901   layer_add_object(change->layer, change->group);
 902   object_add_updates(change->group, dia);
 903
 904   list = change->obj_list;
 905   while (list != NULL) {
 906     DiaObject *obj = (DiaObject *)list->data;
 907
 908   /* Have to hide any open properties dialog
 909      if it contains some object in cut_list */
 910     properties_hide_if_shown(dia, obj);
 911
 912     object_add_updates(obj, dia);
 913
 914     list = g_list_next(list);
 915   }
 916
 917   diagram_tree_add_object(diagram_tree(), dia, change->group);
 918   diagram_tree_remove_objects(diagram_tree(), change->obj_list);
 919 }
 920
 921 static void
 922 group_objects_revert(struct GroupObjectsChange *change, Diagram *dia)
 923 {
 924   DEBUG_PRINTF(("group_objects_revert()\n"));
 925   change->applied = 0;
 926
 927   diagram_unselect_object(dia, change->group);
 928   object_add_updates(change->group, dia);
 929
 930   layer_set_object_list(change->layer, g_list_copy(change->orig_list));
 931
 932   object_add_updates_list(change->obj_list, dia);
 933
 934   properties_hide_if_shown(dia, change->group);
 935
 936   diagram_tree_add_objects(diagram_tree(), dia, change->obj_list);
 937   diagram_tree_remove_object(diagram_tree(), change->group);
 938 }
 939
 940 static void
 941 group_objects_free(struct GroupObjectsChange *change)
 942 {
 943   DEBUG_PRINTF(("group_objects_free()\n"));
 944   if (!change->applied) {
 945     group_destroy_shallow(change->group);
 946     change->group = NULL;
 947     change->obj_list = NULL;
 948     /** Leak here? */
 949   }
 950   g_list_free(change->orig_list);
 951 }
 952
 953 Change *
 954 undo_group_objects(Diagram *dia, GList *obj_list, DiaObject *group,
 955                    GList *orig_list)
 956 {
 957   struct GroupObjectsChange *change;
 958
 959   change = g_new0(struct GroupObjectsChange, 1);
 960
 961   change->change.apply = (UndoApplyFunc) group_objects_apply;
 962   change->change.revert = (UndoRevertFunc) group_objects_revert;
 963   change->change.free = (UndoFreeFunc) group_objects_free;
 964
 965   change->layer = dia->data->active_layer;
 966   change->group = group;
 967   change->obj_list = obj_list;
 968   change->orig_list = orig_list;
 969   change->applied = 1;
 970
 971   DEBUG_PRINTF(("UNDO: Push new group objects at %d\n", depth(dia->undo)));
 972   undo_push_change(dia->undo, (Change *) change);
 973   return (Change *)change;
 974 }
 975
 976 /******** Ungroup object list: */
 977
 978 struct UngroupObjectsChange {
 979   Change change;
 980
 981   Layer *layer;
 982   DiaObject *group;   /* owning reference if applied */
 983   GList *obj_list; /* This list is owned by the ungroup. */
 984   int group_index;
 985   int applied;
 986 };
 987
 988 static void
 989 ungroup_objects_apply(struct UngroupObjectsChange *change, Diagram *dia)
 990 {
 991   DEBUG_PRINTF(("ungroup_objects_apply()\n"));
 992
 993   change->applied = 1;
 994
 995   diagram_unselect_object(dia, change->group);
 996   object_add_updates(change->group, dia);
 997   layer_replace_object_with_list(change->layer, change->group,
 998                                  g_list_copy(change->obj_list));
 999   object_add_updates_list(change->obj_list, dia);
1000
1001   properties_hide_if_shown(dia, change->group);
1002
1003   diagram_tree_add_objects(diagram_tree(), dia, change->obj_list);
1004   diagram_tree_remove_object(diagram_tree(), change->group);
1005 }
1006
1007 static void
1008 ungroup_objects_revert(struct UngroupObjectsChange *change, Diagram *dia)
1009 {
1010   GList *list;
1011
1012   DEBUG_PRINTF(("ungroup_objects_revert()\n"));
1013   change->applied = 0;
1014
1015
1016   diagram_unselect_objects(dia, change->obj_list);
1017   layer_remove_objects(change->layer, change->obj_list);
1018   layer_add_object_at(change->layer, change->group, change->group_index);
1019   object_add_updates(change->group, dia);
1020
1021   list = change->obj_list;
1022   while (list != NULL) {
1023     DiaObject *obj = (DiaObject *)list->data;
1024
1025   /* Have to hide any open properties dialog
1026      if it contains some object in cut_list */
1027     properties_hide_if_shown(dia, obj);
1028
1029     list = g_list_next(list);
1030   }
1031
1032   diagram_tree_add_object(diagram_tree(), dia, change->group);
1033   diagram_tree_remove_objects(diagram_tree(), change->obj_list);
1034 }
1035
1036 static void
1037 ungroup_objects_free(struct UngroupObjectsChange *change)
1038 {
1039   DEBUG_PRINTF(("ungroup_objects_free()\n"));
1040   if (change->applied) {
1041     group_destroy_shallow(change->group);
1042     change->group = NULL;
1043     change->obj_list = NULL;
1044   }
1045 }
1046
1047 Change *
1048 undo_ungroup_objects(Diagram *dia, GList *obj_list, DiaObject *group,
1049                      int group_index)
1050 {
1051   struct UngroupObjectsChange *change;
1052
1053   change = g_new0(struct UngroupObjectsChange, 1);
1054
1055   change->change.apply = (UndoApplyFunc) ungroup_objects_apply;
1056   change->change.revert = (UndoRevertFunc) ungroup_objects_revert;
1057   change->change.free = (UndoFreeFunc) ungroup_objects_free;
1058
1059   change->layer = dia->data->active_layer;
1060   change->group = group;
1061   change->obj_list = obj_list;
1062   change->group_index = group_index;
1063   change->applied = 1;
1064
1065   DEBUG_PRINTF(("UNDO: Push new ungroup objects at %d\n", depth(dia->undo)));
1066   undo_push_change(dia->undo, (Change *) change);
1067   return (Change *)change;
1068 }
1069
1070 /******* PARENTING */
1071
1072 struct ParentChange {
1073   Change change;
1074   DiaObject *parentobj, *childobj;
1075   gboolean parent;
1076 };
1077
1078 /** Performs the actual parenting of a child to a parent.
1079  * Since no display changes arise from this, we need call no update. */
1080 static void
1081 parent_object(Diagram *dia, DiaObject *parent, DiaObject *child)
1082 {
1083   child->parent = parent;
1084   parent->children = g_list_prepend(parent->children, child);
1085 }
1086
1087 /** Performs the actual removal of a child from a parent.
1088  * Since no display changes arise from this, we need call no update. */
1089 static void
1090 unparent_object(Diagram *dia, DiaObject *parent, DiaObject *child)
1091 {
1092   child->parent = NULL;
1093   parent->children = g_list_remove(parent->children, child);
1094 }
1095
1096 /** Applies the given ParentChange */
1097 static void
1098 parent_change_apply(Change *change, Diagram *dia)
1099 {
1100   struct ParentChange *parentchange = (struct ParentChange*)change;
1101   if (parentchange->parent) {
1102     parent_object(dia, parentchange->parentobj, parentchange->childobj);
1103   } else {
1104     unparent_object(dia, parentchange->parentobj, parentchange->childobj);
1105   }
1106 }
1107
1108 /** Reverts the given ParentChange */
1109 static void
1110 parent_change_revert(Change *change, Diagram *dia)
1111 {
1112   struct ParentChange *parentchange = (struct ParentChange*)change;
1113   if (!parentchange->parent) {
1114     parent_object(dia, parentchange->parentobj, parentchange->childobj);
1115   } else {
1116     unparent_object(dia, parentchange->parentobj, parentchange->childobj);
1117   }
1118 }
1119
1120 /** Frees items in the change -- none really */
1121 static void
1122 parent_change_free(Change *change)
1123 {
1124 }
1125
1126 /** Create a new Change object for parenting/unparenting.
1127  * `parent' is TRUE if applying this change makes childobj a
1128  * child of parentobj.
1129  */
1130 Change *
1131 undo_parenting(Diagram *dia, DiaObject* parentobj, DiaObject* childobj,
1132                gboolean parent)
1133 {
1134   struct ParentChange *parentchange = g_new0(struct ParentChange, 1);
1135   Change *change = (Change*)parentchange;
1136   change->apply = parent_change_apply;
1137   change->revert = parent_change_revert;
1138   change->free = parent_change_free;
1139
1140   parentchange->parentobj = parentobj;
1141   parentchange->childobj = childobj;
1142   parentchange->parent = parent;
1143
1144   DEBUG_PRINTF(("UNDO: Push new obj_change at %d\n", depth(dia->undo)));
1145   undo_push_change(dia->undo, change);
1146   return change;
1147 }