1 /* 2 * Copyright 2003-2008, Haiku, Inc. All Rights Reserved. 3 * Distributed under the terms of the MIT License. 4 * 5 * Authors: 6 * Stefano Ceccherini (burton666@libero.it) 7 */ 8 9 //! UndoBuffer and its subclasses handle different types of Undo operations. 10 11 12 #include "UndoBuffer.h" 13 #include "utf8_functions.h" 14 15 #include <Clipboard.h> 16 17 #include <stdio.h> 18 #include <stdlib.h> 19 #include <string.h> 20 21 22 // TODO: properly document this file 23 24 25 // #pragma mark - UndoBuffer 26 27 28 BTextView::UndoBuffer::UndoBuffer(BTextView* textView, undo_state state) 29 : 30 fTextView(textView), 31 fTextData(NULL), 32 fRunArray(NULL), 33 fRunArrayLength(0), 34 fRedo(false), 35 fState(state) 36 { 37 fTextView->GetSelection(&fStart, &fEnd); 38 fTextLength = fEnd - fStart; 39 40 fTextData = (char*)malloc(fTextLength); 41 memcpy(fTextData, fTextView->Text() + fStart, fTextLength); 42 43 if (fTextView->IsStylable()) 44 fRunArray = fTextView->RunArray(fStart, fEnd, &fRunArrayLength); 45 } 46 47 48 BTextView::UndoBuffer::~UndoBuffer() 49 { 50 free(fTextData); 51 BTextView::FreeRunArray(fRunArray); 52 } 53 54 55 void 56 BTextView::UndoBuffer::Undo(BClipboard* clipboard) 57 { 58 fRedo ? RedoSelf(clipboard) : UndoSelf(clipboard); 59 60 fRedo = !fRedo; 61 } 62 63 64 undo_state 65 BTextView::UndoBuffer::State(bool* _isRedo) const 66 { 67 *_isRedo = fRedo; 68 69 return fState; 70 } 71 72 73 void 74 BTextView::UndoBuffer::UndoSelf(BClipboard* clipboard) 75 { 76 fTextView->Select(fStart, fStart); 77 fTextView->Insert(fTextData, fTextLength, fRunArray); 78 fTextView->Select(fStart, fStart); 79 } 80 81 82 void 83 BTextView::UndoBuffer::RedoSelf(BClipboard* clipboard) 84 { 85 } 86 87 88 // #pragma mark - CutUndoBuffer 89 90 91 BTextView::CutUndoBuffer::CutUndoBuffer(BTextView* textView) 92 : BTextView::UndoBuffer(textView, B_UNDO_CUT) 93 { 94 } 95 96 97 BTextView::CutUndoBuffer::~CutUndoBuffer() 98 { 99 } 100 101 102 void 103 BTextView::CutUndoBuffer::RedoSelf(BClipboard* clipboard) 104 { 105 BMessage* clip = NULL; 106 107 fTextView->Select(fStart, fStart); 108 fTextView->Delete(fStart, fEnd); 109 if (clipboard->Lock()) { 110 clipboard->Clear(); 111 if ((clip = clipboard->Data())) { 112 clip->AddData("text/plain", B_MIME_TYPE, fTextData, fTextLength); 113 if (fRunArray) 114 clip->AddData("application/x-vnd.Be-text_run_array", 115 B_MIME_TYPE, fRunArray, fRunArrayLength); 116 clipboard->Commit(); 117 } 118 clipboard->Unlock(); 119 } 120 } 121 122 123 // #pragma mark - PasteUndoBuffer 124 125 126 BTextView::PasteUndoBuffer::PasteUndoBuffer(BTextView* textView, 127 const char* text, int32 textLen, text_run_array* runArray, 128 int32 runArrayLen) 129 : BTextView::UndoBuffer(textView, B_UNDO_PASTE), 130 fPasteText(NULL), 131 fPasteTextLength(textLen), 132 fPasteRunArray(NULL) 133 { 134 fPasteText = (char*)malloc(fPasteTextLength); 135 memcpy(fPasteText, text, fPasteTextLength); 136 137 if (runArray) 138 fPasteRunArray = BTextView::CopyRunArray(runArray); 139 } 140 141 142 BTextView::PasteUndoBuffer::~PasteUndoBuffer() 143 { 144 free(fPasteText); 145 BTextView::FreeRunArray(fPasteRunArray); 146 } 147 148 149 void 150 BTextView::PasteUndoBuffer::UndoSelf(BClipboard* clipboard) 151 { 152 fTextView->Select(fStart, fStart); 153 fTextView->Delete(fStart, fStart + fPasteTextLength); 154 fTextView->Insert(fTextData, fTextLength, fRunArray); 155 fTextView->Select(fStart, fEnd); 156 } 157 158 159 void 160 BTextView::PasteUndoBuffer::RedoSelf(BClipboard* clipboard) 161 { 162 fTextView->Select(fStart, fStart); 163 fTextView->Delete(fStart, fEnd); 164 fTextView->Insert(fPasteText, fPasteTextLength, fPasteRunArray); 165 fTextView->Select(fStart + fPasteTextLength, fStart + fPasteTextLength); 166 } 167 168 169 // #pragma mark - ClearUndoBuffer 170 171 172 BTextView::ClearUndoBuffer::ClearUndoBuffer(BTextView* textView) 173 : BTextView::UndoBuffer(textView, B_UNDO_CLEAR) 174 { 175 } 176 177 178 BTextView::ClearUndoBuffer::~ClearUndoBuffer() 179 { 180 } 181 182 183 void 184 BTextView::ClearUndoBuffer::RedoSelf(BClipboard* clipboard) 185 { 186 fTextView->Select(fStart, fStart); 187 fTextView->Delete(fStart, fEnd); 188 } 189 190 191 // #pragma mark - DropUndoBuffer 192 193 194 BTextView::DropUndoBuffer::DropUndoBuffer(BTextView* textView, 195 char const* text, int32 textLen, text_run_array* runArray, 196 int32 runArrayLen, int32 location, bool internalDrop) 197 : BTextView::UndoBuffer(textView, B_UNDO_DROP), 198 fDropText(NULL), 199 fDropTextLength(textLen), 200 fDropRunArray(NULL) 201 { 202 fInternalDrop = internalDrop; 203 fDropLocation = location; 204 205 fDropText = (char*)malloc(fDropTextLength); 206 memcpy(fDropText, text, fDropTextLength); 207 208 if (runArray) 209 fDropRunArray = BTextView::CopyRunArray(runArray); 210 211 if (fInternalDrop && fDropLocation >= fEnd) 212 fDropLocation -= fDropTextLength; 213 } 214 215 216 BTextView::DropUndoBuffer::~DropUndoBuffer() 217 { 218 free(fDropText); 219 BTextView::FreeRunArray(fDropRunArray); 220 } 221 222 223 void 224 BTextView::DropUndoBuffer::UndoSelf(BClipboard* ) 225 { 226 fTextView->Select(fDropLocation, fDropLocation); 227 fTextView->Delete(fDropLocation, fDropLocation + fDropTextLength); 228 if (fInternalDrop) { 229 fTextView->Select(fStart, fStart); 230 fTextView->Insert(fTextData, fTextLength, fRunArray); 231 } 232 fTextView->Select(fStart, fEnd); 233 } 234 235 236 void 237 BTextView::DropUndoBuffer::RedoSelf(BClipboard* ) 238 { 239 if (fInternalDrop) { 240 fTextView->Select(fStart, fStart); 241 fTextView->Delete(fStart, fEnd); 242 } 243 fTextView->Select(fDropLocation, fDropLocation); 244 fTextView->Insert(fDropText, fDropTextLength, fDropRunArray); 245 fTextView->Select(fDropLocation, fDropLocation + fDropTextLength); 246 } 247 248 249 // #pragma mark - TypingUndoBuffer 250 251 252 BTextView::TypingUndoBuffer::TypingUndoBuffer(BTextView* textView) 253 : BTextView::UndoBuffer(textView, B_UNDO_TYPING), 254 fTypedText(NULL), 255 fTypedStart(fStart), 256 fTypedEnd(fEnd), 257 fUndone(0) 258 { 259 } 260 261 262 BTextView::TypingUndoBuffer::~TypingUndoBuffer() 263 { 264 free(fTypedText); 265 } 266 267 268 void 269 BTextView::TypingUndoBuffer::UndoSelf(BClipboard* clipboard) 270 { 271 int32 len = fTypedEnd - fTypedStart; 272 273 free(fTypedText); 274 fTypedText = NULL; 275 fTypedText = (char*)malloc(len); 276 memcpy(fTypedText, fTextView->Text() + fTypedStart, len); 277 278 fTextView->Select(fTypedStart, fTypedStart); 279 fTextView->Delete(fTypedStart, fTypedEnd); 280 fTextView->Insert(fTextData, fTextLength); 281 fTextView->Select(fStart, fEnd); 282 fUndone++; 283 } 284 285 286 void 287 BTextView::TypingUndoBuffer::RedoSelf(BClipboard* clipboard) 288 { 289 fTextView->Select(fTypedStart, fTypedStart); 290 fTextView->Delete(fTypedStart, fTypedStart + fTextLength); 291 fTextView->Insert(fTypedText, fTypedEnd - fTypedStart); 292 fUndone--; 293 } 294 295 296 void 297 BTextView::TypingUndoBuffer::InputCharacter(int32 len) 298 { 299 int32 start, end; 300 fTextView->GetSelection(&start, &end); 301 302 if (start != fTypedEnd || end != fTypedEnd) 303 _Reset(); 304 305 fTypedEnd += len; 306 } 307 308 309 void 310 BTextView::TypingUndoBuffer::_Reset() 311 { 312 free(fTextData); 313 fTextView->GetSelection(&fStart, &fEnd); 314 fTextLength = fEnd - fStart; 315 fTypedStart = fStart; 316 fTypedEnd = fStart; 317 318 fTextData = (char*)malloc(fTextLength); 319 memcpy(fTextData, fTextView->Text() + fStart, fTextLength); 320 321 free(fTypedText); 322 fTypedText = NULL; 323 fRedo = false; 324 fUndone = 0; 325 } 326 327 328 void 329 BTextView::TypingUndoBuffer::BackwardErase() 330 { 331 int32 start, end; 332 fTextView->GetSelection(&start, &end); 333 334 const char* text = fTextView->Text(); 335 int32 charLen = UTF8PreviousCharLen(text + start, text); 336 337 if (start != fTypedEnd || end != fTypedEnd) { 338 _Reset(); 339 // if we've got a selection, we're already done 340 if (start != end) 341 return; 342 } 343 344 char* buffer = (char*)malloc(fTextLength + charLen); 345 memcpy(buffer + charLen, fTextData, fTextLength); 346 347 fTypedStart = start - charLen; 348 start = fTypedStart; 349 for (int32 x = 0; x < charLen; x++) 350 buffer[x] = fTextView->ByteAt(start + x); 351 free(fTextData); 352 fTextData = buffer; 353 354 fTextLength += charLen; 355 fTypedEnd -= charLen; 356 } 357 358 359 void 360 BTextView::TypingUndoBuffer::ForwardErase() 361 { 362 // TODO: Cleanup 363 int32 start, end; 364 365 fTextView->GetSelection(&start, &end); 366 367 int32 charLen = UTF8NextCharLen(fTextView->Text() + start); 368 369 if (start != fTypedEnd || end != fTypedEnd || fUndone > 0) { 370 _Reset(); 371 // if we've got a selection, we're already done 372 if (fStart == fEnd) { 373 free(fTextData); 374 fTextLength = charLen; 375 fTextData = (char*)malloc(fTextLength); 376 377 // store the erased character 378 for (int32 x = 0; x < charLen; x++) 379 fTextData[x] = fTextView->ByteAt(start + x); 380 } 381 } else { 382 // Here we need to store the erased text, so we get the text that it's 383 // already in the buffer, and we add the erased character. 384 // a realloc + memmove would maybe be cleaner, but that way we spare a 385 // copy (malloc + memcpy vs realloc + memmove). 386 387 int32 newLength = fTextLength + charLen; 388 char* buffer = (char*)malloc(newLength); 389 390 // copy the already stored data 391 memcpy(buffer, fTextData, fTextLength); 392 393 if (fTextLength < newLength) { 394 // store the erased character 395 for (int32 x = 0; x < charLen; x++) 396 buffer[fTextLength + x] = fTextView->ByteAt(start + x); 397 } 398 399 fTextLength = newLength; 400 free(fTextData); 401 fTextData = buffer; 402 } 403 } 404