workbench/classes/zune/texteditor/mcc/UndoFunctions.c

   1 /***************************************************************************
   2
   3  TextEditor.mcc - Textediting MUI Custom Class
   4  Copyright (C) 1997-2000 Allan Odgaard
   5  Copyright (C) 2005-2014 TextEditor.mcc Open Source Team
   6
   7  This library is free software; you can redistribute it and/or
   8  modify it under the terms of the GNU Lesser General Public
   9  License as published by the Free Software Foundation; either
  10  version 2.1 of the License, or (at your option) any later version.
  11
  12  This library is distributed in the hope that it will be useful,
  13  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  Lesser General Public License for more details.
  16
  17  TextEditor class Support Site:  http://www.sf.net/projects/texteditor-mcc
  18
  19  $Id$
  20
  21 ***************************************************************************/
  22
  23 #include <string.h>
  24
  25 #include <clib/alib_protos.h>
  26
  27 #include <proto/exec.h>
  28 #include <proto/intuition.h>
  29
  30 #include "private.h"
  31 #include "Debug.h"
  32
  33 /// FreeUndoStep()
  34 // free the memory occupated by an undo step
  35 static void FreeUndoStep(struct InstData *data, ULONG index)
  36 {
  37   struct UserAction *step = &data->undoSteps[index];
  38
  39   ENTER();
  40
  41   D(DBF_UNDO, "free undo step %ld", index);
  42
  43   if(step->type == ET_DELETEBLOCK || step->type == ET_DELETEBLOCK_NOMOVE || step->type == ET_PASTEBLOCK)
  44   {
  45     if(step->clip != NULL)
  46     {
  47       FreeVecPooled(data->mypool, step->clip);
  48       // clear the pointer
  49       step->clip = NULL;
  50     }
  51     // forget about the type of undo
  52     step->type = ET_NONE;
  53   }
  54
  55   LEAVE();
  56 }
  57
  58 ///
  59 /// Undo()
  60 BOOL Undo(struct InstData *data)
  61 {
  62   BOOL success = FALSE;
  63
  64   ENTER();
  65
  66   D(DBF_UNDO, "before maxUndoSteps=%ld nextUndoStep=%ld usedUndoSteps=%ld", data->maxUndoSteps, data->nextUndoStep, data->usedUndoSteps);
  67
  68   // check if there is something in the undo buffer available
  69   if(isFlagClear(data->flags, FLG_ReadOnly) && data->nextUndoStep > 0)
  70   {
  71     struct UserAction *action;
  72     BOOL moveCursor = TRUE;
  73
  74     if(Enabled(data))
  75     {
  76       data->blockinfo.enabled = FALSE;
  77       MarkText(data, data->blockinfo.startx, data->blockinfo.startline, data->blockinfo.stopx, data->blockinfo.stopline);
  78     }
  79
  80     // as the redo operation automatically
  81     // becomes available when undo is used we just
  82     // check here if we didn't yet set RedoAvailable
  83     // as we only want to set it once
  84     if(data->nextUndoStep == data->usedUndoSteps)
  85       set(data->object, MUIA_TextEditor_RedoAvailable, TRUE);
  86
  87     // go one step back
  88     data->nextUndoStep--;
  89     action = &data->undoSteps[data->nextUndoStep];
  90
  91 //    if(data->actualline != LineNode(data, buffer->y) || data->CPos_X != buffer->x)
  92     SetCursor(data, data->CPos_X, data->actualline, FALSE);
  93
  94     data->CPos_X = action->x;
  95     data->actualline = LineNode(data, action->y);
  96     ScrollIntoDisplay(data);
  97
  98     // perform the saved undo action
  99     switch(action->type)
 100     {
 101       case ET_PASTECHAR:
 102       {
 103         D(DBF_UNDO, "undo PASTECHAR");
 104         action->del.character = data->actualline->line.Contents[data->CPos_X];
 105         action->del.style = GetStyle(data->CPos_X, data->actualline);
 106         action->del.flow = data->actualline->line.Flow;
 107         action->del.separator = data->actualline->line.Separator;
 108         action->del.highlight = data->actualline->line.Highlight;
 109         RemoveChars(data, data->CPos_X, data->actualline, 1);
 110       }
 111       break;
 112
 113       case ET_DELETECHAR:
 114       {
 115         D(DBF_UNDO, "undo DELETECHAR");
 116         PasteChars(data, data->CPos_X, data->actualline, 1, (char *)&action->del.character, action);
 117       }
 118       break;
 119
 120       case ET_SPLITLINE:
 121       {
 122         D(DBF_UNDO, "undo SPLITLINE");
 123         MergeLines(data, data->actualline);
 124       }
 125       break;
 126
 127       case ET_MERGELINES:
 128       {
 129         D(DBF_UNDO, "undo MERGELINES");
 130         SplitLine(data, data->CPos_X, data->actualline, FALSE, action);
 131       }
 132       break;
 133
 134       case ET_BACKSPACEMERGE:
 135       {
 136         D(DBF_UNDO, "undo BACKSPACEMARGE");
 137         SplitLine(data, data->CPos_X, data->actualline, TRUE, action);
 138       }
 139       break;
 140
 141       case ET_PASTEBLOCK:
 142       {
 143         struct marking block =
 144         {
 145           TRUE,
 146           LineNode(data, action->y),
 147           action->x,
 148           LineNode(data, action->blk.y),
 149           action->blk.x
 150         };
 151         STRPTR clip = GetBlock(data, &block);
 152
 153         D(DBF_UNDO, "undo PASTEBLOCK");
 154         CutBlock2(data, CUTF_CUT|CUTF_UPDATE, &block);
 155         action->clip = clip;
 156       }
 157       break;
 158
 159       case ET_DELETEBLOCK_NOMOVE:
 160       {
 161         D(DBF_UNDO, "undo DELETEBLOCK_NOMOVE");
 162         moveCursor = FALSE;
 163       }
 164       // fall through...
 165
 166       case ET_DELETEBLOCK:
 167       {
 168         struct Hook *oldhook;
 169
 170         D(DBF_UNDO, "undo DELETEBLOCK");
 171         oldhook = data->ImportHook;
 172         data->ImportHook = &ImPlainHook;
 173         InsertText(data, action->clip, moveCursor);
 174         data->ImportHook = oldhook;
 175         FreeVecPooled(data->mypool, action->clip);
 176         // clear the pointer
 177         action->clip = NULL;
 178
 179         action->blk.x = data->CPos_X;
 180         action->blk.y = LineNr(data, data->actualline);
 181
 182         if(moveCursor == FALSE)
 183         {
 184           data->CPos_X = action->x;
 185           data->actualline = LineNode(data, action->y);
 186         }
 187       }
 188       break;
 189
 190       default:
 191         // nothing to do
 192       break;
 193     }
 194
 195     ScrollIntoDisplay(data);
 196
 197     if(isFlagSet(data->flags, FLG_Active))
 198       SetCursor(data, data->CPos_X, data->actualline, TRUE);
 199
 200     // if there are no further undo levels we
 201     // have to set UndoAvailable to FALSE
 202     if(data->nextUndoStep == 0)
 203     {
 204       set(data->object, MUIA_TextEditor_UndoAvailable, FALSE);
 205
 206       if(isFlagClear(data->flags, FLG_UndoLost))
 207         data->HasChanged = FALSE;
 208     }
 209
 210     success = TRUE;
 211   }
 212   else
 213   {
 214     DoMethod(data->object, MUIM_TextEditor_HandleError, Error_NothingToUndo);
 215   }
 216
 217   D(DBF_UNDO, "after  maxUndoSteps=%ld nextUndoStep=%ld usedUndoSteps=%ld", data->maxUndoSteps, data->nextUndoStep, data->usedUndoSteps);
 218
 219
 220   RETURN(success);
 221   return success;
 222 }
 223
 224 ///
 225 /// Redo()
 226 BOOL Redo(struct InstData *data)
 227 {
 228   BOOL success = FALSE;
 229
 230   ENTER();
 231
 232   D(DBF_UNDO, "before maxUndoSteps=%ld nextUndoStep=%ld usedUndoSteps=%ld", data->maxUndoSteps, data->nextUndoStep, data->usedUndoSteps);
 233
 234   // check if there something to redo at all
 235   if(isFlagClear(data->flags, FLG_ReadOnly) && data->nextUndoStep < data->usedUndoSteps)
 236   {
 237     struct UserAction *action;
 238
 239     if(Enabled(data))
 240     {
 241       data->blockinfo.enabled = FALSE;
 242       MarkText(data, data->blockinfo.startx, data->blockinfo.startline, data->blockinfo.stopx, data->blockinfo.stopline);
 243     }
 244
 245     // in case nextUndoStep is equal zero then we have to
 246     // set the undoavailable attribute to true to signal
 247     // others that undo is available
 248     if(data->nextUndoStep == 0)
 249       set(data->object, MUIA_TextEditor_UndoAvailable, TRUE);
 250
 251     action = &data->undoSteps[data->nextUndoStep];
 252     data->nextUndoStep++;
 253
 254 //    if(data->actualline != LineNode(data, buffer->y) || data->CPos_X != buffer->x)
 255     SetCursor(data, data->CPos_X, data->actualline, FALSE);
 256     data->CPos_X = action->x;
 257     data->actualline = LineNode(data, action->y);
 258     ScrollIntoDisplay(data);
 259
 260     switch(action->type)
 261     {
 262       case ET_PASTECHAR:
 263       {
 264         D(DBF_UNDO, "redo PASTECHAR");
 265         PasteChars(data, data->CPos_X, data->actualline, 1, (char *)&action->del.character, action);
 266         data->CPos_X++;
 267       }
 268       break;
 269
 270       case ET_DELETECHAR:
 271       {
 272         D(DBF_UNDO, "redo DELETECHAR");
 273         RemoveChars(data, data->CPos_X, data->actualline, 1);
 274       }
 275       break;
 276
 277       case ET_SPLITLINE:
 278       {
 279         D(DBF_UNDO, "redo SPLITLINE");
 280         SplitLine(data, data->CPos_X, data->actualline, TRUE, NULL);
 281       }
 282       break;
 283
 284       case ET_MERGELINES:
 285       case ET_BACKSPACEMERGE:
 286       {
 287         D(DBF_UNDO, "redo MERGELINES/BACKSPACEMERGE");
 288         MergeLines(data, data->actualline);
 289       }
 290       break;
 291
 292       case ET_PASTEBLOCK:
 293       {
 294         struct Hook *oldhook = data->ImportHook;
 295
 296         D(DBF_UNDO, "redo PASTEBLOCK");
 297         data->ImportHook = &ImPlainHook;
 298         InsertText(data, action->clip, TRUE);
 299         data->ImportHook = oldhook;
 300         FreeVecPooled(data->mypool, action->clip);
 301         // clear the pointer
 302         action->clip = NULL;
 303
 304         action->blk.x = data->CPos_X;
 305         action->blk.y = LineNr(data, data->actualline);
 306       }
 307       break;
 308
 309       case ET_DELETEBLOCK_NOMOVE:
 310       case ET_DELETEBLOCK:
 311       {
 312         struct marking block =
 313         {
 314           TRUE,
 315           LineNode(data, action->y),
 316           action->x,
 317           LineNode(data, action->blk.y),
 318           action->blk.x
 319         };
 320         STRPTR clip = GetBlock(data, &block);
 321
 322         D(DBF_UNDO, "redo DELETEBLOCK/DELETEBLOCK_NOMOVE");
 323         CutBlock2(data, CUTF_CUT|CUTF_UPDATE, &block);
 324         action->clip = clip;
 325       }
 326       break;
 327
 328       default:
 329         // nothing to do
 330       break;
 331     }
 332
 333     ScrollIntoDisplay(data);
 334
 335     if(isFlagSet(data->flags, FLG_Active))
 336       SetCursor(data, data->CPos_X, data->actualline, TRUE);
 337
 338     // if nextUndoStep == usedUndoSteps this signals that we
 339     // don't have any things to redo anymore.
 340     if(data->nextUndoStep == data->usedUndoSteps)
 341       set(data->object, MUIA_TextEditor_RedoAvailable, FALSE);
 342
 343     success = TRUE;
 344   }
 345   else
 346   {
 347     DoMethod(data->object, MUIM_TextEditor_HandleError, Error_NothingToRedo);
 348   }
 349
 350   D(DBF_UNDO, "after  maxUndoSteps=%ld nextUndoStep=%ld usedUndoSteps=%ld", data->maxUndoSteps, data->nextUndoStep, data->usedUndoSteps);
 351
 352   RETURN(success);
 353   return success;
 354 }
 355
 356 ///
 357 /// AddToUndoBuffer()
 358 BOOL AddToUndoBuffer(struct InstData *data, enum EventType eventtype, void *eventData)
 359 {
 360   ENTER();
 361
 362   D(DBF_UNDO, "before maxUndoSteps=%ld nextUndoStep=%ld usedUndoSteps=%ld", data->maxUndoSteps, data->nextUndoStep, data->usedUndoSteps);
 363
 364   if(isFlagClear(data->flags, FLG_ReadOnly) && data->maxUndoSteps > 0)
 365   {
 366     struct UserAction *action;
 367     BOOL success = TRUE;
 368
 369     // check if there is still enough space in our undo buffer
 370     // and if not we clean it up one entry
 371     if(data->nextUndoStep == data->maxUndoSteps)
 372     {
 373       // free the oldest stored action and forget about it
 374       D(DBF_UNDO, "undo buffer is full, loose the oldest step");
 375       FreeUndoStep(data, 0);
 376       data->nextUndoStep--;
 377       data->usedUndoSteps--;
 378
 379       // shift all remaining actions one step to the front
 380       memmove(&data->undoSteps[0], &data->undoSteps[1], sizeof(data->undoSteps[0]) * data->maxUndoSteps);
 381
 382       // signal the user that something in the undo buffer was lost
 383       setFlag(data->flags, FLG_UndoLost);
 384     }
 385     else
 386     {
 387       ULONG i;
 388
 389       // adding something new to the undo buffer will erase all previously
 390       // performed redo's
 391       for(i = data->nextUndoStep; i < data->usedUndoSteps; i++)
 392       {
 393         D(DBF_UNDO, "free not yet redone step %ld", i);
 394         FreeUndoStep(data, i);
 395       }
 396       data->usedUndoSteps = data->nextUndoStep;
 397     }
 398
 399     action = &data->undoSteps[data->nextUndoStep];
 400
 401     // clear any previous data
 402     memset(action, 0, sizeof(*action));
 403
 404     action->x = data->CPos_X;
 405     action->y = LineNr(data, data->actualline);
 406     action->type = eventtype;
 407
 408     switch(eventtype)
 409     {
 410       case ET_BACKSPACEMERGE:
 411       case ET_MERGELINES:
 412       {
 413         struct line_node *next = GetNextLine(data->actualline);
 414
 415         D(DBF_UNDO, "add undo MERGELINES/BACKSPACEMERGE");
 416         action->del.highlight = next->line.Highlight;
 417         action->del.flow = next->line.Flow;
 418         action->del.separator = next->line.Separator;
 419       }
 420       break;
 421
 422       case ET_DELETECHAR:
 423       {
 424         STRPTR str = (STRPTR)eventData;
 425
 426         D(DBF_UNDO, "add undo DELETECHAR");
 427         action->del.character = str[0];
 428         action->del.style = GetStyle(data->CPos_X, data->actualline);
 429         action->del.flow = data->actualline->line.Flow;
 430         action->del.separator = data->actualline->line.Separator;
 431         action->del.highlight = data->actualline->line.Highlight;
 432       }
 433       break;
 434
 435       case ET_PASTEBLOCK:
 436       {
 437         struct marking *block = (struct marking *)eventData;
 438
 439         D(DBF_UNDO, "add undo PASTEBLOCK");
 440         action->x = block->startx;
 441         action->y = LineNr(data, block->startline);
 442         action->blk.x = block->stopx;
 443         action->blk.y = LineNr(data, block->stopline);
 444       }
 445       break;
 446
 447       case ET_DELETEBLOCK:
 448       case ET_DELETEBLOCK_NOMOVE:
 449       {
 450         STRPTR text;
 451         struct marking *block = (struct marking *)eventData;
 452
 453         D(DBF_UNDO, "add undo DELETEBLOCK");
 454         if((text = GetBlock(data, block)) != NULL)
 455         {
 456           action->x = block->startx;
 457           action->y = LineNr(data, block->startline);
 458           action->clip = text;
 459
 460           if(eventtype == ET_DELETEBLOCK && isFlagSet(data->flags, FLG_FreezeCrsr))
 461             action->type = ET_DELETEBLOCK_NOMOVE;
 462         }
 463         else
 464         {
 465           success = FALSE;
 466         }
 467       }
 468       break;
 469
 470       default:
 471       {
 472         // nothing to do
 473       }
 474       break;
 475     }
 476
 477     if(success == TRUE)
 478     {
 479       // adding the undo step was successful, update the variables
 480       // advance the index for the next undo step
 481       data->nextUndoStep++;
 482       // and count this new step
 483       data->usedUndoSteps++;
 484     }
 485     else
 486     {
 487       // something went wrong, invoke the error method
 488       DoMethod(data->object, MUIM_TextEditor_HandleError, Error_NotEnoughUndoMem);
 489     }
 490
 491     // trigger possible notifications, no matter if the action succeeded or not,
 492     // because the undo/redo situation might have changed
 493     SetAttrs(data->object, MUIA_TextEditor_RedoAvailable, data->nextUndoStep < data->usedUndoSteps,
 494                            MUIA_TextEditor_UndoAvailable, data->usedUndoSteps != 0,
 495                            TAG_DONE);
 496   }
 497
 498   D(DBF_UNDO, "after  maxUndoSteps=%ld nextUndoStep=%ld usedUndoSteps=%ld", data->maxUndoSteps, data->nextUndoStep, data->usedUndoSteps);
 499
 500   RETURN(TRUE);
 501   return(TRUE);
 502 }
 503
 504 ///
 505 /// ResetUndoBuffer()
 506 void ResetUndoBuffer(struct InstData *data)
 507 {
 508   ENTER();
 509
 510   if(data->maxUndoSteps != 0 && data->undoSteps != NULL)
 511   {
 512     ULONG i;
 513
 514     for(i = 0; i < data->usedUndoSteps; i++)
 515       FreeUndoStep(data, i);
 516
 517     data->usedUndoSteps = 0;
 518     data->nextUndoStep = 0;
 519
 520     // trigger possible notifications
 521     SetAttrs(data->object, MUIA_TextEditor_RedoAvailable, FALSE,
 522                            MUIA_TextEditor_UndoAvailable, FALSE,
 523                            TAG_DONE);
 524   }
 525
 526   LEAVE();
 527 }
 528
 529 ///
 530 /// ResizeUndoBuffer()
 531 void ResizeUndoBuffer(struct InstData *data, ULONG newMaxUndoSteps)
 532 {
 533   ENTER();
 534
 535   if(data->maxUndoSteps != newMaxUndoSteps)
 536   {
 537     struct UserAction *newUndoSteps = NULL;
 538
 539     D(DBF_UNDO, "resizing undo buffer from %ld to %ld steps", data->maxUndoSteps, newMaxUndoSteps);
 540
 541     if(newMaxUndoSteps != 0)
 542     {
 543       ULONG oldSize;
 544       ULONG newSize;
 545
 546       // calculate number of bytes from number of undo levels
 547       oldSize = (data->maxUndoSteps * sizeof(struct UserAction));
 548       newSize = (newMaxUndoSteps * sizeof(struct UserAction));
 549
 550       // allocate a new undo buffer
 551       if((newUndoSteps = AllocVecPooled(data->mypool, newSize)) != NULL)
 552       {
 553         if(data->undoSteps != NULL)
 554         {
 555           // copy over the old undo steps
 556           memcpy(newUndoSteps, data->undoSteps, MIN(oldSize, newSize));
 557         }
 558       }
 559     }
 560
 561     if(data->undoSteps != NULL)
 562     {
 563       ULONG i;
 564
 565       // free the steps which don't fit into the new buffer anymore
 566       for(i = newMaxUndoSteps; i < data->maxUndoSteps; i++)
 567         FreeUndoStep(data, i);
 568
 569       // free the old buffer
 570       FreeVecPooled(data->mypool, data->undoSteps);
 571     }
 572
 573     // reset everything to the new values
 574     data->undoSteps = newUndoSteps;
 575     data->maxUndoSteps = newMaxUndoSteps;
 576     data->usedUndoSteps = MIN(data->usedUndoSteps, newMaxUndoSteps);
 577     data->nextUndoStep = MIN(data->nextUndoStep, newMaxUndoSteps);
 578
 579     // trigger possible notifications
 580     SetAttrs(data->object, MUIA_TextEditor_RedoAvailable, data->nextUndoStep < data->usedUndoSteps,
 581                            MUIA_TextEditor_UndoAvailable, data->usedUndoSteps != 0,
 582                            TAG_DONE);
 583   }
 584
 585   LEAVE();
 586 }
 587
 588 ///
 589 /// FreeUndoBuffer()
 590 void FreeUndoBuffer(struct InstData *data)
 591 {
 592   ENTER();
 593
 594   if(data->undoSteps != NULL)
 595   {
 596     ULONG i;
 597
 598     for(i = 0; i < data->usedUndoSteps; i++)
 599       FreeUndoStep(data, i);
 600
 601     FreeVecPooled(data->mypool, data->undoSteps);
 602     data->undoSteps = NULL;
 603   }
 604
 605   LEAVE();
 606 }
 607
 608 ///