Differential D17441 Diff 47157 src/buffer/katetextblock.cpp

Changeset View

Standalone View

View Options

src/buffer/katetextblock.cpp

Show First 20 Lines • Show All 144 Lines • ▼ Show 20 Line(s)92{
145 145​
146 // no cursors in this block, no work to do.. 146​ // no cursors in this block, no work to do..
147 if (m_cursors.empty()) { 147​ if (m_cursors.empty()) {
148 return; 148​ return;
149 } 149​ }
150 150​
151 // move all cursors on the line which has the text inserted 151​ // move all cursors on the line which has the text inserted
152 // remember all ranges modified 152​ // remember all ranges modified
153 QSet<TextRange *> changedRanges; 153​ std::vector<TextRange *> changedRanges;
anthonyfieroniUnsubmitted
Done

You can use unordered_set, so you don't need m_isCheckValidityRequired any more. It can be applied to other places as well.

anthonyfieroni: You can use unordered_set, so you don't need m_isCheckValidityRequired any more. It can be…
cullmannAuthorUnsubmitted
Done

Actually no, that will be again a lot more expensive.
With the vector, you get one allocation in many cases, with unordered_set a lot, like with QSet.
But I tend to move that to QVarLengthArray to avoid allocations at all for the normal case of << 32 cursors.

cullmann: Actually no, that will be again a lot more expensive. With the vector, you get one allocation…
154 foreach (TextCursor *cursor, m_cursors) { 154​ foreach (TextCursor *cursor, m_cursors) {
155 // skip cursors on lines in front of the wrapped one! 155​ // skip cursors on lines in front of the wrapped one!
156 if (cursor->lineInBlock() < line) { 156​ if (cursor->lineInBlock() < line) {
157 continue; 157​ continue;
158 } 158​ }
159 159​
160 // either this is simple, line behind the wrapped one 160​ // either this is simple, line behind the wrapped one
161 if (cursor->lineInBlock() > line) { 161​ if (cursor->lineInBlock() > line) {
Show All 16 Lines167 else {
178 cursor->m_line++; 178​ cursor->m_line++;
179 179​
180 // patch column 180​ // patch column
181 cursor->m_column -= position.column(); 181​ cursor->m_column -= position.column();
182 } 182​ }
183 183​
184 // remember range, if any 184​ // remember range, if any
185 if (cursor->kateRange()) { 185​ if (cursor->kateRange()) {
186 changedRanges.insert(cursor->kateRange()); 186​ cursor->kateRange()->m_isCheckValidityRequired = true;
187​ changedRanges.push_back(cursor->kateRange());
187 } 188​ }
188 } 189​ }
189 190​
190 // check validity of all ranges, might invalidate them... 191​ // we might need to invalidate ranges or notify about their changes
191 foreach (TextRange *range, changedRanges) { 192​ for (TextRange *range : changedRanges) {
193​ if (range->m_isCheckValidityRequired) {
192 range->checkValidity(); 194​ range->checkValidity();
195​ range->m_isCheckValidityRequired = false;
196​ }
193 } 197​ }
194} 198​}
195 199​
196void TextBlock::unwrapLine(int line, TextBlock *previousBlock, int fixStartLinesStartIndex) 200​void TextBlock::unwrapLine(int line, TextBlock *previousBlock, int fixStartLinesStartIndex)
197{ 201​{
198 // calc internal line 202​ // calc internal line
199 line = line - startLine(); 203​ line = line - startLine();
200 204​
Show All 40 Lines206 if (line == 0) {
241 245​
242 // no cursors in this block and the previous one, no work to do.. 246​ // no cursors in this block and the previous one, no work to do..
243 if (m_cursors.empty() && previousBlock->m_cursors.empty()) { 247​ if (m_cursors.empty() && previousBlock->m_cursors.empty()) {
244 return; 248​ return;
245 } 249​ }
246 250​
247 // move all cursors because of the unwrapped line 251​ // move all cursors because of the unwrapped line
248 // remember all ranges modified 252​ // remember all ranges modified
249 QSet<TextRange *> changedRanges; 253​ std::vector<TextRange *> changedRanges;
250 foreach (TextCursor *cursor, m_cursors) { 254​ foreach (TextCursor *cursor, m_cursors) {
251 // this is the unwrapped line 255​ // this is the unwrapped line
252 if (cursor->lineInBlock() == 0) { 256​ if (cursor->lineInBlock() == 0) {
253 // patch column 257​ // patch column
254 cursor->m_column += oldSizeOfPreviousLine; 258​ cursor->m_column += oldSizeOfPreviousLine;
255 259​
256 // remember range, if any 260​ // remember range, if any
257 if (cursor->kateRange()) { 261​ if (cursor->kateRange()) {
258 changedRanges.insert(cursor->kateRange()); 262​ cursor->kateRange()->m_isCheckValidityRequired = true;
263​ changedRanges.push_back(cursor->kateRange());
259 } 264​ }
260 } 265​ }
261 } 266​ }
262 267​
263 // move cursors of the moved line from previous block to this block now 268​ // move cursors of the moved line from previous block to this block now
264 QSet<TextCursor *> newPreviousCursors; 269​ QSet<TextCursor *> newPreviousCursors;
265 foreach (TextCursor *cursor, previousBlock->m_cursors) { 270​ foreach (TextCursor *cursor, previousBlock->m_cursors) {
266 if (cursor->lineInBlock() == lastLineOfPreviousBlock) { 271​ if (cursor->lineInBlock() == lastLineOfPreviousBlock) {
267 cursor->m_line = 0; 272​ cursor->m_line = 0;
268 cursor->m_block = this; 273​ cursor->m_block = this;
269 m_cursors.insert(cursor); 274​ m_cursors.insert(cursor);
270 275​
271 // remember range, if any 276​ // remember range, if any
272 if (cursor->kateRange()) { 277​ if (cursor->kateRange()) {
273 changedRanges.insert(cursor->kateRange()); 278​ cursor->kateRange()->m_isCheckValidityRequired = true;
279​ changedRanges.push_back(cursor->kateRange());
274 } 280​ }
275 } else { 281​ } else {
276 newPreviousCursors.insert(cursor); 282​ newPreviousCursors.insert(cursor);
277 } 283​ }
278 } 284​ }
279 previousBlock->m_cursors = newPreviousCursors; 285​ previousBlock->m_cursors = newPreviousCursors;
280 286​
281 // fixup the ranges that might be effected, because they moved from last line to this block 287​ // fixup the ranges that might be effected, because they moved from last line to this block
282 foreach (TextRange *range, changedRanges) { 288​ // we might need to invalidate ranges or notify about their changes
289​ for (TextRange *range : changedRanges) {
cullmannAuthorUnsubmitted
Done

This loop now crash in the unit test

./bin/bug313759

)

It works again, if I use a QSet, at that one location.
I think this is some ordering issue, funny.
Need to investigate.

cullmann: This loop now crash in the unit test ./bin/bug313759 =) It works again, if I use a QSet, at…
cullmannAuthorUnsubmitted
Done

Ok, doesn't work due to the issue that we might delete the range via notifier in checkValidity() :P

cullmann: Ok, doesn't work due to the issue that we might delete the range via notifier in checkValidity…
loh.tarUnsubmitted
Not Done

Noob question: Would QPointer help?

if (range && range->isValidityCheckRequired()) {
loh.tar: Noob question: Would QPointer help? if (range && range->isValidityCheckRequired()) {
cullmannAuthorUnsubmitted
Not Done

As it is no QObject, no ;=) Actually, I think all workaround might be even more expensive than the QSet.

cullmann: As it is no QObject, no ;=) Actually, I think all workaround might be even more expensive than…
290​ if (range->m_isCheckValidityRequired) {
283 // update both blocks 291​ // update both blocks
284 updateRange(range); 292​ updateRange(range);
285 previousBlock->updateRange(range); 293​ previousBlock->updateRange(range);
286 } ​
287 294​
288 // check validity of all ranges, might invalidate them... 295​ // afterwards check validity
289 foreach (TextRange *range, changedRanges) { ​
290 range->checkValidity(); 296​ range->checkValidity();
297​ range->m_isCheckValidityRequired = false;
298​ }
291 } 299​ }
292 300​
293 // be done 301​ // be done
294 return; 302​ return;
295 } 303​ }
296 304​
297 // easy: just move text to previous line and remove current one 305​ // easy: just move text to previous line and remove current one
298 const int oldSizeOfPreviousLine = m_lines.at(line - 1)->length(); 306​ const int oldSizeOfPreviousLine = m_lines.at(line - 1)->length();
Show All 29 Lines
328 336​
329 // no cursors in this block, no work to do.. 337​ // no cursors in this block, no work to do..
330 if (m_cursors.empty()) { 338​ if (m_cursors.empty()) {
331 return; 339​ return;
332 } 340​ }
333 341​
334 // move all cursors because of the unwrapped line 342​ // move all cursors because of the unwrapped line
335 // remember all ranges modified 343​ // remember all ranges modified
336 QSet<TextRange *> changedRanges; 344​ std::vector<TextRange *> changedRanges;
337 foreach (TextCursor *cursor, m_cursors) { 345​ foreach (TextCursor *cursor, m_cursors) {
338 // skip cursors in lines in front of removed one 346​ // skip cursors in lines in front of removed one
339 if (cursor->lineInBlock() < line) { 347​ if (cursor->lineInBlock() < line) {
340 continue; 348​ continue;
341 } 349​ }
342 350​
343 // this is the unwrapped line 351​ // this is the unwrapped line
344 if (cursor->lineInBlock() == line) { 352​ if (cursor->lineInBlock() == line) {
345 // patch column 353​ // patch column
346 cursor->m_column += oldSizeOfPreviousLine; 354​ cursor->m_column += oldSizeOfPreviousLine;
347 } 355​ }
348 356​
349 // patch line of cursor 357​ // patch line of cursor
350 cursor->m_line--; 358​ cursor->m_line--;
351 359​
352 // remember range, if any 360​ // remember range, if any
353 if (cursor->kateRange()) { 361​ if (cursor->kateRange()) {
354 changedRanges.insert(cursor->kateRange()); 362​ cursor->kateRange()->m_isCheckValidityRequired = true;
363​ changedRanges.push_back(cursor->kateRange());
355 } 364​ }
356 } 365​ }
357 366​
358 // check validity of all ranges, might invalidate them... 367​ // we might need to invalidate ranges or notify about their changes
359 foreach (TextRange *range, changedRanges) { 368​ for (TextRange *range : changedRanges) {
369​ if (range->m_isCheckValidityRequired) {
360 range->checkValidity(); 370​ range->checkValidity();
371​ range->m_isCheckValidityRequired = false;
372​ }
361 } 373​ }
362} 374​}
363 375​
364void TextBlock::insertText(const KTextEditor::Cursor &position, const QString &text) 376​void TextBlock::insertText(const KTextEditor::Cursor &position, const QString &text)
365{ 377​{
366 // calc internal line 378​ // calc internal line
367 int line = position.line() - startLine(); 379​ int line = position.line() - startLine();
368 380​
Show All 20 Lines
389 401​
390 // no cursors in this block, no work to do.. 402​ // no cursors in this block, no work to do..
391 if (m_cursors.empty()) { 403​ if (m_cursors.empty()) {
392 return; 404​ return;
393 } 405​ }
394 406​
395 // move all cursors on the line which has the text inserted 407​ // move all cursors on the line which has the text inserted
396 // remember all ranges modified 408​ // remember all ranges modified
397 QSet<TextRange *> changedRanges; 409​ std::vector<TextRange *> changedRanges;
398 foreach (TextCursor *cursor, m_cursors) { 410​ foreach (TextCursor *cursor, m_cursors) {
399 // skip cursors not on this line! 411​ // skip cursors not on this line!
400 if (cursor->lineInBlock() != line) { 412​ if (cursor->lineInBlock() != line) {
401 continue; 413​ continue;
402 } 414​ }
403 415​
404 // skip cursors with too small column 416​ // skip cursors with too small column
405 if (cursor->column() <= position.column()) { 417​ if (cursor->column() <= position.column()) {
406 if (cursor->column() < position.column() || !cursor->m_moveOnInsert) { 418​ if (cursor->column() < position.column() || !cursor->m_moveOnInsert) {
407 continue; 419​ continue;
408 } 420​ }
409 } 421​ }
410 422​
411 // patch column of cursor 423​ // patch column of cursor
412 if (cursor->m_column <= oldLength) { 424​ if (cursor->m_column <= oldLength) {
413 cursor->m_column += text.size(); 425​ cursor->m_column += text.size();
414 } 426​ }
415 427​
416 // special handling if cursor behind the real line, e.g. non-wrapping cursor in block selection mode 428​ // special handling if cursor behind the real line, e.g. non-wrapping cursor in block selection mode
417 else if (cursor->m_column < textOfLine.size()) { 429​ else if (cursor->m_column < textOfLine.size()) {
418 cursor->m_column = textOfLine.size(); 430​ cursor->m_column = textOfLine.size();
419 } 431​ }
420 432​
421 // remember range, if any 433​ // we only need to trigger checkValidity later if the range has feedback or might be invalidated
422 if (cursor->kateRange()) { 434​ if (cursor->kateRange() && (cursor->kateRange()->feedback() || cursor->kateRange()->start().line() == cursor->kateRange()->end().line())) {
423 changedRanges.insert(cursor->kateRange()); 435​ cursor->kateRange()->m_isCheckValidityRequired = true;
436​ changedRanges.push_back(cursor->kateRange());
424 } 437​ }
425 } 438​ }
426 439​
427 // check validity of all ranges, might invalidate them... 440​ // we might need to invalidate ranges or notify about their changes
428 foreach (TextRange *range, changedRanges) { 441​ for (TextRange *range : changedRanges) {
442​ if (range->m_isCheckValidityRequired) {
429 range->checkValidity(); 443​ range->checkValidity();
444​ range->m_isCheckValidityRequired = false;
445​ }
430 } 446​ }
431} 447​}
432 448​
433void TextBlock::removeText(const KTextEditor::Range &range, QString &removedText) 449​void TextBlock::removeText(const KTextEditor::Range &range, QString &removedText)
434{ 450​{
435 // calc internal line 451​ // calc internal line
436 int line = range.start().line() - startLine(); 452​ int line = range.start().line() - startLine();
437 453​
Show All 25 Lines
463 479​
464 // no cursors in this block, no work to do.. 480​ // no cursors in this block, no work to do..
465 if (m_cursors.empty()) { 481​ if (m_cursors.empty()) {
466 return; 482​ return;
467 } 483​ }
468 484​
469 // move all cursors on the line which has the text removed 485​ // move all cursors on the line which has the text removed
470 // remember all ranges modified 486​ // remember all ranges modified
471 QSet<TextRange *> changedRanges; 487​ std::vector<TextRange *> changedRanges;
472 foreach (TextCursor *cursor, m_cursors) { 488​ foreach (TextCursor *cursor, m_cursors) {
473 // skip cursors not on this line! 489​ // skip cursors not on this line!
474 if (cursor->lineInBlock() != line) { 490​ if (cursor->lineInBlock() != line) {
475 continue; 491​ continue;
476 } 492​ }
477 493​
478 // skip cursors with too small column 494​ // skip cursors with too small column
479 if (cursor->column() <= range.start().column()) { 495​ if (cursor->column() <= range.start().column()) {
480 continue; 496​ continue;
481 } 497​ }
482 498​
483 // patch column of cursor 499​ // patch column of cursor
484 if (cursor->column() <= range.end().column()) { 500​ if (cursor->column() <= range.end().column()) {
485 cursor->m_column = range.start().column(); 501​ cursor->m_column = range.start().column();
486 } else { 502​ } else {
487 cursor->m_column -= (range.end().column() - range.start().column()); 503​ cursor->m_column -= (range.end().column() - range.start().column());
488 } 504​ }
489 505​
490 // remember range, if any 506​ // we only need to trigger checkValidity later if the range has feedback or might be invalidated
491 if (cursor->kateRange()) { 507​ if (cursor->kateRange() && (cursor->kateRange()->feedback() || cursor->kateRange()->start().line() == cursor->kateRange()->end().line())) {
492 changedRanges.insert(cursor->kateRange()); 508​ cursor->kateRange()->m_isCheckValidityRequired = true;
509​ changedRanges.push_back(cursor->kateRange());
493 } 510​ }
494 } 511​ }
495 512​
496 // check validity of all ranges, might invalidate them... 513​ // we might need to invalidate ranges or notify about their changes
497 foreach (TextRange *range, changedRanges) { 514​ for (TextRange *range : changedRanges) {
515​ if (range->m_isCheckValidityRequired) {
498 range->checkValidity(); 516​ range->checkValidity();
517​ range->m_isCheckValidityRequired = false;
518​ }
499 } 519​ }
500} 520​}
501 521​
502void TextBlock::debugPrint(int blockIndex) const 522​void TextBlock::debugPrint(int blockIndex) const
503{ 523​{
504 // print all blocks 524​ // print all blocks
505 for (int i = 0; i < m_lines.size(); ++i) 525​ for (int i = 0; i < m_lines.size(); ++i)
506 printf("%4d - %4d : %4d : '%s'\n", blockIndex, startLine() + i 526​ printf("%4d - %4d : %4d : '%s'\n", blockIndex, startLine() + i
▲ Show 20 Lines • Show All 219 Lines • Show Last 20 Lines