src/undo.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2001 Hiroyuki Yamamoto
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 /* code ported from gedit */
  21 /* This is for my patient girlfirend Regina */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #  include "config.h"
  25 #endif
  26
  27 #include <glib.h>
  28
  29 #include <string.h> /* for strlen */
  30 #include <stdlib.h> /* for mbstowcs */
  31
  32 #include "undo.h"
  33 #include "utils.h"
  34 #include "gtkstext.h"
  35 #include "prefs_common.h"
  36
  37 typedef struct _UndoInfo UndoInfo;
  38
  39 struct _UndoInfo
  40 {
  41         UndoAction action;
  42         gchar *text;
  43         gint start_pos;
  44         gint end_pos;
  45         float window_position;
  46         int mergeable;
  47 };
  48
  49 static void undo_free_list      (GList         **list_pointer);
  50 static void undo_check_size     (UndoMain       *undostruct);
  51 static gint undo_merge          (GList          *list,
  52                                  guint           start_pos,
  53                                  guint           end_pos,
  54                                  gint            action,
  55                                  const guchar   *text);
  56 static void undo_add            (const gchar    *text,
  57                                  gint            start_pos,
  58                                  gint            end_pos,
  59                                  UndoAction      action,
  60                                  UndoMain       *undostruct);
  61 static gint undo_get_selection  (GtkEditable    *text,
  62                                  guint          *start,
  63                                  guint          *end);
  64 static void undo_insert_text_cb (GtkEditable    *editable,
  65                                  gchar          *new_text,
  66                                  gint            new_text_length,
  67                                  gint           *position,
  68                                  UndoMain       *undostruct);
  69 static void undo_delete_text_cb (GtkEditable    *editable,
  70                                  gint            start_pos,
  71                                  gint            end_pos,
  72                                  UndoMain       *undostruct);
  73
  74 static void undo_paste_clipboard_cb     (GtkEditable    *editable,
  75                                          UndoMain       *undostruct);
  76
  77 void undo_undo                  (UndoMain       *undostruct);
  78 void undo_redo                  (UndoMain       *undostruct);
  79
  80
  81 UndoMain *undo_init (GtkWidget *text)
  82 {
  83         UndoMain *undostruct;
  84
  85         g_return_val_if_fail(text != NULL, NULL);
  86
  87         undostruct = g_new(UndoMain, 1);
  88         undostruct->text = text;
  89         undostruct->undo = NULL;
  90         undostruct->redo = NULL;
  91         undostruct->paste = 0;
  92         undostruct->undo_state = FALSE;
  93         undostruct->redo_state = FALSE;
  94
  95         gtk_signal_connect(GTK_OBJECT(text), "insert-text",
  96                            GTK_SIGNAL_FUNC(undo_insert_text_cb), undostruct);
  97         gtk_signal_connect(GTK_OBJECT(text), "delete-text",
  98                            GTK_SIGNAL_FUNC(undo_delete_text_cb), undostruct);
  99         gtk_signal_connect(GTK_OBJECT(text), "paste-clipboard",
 100                            GTK_SIGNAL_FUNC(undo_paste_clipboard_cb), undostruct);
 101
 102         return undostruct;
 103 }
 104
 105 void undo_destroy (UndoMain *undostruct)
 106 {
 107         undo_free_list(&undostruct->undo);
 108         undo_free_list(&undostruct->redo);
 109         g_free(undostruct);
 110 }
 111
 112 static UndoInfo *undo_object_new(gchar *text, gint start_pos, gint end_pos,
 113                                  UndoAction action, gfloat window_position)
 114 {
 115         UndoInfo *undoinfo;
 116         undoinfo = g_new (UndoInfo, 1);
 117         undoinfo->text      = text;
 118         undoinfo->start_pos = start_pos;
 119         undoinfo->end_pos   = end_pos;
 120         undoinfo->action    = action;
 121         undoinfo->window_position = window_position;
 122         return undoinfo;
 123 }
 124
 125 static void undo_object_free(UndoInfo *undo)
 126 {
 127         g_free (undo->text);
 128         g_free (undo);
 129 }
 130
 131 /**
 132  * undo_free_list:
 133  * @list_pointer: list to be freed
 134  *
 135  * frees and undo structure list
 136  **/
 137 static void undo_free_list(GList **list_pointer)
 138 {
 139         UndoInfo *nth_redo;
 140         GList *cur, *list = *list_pointer;
 141
 142         if (list == NULL)
 143                 return;
 144
 145         debug_print("length of list: %d\n", g_list_length(list));
 146
 147         for (cur = list; cur != NULL; cur = cur->next) {
 148                 nth_redo = cur->data;
 149                 undo_object_free(nth_redo);
 150         }
 151
 152         g_list_free(list);
 153         *list_pointer = NULL;
 154 }
 155
 156 void undo_set_undo_change_funct(UndoMain *undostruct, UndoChangeState func,
 157                                 GtkWidget *changewidget)
 158 {
 159         g_return_if_fail(undostruct != NULL);
 160         undostruct->change_func = func;
 161         undostruct->changewidget = changewidget;
 162 }
 163
 164 /**
 165  * undo_check_size:
 166  * @compose: document to check
 167  *
 168  * Checks that the size of compose->undo does not excede settings->undo_levels and
 169  * frees any undo level above sett->undo_level.
 170  *
 171  **/
 172 static void undo_check_size(UndoMain *undostruct)
 173 {
 174         UndoInfo *nth_undo;
 175
 176         if (prefs_common.undolevels < 1)
 177                 return;
 178
 179         /* No need to check for the redo list size since the undo
 180            list gets freed on any call to compose_undo_add */
 181         if (g_list_length(undostruct->undo) >= prefs_common.undolevels && prefs_common.undolevels > 0) {
 182                 nth_undo = g_list_nth_data(undostruct->undo, g_list_length(undostruct->undo) - 1);
 183                 undostruct->undo = g_list_remove(undostruct->undo, nth_undo);
 184                 g_free (nth_undo->text);
 185                 g_free (nth_undo);
 186         }
 187         debug_print("g_list_length (undostruct->undo): %d\n", g_list_length(undostruct->undo));
 188 }
 189
 190 /**
 191  * undo_merge:
 192  * @last_undo:
 193  * @start_pos:
 194  * @end_pos:
 195  * @action:
 196  *
 197  * This function tries to merge the undo object at the top of
 198  * the stack with a new set of data. So when we undo for example
 199  * typing, we can undo the whole word and not each letter by itself
 200  *
 201  * Return Value: TRUE is merge was sucessful, FALSE otherwise
 202  **/
 203 static gint undo_merge (GList *list, guint start_pos, guint end_pos, gint action, const guchar* text)
 204 {
 205         guchar *temp_string;
 206         UndoInfo *last_undo;
 207         gboolean checkit = TRUE;
 208
 209         /* This are the cases in which we will NOT merge :
 210            1. if (last_undo->mergeable == FALSE)
 211            [mergeable = FALSE when the size of the undo data was not 1.
 212            or if the data was size = 1 but = '\n' or if the undo object
 213            has been "undone" already ]
 214            2. The size of text is not 1
 215            3. If the new merging data is a '\n'
 216            4. If the last char of the undo_last data is a space/tab
 217            and the new char is not a space/tab ( so that we undo
 218            words and not chars )
 219            5. If the type (action) of undo is different from the last one
 220         Chema */
 221
 222         if (list == NULL)
 223                 return FALSE;
 224
 225         last_undo = list->data;
 226
 227         if (!last_undo->mergeable)
 228                 return FALSE;
 229
 230         if (end_pos-start_pos != 1) {
 231                 last_undo->mergeable = FALSE;
 232                 return FALSE;
 233         }
 234
 235         if (text[0] == '\n')
 236                 checkit = FALSE;
 237
 238         if (action != last_undo->action)
 239                 checkit = FALSE;
 240
 241         if (action == UNDO_ACTION_REPLACE_INSERT || action == UNDO_ACTION_REPLACE_DELETE)
 242                  checkit = FALSE;
 243
 244         if (action == UNDO_ACTION_DELETE && checkit) {
 245                 if (last_undo->start_pos!=end_pos && last_undo->start_pos != start_pos && checkit)
 246                          checkit = FALSE;
 247
 248                 if (last_undo->start_pos == start_pos && checkit) {
 249                         /* Deleted with the delete key */
 250                         if ( text[0] != ' ' && text[0] != '\t' && checkit &&
 251                              (last_undo->text[last_undo->end_pos-last_undo->start_pos - 1] == ' '
 252                               || last_undo->text[last_undo->end_pos-last_undo->start_pos - 1] == '\t'))
 253                                  checkit = FALSE;
 254
 255                         temp_string = g_strdup_printf("%s%s", last_undo->text, text);
 256                         g_free(last_undo->text);
 257                         last_undo->end_pos += 1;
 258                         last_undo->text = temp_string;
 259                 } else if (checkit) {
 260                         /* Deleted with the backspace key */
 261                         if ( text[0] != ' ' && text[0] != '\t' && checkit &&
 262                              (last_undo->text[0] == ' '
 263                               || last_undo->text[0] == '\t'))
 264                                  checkit = FALSE;
 265
 266                         temp_string = g_strdup_printf("%s%s", text, last_undo->text);
 267                         g_free(last_undo->text);
 268                         last_undo->start_pos = start_pos;
 269                         last_undo->text = temp_string;
 270                 }
 271         } else if (action == UNDO_ACTION_INSERT && checkit) {
 272                 if (last_undo->end_pos != start_pos && checkit)
 273                          checkit = FALSE;
 274
 275 /*                if ( text[0]!=' ' && text[0]!='\t' &&
 276                      (last_undo->text [last_undo->end_pos-last_undo->start_pos - 1] ==' '
 277                       || last_undo->text [last_undo->end_pos-last_undo->start_pos - 1] == '\t'))
 278                         goto compose_undo_do_not_merge;
 279 */
 280                 if (checkit) {
 281                         temp_string = g_strdup_printf("%s%s", last_undo->text, text);
 282                         g_free(last_undo->text);
 283                         last_undo->end_pos = end_pos;
 284                         last_undo->text = temp_string;
 285                 }
 286         } else if (checkit)
 287                 debug_print("Unknown action [%i] inside undo merge encountered", action);
 288
 289         if (checkit) {
 290                 debug_print("Merged: %s\n", text);
 291                 return TRUE;
 292         } else {
 293                 last_undo->mergeable = FALSE;
 294                 return FALSE;
 295         }
 296 }
 297
 298 /**
 299  * compose_undo_add:
 300  * @text:
 301  * @start_pos:
 302  * @end_pos:
 303  * @action: either UNDO_ACTION_INSERT or UNDO_ACTION_DELETE
 304  * @compose:
 305  * @view: The view so that we save the scroll bar position.
 306  *
 307  * Adds text to the undo stack. It also performs test to limit the number
 308  * of undo levels and deltes the redo list
 309  **/
 310
 311 static void undo_add(const gchar *text,
 312                      gint start_pos, gint end_pos,
 313                      UndoAction action, UndoMain *undostruct)
 314 {
 315         UndoInfo *undoinfo;
 316
 317         debug_print("undo_add(%i)*%s*\n", strlen (text), text);
 318
 319         g_return_if_fail(text != NULL);
 320         g_return_if_fail(end_pos >= start_pos);
 321
 322         undo_free_list(&undostruct->redo);
 323
 324         /* Set the redo sensitivity */
 325         undostruct->change_func(undostruct, UNDO_STATE_UNCHANGED, UNDO_STATE_FALSE,
 326                                 undostruct->changewidget);
 327
 328         if (undostruct->paste != 0) {
 329                 if (action == UNDO_ACTION_INSERT)
 330                         action = UNDO_ACTION_REPLACE_INSERT;
 331                 else
 332                         action = UNDO_ACTION_REPLACE_DELETE;
 333                 undostruct->paste = undostruct->paste + 1;
 334                 if (undostruct->paste == 3)
 335                         undostruct->paste = 0;
 336         }
 337
 338         if (undo_merge(undostruct->undo, start_pos, end_pos, action, text))
 339                 return;
 340
 341         undo_check_size(undostruct);
 342
 343         debug_print("New: %s Action: %d Paste: %d\n", text, action, undostruct->paste);
 344
 345         undoinfo = undo_object_new(g_strdup(text), start_pos, end_pos, action,
 346                                    GTK_ADJUSTMENT(GTK_STEXT(undostruct->text)->vadj)->value);
 347
 348         if (end_pos-start_pos != 1 || text[0] == '\n')
 349                 undoinfo->mergeable = FALSE;
 350         else
 351                 undoinfo->mergeable = TRUE;
 352
 353         undostruct->undo = g_list_prepend(undostruct->undo, undoinfo);
 354
 355         undostruct->change_func(undostruct, UNDO_STATE_TRUE, UNDO_STATE_UNCHANGED, undostruct->changewidget);
 356 }
 357
 358 /**
 359  * undo_undo:
 360  * @w: not used
 361  * @data: not used
 362  *
 363  * Executes an undo request on the current document
 364  **/
 365 void undo_undo(UndoMain *undostruct)
 366 {
 367         UndoInfo *undoinfo;
 368         guint start_pos, end_pos;
 369
 370         if (undostruct->undo == NULL)
 371                 return;
 372
 373         g_return_if_fail(undostruct != NULL);
 374
 375
 376         /* The undo data we need is always at the top op the
 377            stack. So, therefore, the first one */
 378         undoinfo = g_list_nth_data(undostruct->undo, 0);
 379         g_return_if_fail(undoinfo != NULL);
 380         undoinfo->mergeable = FALSE;
 381         undostruct->redo = g_list_prepend(undostruct->redo, undoinfo);
 382         undostruct->undo = g_list_remove(undostruct->undo, undoinfo);
 383
 384         /* Check if there is a selection active */
 385         start_pos = GTK_EDITABLE(undostruct->text)->selection_start_pos;
 386         end_pos   = GTK_EDITABLE(undostruct->text)->selection_end_pos;
 387         if ((start_pos > 0 || end_pos > 0) && (start_pos != end_pos))
 388                 gtk_editable_select_region(GTK_EDITABLE(undostruct->text), 0, 0);
 389
 390         /* Move the view (scrollbars) to the correct position */
 391         gtk_adjustment_set_value(GTK_ADJUSTMENT(GTK_STEXT(undostruct->text)->vadj), undoinfo->window_position);
 392
 393         switch (undoinfo->action) {
 394         case UNDO_ACTION_DELETE:
 395                 gtk_stext_set_point(GTK_STEXT(undostruct->text), undoinfo->start_pos);
 396                 gtk_stext_insert(GTK_STEXT(undostruct->text), NULL, NULL, NULL, undoinfo->text, -1);
 397                 debug_print("UNDO_ACTION_DELETE %s\n", undoinfo->text);
 398                 break;
 399         case UNDO_ACTION_INSERT:
 400                 gtk_stext_set_point(GTK_STEXT(undostruct->text), undoinfo->end_pos);
 401                 gtk_stext_backward_delete(GTK_STEXT(undostruct->text), undoinfo->end_pos-undoinfo->start_pos);
 402                 debug_print("UNDO_ACTION_INSERT %d\n", undoinfo->end_pos-undoinfo->start_pos);
 403                 break;
 404         case UNDO_ACTION_REPLACE_INSERT:
 405                 gtk_stext_set_point(GTK_STEXT(undostruct->text), undoinfo->end_pos);
 406                 gtk_stext_backward_delete(GTK_STEXT(undostruct->text), undoinfo->end_pos-undoinfo->start_pos);
 407                 debug_print("UNDO_ACTION_REPLACE %s\n", undoinfo->text);
 408                 /* "pull" another data structure from the list */
 409                 undoinfo = g_list_nth_data(undostruct->undo, 0);
 410                 g_return_if_fail(undoinfo != NULL);
 411                 undostruct->redo = g_list_prepend(undostruct->redo, undoinfo);
 412                 undostruct->undo = g_list_remove(undostruct->undo, undoinfo);
 413                 g_return_if_fail(undoinfo->action == UNDO_ACTION_REPLACE_DELETE);
 414                 gtk_stext_set_point(GTK_STEXT(undostruct->text), undoinfo->start_pos);
 415                 gtk_stext_insert(GTK_STEXT(undostruct->text), NULL, NULL, NULL, undoinfo->text, -1);
 416                 debug_print("UNDO_ACTION_REPLACE %s\n", undoinfo->text);
 417                 break;
 418         case UNDO_ACTION_REPLACE_DELETE:
 419                 g_warning("This should not happen. UNDO_REPLACE_DELETE");
 420                 break;
 421         default:
 422                 g_assert_not_reached();
 423                 break;
 424         }
 425
 426         undostruct->change_func(undostruct, UNDO_STATE_UNCHANGED,
 427                                 UNDO_STATE_TRUE, undostruct->changewidget);
 428
 429         if (g_list_length (undostruct->undo) == 0)
 430                 undostruct->change_func(undostruct, UNDO_STATE_FALSE,
 431                                         UNDO_STATE_UNCHANGED,
 432                                         undostruct->changewidget);
 433 }
 434
 435 /**
 436  * undo_redo:
 437  * @w: not used
 438  * @data: not used
 439  *
 440  * executes a redo request on the current document
 441  **/
 442 void undo_redo(UndoMain *undostruct)
 443 {
 444         UndoInfo *redoinfo;
 445         guint start_pos, end_pos;
 446
 447         if (undostruct->redo == NULL)
 448                 return;
 449
 450         if (undostruct==NULL)
 451                 return;
 452
 453         redoinfo = g_list_nth_data(undostruct->redo, 0);
 454         g_return_if_fail (redoinfo!=NULL);
 455         undostruct->undo = g_list_prepend(undostruct->undo, redoinfo);
 456         undostruct->redo = g_list_remove(undostruct->redo, redoinfo);
 457
 458         /* Check if there is a selection active */
 459         start_pos = GTK_EDITABLE(undostruct->text)->selection_start_pos;
 460         end_pos   = GTK_EDITABLE(undostruct->text)->selection_end_pos;
 461         if ((start_pos > 0 || end_pos > 0) && (start_pos != end_pos))
 462                 gtk_editable_select_region(GTK_EDITABLE(undostruct->text), 0, 0);
 463
 464         /* Move the view to the right position. */
 465         gtk_adjustment_set_value(GTK_ADJUSTMENT(GTK_STEXT(undostruct->text)->vadj),
 466                                  redoinfo->window_position);
 467
 468         switch (redoinfo->action) {
 469         case UNDO_ACTION_INSERT:
 470                 gtk_stext_set_point(GTK_STEXT(undostruct->text), redoinfo->start_pos);
 471                 gtk_stext_insert(GTK_STEXT(undostruct->text), NULL, NULL,
 472                                  NULL, redoinfo->text, -1);
 473                 debug_print("UNDO_ACTION_DELETE %s\n",redoinfo->text);
 474                 break;
 475         case UNDO_ACTION_DELETE:
 476                 gtk_stext_set_point(GTK_STEXT(undostruct->text), redoinfo->end_pos);
 477                 gtk_stext_backward_delete(GTK_STEXT(undostruct->text),
 478                                           redoinfo->end_pos-redoinfo->start_pos);
 479                 debug_print("UNDO_ACTION_INSERT %d\n",
 480                             redoinfo->end_pos-redoinfo->start_pos);
 481                 break;
 482         case UNDO_ACTION_REPLACE_DELETE:
 483                 gtk_stext_set_point(GTK_STEXT(undostruct->text), redoinfo->end_pos);
 484                 gtk_stext_backward_delete(GTK_STEXT(undostruct->text),
 485                                           redoinfo->end_pos-redoinfo->start_pos);
 486                 /* "pull" another data structure from the list */
 487                 redoinfo = g_list_nth_data(undostruct->redo, 0);
 488                 g_return_if_fail(redoinfo != NULL);
 489                 undostruct->undo = g_list_prepend(undostruct->undo, redoinfo);
 490                 undostruct->redo = g_list_remove(undostruct->redo, redoinfo);
 491                 g_return_if_fail(redoinfo->action==UNDO_ACTION_REPLACE_INSERT);
 492                 gtk_stext_set_point(GTK_STEXT(undostruct->text), redoinfo->start_pos);
 493                 gtk_stext_insert(GTK_STEXT(undostruct->text), NULL, NULL,
 494                                  NULL, redoinfo->text, -1);
 495                 break;
 496         case UNDO_ACTION_REPLACE_INSERT:
 497                 g_warning("This should not happen. Redo: UNDO_REPLACE_INSERT");
 498                 break;
 499         default:
 500                 g_assert_not_reached();
 501                 break;
 502         }
 503
 504         undostruct->change_func(undostruct, UNDO_STATE_TRUE, UNDO_STATE_UNCHANGED,
 505                                 undostruct->changewidget);
 506
 507         if (g_list_length(undostruct->redo) == 0)
 508                 undostruct->change_func(undostruct, UNDO_STATE_UNCHANGED,
 509                                         UNDO_STATE_FALSE, undostruct->changewidget);
 510 }
 511
 512 void undo_insert_text_cb(GtkEditable *editable, gchar *new_text,
 513                          gint new_text_length, gint *position,
 514                          UndoMain *undostruct)
 515 {
 516         gchar *text_to_insert;
 517         size_t wlen;
 518
 519         if (prefs_common.undolevels <= 0) return;
 520
 521         Xstrndup_a(text_to_insert, new_text, new_text_length, return);
 522         if (MB_CUR_MAX > 1) {
 523                 wchar_t *wstr;
 524
 525                 Xalloca(wstr, sizeof(wchar_t) * (new_text_length + 1), return);
 526                 wlen = mbstowcs(wstr, text_to_insert, new_text_length + 1);
 527                 if (wlen < 0) return;
 528         } else
 529                 wlen = new_text_length;
 530
 531         undo_add(text_to_insert, *position, *position + wlen,
 532                  UNDO_ACTION_INSERT, undostruct);
 533 }
 534
 535 void undo_delete_text_cb(GtkEditable *editable, gint start_pos,
 536                          gint end_pos, UndoMain *undostruct)
 537 {
 538         gchar *text_to_delete;
 539
 540         if (prefs_common.undolevels <= 0) return;
 541         if (start_pos == end_pos) return;
 542
 543         text_to_delete = gtk_editable_get_chars(GTK_EDITABLE(editable),
 544                                                 start_pos, end_pos);
 545         undo_add(text_to_delete, start_pos, end_pos, UNDO_ACTION_DELETE,
 546                  undostruct);
 547         g_free(text_to_delete);
 548 }
 549
 550 void undo_paste_clipboard_cb (GtkEditable *editable, UndoMain *undostruct)
 551 {
 552         debug_print("befor Paste: %d\n", undostruct->paste);
 553         if (prefs_common.undolevels > 0)
 554                 if (undo_get_selection(editable, NULL, NULL))
 555                         undostruct->paste = TRUE;
 556         debug_print("after Paste: %d\n", undostruct->paste);
 557 }
 558
 559 /**
 560  * undo_get_selection:
 561  * @text: Text to get the selection from
 562  * @start: return here the start position of the selection
 563  * @end: return here the end position of the selection
 564  *
 565  * Gets the current selection for View
 566  *
 567  * Return Value: TRUE if there is a selection active, FALSE if not
 568  **/
 569 static gint undo_get_selection(GtkEditable *text, guint *start, guint *end)
 570 {
 571         guint start_pos, end_pos;
 572
 573         start_pos = text->selection_start_pos;
 574         end_pos   = text->selection_end_pos;
 575
 576         /* The user can select from end to start too. If so, swap it*/
 577         if (end_pos < start_pos) {
 578                 guint swap_pos;
 579                 swap_pos  = end_pos;
 580                 end_pos   = start_pos;
 581                 start_pos = swap_pos;
 582         }
 583
 584         if (start != NULL)
 585                 *start = start_pos;
 586
 587         if (end != NULL)
 588                 *end = end_pos;
 589
 590         if ((start_pos > 0 || end_pos > 0) && (start_pos != end_pos))
 591                 return TRUE;
 592         else
 593                 return FALSE;
 594 }