File indexing completed on 2024-04-14 03:56:09

 /*
     Nested list helper
     SPDX-FileCopyrightText: 2008 Stephen Kelly <steveire@gmail.com>
 
     SPDX-License-Identifier: LGPL-2.1-or-later
 */
 
 #include "nestedlisthelper_p.h"
 
 #include <QKeyEvent>
 #include <QTextBlock>
 #include <QTextCursor>
 #include <QTextList>
 
 #include "ktextedit.h"
 
 NestedListHelper::NestedListHelper(QTextEdit *te)
     : textEdit(te)
 {
 }
 
 NestedListHelper::~NestedListHelper()
 {
 }
 
 bool NestedListHelper::handleKeyPressEvent(QKeyEvent *event)
 {
     QTextCursor cursor = textEdit->textCursor();
     if (!cursor.currentList()) {
         return false;
     }
 
     if (event->key() == Qt::Key_Backspace && !cursor.hasSelection() && cursor.atBlockStart() && canDedent()) {
         changeIndent(-1);
         return true;
     }
 
     if (event->key() == Qt::Key_Return && !cursor.hasSelection() && cursor.block().text().isEmpty() && canDedent()) {
         changeIndent(-1);
         return true;
     }
 
     if (event->key() == Qt::Key_Tab && (cursor.atBlockStart() || cursor.hasSelection()) && canIndent()) {
         changeIndent(+1);
         return true;
     }
 
     return false;
 }
 
 bool NestedListHelper::canIndent() const
 {
     const QTextCursor cursor = topOfSelection();
     const QTextBlock block = cursor.block();
     if (!block.isValid()) {
         return false;
     }
     if (!block.textList()) {
         return true;
     }
     const QTextBlock prevBlock = block.previous();
     if (!prevBlock.textList()) {
         return false;
     }
     return block.textList()->format().indent() <= prevBlock.textList()->format().indent();
 }
 
 bool NestedListHelper::canDedent() const
 {
     const QTextCursor cursor = bottomOfSelection();
     const QTextBlock block = cursor.block();
     if (!block.isValid()) {
         return false;
     }
     if (!block.textList() || block.textList()->format().indent() <= 0) {
         return false;
     }
     const QTextBlock nextBlock = block.next();
     if (!nextBlock.textList()) {
         return true;
     }
     return block.textList()->format().indent() >= nextBlock.textList()->format().indent();
 }
 
 bool NestedListHelper::handleAfterDropEvent(QDropEvent *dropEvent)
 {
     Q_UNUSED(dropEvent);
     QTextCursor cursor = topOfSelection();
 
     QTextBlock droppedBlock = cursor.block();
     int firstDroppedItemIndent = droppedBlock.textList()->format().indent();
 
     int minimumIndent = droppedBlock.previous().textList()->format().indent();
 
     if (firstDroppedItemIndent < minimumIndent) {
         cursor = QTextCursor(droppedBlock);
         QTextListFormat fmt = droppedBlock.textList()->format();
         fmt.setIndent(minimumIndent);
         QTextList *list = cursor.createList(fmt);
 
         int endOfDrop = bottomOfSelection().position();
         while (droppedBlock.next().position() < endOfDrop) {
             droppedBlock = droppedBlock.next();
             if (droppedBlock.textList()->format().indent() != firstDroppedItemIndent) {
                 // new list?
             }
             list->add(droppedBlock);
         }
         //         list.add( droppedBlock );
     }
 
     return true;
 }
 
 void NestedListHelper::processList(QTextList *list)
 {
     QTextBlock block = list->item(0);
     int thisListIndent = list->format().indent();
 
     QTextCursor cursor = QTextCursor(block);
     list = cursor.createList(list->format());
     bool processingSubList = false;
     while (block.next().textList() != nullptr) {
         block = block.next();
 
         QTextList *nextList = block.textList();
         int nextItemIndent = nextList->format().indent();
         if (nextItemIndent < thisListIndent) {
             return;
         } else if (nextItemIndent > thisListIndent) {
             if (processingSubList) {
                 continue;
             }
             processingSubList = true;
             processList(nextList);
         } else {
             processingSubList = false;
             list->add(block);
         }
     }
     //     delete nextList;
     //     nextList = 0;
 }
 
 void NestedListHelper::reformatList(QTextBlock block)
 {
     if (block.textList()) {
         int minimumIndent = block.textList()->format().indent();
 
         // Start at the top of the list
         while (block.previous().textList() != nullptr) {
             if (block.previous().textList()->format().indent() < minimumIndent) {
                 break;
             }
             block = block.previous();
         }
 
         processList(block.textList());
     }
 }
 
 void NestedListHelper::reformatList()
 {
     QTextCursor cursor = textEdit->textCursor();
     reformatList(cursor.block());
 }
 
 QTextCursor NestedListHelper::topOfSelection() const
 {
     QTextCursor cursor = textEdit->textCursor();
 
     if (cursor.hasSelection()) {
         cursor.setPosition(qMin(cursor.position(), cursor.anchor()));
     }
     return cursor;
 }
 
 QTextCursor NestedListHelper::bottomOfSelection() const
 {
     QTextCursor cursor = textEdit->textCursor();
 
     if (cursor.hasSelection()) {
         cursor.setPosition(qMax(cursor.position(), cursor.anchor()));
     }
     return cursor;
 }
 
 void NestedListHelper::changeIndent(int delta)
 {
     QTextCursor cursor = textEdit->textCursor();
     cursor.beginEditBlock();
 
     const int top = qMin(cursor.position(), cursor.anchor());
     const int bottom = qMax(cursor.position(), cursor.anchor());
 
     // A reformatList should be called on the block inside selection
     // with the lowest indentation level
     int minIndentPosition;
     int minIndent = -1;
 
     // Changing indentation of all blocks between top and bottom
     cursor.setPosition(top);
     do {
         QTextList *list = cursor.currentList();
         // Setting up listFormat
         QTextListFormat listFmt;
         if (!list) {
             if (delta > 0) {
                 // No list, we're increasing indentation -> create a new one
                 listFmt.setStyle(QTextListFormat::ListDisc);
                 listFmt.setIndent(delta);
             }
             // else do nothing
         } else {
             const int newIndent = list->format().indent() + delta;
             if (newIndent > 0) {
                 listFmt = list->format();
                 listFmt.setIndent(newIndent);
             } else {
                 listFmt.setIndent(0);
             }
         }
 
         if (listFmt.indent() > 0) {
             // This block belongs to a list: here we create a new one
             // for each block, and then let reformatList() sort it out
             cursor.createList(listFmt);
             if (minIndent == -1 || minIndent > listFmt.indent()) {
                 minIndent = listFmt.indent();
                 minIndentPosition = cursor.block().position();
             }
         } else {
             // If the block belonged to a list, remove it from there
             if (list) {
                 list->remove(cursor.block());
             }
             // The removal does not change the indentation, we need to do it explicitly
             QTextBlockFormat blkFmt;
             blkFmt.setIndent(0);
             cursor.mergeBlockFormat(blkFmt);
         }
         if (!cursor.block().next().isValid()) {
             break;
         }
         cursor.movePosition(QTextCursor::NextBlock);
     } while (cursor.position() < bottom);
     // Reformatting the whole list
     if (minIndent != -1) {
         cursor.setPosition(minIndentPosition);
         reformatList(cursor.block());
     }
     cursor.setPosition(top);
     reformatList(cursor.block());
     cursor.endEditBlock();
 }
 
 void NestedListHelper::handleOnBulletType(int styleIndex)
 {
     QTextCursor cursor = textEdit->textCursor();
     if (styleIndex != 0) {
         QTextListFormat::Style style = static_cast<QTextListFormat::Style>(styleIndex);
         QTextList *currentList = cursor.currentList();
         QTextListFormat listFmt;
 
         cursor.beginEditBlock();
 
         if (currentList) {
             listFmt = currentList->format();
             listFmt.setStyle(style);
             currentList->setFormat(listFmt);
         } else {
             listFmt.setStyle(style);
             cursor.createList(listFmt);
         }
 
         cursor.endEditBlock();
     } else {
         QTextBlockFormat bfmt;
         bfmt.setObjectIndex(-1);
         cursor.setBlockFormat(bfmt);
     }
 
     reformatList();
 }