src/kits/tracker/FSUndoRedo.cpp

   1 /*
   2 Open Tracker License
   3
   4 Terms and Conditions
   5
   6 Copyright (c) 1991-2000, Be Incorporated. All rights reserved.
   7
   8 Permission is hereby granted, free of charge, to any person obtaining a copy of
   9 this software and associated documentation files (the "Software"), to deal in
  10 the Software without restriction, including without limitation the rights to
  11 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
  12 of the Software, and to permit persons to whom the Software is furnished to do
  13 so, subject to the following conditions:
  14
  15 The above copyright notice and this permission notice applies to all licensees
  16 and shall be included in all copies or substantial portions of the Software.
  17
  18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF TITLE, MERCHANTABILITY,
  20 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  21 BE INCORPORATED BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  22 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION
  23 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24
  25 Except as contained in this notice, the name of Be Incorporated shall not be
  26 used in advertising or otherwise to promote the sale, use or other dealings in
  27 this Software without prior written authorization from Be Incorporated.
  28
  29 Tracker(TM), Be(R), BeOS(R), and BeIA(TM) are trademarks or registered trademarks
  30 of Be Incorporated in the United States and other countries. Other brand product
  31 names are registered trademarks or trademarks of their respective holders.
  32 All rights reserved.
  33 */
  34
  35
  36 #include "Commands.h"
  37 #include "FSUndoRedo.h"
  38 #include "FSUtils.h"
  39
  40 #include <Autolock.h>
  41 #include <Volume.h>
  42 #include <Node.h>
  43 #include <Path.h>
  44
  45
  46 static const int32 kUndoRedoListMaxCount = 20;
  47
  48
  49 namespace BPrivate {
  50
  51 class UndoItem {
  52         public:
  53                 virtual ~UndoItem() {}
  54
  55                 virtual status_t Undo() = 0;
  56                 virtual status_t Redo() = 0;
  57
  58                 virtual void UpdateEntry(BEntry* /*entry*/, const char* /*name*/) {}
  59                         // updates the name of the target from the source entry "entry"
  60 };
  61
  62 static BObjectList<UndoItem> sUndoList, sRedoList;
  63 static BLocker sLock("undo");
  64
  65 class UndoItemCopy : public UndoItem {
  66         public:
  67                 UndoItemCopy(BObjectList<entry_ref>* sourceList, BDirectory &target,
  68                         BList* pointList, uint32 moveMode);
  69                 virtual ~UndoItemCopy();
  70
  71                 virtual status_t Undo();
  72                 virtual status_t Redo();
  73                 virtual void UpdateEntry(BEntry* entry, const char* name);
  74
  75         private:
  76                 BObjectList<entry_ref> fSourceList;
  77                 BObjectList<entry_ref> fTargetList;
  78                 entry_ref       fSourceRef, fTargetRef;
  79                 uint32          fMoveMode;
  80 };
  81
  82
  83 class UndoItemMove : public UndoItem {
  84         public:
  85                 /** source - list of file(s) that were moved.  Assumes ownership.
  86                  *      origfolder - location it was moved from
  87                  */
  88                 UndoItemMove(BObjectList<entry_ref>* sourceList, BDirectory &target,
  89                         BList* pointList);
  90                 virtual ~UndoItemMove();
  91
  92                 virtual status_t Undo();
  93                 virtual status_t Redo();
  94
  95         private:
  96                 BObjectList<entry_ref> fSourceList;
  97                 entry_ref       fSourceRef, fTargetRef;
  98 };
  99
 100
 101 class UndoItemFolder : public UndoItem {
 102         public:
 103                 UndoItemFolder(const entry_ref &ref);
 104                         // ref - entry_ref indicating the folder created
 105                 virtual ~UndoItemFolder();
 106
 107                 virtual status_t Undo();
 108                 virtual status_t Redo();
 109
 110         private:
 111                 // this ref has two different meanings in the different states of
 112                 // this object:
 113                 //  - Undo() - fRef indicates the folder that was created via
 114                 //    FSCreateNewFolderIn(...)
 115                 //  - Redo() - fRef indicates the folder in which
 116                 //    FSCreateNewFolderIn() should be performed
 117                 entry_ref       fRef;
 118 };
 119
 120
 121 class UndoItemRename : public UndoItem {
 122         public:
 123                 UndoItemRename(const entry_ref &origRef, const entry_ref &ref);
 124                 UndoItemRename(const BEntry &entry, const char* newName);
 125                 virtual ~UndoItemRename();
 126
 127                 virtual status_t Undo();
 128                 virtual status_t Redo();
 129
 130         private:
 131                 entry_ref       fRef, fOrigRef;
 132 };
 133
 134
 135 class UndoItemRenameVolume : public UndoItem {
 136         public:
 137                 UndoItemRenameVolume(BVolume &volume, const char* newName);
 138                 virtual ~UndoItemRenameVolume();
 139
 140                 virtual status_t Undo();
 141                 virtual status_t Redo();
 142
 143         private:
 144                 BVolume fVolume;
 145                 BString fOldName, fNewName;
 146 };
 147
 148
 149 //--------------------------
 150
 151
 152 static status_t
 153 ChangeListSource(BObjectList<entry_ref> &list, BEntry &entry)
 154 {
 155         node_ref source;
 156         if (entry.GetNodeRef(&source) != B_OK)
 157                 return B_ERROR;
 158
 159         for (int32 index = 0; index < list.CountItems(); index++) {
 160                 entry_ref* ref = list.ItemAt(index);
 161
 162                 ref->device = source.device;
 163                 ref->directory = source.node;
 164         }
 165
 166         return B_OK;
 167 }
 168
 169
 170 static void
 171 AddUndoItem(UndoItem* item)
 172 {
 173         BAutolock locker(sLock);
 174
 175         // we have a restricted number of possible undos
 176         if (sUndoList.CountItems() == kUndoRedoListMaxCount)
 177                 sUndoList.RemoveItem(sUndoList.LastItem());
 178
 179         sUndoList.AddItem(item, 0);
 180         sRedoList.MakeEmpty();
 181 }
 182
 183
 184 //      #pragma mark - Undo
 185
 186
 187 Undo::~Undo()
 188 {
 189         if (fUndo != NULL)
 190                 AddUndoItem(fUndo);
 191 }
 192
 193
 194 void
 195 Undo::UpdateEntry(BEntry* entry, const char* destName)
 196 {
 197         if (fUndo != NULL)
 198                 fUndo->UpdateEntry(entry, destName);
 199 }
 200
 201
 202 void
 203 Undo::Remove()
 204 {
 205         delete fUndo;
 206         fUndo = NULL;
 207 }
 208
 209
 210 MoveCopyUndo::MoveCopyUndo(BObjectList<entry_ref>* sourceList,
 211         BDirectory &dest, BList* pointList, uint32 moveMode)
 212 {
 213         if (moveMode == kMoveSelectionTo)
 214                 fUndo = new UndoItemMove(sourceList, dest, pointList);
 215         else
 216                 fUndo = new UndoItemCopy(sourceList, dest, pointList, moveMode);
 217 }
 218
 219
 220 NewFolderUndo::NewFolderUndo(const entry_ref &ref)
 221 {
 222         fUndo = new UndoItemFolder(ref);
 223 }
 224
 225
 226 RenameUndo::RenameUndo(BEntry &entry, const char* newName)
 227 {
 228         fUndo = new UndoItemRename(entry, newName);
 229 }
 230
 231
 232 RenameVolumeUndo::RenameVolumeUndo(BVolume &volume, const char* newName)
 233 {
 234         fUndo = new UndoItemRenameVolume(volume, newName);
 235 }
 236
 237
 238 //      #pragma mark - UndoItemCopy
 239
 240
 241 UndoItemCopy::UndoItemCopy(BObjectList<entry_ref>* sourceList,
 242         BDirectory &target, BList* /*pointList*/, uint32 moveMode)
 243         :
 244         fSourceList(*sourceList),
 245         fTargetList(*sourceList),
 246         fMoveMode(moveMode)
 247 {
 248         BEntry entry(sourceList->ItemAt(0));
 249
 250         BEntry sourceEntry;
 251         entry.GetParent(&sourceEntry);
 252         sourceEntry.GetRef(&fSourceRef);
 253
 254         BEntry targetEntry;
 255         target.GetEntry(&targetEntry);
 256         targetEntry.GetRef(&fTargetRef);
 257         ChangeListSource(fTargetList, targetEntry);
 258 }
 259
 260
 261 UndoItemCopy::~UndoItemCopy()
 262 {
 263 }
 264
 265
 266 status_t
 267 UndoItemCopy::Undo()
 268 {
 269         FSDeleteRefList(new BObjectList<entry_ref>(fTargetList), true, false);
 270         return B_OK;
 271 }
 272
 273
 274 status_t
 275 UndoItemCopy::Redo()
 276 {
 277         FSMoveToFolder(new BObjectList<entry_ref>(fSourceList),
 278                 new BEntry(&fTargetRef), FSUndoMoveMode(fMoveMode), NULL);
 279
 280         return B_OK;
 281 }
 282
 283
 284 void
 285 UndoItemCopy::UpdateEntry(BEntry* entry, const char* name)
 286 {
 287         entry_ref changedRef;
 288         if (entry->GetRef(&changedRef) != B_OK)
 289                 return;
 290
 291         for (int32 index = 0; index < fSourceList.CountItems(); index++) {
 292                 entry_ref* ref = fSourceList.ItemAt(index);
 293                 if (changedRef != *ref)
 294                         continue;
 295
 296                 ref = fTargetList.ItemAt(index);
 297                 ref->set_name(name);
 298         }
 299 }
 300
 301
 302 //      #pragma mark - UndoItemMove
 303
 304
 305 UndoItemMove::UndoItemMove(BObjectList<entry_ref>* sourceList,
 306         BDirectory &target, BList* /*pointList*/)
 307         :
 308         fSourceList(*sourceList)
 309 {
 310         BEntry entry(sourceList->ItemAt(0));
 311         BEntry source;
 312         entry.GetParent(&source);
 313         source.GetRef(&fSourceRef);
 314
 315         BEntry targetEntry;
 316         target.GetEntry(&targetEntry);
 317         targetEntry.GetRef(&fTargetRef);
 318 }
 319
 320
 321 UndoItemMove::~UndoItemMove()
 322 {
 323 }
 324
 325
 326 status_t
 327 UndoItemMove::Undo()
 328 {
 329         BObjectList<entry_ref>* list = new BObjectList<entry_ref>(fSourceList);
 330         BEntry entry(&fTargetRef);
 331         ChangeListSource(*list, entry);
 332
 333         // FSMoveToFolder() owns its arguments
 334         FSMoveToFolder(list, new BEntry(&fSourceRef),
 335                 FSUndoMoveMode(kMoveSelectionTo), NULL);
 336
 337         return B_OK;
 338 }
 339
 340
 341 status_t
 342 UndoItemMove::Redo()
 343 {
 344         // FSMoveToFolder() owns its arguments
 345         FSMoveToFolder(new BObjectList<entry_ref>(fSourceList),
 346                 new BEntry(&fTargetRef), FSUndoMoveMode(kMoveSelectionTo), NULL);
 347
 348         return B_OK;
 349 }
 350
 351
 352 //      #pragma mark -
 353
 354
 355 UndoItemFolder::UndoItemFolder(const entry_ref &ref)
 356         :
 357         fRef(ref)
 358 {
 359 }
 360
 361
 362 UndoItemFolder::~UndoItemFolder()
 363 {
 364 }
 365
 366
 367 status_t
 368 UndoItemFolder::Undo()
 369 {
 370         FSDelete(new entry_ref(fRef), false, false);
 371         return B_OK;
 372 }
 373
 374
 375 status_t
 376 UndoItemFolder::Redo()
 377 {
 378         return FSCreateNewFolder(&fRef);
 379 }
 380
 381
 382 //      #pragma mark -
 383
 384
 385 UndoItemRename::UndoItemRename(const entry_ref &origRef, const entry_ref &ref)
 386         :
 387         fRef(ref),
 388         fOrigRef(origRef)
 389 {
 390 }
 391
 392
 393 UndoItemRename::UndoItemRename(const BEntry &entry, const char* newName)
 394 {
 395         entry.GetRef(&fOrigRef);
 396
 397         fRef = fOrigRef;
 398         fRef.set_name(newName);
 399 }
 400
 401
 402 UndoItemRename::~UndoItemRename()
 403 {
 404 }
 405
 406
 407 status_t
 408 UndoItemRename::Undo()
 409 {
 410         BEntry entry(&fRef, false);
 411         return entry.Rename(fOrigRef.name);
 412 }
 413
 414
 415 status_t
 416 UndoItemRename::Redo()
 417 {
 418         BEntry entry(&fOrigRef, false);
 419         return entry.Rename(fRef.name);
 420 }
 421
 422
 423 //      #pragma mark - UndoItemRenameVolume
 424
 425
 426 UndoItemRenameVolume::UndoItemRenameVolume(BVolume &volume,
 427         const char* newName)
 428         :
 429         fVolume(volume),
 430         fNewName(newName)
 431 {
 432         char* buffer = fOldName.LockBuffer(B_FILE_NAME_LENGTH);
 433         if (buffer != NULL) {
 434                 fVolume.GetName(buffer);
 435                 fOldName.UnlockBuffer();
 436         }
 437 }
 438
 439
 440 UndoItemRenameVolume::~UndoItemRenameVolume()
 441 {
 442 }
 443
 444
 445 status_t
 446 UndoItemRenameVolume::Undo()
 447 {
 448         return fVolume.SetName(fOldName.String());
 449 }
 450
 451
 452 status_t
 453 UndoItemRenameVolume::Redo()
 454 {
 455         return fVolume.SetName(fNewName.String());
 456 }
 457
 458
 459 //      #pragma mark - FSUndo() and FSRedo() functions
 460
 461
 462 void
 463 FSUndo()
 464 {
 465         BAutolock locker(sLock);
 466
 467         UndoItem* undoItem = sUndoList.FirstItem();
 468         if (undoItem == NULL)
 469                 return;
 470
 471         undoItem->Undo();
 472                 // ToDo: evaluate return code
 473
 474         sUndoList.RemoveItem(undoItem);
 475
 476         if (sRedoList.CountItems() == kUndoRedoListMaxCount)
 477                 sRedoList.RemoveItem(sRedoList.LastItem());
 478
 479         sRedoList.AddItem(undoItem, 0);
 480 }
 481
 482
 483 void
 484 FSRedo()
 485 {
 486         BAutolock locker(sLock);
 487
 488         UndoItem* undoItem = sRedoList.FirstItem();
 489         if (undoItem == NULL)
 490                 return;
 491
 492         undoItem->Redo();
 493                 // ToDo: evaluate return code
 494
 495         sRedoList.RemoveItem(undoItem);
 496
 497         if (sUndoList.CountItems() == kUndoRedoListMaxCount)
 498                 sUndoList.RemoveItem(sUndoList.LastItem());
 499
 500         sUndoList.AddItem(undoItem, 0);
 501 }
 502
 503 }       // namespace BPrivate