diff --git a/src/basketscene.cpp b/src/basketscene.cpp
index 72dac55..a43874a 100644
--- a/src/basketscene.cpp
+++ b/src/basketscene.cpp
@@ -1,5062 +1,5065 @@
 /**
  * SPDX-FileCopyrightText: (C) 2003 by Sébastien Laoût <slaout@linux62.org>
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "basketscene.h"
 
 #include <QApplication>
 #include <QFileDialog>
 #include <QFrame>
 #include <QGraphicsProxyWidget>
 #include <QGridLayout>
 #include <QInputDialog>
 #include <QLabel>
 #include <QLineEdit>
 #include <QLocale>
 #include <QMenu>
 #include <QPushButton>
 #include <QSaveFile>
 #include <QScrollBar>
 #include <QToolTip>
 #include <QtCore/QDateTime> // seed for rand()
 #include <QtCore/QDir>
 #include <QtCore/QFile>
 #include <QtCore/QFileInfo>
 #include <QtCore/QList>
 #include <QtCore/QPoint>
 #include <QtCore/QStringList>
 #include <QtCore/QTimeLine>
 #include <QtGui/QAbstractTextDocumentLayout>
 #include <QtGui/QClipboard>
 #include <QtGui/QContextMenuEvent>
 #include <QtGui/QCursor>
 #include <QtGui/QDrag>
 #include <QtGui/QDragEnterEvent>
 #include <QtGui/QDragLeaveEvent>
 #include <QtGui/QDragMoveEvent>
 #include <QtGui/QDropEvent>
 #include <QtGui/QFocusEvent>
 #include <QtGui/QKeyEvent>
 #include <QtGui/QMouseEvent>
 #include <QtGui/QPainter>
 #include <QtGui/QResizeEvent>
 #include <QtGui/QTextDocument>
 #include <QtGui/QWheelEvent>
 #include <QtXml/QDomDocument>
 
 #include <KTextEdit>
 
 #include <KAboutData>
 #include <KActionCollection>
 #include <KAuthorized>
 #include <KColorScheme> // for KStatefulBrush
 #include <KDirWatch>
 #include <KGlobalAccel>
 #include <KIconLoader>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KOpenWithDialog>
 #include <KRun>
 #include <KService>
 
 #include <KIO/CopyJob>
 
 #include <stdlib.h> // rand() function
 
 #include "backgroundmanager.h"
 #include "basketview.h"
 #include "common.h"
 #include "debugwindow.h"
 #include "decoratedbasket.h"
 #include "focusedwidgets.h"
 #include "gitwrapper.h"
 #include "global.h"
 #include "note.h"
 #include "notedrag.h"
 #include "noteedit.h"
 #include "notefactory.h"
 #include "noteselection.h"
 #include "settings.h"
 #include "tagsedit.h"
 #include "tools.h"
 #include "transparentwidget.h"
 #include "xmlwork.h"
 
 #include "config.h"
 
 #ifdef HAVE_LIBGPGME
 #include "kgpgme.h"
 #endif
 
 void debugZone(int zone)
 {
     QString s;
     switch (zone) {
     case Note::Handle:
         s = "Handle";
         break;
     case Note::Group:
         s = "Group";
         break;
     case Note::TagsArrow:
         s = "TagsArrow";
         break;
     case Note::Custom0:
         s = "Custom0";
         break;
     case Note::GroupExpander:
         s = "GroupExpander";
         break;
     case Note::Content:
         s = "Content";
         break;
     case Note::Link:
         s = "Link";
         break;
     case Note::TopInsert:
         s = "TopInsert";
         break;
     case Note::TopGroup:
         s = "TopGroup";
         break;
     case Note::BottomInsert:
         s = "BottomInsert";
         break;
     case Note::BottomGroup:
         s = "BottomGroup";
         break;
     case Note::BottomColumn:
         s = "BottomColumn";
         break;
     case Note::None:
         s = "None";
         break;
     default:
         if (zone == Note::Emblem0)
             s = "Emblem0";
         else
             s = "Emblem0+" + QString::number(zone - Note::Emblem0);
         break;
     }
     qDebug() << s;
 }
 
 #define FOR_EACH_NOTE(noteVar) for (Note *noteVar = firstNote(); noteVar; noteVar = noteVar->next())
 
 
 void BasketScene::appendNoteIn(Note *note, Note *in)
 {
     if (!note)
         // No note to append:
         return;
 
     if (in) {
         // INSERT IN MODEL
         m_model.insertNote(note, in);
 
         // The normal case:
         preparePlug(note);
 
         //      Note *last = note->lastSibling();
         Note *lastChild = in->lastChild();
 
         for (Note *n = note; n; n = n->next())
             n->setParentNote(in);
         note->setPrev(lastChild);
         //      last->setNext(0L);
 
         if (!in->firstChild())
             in->setFirstChild(note);
 
         if (lastChild)
             lastChild->setNext(note);
 
         if (m_loaded)
             signalCountsChanged();
     } else
         // Prepend it directly in the basket:
         appendNoteAfter(note, lastNote());
 }
 
 void BasketScene::appendNoteAfter(Note *note, Note *after)
 {
     if (!note)
         // No note to append:
         return;
 
     if (!after)
         // By default, insert after the last note:
         after = lastNote();
 
     if (m_loaded && after && !after->isFree() && !after->isColumn())
         for (Note *n = note; n; n = n->next())
             n->inheritTagsOf(after);
 
     // INSERT IN MODEL
-    m_model.insertNote(note, after? after->parentNote() : nullptr);
+    // m_model.insertNote(note, after? after->parentNote() : nullptr);
 
     //  if (!alreadyInBasket)
     preparePlug(note);
 
     Note *last = note->lastSibling();
     if (after) {
         // The normal case:
         for (Note *n = note; n; n = n->next())
             n->setParentNote(after->parentNote());
         note->setPrev(after);
         last->setNext(after->next());
         after->setNext(note);
         if (last->next())
             last->next()->setPrev(last);
     } else {
         // There is no note in the basket:
         for (Note *n = note; n; n = n->next())
             n->setParentNote(nullptr);
         m_firstNote = note;
         //      note->setPrev(0);
         //      last->setNext(0);
     }
 
     //  if (!alreadyInBasket)
     if (m_loaded)
         signalCountsChanged();
 }
 
 void BasketScene::appendNoteBefore(Note *note, Note *before)
 {
     if (!note)
         // No note to append:
         return;
 
     if (!before)
         // By default, insert before the first note:
         before = firstNote();
 
     if (m_loaded && before && !before->isFree() && !before->isColumn())
         for (Note *n = note; n; n = n->next())
             n->inheritTagsOf(before);
 
     // INSERT IN MODEL
-    m_model.insertNote(note, before? before->parentNote() : nullptr, 0);
+    // m_model.insertNote(note, before? before->parentNote() : nullptr, 0);
 
     preparePlug(note);
 
     Note *last = note->lastSibling();
     if (before) {
         // The normal case:
         for (Note *n = note; n; n = n->next())
             n->setParentNote(before->parentNote());
         note->setPrev(before->prev());
         last->setNext(before);
         before->setPrev(last);
         if (note->prev())
             note->prev()->setNext(note);
         else {
             if (note->parentNote())
                 note->parentNote()->setFirstChild(note);
             else
                 m_firstNote = note;
         }
     } else {
         // There is no note in the basket:
         for (Note *n = note; n; n = n->next())
             n->setParentNote(nullptr);
         m_firstNote = note;
         //      note->setPrev(0);
         //      last->setNext(0);
     }
 
     if (m_loaded)
         signalCountsChanged();
 }
 
 DecoratedBasket *BasketScene::decoration()
 {
     return (DecoratedBasket *)parent();
 }
 
 void BasketScene::preparePlug(Note *note)
 {
     // Select only the new notes, compute the new notes count and the new number of found notes:
     if (m_loaded)
         unselectAll();
     int count = 0;
     int founds = 0;
     Note *last = nullptr;
     for (Note *n = note; n; n = n->next()) {
         if (m_loaded)
             n->setSelectedRecursively(true); // Notes should have a parent basket (and they have, so that's OK).
         count += n->count();
         founds += n->newFilter(decoration()->filterData());
         last = n;
     }
     m_count += count;
     m_countFounds += founds;
 
     // Focus the last inserted note:
     if (m_loaded && last) {
         setFocusedNote(last);
         m_startOfShiftSelectionNote = (last->isGroup() ? last->lastRealChild() : last);
     }
 
     // If some notes don't match (are hidden), tell it to the user:
     if (m_loaded && founds < count) {
         if (count == 1) {
             Q_EMIT postMessage(i18n("The new note does not match the filter and is hidden."));
         } else if (founds == count - 1) {
             Q_EMIT postMessage(i18n("A new note does not match the filter and is hidden."));
         } else if (founds > 0) {
             Q_EMIT postMessage(i18n("Some new notes do not match the filter and are hidden."));
         } else {
             Q_EMIT postMessage(i18n("The new notes do not match the filter and are hidden."));
         }
     }
 }
 
 void BasketScene::unplugNote(Note *note)
 {
     // If there is nothing to do...
     if (!note)
         return;
 
     //  if (!willBeReplugged) {
     note->setSelectedRecursively(false); // To removeSelectedNote() and decrease the selectedsCount.
     m_count -= note->count();
     m_countFounds -= note->newFilter(decoration()->filterData());
     signalCountsChanged();
     //  }
 
     // If it was the first note, change the first note:
     if (m_firstNote == note)
         m_firstNote = note->next();
 
     // Change previous and next notes:
     if (note->prev())
         note->prev()->setNext(note->next());
     if (note->next())
         note->next()->setPrev(note->prev());
 
     if (note->parentNote()) {
         // If it was the first note of a group, change the first note of the group:
         if (note->parentNote()->firstChild() == note)
             note->parentNote()->setFirstChild(note->next());
 
         if (!note->parentNote()->isColumn()) {
             // Delete parent if now 0 notes inside parent group:
             if (!note->parentNote()->firstChild()) {
                 unplugNote(note->parentNote());
                 // a group could call this method for one or more of its children,
                 // each children could call this method for its parent's group...
                 // we have to do the deletion later otherwise we may corrupt the current process
                 m_notesToBeDeleted << note;
                 if (m_notesToBeDeleted.count() == 1) {
                     QTimer::singleShot(0, this, SLOT(doCleanUp()));
                 }
             }
             // Ungroup if still 1 note inside parent group:
             else if (!note->parentNote()->firstChild()->next()) {
                 ungroupNote(note->parentNote());
             }
         }
     }
 
     note->setParentNote(nullptr);
     note->setPrev(nullptr);
     note->setNext(nullptr);
 
     // Reste focus and hover note if necessary
     if (m_focusedNote == note)
         m_focusedNote = nullptr;
     if (m_hoveredNote == note)
         m_hoveredNote = nullptr;
 
     //  recomputeBlankRects(); // FIXME: called too much time. It's here because when dragging and moving a note to another basket and then go back to the original basket, the note is deleted but the note rect is not painter anymore.
 }
 
 void BasketScene::ungroupNote(Note *group)
 {
     Note *note = group->firstChild();
     Note *lastGroupedNote = group;
     Note *nextNote;
 
     // Move all notes after the group (not before, to avoid to change m_firstNote or group->m_firstChild):
     while (note) {
         nextNote = note->next();
 
-        m_model.moveNoteTo(note, group->parentNote());
+        //m_model.moveNoteTo(note, group->parentNote());
 
         if (lastGroupedNote->next())
             lastGroupedNote->next()->setPrev(note);
         note->setNext(lastGroupedNote->next());
         lastGroupedNote->setNext(note);
         note->setParentNote(group->parentNote());
         note->setPrev(lastGroupedNote);
 
         note->setGroupWidth(group->groupWidth() - Note::GROUP_WIDTH);
         lastGroupedNote = note;
         note = nextNote;
     }
 
     // Unplug the group:
     group->setFirstChild(nullptr);
     unplugNote(group);
     // a group could call this method for one or more of its children,
     // each children could call this method for its parent's group...
     // we have to do the deletion later otherwise we may corrupt the current process
     m_notesToBeDeleted << group;
     if (m_notesToBeDeleted.count() == 1) {
         QTimer::singleShot(0, this, SLOT(doCleanUp()));
     }
 }
 
 void BasketScene::groupNoteBefore(Note *note, Note *with)
 {
     if (!note || !with)
         // No note to group or nowhere to group it:
         return;
 
     //  if (m_loaded && before && !with->isFree() && !with->isColumn())
     for (Note *n = note; n; n = n->next())
         n->inheritTagsOf(with);
 
     preparePlug(note);
 
     Note *last = note->lastSibling();
 
     Note *group = new Note(this);
-    m_model.insertNote(group, with->parentNote(), 0);
+    //m_model.insertNote(group, with->parentNote(), 0);
 
     group->setPrev(with->prev());
     group->setNext(with->next());
     group->setX(with->x());
     group->setY(with->y());
     if (with->parentNote() && with->parentNote()->firstChild() == with)
         with->parentNote()->setFirstChild(group);
     else if (m_firstNote == with)
         m_firstNote = group;
     group->setParentNote(with->parentNote());
     group->setFirstChild(note);
     group->setGroupWidth(with->groupWidth() + Note::GROUP_WIDTH);
 
     if (with->prev())
         with->prev()->setNext(group);
     if (with->next())
         with->next()->setPrev(group);
     with->setParentNote(group);
     with->setPrev(last);
     with->setNext(nullptr);
 
     for (Note *n = note; n; n = n->next()) {
-        m_model.moveNoteTo(n, group);
+        //m_model.moveNoteTo(n, group);
         n->setParentNote(group);
     }
     //  note->setPrev(0L);
     last->setNext(with);
-    m_model.moveNoteTo(with, group);
+    //m_model.moveNoteTo(with, group);
 
     if (m_loaded)
         signalCountsChanged();
 }
 
 void BasketScene::groupNoteAfter(Note *note, Note *with)
 {
     if (!note || !with)
         // No note to group or nowhere to group it:
         return;
 
     //  if (m_loaded && before && !with->isFree() && !with->isColumn())
     for (Note *n = note; n; n = n->next())
         n->inheritTagsOf(with);
 
     preparePlug(note);
 
     //  Note *last = note->lastSibling();
 
     Note *group = new Note(this);
-    m_model.insertNote(group, with->parentNote());
+    //m_model.insertNote(group, with->parentNote());
 
     group->setPrev(with->prev());
     group->setNext(with->next());
     group->setX(with->x());
     group->setY(with->y());
     if (with->parentNote() && with->parentNote()->firstChild() == with)
         with->parentNote()->setFirstChild(group);
     else if (m_firstNote == with)
         m_firstNote = group;
     group->setParentNote(with->parentNote());
     group->setFirstChild(with);
     group->setGroupWidth(with->groupWidth() + Note::GROUP_WIDTH);
 
     if (with->prev())
         with->prev()->setNext(group);
     if (with->next())
         with->next()->setPrev(group);
     with->setParentNote(group);
     with->setPrev(nullptr);
     with->setNext(note);
 
     for (Note *n = note; n; n = n->next()) {
-        m_model.moveNoteTo(n, group);
+        //m_model.moveNoteTo(n, group);
         n->setParentNote(group);
     }
     note->setPrev(with);
     //  last->setNext(0L);
-    m_model.moveNoteTo(with, group, 0);
+    //m_model.moveNoteTo(with, group, 0);
 
     if (m_loaded)
         signalCountsChanged();
 }
 
 void BasketScene::doCleanUp()
 {
     QSet<Note *>::iterator it = m_notesToBeDeleted.begin();
     while (it != m_notesToBeDeleted.end()) {
         delete *it;
         it = m_notesToBeDeleted.erase(it);
     }
 }
 
 void BasketScene::loadNotes(const QDomElement &notes, Note *parent)
 {
     Note *note;
     for (QDomNode n = notes.firstChild(); !n.isNull(); n = n.nextSibling()) {
         QDomElement e = n.toElement();
         if (e.isNull()) // Cannot handle that!
             continue;
         note = nullptr;
         // Load a Group:
         if (e.tagName() == "group") {
             note = new Note(this); // 1. Create the group...
             // MODEL -> Because Group is inserted later, child nodes cannot find it's parent :(
             //  So we insert the group before the childre
             //  (insertNote is protected anyway against double insertions)
-            m_model.insertNote(note, parent);
+            //m_model.insertNote(note, parent);
             loadNotes(e, note);    // 3. ... And populate it with child notes.
             int noteCount = note->count();
             if (noteCount > 0 || (parent == nullptr && !isFreeLayout())) { // But don't remove columns!
                 appendNoteIn(note, parent);                                // 2. ... Insert it... FIXME: Initially, the if() the insertion was the step 2. Was it on purpose?
                 // The notes in the group are counted two times (it's why appendNoteIn() was called before loadNotes):
                 m_count -= noteCount; // TODO: Recompute note count every time noteCount() is emitted!
                 m_countFounds -= noteCount;
             }
         }
         // Load a Content-Based Note:
         if (e.tagName() == "note" || e.tagName() == "item") {                                                                          // Keep compatible with 0.6.0 Alpha 1
             note = new Note(this);                                                                                                     // Create the note...
             NoteFactory::loadNode(XMLWork::getElement(e, "content"), e.attribute("type"), note, /*lazyLoad=*/m_finishLoadOnFirstShow); // ... Populate it with content...
             if (e.attribute("type") == "text")
                 m_shouldConvertPlainTextNotes = true; // Convert Pre-0.6.0 baskets: plain text notes should be converted to rich text ones once all is loaded!
             appendNoteIn(note, parent);               // ... And insert it.
             // Load dates:
             if (e.hasAttribute("added"))
                 note->setAddedDate(QDateTime::fromString(e.attribute("added"), Qt::ISODate));
             if (e.hasAttribute("lastModification"))
                 note->setLastModificationDate(QDateTime::fromString(e.attribute("lastModification"), Qt::ISODate));
         }
         // If we successfully loaded a note:
         if (note) {
             // Free Note Properties:
             if (note->isFree()) {
                 int x = e.attribute("x").toInt();
                 int y = e.attribute("y").toInt();
                 note->setX(x < 0 ? 0 : x);
                 note->setY(y < 0 ? 0 : y);
             }
             // Resizeable Note Properties:
             if (note->hasResizer() || note->isColumn())
                 note->setGroupWidth(e.attribute("width", "200").toInt());
             // Group Properties:
             if (note->isGroup() && !note->isColumn() && XMLWork::trueOrFalse(e.attribute("folded", "false")))
                 note->toggleFolded();
             // Tags:
             if (note->content()) {
                 QString tagsString = XMLWork::getElementText(e, QStringLiteral("tags"), QString());
                 QStringList tagsId = tagsString.split(';');
                 for (QStringList::iterator it = tagsId.begin(); it != tagsId.end(); ++it) {
                     State *state = Tag::stateForId(*it);
                     if (state)
                         note->addState(state, /*orReplace=*/true);
                 }
             }
         }
         qApp->processEvents();
     }
 }
 
 void BasketScene::saveNotes(QXmlStreamWriter &stream, Note *parent)
 {
     Note *note = (parent ? parent->firstChild() : firstNote());
     while (note) {
         // Create Element:
         stream.writeStartElement(note->isGroup() ? "group" : "note");
         // Free Note Properties:
         if (note->isFree()) {
             stream.writeAttribute("x", QString::number(note->x()));
             stream.writeAttribute("y", QString::number(note->y()));
         }
         // Resizeable Note Properties:
         if (note->hasResizer())
             stream.writeAttribute("width", QString::number(note->groupWidth()));
         // Group Properties:
         if (note->isGroup() && !note->isColumn())
             stream.writeAttribute("folded", XMLWork::trueOrFalse(note->isFolded()));
         // Save Content:
         if (note->content()) {
             // Save Dates:
             stream.writeAttribute("added", note->addedDate().toString(Qt::ISODate));
             stream.writeAttribute("lastModification", note->lastModificationDate().toString(Qt::ISODate));
             // Save Content:
             stream.writeAttribute("type", note->content()->lowerTypeName());
             note->content()->saveToNode(stream);
             // Save Tags:
             if (note->states().count() > 0) {
                 QString tags;
                 for (State::List::iterator it = note->states().begin(); it != note->states().end(); ++it) {
                     tags += (tags.isEmpty() ? QString() : QStringLiteral(";")) + (*it)->id();
                 }
                 stream.writeTextElement("tags", tags);
             }
         } else {
             // Save Child Notes:
             saveNotes(stream, note);
         }
         stream.writeEndElement();
         // Go to the Next One:
         note = note->next();
     }
 }
 
 void BasketScene::loadProperties(const QDomElement &properties)
 {
     // Compute Default Values for When Loading the Properties:
     QString defaultBackgroundColor = (backgroundColorSetting().isValid() ? backgroundColorSetting().name() : QString());
     QString defaultTextColor = (textColorSetting().isValid() ? textColorSetting().name() : QString());
 
     // Load the Properties:
     QString icon = XMLWork::getElementText(properties, "icon", this->icon());
     QString name = XMLWork::getElementText(properties, "name", basketName());
 
     QDomElement appearance = XMLWork::getElement(properties, "appearance");
     // In 0.6.0-Alpha versions, there was a typo error: "backround" instead of "background"
     QString backgroundImage = appearance.attribute("backgroundImage", appearance.attribute("backroundImage", backgroundImageName()));
     QString backgroundColorString = appearance.attribute("backgroundColor", appearance.attribute("backroundColor", defaultBackgroundColor));
     QString textColorString = appearance.attribute("textColor", defaultTextColor);
     QColor backgroundColor = (backgroundColorString.isEmpty() ? QColor() : QColor(backgroundColorString));
     QColor textColor = (textColorString.isEmpty() ? QColor() : QColor(textColorString));
 
     QDomElement disposition = XMLWork::getElement(properties, "disposition");
     bool free = XMLWork::trueOrFalse(disposition.attribute("free", XMLWork::trueOrFalse(isFreeLayout())));
     int columnCount = disposition.attribute("columnCount", QString::number(this->columnsCount())).toInt();
     bool mindMap = XMLWork::trueOrFalse(disposition.attribute("mindMap", XMLWork::trueOrFalse(isMindMap())));
 
     QDomElement shortcut = XMLWork::getElement(properties, "shortcut");
     QString actionStrings[] = {"show", "globalShow", "globalSwitch"};
     QKeySequence combination = QKeySequence(shortcut.attribute("combination", m_action->shortcut().toString()));
     QString actionString = shortcut.attribute("action");
     int action = shortcutAction();
     if (actionString == actionStrings[0])
         action = 0;
     if (actionString == actionStrings[1])
         action = 1;
     if (actionString == actionStrings[2])
         action = 2;
 
     QDomElement protection = XMLWork::getElement(properties, "protection");
     m_encryptionType = protection.attribute("type").toInt();
     m_encryptionKey = protection.attribute("key");
 
     // Apply the Properties:
     setDisposition((free ? (mindMap ? 2 : 1) : 0), columnCount);
     setShortcut(combination, action);
     setAppearance(icon, name, backgroundImage, backgroundColor, textColor); // Will emit propertiesChanged(this)
 }
 
 void BasketScene::saveProperties(QXmlStreamWriter &stream)
 {
     stream.writeStartElement("properties");
 
     stream.writeTextElement("name", basketName());
     stream.writeTextElement("icon", icon());
 
     stream.writeStartElement("appearance");
     stream.writeAttribute("backgroundColor", backgroundColorSetting().isValid() ? backgroundColorSetting().name() : QString());
     stream.writeAttribute("backgroundImage", backgroundImageName());
     stream.writeAttribute("textColor", textColorSetting().isValid() ? textColorSetting().name() : QString());
     stream.writeEndElement();
 
     stream.writeStartElement("disposition");
     stream.writeAttribute("columnCount", QString::number(columnsCount()));
     stream.writeAttribute("free", XMLWork::trueOrFalse(isFreeLayout()));
     stream.writeAttribute("mindMap", XMLWork::trueOrFalse(isMindMap()));
     stream.writeEndElement();
 
     stream.writeStartElement("shortcut");
     QString actionStrings[] = {"show", "globalShow", "globalSwitch"};
     stream.writeAttribute("action", actionStrings[shortcutAction()]);
     stream.writeAttribute("combination", m_action->shortcut().toString());
     stream.writeEndElement();
 
     stream.writeStartElement("protection");
     stream.writeAttribute("key", m_encryptionKey);
     stream.writeAttribute("type", QString::number(m_encryptionType));
     stream.writeEndElement();
 
     stream.writeEndElement();
 }
 
 void BasketScene::subscribeBackgroundImages()
 {
     if (!m_backgroundImageName.isEmpty()) {
         Global::backgroundManager->subscribe(m_backgroundImageName);
         Global::backgroundManager->subscribe(m_backgroundImageName, this->backgroundColor());
         Global::backgroundManager->subscribe(m_backgroundImageName, selectionRectInsideColor());
         m_backgroundPixmap = Global::backgroundManager->pixmap(m_backgroundImageName);
         m_opaqueBackgroundPixmap = Global::backgroundManager->opaquePixmap(m_backgroundImageName, this->backgroundColor());
         m_selectedBackgroundPixmap = Global::backgroundManager->opaquePixmap(m_backgroundImageName, selectionRectInsideColor());
         m_backgroundTiled = Global::backgroundManager->tiled(m_backgroundImageName);
     }
 }
 
 void BasketScene::unsubscribeBackgroundImages()
 {
     if (hasBackgroundImage()) {
         Global::backgroundManager->unsubscribe(m_backgroundImageName);
         Global::backgroundManager->unsubscribe(m_backgroundImageName, this->backgroundColor());
         Global::backgroundManager->unsubscribe(m_backgroundImageName, selectionRectInsideColor());
         m_backgroundPixmap = nullptr;
         m_opaqueBackgroundPixmap = nullptr;
         m_selectedBackgroundPixmap = nullptr;
     }
 }
 
 void BasketScene::setAppearance(const QString &icon, const QString &name, const QString &backgroundImage, const QColor &backgroundColor, const QColor &textColor)
 {
     unsubscribeBackgroundImages();
 
     m_icon = icon;
     m_basketName = name;
     m_backgroundImageName = backgroundImage;
     m_backgroundColorSetting = backgroundColor;
     m_textColorSetting = textColor;
 
     // Where is this shown?
     m_action->setText("BASKET SHORTCUT: " + name);
 
     // Basket should ALWAYS have an icon (the "basket" icon by default):
     QPixmap iconTest = KIconLoader::global()->loadIcon(m_icon, KIconLoader::NoGroup, 16, KIconLoader::DefaultState, QStringList(), nullptr, /*canReturnNull=*/true);
     if (iconTest.isNull())
         m_icon = "basket";
 
     // We don't request the background images if it's not loaded yet (to make the application startup fast).
     // When the basket is loading (because requested by the user: he/she want to access it)
     // it load the properties, subscribe to (and then load) the images, update the "Loading..." message with the image,
     // load all the notes and it's done!
     if (m_loadingLaunched)
         subscribeBackgroundImages();
 
     recomputeAllStyles();  // If a note have a tag with the same background color as the basket one, then display a "..."
     recomputeBlankRects(); // See the drawing of blank areas in BasketScene::drawContents()
     unbufferizeAll();
 
     if (isDuringEdit() && m_editor->graphicsWidget()) {
         QPalette palette;
         palette.setColor(m_editor->graphicsWidget()->widget()->backgroundRole(), m_editor->note()->backgroundColor());
         palette.setColor(m_editor->graphicsWidget()->widget()->foregroundRole(), m_editor->note()->textColor());
         m_editor->graphicsWidget()->setPalette(palette);
     }
 
     Q_EMIT propertiesChanged(this);
 }
 
 void BasketScene::setDisposition(int disposition, int columnCount)
 {
     static const int COLUMNS_LAYOUT = 0;
     static const int FREE_LAYOUT = 1;
     static const int MINDMAPS_LAYOUT = 2;
 
     int currentDisposition = (isFreeLayout() ? (isMindMap() ? MINDMAPS_LAYOUT : FREE_LAYOUT) : COLUMNS_LAYOUT);
 
     if (currentDisposition == COLUMNS_LAYOUT && disposition == COLUMNS_LAYOUT) {
         if (firstNote() && columnCount > m_columnsCount) {
             // Insert each new columns:
             for (int i = m_columnsCount; i < columnCount; ++i) {
                 Note *newColumn = new Note(this);
                 insertNote(newColumn, /*clicked=*/lastNote(), /*zone=*/Note::BottomInsert);
             }
         } else if (firstNote() && columnCount < m_columnsCount) {
             Note *column = firstNote();
             Note *cuttedNotes = nullptr;
             for (int i = 1; i <= m_columnsCount; ++i) {
                 Note *columnToRemove = column;
                 column = column->next();
                 if (i > columnCount) {
                     // Remove the columns that are too much:
                     unplugNote(columnToRemove);
                     // "Cut" the content in the columns to be deleted:
                     if (columnToRemove->firstChild()) {
                         for (Note *it = columnToRemove->firstChild(); it; it = it->next())
                             it->setParentNote(nullptr);
                         if (!cuttedNotes)
                             cuttedNotes = columnToRemove->firstChild();
                         else {
                             Note *lastCuttedNote = cuttedNotes;
                             while (lastCuttedNote->next())
                                 lastCuttedNote = lastCuttedNote->next();
                             lastCuttedNote->setNext(columnToRemove->firstChild());
                             columnToRemove->firstChild()->setPrev(lastCuttedNote);
                         }
                         columnToRemove->setFirstChild(nullptr);
                     }
                     delete columnToRemove;
                 }
             }
             // Paste the content in the last column:
             if (cuttedNotes)
                 insertNote(cuttedNotes, /*clicked=*/lastNote(), /*zone=*/Note::BottomColumn);
             unselectAll();
         }
         if (columnCount != m_columnsCount) {
             m_columnsCount = (columnCount <= 0 ? 1 : columnCount);
             equalizeColumnSizes(); // Will relayoutNotes()
         }
     } else if (currentDisposition == COLUMNS_LAYOUT && (disposition == FREE_LAYOUT || disposition == MINDMAPS_LAYOUT)) {
         Note *column = firstNote();
         m_columnsCount = 0; // Now, so relayoutNotes() will not relayout the free notes as if they were columns!
         while (column) {
             // Move all childs on the first level:
             Note *nextColumn = column->next();
             ungroupNote(column);
             column = nextColumn;
         }
         unselectAll();
         m_mindMap = (disposition == MINDMAPS_LAYOUT);
         relayoutNotes();
     } else if ((currentDisposition == FREE_LAYOUT || currentDisposition == MINDMAPS_LAYOUT) && disposition == COLUMNS_LAYOUT) {
         if (firstNote()) {
             // TODO: Reorder notes!
             // Remove all notes (but keep a reference to them, we're not crazy ;-) ):
             Note *notes = m_firstNote;
             m_firstNote = nullptr;
             m_count = 0;
             m_countFounds = 0;
             // Insert the number of columns that is needed:
             Note *lastInsertedColumn = nullptr;
             for (int i = 0; i < columnCount; ++i) {
                 Note *column = new Note(this);
                 if (lastInsertedColumn)
                     insertNote(column, /*clicked=*/lastInsertedColumn, /*zone=*/Note::BottomInsert);
                 else
                     m_firstNote = column;
                 lastInsertedColumn = column;
             }
             // Reinsert the old notes in the first column:
             insertNote(notes, /*clicked=*/firstNote(), /*zone=*/Note::BottomColumn);
             unselectAll();
         } else {
             // Insert the number of columns that is needed:
             Note *lastInsertedColumn = nullptr;
             for (int i = 0; i < columnCount; ++i) {
                 Note *column = new Note(this);
                 if (lastInsertedColumn)
                     insertNote(column, /*clicked=*/lastInsertedColumn, /*zone=*/Note::BottomInsert);
                 else
                     m_firstNote = column;
                 lastInsertedColumn = column;
             }
         }
         m_columnsCount = (columnCount <= 0 ? 1 : columnCount);
         equalizeColumnSizes(); // Will relayoutNotes()
     }
 }
 
 void BasketScene::equalizeColumnSizes()
 {
     if (!firstNote())
         return;
 
     // Necessary to know the available space;
     relayoutNotes();
 
     int availableSpace = m_view->viewport()->width();
     int columnWidth = (availableSpace - (columnsCount() - 1) * Note::GROUP_WIDTH) / columnsCount();
     int columnCount = columnsCount();
     Note *column = firstNote();
     while (column) {
         int minGroupWidth = column->minRight() - column->x();
         if (minGroupWidth > columnWidth) {
             availableSpace -= minGroupWidth;
             --columnCount;
         }
         column = column->next();
     }
     columnWidth = (availableSpace - (columnsCount() - 1) * Note::GROUP_WIDTH) / columnCount;
 
     column = firstNote();
     while (column) {
         int minGroupWidth = column->minRight() - column->x();
         if (minGroupWidth > columnWidth)
             column->setGroupWidth(minGroupWidth);
         else
             column->setGroupWidth(columnWidth);
         column = column->next();
     }
 
     relayoutNotes();
 }
 
 void BasketScene::enableActions()
 {
     Global::bnpView->enableActions();
     m_view->setFocusPolicy(isLocked() ? Qt::NoFocus : Qt::StrongFocus);
     if (isLocked())
         m_view->viewport()->setCursor(Qt::ArrowCursor); // When locking, the cursor stays the last form it was
 }
 
 bool BasketScene::save()
 {
     if (!m_loaded)
         return false;
 
     DEBUG_WIN << "Basket[" + folderName() + "]: Saving...";
 
     QString data;
     QXmlStreamWriter stream(&data);
     XMLWork::setupXmlStream(stream, "basket");
 
     // Create Properties Element and Populate It:
     saveProperties(stream);
 
     // Create Notes Element and Populate It:
     stream.writeStartElement("notes");
     saveNotes(stream, nullptr);
     stream.writeEndElement();
 
     stream.writeEndElement();
     stream.writeEndDocument();
 
     // Write to Disk:
     if (!FileStorage::saveToFile(fullPath() + ".basket", data, isEncrypted())) {
         DEBUG_WIN << "Basket[" + folderName() + "]: <font color=red>FAILED to save</font>!";
         return false;
     }
 
     Global::bnpView->setUnsavedStatus(false);
 
     m_commitdelay.start(10000); // delay is 10 seconds
 
     return true;
 }
 
 void BasketScene::commitEdit()
 {
     GitWrapper::commitBasket(this);
 }
 
 void BasketScene::aboutToBeActivated()
 {
     if (m_finishLoadOnFirstShow) {
         FOR_EACH_NOTE(note)
         note->finishLazyLoad();
 
         // relayoutNotes(/*animate=*/false);
         setFocusedNote(nullptr); // So that during the focusInEvent that will come shortly, the FIRST note is focused.
 
         m_finishLoadOnFirstShow = false;
         m_loaded = true;
     }
 }
 
 void BasketScene::reload()
 {
     closeEditor();
     unbufferizeAll(); // Keep the memory footprint low
 
     m_firstNote = nullptr;
 
     m_loaded = false;
     m_loadingLaunched = false;
 
     invalidate();
 }
 
 void BasketScene::load()
 {
     // Load only once:
     if (m_loadingLaunched)
         return;
     m_loadingLaunched = true;
 
     DEBUG_WIN << "Basket[" + folderName() + "]: Loading...";
     QDomDocument *doc = nullptr;
     QString content;
 
     // Load properties
     if (FileStorage::loadFromFile(fullPath() + ".basket", &content)) {
         doc = new QDomDocument("basket");
         if (!doc->setContent(content)) {
             DEBUG_WIN << "Basket[" + folderName() + "]: <font color=red>FAILED to parse XML</font>!";
             delete doc;
             doc = nullptr;
         }
     }
     if (isEncrypted())
         DEBUG_WIN << "Basket is encrypted.";
     if (!doc) {
         DEBUG_WIN << "Basket[" + folderName() + "]: <font color=red>FAILED to load</font>!";
         m_loadingLaunched = false;
         if (isEncrypted())
             m_locked = true;
         Global::bnpView->notesStateChanged(); // Show "Locked" instead of "Loading..." in the statusbar
         return;
     }
     m_locked = false;
 
     QDomElement docElem = doc->documentElement();
     QDomElement properties = XMLWork::getElement(docElem, "properties");
 
     loadProperties(properties); // Since we are loading, this time the background image will also be loaded!
     // Now that the background image is loaded and subscribed, we display it during the load process:
     delete doc;
 
     // BEGIN Compatibility with 0.6.0 Pre-Alpha versions:
     QDomElement notes = XMLWork::getElement(docElem, "notes");
     if (notes.isNull())
         notes = XMLWork::getElement(docElem, "items");
     m_watcher->stopScan();
     m_shouldConvertPlainTextNotes = false; // Convert Pre-0.6.0 baskets: plain text notes should be converted to rich text ones once all is loaded!
 
     // Load notes
     m_finishLoadOnFirstShow = (Global::bnpView->currentBasket() != this);
     loadNotes(notes, nullptr);
     if (m_shouldConvertPlainTextNotes)
         convertTexts();
     m_watcher->startScan();
 
+    // Load model
+    m_model.loadFromXML(notes);
+
     signalCountsChanged();
     if (isColumnsLayout()) {
         // Count the number of columns:
         int columnsCount = 0;
         Note *column = firstNote();
         while (column) {
             ++columnsCount;
             column = column->next();
         }
         m_columnsCount = columnsCount;
     }
 
     relayoutNotes();
 
     // On application start, the current basket is not focused yet, so the focus rectangle is not shown when calling focusANote():
     if (Global::bnpView->currentBasket() == this)
         setFocus();
     focusANote();
 
     m_loaded = true;
     enableActions();
 }
 
 void BasketScene::filterAgain(bool andEnsureVisible /* = true*/)
 {
     newFilter(decoration()->filterData(), andEnsureVisible);
 }
 
 void BasketScene::filterAgainDelayed()
 {
     QTimer::singleShot(0, this, SLOT(filterAgain()));
 }
 
 void BasketScene::newFilter(const FilterData &data, bool andEnsureVisible /* = true*/)
 {
     if (!isLoaded())
         return;
 
     // StopWatch::start(20);
 
     m_countFounds = 0;
     for (Note *note = firstNote(); note; note = note->next())
         m_countFounds += note->newFilter(data);
 
     relayoutNotes();
     signalCountsChanged();
 
     if (hasFocus())   // if (!hasFocus()), focusANote() will be called at focusInEvent()
         focusANote(); //  so, we avoid de-focus a note if it will be re-shown soon
     if (andEnsureVisible && m_focusedNote != nullptr)
         ensureNoteVisible(m_focusedNote);
 
     Global::bnpView->setFiltering(data.isFiltering);
 
     // StopWatch::check(20);
 }
 
 bool BasketScene::isFiltering()
 {
     return decoration()->filterBar()->filterData().isFiltering;
 }
 
 QString BasketScene::fullPath()
 {
     return Global::basketsFolder() + folderName();
 }
 
 QString BasketScene::fullPathForFileName(const QString &fileName)
 {
     return fullPath() + fileName;
 }
 
 /*static*/ QString BasketScene::fullPathForFolderName(const QString &folderName)
 {
     return Global::basketsFolder() + folderName;
 }
 
 void BasketScene::setShortcut(QKeySequence shortcut, int action)
 {
     QList<QKeySequence> shortcuts {shortcut};
     if (action > 0) {
         KGlobalAccel::self()->setShortcut(m_action, shortcuts, KGlobalAccel::Autoloading);
         KGlobalAccel::self()->setDefaultShortcut(m_action, shortcuts, KGlobalAccel::Autoloading);
     }
     m_shortcutAction = action;
 }
 
 void BasketScene::activatedShortcut()
 {
     Global::bnpView->setCurrentBasket(this);
 
     if (m_shortcutAction == 1)
         Global::bnpView->setActive(true);
 }
 
 void BasketScene::signalCountsChanged()
 {
     if (!m_timerCountsChanged.isActive()) {
         m_timerCountsChanged.setSingleShot(true);
         m_timerCountsChanged.start(0);
     }
 }
 
 void BasketScene::countsChangedTimeOut()
 {
     Q_EMIT countsChanged(this);
 }
 
 BasketScene::BasketScene(QWidget *parent, const QString &folderName)
     //: Q3ScrollView(parent)
     : QGraphicsScene(parent)
     , m_model(this)
     , m_noActionOnMouseRelease(false)
     , m_ignoreCloseEditorOnNextMouseRelease(false)
     , m_pressPos(-100, -100)
     , m_canDrag(false)
     , m_firstNote(nullptr)
     , m_columnsCount(1)
     , m_mindMap(false)
     , m_resizingNote(nullptr)
     , m_pickedResizer(0)
     , m_movingNote(nullptr)
     , m_pickedHandle(0, 0)
     , m_notesToBeDeleted()
     , m_clickedToInsert(nullptr)
     , m_zoneToInsert(0)
     , m_posToInsert(-1, -1)
     , m_isInsertPopupMenu(false)
     , m_insertMenuTitle(nullptr)
     , m_loaded(false)
     , m_loadingLaunched(false)
     , m_locked(false)
     , m_decryptBox(nullptr)
     , m_button(nullptr)
     , m_encryptionType(NoEncryption)
 #ifdef HAVE_LIBGPGME
     , m_gpg(0)
 #endif
     , m_backgroundPixmap(nullptr)
     , m_opaqueBackgroundPixmap(nullptr)
     , m_selectedBackgroundPixmap(nullptr)
     , m_action(nullptr)
     , m_shortcutAction(0)
     , m_hoveredNote(nullptr)
     , m_hoveredZone(Note::None)
     , m_lockedHovering(false)
     , m_underMouse(false)
     , m_inserterRect()
     , m_inserterShown(false)
     , m_inserterSplit(true)
     , m_inserterTop(false)
     , m_inserterGroup(false)
     , m_lastDisableClick(QTime::currentTime())
     , m_isSelecting(false)
     , m_selectionStarted(false)
     , m_count(0)
     , m_countFounds(0)
     , m_countSelecteds(0)
     , m_folderName(folderName)
     , m_editor(nullptr)
     , m_leftEditorBorder(nullptr)
     , m_rightEditorBorder(nullptr)
     , m_redirectEditActions(false)
     , m_editorTrackMouseEvent(false)
     , m_editorWidth(-1)
     , m_editorHeight(-1)
     , m_doNotCloseEditor(false)
     , m_isDuringDrag(false)
     , m_draggedNotes()
     , m_focusedNote(nullptr)
     , m_startOfShiftSelectionNote(nullptr)
     , m_finishLoadOnFirstShow(false)
     , m_relayoutOnNextShow(false)
 {
     m_view = new BasketView(this);
     m_view->setFocusPolicy(Qt::StrongFocus);
     m_view->setAlignment(Qt::AlignLeft | Qt::AlignTop);
 
     m_action = new QAction(this);
     connect(m_action, &QAction::triggered, this, &BasketScene::activatedShortcut);
     m_action->setObjectName(folderName);
     KGlobalAccel::self()->setGlobalShortcut(m_action, (QKeySequence()));
     // We do this in the basket properties dialog (and keep it in sync with the
     // global one)
     KActionCollection *ac = Global::bnpView->actionCollection();
     ac->setShortcutsConfigurable(m_action, false);
 
     if (!m_folderName.endsWith('/'))
         m_folderName += '/';
 
     //    setDragAutoScroll(true);
 
     // By default, there is no corner widget: we set one for the corner area to be painted!
     // If we don't set one and there are two scrollbars present, slowly resizing up the window show graphical glitches in that area!
     m_cornerWidget = new QWidget(m_view);
     m_view->setCornerWidget(m_cornerWidget);
 
     m_view->viewport()->setAcceptDrops(true);
     m_view->viewport()->setMouseTracking(true);
     m_view->viewport()->setAutoFillBackground(false); // Do not clear the widget before paintEvent() because we always draw every pixels (faster and flicker-free)
 
     // File Watcher:
     m_watcher = new KDirWatch(this);
 
     connect(m_watcher, &KDirWatch::dirty, this, &BasketScene::watchedFileModified);
     //connect(m_watcher, &KDirWatch::deleted, this, &BasketScene::watchedFileDeleted);
     connect(&m_watcherTimer, &QTimer::timeout, this, &BasketScene::updateModifiedNotes);
 
     // Various Connections:
     connect(&m_autoScrollSelectionTimer, &QTimer::timeout, this, &BasketScene::doAutoScrollSelection);
     connect(&m_timerCountsChanged, &QTimer::timeout, this, &BasketScene::countsChangedTimeOut);
     connect(&m_inactivityAutoSaveTimer, &QTimer::timeout, this, &BasketScene::inactivityAutoSaveTimeout);
     connect(&m_inactivityAutoLockTimer, &QTimer::timeout, this, &BasketScene::inactivityAutoLockTimeout);
 
 #ifdef HAVE_LIBGPGME
     m_gpg = new KGpgMe();
 #endif
     m_locked = isFileEncrypted();
 
     // setup the delayed commit timer
     m_commitdelay.setSingleShot(true);
     connect(&m_commitdelay, &QTimer::timeout, this, &BasketScene::commitEdit);
 }
 
 void BasketScene::enterEvent(QEvent *)
 {
     m_underMouse = true;
     doHoverEffects();
 }
 
 void BasketScene::leaveEvent(QEvent *)
 {
     m_underMouse = false;
     doHoverEffects();
 
     if (m_lockedHovering)
         return;
 
     removeInserter();
     if (m_hoveredNote) {
         m_hoveredNote->setHovered(false);
         m_hoveredNote->setHoveredZone(Note::None);
         m_hoveredNote->update();
     }
     m_hoveredNote = nullptr;
 }
 
 void BasketScene::setFocusIfNotInPopupMenu()
 {
     if (!qApp->activePopupWidget()) {
         if (isDuringEdit())
             m_editor->graphicsWidget()->setFocus();
         else
             setFocus();
     }
 }
 
 void BasketScene::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
     // If user click the basket, focus it!
     // The focus is delayed because if the click results in showing a popup menu,
     // the interface flicker by showing the focused rectangle (as the basket gets focus)
     // and immediately removing it (because the popup menu now have focus).
     if (!isDuringEdit())
         QTimer::singleShot(0, this, SLOT(setFocusIfNotInPopupMenu()));
 
     // Convenient variables:
     bool controlPressed = event->modifiers() & Qt::ControlModifier;
     bool shiftPressed = event->modifiers() & Qt::ShiftModifier;
 
     // Do nothing if we disabled the click some milliseconds sooner.
     // For instance when a popup menu has been closed with click, we should not do action:
     if (event->button() == Qt::LeftButton && (qApp->activePopupWidget() || m_lastDisableClick.msecsTo(QTime::currentTime()) <= 80)) {
         doHoverEffects();
         m_noActionOnMouseRelease = true;
         // But we allow to select:
         // The code is the same as at the bottom of this method:
         if (event->button() == Qt::LeftButton) {
             m_selectionStarted = true;
             m_selectionBeginPoint = event->scenePos();
             m_selectionInvert = controlPressed || shiftPressed;
         }
 
         return;
     }
 
     // if we are editing and no control key are pressed
     if (m_editor && !shiftPressed && !controlPressed) {
         // if the mouse is over the editor
         QPoint view_shift(m_view->horizontalScrollBar()->value(), m_view->verticalScrollBar()->value());
         QGraphicsWidget *widget = dynamic_cast<QGraphicsWidget *>(m_view->itemAt((event->scenePos() - view_shift).toPoint()));
         if (widget && m_editor->graphicsWidget() == widget) {
             if (event->button() == Qt::LeftButton) {
                 m_editorTrackMouseEvent = true;
                 m_editor->startSelection(event->scenePos());
                 return;
             } else if (event->button() == Qt::MiddleButton) {
                 m_editor->paste(event->scenePos(), QClipboard::Selection);
                 return;
             }
         }
     }
 
     // Figure out what is the clicked note and zone:
     Note *clicked = noteAt(event->scenePos());
     if (m_editor && (!clicked || (clicked && !(editedNote() == clicked)))) {
         closeEditor();
     }
     Note::Zone zone = (clicked ? clicked->zoneAt(event->scenePos() - QPointF(clicked->x(), clicked->y())) : Note::None);
 
     // Popup Tags menu:
     if (zone == Note::TagsArrow && !controlPressed && !shiftPressed && event->button() != Qt::MidButton) {
         if (!clicked->allSelected())
             unselectAllBut(clicked);
         setFocusedNote(clicked); /// /// ///
         m_startOfShiftSelectionNote = clicked;
         m_noActionOnMouseRelease = true;
         popupTagsMenu(clicked);
 
         return;
     }
 
     if (event->button() == Qt::LeftButton) {
         // Prepare to allow drag and drop when moving mouse further:
         if ((zone == Note::Handle || zone == Note::Group) || (clicked && clicked->allSelected() && (zone == Note::TagsArrow || zone == Note::Custom0 || zone == Note::Content || zone == Note::Link /**/ || zone >= Note::Emblem0 /**/))) {
             if (!shiftPressed && !controlPressed) {
                 m_pressPos = event->scenePos(); // TODO: Allow to drag emblems to assign them to other notes. Then don't allow drag at Emblem0!!
 
                 m_canDrag = true;
 
                 // Saving where we were editing, because during a drag, the mouse can fly over the text edit and move the cursor position:
                 if (m_editor && m_editor->textEdit()) {
                     KTextEdit *editor = m_editor->textEdit();
                     m_textCursor = editor->textCursor();
                 }
             }
         }
 
         // Initializing Resizer move:
         if (zone == Note::Resizer) {
             m_resizingNote = clicked;
             m_pickedResizer = event->scenePos().x() - clicked->rightLimit();
             m_noActionOnMouseRelease = true;
             m_lockedHovering = true;
 
             return;
         }
 
         // Select note(s):
         if (zone == Note::Handle || zone == Note::Group || (zone == Note::GroupExpander && (controlPressed || shiftPressed))) {
             // closeEditor();
             Note *end = clicked;
             if (clicked->isGroup() && shiftPressed) {
                 if (clicked->containsNote(m_startOfShiftSelectionNote)) {
                     m_startOfShiftSelectionNote = clicked->firstRealChild();
                     end = clicked->lastRealChild();
                 } else if (clicked->firstRealChild()->isAfter(m_startOfShiftSelectionNote)) {
                     end = clicked->lastRealChild();
                 } else {
                     end = clicked->firstRealChild();
                 }
             }
             if (controlPressed && shiftPressed)
                 selectRange(m_startOfShiftSelectionNote, end, /*unselectOthers=*/false);
             else if (shiftPressed)
                 selectRange(m_startOfShiftSelectionNote, end);
             else if (controlPressed)
                 clicked->setSelectedRecursively(!clicked->allSelected());
             else if (!clicked->allSelected())
                 unselectAllBut(clicked);
             setFocusedNote(end); /// /// ///
             m_startOfShiftSelectionNote = (end->isGroup() ? end->firstRealChild() : end);
             // m_noActionOnMouseRelease = false;
             m_noActionOnMouseRelease = true;
 
             return;
         }
 
         // Folding/Unfolding group:
         if (zone == Note::GroupExpander) {
             clicked->toggleFolded();
 
             if (/*m_animationTimeLine == 0 && */ Settings::playAnimations()) {
                 qWarning() << "Folding animation to be done";
             }
 
             relayoutNotes();
             m_noActionOnMouseRelease = true;
 
             return;
         }
     }
 
     // Popup menu for tag emblems:
     if (event->button() == Qt::RightButton && zone >= Note::Emblem0) {
         if (!clicked->allSelected())
             unselectAllBut(clicked);
         setFocusedNote(clicked); /// /// ///
         m_startOfShiftSelectionNote = clicked;
         popupEmblemMenu(clicked, zone - Note::Emblem0);
         m_noActionOnMouseRelease = true;
 
         return;
     }
 
     // Insertion Popup Menu:
     if ((event->button() == Qt::RightButton) && ((!clicked && isFreeLayout()) || (clicked && (zone == Note::TopInsert || zone == Note::TopGroup || zone == Note::BottomInsert || zone == Note::BottomGroup || zone == Note::BottomColumn)))) {
         unselectAll();
         m_clickedToInsert = clicked;
         m_zoneToInsert = zone;
         m_posToInsert = event->scenePos();
 
         QMenu menu(m_view);
         menu.addActions(Global::bnpView->popupMenu("insert_popup")->actions());
 
         // If we already added a title, remove it because it would be kept and
         // then added several times.
         if (m_insertMenuTitle && menu.actions().contains(m_insertMenuTitle))
             menu.removeAction(m_insertMenuTitle);
 
         QAction *first = menu.actions().value(0);
 
         // i18n: Verbs (for the "insert" menu)
         if (zone == Note::TopGroup || zone == Note::BottomGroup)
             m_insertMenuTitle = menu.insertSection(first, i18n("Group"));
         else
             m_insertMenuTitle = menu.insertSection(first, i18n("Insert"));
 
         setInsertPopupMenu();
         connect(&menu, &QMenu::aboutToHide, this, &BasketScene::delayedCancelInsertPopupMenu);
         connect(&menu, &QMenu::aboutToHide, this, &BasketScene::unlockHovering);
         connect(&menu, &QMenu::aboutToHide, this, &BasketScene::disableNextClick);
         connect(&menu, &QMenu::aboutToHide, this, &BasketScene::hideInsertPopupMenu);
         doHoverEffects(clicked, zone); // In the case where another popup menu was open, we should do that manually!
         m_lockedHovering = true;
         menu.exec(QCursor::pos());
         m_noActionOnMouseRelease = true;
         return;
     }
 
     // Note Context Menu:
     if (event->button() == Qt::RightButton && clicked && !clicked->isColumn() && zone != Note::Resizer) {
         if (!clicked->allSelected())
             unselectAllBut(clicked);
         setFocusedNote(clicked); /// /// ///
         if (editedNote() == clicked) {
             closeEditor(false);
             clicked->setSelected(true);
         }
         m_startOfShiftSelectionNote = (clicked->isGroup() ? clicked->firstRealChild() : clicked);
         QMenu *menu = Global::bnpView->popupMenu("note_popup");
         connect(menu, &QMenu::aboutToHide, this, &BasketScene::unlockHovering);
         connect(menu, &QMenu::aboutToHide, this, &BasketScene::disableNextClick);
         doHoverEffects(clicked, zone); // In the case where another popup menu was open, we should do that manually!
         m_lockedHovering = true;
         menu->exec(QCursor::pos());
         m_noActionOnMouseRelease = true;
         return;
     }
 
     // Paste selection under cursor (but not "create new primary note under cursor" because this is on moveRelease):
     if (event->button() == Qt::MidButton && zone != Note::Resizer && (!isDuringEdit() || clicked != editedNote())) {
         if ((Settings::middleAction() != 0) && (event->modifiers() == Qt::ShiftModifier)) {
             m_clickedToInsert = clicked;
             m_zoneToInsert = zone;
             m_posToInsert = event->scenePos();
             // closeEditor();
             removeInserter();                    // If clicked at an insertion line and the new note shows a dialog for editing,
             NoteType::Id type = (NoteType::Id)0; //  hide that inserter before the note edition instead of after the dialog is closed
             switch (Settings::middleAction()) {
             case 1:
                 m_isInsertPopupMenu = true;
                 pasteNote();
                 break;
             case 2:
                 type = NoteType::Image;
                 break;
             case 3:
                 type = NoteType::Link;
                 break;
             case 4:
                 type = NoteType::Launcher;
                 break;
             default:
                 m_noActionOnMouseRelease = false;
                 return;
             }
             if (type != 0) {
                 m_ignoreCloseEditorOnNextMouseRelease = true;
                 Global::bnpView->insertEmpty(type);
             }
         } else {
             if (clicked)
                 zone = clicked->zoneAt(event->scenePos() - QPoint(clicked->x(), clicked->y()), true);
             // closeEditor();
             clickedToInsert(event, clicked, zone);
             save();
         }
         m_noActionOnMouseRelease = true;
         return;
     }
 
     // Finally, no action has been done during pressEvent, so an action can be done on releaseEvent:
     m_noActionOnMouseRelease = false;
 
     /* Selection scenario:
      * On contentsMousePressEvent, put m_selectionStarted to true and init Begin and End selection point.
      * On contentsMouseMoveEvent, if m_selectionStarted, update End selection point, update selection rect,
      * and if it's larger, switching to m_isSelecting mode: we can draw the selection rectangle.
      */
     // Prepare selection:
     if (event->button() == Qt::LeftButton) {
         m_selectionStarted = true;
         m_selectionBeginPoint = event->scenePos();
         // We usually invert the selection with the Ctrl key, but some environments (like GNOME or The Gimp) do it with the Shift key.
         // Since the Shift key has no specific usage, we allow to invert selection ALSO with Shift for Gimp people
         m_selectionInvert = controlPressed || shiftPressed;
     }
 }
 
 void BasketScene::delayedCancelInsertPopupMenu()
 {
     QTimer::singleShot(0, this, SLOT(cancelInsertPopupMenu()));
 }
 
 void BasketScene::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
 {
     if (event->reason() == QGraphicsSceneContextMenuEvent::Keyboard) {
         if (countFounds /*countShown*/ () == 0) { // TODO: Count shown!!
             QMenu *menu = Global::bnpView->popupMenu("insert_popup");
             setInsertPopupMenu();
             connect(menu, &QMenu::aboutToHide, this, &BasketScene::delayedCancelInsertPopupMenu);
             connect(menu, &QMenu::aboutToHide, this, &BasketScene::unlockHovering);
             connect(menu, &QMenu::aboutToHide, this, &BasketScene::disableNextClick);
             removeInserter();
             m_lockedHovering = true;
             menu->exec(m_view->mapToGlobal(QPoint(0, 0)));
         } else {
             if (!m_focusedNote->isSelected())
                 unselectAllBut(m_focusedNote);
             setFocusedNote(m_focusedNote); /// /// ///
             m_startOfShiftSelectionNote = (m_focusedNote->isGroup() ? m_focusedNote->firstRealChild() : m_focusedNote);
             // Popup at bottom (or top) of the focused note, if visible :
             QMenu *menu = Global::bnpView->popupMenu("note_popup");
             connect(menu, &QMenu::aboutToHide, this, &BasketScene::unlockHovering);
             connect(menu, &QMenu::aboutToHide, this, &BasketScene::disableNextClick);
             doHoverEffects(m_focusedNote, Note::Content); // In the case where another popup menu was open, we should do that manually!
             m_lockedHovering = true;
             menu->exec(noteVisibleRect(m_focusedNote).bottomLeft().toPoint());
         }
     }
 }
 
 QRectF BasketScene::noteVisibleRect(Note *note)
 {
     QRectF rect(QPointF(note->x(), note->y()), QSizeF(note->width(), note->height()));
     QPoint basketPoint = m_view->mapToGlobal(QPoint(0, 0));
     rect.moveTopLeft(rect.topLeft() + basketPoint + QPoint(m_view->frameWidth(), m_view->frameWidth()));
 
     // Now, rect contain the global note rectangle on the screen.
     // We have to clip it by the basket widget :
     //    if (rect.bottom() > basketPoint.y() + visibleHeight() + 1) { // Bottom too... bottom
     //        rect.setBottom(basketPoint.y() + visibleHeight() + 1);
     if (rect.bottom() > basketPoint.y() + m_view->viewport()->height() + 1) { // Bottom too... bottom
         rect.setBottom(basketPoint.y() + m_view->viewport()->height() + 1);
         if (rect.height() <= 0) // Have at least one visible pixel of height
             rect.setTop(rect.bottom());
     }
     if (rect.top() < basketPoint.y() + m_view->frameWidth()) { // Top too... top
         rect.setTop(basketPoint.y() + m_view->frameWidth());
         if (rect.height() <= 0)
             rect.setBottom(rect.top());
     }
     //    if (rect.right() > basketPoint.x() + visibleWidth() + 1) { // Right too... right
     //        rect.setRight(basketPoint.x() + visibleWidth() + 1);
     if (rect.right() > basketPoint.x() + m_view->viewport()->width() + 1) { // Right too... right
         rect.setRight(basketPoint.x() + m_view->viewport()->width() + 1);
         if (rect.width() <= 0) // Have at least one visible pixel of width
             rect.setLeft(rect.right());
     }
     if (rect.left() < basketPoint.x() + m_view->frameWidth()) { // Left too... left
         rect.setLeft(basketPoint.x() + m_view->frameWidth());
         if (rect.width() <= 0)
             rect.setRight(rect.left());
     }
     return rect;
 }
 
 void BasketScene::disableNextClick()
 {
     m_lastDisableClick = QTime::currentTime();
 }
 
 void BasketScene::recomputeAllStyles()
 {
     FOR_EACH_NOTE(note)
     note->recomputeAllStyles();
 }
 
 void BasketScene::removedStates(const QList<State *> &deletedStates)
 {
     bool modifiedBasket = false;
 
     FOR_EACH_NOTE(note)
     if (note->removedStates(deletedStates))
         modifiedBasket = true;
 
     if (modifiedBasket)
         save();
 }
 
 void BasketScene::insertNote(Note *note, Note *clicked, int zone, const QPointF &pos)
 {
     if (!note) {
         qDebug() << "Wanted to insert NO note";
         return;
     }
 
     if (clicked && zone == Note::BottomColumn) {
         // When inserting at the bottom of a column, it's obvious the new note SHOULD inherit tags.
         // We ensure that by changing the insertion point after the last note of the column:
         Note *last = clicked->lastChild();
         if (last) {
             clicked = last;
             zone = Note::BottomInsert;
         }
     }
 
     /// Insertion at the bottom of a column:
     if (clicked && zone == Note::BottomColumn) {
         note->setWidth(clicked->rightLimit() - clicked->x());
         Note *lastChild = clicked->lastChild();
         for (Note *n = note; n; n = n->next()) {
             n->setXRecursively(clicked->x());
             n->setYRecursively((lastChild ? lastChild : clicked)->bottom() + 1);
         }
         appendNoteIn(note, clicked);
 
         /// Insertion relative to a note (top/bottom, insert/group):
     } else if (clicked) {
         note->setWidth(clicked->width());
         for (Note *n = note; n; n = n->next()) {
             if (zone == Note::TopGroup || zone == Note::BottomGroup) {
                 n->setXRecursively(clicked->x() + Note::GROUP_WIDTH);
             } else {
                 n->setXRecursively(clicked->x());
             }
             if (zone == Note::TopInsert || zone == Note::TopGroup) {
                 n->setYRecursively(clicked->y());
             } else {
                 n->setYRecursively(clicked->bottom() + 1);
             }
         }
 
         if (zone == Note::TopInsert) {
             appendNoteBefore(note, clicked);
         } else if (zone == Note::BottomInsert) {
             appendNoteAfter(note, clicked);
         } else if (zone == Note::TopGroup) {
             groupNoteBefore(note, clicked);
         } else if (zone == Note::BottomGroup) {
             groupNoteAfter(note, clicked);
         }
 
         /// Free insertion:
     } else if (isFreeLayout()) {
         // Group if note have siblings:
         if (note->next()) {
             Note *group = new Note(this);
             for (Note *n = note; n; n = n->next())
                 n->setParentNote(group);
             group->setFirstChild(note);
             note = group;
         }
         // Insert at cursor position:
         const int initialWidth = 250;
         note->setWidth(note->isGroup() ? Note::GROUP_WIDTH : initialWidth);
         if (note->isGroup() && note->firstChild())
             note->setInitialHeight(note->firstChild()->height());
         // note->setGroupWidth(initialWidth);
         note->setXRecursively(pos.x());
         note->setYRecursively(pos.y());
         appendNoteAfter(note, lastNote());
     }
 
     relayoutNotes();
 }
 
 void BasketScene::clickedToInsert(QGraphicsSceneMouseEvent *event, Note *clicked, /*Note::Zone*/ int zone)
 {
     Note *note;
     if (event->button() == Qt::MidButton)
         note = NoteFactory::dropNote(QApplication::clipboard()->mimeData(QClipboard::Selection), this);
     else
         note = NoteFactory::createNoteText(QString(), this);
 
     if (!note)
         return;
 
     insertNote(note, clicked, zone, QPointF(event->scenePos()));
 
     //  ensureNoteVisible(lastInsertedNote()); // TODO: in insertNote()
 
     if (event->button() != Qt::MidButton) {
         removeInserter(); // Case: user clicked below a column to insert, the note is inserted and doHoverEffects() put a new inserter below. We don't want it.
         closeEditor();
         noteEdit(note, /*justAdded=*/true);
     }
 }
 
 void BasketScene::dragEnterEvent(QGraphicsSceneDragDropEvent *event)
 {
     m_isDuringDrag = true;
     Global::bnpView->updateStatusBarHint();
     if (NoteDrag::basketOf(event->mimeData()) == this) {
         m_draggedNotes = NoteDrag::notesOf(event);
         NoteDrag::saveNoteSelectionToList(selectedNotes());
     }
     event->accept();
 }
 
 void BasketScene::dragMoveEvent(QGraphicsSceneDragDropEvent *event)
 {
     //  m_isDuringDrag = true;
 
     //  if (isLocked())
     //      return;
 
     //  FIXME: viewportToContents does NOT work !!!
     //  QPoint pos = viewportToContents(event->pos());
     //  QPoint pos( event->pos().x() + contentsX(), event->pos().y() + contentsY() );
 
     //  if (insertAtCursorPos())
     //      computeInsertPlace(pos);
     doHoverEffects(event->scenePos());
 
     //  showFrameInsertTo();
     if (isFreeLayout() || noteAt(event->scenePos())) // Cursor before rightLimit() or hovering the dragged source notes
         acceptDropEvent(event);
     else {
         event->setAccepted(false);
     }
 
     /*  Note *hoveredNote = noteAt(event->pos().x(), event->pos().y());
         if ( (isColumnsLayout() && !hoveredNote) || (draggedNotes().contains(hoveredNote)) ) {
             event->acceptAction(false);
             event->accept(false);
         } else
             acceptDropEvent(event);*/
 
     // A workaround since QScrollView::dragAutoScroll seem to have no effect :
     //  ensureVisible(event->pos().x() + contentsX(), event->pos().y() + contentsY(), 30, 30);
     //  QScrollView::dragMoveEvent(event);
 }
 
 void BasketScene::dragLeaveEvent(QGraphicsSceneDragDropEvent *)
 {
     //  resetInsertTo();
     m_isDuringDrag = false;
     m_draggedNotes.clear();
     NoteDrag::selectedNotes.clear();
     m_noActionOnMouseRelease = true;
     Q_EMIT resetStatusBarText();
     doHoverEffects();
 }
 
 void BasketScene::dropEvent(QGraphicsSceneDragDropEvent *event)
 {
     QPointF pos = event->scenePos();
     qDebug() << "Drop Event at position " << pos.x() << ":" << pos.y();
 
     m_isDuringDrag = false;
     Q_EMIT resetStatusBarText();
 
     //  if (isLocked())
     //      return;
 
     // Do NOT check the bottom&right borders.
     // Because imagine someone drag&drop a big note from the top to the bottom of a big basket (with big vertical scrollbars),
     // the note is first removed, and relayoutNotes() compute the new height that is smaller
     // Then noteAt() is called for the mouse pointer position, because the basket is now smaller, the cursor is out of boundaries!!!
     // Should, of course, not return 0:
     Note *clicked = noteAt(pos);
 
     if (NoteFactory::movingNotesInTheSameBasket(event->mimeData(), this, event->dropAction()) && event->dropAction() == Qt::MoveAction) {
         m_doNotCloseEditor = true;
     }
 
     Note *note = NoteFactory::dropNote(event->mimeData(), this, true, event->dropAction(), dynamic_cast<Note *>(event->source()));
 
     if (note) {
         Note::Zone zone = (clicked ? clicked->zoneAt(pos - QPointF(clicked->x(), clicked->y()), /*toAdd=*/true) : Note::None);
         bool animateNewPosition = NoteFactory::movingNotesInTheSameBasket(event->mimeData(), this, event->dropAction());
         if (animateNewPosition) {
             FOR_EACH_NOTE(n)
             n->setOnTop(false);
             // FOR_EACH_NOTE_IN_CHUNK(note)
             for (Note *n = note; n; n = n->next())
                 n->setOnTop(true);
         }
 
         insertNote(note, clicked, zone, pos);
 
         // If moved a note on bottom, contentsHeight has been diminished, then view scrolled up, and we should re-scroll the view down:
         ensureNoteVisible(note);
 
         //      if (event->button() != Qt::MidButton) {
         //          removeInserter(); // Case: user clicked below a column to insert, the note is inserted and doHoverEffects() put a new inserter below. We don't want it.
         //      }
 
         //      resetInsertTo();
         //      doHoverEffects(); called by insertNote()
         save();
     }
 
     m_draggedNotes.clear();
     NoteDrag::selectedNotes.clear();
 
     m_doNotCloseEditor = false;
     // When starting the drag, we saved where we were editing.
     // This is because during a drag, the mouse can fly over the text edit and move the cursor position, and even HIDE the cursor.
     // So we re-show the cursor, and re-position it at the right place:
     if (m_editor && m_editor->textEdit()) {
         KTextEdit *editor = m_editor->textEdit();
         editor->setTextCursor(m_textCursor);
     }
 }
 
 // handles dropping of a note to basket that is not shown
 // (usually through its entry in the basket list)
 void BasketScene::blindDrop(QGraphicsSceneDragDropEvent *event)
 {
     if (!m_isInsertPopupMenu && redirectEditActions()) {
         if (m_editor->textEdit())
             m_editor->textEdit()->paste();
         else if (m_editor->lineEdit())
             m_editor->lineEdit()->paste();
     } else {
         if (!isLoaded()) {
             Global::bnpView->showPassiveLoading(this);
             load();
         }
         closeEditor();
         unselectAll();
         Note *note = NoteFactory::dropNote(event->mimeData(), this, true, event->dropAction(), dynamic_cast<Note *>(event->source()));
         if (note) {
             insertCreatedNote(note);
             // unselectAllBut(note);
             if (Settings::usePassivePopup())
                 Global::bnpView->showPassiveDropped(i18n("Dropped to basket <i>%1</i>", m_basketName));
         }
     }
     save();
 }
 
 void BasketScene::blindDrop(const QMimeData *mimeData, Qt::DropAction dropAction, QObject *source)
 {
     if (!m_isInsertPopupMenu && redirectEditActions()) {
         if (m_editor->textEdit())
             m_editor->textEdit()->paste();
         else if (m_editor->lineEdit())
             m_editor->lineEdit()->paste();
     } else {
         if (!isLoaded()) {
             Global::bnpView->showPassiveLoading(this);
             load();
         }
         closeEditor();
         unselectAll();
         Note *note = NoteFactory::dropNote(mimeData, this, true, dropAction, dynamic_cast<Note *>(source));
         if (note) {
             insertCreatedNote(note);
             // unselectAllBut(note);
             if (Settings::usePassivePopup())
                 Global::bnpView->showPassiveDropped(i18n("Dropped to basket <i>%1</i>", m_basketName));
         }
     }
     save();
 }
 
 void BasketScene::insertEmptyNote(int type)
 {
     if (!isLoaded())
         load();
     if (isDuringEdit())
         closeEditor();
     Note *note = NoteFactory::createEmptyNote((NoteType::Id)type, this);
     insertCreatedNote(note /*, / *edit=* /true*/);
     noteEdit(note, /*justAdded=*/true);
 }
 
 void BasketScene::insertWizard(int type)
 {
     saveInsertionData();
     Note *note = nullptr;
     switch (type) {
     default:
     case 1:
         note = NoteFactory::importKMenuLauncher(this);
         break;
     case 2:
         note = NoteFactory::importIcon(this);
         break;
     case 3:
         note = NoteFactory::importFileContent(this);
         break;
     }
     if (!note)
         return;
     restoreInsertionData();
     insertCreatedNote(note);
     unselectAllBut(note);
     resetInsertionData();
 }
 
 void BasketScene::insertColor(const QColor &color)
 {
     Note *note = NoteFactory::createNoteColor(color, this);
     restoreInsertionData();
     insertCreatedNote(note);
     unselectAllBut(note);
     resetInsertionData();
 }
 
 void BasketScene::insertImage(const QPixmap &image)
 {
     Note *note = NoteFactory::createNoteImage(image, this);
     restoreInsertionData();
     insertCreatedNote(note);
     unselectAllBut(note);
     resetInsertionData();
 }
 
 void BasketScene::pasteNote(QClipboard::Mode mode)
 {
     if (!m_isInsertPopupMenu && redirectEditActions()) {
         if (m_editor->textEdit())
             m_editor->textEdit()->paste();
         else if (m_editor->lineEdit())
             m_editor->lineEdit()->paste();
     } else {
         if (!isLoaded()) {
             Global::bnpView->showPassiveLoading(this);
             load();
         }
         closeEditor();
         unselectAll();
         Note *note = NoteFactory::dropNote(QApplication::clipboard()->mimeData(mode), this);
         if (note) {
             insertCreatedNote(note);
             // unselectAllBut(note);
         }
     }
 }
 
 void BasketScene::insertCreatedNote(Note *note)
 {
     // Get the insertion data if the user clicked inside the basket:
     Note *clicked = m_clickedToInsert;
     int zone = m_zoneToInsert;
     QPointF pos = m_posToInsert;
 
     // If it isn't the case, use the default position:
     if (!clicked && (pos.x() < 0 || pos.y() < 0)) {
         // Insert right after the focused note:
         focusANote();
         if (m_focusedNote) {
             clicked = m_focusedNote;
             zone = (m_focusedNote->isFree() ? Note::BottomGroup : Note::BottomInsert);
             pos = QPointF(m_focusedNote->x(), m_focusedNote->bottom());
             // Insert at the end of the last column:
         } else if (isColumnsLayout()) {
             Note *column = /*(Settings::newNotesPlace == 0 ?*/ firstNote() /*: lastNote())*/;
             /*if (Settings::newNotesPlace == 0 && column->firstChild()) { // On Top, if at least one child in the column
                 clicked = column->firstChild();
                 zone    = Note::TopInsert;
             } else { // On Bottom*/
             clicked = column;
             zone = Note::BottomColumn;
             /*}*/
             // Insert at free position:
         } else {
             pos = QPointF(0, 0);
         }
     }
 
     insertNote(note, clicked, zone, pos);
     //  ensureNoteVisible(lastInsertedNote());
     removeInserter(); // Case: user clicked below a column to insert, the note is inserted and doHoverEffects() put a new inserter below. We don't want it.
                       //  resetInsertTo();
     save();
 }
 
 void BasketScene::saveInsertionData()
 {
     m_savedClickedToInsert = m_clickedToInsert;
     m_savedZoneToInsert = m_zoneToInsert;
     m_savedPosToInsert = m_posToInsert;
 }
 
 void BasketScene::restoreInsertionData()
 {
     m_clickedToInsert = m_savedClickedToInsert;
     m_zoneToInsert = m_savedZoneToInsert;
     m_posToInsert = m_savedPosToInsert;
 }
 
 void BasketScene::resetInsertionData()
 {
     m_clickedToInsert = nullptr;
     m_zoneToInsert = 0;
     m_posToInsert = QPoint(-1, -1);
 }
 
 void BasketScene::hideInsertPopupMenu()
 {
     QTimer::singleShot(50 /*ms*/, this, SLOT(timeoutHideInsertPopupMenu()));
 }
 
 void BasketScene::timeoutHideInsertPopupMenu()
 {
     resetInsertionData();
 }
 
 void BasketScene::acceptDropEvent(QGraphicsSceneDragDropEvent *event, bool preCond)
 {
     // FIXME: Should not accept all actions! Or not all actions (link not supported?!)
     // event->acceptAction(preCond && 1);
     // event->accept(preCond);
     event->setAccepted(preCond);
 }
 
 void BasketScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
     // Now disallow drag and mouse redirection
     m_canDrag = false;
 
     if (m_editorTrackMouseEvent) {
         m_editorTrackMouseEvent = false;
         m_editor->endSelection(m_pressPos);
         return;
     }
 
     // Cancel Resizer move:
     if (m_resizingNote) {
         m_resizingNote = nullptr;
         m_pickedResizer = 0;
         m_lockedHovering = false;
         doHoverEffects();
         save();
     }
 
     // Cancel Note move:
     /*  if (m_movingNote) {
             m_movingNote   = 0;
             m_pickedHandle = QPoint(0, 0);
             m_lockedHovering = false;
             //doHoverEffects();
             save();
     }*/
 
     // Cancel Selection rectangle:
     if (m_isSelecting) {
         m_isSelecting = false;
         stopAutoScrollSelection();
         resetWasInLastSelectionRect();
         doHoverEffects();
         invalidate(m_selectionRect);
     }
     m_selectionStarted = false;
 
     Note *clicked = noteAt(event->scenePos());
     Note::Zone zone = (clicked ? clicked->zoneAt(event->scenePos() - QPointF(clicked->x(), clicked->y())) : Note::None);
     if ((zone == Note::Handle || zone == Note::Group) && editedNote() && editedNote() == clicked) {
         if (m_ignoreCloseEditorOnNextMouseRelease)
             m_ignoreCloseEditorOnNextMouseRelease = false;
         else {
             bool editedNoteStillThere = closeEditor();
             if (editedNoteStillThere)
                 // clicked->setSelected(true);
                 unselectAllBut(clicked);
         }
     }
 
     /*
         if (event->buttons() == 0 && (zone == Note::Group || zone == Note::Handle)) {
             closeEditor();
             unselectAllBut(clicked);
         }
     */
 
     // Do nothing if an action has already been made during mousePressEvent,
     // or if user made a selection and canceled it by regressing to a very small rectangle.
     if (m_noActionOnMouseRelease)
         return;
 
     // We immediately set it to true, to avoid actions set on mouseRelease if NO mousePress event has been triggered.
     // This is the case when a popup menu is shown, and user click to the basket area to close it:
     // the menu then receive the mousePress event and the basket area ONLY receive the mouseRelease event.
     // Obviously, nothing should be done in this case:
     m_noActionOnMouseRelease = true;
 
     if (event->button() == Qt::MidButton && zone != Note::Resizer && (!isDuringEdit() || clicked != editedNote())) {
         if ((Settings::middleAction() != 0) && (event->modifiers() == Qt::ShiftModifier)) {
             m_clickedToInsert = clicked;
             m_zoneToInsert = zone;
             m_posToInsert = event->scenePos();
             closeEditor();
             removeInserter();                    // If clicked at an insertion line and the new note shows a dialog for editing,
             NoteType::Id type = (NoteType::Id)0; //  hide that inserter before the note edition instead of after the dialog is closed
             switch (Settings::middleAction()) {
             case 5:
                 type = NoteType::Color;
                 break;
             case 6:
                 Global::bnpView->grabScreenshot();
                 return;
             case 7:
                 Global::bnpView->slotColorFromScreen();
                 return;
             case 8:
                 Global::bnpView->insertWizard(3); // loadFromFile
                 return;
             case 9:
                 Global::bnpView->insertWizard(1); // importKMenuLauncher
                 return;
             case 10:
                 Global::bnpView->insertWizard(2); // importIcon
                 return;
             }
             if (type != 0) {
                 m_ignoreCloseEditorOnNextMouseRelease = true;
                 Global::bnpView->insertEmpty(type);
                 return;
             }
         }
     }
 
     //  Note *clicked = noteAt(event->pos().x(), event->pos().y());
     if (!clicked) {
         if (isFreeLayout() && event->button() == Qt::LeftButton) {
             clickedToInsert(event);
             save();
         }
 
         return;
     }
     //  Note::Zone zone = clicked->zoneAt( event->pos() - QPoint(clicked->x(), clicked->y()) );
 
     // Convenient variables:
     bool controlPressed = event->modifiers() & Qt::ControlModifier;
     bool shiftPressed = event->modifiers() & Qt::ShiftModifier;
 
     if (clicked && zone != Note::None && zone != Note::BottomColumn && zone != Note::Resizer && (controlPressed || shiftPressed)) {
         if (controlPressed && shiftPressed)
             selectRange(m_startOfShiftSelectionNote, clicked, /*unselectOthers=*/false);
         else if (shiftPressed)
             selectRange(m_startOfShiftSelectionNote, clicked);
         else if (controlPressed)
             clicked->setSelectedRecursively(!clicked->allSelected());
         setFocusedNote(clicked); /// /// ///
         m_startOfShiftSelectionNote = (clicked->isGroup() ? clicked->firstRealChild() : clicked);
         m_noActionOnMouseRelease = true;
 
         return;
     }
 
     // Switch tag states:
     if (zone >= Note::Emblem0) {
         if (event->button() == Qt::LeftButton) {
             int icons = -1;
             for (State::List::iterator it = clicked->states().begin(); it != clicked->states().end(); ++it) {
                 if (!(*it)->emblem().isEmpty())
                     icons++;
                 if (icons == zone - Note::Emblem0) {
                     State *state = (*it)->nextState();
                     if (!state)
                         return;
                     it = clicked->states().insert(it, state);
                     ++it;
                     clicked->states().erase(it);
                     clicked->recomputeStyle();
                     clicked->unbufferize();
                     clicked->update();
                     updateEditorAppearance();
                     filterAgain();
                     save();
                     break;
                 }
             }
 
             return;
         } /* else if (event->button() == Qt::RightButton) {
          popupEmblemMenu(clicked, zone - Note::Emblem0);
          return;
      }*/
     }
 
     // Insert note or past clipboard:
     QString link;
     if (event->button() == Qt::MidButton && zone == Note::Resizer) {
         return; // zone = clicked->zoneAt( event->pos() - QPoint(clicked->x(), clicked->y()), true );
     }
     if (event->button() == Qt::RightButton && (clicked->isColumn() || zone == Note::Resizer)) {
         return;
     }
     if (clicked->isGroup() && zone == Note::None) {
         return;
     }
     switch (zone) {
     case Note::Handle:
     case Note::Group:
         // We select note on mousePress if it was unselected or Ctrl is pressed.
         // But the user can want to drag select_s_ notes, so it the note is selected, we only select it alone on mouseRelease:
         if (event->buttons() == 0) {
             qDebug() << "EXEC";
             if (!(event->modifiers() & Qt::ControlModifier) && clicked->allSelected())
                 unselectAllBut(clicked);
             if (zone == Note::Handle && isDuringEdit() && editedNote() == clicked) {
                 closeEditor();
                 clicked->setSelected(true);
             }
         }
         break;
 
     case Note::Custom0:
         // unselectAllBut(clicked);
         setFocusedNote(clicked);
         noteOpen(clicked);
         break;
 
     case Note::GroupExpander:
     case Note::TagsArrow:
         break;
 
     case Note::Link:
         link = clicked->linkAt(event->scenePos() - QPoint(clicked->x(), clicked->y()));
         if (!link.isEmpty()) {
             if (link == "basket-internal-remove-basket") {
                 // TODO: ask confirmation: "Do you really want to delete the welcome baskets?\n You can re-add them at any time in the Help menu."
                 Global::bnpView->doBasketDeletion(this);
             } else if (link == "basket-internal-import") {
                 QMenu *menu = Global::bnpView->popupMenu("fileimport");
                 menu->exec(event->screenPos());
             } else if (link.startsWith("basket://")) {
                 Q_EMIT crossReference(link);
             } else {
                 KRun *run = new KRun(QUrl::fromUserInput(link), m_view->window()); //  open the URL.
                 run->setAutoDelete(true);
             }
             break;
         } // If there is no link, edit note content
     case Note::Content: {
         if (m_editor && m_editor->note() == clicked && m_editor->graphicsWidget()) {
             m_editor->setCursorTo(event->scenePos());
         } else {
             closeEditor();
             unselectAllBut(clicked);
             noteEdit(clicked, /*justAdded=*/false, event->scenePos());
             QGraphicsScene::mouseReleaseEvent(event);
         }
         break;
     }
     case Note::TopInsert:
     case Note::TopGroup:
     case Note::BottomInsert:
     case Note::BottomGroup:
     case Note::BottomColumn:
         clickedToInsert(event, clicked, zone);
         save();
         break;
 
     case Note::None:
     default:
         KMessageBox::information(m_view->viewport(),
                                  i18n("This message should never appear. If it does, this program is buggy! "
                                       "Please report the bug to the developer."));
         break;
     }
 }
 
 void BasketScene::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
 {
     Note *clicked = noteAt(event->scenePos());
     Note::Zone zone = (clicked ? clicked->zoneAt(event->scenePos() - QPointF(clicked->x(), clicked->y())) : Note::None);
 
     if (event->button() == Qt::LeftButton && (zone == Note::Group || zone == Note::Handle)) {
         doCopy(CopyToSelection);
         m_noActionOnMouseRelease = true;
     } else
         mousePressEvent(event);
 }
 
 void BasketScene::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 {
     // redirect this event to the editor if track mouse event is active
     if (m_editorTrackMouseEvent && (m_pressPos - event->scenePos()).manhattanLength() > QApplication::startDragDistance()) {
         m_editor->updateSelection(event->scenePos());
         return;
     }
 
     // Drag the notes:
     if (m_canDrag && (m_pressPos - event->scenePos()).manhattanLength() > QApplication::startDragDistance()) {
         m_canDrag = false;
         m_isSelecting = false; // Don't draw selection rectangle after drag!
         m_selectionStarted = false;
 
         NoteSelection *selection = selectedNotes();
         if (selection->firstStacked()) {
             QDrag *d = NoteDrag::dragObject(selection, /*cutting=*/false, /*source=*/m_view); // d will be deleted by QT
             /*bool shouldRemove = */ d->exec();
             //      delete selection;
 
             // Never delete because URL is dragged and the file must be available for the extern application
             //      if (shouldRemove && d->target() == 0) // If target is another application that request to remove the note
             //          Q_EMIT wantDelete(this);
         }
         return;
     }
 
     // Moving a Resizer:
     if (m_resizingNote) {
         qreal groupWidth = event->scenePos().x() - m_resizingNote->x() - m_pickedResizer;
         qreal minRight = m_resizingNote->minRight();
         //        int maxRight   = 100 * contentsWidth(); // A big enough value (+infinity) for free layouts.
         qreal maxRight = 100 * sceneRect().width(); // A big enough value (+infinity) for free layouts.
         Note *nextColumn = m_resizingNote->next();
         if (m_resizingNote->isColumn()) {
             if (nextColumn)
                 maxRight = nextColumn->x() + nextColumn->rightLimit() - nextColumn->minRight() - Note::RESIZER_WIDTH;
             else
                 //                maxRight = contentsWidth();
                 maxRight = sceneRect().width();
         }
         if (groupWidth > maxRight - m_resizingNote->x())
             groupWidth = maxRight - m_resizingNote->x();
         if (groupWidth < minRight - m_resizingNote->x())
             groupWidth = minRight - m_resizingNote->x();
         qreal delta = groupWidth - m_resizingNote->groupWidth();
         m_resizingNote->setGroupWidth(groupWidth);
         // If resizing columns:
         if (m_resizingNote->isColumn()) {
             Note *column = m_resizingNote;
             if ((column = column->next())) {
                 // Next columns should not have them X coordinate animated, because it would flicker:
                 column->setXRecursively(column->x() + delta);
                 // And the resizer should resize the TWO sibling columns, and not push the other columns on th right:
                 column->setGroupWidth(column->groupWidth() - delta);
             }
         }
         relayoutNotes();
     }
 
     // Moving a Note:
     /*  if (m_movingNote) {
             int x = event->pos().x() - m_pickedHandle.x();
             int y = event->pos().y() - m_pickedHandle.y();
             if (x < 0) x = 0;
             if (y < 0) y = 0;
             m_movingNote->setX(x);
             m_movingNote->setY(y);
             m_movingNote->relayoutAt(x, y, / *animate=* /false);
             relayoutNotes(true);
         }
     */
 
     // Dragging the selection rectangle:
     if (m_selectionStarted)
         doAutoScrollSelection();
 
     doHoverEffects(event->scenePos());
 }
 
 void BasketScene::doAutoScrollSelection()
 {
     static const int AUTO_SCROLL_MARGIN = 50; // pixels
     static const int AUTO_SCROLL_DELAY = 100; // milliseconds
 
     QPoint pos = m_view->mapFromGlobal(QCursor::pos());
     // Do the selection:
     if (m_isSelecting)
         invalidate(m_selectionRect);
 
     m_selectionEndPoint = m_view->mapToScene(pos);
     m_selectionRect = QRectF(m_selectionBeginPoint, m_selectionEndPoint).normalized();
     if (m_selectionRect.left() < 0)
         m_selectionRect.setLeft(0);
     if (m_selectionRect.top() < 0)
         m_selectionRect.setTop(0);
     //    if (m_selectionRect.right() >= contentsWidth())    m_selectionRect.setRight(contentsWidth() - 1);
     //    if (m_selectionRect.bottom() >= contentsHeight())  m_selectionRect.setBottom(contentsHeight() - 1);
     if (m_selectionRect.right() >= sceneRect().width())
         m_selectionRect.setRight(sceneRect().width() - 1);
     if (m_selectionRect.bottom() >= sceneRect().height())
         m_selectionRect.setBottom(sceneRect().height() - 1);
 
     if ((m_selectionBeginPoint - m_selectionEndPoint).manhattanLength() > QApplication::startDragDistance()) {
         m_isSelecting = true;
         selectNotesIn(m_selectionRect, m_selectionInvert);
         invalidate(m_selectionRect);
         m_noActionOnMouseRelease = true;
     } else {
         // If the user was selecting but cancel by making the rectangle too small, cancel it really!!!
         if (m_isSelecting) {
             if (m_selectionInvert)
                 selectNotesIn(QRectF(), m_selectionInvert);
             else
                 unselectAllBut(nullptr); // TODO: unselectAll();
         }
         if (m_isSelecting)
             resetWasInLastSelectionRect();
         m_isSelecting = false;
         stopAutoScrollSelection();
 
         return;
     }
 
     // Do the auto-scrolling:
     // FIXME: It's still flickering
 
     //    QRectF insideRect(AUTO_SCROLL_MARGIN, AUTO_SCROLL_MARGIN, visibleWidth() - 2*AUTO_SCROLL_MARGIN, visibleHeight() - 2*AUTO_SCROLL_MARGIN);
     // QRectF insideRect(AUTO_SCROLL_MARGIN, AUTO_SCROLL_MARGIN, m_view->viewport()->width() - 2 * AUTO_SCROLL_MARGIN, m_view->viewport()->height() - 2 * AUTO_SCROLL_MARGIN);
 
     int dx = 0;
     int dy = 0;
 
     if (pos.y() < AUTO_SCROLL_MARGIN)
         dy = pos.y() - AUTO_SCROLL_MARGIN;
     else if (pos.y() > m_view->viewport()->height() - AUTO_SCROLL_MARGIN)
         dy = pos.y() - m_view->viewport()->height() + AUTO_SCROLL_MARGIN;
     //    else if (pos.y() > visibleHeight() - AUTO_SCROLL_MARGIN)
     //        dy = pos.y() - visibleHeight() + AUTO_SCROLL_MARGIN;
 
     if (pos.x() < AUTO_SCROLL_MARGIN)
         dx = pos.x() - AUTO_SCROLL_MARGIN;
     else if (pos.x() > m_view->viewport()->width() - AUTO_SCROLL_MARGIN)
         dx = pos.x() - m_view->viewport()->width() + AUTO_SCROLL_MARGIN;
     //    else if (pos.x() > visibleWidth() - AUTO_SCROLL_MARGIN)
     //        dx = pos.x() - visibleWidth() + AUTO_SCROLL_MARGIN;
 
     if (dx || dy) {
         qApp->sendPostedEvents(); // Do the repaints, because the scrolling will make the area to repaint to be wrong
                                   //        scrollBy(dx, dy);
         if (!m_autoScrollSelectionTimer.isActive())
             m_autoScrollSelectionTimer.start(AUTO_SCROLL_DELAY);
     } else
         stopAutoScrollSelection();
 }
 
 void BasketScene::stopAutoScrollSelection()
 {
     m_autoScrollSelectionTimer.stop();
 }
 
 void BasketScene::resetWasInLastSelectionRect()
 {
     Note *note = m_firstNote;
     while (note) {
         note->resetWasInLastSelectionRect();
         note = note->next();
     }
 }
 
 void BasketScene::selectAll()
 {
     if (redirectEditActions()) {
         if (m_editor->textEdit())
             m_editor->textEdit()->selectAll();
         else if (m_editor->lineEdit())
             m_editor->lineEdit()->selectAll();
     } else {
         // First select all in the group, then in the parent group...
         Note *child = m_focusedNote;
         Note *parent = (m_focusedNote ? m_focusedNote->parentNote() : nullptr);
         while (parent) {
             if (!parent->allSelected()) {
                 parent->setSelectedRecursively(true);
                 return;
             }
             child = parent;
             parent = parent->parentNote();
         }
         // Then, select all:
         FOR_EACH_NOTE(note)
         note->setSelectedRecursively(true);
     }
 }
 
 void BasketScene::unselectAll()
 {
     if (redirectEditActions()) {
         if (m_editor->textEdit()) {
             QTextCursor cursor = m_editor->textEdit()->textCursor();
             cursor.clearSelection();
             m_editor->textEdit()->setTextCursor(cursor);
             selectionChangedInEditor(); // THIS IS NOT EMITTED BY Qt!!!
         } else if (m_editor->lineEdit())
             m_editor->lineEdit()->deselect();
     } else {
         if (countSelecteds() > 0) // Optimization
             FOR_EACH_NOTE(note)
         note->setSelectedRecursively(false);
     }
 }
 
 void BasketScene::invertSelection()
 {
     FOR_EACH_NOTE(note)
     note->invertSelectionRecursively();
 }
 
 void BasketScene::unselectAllBut(Note *toSelect)
 {
     FOR_EACH_NOTE(note)
     note->unselectAllBut(toSelect);
 }
 
 void BasketScene::invertSelectionOf(Note *toSelect)
 {
     FOR_EACH_NOTE(note)
     note->invertSelectionOf(toSelect);
 }
 
 void BasketScene::selectNotesIn(const QRectF &rect, bool invertSelection, bool unselectOthers /*= true*/)
 {
     FOR_EACH_NOTE(note)
     note->selectIn(rect, invertSelection, unselectOthers);
 }
 
 void BasketScene::doHoverEffects()
 {
     doHoverEffects(m_view->mapToScene(m_view->viewport()->mapFromGlobal(QCursor::pos())));
 }
 
 void BasketScene::doHoverEffects(Note *note, Note::Zone zone, const QPointF &pos)
 {
     // Inform the old and new hovered note (if any):
     Note *oldHoveredNote = m_hoveredNote;
     if (note != m_hoveredNote) {
         if (m_hoveredNote) {
             m_hoveredNote->setHovered(false);
             m_hoveredNote->setHoveredZone(Note::None);
             m_hoveredNote->update();
         }
         m_hoveredNote = note;
         if (m_hoveredNote) {
             m_hoveredNote->setHovered(true);
         }
     }
 
     // If we are hovering a note, compute which zone is hovered and inform the note:
     if (m_hoveredNote) {
         if (zone != m_hoveredZone || oldHoveredNote != m_hoveredNote) {
             m_hoveredZone = zone;
             m_hoveredNote->setHoveredZone(zone);
             m_view->viewport()->setCursor(m_hoveredNote->cursorFromZone(zone));
 
             m_hoveredNote->update();
         }
 
         // If we are hovering an insert line zone, update this thing:
         if (zone == Note::TopInsert || zone == Note::TopGroup || zone == Note::BottomInsert || zone == Note::BottomGroup || zone == Note::BottomColumn) {
             placeInserter(m_hoveredNote, zone);
         } else {
             removeInserter();
         }
         // If we are hovering an embedded link in a rich text element, show the destination in the statusbar:
         if (zone == Note::Link)
             Q_EMIT setStatusBarText(m_hoveredNote->linkAt(pos - QPoint(m_hoveredNote->x(), m_hoveredNote->y())));
         else if (m_hoveredNote->content())
             Q_EMIT setStatusBarText(m_hoveredNote->content()->statusBarMessage(m_hoveredZone)); // resetStatusBarText();
         // If we aren't hovering a note, reset all:
     } else {
         if (isFreeLayout() && !isSelecting())
             m_view->viewport()->setCursor(Qt::CrossCursor);
         else
             m_view->viewport()->unsetCursor();
         m_hoveredZone = Note::None;
         removeInserter();
         Q_EMIT resetStatusBarText();
     }
 }
 
 void BasketScene::doHoverEffects(const QPointF &pos)
 {
     //  if (isDuringEdit())
     //      viewport()->unsetCursor();
 
     // Do we have the right to do hover effects?
     if (!m_loaded || m_lockedHovering) {
         return;
     }
 
     // enterEvent() (mouse enter in the widget) set m_underMouse to true, and leaveEvent() make it false.
     // But some times the enterEvent() is not trigerred: eg. when dragging the scrollbar:
     // Ending the drag INSIDE the basket area will make NO hoverEffects() because m_underMouse is false.
     // User need to leave the area and re-enter it to get effects.
     // This hack solve that by dismissing the m_underMouse variable:
 
     // Don't do hover effects when a popup menu is opened.
     // Primarily because the basket area will only receive mouseEnterEvent and mouveLeaveEvent.
     // It willn't be noticed of mouseMoveEvent, which would result in a apparently broken application state:
     bool underMouse = !qApp->activePopupWidget();
     // if (qApp->activePopupWidget())
     //    underMouse = false;
 
     // Compute which note is hovered:
     Note *note = (m_isSelecting || !underMouse ? nullptr : noteAt(pos));
     Note::Zone zone = (note ? note->zoneAt(pos - QPointF(note->x(), note->y()), isDuringDrag()) : Note::None);
 
     // Inform the old and new hovered note (if any) and update the areas:
     doHoverEffects(note, zone, pos);
 }
 
 void BasketScene::mouseEnteredEditorWidget()
 {
     if (!m_lockedHovering && !qApp->activePopupWidget())
         doHoverEffects(editedNote(), Note::Content, QPoint());
 }
 
 void BasketScene::removeInserter()
 {
     if (m_inserterShown) { // Do not hide (and then update/repaint the view) if it is already hidden!
         m_inserterShown = false;
         invalidate(m_inserterRect);
     }
 }
 
 void BasketScene::placeInserter(Note *note, int zone)
 {
     // Remove the inserter:
     if (!note) {
         removeInserter();
         return;
     }
 
     // Update the old position:
     if (inserterShown()) {
         invalidate(m_inserterRect);
     }
     // Some commodities:
     m_inserterShown = true;
     m_inserterTop = (zone == Note::TopGroup || zone == Note::TopInsert);
     m_inserterGroup = (zone == Note::TopGroup || zone == Note::BottomGroup);
     // X and width:
     qreal groupIndent = (note->isGroup() ? note->width() : Note::HANDLE_WIDTH);
     qreal x = note->x();
     qreal width = (note->isGroup() ? note->rightLimit() - note->x() : note->width());
     if (m_inserterGroup) {
         x += groupIndent;
         width -= groupIndent;
     }
     m_inserterSplit = (Settings::groupOnInsertionLine() && note && !note->isGroup() && !note->isFree() && !note->isColumn());
     //  if (note->isGroup())
     //      width = note->rightLimit() - note->x() - (m_inserterGroup ? groupIndent : 0);
     // Y:
     qreal y = note->y() - (m_inserterGroup && m_inserterTop ? 1 : 3);
     if (!m_inserterTop)
         y += (note->isColumn() ? note->height() : note->height());
     // Assigning result:
     m_inserterRect = QRectF(x, y, width, 6 - (m_inserterGroup ? 2 : 0));
     // Update the new position:
     invalidate(m_inserterRect);
 }
 
 inline void drawLineByRect(QPainter &painter, qreal x, qreal y, qreal width, qreal height)
 {
     painter.drawLine(x, y, x + width - 1, y + height - 1);
 }
 
 void BasketScene::drawInserter(QPainter &painter, qreal xPainter, qreal yPainter)
 {
     if (!m_inserterShown)
         return;
 
     QRectF rect = m_inserterRect; // For shorter code-lines when drawing!
     rect.translate(-xPainter, -yPainter);
     int lineY = (m_inserterGroup && m_inserterTop ? 0 : 2);
     int roundY = (m_inserterGroup && m_inserterTop ? 0 : 1);
 
     KStatefulBrush statefulBrush(KColorScheme::View, KColorScheme::HoverColor);
     const QColor highlightColor = palette().color(QPalette::Highlight).lighter();
     painter.setPen(highlightColor);
     // The horizontal line:
     // painter.drawRect(       rect.x(),                    rect.y() + lineY,  rect.width(), 2);
     int width = rect.width() - 4;
     painter.fillRect(rect.x() + 2, rect.y() + lineY, width, 2, highlightColor);
     // The left-most and right-most edges (biggest vertical lines):
     drawLineByRect(painter, rect.x(), rect.y(), 1, (m_inserterGroup ? 4 : 6));
     drawLineByRect(painter, rect.x() + rect.width() - 1, rect.y(), 1, (m_inserterGroup ? 4 : 6));
     // The left and right mid vertical lines:
     drawLineByRect(painter, rect.x() + 1, rect.y() + roundY, 1, (m_inserterGroup ? 3 : 4));
     drawLineByRect(painter, rect.x() + rect.width() - 2, rect.y() + roundY, 1, (m_inserterGroup ? 3 : 4));
     // Draw the split as a feedback to know where is the limit between insert and group:
     if (m_inserterSplit) {
         int noteWidth = rect.width() + (m_inserterGroup ? Note::HANDLE_WIDTH : 0);
         int xSplit = rect.x() - (m_inserterGroup ? Note::HANDLE_WIDTH : 0) + noteWidth / 2;
         painter.drawRect(xSplit - 2, rect.y() + lineY, 4, 2);
         painter.drawRect(xSplit - 1, rect.y() + lineY, 2, 2);
     }
 }
 
 void BasketScene::helpEvent(QGraphicsSceneHelpEvent *event)
 {
     if (!m_loaded || !Settings::showNotesToolTip())
         return;
 
     QString message;
     QRectF rect;
 
     QPointF contentPos = event->scenePos();
     Note *note = noteAt(contentPos);
 
     if (!note && isFreeLayout()) {
         message = i18n("Insert note here\nRight click for more options");
         QRectF itRect;
         for (QList<QRectF>::iterator it = m_blankAreas.begin(); it != m_blankAreas.end(); ++it) {
             itRect = QRectF(0, 0, m_view->viewport()->width(), m_view->viewport()->height()).intersected(*it);
             if (itRect.contains(contentPos)) {
                 rect = itRect;
                 rect.moveLeft(rect.left() - sceneRect().x());
                 rect.moveTop(rect.top() - sceneRect().y());
                 break;
             }
         }
     } else {
         if (!note)
             return;
 
         Note::Zone zone = note->zoneAt(contentPos - QPointF(note->x(), note->y()));
 
         switch (zone) {
         case Note::Resizer:
             message = (note->isColumn() ? i18n("Resize those columns") : (note->isGroup() ? i18n("Resize this group") : i18n("Resize this note")));
             break;
         case Note::Handle:
             message = i18n("Select or move this note");
             break;
         case Note::Group:
             message = i18n("Select or move this group");
             break;
         case Note::TagsArrow:
             message = i18n("Assign or remove tags from this note");
             if (note->states().count() > 0) {
                 QString tagsString;
                 for (State::List::iterator it = note->states().begin(); it != note->states().end(); ++it) {
                     QString tagName = "<nobr>" + Tools::textToHTMLWithoutP((*it)->fullName()) + "</nobr>";
                     if (tagsString.isEmpty())
                         tagsString = tagName;
                     else
                         tagsString = i18n("%1, %2", tagsString, tagName);
                 }
                 message = "<qt><nobr>" + message + "</nobr><br>" + i18n("<b>Assigned Tags</b>: %1", tagsString);
             }
             break;
         case Note::Custom0:
             message = note->content()->zoneTip(zone);
             break; //"Open this link/Open this file/Open this sound file/Launch this application"
         case Note::GroupExpander:
             message = (note->isFolded() ? i18n("Expand this group") : i18n("Collapse this group"));
             break;
         case Note::Link:
         case Note::Content:
             message = note->content()->editToolTipText();
             break;
         case Note::TopInsert:
         case Note::BottomInsert:
             message = i18n("Insert note here\nRight click for more options");
             break;
         case Note::TopGroup:
             message = i18n("Group note with the one below\nRight click for more options");
             break;
         case Note::BottomGroup:
             message = i18n("Group note with the one above\nRight click for more options");
             break;
         case Note::BottomColumn:
             message = i18n("Insert note here\nRight click for more options");
             break;
         case Note::None:
             message = "** Zone NONE: internal error **";
             break;
         default:
             if (zone >= Note::Emblem0)
                 message = note->stateForEmblemNumber(zone - Note::Emblem0)->fullName();
             else
                 message = QString();
             break;
         }
 
         if (zone == Note::Content || zone == Note::Link || zone == Note::Custom0) {
             QStringList keys;
             QStringList values;
 
             note->content()->toolTipInfos(&keys, &values);
             keys.append(i18n("Added"));
             keys.append(i18n("Last Modification"));
             values.append(note->addedStringDate());
             values.append(note->lastModificationStringDate());
 
             message = "<qt><nobr>" + message;
             QStringList::iterator key;
             QStringList::iterator value;
             for (key = keys.begin(), value = values.begin(); key != keys.end() && value != values.end(); ++key, ++value)
                 message += "<br>" + i18nc("of the form 'key: value'", "<b>%1</b>: %2", *key, *value);
             message += "</nobr></qt>";
         } else if (m_inserterSplit && (zone == Note::TopInsert || zone == Note::BottomInsert))
             message += '\n' + i18n("Click on the right to group instead of insert");
         else if (m_inserterSplit && (zone == Note::TopGroup || zone == Note::BottomGroup))
             message += '\n' + i18n("Click on the left to insert instead of group");
 
         rect = note->zoneRect(zone, contentPos - QPoint(note->x(), note->y()));
 
         rect.moveLeft(rect.left() - sceneRect().x());
         rect.moveTop(rect.top() - sceneRect().y());
 
         rect.moveLeft(rect.left() + note->x());
         rect.moveTop(rect.top() + note->y());
     }
 
     QToolTip::showText(event->screenPos(), message, m_view, rect.toRect());
 }
 
 Note *BasketScene::lastNote()
 {
     Note *note = firstNote();
     while (note && note->next())
         note = note->next();
     return note;
 }
 
 void BasketScene::deleteNotes()
 {
     Note *note = m_firstNote;
 
     while (note) {
         Note *tmp = note->next();
         delete note;
         note = tmp;
     }
     m_firstNote = nullptr;
     m_resizingNote = nullptr;
     m_movingNote = nullptr;
     m_focusedNote = nullptr;
     m_startOfShiftSelectionNote = nullptr;
     m_tagPopupNote = nullptr;
     m_clickedToInsert = nullptr;
     m_savedClickedToInsert = nullptr;
     m_hoveredNote = nullptr;
     m_count = 0;
     m_countFounds = 0;
     m_countSelecteds = 0;
 
     emit resetStatusBarText();
     emit countsChanged(this);
 }
 
 Note *BasketScene::noteAt(QPointF pos)
 {
     qreal x = pos.x();
     qreal y = pos.y();
     // NO:
     //  // Do NOT check the bottom&right borders.
     //  // Because imagine someone drag&drop a big note from the top to the bottom of a big basket (with big vertical scrollbars),
     //  // the note is first removed, and relayoutNotes() compute the new height that is smaller
     //  // Then noteAt() is called for the mouse pointer position, because the basket is now smaller, the cursor is out of boundaries!!!
     //  // Should, of course, not return 0:
     if (x < 0 || x > sceneRect().width() || y < 0 || y > sceneRect().height())
         return nullptr;
 
     // When resizing a note/group, keep it highlighted:
     if (m_resizingNote)
         return m_resizingNote;
 
     // Search and return the hovered note:
     Note *note = m_firstNote;
     Note *possibleNote;
     while (note) {
         possibleNote = note->noteAt(pos);
         if (possibleNote) {
             if (NoteDrag::selectedNotes.contains(possibleNote) || draggedNotes().contains(possibleNote))
                 return nullptr;
             else
                 return possibleNote;
         }
         note = note->next();
     }
 
     // If the basket is layouted in columns, return one of the columns to be able to add notes in them:
     if (isColumnsLayout()) {
         Note *column = m_firstNote;
         while (column) {
             if (x >= column->x() && x < column->rightLimit())
                 return column;
             column = column->next();
         }
     }
 
     // Nothing found, no note is hovered:
     return nullptr;
 }
 
 BasketScene::~BasketScene()
 {
     m_commitdelay.stop(); // we don't know how long deleteNotes() last so we want to make extra sure that nobody will commit in between
     if (m_decryptBox)
         delete m_decryptBox;
 #ifdef HAVE_LIBGPGME
     delete m_gpg;
 #endif
     deleteNotes();
 
     if (m_view)
         delete m_view;
 }
 
 QColor BasketScene::selectionRectInsideColor()
 {
     return Tools::mixColor(Tools::mixColor(backgroundColor(), palette().color(QPalette::Highlight)), backgroundColor());
 }
 
 QColor alphaBlendColors(const QColor &bgColor, const QColor &fgColor, const int a)
 {
     // normal button...
     QRgb rgb = bgColor.rgb();
     QRgb rgb_b = fgColor.rgb();
     int alpha = a;
     if (alpha > 255)
         alpha = 255;
     if (alpha < 0)
         alpha = 0;
     int inv_alpha = 255 - alpha;
     QColor result = QColor(qRgb(qRed(rgb_b) * inv_alpha / 255 + qRed(rgb) * alpha / 255, qGreen(rgb_b) * inv_alpha / 255 + qGreen(rgb) * alpha / 255, qBlue(rgb_b) * inv_alpha / 255 + qBlue(rgb) * alpha / 255));
 
     return result;
 }
 
 void BasketScene::unlock()
 {
     QTimer::singleShot(0, this, SLOT(load()));
 }
 
 void BasketScene::inactivityAutoLockTimeout()
 {
     lock();
 }
 
 void BasketScene::drawBackground(QPainter *painter, const QRectF &rect)
 {
     if (!m_loadingLaunched) {
         if (!m_locked) {
             QTimer::singleShot(0, this, SLOT(load()));
             return;
         } else {
             Global::bnpView->notesStateChanged(); // Show "Locked" instead of "Loading..." in the statusbar
         }
     }
 
     if (!hasBackgroundImage()) {
         painter->fillRect(rect, backgroundColor());
         // It's either a background pixmap to draw or a background color to fill:
     } else if (isTiledBackground() || (rect.x() < backgroundPixmap()->width() && rect.y() < backgroundPixmap()->height())) {
         painter->fillRect(rect, backgroundColor());
         blendBackground(*painter, rect, 0, 0, /*opaque=*/true);
     } else {
         painter->fillRect(rect, backgroundColor());
     }
 }
 
 void BasketScene::drawForeground(QPainter *painter, const QRectF &rect)
 {
     if (m_locked) {
         if (!m_decryptBox) {
             m_decryptBox = new QFrame(m_view);
             m_decryptBox->setFrameShape(QFrame::StyledPanel);
             m_decryptBox->setFrameShadow(QFrame::Plain);
             m_decryptBox->setLineWidth(1);
 
             QGridLayout *layout = new QGridLayout(m_decryptBox);
             layout->setContentsMargins(11, 11, 11, 11);
             layout->setSpacing(6);
 
 #ifdef HAVE_LIBGPGME
             m_button = new QPushButton(m_decryptBox);
             m_button->setText(i18n("&Unlock"));
             layout->addWidget(m_button, 1, 2);
             connect(m_button, &QButton::clicked, this, &BasketScene::unlock);
 #endif
             QLabel *label = new QLabel(m_decryptBox);
             QString text = "<b>" + i18n("Password protected basket.") + "</b><br/>";
 #ifdef HAVE_LIBGPGME
             label->setText(text + i18n("Press Unlock to access it."));
 #else
             label->setText(text + i18n("Encryption is not supported by<br/>this version of %1.", QGuiApplication::applicationDisplayName()));
 #endif
             label->setAlignment(Qt::AlignTop);
             layout->addWidget(label, 0, 1, 1, 2);
             QLabel *pixmap = new QLabel(m_decryptBox);
             pixmap->setPixmap(KIconLoader::global()->loadIcon("encrypted", KIconLoader::NoGroup, KIconLoader::SizeHuge));
             layout->addWidget(pixmap, 0, 0, 2, 1);
 
             QSpacerItem *spacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
             layout->addItem(spacer, 1, 1);
 
             label = new QLabel("<small>" +
                                    i18n("To make baskets stay unlocked, change the automatic<br>"
                                         "locking duration in the application settings.") +
                                    "</small>",
                                m_decryptBox);
             label->setAlignment(Qt::AlignTop);
             layout->addWidget(label, 2, 0, 1, 3);
 
             m_decryptBox->resize(layout->sizeHint());
         }
         if (m_decryptBox->isHidden()) {
             m_decryptBox->show();
         }
 #ifdef HAVE_LIBGPGME
         m_button->setFocus();
 #endif
         m_decryptBox->move((m_view->viewport()->width() - m_decryptBox->width()) / 2, (m_view->viewport()->height() - m_decryptBox->height()) / 2);
     } else {
         if (m_decryptBox && !m_decryptBox->isHidden())
             m_decryptBox->hide();
     }
 
     if (!m_loaded) {
         setSceneRect(0, 0, m_view->viewport()->width(), m_view->viewport()->height());
         QBrush brush(backgroundColor());
         QPixmap pixmap(m_view->viewport()->width(), m_view->viewport()->height()); // TODO: Clip it to asked size only!
         QPainter painter2(&pixmap);
         QTextDocument rt;
         rt.setHtml(QString("<center>%1</center>").arg(i18n("Loading...")));
         rt.setTextWidth(m_view->viewport()->width());
         int hrt = rt.size().height();
         painter2.fillRect(0, 0, m_view->viewport()->width(), m_view->viewport()->height(), brush);
         blendBackground(painter2, QRectF(0, 0, m_view->viewport()->width(), m_view->viewport()->height()), -1, -1, /*opaque=*/true);
         QPalette pal = palette();
         pal.setColor(QPalette::WindowText, textColor());
         painter2.translate(0, (m_view->viewport()->height() - hrt) / 2);
         QAbstractTextDocumentLayout::PaintContext context;
         context.palette = pal;
         rt.documentLayout()->draw(&painter2, context);
         painter2.end();
         painter->drawPixmap(0, 0, pixmap);
         return; // TODO: Clip to the wanted rectangle
     }
 
     enableActions();
 
     if ((inserterShown() && rect.intersects(inserterRect())) || (m_isSelecting && rect.intersects(m_selectionRect))) {
         // Draw inserter:
         if (inserterShown() && rect.intersects(inserterRect())) {
             drawInserter(*painter, 0, 0);
         }
         // Draw selection rect:
         if (m_isSelecting && rect.intersects(m_selectionRect)) {
             QRectF selectionRect = m_selectionRect;
             QRectF selectionRectInside(selectionRect.x() + 1, selectionRect.y() + 1, selectionRect.width() - 2, selectionRect.height() - 2);
             if (selectionRectInside.width() > 0 && selectionRectInside.height() > 0) {
                 QColor insideColor = selectionRectInsideColor();
                 painter->fillRect(selectionRectInside, QBrush(insideColor, Qt::Dense4Pattern));
             }
             painter->setPen(palette().color(QPalette::Highlight).darker());
             painter->drawRect(selectionRect);
             painter->setPen(Tools::mixColor(palette().color(QPalette::Highlight).darker(), backgroundColor()));
             painter->drawPoint(selectionRect.topLeft());
             painter->drawPoint(selectionRect.topRight());
             painter->drawPoint(selectionRect.bottomLeft());
             painter->drawPoint(selectionRect.bottomRight());
         }
     }
 }
 
 /*  rect(x,y,width,height)==(xBackgroundToDraw,yBackgroundToDraw,widthToDraw,heightToDraw)
  */
 void BasketScene::blendBackground(QPainter &painter, const QRectF &rect, qreal xPainter, qreal yPainter, bool opaque, QPixmap *bg)
 {
     painter.save();
     if (xPainter == -1 && yPainter == -1) {
         xPainter = rect.x();
         yPainter = rect.y();
     }
 
     if (hasBackgroundImage()) {
         const QPixmap *bgPixmap = (bg ? /* * */ bg : (opaque ? m_opaqueBackgroundPixmap : m_backgroundPixmap));
         if (isTiledBackground()) {
             painter.drawTiledPixmap(rect.x() - xPainter, rect.y() - yPainter, rect.width(), rect.height(), *bgPixmap, rect.x(), rect.y());
         } else {
             painter.drawPixmap(QPointF(rect.x() - xPainter, rect.y() - yPainter), *bgPixmap, rect);
         }
     }
     painter.restore();
 }
 
 void BasketScene::recomputeBlankRects()
 {
     m_blankAreas.clear();
     return;
 
     m_blankAreas.append(QRectF(0, 0, sceneRect().width(), sceneRect().height()));
 
     FOR_EACH_NOTE(note)
     note->recomputeBlankRects(m_blankAreas);
 
     // See the drawing of blank areas in BasketScene::drawContents()
     if (hasBackgroundImage() && !isTiledBackground())
         substractRectOnAreas(QRectF(0, 0, backgroundPixmap()->width(), backgroundPixmap()->height()), m_blankAreas, false);
 }
 
 void BasketScene::unsetNotesWidth()
 {
     Note *note = m_firstNote;
     while (note) {
         note->unsetWidth();
         note = note->next();
     }
 }
 
 void BasketScene::relayoutNotes()
 {
     if (Global::bnpView->currentBasket() != this)
         return; // Optimize load time, and basket will be relaid out when activated, anyway
 
     int h = 0;
     tmpWidth = 0;
     tmpHeight = 0;
     Note *note = m_firstNote;
     while (note) {
         if (note->matching()) {
             note->relayoutAt(0, h);
             if (note->hasResizer()) {
                 int minGroupWidth = note->minRight() - note->x();
                 if (note->groupWidth() < minGroupWidth) {
                     note->setGroupWidth(minGroupWidth);
                     relayoutNotes(); // Redo the thing, but this time it should not recurse
                     return;
                 }
             }
             h += note->height();
         }
         note = note->next();
     }
 
     if (isFreeLayout())
         tmpHeight += 100;
     else
         tmpHeight += 15;
 
     setSceneRect(0, 0, qMax((qreal)m_view->viewport()->width(), tmpWidth), qMax((qreal)m_view->viewport()->height(), tmpHeight));
 
     recomputeBlankRects();
     placeEditor();
     doHoverEffects();
     invalidate();
 }
 
 void BasketScene::popupEmblemMenu(Note *note, int emblemNumber)
 {
     m_tagPopupNote = note;
     State *state = note->stateForEmblemNumber(emblemNumber);
     State *nextState = state->nextState(/*cycle=*/false);
     Tag *tag = state->parentTag();
     m_tagPopup = tag;
 
     QKeySequence sequence = tag->shortcut();
     bool sequenceOnDelete = (nextState == nullptr && !tag->shortcut().isEmpty());
 
     QMenu menu(m_view);
     if (tag->countStates() == 1) {
         menu.addSection(/*SmallIcon(state->icon()), */ tag->name());
         QAction *act;
         act = new QAction(QIcon::fromTheme("edit-delete"), i18n("&Remove"), &menu);
         act->setData(1);
         menu.addAction(act);
         act = new QAction(QIcon::fromTheme("configure"), i18n("&Customize..."), &menu);
         act->setData(2);
         menu.addAction(act);
 
         menu.addSeparator();
 
         act = new QAction(QIcon::fromTheme("search-filter"), i18n("&Filter by this Tag"), &menu);
         act->setData(3);
         menu.addAction(act);
     } else {
         menu.addSection(tag->name());
         QList<State *>::iterator it;
         State *currentState;
 
         int i = 10;
         // QActionGroup makes the actions exclusive; turns checkboxes into radio
         // buttons on some styles.
         QActionGroup *emblemGroup = new QActionGroup(&menu);
         for (it = tag->states().begin(); it != tag->states().end(); ++it) {
             currentState = *it;
             QKeySequence sequence;
             if (currentState == nextState && !tag->shortcut().isEmpty())
                 sequence = tag->shortcut();
 
             StateAction *sa = new StateAction(currentState, QKeySequence(sequence), nullptr, false);
             sa->setChecked(state == currentState);
             sa->setActionGroup(emblemGroup);
             sa->setData(i);
 
             menu.addAction(sa);
             if (currentState == nextState && !tag->shortcut().isEmpty())
                 sa->setShortcut(sequence);
             ++i;
         }
 
         menu.addSeparator();
 
         QAction *act = new QAction(&menu);
         act->setIcon(QIcon::fromTheme("edit-delete"));
         act->setText(i18n("&Remove"));
         act->setShortcut(sequenceOnDelete ? sequence : QKeySequence());
         act->setData(1);
         menu.addAction(act);
         act = new QAction(QIcon::fromTheme("configure"), i18n("&Customize..."), &menu);
         act->setData(2);
         menu.addAction(act);
 
         menu.addSeparator();
 
         act = new QAction(QIcon::fromTheme("search-filter"), i18n("&Filter by this Tag"), &menu);
         act->setData(3);
         menu.addAction(act);
         act = new QAction(QIcon::fromTheme("search-filter"), i18n("Filter by this &State"), &menu);
         act->setData(4);
         menu.addAction(act);
     }
 
     connect(&menu, &QMenu::triggered, this, &BasketScene::toggledStateInMenu);
     connect(&menu, &QMenu::aboutToHide, this, &BasketScene::unlockHovering);
     connect(&menu, &QMenu::aboutToHide, this, &BasketScene::disableNextClick);
 
     m_lockedHovering = true;
     menu.exec(QCursor::pos());
 }
 
 void BasketScene::toggledStateInMenu(QAction *action)
 {
     int id = action->data().toInt();
     if (id == 1) {
         removeTagFromSelectedNotes(m_tagPopup);
         // m_tagPopupNote->removeTag(m_tagPopup);
         // m_tagPopupNote->setWidth(0); // To force a new layout computation
         updateEditorAppearance();
         filterAgain();
         save();
         return;
     }
     if (id == 2) { // Customize this State:
         TagsEditDialog dialog(m_view, m_tagPopupNote->stateOfTag(m_tagPopup));
         dialog.exec();
         return;
     }
     if (id == 3) { // Filter by this Tag
         decoration()->filterBar()->filterTag(m_tagPopup);
         return;
     }
     if (id == 4) { // Filter by this State
         decoration()->filterBar()->filterState(m_tagPopupNote->stateOfTag(m_tagPopup));
         return;
     }
 
     /*addStateToSelectedNotes*/ changeStateOfSelectedNotes(m_tagPopup->states()[id - 10] /*, orReplace=true*/);
     // m_tagPopupNote->addState(m_tagPopup->states()[id - 10], true);
     filterAgain();
     save();
 }
 
 State *BasketScene::stateForTagFromSelectedNotes(Tag *tag)
 {
     State *state = nullptr;
 
     FOR_EACH_NOTE(note)
     if (note->stateForTagFromSelectedNotes(tag, &state) && state == nullptr)
         return nullptr;
     return state;
 }
 
 void BasketScene::activatedTagShortcut(Tag *tag)
 {
     // Compute the next state to set:
     State *state = stateForTagFromSelectedNotes(tag);
     if (state)
         state = state->nextState(/*cycle=*/false);
     else
         state = tag->states().first();
 
     // Set or unset it:
     if (state) {
         FOR_EACH_NOTE(note)
         note->addStateToSelectedNotes(state, /*orReplace=*/true);
         updateEditorAppearance();
     } else
         removeTagFromSelectedNotes(tag);
 
     filterAgain();
     save();
 }
 
 void BasketScene::popupTagsMenu(Note *note)
 {
     m_tagPopupNote = note;
 
     QMenu menu(m_view);
     menu.addSection(i18n("Tags"));
 
     Global::bnpView->populateTagsMenu(menu, note);
 
     m_lockedHovering = true;
     menu.exec(QCursor::pos());
 }
 
 void BasketScene::unlockHovering()
 {
     m_lockedHovering = false;
     doHoverEffects();
 }
 
 void BasketScene::toggledTagInMenu(QAction *act)
 {
     int id = act->data().toInt();
     if (id == 1) { // Assign new Tag...
         TagsEditDialog dialog(m_view, /*stateToEdit=*/nullptr, /*addNewTag=*/true);
         dialog.exec();
         if (!dialog.addedStates().isEmpty()) {
             State::List states = dialog.addedStates();
             for (State::List::iterator itState = states.begin(); itState != states.end(); ++itState)
                 FOR_EACH_NOTE(note)
             note->addStateToSelectedNotes(*itState);
             updateEditorAppearance();
             filterAgain();
             save();
         }
         return;
     }
     if (id == 2) { // Remove All
         removeAllTagsFromSelectedNotes();
         filterAgain();
         save();
         return;
     }
     if (id == 3) { // Customize...
         TagsEditDialog dialog(m_view);
         dialog.exec();
         return;
     }
 
     Tag *tag = Tag::all[id - 10];
     if (!tag)
         return;
 
     if (m_tagPopupNote->hasTag(tag))
         removeTagFromSelectedNotes(tag);
     else
         addTagToSelectedNotes(tag);
     m_tagPopupNote->setWidth(0); // To force a new layout computation
     filterAgain();
     save();
 }
 
 void BasketScene::addTagToSelectedNotes(Tag *tag)
 {
     FOR_EACH_NOTE(note)
     note->addTagToSelectedNotes(tag);
     updateEditorAppearance();
 }
 
 void BasketScene::removeTagFromSelectedNotes(Tag *tag)
 {
     FOR_EACH_NOTE(note)
     note->removeTagFromSelectedNotes(tag);
     updateEditorAppearance();
 }
 
 void BasketScene::addStateToSelectedNotes(State *state)
 {
     FOR_EACH_NOTE(note)
     note->addStateToSelectedNotes(state);
     updateEditorAppearance();
 }
 
 void BasketScene::updateEditorAppearance()
 {
     if (isDuringEdit() && m_editor->graphicsWidget()) {
         m_editor->graphicsWidget()->setFont(m_editor->note()->font());
 
         if (m_editor->graphicsWidget()->widget()) {
             QPalette palette;
             palette.setColor(m_editor->graphicsWidget()->widget()->backgroundRole(), m_editor->note()->backgroundColor());
             palette.setColor(m_editor->graphicsWidget()->widget()->foregroundRole(), m_editor->note()->textColor());
             m_editor->graphicsWidget()->setPalette(palette);
         }
 
         // Ugly Hack around Qt bugs: placeCursor() don't call any signal:
         HtmlEditor *htmlEditor = dynamic_cast<HtmlEditor *>(m_editor);
         if (htmlEditor) {
             if (m_editor->textEdit()->textCursor().atStart()) {
                 m_editor->textEdit()->moveCursor(QTextCursor::Right);
                 m_editor->textEdit()->moveCursor(QTextCursor::Left);
             } else {
                 m_editor->textEdit()->moveCursor(QTextCursor::Left);
                 m_editor->textEdit()->moveCursor(QTextCursor::Right);
             }
             htmlEditor->cursorPositionChanged(); // Does not work anyway :-( (when clicking on a red bold text, the toolbar still show black normal text)
         }
     }
 }
 
 void BasketScene::editorPropertiesChanged()
 {
     if (isDuringEdit() && m_editor->note()->content()->type() == NoteType::Html) {
         m_editor->textEdit()->setAutoFormatting(Settings::autoBullet() ? QTextEdit::AutoAll : QTextEdit::AutoNone);
     }
 }
 
 void BasketScene::changeStateOfSelectedNotes(State *state)
 {
     FOR_EACH_NOTE(note)
     note->changeStateOfSelectedNotes(state);
     updateEditorAppearance();
 }
 
 void BasketScene::removeAllTagsFromSelectedNotes()
 {
     FOR_EACH_NOTE(note)
     note->removeAllTagsFromSelectedNotes();
     updateEditorAppearance();
 }
 
 bool BasketScene::selectedNotesHaveTags()
 {
     FOR_EACH_NOTE(note)
     if (note->selectedNotesHaveTags())
         return true;
     return false;
 }
 
 QColor BasketScene::backgroundColor() const
 {
     if (m_backgroundColorSetting.isValid())
         return m_backgroundColorSetting;
     else
         return palette().color(QPalette::Base);
 }
 
 QColor BasketScene::textColor() const
 {
     if (m_textColorSetting.isValid())
         return m_textColorSetting;
     else
         return palette().color(QPalette::Text);
 }
 
 void BasketScene::unbufferizeAll()
 {
     FOR_EACH_NOTE(note)
     note->unbufferizeAll();
 }
 
 Note *BasketScene::editedNote()
 {
     if (m_editor)
         return m_editor->note();
     else
         return nullptr;
 }
 
 bool BasketScene::hasTextInEditor()
 {
     if (!isDuringEdit() || !redirectEditActions())
         return false;
 
     if (m_editor->textEdit())
         return !m_editor->textEdit()->document()->isEmpty();
     else if (m_editor->lineEdit())
         return !m_editor->lineEdit()->displayText().isEmpty();
     else
         return false;
 }
 
 bool BasketScene::hasSelectedTextInEditor()
 {
     if (!isDuringEdit() || !redirectEditActions())
         return false;
 
     if (m_editor->textEdit()) {
         // The following line does NOT work if one letter is selected and the user press Shift+Left or Shift+Right to unselect than letter:
         // Qt mysteriously tell us there is an invisible selection!!
         // return m_editor->textEdit()->hasSelectedText();
         return !m_editor->textEdit()->textCursor().selectedText().isEmpty();
     } else if (m_editor->lineEdit())
         return m_editor->lineEdit()->hasSelectedText();
     else
         return false;
 }
 
 bool BasketScene::selectedAllTextInEditor()
 {
     if (!isDuringEdit() || !redirectEditActions())
         return false;
 
     if (m_editor->textEdit()) {
         return m_editor->textEdit()->document()->isEmpty() || m_editor->textEdit()->toPlainText() == m_editor->textEdit()->textCursor().selectedText();
     } else if (m_editor->lineEdit())
         return m_editor->lineEdit()->displayText().isEmpty() || m_editor->lineEdit()->displayText() == m_editor->lineEdit()->selectedText();
     else
         return false;
 }
 
 void BasketScene::selectionChangedInEditor()
 {
     Global::bnpView->notesStateChanged();
 }
 
 void BasketScene::contentChangedInEditor()
 {
     // Do not wait 3 seconds, because we need the note to expand as needed (if a line is too wider... the note should grow wider):
     if (m_editor->textEdit())
         m_editor->autoSave(/*toFileToo=*/false);
     //  else {
     if (m_inactivityAutoSaveTimer.isActive())
         m_inactivityAutoSaveTimer.stop();
     m_inactivityAutoSaveTimer.setSingleShot(true);
     m_inactivityAutoSaveTimer.start(3 * 1000);
     Global::bnpView->setUnsavedStatus(true);
     //  }
 }
 
 void BasketScene::inactivityAutoSaveTimeout()
 {
     if (m_editor)
         m_editor->autoSave(/*toFileToo=*/true);
 }
 
 void BasketScene::placeEditorAndEnsureVisible()
 {
     placeEditor(/*andEnsureVisible=*/true);
 }
 
 // TODO: [kw] Oh boy, this will probably require some tweaking.
 void BasketScene::placeEditor(bool /*andEnsureVisible*/ /*= false*/)
 {
     if (!isDuringEdit())
         return;
 
     QFrame *editorQFrame = dynamic_cast<QFrame *>(m_editor->graphicsWidget()->widget());
     KTextEdit *textEdit = m_editor->textEdit();
     Note *note = m_editor->note();
 
     qreal frameWidth = (editorQFrame ? editorQFrame->frameWidth() : 0);
     qreal x = note->x() + note->contentX() + note->content()->xEditorIndent() - frameWidth;
     qreal y;
     qreal maxHeight = qMax((qreal)m_view->viewport()->height(), sceneRect().height());
     qreal height, width;
 
     if (textEdit) {
         // Need to do it 2 times, because it's wrong otherwise
         // (sometimes, width depends on height, and sometimes, height depends on with):
         for (int i = 0; i < 2; i++) {
             // FIXME: CRASH: Select all text, press Del or [<--] and editor->removeSelectedText() is called:
             //        editor->sync() CRASH!!
             //      editor->sync();
             y = note->y() + Note::NOTE_MARGIN - frameWidth;
             height = note->height() - 2 * frameWidth - 2 * Note::NOTE_MARGIN;
             width = note->x() + note->width() - x + 1;
             if (y + height > maxHeight)
                 y = maxHeight - height;
 
             m_editor->graphicsWidget()->setMaximumSize(width, height);
             textEdit->setFixedSize(width, height);
             textEdit->viewport()->setFixedSize(width, height);
         }
     } else {
         height = note->height() - 2 * Note::NOTE_MARGIN + 2 * frameWidth;
         width = note->x() + note->width() - x; // note->rightLimit() - x + 2*m_view->frameWidth;
         if (m_editor->graphicsWidget())
             m_editor->graphicsWidget()->widget()->setFixedSize(width, height);
         x -= 1;
         y = note->y() + Note::NOTE_MARGIN - frameWidth;
     }
     if ((m_editorWidth > 0 && m_editorWidth != width) || (m_editorHeight > 0 && m_editorHeight != height)) {
         m_editorWidth = width; // Avoid infinite recursion!!!
         m_editorHeight = height;
         m_editor->autoSave(/*toFileToo=*/true);
     }
     m_editorWidth = width;
     m_editorHeight = height;
     m_editor->graphicsWidget()->setPos(x, y);
     m_editorX = x;
     m_editorY = y;
 
     //  if (andEnsureVisible)
     //      ensureNoteVisible(note);
 }
 
 void BasketScene::editorCursorPositionChanged()
 {
     if (!isDuringEdit())
         return;
 
     FocusedTextEdit *textEdit = dynamic_cast<FocusedTextEdit *>(m_editor->textEdit());
 
     if (textEdit) {
         QPoint cursorPoint = textEdit->viewport()->mapToGlobal(textEdit->cursorRect().center());
 
         // QPointF contentsCursor = m_view->mapToScene( m_view->viewport()->mapFromGlobal(cursorPoint) );
         // m_view->ensureVisible(contentsCursor.x(), contentsCursor.y(),1,1);
     }
 }
 
 void BasketScene::closeEditorDelayed()
 {
     setFocus();
     QTimer::singleShot(0, this, SLOT(closeEditor()));
 }
 
 bool BasketScene::closeEditor(bool deleteEmptyNote /* =true*/)
 {
     if (!isDuringEdit())
         return true;
 
     if (m_doNotCloseEditor)
         return true;
 
     if (m_redirectEditActions) {
         if (m_editor->textEdit()) {
             disconnect(m_editor->textEdit(), &KTextEdit::selectionChanged, this, &BasketScene::selectionChangedInEditor);
             disconnect(m_editor->textEdit(), &KTextEdit::textChanged, this, &BasketScene::selectionChangedInEditor);
             disconnect(m_editor->textEdit(), &KTextEdit::textChanged, this, &BasketScene::contentChangedInEditor);
         } else if (m_editor->lineEdit()) {
             disconnect(m_editor->lineEdit(), &QLineEdit::selectionChanged, this, &BasketScene::selectionChangedInEditor);
             disconnect(m_editor->lineEdit(), &QLineEdit::textChanged, this, &BasketScene::selectionChangedInEditor);
             disconnect(m_editor->lineEdit(), &QLineEdit::textChanged, this, &BasketScene::contentChangedInEditor);
         }
     }
     m_editorTrackMouseEvent = false;
     m_editor->graphicsWidget()->widget()->disconnect();
     removeItem(m_editor->graphicsWidget());
     m_editor->validate();
 
     Note *note = m_editor->note();
 
     // Delete the editor BEFORE unselecting the note because unselecting the note would trigger closeEditor() recursivly:
     bool isEmpty = m_editor->isEmpty();
     delete m_editor;
 
     m_editor = nullptr;
     m_redirectEditActions = false;
     m_editorWidth = -1;
     m_editorHeight = -1;
     m_inactivityAutoSaveTimer.stop();
 
     // Delete the note if it is now empty:
     if (isEmpty && deleteEmptyNote) {
         focusANonSelectedNoteAboveOrThenBelow();
         note->setSelected(true);
         note->deleteSelectedNotes();
         if (m_hoveredNote == note)
             m_hoveredNote = nullptr;
         if (m_focusedNote == note)
             m_focusedNote = nullptr;
         delete note;
         save();
         note = nullptr;
     }
 
     unlockHovering();
     filterAgain(/*andEnsureVisible=*/false);
 
     // Does not work:
     //  if (Settings::playAnimations())
     //      note->setOnTop(true); // So if it grew, do not obscure it temporarily while the notes below it are moving
 
     if (note)
         note->setSelected(false); // unselectAll();
     doHoverEffects();
     //  save();
 
     Global::bnpView->m_actEditNote->setEnabled(!isLocked() && countSelecteds() == 1 /*&& !isDuringEdit()*/);
 
     emit resetStatusBarText(); // Remove the "Editing. ... to validate." text.
 
     // if (qApp->activeWindow() == Global::mainContainer)
 
     // Set focus to the basket, unless the user pressed a letter key in the filter bar and the currently edited note came hidden, then editing closed:
     if (!decoration()->filterBar()->lineEdit()->hasFocus())
         setFocus();
 
     // Return true if the note is still there:
     return (note != nullptr);
 }
 
 void BasketScene::closeBasket()
 {
     closeEditor();
     unbufferizeAll(); // Keep the memory footprint low
     if (isEncrypted()) {
         if (Settings::enableReLockTimeout()) {
             int seconds = Settings::reLockTimeoutMinutes() * 60;
             m_inactivityAutoLockTimer.setSingleShot(true);
             m_inactivityAutoLockTimer.start(seconds * 1000);
         }
     }
 }
 
 void BasketScene::openBasket()
 {
     if (m_inactivityAutoLockTimer.isActive())
         m_inactivityAutoLockTimer.stop();
 }
 
 Note *BasketScene::theSelectedNote()
 {
     if (countSelecteds() != 1) {
         qDebug() << "NO SELECTED NOTE !!!!";
         return nullptr;
     }
 
     Note *selectedOne;
     FOR_EACH_NOTE(note)
     {
         selectedOne = note->theSelectedNote();
         if (selectedOne)
             return selectedOne;
     }
 
     qDebug() << "One selected note, BUT NOT FOUND !!!!";
 
     return nullptr;
 }
 
 NoteSelection *BasketScene::selectedNotes()
 {
     NoteSelection selection;
 
     FOR_EACH_NOTE(note)
     selection.append(note->selectedNotes());
 
     if (!selection.firstChild)
         return nullptr;
 
     for (NoteSelection *node = selection.firstChild; node; node = node->next)
         node->parent = nullptr;
 
     // If the top-most groups are columns, export only children of those groups
     // (because user is not aware that columns are groups, and don't care: it's not what she want):
     if (selection.firstChild->note->isColumn()) {
         NoteSelection tmpSelection;
         NoteSelection *nextNode;
         NoteSelection *nextSubNode;
         for (NoteSelection *node = selection.firstChild; node; node = nextNode) {
             nextNode = node->next;
             if (node->note->isColumn()) {
                 for (NoteSelection *subNode = node->firstChild; subNode; subNode = nextSubNode) {
                     nextSubNode = subNode->next;
                     tmpSelection.append(subNode);
                     subNode->parent = nullptr;
                     subNode->next = nullptr;
                 }
             } else {
                 tmpSelection.append(node);
                 node->parent = nullptr;
                 node->next = nullptr;
             }
         }
         //      debugSel(tmpSelection.firstChild);
         return tmpSelection.firstChild;
     } else {
         //      debugSel(selection.firstChild);
         return selection.firstChild;
     }
 }
 
 void BasketScene::showEditedNoteWhileFiltering()
 {
     if (m_editor) {
         Note *note = m_editor->note();
         filterAgain();
         note->setSelected(true);
         relayoutNotes();
         note->setX(note->x());
         note->setY(note->y());
         filterAgainDelayed();
     }
 }
 
 void BasketScene::noteEdit(Note *note, bool justAdded, const QPointF &clickedPoint) // TODO: Remove the first parameter!!!
 {
     if (!note)
         note = theSelectedNote(); // TODO: Or pick the focused note!
     if (!note)
         return;
 
     if (isDuringEdit()) {
         closeEditor(); // Validate the noteeditors in QLineEdit that does not intercept Enter key press (and edit is triggered with Enter too... Can conflict)
         return;
     }
 
     if (note != m_focusedNote) {
         setFocusedNote(note);
         m_startOfShiftSelectionNote = note;
     }
 
     if (justAdded && isFiltering()) {
         QTimer::singleShot(0, this, SLOT(showEditedNoteWhileFiltering()));
     }
 
     doHoverEffects(note, Note::Content); // Be sure (in the case Edit was triggered by menu or Enter key...): better feedback!
 
     NoteEditor *editor = NoteEditor::editNoteContent(note->content(), nullptr);
     if (editor->graphicsWidget()) {
         m_editor = editor;
 
         addItem(m_editor->graphicsWidget());
 
         placeEditorAndEnsureVisible(); //       placeEditor(); // FIXME: After?
         m_redirectEditActions = m_editor->lineEdit() || m_editor->textEdit();
         if (m_redirectEditActions) {
             // In case there is NO text, "Select All" is disabled. But if the user press a key the there is now a text:
             // selection has not changed but "Select All" should be re-enabled:
             m_editor->connectActions(this);
         }
 
         m_editor->graphicsWidget()->setFocus();
         connect(m_editor, &NoteEditor::askValidation, this, &BasketScene::closeEditorDelayed);
         connect(m_editor, &NoteEditor::mouseEnteredEditorWidget, this, &BasketScene::mouseEnteredEditorWidget);
 
         if (clickedPoint != QPoint()) {
             m_editor->setCursorTo(clickedPoint);
             updateEditorAppearance();
         }
 
         //      qApp->processEvents();     // Show the editor toolbar before ensuring the note is visible
         ensureNoteVisible(note);                //  because toolbar can create a new line and then partially hide the note
         m_editor->graphicsWidget()->setFocus(); // When clicking in the basket, a QTimer::singleShot(0, ...) focus the basket! So we focus the widget after qApp->processEvents()
         emit resetStatusBarText();              // Display "Editing. ... to validate."
     } else {
         // Delete the note user have canceled the addition:
         if ((justAdded && editor->canceled()) || editor->isEmpty() /*) && editor->note()->states().count() <= 0*/) {
             focusANonSelectedNoteAboveOrThenBelow();
             editor->note()->setSelected(true);
             editor->note()->deleteSelectedNotes();
             if (m_hoveredNote == editor->note())
                 m_hoveredNote = nullptr;
             if (m_focusedNote == editor->note())
                 m_focusedNote = nullptr;
-            m_model.removeNote(editor->note());
+            //m_model.removeNote(editor->note());
             delete editor->note();
             save();
         }
         editor->deleteLater();
         unlockHovering();
         filterAgain();
         unselectAll();
     }
     // Must set focus to the editor, otherwise edit cursor is not seen and precomposed characters cannot be entered
     if (m_editor != nullptr && m_editor->textEdit() != nullptr)
         m_editor->textEdit()->setFocus();
 
     Global::bnpView->m_actEditNote->setEnabled(false);
 }
 
 void BasketScene::noteDelete()
 {
     if (redirectEditActions()) {
         if (m_editor->textEdit())
             m_editor->textEdit()->textCursor().deleteChar();
         else if (m_editor->lineEdit())
             m_editor->lineEdit()->del();
         return;
     }
 
     if (countSelecteds() <= 0)
         return;
     int really = KMessageBox::Yes;
     if (Settings::confirmNoteDeletion())
         really = KMessageBox::questionYesNo(m_view,
                                             i18np("<qt>Do you really want to delete this note?</qt>", "<qt>Do you really want to delete these <b>%1</b> notes?</qt>", countSelecteds()),
                                             i18np("Delete Note", "Delete Notes", countSelecteds()),
                                             KStandardGuiItem::del(),
                                             KStandardGuiItem::cancel());
     if (really == KMessageBox::No)
         return;
 
     noteDeleteWithoutConfirmation();
 }
 
 void BasketScene::focusANonSelectedNoteBelow(bool inSameColumn)
 {
     // First focus another unselected one below it...:
     if (m_focusedNote && m_focusedNote->isSelected()) {
         Note *next = m_focusedNote->nextShownInStack();
         while (next && next->isSelected())
             next = next->nextShownInStack();
         if (next) {
             if (inSameColumn && isColumnsLayout() && m_focusedNote->parentPrimaryNote() == next->parentPrimaryNote()) {
                 setFocusedNote(next);
                 m_startOfShiftSelectionNote = next;
             }
         }
     }
 }
 
 void BasketScene::focusANonSelectedNoteAbove(bool inSameColumn)
 {
     // ... Or above it:
     if (m_focusedNote && m_focusedNote->isSelected()) {
         Note *prev = m_focusedNote->prevShownInStack();
         while (prev && prev->isSelected())
             prev = prev->prevShownInStack();
         if (prev) {
             if (inSameColumn && isColumnsLayout() && m_focusedNote->parentPrimaryNote() == prev->parentPrimaryNote()) {
                 setFocusedNote(prev);
                 m_startOfShiftSelectionNote = prev;
             }
         }
     }
 }
 
 void BasketScene::focusANonSelectedNoteBelowOrThenAbove()
 {
     focusANonSelectedNoteBelow(/*inSameColumn=*/true);
     focusANonSelectedNoteAbove(/*inSameColumn=*/true);
     focusANonSelectedNoteBelow(/*inSameColumn=*/false);
     focusANonSelectedNoteAbove(/*inSameColumn=*/false);
 }
 
 void BasketScene::focusANonSelectedNoteAboveOrThenBelow()
 {
     focusANonSelectedNoteAbove(/*inSameColumn=*/true);
     focusANonSelectedNoteBelow(/*inSameColumn=*/true);
     focusANonSelectedNoteAbove(/*inSameColumn=*/false);
     focusANonSelectedNoteBelow(/*inSameColumn=*/false);
 }
 
 void BasketScene::noteDeleteWithoutConfirmation(bool deleteFilesToo)
 {
     // If the currently focused note is selected, it will be deleted.
     focusANonSelectedNoteBelowOrThenAbove();
 
     // Do the deletion:
     Note *note = firstNote();
     Note *next;
     while (note) {
         next = note->next(); // If we delete 'note' on the next line, note->next() will be 0!
         note->deleteSelectedNotes(deleteFilesToo, &m_notesToBeDeleted);
         note = next;
     }
 
     if (!m_notesToBeDeleted.isEmpty()) {
         doCleanUp();
     }
 
     relayoutNotes(); // FIXME: filterAgain()?
     save();
 }
 
 void BasketScene::doCopy(CopyMode copyMode)
 {
     QClipboard *cb = QApplication::clipboard();
     QClipboard::Mode mode = ((copyMode == CopyToSelection) ? QClipboard::Selection : QClipboard::Clipboard);
 
     NoteSelection *selection = selectedNotes();
     int countCopied = countSelecteds();
     if (selection->firstStacked()) {
         QDrag *d = NoteDrag::dragObject(selection, copyMode == CutToClipboard, /*source=*/nullptr); // d will be deleted by QT
                                                                                                     //      /*bool shouldRemove = */d->drag();
                                                                                                     //      delete selection;
         cb->setMimeData(d->mimeData(), mode);                                                       // NoteMultipleDrag will be deleted by QT
                                                                                                     //      if (copyMode == CutToClipboard && !note->useFile()) // If useFile(), NoteDrag::dragObject() will delete it TODO
                                                                                                     //          note->slotDelete();
 
         if (copyMode == CutToClipboard) {
             noteDeleteWithoutConfirmation(/*deleteFilesToo=*/false);
             focusANote();
         }
 
         switch (copyMode) {
         default:
         case CopyToClipboard:
             Q_EMIT postMessage(i18np("Copied note to clipboard.", "Copied notes to clipboard.", countCopied));
             break;
         case CutToClipboard:
             Q_EMIT postMessage(i18np("Cut note to clipboard.", "Cut notes to clipboard.", countCopied));
             break;
         case CopyToSelection:
             Q_EMIT postMessage(i18np("Copied note to selection.", "Copied notes to selection.", countCopied));
             break;
         }
     }
 }
 
 void BasketScene::noteCopy()
 {
     if (redirectEditActions()) {
         if (m_editor->textEdit())
             m_editor->textEdit()->copy();
         else if (m_editor->lineEdit())
             m_editor->lineEdit()->copy();
     } else
         doCopy(CopyToClipboard);
 }
 
 void BasketScene::noteCut()
 {
     if (redirectEditActions()) {
         if (m_editor->textEdit())
             m_editor->textEdit()->cut();
         else if (m_editor->lineEdit())
             m_editor->lineEdit()->cut();
     } else
         doCopy(CutToClipboard);
 }
 
 void BasketScene::noteOpen(Note *note)
 {
     /*
     GetSelectedNotes
     NoSelectedNote || Count == 0 ? return
     AllTheSameType ?
     Get { url, message(count) }
     */
 
     // TODO: Open ALL selected notes!
     if (!note)
         note = theSelectedNote();
     if (!note)
         return;
 
     QUrl url = note->content()->urlToOpen(/*with=*/false);
     QString message = note->content()->messageWhenOpening(NoteContent::OpenOne /*NoteContent::OpenSeveral*/);
     if (url.isEmpty()) {
         if (message.isEmpty())
             Q_EMIT postMessage(i18n("Unable to open this note.") /*"Unable to open those notes."*/);
         else {
             int result = KMessageBox::warningContinueCancel(m_view, message, /*caption=*/QString(), KGuiItem(i18n("&Edit"), "edit"));
             if (result == KMessageBox::Continue)
                 noteEdit(note);
         }
     } else {
         Q_EMIT postMessage(message); // "Opening link target..." / "Launching application..." / "Opening note file..."
         // Finally do the opening job:
         QString customCommand = note->content()->customOpenCommand();
 
         if (url.url().startsWith("basket://")) {
             Q_EMIT crossReference(url.url());
         } else if (customCommand.isEmpty()) {
             KRun *run = new KRun(url, m_view->window());
             run->setAutoDelete(true);
         } else {
             QList<QUrl> urls {url};
             KRun::run(customCommand, urls, m_view->window());
         }
     }
 }
 
 /** Code from bool KRun::displayOpenWithDialog(const KUrl::List& lst, bool tempFiles)
  * It does not allow to set a text, so I ripped it to do that:
  */
 bool KRun__displayOpenWithDialog(const QList<QUrl> &lst, QWidget *window, bool tempFiles, const QString &text)
 {
     if (qApp && !KAuthorized::authorizeAction("openwith")) {
         KMessageBox::sorry(window, i18n("You are not authorized to open this file.")); // TODO: Better message, i18n freeze :-(
         return false;
     }
     KOpenWithDialog l(lst, text, QString(), nullptr);
     if (l.exec()) {
         KService::Ptr service = l.service();
         if (!!service)
             return KRun::runApplication(*service, lst, window, tempFiles ? KRun::DeleteTemporaryFiles : KRun::RunFlags());
         // qDebug(250) << "No service set, running " << l.text() << endl;
         return KRun::run(l.text(), lst, window); // TODO handle tempFiles
     }
     return false;
 }
 
 void BasketScene::noteOpenWith(Note *note)
 {
     if (!note)
         note = theSelectedNote();
     if (!note)
         return;
 
     QUrl url = note->content()->urlToOpen(/*with=*/true);
     QString message = note->content()->messageWhenOpening(NoteContent::OpenOneWith /*NoteContent::OpenSeveralWith*/);
     QString text = note->content()->messageWhenOpening(NoteContent::OpenOneWithDialog /*NoteContent::OpenSeveralWithDialog*/);
     if (url.isEmpty()) {
         Q_EMIT postMessage(i18n("Unable to open this note.") /*"Unable to open those notes."*/);
     } else {
         QList<QUrl> urls {url};
         if (KRun__displayOpenWithDialog(urls, m_view->window(), false, text))
             Q_EMIT postMessage(message); // "Opening link target with..." / "Opening note file with..."
     }
 }
 
 void BasketScene::noteSaveAs()
 {
     //  if (!note)
     //      note = theSelectedNote();
     Note *note = theSelectedNote();
     if (!note)
         return;
 
     QUrl url = note->content()->urlToOpen(/*with=*/false);
     if (url.isEmpty())
         return;
 
     QString fileName = QFileDialog::getSaveFileName(m_view, i18n("Save to File"), url.fileName(), note->content()->saveAsFilters());
     // TODO: Ask to overwrite !
     if (fileName.isEmpty())
         return;
 
     // TODO: Convert format, etc. (use NoteContent::saveAs(fileName))
     KIO::copy(url, QUrl::fromLocalFile(fileName));
 }
 
 Note *BasketScene::selectedGroup()
 {
     FOR_EACH_NOTE(note)
     {
         Note *selectedGroup = note->selectedGroup();
         if (selectedGroup) {
             // If the selected group is one group in a column, then return that group, and not the column,
             // because the column is not ungrouppage, and the Ungroup action would be disabled.
             if (selectedGroup->isColumn() && selectedGroup->firstChild() && !selectedGroup->firstChild()->next()) {
                 return selectedGroup->firstChild();
             }
             return selectedGroup;
         }
     }
     return nullptr;
 }
 
 bool BasketScene::selectionIsOneGroup()
 {
     return (selectedGroup() != nullptr);
 }
 
 Note *BasketScene::firstSelected()
 {
     Note *first = nullptr;
     FOR_EACH_NOTE(note)
     {
         first = note->firstSelected();
         if (first)
             return first;
     }
     return nullptr;
 }
 
 Note *BasketScene::lastSelected()
 {
     Note *last = nullptr, *tmp = nullptr;
     FOR_EACH_NOTE(note)
     {
         tmp = note->lastSelected();
         if (tmp)
             last = tmp;
     }
     return last;
 }
 
 bool BasketScene::convertTexts()
 {
     m_watcher->stopScan();
     bool convertedNotes = false;
 
     if (!isLoaded())
         load();
 
     FOR_EACH_NOTE(note)
     if (note->convertTexts())
         convertedNotes = true;
 
     if (convertedNotes)
         save();
     m_watcher->startScan();
     return convertedNotes;
 }
 
 void BasketScene::noteGroup()
 {
     /*  // Nothing to do?
         if (isLocked() || countSelecteds() <= 1)
             return;
 
         // If every selected notes are ALREADY in one group, then don't touch anything:
         Note *selectedGroup = this->selectedGroup();
         if (selectedGroup && !selectedGroup->isColumn())
             return;
     */
 
     // Copied from BNPView::updateNotesActions()
     bool severalSelected = countSelecteds() >= 2;
     Note *selectedGroup = (severalSelected ? this->selectedGroup() : nullptr);
     bool enabled = !isLocked() && severalSelected && (!selectedGroup || selectedGroup->isColumn());
     if (!enabled)
         return;
 
     // Get the first selected note: we will group selected items just before:
     Note *first = firstSelected();
     //  if (selectedGroup != 0 || first == 0)
     //      return;
 
     m_loaded = false; // Hack to avoid notes to be unselected and new notes to be selected:
 
     // Create and insert the receiving group:
     Note *group = new Note(this);
     if (first->isFree()) {
         insertNote(group, nullptr, Note::BottomColumn, QPointF(first->x(), first->y()));
     } else {
         insertNote(group, first, Note::TopInsert);
     }
 
     // Put a FAKE UNSELECTED note in the new group, so if the new group is inside an allSelected() group, the parent group is not moved inside the new group!
     Note *fakeNote = NoteFactory::createNoteColor(Qt::red, this);
     insertNote(fakeNote, group, Note::BottomColumn);
 
     // Group the notes:
     Note *nextNote;
     Note *note = firstNote();
     while (note) {
         nextNote = note->next();
         note->groupIn(group);
         note = nextNote;
     }
 
     m_loaded = true; // Part 2 / 2 of the workaround!
 
     // Do cleanup:
     unplugNote(fakeNote);
     delete fakeNote;
     unselectAll();
     group->setSelectedRecursively(true); // Notes were unselected by unplugging
 
     relayoutNotes();
     save();
 }
 
 void BasketScene::noteUngroup()
 {
     Note *group = selectedGroup();
     if (group && !group->isColumn()) {
         ungroupNote(group);
         relayoutNotes();
     }
     save();
 }
 
 void BasketScene::unplugSelection(NoteSelection *selection)
 {
     for (NoteSelection *toUnplug = selection->firstStacked(); toUnplug; toUnplug = toUnplug->nextStacked()) {
         unplugNote(toUnplug->note);
     }
 }
 
 void BasketScene::insertSelection(NoteSelection *selection, Note *after)
 {
     for (NoteSelection *toUnplug = selection->firstStacked(); toUnplug; toUnplug = toUnplug->nextStacked()) {
         if (toUnplug->note->isGroup()) {
             Note *group = new Note(this);
             insertNote(group, after, Note::BottomInsert);
             Note *fakeNote = NoteFactory::createNoteColor(Qt::red, this);
             insertNote(fakeNote, group, Note::BottomColumn);
             insertSelection(toUnplug->firstChild, fakeNote);
             unplugNote(fakeNote);
             delete fakeNote;
             after = group;
         } else {
             Note *note = toUnplug->note;
             note->setPrev(nullptr);
             note->setNext(nullptr);
             insertNote(note, after, Note::BottomInsert);
             after = note;
         }
     }
 }
 
 void BasketScene::selectSelection(NoteSelection *selection)
 {
     for (NoteSelection *toUnplug = selection->firstStacked(); toUnplug; toUnplug = toUnplug->nextStacked()) {
         if (toUnplug->note->isGroup())
             selectSelection(toUnplug);
         else
             toUnplug->note->setSelected(true);
     }
 }
 
 void BasketScene::noteMoveOnTop()
 {
     // TODO: Get the group containing the selected notes and first move inside the group, then inside parent group, then in the basket
     // TODO: Move on top/bottom... of the column or basjet
 
     NoteSelection *selection = selectedNotes();
     unplugSelection(selection);
     // Replug the notes:
     Note *fakeNote = NoteFactory::createNoteColor(Qt::red, this);
     if (isColumnsLayout()) {
         if (firstNote()->firstChild())
             insertNote(fakeNote, firstNote()->firstChild(), Note::TopInsert);
         else
             insertNote(fakeNote, firstNote(), Note::BottomColumn);
     } else {
         // TODO: Also allow to move notes on top of a group!!!!!!!
         insertNote(fakeNote, nullptr, Note::BottomInsert);
     }
     insertSelection(selection, fakeNote);
     unplugNote(fakeNote);
     delete fakeNote;
     selectSelection(selection);
     relayoutNotes();
     save();
 }
 
 void BasketScene::noteMoveOnBottom()
 {
     // TODO: Duplicate code: void noteMoveOn();
 
     // TODO: Get the group containing the selected notes and first move inside the group, then inside parent group, then in the basket
     // TODO: Move on top/bottom... of the column or basjet
 
     NoteSelection *selection = selectedNotes();
     unplugSelection(selection);
     // Replug the notes:
     Note *fakeNote = NoteFactory::createNoteColor(Qt::red, this);
     if (isColumnsLayout())
         insertNote(fakeNote, firstNote(), Note::BottomColumn);
     else {
         // TODO: Also allow to move notes on top of a group!!!!!!!
         insertNote(fakeNote, nullptr, Note::BottomInsert);
     }
     insertSelection(selection, fakeNote);
     unplugNote(fakeNote);
     delete fakeNote;
     selectSelection(selection);
     relayoutNotes();
     save();
 }
 
 void BasketScene::moveSelectionTo(Note *here, bool below /* = true*/)
 {
     NoteSelection *selection = selectedNotes();
     unplugSelection(selection);
     // Replug the notes:
     Note *fakeNote = NoteFactory::createNoteColor(Qt::red, this);
     //  if (isColumnsLayout())
     insertNote(fakeNote, here, (below ? Note::BottomInsert : Note::TopInsert));
     //  else {
     //      // TODO: Also allow to move notes on top of a group!!!!!!!
     //      insertNote(fakeNote, 0, Note::BottomInsert, QPoint(0, 0), /*animateNewPosition=*/false);
     //  }
     insertSelection(selection, fakeNote);
     unplugNote(fakeNote);
     delete fakeNote;
     selectSelection(selection);
     relayoutNotes();
     save();
 }
 
 void BasketScene::noteMoveNoteUp()
 {
     // TODO: Move between columns, even if they are empty !!!!!!!
 
     // TODO: if first note of a group, move just above the group! And let that even if there is no note before that group!!!
 
     Note *first = firstSelected();
     Note *previous = first->prevShownInStack();
     if (previous)
         moveSelectionTo(previous, /*below=*/false);
 }
 
 void BasketScene::noteMoveNoteDown()
 {
     Note *first = lastSelected();
     Note *next = first->nextShownInStack();
     if (next)
         moveSelectionTo(next, /*below=*/true);
 }
 
 void BasketScene::wheelEvent(QGraphicsSceneWheelEvent *event)
 {
     // Q3ScrollView::wheelEvent(event);
     QGraphicsScene::wheelEvent(event);
 }
 
 void BasketScene::linkLookChanged()
 {
     Note *note = m_firstNote;
     while (note) {
         note->linkLookChanged();
         note = note->next();
     }
     relayoutNotes();
 }
 
 void BasketScene::slotCopyingDone2(KIO::Job *job, const QUrl & /*from*/, const QUrl &to)
 {
     if (job->error()) {
         DEBUG_WIN << "Copy finished, ERROR";
         return;
     }
     Note *note = noteForFullPath(to.path());
     DEBUG_WIN << "Copy finished, load note: " + to.path() + (note ? QString() : " --- NO CORRESPONDING NOTE");
     if (note != nullptr) {
         note->content()->loadFromFile(/*lazyLoad=*/false);
         if (isEncrypted())
             note->content()->saveToFile();
         if (m_focusedNote == note)   // When inserting a new note we ensure it visible
             ensureNoteVisible(note); //  But after loading it has certainly grown and if it was
     }                                //  on bottom of the basket it's not visible entirely anymore
 }
 
 Note *BasketScene::noteForFullPath(const QString &path)
 {
     Note *note = firstNote();
     Note *found;
     while (note) {
         found = note->noteForFullPath(path);
         if (found)
             return found;
         note = note->next();
     }
     return nullptr;
 }
 
 void BasketScene::deleteFiles()
 {
     m_watcher->stopScan();
     Tools::deleteRecursively(fullPath());
 }
 
 QList<State *> BasketScene::usedStates()
 {
     QList<State *> states;
     FOR_EACH_NOTE(note)
     note->usedStates(states);
     return states;
 }
 
 void BasketScene::listUsedTags(QList<Tag *> &list)
 {
     if (!isLoaded()) {
         load();
     }
 
     FOR_EACH_NOTE(child)
     child->listUsedTags(list);
 }
 
 /** Unfocus the previously focused note (unless it was null)
  * and focus the new @param note (unless it is null) if hasFocus()
  * Update m_focusedNote to the new one
  */
 void BasketScene::setFocusedNote(Note *note) // void BasketScene::changeFocusTo(Note *note)
 {
     // Don't focus an hidden note:
     if (note != nullptr && !note->isShown())
         return;
     // When clicking a group, this group gets focused. But only content-based notes should be focused:
     if (note && note->isGroup())
         note = note->firstRealChild();
     // The first time a note is focused, it becomes the start of the Shift selection:
     if (m_startOfShiftSelectionNote == nullptr)
         m_startOfShiftSelectionNote = note;
     // Unfocus the old focused note:
     if (m_focusedNote != nullptr)
         m_focusedNote->setFocused(false);
     // Notify the new one to draw a focus rectangle... only if the basket is focused:
     if (hasFocus() && note != nullptr)
         note->setFocused(true);
     // Save the new focused note:
     m_focusedNote = note;
 }
 
 /** If no shown note is currently focused, try to find a shown note and focus it
  * Also update m_focusedNote to the new one (or null if there isn't)
  */
 void BasketScene::focusANote()
 {
     if (countFounds() == 0) { // No note to focus
         setFocusedNote(nullptr);
         //      m_startOfShiftSelectionNote = 0;
         return;
     }
 
     if (m_focusedNote == nullptr) { // No focused note yet : focus the first shown
         Note *toFocus = (isFreeLayout() ? noteOnHome() : firstNoteShownInStack());
         setFocusedNote(toFocus);
         //      m_startOfShiftSelectionNote = m_focusedNote;
         return;
     }
 
     // Search a visible note to focus if the focused one isn't shown :
     Note *toFocus = m_focusedNote;
     if (toFocus && !toFocus->isShown())
         toFocus = toFocus->nextShownInStack();
     if (!toFocus && m_focusedNote)
         toFocus = m_focusedNote->prevShownInStack();
     setFocusedNote(toFocus);
     //  m_startOfShiftSelectionNote = toFocus;
 }
 
 Note *BasketScene::firstNoteInStack()
 {
     if (!firstNote())
         return nullptr;
 
     if (firstNote()->content())
         return firstNote();
     else
         return firstNote()->nextInStack();
 }
 
 Note *BasketScene::lastNoteInStack()
 {
     Note *note = lastNote();
     while (note) {
         if (note->content())
             return note;
         Note *possibleNote = note->lastRealChild();
         if (possibleNote && possibleNote->content())
             return possibleNote;
         note = note->prev();
     }
     return nullptr;
 }
 
 Note *BasketScene::firstNoteShownInStack()
 {
     Note *first = firstNoteInStack();
     while (first && !first->isShown())
         first = first->nextInStack();
     return first;
 }
 
 Note *BasketScene::lastNoteShownInStack()
 {
     Note *last = lastNoteInStack();
     while (last && !last->isShown())
         last = last->prevInStack();
     return last;
 }
 
 Note *BasketScene::noteOn(NoteOn side)
 {
     Note *bestNote = nullptr;
     int distance = -1;
     //    int   bestDistance = contentsWidth() * contentsHeight() * 10;
     int bestDistance = sceneRect().width() * sceneRect().height() * 10;
 
     Note *note = firstNoteShownInStack();
     Note *primary = m_focusedNote->parentPrimaryNote();
     while (note) {
         switch (side) {
         case LEFT_SIDE:
             distance = m_focusedNote->distanceOnLeftRight(note, LEFT_SIDE);
             break;
         case RIGHT_SIDE:
             distance = m_focusedNote->distanceOnLeftRight(note, RIGHT_SIDE);
             break;
         case TOP_SIDE:
             distance = m_focusedNote->distanceOnTopBottom(note, TOP_SIDE);
             break;
         case BOTTOM_SIDE:
             distance = m_focusedNote->distanceOnTopBottom(note, BOTTOM_SIDE);
             break;
         }
         if ((side == TOP_SIDE || side == BOTTOM_SIDE || primary != note->parentPrimaryNote()) && note != m_focusedNote && distance > 0 && distance < bestDistance) {
             bestNote = note;
             bestDistance = distance;
         }
         note = note->nextShownInStack();
     }
 
     return bestNote;
 }
 
 Note *BasketScene::firstNoteInGroup()
 {
     Note *child = m_focusedNote;
     Note *parent = (m_focusedNote ? m_focusedNote->parentNote() : nullptr);
     while (parent) {
         if (parent->firstChild() != child && !parent->isColumn())
             return parent->firstRealChild();
         child = parent;
         parent = parent->parentNote();
     }
     return nullptr;
 }
 
 Note *BasketScene::noteOnHome()
 {
     // First try to find the first note of the group containing the focused note:
     Note *child = m_focusedNote;
     Note *parent = (m_focusedNote ? m_focusedNote->parentNote() : nullptr);
     while (parent) {
         if (parent->nextShownInStack() != m_focusedNote)
             return parent->nextShownInStack();
         child = parent;
         parent = parent->parentNote();
     }
 
     // If it was not found, then focus the very first note in the basket:
     if (isFreeLayout()) {
         Note *first = firstNoteShownInStack(); // The effective first note found
         Note *note = first;                    // The current note, to compare with the previous first note, if this new note is more on top
         if (note)
             note = note->nextShownInStack();
         while (note) {
             if (note->y() < first->y() || (note->y() == first->y() && note->x() < first->x()))
                 first = note;
             note = note->nextShownInStack();
         }
         return first;
     } else
         return firstNoteShownInStack();
 }
 
 Note *BasketScene::noteOnEnd()
 {
     Note *child = m_focusedNote;
     Note *parent = (m_focusedNote ? m_focusedNote->parentNote() : nullptr);
     Note *lastChild;
     while (parent) {
         lastChild = parent->lastRealChild();
         if (lastChild && lastChild != m_focusedNote) {
             if (lastChild->isShown())
                 return lastChild;
             lastChild = lastChild->prevShownInStack();
             if (lastChild && lastChild->isShown() && lastChild != m_focusedNote)
                 return lastChild;
         }
         child = parent;
         parent = parent->parentNote();
     }
     if (isFreeLayout()) {
         Note *last;
         Note *note;
         last = note = firstNoteShownInStack();
         note = note->nextShownInStack();
         while (note) {
             if (note->bottom() > last->bottom() || (note->bottom() == last->bottom() && note->x() > last->x()))
                 last = note;
             note = note->nextShownInStack();
         }
         return last;
     } else
         return lastNoteShownInStack();
 }
 
 void BasketScene::keyPressEvent(QKeyEvent *event)
 {
     if (isDuringEdit()) {
         QGraphicsScene::keyPressEvent(event);
         /*if( event->key() == Qt::Key_Return )
         {
       m_editor->graphicsWidget()->setFocus();
         }
         else if( event->key() == Qt::Key_Escape)
         {
       closeEditor();
         }*/
         event->accept();
         return;
     }
 
     if (event->key() == Qt::Key_Escape) {
         if (decoration()->filterData().isFiltering)
             decoration()->filterBar()->reset();
         else
             unselectAll();
     }
 
     if (countFounds() == 0)
         return;
 
     if (!m_focusedNote)
         return;
 
     Note *toFocus = nullptr;
 
     switch (event->key()) {
     case Qt::Key_Down:
         toFocus = (isFreeLayout() ? noteOn(BOTTOM_SIDE) : m_focusedNote->nextShownInStack());
         if (toFocus)
             break;
         //        scrollBy(0, 30); // This cases do not move focus to another note...
         return;
     case Qt::Key_Up:
         toFocus = (isFreeLayout() ? noteOn(TOP_SIDE) : m_focusedNote->prevShownInStack());
         if (toFocus)
             break;
         //	scrollBy(0, -30); // This cases do not move focus to another note...
         return;
     case Qt::Key_PageDown:
         if (isFreeLayout()) {
             Note *lastFocused = m_focusedNote;
             for (int i = 0; i < 10 && m_focusedNote; ++i)
                 m_focusedNote = noteOn(BOTTOM_SIDE);
             toFocus = m_focusedNote;
             m_focusedNote = lastFocused;
         } else {
             toFocus = m_focusedNote;
             for (int i = 0; i < 10 && toFocus; ++i)
                 toFocus = toFocus->nextShownInStack();
         }
         if (toFocus == nullptr)
             toFocus = (isFreeLayout() ? noteOnEnd() : lastNoteShownInStack());
         if (toFocus && toFocus != m_focusedNote)
             break;
         //        scrollBy(0, visibleHeight() / 2); // This cases do not move focus to another note...
         //        scrollBy(0, viewport()->height() / 2); // This cases do not move focus to another note...
         return;
     case Qt::Key_PageUp:
         if (isFreeLayout()) {
             Note *lastFocused = m_focusedNote;
             for (int i = 0; i < 10 && m_focusedNote; ++i)
                 m_focusedNote = noteOn(TOP_SIDE);
             toFocus = m_focusedNote;
             m_focusedNote = lastFocused;
         } else {
             toFocus = m_focusedNote;
             for (int i = 0; i < 10 && toFocus; ++i)
                 toFocus = toFocus->prevShownInStack();
         }
         if (toFocus == nullptr)
             toFocus = (isFreeLayout() ? noteOnHome() : firstNoteShownInStack());
         if (toFocus && toFocus != m_focusedNote)
             break;
         //        scrollBy(0, - visibleHeight() / 2); // This cases do not move focus to another note...
         //	  scrollBy(0, - viewport()->height() / 2); // This cases do not move focus to another note...
         return;
     case Qt::Key_Home:
         toFocus = noteOnHome();
         break;
     case Qt::Key_End:
         toFocus = noteOnEnd();
         break;
     case Qt::Key_Left:
         if (m_focusedNote->tryFoldParent())
             return;
         if ((toFocus = noteOn(LEFT_SIDE)))
             break;
         if ((toFocus = firstNoteInGroup()))
             break;
         //        scrollBy(-30, 0); // This cases do not move focus to another note...
         return;
     case Qt::Key_Right:
         if (m_focusedNote->tryExpandParent())
             return;
         if ((toFocus = noteOn(RIGHT_SIDE)))
             break;
         //	scrollBy(30, 0); // This cases do not move focus to another note...
         return;
     case Qt::Key_Space: // This case do not move focus to another note...
         if (m_focusedNote) {
             m_focusedNote->setSelected(!m_focusedNote->isSelected());
             event->accept();
         } else
             event->ignore();
         return; // ... so we return after the process
     default:
         return;
     }
 
     if (toFocus == nullptr) { // If no direction keys have been pressed OR reached out the begin or end
         event->ignore();      // Important !!
         return;
     }
 
     if (event->modifiers() & Qt::ShiftModifier) { // Shift+arrowKeys selection
         if (m_startOfShiftSelectionNote == nullptr)
             m_startOfShiftSelectionNote = toFocus;
         ensureNoteVisible(toFocus); // Important: this line should be before the other ones because else repaint would be done on the wrong part!
         selectRange(m_startOfShiftSelectionNote, toFocus);
         setFocusedNote(toFocus);
         event->accept();
         return;
     } else /*if (toFocus != m_focusedNote)*/ { // Move focus to ANOTHER note...
         ensureNoteVisible(toFocus);            // Important: this line should be before the other ones because else repaint would be done on the wrong part!
         setFocusedNote(toFocus);
         m_startOfShiftSelectionNote = toFocus;
         if (!(event->modifiers() & Qt::ControlModifier)) // ... select only current note if Control
             unselectAllBut(m_focusedNote);
         event->accept();
         return;
     }
 
     event->ignore(); // Important !!
 }
 
 /** Select a range of notes and deselect the others.
  * The order between start and end has no importance (end could be before start)
  */
 void BasketScene::selectRange(Note *start, Note *end, bool unselectOthers /*= true*/)
 {
     Note *cur;
     Note *realEnd = nullptr;
 
     // Avoid crash when start (or end) is null
     if (start == nullptr)
         start = end;
     else if (end == nullptr)
         end = start;
     // And if *both* are null
     if (start == nullptr) {
         if (unselectOthers)
             unselectAll();
         return;
     }
     // In case there is only one note to select
     if (start == end) {
         if (unselectOthers)
             unselectAllBut(start);
         else
             start->setSelected(true);
         return;
     }
 
     // Free layout baskets should select range as if we were drawing a rectangle between start and end:
     if (isFreeLayout()) {
         QRectF startRect(start->x(), start->y(), start->width(), start->height());
         QRectF endRect(end->x(), end->y(), end->width(), end->height());
         QRectF toSelect = startRect.united(endRect);
         selectNotesIn(toSelect, /*invertSelection=*/false, unselectOthers);
         return;
     }
 
     // Search the REAL first (and deselect the others before it) :
     for (cur = firstNoteInStack(); cur != nullptr; cur = cur->nextInStack()) {
         if (cur == start || cur == end)
             break;
         if (unselectOthers)
             cur->setSelected(false);
     }
 
     // Select the notes after REAL start, until REAL end :
     if (cur == start)
         realEnd = end;
     else if (cur == end)
         realEnd = start;
 
     for (/*cur = cur*/; cur != nullptr; cur = cur->nextInStack()) {
         cur->setSelected(cur->isShown()); // Select all notes in the range, but only if they are shown
         if (cur == realEnd)
             break;
     }
 
     if (!unselectOthers)
         return;
 
     // Deselect the remaining notes :
     if (cur)
         cur = cur->nextInStack();
     for (/*cur = cur*/; cur != nullptr; cur = cur->nextInStack())
         cur->setSelected(false);
 }
 
 void BasketScene::focusInEvent(QFocusEvent *event)
 {
     // Focus cannot be get with Tab when locked, but a click can focus the basket!
     if (isLocked()) {
         if (m_button) {
             QGraphicsScene::focusInEvent(event);
             QTimer::singleShot(0, m_button, SLOT(setFocus()));
         }
     } else {
         QGraphicsScene::focusInEvent(event);
         focusANote(); // hasFocus() is true at this stage, note will be focused
     }
 }
 
 void BasketScene::focusOutEvent(QFocusEvent *)
 {
     if (m_focusedNote != nullptr)
         m_focusedNote->setFocused(false);
 }
 
 void BasketScene::ensureNoteVisible(Note *note)
 {
     if (!note->isShown()) // Logical!
         return;
 
     if (note == editedNote()) // HACK: When filtering while editing big notes, etc... cause unwanted scrolls
         return;
 
     m_view->ensureVisible(note);
     /*//    int bottom = note->y() + qMin(note->height(),                                             visibleHeight());
     //    int finalRight  = note->x() + qMin(note->width() + (note->hasResizer() ? Note::RESIZER_WIDTH : 0),  visibleWidth());
         qreal bottom = note->y() + qMin(note->height(),                                             (qreal)m_view->viewport()->height());
         qreal finalRight  = note->x() + qMin(note->width() + (note->hasResizer() ? Note::RESIZER_WIDTH : 0),  (qreal)m_view->viewport()->width());
         m_view->ensureVisible(finalRight,     bottom,    0, 0);
         m_view->ensureVisible(note->x(), note->y(), 0, 0);*/
 }
 
 void BasketScene::addWatchedFile(const QString &fullPath)
 {
     //  DEBUG_WIN << "Watcher>Add Monitoring Of : <font color=blue>" + fullPath + "</font>";
     m_watcher->addFile(fullPath);
 }
 
 void BasketScene::removeWatchedFile(const QString &fullPath)
 {
     //  DEBUG_WIN << "Watcher>Remove Monitoring Of : <font color=blue>" + fullPath + "</font>";
     m_watcher->removeFile(fullPath);
 }
 
 void BasketScene::watchedFileModified(const QString &fullPath)
 {
     if (!m_modifiedFiles.contains(fullPath))
         m_modifiedFiles.append(fullPath);
     // If a big file is saved by an application, notifications are send several times.
     // We wait they are not sent anymore to consider the file complete!
     m_watcherTimer.setSingleShot(true);
     m_watcherTimer.start(200);
     DEBUG_WIN << "Watcher>Modified : <font color=blue>" + fullPath + "</font>";
 }
 
 void BasketScene::watchedFileDeleted(const QString &fullPath)
 {
     Note *note = noteForFullPath(fullPath);
     removeWatchedFile(fullPath);
     if (note) {
         NoteSelection *selection = selectedNotes();
         unselectAllBut(note);
         noteDeleteWithoutConfirmation();
         while (selection) {
             selection->note->setSelected(true);
             selection = selection->nextStacked();
         }
     }
     DEBUG_WIN << "Watcher>Removed : <font color=blue>" + fullPath + "</font>";
 }
 
 void BasketScene::updateModifiedNotes()
 {
     for (QList<QString>::iterator it = m_modifiedFiles.begin(); it != m_modifiedFiles.end(); ++it) {
         Note *note = noteForFullPath(*it);
         if (note)
             note->content()->loadFromFile(/*lazyLoad=*/false);
     }
     m_modifiedFiles.clear();
 }
 
 bool BasketScene::setProtection(int type, QString key)
 {
 #ifdef HAVE_LIBGPGME
     if (type == PasswordEncryption || // Ask a new password
         m_encryptionType != type || m_encryptionKey != key) {
         int savedType = m_encryptionType;
         QString savedKey = m_encryptionKey;
 
         m_encryptionType = type;
         m_encryptionKey = key;
         m_gpg->clearCache();
 
         if (saveAgain()) {
             Q_EMIT propertiesChanged(this);
         } else {
             m_encryptionType = savedType;
             m_encryptionKey = savedKey;
             m_gpg->clearCache();
             return false;
         }
     }
     return true;
 #else
     m_encryptionType = type;
     m_encryptionKey = key;
 
     return false;
 #endif
 }
 
 bool BasketScene::saveAgain()
 {
     bool result = false;
 
     m_watcher->stopScan();
     // Re-encrypt basket file:
     result = save();
     // Re-encrypt every note files recursively:
     if (result) {
         FOR_EACH_NOTE(note)
         {
             result = note->saveAgain();
             if (!result)
                 break;
         }
     }
     m_watcher->startScan();
     return result;
 }
 
 bool BasketScene::isEncrypted()
 {
     return (m_encryptionType != NoEncryption);
 }
 
 bool BasketScene::isFileEncrypted()
 {
     QFile file(fullPath() + ".basket");
 
     if (file.open(QIODevice::ReadOnly)) {
         // Should be ASCII anyways
         QString line = file.readLine(32);
         if (line.startsWith("-----BEGIN PGP MESSAGE-----"))
             return true;
     }
     return false;
 }
 
 void BasketScene::lock()
 {
 #ifdef HAVE_LIBGPGME
     closeEditor();
     m_gpg->clearCache();
     m_locked = true;
     enableActions();
     deleteNotes();
     m_loaded = false;
     m_loadingLaunched = false;
 #endif
 }
diff --git a/src/basketscenemodel.cpp b/src/basketscenemodel.cpp
index 5efadb2..bea6122 100644
--- a/src/basketscenemodel.cpp
+++ b/src/basketscenemodel.cpp
@@ -1,308 +1,310 @@
 /*
  * SPDX-FileCopyrightText: (C) 2020 by Ismael Asensio <isma.af@gmail.com>
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "basketscenemodel.h"
+#include "basketscene.h"
 
 #include <QDebug>
 
 
 BasketSceneModel::BasketSceneModel(QObject *parent)
     : QAbstractItemModel(parent)
     , m_root(new NoteItem())
 {
     qRegisterMetaType<NoteContent *>();
     qRegisterMetaType<NoteItem::EditInfo>();
 }
 
 BasketSceneModel::~BasketSceneModel()
 {
     delete m_root;
 }
 
 int BasketSceneModel::rowCount(const QModelIndex &parent) const
 {
     return itemAtIndex(parent)->childrenCount();
 }
 
 int BasketSceneModel::columnCount(const QModelIndex& parent) const
 {
     Q_UNUSED(parent)
     return 1;
 }
 
 QModelIndex BasketSceneModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (!hasIndex(row, column, parent)) {
         return QModelIndex();
     }
 
     NoteItem *item = itemAtIndex(parent)->children().at(row);
     if (item) {
         return createIndex(row, column, item);
     }
     return QModelIndex();
 }
 
 QModelIndex BasketSceneModel::parent(const QModelIndex& index) const
 {
     if (!index.isValid())
         return QModelIndex();
 
     NoteItem *parentItem = itemAtIndex(index)->parent();
     return indexOfItem(parentItem);
 }
 
 QVariant BasketSceneModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     Q_UNUSED(section)
     if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
         return QStringLiteral("BasketSceneModel");
 
     return QVariant();
 }
 
 QHash<int, QByteArray> BasketSceneModel::roleNames() const
 {
     static const auto roles = QHash<int, QByteArray> {
         { ContentRole,  "content"   },
         { TypeRole,     "type"      },
         { GeometryRole, "geometry"  },
         { EditionRole,  "edition"   },
         { AddressRole,  "address"   }
     }.unite(QAbstractItemModel::roleNames());
     return roles;
 }
 
 
 QVariant BasketSceneModel::data(const QModelIndex &index, int role) const
 {
     if (!checkIndex(index, CheckIndexOption::IndexIsValid)) {
         return QVariant();
     }
 
     const NoteItem *item = itemAtIndex(index);
 
     switch (role) {
         case Qt::DisplayRole:
             return item->displayText();
         case Qt::DecorationRole:
             return item->decoration();
         case Qt::ToolTipRole:       // To ease debugging
             return item->toolTipInfo();
         case BasketSceneModel::ContentRole:
             return QVariant::fromValue(item->content());
         case BasketSceneModel::TypeRole:
             return item->type();
         case BasketSceneModel::GeometryRole:
             return item->bounds();
         case BasketSceneModel::EditionRole: {
             QVariant info;
             info.setValue(item->editInformation());
             return info;
         }
         case BasketSceneModel::AddressRole:
             return item->address();
     }
 
     return QVariant();
 }
 
 
 NoteItem *BasketSceneModel::itemAtIndex(const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return m_root;
     }
     return static_cast<NoteItem*>(index.internalPointer());
 }
 
 QModelIndex BasketSceneModel::indexOfItem(NoteItem *item) const
 {
     if (!item || item == m_root) {
         return QModelIndex();
     }
     return createIndex(item->row(), 0, item);
 }
 
 QModelIndex BasketSceneModel::findNote(NotePtr note) const
 {
     if (!note || m_root->childrenCount() == 0) {
         return QModelIndex();
     }
     const QModelIndexList matchResult = match(indexOfItem(m_root->children().at(0)),
                                               BasketSceneModel::AddressRole,
                                               NoteItem::formatAddress(note), 1,
                                               Qt::MatchExactly | Qt::MatchWrap | Qt::MatchRecursive);
     if (matchResult.isEmpty()) {
         return QModelIndex();
     }
     return matchResult[0];
 }
 
 
 bool BasketSceneModel::insertRows(int row, int count, const QModelIndex& parent)
 {
     if(!checkIndex(parent)) {
         return false;
     }
 
     beginInsertRows(parent, row, row + count - 1);
     for (int i = 0; i < count; i++) {
         itemAtIndex(parent)->insertAt(row + i, new NoteItem());
     }
     endInsertRows();
     return true;
 }
 
 bool BasketSceneModel::removeRows(int row, int count, const QModelIndex& parent)
 {
     if(!checkIndex(parent)) {
         return false;
     }
 
     beginRemoveRows(parent, row, row + count - 1);
     for (int i = 0; i < count; i++) {
         itemAtIndex(parent)->removeAt(row);
     }
     endRemoveRows();
     return true;
 }
 
 bool BasketSceneModel::moveRows(const QModelIndex& sourceParent, int sourceRow, int count,
                                 const QModelIndex& destinationParent, int destinationChild)
 {
     const bool isMoveDown = (destinationParent == sourceParent  && destinationChild > sourceRow);
 
     if (!beginMoveRows(sourceParent, sourceRow, sourceRow + count -1,
                        destinationParent, (isMoveDown) ? destinationChild + 1 : destinationChild)) {
         return false;
     }
 
     for (int i = 0; i < count; i++) {
         const int oldRow = (isMoveDown) ? sourceRow : sourceRow + i;
         itemAtIndex(destinationParent)->insertAt(destinationChild + i,
                                                  itemAtIndex(sourceParent)->takeAt(oldRow));
     }
     endMoveRows();
     return true;
 }
 
 
 void BasketSceneModel::clear()
 {
     beginResetModel();
     qDeleteAll(m_root->children());
     endResetModel();
 }
 
 void BasketSceneModel::loadFromXML(const QDomElement &node)
 {
     beginResetModel();
     qDeleteAll(m_root->children());
+    NoteItem::setBasketParent(qobject_cast<BasketScene *>(qobject_cast<QObject *>(this)->parent()));
     m_root->loadFromXMLNode(node);
     endResetModel();
 }
 
 
 void BasketSceneModel::insertNote(NotePtr note, NotePtr parentNote, int row)
 {
     if (!note) {
         return;
     }
 
     const QModelIndex parentIndex = findNote(parentNote);
     if (!checkIndex(parentIndex)) {
         return;
     }
 
     if (row < 0 || row >= rowCount(parentIndex)) {  // row == -1 : insert at the end
         row = rowCount(parentIndex);
     }
 
     qDebug() << "BasketSceneModel::insertNote " << NoteItem::formatAddress(note)
              << " at " << itemAtIndex(parentIndex)->address()
              << "[" << row << "]";
 
     // Protection against adding the same Note * twice (same pointer)
     // This should not be necessary once the old code in BasketScene has been cleaned-up
     if (findNote(note).isValid()) {
         QModelIndex prevIndex = findNote(note);
         qDebug() << " · Note " << itemAtIndex(prevIndex)->address()
                  << " was alreadyPresent at " << itemAtIndex(parentIndex)->address()
                  << "[" << prevIndex.row() << "]"
                  << ". Moving it instead to new location";
         moveNoteTo(note, parentNote, row);
         return;
     }
 
     if (insertRow(row, parentIndex)) {
         itemAtIndex(parentIndex)->children().at(row)->setNote(note);
         connect(note, &QObject::destroyed, this, [=](QObject *note) {
             BasketSceneModel::removeNote(static_cast<Note *>(note));
         });
     }
 }
 
 void BasketSceneModel::removeNote(NotePtr note)
 {
     if (!note) {
         return;
     }
     const QModelIndex index = findNote(note);
     const QModelIndex parentIndex = index.parent();
 
     qDebug() << "BasketSceneModel::removeNote " << itemAtIndex(index)->address();
 
     removeRow(index.row(), parentIndex);
 }
 
 void BasketSceneModel::moveNoteTo(NotePtr note, NotePtr parentNote, int row)
 {
     if (!note) {
         return;
     }
     const QModelIndex currentIndex = findNote(note);
     const QModelIndex srcParentIndex = currentIndex.parent();
     const QModelIndex destParentIndex = findNote(parentNote);
 
     if (!checkIndex(currentIndex, CheckIndexOption::IndexIsValid)) {
         return;
     }
 
     if (row < 0 || row >= rowCount(destParentIndex)) {
         row = rowCount(destParentIndex);    // row == -1 : insert at the end
     }
 
     qDebug() << "BasketSceneModel::moveNote " << itemAtIndex(currentIndex)->address()
              << "\n  from: " << itemAtIndex(srcParentIndex)->address() << "[" << currentIndex.row() << "]"
              << "\n    to: " << itemAtIndex(destParentIndex)->address() << "[" << row << "]";
 
     moveRow(srcParentIndex, currentIndex.row(), destParentIndex, row);
 }
 
 
 void BasketSceneModel::collapseItem(const QModelIndex &index)
 {
     if (hasChildren(index)) {
         itemAtIndex(index)->children().at(0)->note()->tryFoldParent();
     }
 }
 
 void BasketSceneModel::expandItem(const QModelIndex &index)
 {
     if (hasChildren(index)) {
         itemAtIndex(index)->children().at(0)->note()->tryExpandParent();
     }
 }
 
 void BasketSceneModel::changeSelection(const QItemSelection& selected, const QItemSelection& deselected)
 {
     for (const auto index : deselected.indexes()) {
         itemAtIndex(index)->note()->setSelected(false);
     }
     for (const auto index : selected.indexes()) {
         itemAtIndex(index)->note()->setSelected(true);
     }
 }
diff --git a/src/basketscenemodel.h b/src/basketscenemodel.h
index cbe5c2e..91c1b41 100644
--- a/src/basketscenemodel.h
+++ b/src/basketscenemodel.h
@@ -1,69 +1,72 @@
 /*
  * SPDX-FileCopyrightText: 2020 by Ismael Asensio <isma.af@gmail.com>
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #pragma once
 
 #include "basket_export.h"
 #include "noteitem.h"
 
 #include <QAbstractItemModel>
 #include <QItemSelection>
 
 
+class BasketScene;
+
+
 class BASKET_EXPORT BasketSceneModel : public QAbstractItemModel
 {
     Q_OBJECT
 
 public:
     enum AdditionalRoles {
         ContentRole = Qt::UserRole + 1, // NoteContent * : the internal NoteContent
         TypeRole,           // NoteContent::Type: the type of the NoteContent
         GeometryRole,       // QRect: the bounds of the Note
         EditionRole,        // NoteItem::EditInfo: the edition information about the Note
         AddressRole         // QString: representation of the internal NotePtr address
     };
 
 public:
     explicit BasketSceneModel(QObject *parent = nullptr);
     ~BasketSceneModel();
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     int columnCount(const QModelIndex &parent = QModelIndex()) const override;
     QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
     QModelIndex parent(const QModelIndex &index) const override;
     QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
 
     QHash<int, QByteArray> roleNames() const override;
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
 //    bool setData(const QModelIndex &index, const QVariant &value, int role) override;
 
     bool insertRows(int row, int count, const QModelIndex &parent = QModelIndex()) override;
     bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex()) override;
     bool moveRows(const QModelIndex &sourceParent, int sourceRow, int count,
                   const QModelIndex &destinationParent, int destinationChild) override;
 
     void clear();
     void loadFromXML(const QDomElement &node);
 
     // Specific methods to call from BasketScene (temporary)
     void insertNote(NotePtr note, NotePtr parentNote, int row = -1);
     void removeNote(NotePtr note);
     void moveNoteTo(NotePtr note, NotePtr parentNote, int row = -1);
 
 
 public slots:
     // Interaction between the model and BasketScene, mainly for demo and debugging purposes
     void expandItem(const QModelIndex &index);
     void collapseItem(const QModelIndex &index);
     void changeSelection(const QItemSelection &selected, const QItemSelection &deselected);
 
 private:
     NoteItem *itemAtIndex(const QModelIndex &index) const;
     QModelIndex indexOfItem(NoteItem *item) const;
     QModelIndex findNote(NotePtr note) const;
 
 private:
     NoteItem *m_root;
 };
diff --git a/src/bnpview.cpp b/src/bnpview.cpp
index 32d669b..ff57387 100644
--- a/src/bnpview.cpp
+++ b/src/bnpview.cpp
@@ -1,2861 +1,2863 @@
 /**
  * SPDX-FileCopyrightText: (C) 2003 by Sébastien Laoût <slaout@linux62.org>
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "bnpview.h"
 #include "common.h"
 
 #include <QAction>
 #include <QApplication>
 #include <QCommandLineParser>
 #include <QGraphicsView>
 #include <QMenu>
 #include <QProgressDialog>
 #include <QStackedWidget>
 #include <QUndoStack>
 #include <QtCore/QDir>
 #include <QtCore/QEvent>
 #include <QtCore/QList>
 #include <QtCore/QRegExp>
 #include <QtGui/QHideEvent>
 #include <QtGui/QImage>
 #include <QtGui/QKeyEvent>
 #include <QtGui/QPixmap>
 #include <QtGui/QResizeEvent>
 #include <QtGui/QShowEvent>
 #include <QtXml/QDomDocument>
 
 #include <KAboutData>
 #include <KActionCollection>
 #include <KActionMenu>
 #include <KConfigGroup>
 #include <KGlobalAccel>
 #include <KIconLoader>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KPassivePopup>
 #include <KStandardShortcut>
 #include <KToggleAction>
 #include <KWindowSystem>
 #include <KXMLGUIFactory>
 
 #ifndef BASKET_USE_DRKONQI
 #include <KCrash>
 #endif // BASKET_USE_DRKONQI
 
 #include <cstdlib>
 #include <unistd.h> // usleep
 
 #include "archive.h"
 #include "backgroundmanager.h"
 #include "backup.h"
 #include "basketfactory.h"
 #include "basketlistview.h"
 #include "basketproperties.h"
 #include "basketscene.h"
 #include "basketstatusbar.h"
 #include "colorpicker.h"
 #include "debugwindow.h"
 #include "decoratedbasket.h"
 #include "formatimporter.h"
 #include "gitwrapper.h"
 #include "history.h"
 #include "htmlexporter.h"
 #include "icon_names.h"
 #include "newbasketdialog.h"
 #include "notedrag.h"
 #include "noteedit.h" // To launch InlineEditors::initToolBars()
 #include "notefactory.h"
 #include "password.h"
 #include "regiongrabber.h"
 #include "settings.h"
 #include "softwareimporters.h"
 #include "tools.h"
 #include "xmlwork.h"
 
 #include <QFileDialog>
 #include <QResource>
 #include <QStandardPaths>
 #include <qdbusconnection.h>
 
 //#include "bnpviewadaptor.h"
 
 /** class BNPView: */
 
 const int BNPView::c_delayTooltipTime = 275;
 
 BNPView::BNPView(QWidget *parent, const char *name, KXMLGUIClient *aGUIClient, KActionCollection *actionCollection, BasketStatusBar *bar)
     : QSplitter(Qt::Horizontal, parent)
     , m_actLockBasket(nullptr)
     , m_actPassBasket(nullptr)
     , m_loading(true)
     , m_newBasketPopup(false)
     , m_firstShow(true)
     , m_colorPicker(new DesktopColorPicker())
     , m_regionGrabber(nullptr)
     , m_passiveDroppedSelection(nullptr)
     , m_actionCollection(actionCollection)
     , m_guiClient(aGUIClient)
     , m_statusbar(bar)
     , m_tryHideTimer(nullptr)
     , m_hideTimer(nullptr)
     , m_modelView(nullptr)
 {
     // new BNPViewAdaptor(this);
     QDBusConnection dbus = QDBusConnection::sessionBus();
     dbus.registerObject("/BNPView", this);
 
     setObjectName(name);
 
     /* Settings */
     Settings::loadConfig();
 
     Global::bnpView = this;
 
     // Needed when loading the baskets:
     Global::backgroundManager = new BackgroundManager();
 
     setupGlobalShortcuts();
     m_history = new QUndoStack(this);
     initialize();
     QTimer::singleShot(0, this, SLOT(lateInit()));
 }
 
 BNPView::~BNPView()
 {
     int treeWidth = Global::bnpView->sizes()[Settings::treeOnLeft() ? 0 : 1];
 
     Settings::setBasketTreeWidth(treeWidth);
 
     if (currentBasket() && currentBasket()->isDuringEdit())
         currentBasket()->closeEditor();
 
     Settings::saveConfig();
 
     Global::bnpView = nullptr;
 
     delete Global::systemTray;
     Global::systemTray = nullptr;
     delete m_statusbar;
     delete m_history;
     m_history = nullptr;
 
     NoteDrag::createAndEmptyCuttingTmpFolder(); // Clean the temporary folder we used
 }
 
 void BNPView::lateInit()
 {
     /*
         InlineEditors* instance = InlineEditors::instance();
 
         if(instance)
         {
             KToolBar* toolbar = instance->richTextToolBar();
 
             if(toolbar)
                 toolbar->hide();
         }
     */
 
     // If the main window is hidden when session is saved, Container::queryClose()
     //  isn't called and the last value would be kept
     Settings::setStartDocked(true);
     Settings::saveConfig();
 
     /* System tray icon */
     Global::systemTray = new SystemTray(Global::activeMainWindow());
     Global::systemTray->setIconByName(":/images/22-apps-basket");
     connect(Global::systemTray, &SystemTray::showPart, this, &BNPView::showPart);
     /*if (Settings::useSystray())
         Global::systemTray->show();*/
 
     // Load baskets
     DEBUG_WIN << "Baskets are loaded from " + Global::basketsFolder();
 
     NoteDrag::createAndEmptyCuttingTmpFolder(); // If last exec hasn't done it: clean the temporary folder we will use
     Tag::loadTags();                            // Tags should be ready before loading baskets, but tags need the mainContainer to be ready to create KActions!
     load();
 
     // If no basket has been found, try to import from an older version,
     if (topLevelItemCount() <= 0) {
         QDir dir;
         dir.mkdir(Global::basketsFolder());
         if (FormatImporter::shouldImportBaskets()) {
             FormatImporter::importBaskets();
             load();
         }
         if (topLevelItemCount() <= 0) {
             // Create first basket:
             BasketFactory::newBasket(QString(), i18n("General"));
             GitWrapper::commitBasket(currentBasket());
             GitWrapper::commitTagsXml();
         }
     }
 
     // Load the Welcome Baskets if it is the First Time:
     if (!Settings::welcomeBasketsAdded()) {
         addWelcomeBaskets();
         Settings::setWelcomeBasketsAdded(true);
         Settings::saveConfig();
     }
 
     m_tryHideTimer = new QTimer(this);
     m_hideTimer = new QTimer(this);
     connect(m_tryHideTimer, &QTimer::timeout, this, &BNPView::timeoutTryHide);
     connect(m_hideTimer, &QTimer::timeout, this, &BNPView::timeoutHide);
 
     // Preload every baskets for instant filtering:
     /*StopWatch::start(100);
         QListViewItemIterator it(m_tree);
         while (it.current()) {
             BasketListViewItem *item = ((BasketListViewItem*)it.current());
             item->basket()->load();
             qApp->processEvents();
             ++it;
         }
     StopWatch::check(100);*/
 }
 
 void BNPView::addWelcomeBaskets()
 {
     // Possible paths where to find the welcome basket archive, trying the translated one, and falling back to the English one:
     QStringList possiblePaths;
     if (QString(Tools::systemCodeset()) == QString("UTF-8")) { // Welcome baskets are encoded in UTF-8. If the system is not, then use the English version:
         QString lang = QLocale().languageToString(QLocale().language());
         possiblePaths.append(QStandardPaths::locate(QStandardPaths::GenericDataLocation, "basket/welcome/Welcome_" + lang + ".baskets"));
         possiblePaths.append(QStandardPaths::locate(QStandardPaths::GenericDataLocation, "basket/welcome/Welcome_" + lang.split('_')[0] + ".baskets"));
     }
     possiblePaths.append(QStandardPaths::locate(QStandardPaths::GenericDataLocation, "basket/welcome/Welcome_en_US.baskets"));
 
     // Take the first EXISTING basket archive found:
     QDir dir;
     QString path;
     for (QStringList::Iterator it = possiblePaths.begin(); it != possiblePaths.end(); ++it) {
         if (dir.exists(*it)) {
             path = *it;
             break;
         }
     }
 
     // Extract:
     if (!path.isEmpty())
         Archive::open(path);
 }
 
 void BNPView::onFirstShow()
 {
     // In late init, because we need qApp->mainWidget() to be set!
     connectTagsMenu();
 
     m_statusbar->setupStatusBar();
 
     int treeWidth = Settings::basketTreeWidth();
     if (treeWidth < 0)
         treeWidth = m_tree->fontMetrics().maxWidth() * 11;
     QList<int> splitterSizes;
     splitterSizes.append(treeWidth);
     setSizes(splitterSizes);
 }
 
 void BNPView::setupGlobalShortcuts()
 {
     KActionCollection *ac = new KActionCollection(this);
     QAction *a = nullptr;
 
     // Ctrl+Shift+W only works when started standalone:
     QWidget *basketMainWindow = qobject_cast<KMainWindow *>(Global::bnpView->parent());
 
     int modifier = Qt::CTRL + Qt::ALT + Qt::SHIFT;
 
     if (basketMainWindow) {
         a = ac->addAction("global_show_hide_main_window", Global::systemTray, SLOT(toggleActive()));
         a->setText(i18n("Show/hide main window"));
         a->setStatusTip(
             i18n("Allows you to show main Window if it is hidden, and to hide "
                  "it if it is shown."));
         KGlobalAccel::self()->setGlobalShortcut(a, (QKeySequence(modifier + Qt::Key_W)));
     }
 
     a = ac->addAction("global_paste", Global::bnpView, SLOT(globalPasteInCurrentBasket()));
     a->setText(i18n("Paste clipboard contents in current basket"));
     a->setStatusTip(
         i18n("Allows you to paste clipboard contents in the current basket "
              "without having to open the main window."));
     KGlobalAccel::self()->setGlobalShortcut(a, QKeySequence(modifier + Qt::Key_V));
 
     a = ac->addAction("global_show_current_basket", Global::bnpView, SLOT(showPassiveContentForced()));
     a->setText(i18n("Show current basket name"));
     a->setStatusTip(
         i18n("Allows you to know basket is current without opening "
              "the main window."));
 
     a = ac->addAction("global_paste_selection", Global::bnpView, SLOT(pasteSelInCurrentBasket()));
     a->setText(i18n("Paste selection in current basket"));
     a->setStatusTip(
         i18n("Allows you to paste clipboard selection in the current basket "
              "without having to open the main window."));
     KGlobalAccel::self()->setGlobalShortcut(a, (QKeySequence(Qt::CTRL + Qt::ALT + Qt::SHIFT + Qt::Key_S)));
 
     a = ac->addAction("global_new_basket", Global::bnpView, SLOT(askNewBasket()));
     a->setText(i18n("Create a new basket"));
     a->setStatusTip(
         i18n("Allows you to create a new basket without having to open the "
              "main window (you then can use the other global shortcuts to add "
              "a note, paste clipboard or paste selection in this new basket)."));
 
     a = ac->addAction("global_previous_basket", Global::bnpView, SLOT(goToPreviousBasket()));
     a->setText(i18n("Go to previous basket"));
     a->setStatusTip(
         i18n("Allows you to change current basket to the previous one without "
              "having to open the main window."));
 
     a = ac->addAction("global_next_basket", Global::bnpView, SLOT(goToNextBasket()));
     a->setText(i18n("Go to next basket"));
     a->setStatusTip(
         i18n("Allows you to change current basket to the next one "
              "without having to open the main window."));
 
     a = ac->addAction("global_note_add_html", Global::bnpView, SLOT(addNoteHtml()));
     a->setText(i18n("Insert text note"));
     a->setStatusTip(
         i18n("Add a text note to the current basket without having to open "
              "the main window."));
     KGlobalAccel::self()->setGlobalShortcut(a, (QKeySequence(modifier + Qt::Key_T)));
 
     a = ac->addAction("global_note_add_image", Global::bnpView, SLOT(addNoteImage()));
     a->setText(i18n("Insert image note"));
     a->setStatusTip(
         i18n("Add an image note to the current basket without having to open "
              "the main window."));
 
     a = ac->addAction("global_note_add_link", Global::bnpView, SLOT(addNoteLink()));
     a->setText(i18n("Insert link note"));
     a->setStatusTip(
         i18n("Add a link note to the current basket without having "
              "to open the main window."));
 
     a = ac->addAction("global_note_add_color", Global::bnpView, SLOT(addNoteColor()));
     a->setText(i18n("Insert color note"));
     a->setStatusTip(
         i18n("Add a color note to the current basket without having to open "
              "the main window."));
 
     a = ac->addAction("global_note_pick_color", Global::bnpView, SLOT(slotColorFromScreenGlobal()));
     a->setText(i18n("Pick color from screen"));
     a->setStatusTip(
         i18n("Add a color note picked from one pixel on screen to the current "
              "basket without "
              "having to open the main window."));
 
     a = ac->addAction("global_note_grab_screenshot", Global::bnpView, SLOT(grabScreenshotGlobal()));
     a->setText(i18n("Grab screen zone"));
     a->setStatusTip(
         i18n("Grab a screen zone as an image in the current basket without "
              "having to open the main window."));
 
 #if 0
     a = ac->addAction("global_note_add_text", Global::bnpView,
                       SLOT(addNoteText()));
     a->setText(i18n("Insert plain text note"));
     a->setStatusTip(
         i18n("Add a plain text note to the current basket without having to "
              "open the main window."));
 #endif
 }
 
 void BNPView::initialize()
 {
     /// Configure the List View Columns:
     m_tree = new BasketTreeListView(this);
     m_tree->setHeaderLabel(i18n("Baskets"));
     m_tree->setSortingEnabled(false /*Disabled*/);
     m_tree->setRootIsDecorated(true);
     m_tree->setLineWidth(1);
     m_tree->setMidLineWidth(0);
     m_tree->setFocusPolicy(Qt::NoFocus);
 
     /// Configure the List View Drag and Drop:
     m_tree->setDragEnabled(true);
     m_tree->setDragDropMode(QAbstractItemView::DragDrop);
     m_tree->setAcceptDrops(true);
     m_tree->viewport()->setAcceptDrops(true);
 
     /// Configure the Splitter:
     m_stack = new QStackedWidget(this);
 
     setOpaqueResize(true);
 
     setCollapsible(indexOf(m_tree), true);
     setCollapsible(indexOf(m_stack), false);
     setStretchFactor(indexOf(m_tree), 0);
     setStretchFactor(indexOf(m_stack), 1);
 
     /// Configure the List View Signals:
     connect(m_tree, &BasketTreeListView::itemActivated, this, &BNPView::slotPressed);
     connect(m_tree, &BasketTreeListView::itemPressed, this, &BNPView::slotPressed);
     connect(m_tree, &BasketTreeListView::itemClicked, this, &BNPView::slotPressed);
 
     connect(m_tree, &BasketTreeListView::itemExpanded, this, &BNPView::needSave);
     connect(m_tree, &BasketTreeListView::itemCollapsed, this, &BNPView::needSave);
     connect(m_tree, &BasketTreeListView::contextMenuRequested, this, &BNPView::slotContextMenu);
     connect(m_tree, &BasketTreeListView::itemDoubleClicked, this, &BNPView::slotShowProperties);
 
     connect(m_tree, &BasketTreeListView::itemExpanded, this, &BNPView::basketChanged);
     connect(m_tree, &BasketTreeListView::itemCollapsed, this, &BNPView::basketChanged);
 
     connect(this, &BNPView::basketChanged, this, &BNPView::slotBasketChanged);
 
     connect(m_history, &QUndoStack::canRedoChanged, this, &BNPView::canUndoRedoChanged);
     connect(m_history, &QUndoStack::canUndoChanged, this, &BNPView::canUndoRedoChanged);
 
     setupActions();
 
     /// What's This Help for the tree:
     m_tree->setWhatsThis(
         i18n("<h2>Basket Tree</h2>"
              "Here is the list of your baskets. "
              "You can organize your data by putting them in different baskets. "
              "You can group baskets by subject by creating new baskets inside others. "
              "You can browse between them by clicking a basket to open it, or reorganize them using drag and drop."));
 
     setTreePlacement(Settings::treeOnLeft());
 
     // VISUALAIZE AND INTERACT WITH BasketSceneModel using a QTreeView
     m_modelView = new QTreeView();
     m_modelView->setMinimumSize(300, 100);
     m_modelView->setSelectionMode(QAbstractItemView::ExtendedSelection);
 
     this->addWidget(m_modelView);
     this->setCollapsible(2, false);
 }
 
 void BNPView::setupActions()
 {
     QAction *a = nullptr;
     KActionCollection *ac = actionCollection();
 
     a = ac->addAction("basket_export_basket_archive", this, SLOT(saveAsArchive()));
     a->setText(i18n("&Basket Archive..."));
     a->setIcon(QIcon::fromTheme("baskets"));
     a->setShortcut(0);
     m_actSaveAsArchive = a;
 
     a = ac->addAction("basket_import_basket_archive", this, SLOT(openArchive()));
     a->setText(i18n("&Basket Archive..."));
     a->setIcon(QIcon::fromTheme("baskets"));
     a->setShortcut(0);
     m_actOpenArchive = a;
 
     a = ac->addAction("window_hide", this, SLOT(hideOnEscape()));
     a->setText(i18n("&Hide Window"));
     m_actionCollection->setDefaultShortcut(a, KStandardShortcut::Close);
     m_actHideWindow = a;
 
     m_actHideWindow->setEnabled(Settings::useSystray()); // Init here !
 
     a = ac->addAction("basket_export_html", this, SLOT(exportToHTML()));
     a->setText(i18n("&HTML Web Page..."));
     a->setIcon(QIcon::fromTheme("text-html"));
     a->setShortcut(0);
     m_actExportToHtml = a;
 
     a = ac->addAction("basket_import_text_file", this, &BNPView::importTextFile);
     a->setText(i18n("Text &File..."));
     a->setIcon(QIcon::fromTheme("text-plain"));
     a->setShortcut(0);
 
     a = ac->addAction("basket_backup_restore", this, SLOT(backupRestore()));
     a->setText(i18n("&Backup && Restore..."));
     a->setShortcut(0);
 
     a = ac->addAction("check_cleanup", this, SLOT(checkCleanup()));
     a->setText(i18n("&Check && Cleanup..."));
     a->setShortcut(0);
     if (Global::commandLineOpts->isSet("debug")) {
         a->setEnabled(true);
     } else {
         a->setEnabled(false);
     }
 
     /** Note : ****************************************************************/
 
     a = ac->addAction("edit_delete", this, SLOT(delNote()));
     a->setText(i18n("D&elete"));
     a->setIcon(QIcon::fromTheme("edit-delete"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Delete"));
     m_actDelNote = a;
 
     m_actCutNote = ac->addAction(KStandardAction::Cut, this, SLOT(cutNote()));
     m_actCopyNote = ac->addAction(KStandardAction::Copy, this, SLOT(copyNote()));
 
     m_actSelectAll = ac->addAction(KStandardAction::SelectAll, this, SLOT(slotSelectAll()));
     m_actSelectAll->setStatusTip(i18n("Selects all notes"));
 
     a = ac->addAction("edit_unselect_all", this, SLOT(slotUnselectAll()));
     a->setText(i18n("U&nselect All"));
     m_actUnselectAll = a;
     m_actUnselectAll->setStatusTip(i18n("Unselects all selected notes"));
 
     a = ac->addAction("edit_invert_selection", this, SLOT(slotInvertSelection()));
     a->setText(i18n("&Invert Selection"));
     m_actionCollection->setDefaultShortcut(a, Qt::CTRL + Qt::Key_Asterisk);
     m_actInvertSelection = a;
 
     m_actInvertSelection->setStatusTip(i18n("Inverts the current selection of notes"));
 
     a = ac->addAction("note_edit", this, SLOT(editNote()));
     a->setText(i18nc("Verb; not Menu", "&Edit..."));
     // a->setIcon(QIcon::fromTheme("edit"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Return"));
     m_actEditNote = a;
 
     m_actOpenNote = ac->addAction(KStandardAction::Open, "note_open", this, SLOT(openNote()));
     m_actOpenNote->setIcon(QIcon::fromTheme("window-new"));
     m_actOpenNote->setText(i18n("&Open"));
     m_actionCollection->setDefaultShortcut(m_actOpenNote, QKeySequence("F9"));
 
     a = ac->addAction("note_open_with", this, SLOT(openNoteWith()));
     a->setText(i18n("Open &With..."));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Shift+F9"));
     m_actOpenNoteWith = a;
 
     m_actSaveNoteAs = ac->addAction(KStandardAction::SaveAs, "note_save_to_file", this, SLOT(saveNoteAs()));
     m_actSaveNoteAs->setText(i18n("&Save to File..."));
     m_actionCollection->setDefaultShortcut(m_actSaveNoteAs, QKeySequence("F10"));
 
     a = ac->addAction("note_group", this, SLOT(noteGroup()));
     a->setText(i18n("&Group"));
     a->setIcon(QIcon::fromTheme("mail-attachment"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Ctrl+G"));
     m_actGroup = a;
 
     a = ac->addAction("note_ungroup", this, SLOT(noteUngroup()));
     a->setText(i18n("U&ngroup"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Ctrl+Shift+G"));
     m_actUngroup = a;
 
     a = ac->addAction("note_move_top", this, SLOT(moveOnTop()));
     a->setText(i18n("Move on &Top"));
     a->setIcon(QIcon::fromTheme("arrow-up-double"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Ctrl+Shift+Home"));
     m_actMoveOnTop = a;
 
     a = ac->addAction("note_move_up", this, SLOT(moveNoteUp()));
     a->setText(i18n("Move &Up"));
     a->setIcon(QIcon::fromTheme("arrow-up"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Ctrl+Shift+Up"));
     m_actMoveNoteUp = a;
 
     a = ac->addAction("note_move_down", this, SLOT(moveNoteDown()));
     a->setText(i18n("Move &Down"));
     a->setIcon(QIcon::fromTheme("arrow-down"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Ctrl+Shift+Down"));
     m_actMoveNoteDown = a;
 
     a = ac->addAction("note_move_bottom", this, SLOT(moveOnBottom()));
     a->setText(i18n("Move on &Bottom"));
     a->setIcon(QIcon::fromTheme("arrow-down-double"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Ctrl+Shift+End"));
     m_actMoveOnBottom = a;
 
     m_actPaste = ac->addAction(KStandardAction::Paste, this, SLOT(pasteInCurrentBasket()));
 
     /** Insert : **************************************************************/
 
 #if 0
     a = ac->addAction("insert_text");
     a->setText(i18n("Plai&n Text"));
     a->setIcon(QIcon::fromTheme("text"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Ctrl+T"));
     m_actInsertText = a;
 #endif
 
     a = ac->addAction("insert_html");
     a->setText(i18n("&Text"));
     a->setIcon(QIcon::fromTheme("text-html"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Insert"));
     m_actInsertHtml = a;
 
     a = ac->addAction("insert_link");
     a->setText(i18n("&Link"));
     a->setIcon(QIcon::fromTheme(IconNames::LINK));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Ctrl+Y"));
     m_actInsertLink = a;
 
     a = ac->addAction("insert_cross_reference");
     a->setText(i18n("Cross &Reference"));
     a->setIcon(QIcon::fromTheme(IconNames::CROSS_REF));
     m_actInsertCrossReference = a;
 
     a = ac->addAction("insert_image");
     a->setText(i18n("&Image"));
     a->setIcon(QIcon::fromTheme(IconNames::IMAGE));
     m_actInsertImage = a;
 
     a = ac->addAction("insert_color");
     a->setText(i18n("&Color"));
     a->setIcon(QIcon::fromTheme(IconNames::COLOR));
     m_actInsertColor = a;
 
     a = ac->addAction("insert_launcher");
     a->setText(i18n("L&auncher"));
     a->setIcon(QIcon::fromTheme(IconNames::LAUNCH));
     m_actInsertLauncher = a;
 
     a = ac->addAction("insert_kmenu");
     a->setText(i18n("Import Launcher for &desktop application..."));
     a->setIcon(QIcon::fromTheme(IconNames::KMENU));
     m_actImportKMenu = a;
 
     a = ac->addAction("insert_icon");
     a->setText(i18n("Im&port Icon..."));
     a->setIcon(QIcon::fromTheme(IconNames::ICONS));
     m_actImportIcon = a;
 
     a = ac->addAction("insert_from_file");
     a->setText(i18n("Load From &File..."));
     a->setIcon(QIcon::fromTheme(IconNames::DOCUMENT_IMPORT));
     m_actLoadFile = a;
 
     //  connect( m_actInsertText, QAction::triggered, this, [this] () { insertEmpty(NoteType::Text); });
     connect(m_actInsertHtml, &QAction::triggered, this, [this] () { insertEmpty(NoteType::Html); });
     connect(m_actInsertImage, &QAction::triggered, this, [this] () { insertEmpty(NoteType::Image); });
     connect(m_actInsertLink, &QAction::triggered, this, [this] () { insertEmpty(NoteType::Link); });
     connect(m_actInsertCrossReference, &QAction::triggered, this, [this] () { insertEmpty(NoteType::CrossReference); });
     connect(m_actInsertColor, &QAction::triggered, this, [this] () { insertEmpty(NoteType::Color); });
     connect(m_actInsertLauncher, &QAction::triggered, this, [this] () { insertEmpty(NoteType::Launcher); });
 
     connect(m_actImportKMenu, &QAction::triggered, this, [this] () { insertWizard(1); });
     connect(m_actImportIcon, &QAction::triggered, this, [this] () { insertWizard(2); });
     connect(m_actLoadFile, &QAction::triggered, this, [this] () { insertWizard(3); });
 
     a = ac->addAction("insert_screen_color", this, &BNPView::slotColorFromScreen);
     a->setText(i18n("C&olor from Screen"));
     a->setIcon(QIcon::fromTheme("kcolorchooser"));
     m_actColorPicker = a;
 
     connect(m_colorPicker.get(), &DesktopColorPicker::pickedColor, this, &BNPView::colorPicked);
 
     a = ac->addAction("insert_screen_capture", this, SLOT(grabScreenshot()));
     a->setText(i18n("Grab Screen &Zone"));
     a->setIcon(QIcon::fromTheme("ksnapshot"));
     m_actGrabScreenshot = a;
 
     //connect(m_actGrabScreenshot, SIGNAL(regionGrabbed(const QPixmap&)), this, SLOT(screenshotGrabbed(const QPixmap&)));
     //connect(m_colorPicker, SIGNAL(canceledPick()), this, SLOT(colorPickingCanceled()));
 
     //  m_insertActions.append( m_actInsertText     );
     m_insertActions.append(m_actInsertHtml);
     m_insertActions.append(m_actInsertLink);
     m_insertActions.append(m_actInsertCrossReference);
     m_insertActions.append(m_actInsertImage);
     m_insertActions.append(m_actInsertColor);
     m_insertActions.append(m_actImportKMenu);
     m_insertActions.append(m_actInsertLauncher);
     m_insertActions.append(m_actImportIcon);
     m_insertActions.append(m_actLoadFile);
     m_insertActions.append(m_actColorPicker);
     m_insertActions.append(m_actGrabScreenshot);
 
     /** Basket : **************************************************************/
 
     // At this stage, main.cpp has not set qApp->mainWidget(), so Global::runInsideKontact()
     // returns true. We do it ourself:
     bool runInsideKontact = true;
     QWidget *parentWidget = (QWidget *)parent();
     while (parentWidget) {
         if (parentWidget->inherits("MainWindow"))
             runInsideKontact = false;
         parentWidget = (QWidget *)parentWidget->parent();
     }
 
     // Use the "basket" icon in Kontact so it is consistent with the Kontact "New..." icon
 
     a = ac->addAction("basket_new", this, SLOT(askNewBasket()));
     a->setText(i18n("&New Basket..."));
     a->setIcon(QIcon::fromTheme((runInsideKontact ? "basket" : "document-new")));
     m_actionCollection->setDefaultShortcuts(a, KStandardShortcut::shortcut(KStandardShortcut::New));
     actNewBasket = a;
 
     a = ac->addAction("basket_new_sub", this, SLOT(askNewSubBasket()));
     a->setText(i18n("New &Sub-Basket..."));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Ctrl+Shift+N"));
     actNewSubBasket = a;
 
     a = ac->addAction("basket_new_sibling", this, SLOT(askNewSiblingBasket()));
     a->setText(i18n("New Si&bling Basket..."));
     actNewSiblingBasket = a;
 
     KActionMenu *newBasketMenu = new KActionMenu(i18n("&New"), ac);
     newBasketMenu->setIcon(QIcon::fromTheme("document-new"));
     ac->addAction("basket_new_menu", newBasketMenu);
 
     newBasketMenu->addAction(actNewBasket);
     newBasketMenu->addAction(actNewSubBasket);
     newBasketMenu->addAction(actNewSiblingBasket);
     connect(newBasketMenu, SIGNAL(triggered()), this, SLOT(askNewBasket()));
 
     a = ac->addAction("basket_properties", this, SLOT(propBasket()));
     a->setText(i18n("&Properties..."));
     a->setIcon(QIcon::fromTheme("document-properties"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("F2"));
     m_actPropBasket = a;
 
     a = ac->addAction("basket_sort_children_asc", this, SLOT(sortChildrenAsc()));
     a->setText(i18n("Sort Children Ascending"));
     a->setIcon(QIcon::fromTheme("view-sort-ascending"));
     m_actSortChildrenAsc = a;
 
     a = ac->addAction("basket_sort_children_desc", this, SLOT(sortChildrenDesc()));
     a->setText(i18n("Sort Children Descending"));
     a->setIcon(QIcon::fromTheme("view-sort-descending"));
     m_actSortChildrenDesc = a;
 
     a = ac->addAction("basket_sort_siblings_asc", this, SLOT(sortSiblingsAsc()));
     a->setText(i18n("Sort Siblings Ascending"));
     a->setIcon(QIcon::fromTheme("view-sort-ascending"));
     m_actSortSiblingsAsc = a;
 
     a = ac->addAction("basket_sort_siblings_desc", this, SLOT(sortSiblingsDesc()));
     a->setText(i18n("Sort Siblings Descending"));
     a->setIcon(QIcon::fromTheme("view-sort-descending"));
     m_actSortSiblingsDesc = a;
 
     a = ac->addAction("basket_remove", this, SLOT(delBasket()));
     a->setText(i18nc("Remove Basket", "&Remove"));
     a->setShortcut(0);
     m_actDelBasket = a;
 
 #ifdef HAVE_LIBGPGME
     a = ac->addAction("basket_password", this, SLOT(password()));
     a->setText(i18nc("Password protection", "Pass&word..."));
     a->setShortcut(0);
     m_actPassBasket = a;
 
     a = ac->addAction("basket_lock", this, SLOT(lockBasket()));
     a->setText(i18nc("Lock Basket", "&Lock"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Ctrl+L"));
     m_actLockBasket = a;
 #endif
 
     /** Edit : ****************************************************************/
 
     // m_actUndo     = KStandardAction::undo(  this, SLOT(undo()),                 actionCollection() );
     // m_actUndo->setEnabled(false); // Not yet implemented !
     // m_actRedo     = KStandardAction::redo(  this, SLOT(redo()),                 actionCollection() );
     // m_actRedo->setEnabled(false); // Not yet implemented !
 
     KToggleAction *toggleAct = nullptr;
     toggleAct = new KToggleAction(i18n("&Filter"), ac);
     ac->addAction("edit_filter", toggleAct);
     toggleAct->setIcon(QIcon::fromTheme("view-filter"));
     m_actionCollection->setDefaultShortcuts(toggleAct, KStandardShortcut::shortcut(KStandardShortcut::Find));
     m_actShowFilter = toggleAct;
 
     connect(m_actShowFilter, SIGNAL(toggled(bool)), this, SLOT(showHideFilterBar(bool)));
 
     toggleAct = new KToggleAction(ac);
     ac->addAction("edit_filter_all_baskets", toggleAct);
     toggleAct->setText(i18n("&Search All"));
     toggleAct->setIcon(QIcon::fromTheme("edit-find"));
     m_actionCollection->setDefaultShortcut(toggleAct, QKeySequence("Ctrl+Shift+F"));
     m_actFilterAllBaskets = toggleAct;
 
     connect(m_actFilterAllBaskets, &KToggleAction::toggled, this, &BNPView::toggleFilterAllBaskets);
 
     a = ac->addAction("edit_filter_reset", this, SLOT(slotResetFilter()));
     a->setText(i18n("&Reset Filter"));
     a->setIcon(QIcon::fromTheme("edit-clear-locationbar-rtl"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Ctrl+R"));
     m_actResetFilter = a;
 
     /** Go : ******************************************************************/
 
     a = ac->addAction("go_basket_previous", this, SLOT(goToPreviousBasket()));
     a->setText(i18n("&Previous Basket"));
     a->setIcon(QIcon::fromTheme("go-previous"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Alt+Left"));
     m_actPreviousBasket = a;
 
     a = ac->addAction("go_basket_next", this, SLOT(goToNextBasket()));
     a->setText(i18n("&Next Basket"));
     a->setIcon(QIcon::fromTheme("go-next"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Alt+Right"));
     m_actNextBasket = a;
 
     a = ac->addAction("go_basket_fold", this, SLOT(foldBasket()));
     a->setText(i18n("&Fold Basket"));
     a->setIcon(QIcon::fromTheme("go-up"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Alt+Up"));
     m_actFoldBasket = a;
 
     a = ac->addAction("go_basket_expand", this, SLOT(expandBasket()));
     a->setText(i18n("&Expand Basket"));
     a->setIcon(QIcon::fromTheme("go-down"));
     m_actionCollection->setDefaultShortcut(a, QKeySequence("Alt+Down"));
     m_actExpandBasket = a;
 
 #if 0
     // FOR_BETA_PURPOSE:
     a = ac->addAction("beta_convert_texts", this, SLOT(convertTexts()));
     a->setText(i18n("Convert text notes to rich text notes"));
     a->setIcon(QIcon::fromTheme("run-build-file"));
     m_convertTexts = a;
 #endif
 
     InlineEditors::instance()->initToolBars(actionCollection());
     /** Help : ****************************************************************/
 
     a = ac->addAction("help_welcome_baskets", this, SLOT(addWelcomeBaskets()));
     a->setText(i18n("&Welcome Baskets"));
 }
 
 BasketListViewItem *BNPView::topLevelItem(int i)
 {
     return (BasketListViewItem *)m_tree->topLevelItem(i);
 }
 
 void BNPView::slotShowProperties(QTreeWidgetItem *item)
 {
     if (item)
         propBasket();
 }
 
 void BNPView::slotContextMenu(const QPoint &pos)
 {
     QTreeWidgetItem *item;
     item = m_tree->itemAt(pos);
     QString menuName;
     if (item) {
         BasketScene *basket = ((BasketListViewItem *)item)->basket();
 
         setCurrentBasket(basket);
         menuName = "basket_popup";
     } else {
         menuName = "tab_bar_popup";
         /*
          * "File -> New" create a new basket with the same parent basket as the current one.
          * But when invoked when right-clicking the empty area at the bottom of the basket tree,
          * it is obvious the user want to create a new basket at the bottom of the tree (with no parent).
          * So we set a temporary variable during the time the popup menu is shown,
          * so the slot askNewBasket() will do the right thing:
          */
         setNewBasketPopup();
     }
 
     QMenu *menu = popupMenu(menuName);
     connect(menu, &QMenu::aboutToHide, this, &BNPView::aboutToHideNewBasketPopup);
     menu->exec(m_tree->mapToGlobal(pos));
 }
 
 /* this happens every time we switch the basket (but not if we tell the user we save the stuff
  */
 void BNPView::save()
 {
     DEBUG_WIN << "Basket Tree: Saving...";
 
     QString data;
     QXmlStreamWriter stream(&data);
     XMLWork::setupXmlStream(stream, "basketTree");
 
     // Save Basket Tree:
     save(m_tree, nullptr, stream);
 
     stream.writeEndElement();
     stream.writeEndDocument();
 
     // Write to Disk:
     FileStorage::safelySaveToFile(Global::basketsFolder() + "baskets.xml", data);
 
     GitWrapper::commitBasketView();
 }
 
 void BNPView::save(QTreeWidget *listView, QTreeWidgetItem *item, QXmlStreamWriter &stream)
 {
     if (item == nullptr) {
         if (listView == nullptr) {
             // This should not happen: we call either save(listView, 0) or save(0, item)
             DEBUG_WIN << "BNPView::save error: listView=NULL and item=NULL";
             return;
         }
 
         // For each basket:
         for (int i = 0; i < listView->topLevelItemCount(); i++) {
             item = listView->topLevelItem(i);
             save(nullptr, item, stream);
         }
     } else {
         saveSubHierarchy(item, stream, true);
     }
 }
 
 void BNPView::writeBasketElement(QTreeWidgetItem *item, QXmlStreamWriter &stream)
 {
     BasketScene *basket = ((BasketListViewItem *)item)->basket();
 
     // Save Attributes:
     stream.writeAttribute("folderName", basket->folderName());
     if (item->childCount() >= 0) // If it can be expanded/folded:
         stream.writeAttribute("folded", XMLWork::trueOrFalse(!item->isExpanded()));
 
     if (((BasketListViewItem *)item)->isCurrentBasket())
         stream.writeAttribute("lastOpened", "true");
 
     basket->saveProperties(stream);
 }
 
 void BNPView::saveSubHierarchy(QTreeWidgetItem *item, QXmlStreamWriter &stream, bool recursive)
 {
     stream.writeStartElement("basket");
     writeBasketElement(item, stream); // create root <basket>
     if (recursive) {
         for (int i = 0; i < item->childCount(); i++) {
             saveSubHierarchy(item->child(i), stream, true);
         }
     }
     stream.writeEndElement();
 }
 
 void BNPView::load()
 {
     QScopedPointer<QDomDocument> doc(XMLWork::openFile("basketTree", Global::basketsFolder() + "baskets.xml"));
     // BEGIN Compatibility with 0.6.0 Pre-Alpha versions:
     if (!doc)
         doc.reset(XMLWork::openFile("basketsTree", Global::basketsFolder() + "baskets.xml"));
     // END
     if (doc != nullptr) {
         QDomElement docElem = doc->documentElement();
         load(nullptr, docElem);
     }
     m_loading = false;
 }
 
 void BNPView::load(QTreeWidgetItem *item, const QDomElement &baskets)
 {
     QDomNode n = baskets.firstChild();
     while (!n.isNull()) {
         QDomElement element = n.toElement();
         if ((!element.isNull()) && element.tagName() == "basket") {
             QString folderName = element.attribute("folderName");
             if (!folderName.isEmpty()) {
                 BasketScene *basket = loadBasket(folderName);
                 BasketListViewItem *basketItem = appendBasket(basket, item);
                 basketItem->setExpanded(!XMLWork::trueOrFalse(element.attribute("folded", "false"), false));
                 basket->loadProperties(XMLWork::getElement(element, "properties"));
                 if (XMLWork::trueOrFalse(element.attribute("lastOpened", element.attribute("lastOpened", "false")), false)) // Compat with 0.6.0-Alphas
                     setCurrentBasket(basket);
                 // Load Sub-baskets:
                 load(basketItem, element);
             }
         }
         n = n.nextSibling();
     }
 }
 
 BasketScene *BNPView::loadBasket(const QString &folderName)
 {
     if (folderName.isEmpty())
         return nullptr;
 
     DecoratedBasket *decoBasket = new DecoratedBasket(m_stack, folderName);
     BasketScene *basket = decoBasket->basket();
     m_stack->addWidget(decoBasket);
 
     setUpModel(decoBasket->basket()->model());
 
     connect(basket, &BasketScene::countsChanged, this, &BNPView::countsChanged);
     // Important: Create listViewItem and connect signal BEFORE loadProperties(), so we get the listViewItem updated without extra work:
     connect(basket, &BasketScene::propertiesChanged, this, &BNPView::updateBasketListViewItem);
 
     connect(basket->decoration()->filterBar(), &FilterBar::newFilter, this, &BNPView::newFilterFromFilterBar);
     connect(basket, &BasketScene::crossReference, this, &BNPView::loadCrossReference);
 
     return basket;
 }
 
 int BNPView::basketCount(QTreeWidgetItem *parent)
 {
     int count = 1;
     if (parent == nullptr)
         return 0;
 
     for (int i = 0; i < parent->childCount(); i++) {
         count += basketCount(parent->child(i));
     }
 
     return count;
 }
 
 bool BNPView::canFold()
 {
     BasketListViewItem *item = listViewItemForBasket(currentBasket());
     if (!item)
         return false;
     return (item->childCount() > 0 && item->isExpanded());
 }
 
 bool BNPView::canExpand()
 {
     BasketListViewItem *item = listViewItemForBasket(currentBasket());
     if (!item)
         return false;
     return (item->childCount() > 0 && !item->isExpanded());
 }
 
 BasketListViewItem *BNPView::appendBasket(BasketScene *basket, QTreeWidgetItem *parentItem)
 {
     BasketListViewItem *newBasketItem;
     if (parentItem)
         newBasketItem = new BasketListViewItem(parentItem, parentItem->child(parentItem->childCount() - 1), basket);
     else {
         newBasketItem = new BasketListViewItem(m_tree, m_tree->topLevelItem(m_tree->topLevelItemCount() - 1), basket);
     }
 
     return newBasketItem;
 }
 
 void BNPView::loadNewBasket(const QString &folderName, const QDomElement &properties, BasketScene *parent)
 {
     BasketScene *basket = loadBasket(folderName);
     appendBasket(basket, (basket ? listViewItemForBasket(parent) : nullptr));
     basket->loadProperties(properties);
     setCurrentBasketInHistory(basket);
     //  save();
 }
 
 int BNPView::topLevelItemCount()
 {
     return m_tree->topLevelItemCount();
 }
 
 void BNPView::goToPreviousBasket()
 {
     if (m_history->canUndo())
         m_history->undo();
 }
 
 void BNPView::goToNextBasket()
 {
     if (m_history->canRedo())
         m_history->redo();
 }
 
 void BNPView::foldBasket()
 {
     BasketListViewItem *item = listViewItemForBasket(currentBasket());
     if (item && item->childCount() <= 0)
         item->setExpanded(false); // If Alt+Left is hit and there is nothing to close, make sure the focus will go to the parent basket
 
     QKeyEvent *keyEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_Left, nullptr, nullptr);
     QApplication::postEvent(m_tree, keyEvent);
 }
 
 void BNPView::expandBasket()
 {
     QKeyEvent *keyEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_Right, nullptr, nullptr);
     QApplication::postEvent(m_tree, keyEvent);
 }
 
 void BNPView::closeAllEditors()
 {
     QTreeWidgetItemIterator it(m_tree);
     while (*it) {
         BasketListViewItem *item = (BasketListViewItem *)(*it);
         item->basket()->closeEditor();
         ++it;
     }
 }
 
 bool BNPView::convertTexts()
 {
     bool convertedNotes = false;
     QProgressDialog dialog;
     dialog.setWindowTitle(i18n("Plain Text Notes Conversion"));
     dialog.setLabelText(i18n("Converting plain text notes to rich text ones..."));
     dialog.setModal(true);
     dialog.setRange(0, basketCount());
     dialog.show(); // setMinimumDuration(50/*ms*/);
 
     QTreeWidgetItemIterator it(m_tree);
     while (*it) {
         BasketListViewItem *item = (BasketListViewItem *)(*it);
         if (item->basket()->convertTexts())
             convertedNotes = true;
 
         dialog.setValue(dialog.value() + 1);
 
         if (dialog.wasCanceled())
             break;
         ++it;
     }
 
     return convertedNotes;
 }
 
 void BNPView::toggleFilterAllBaskets(bool doFilter)
 {
     // If the filter isn't already showing, we make sure it does.
     if (doFilter)
         m_actShowFilter->setChecked(true);
 
     // currentBasket()->decoration()->filterBar()->setFilterAll(doFilter);
 
     if (doFilter)
         currentBasket()->decoration()->filterBar()->setEditFocus();
 
     // Filter every baskets:
     newFilter();
 }
 
 /** This function can be called recursively because we call qApp->processEvents().
  * If this function is called whereas another "instance" is running,
  * this new "instance" leave and set up a flag that is read by the first "instance"
  * to know it should re-begin the work.
  * PS: Yes, that's a very lame pseudo-threading but that works, and it's programmer-efforts cheap :-)
  */
 void BNPView::newFilter()
 {
     static bool alreadyEntered = false;
     static bool shouldRestart = false;
 
     if (alreadyEntered) {
         shouldRestart = true;
         return;
     }
     alreadyEntered = true;
     shouldRestart = false;
 
     BasketScene *current = currentBasket();
     const FilterData &filterData = current->decoration()->filterBar()->filterData();
 
     // Set the filter data for every other baskets, or reset the filter for every other baskets if we just disabled the filterInAllBaskets:
     QTreeWidgetItemIterator it(m_tree);
     while (*it) {
         BasketListViewItem *item = ((BasketListViewItem *)*it);
         if (item->basket() != current) {
             if (isFilteringAllBaskets())
                 item->basket()->decoration()->filterBar()->setFilterData(filterData); // Set the new FilterData for every other baskets
             else
                 item->basket()->decoration()->filterBar()->setFilterData(FilterData()); // We just disabled the global filtering: remove the FilterData
         }
         ++it;
     }
 
     // Show/hide the "little filter icons" (during basket load)
     // or the "little numbers" (to show number of found notes in the baskets) is the tree:
     qApp->processEvents();
 
     // Load every baskets for filtering, if they are not already loaded, and if necessary:
     if (filterData.isFiltering) {
         BasketScene *current = currentBasket();
         QTreeWidgetItemIterator it(m_tree);
         while (*it) {
             BasketListViewItem *item = ((BasketListViewItem *)*it);
             if (item->basket() != current) {
                 BasketScene *basket = item->basket();
                 if (!basket->loadingLaunched() && !basket->isLocked())
                     basket->load();
                 basket->filterAgain();
                 qApp->processEvents();
                 if (shouldRestart) {
                     alreadyEntered = false;
                     shouldRestart = false;
                     newFilter();
                     return;
                 }
             }
             ++it;
         }
     }
 
     //  qApp->processEvents();
     m_tree->viewport()->update(); // to see the "little numbers"
 
     alreadyEntered = false;
     shouldRestart = false;
 }
 
 void BNPView::newFilterFromFilterBar()
 {
     if (isFilteringAllBaskets())
         QTimer::singleShot(0, this, SLOT(newFilter())); // Keep time for the QLineEdit to display the filtered character and refresh correctly!
 }
 
 bool BNPView::isFilteringAllBaskets()
 {
     return m_actFilterAllBaskets->isChecked();
 }
 
 BasketListViewItem *BNPView::listViewItemForBasket(BasketScene *basket)
 {
     QTreeWidgetItemIterator it(m_tree);
     while (*it) {
         BasketListViewItem *item = ((BasketListViewItem *)*it);
         if (item->basket() == basket)
             return item;
         ++it;
     }
     return nullptr;
 }
 
 BasketScene *BNPView::currentBasket()
 {
     DecoratedBasket *decoBasket = (DecoratedBasket *)m_stack->currentWidget();
     if (decoBasket)
         return decoBasket->basket();
     else
         return nullptr;
 }
 
 BasketScene *BNPView::parentBasketOf(BasketScene *basket)
 {
     BasketListViewItem *item = (BasketListViewItem *)(listViewItemForBasket(basket)->parent());
     if (item)
         return item->basket();
     else
         return nullptr;
 }
 
 void BNPView::setCurrentBasketInHistory(BasketScene *basket)
 {
     if (!basket)
         return;
 
     if (currentBasket() == basket)
         return;
 
     m_history->push(new HistorySetBasket(basket));
 }
 
 void BNPView::setCurrentBasket(BasketScene *basket)
 {
     if (currentBasket() == basket)
         return;
 
     if (currentBasket())
         currentBasket()->closeBasket();
 
     if (basket)
         basket->aboutToBeActivated();
 
     BasketListViewItem *item = listViewItemForBasket(basket);
     if (item) {
         m_tree->setCurrentItem(item);
         item->ensureVisible();
         m_stack->setCurrentWidget(basket->decoration());
         // If the window has changed size, only the current basket receive the event,
         // the others will receive ony one just before they are shown.
         // But this triggers unwanted animations, so we eliminate it:
         basket->relayoutNotes();
         basket->openBasket();
         setWindowTitle(item->basket()->basketName());
         countsChanged(basket);
         updateStatusBarHint();
         if (Global::systemTray)
             Global::systemTray->updateDisplay();
         m_tree->scrollToItem(m_tree->currentItem());
         item->basket()->setFocus();
     }
     m_tree->viewport()->update();
 
     if (basket) {
         setUpModel(basket->model());
     }
     Q_EMIT basketChanged();
 }
 
 void BNPView::setUpModel(BasketSceneModel* model)
 {
     m_modelView->setModel(model);
     m_modelView->update();
 
+    /*
     connect(m_modelView, &QTreeView::expanded, model, &BasketSceneModel::expandItem);
     connect(m_modelView, &QTreeView::collapsed, model, &BasketSceneModel::collapseItem);
 
     connect(m_modelView->selectionModel(), &QItemSelectionModel::selectionChanged,
             qobject_cast<BasketSceneModel *>(m_modelView->model()), &BasketSceneModel::changeSelection);
+    */
 }
 
 
 void BNPView::removeBasket(BasketScene *basket)
 {
     if (basket->isDuringEdit())
         basket->closeEditor();
 
     // Find a new basket to switch to and select it.
     // Strategy: get the next sibling, or the previous one if not found.
     // If there is no such one, get the parent basket:
     BasketListViewItem *basketItem = listViewItemForBasket(basket);
     BasketListViewItem *nextBasketItem = (BasketListViewItem *)(m_tree->itemBelow(basketItem));
     if (!nextBasketItem)
         nextBasketItem = (BasketListViewItem *)m_tree->itemAbove(basketItem);
     if (!nextBasketItem)
         nextBasketItem = (BasketListViewItem *)(basketItem->parent());
 
     if (nextBasketItem)
         setCurrentBasketInHistory(nextBasketItem->basket());
 
     // Remove from the view:
     basket->unsubscribeBackgroundImages();
     m_stack->removeWidget(basket->decoration());
     //  delete basket->decoration();
     delete basketItem;
     //  delete basket;
 
     // If there is no basket anymore, add a new one:
     if (!nextBasketItem) {
         BasketFactory::newBasket(QString(), i18n("General"));
     } else {    // No need to save two times if we add a basket
         save();
     }
 }
 
 void BNPView::setTreePlacement(bool onLeft)
 {
     if (onLeft)
         insertWidget(0, m_tree);
     else
         addWidget(m_tree);
     // updateGeometry();
     qApp->postEvent(this, new QResizeEvent(size(), size()));
 }
 
 void BNPView::relayoutAllBaskets()
 {
     QTreeWidgetItemIterator it(m_tree);
     while (*it) {
         BasketListViewItem *item = ((BasketListViewItem *)*it);
         // item->basket()->unbufferizeAll();
         item->basket()->unsetNotesWidth();
         item->basket()->relayoutNotes();
         ++it;
     }
 }
 
 void BNPView::recomputeAllStyles()
 {
     QTreeWidgetItemIterator it(m_tree);
     while (*it) {
         BasketListViewItem *item = ((BasketListViewItem *)*it);
         item->basket()->recomputeAllStyles();
         item->basket()->unsetNotesWidth();
         item->basket()->relayoutNotes();
         ++it;
     }
 }
 
 void BNPView::removedStates(const QList<State *> &deletedStates)
 {
     QTreeWidgetItemIterator it(m_tree);
     while (*it) {
         BasketListViewItem *item = ((BasketListViewItem *)*it);
         item->basket()->removedStates(deletedStates);
         ++it;
     }
 }
 
 void BNPView::linkLookChanged()
 {
     QTreeWidgetItemIterator it(m_tree);
     while (*it) {
         BasketListViewItem *item = ((BasketListViewItem *)*it);
         item->basket()->linkLookChanged();
         ++it;
     }
 }
 
 void BNPView::filterPlacementChanged(bool onTop)
 {
     QTreeWidgetItemIterator it(m_tree);
     while (*it) {
         BasketListViewItem *item = static_cast<BasketListViewItem *>(*it);
         DecoratedBasket *decoration = static_cast<DecoratedBasket *>(item->basket()->parent());
         decoration->setFilterBarPosition(onTop);
         ++it;
     }
 }
 
 void BNPView::updateBasketListViewItem(BasketScene *basket)
 {
     BasketListViewItem *item = listViewItemForBasket(basket);
     if (item)
         item->setup();
 
     if (basket == currentBasket()) {
         setWindowTitle(basket->basketName());
         if (Global::systemTray)
             Global::systemTray->updateDisplay();
     }
 
     // Don't save if we are loading!
     if (!m_loading)
         save();
 }
 
 void BNPView::needSave(QTreeWidgetItem *)
 {
     if (!m_loading)
         // A basket has been collapsed/expanded or a new one is select: this is not urgent:
         QTimer::singleShot(500 /*ms*/, this, SLOT(save()));
 }
 
 void BNPView::slotPressed(QTreeWidgetItem *item, int column)
 {
     Q_UNUSED(column);
     BasketScene *basket = currentBasket();
     if (basket == nullptr)
         return;
 
     // Impossible to Select no Basket:
     if (!item)
         m_tree->setCurrentItem(listViewItemForBasket(basket), true);
 
     else if (dynamic_cast<BasketListViewItem *>(item) != nullptr && currentBasket() != ((BasketListViewItem *)item)->basket()) {
         setCurrentBasketInHistory(((BasketListViewItem *)item)->basket());
         needSave(nullptr);
     }
     basket->graphicsView()->viewport()->setFocus();
 }
 
 DecoratedBasket *BNPView::currentDecoratedBasket()
 {
     if (currentBasket())
         return currentBasket()->decoration();
     else
         return nullptr;
 }
 
 // Redirected actions :
 
 void BNPView::exportToHTML()
 {
     HTMLExporter exporter(currentBasket());
 }
 void BNPView::editNote()
 {
     currentBasket()->noteEdit();
 }
 void BNPView::cutNote()
 {
     currentBasket()->noteCut();
 }
 void BNPView::copyNote()
 {
     currentBasket()->noteCopy();
 }
 void BNPView::delNote()
 {
     currentBasket()->noteDelete();
 }
 void BNPView::openNote()
 {
     currentBasket()->noteOpen();
 }
 void BNPView::openNoteWith()
 {
     currentBasket()->noteOpenWith();
 }
 void BNPView::saveNoteAs()
 {
     currentBasket()->noteSaveAs();
 }
 void BNPView::noteGroup()
 {
     currentBasket()->noteGroup();
 }
 void BNPView::noteUngroup()
 {
     currentBasket()->noteUngroup();
 }
 void BNPView::moveOnTop()
 {
     currentBasket()->noteMoveOnTop();
 }
 void BNPView::moveOnBottom()
 {
     currentBasket()->noteMoveOnBottom();
 }
 void BNPView::moveNoteUp()
 {
     currentBasket()->noteMoveNoteUp();
 }
 void BNPView::moveNoteDown()
 {
     currentBasket()->noteMoveNoteDown();
 }
 void BNPView::slotSelectAll()
 {
     currentBasket()->selectAll();
 }
 void BNPView::slotUnselectAll()
 {
     currentBasket()->unselectAll();
 }
 void BNPView::slotInvertSelection()
 {
     currentBasket()->invertSelection();
 }
 void BNPView::slotResetFilter()
 {
     currentDecoratedBasket()->resetFilter();
 }
 
 void BNPView::importTextFile()
 {
     SoftwareImporters::importTextFile();
 }
 
 void BNPView::backupRestore()
 {
     BackupDialog dialog;
     dialog.exec();
 }
 
 void checkNote(Note *note, QList<QString> &fileList)
 {
     while (note) {
         note->finishLazyLoad();
         if (note->isGroup()) {
             checkNote(note->firstChild(), fileList);
         } else if (note->content()->useFile()) {
             QString noteFileName = note->basket()->folderName() + note->content()->fileName();
             int basketFileIndex = fileList.indexOf(noteFileName);
             if (basketFileIndex < 0) {
                 DEBUG_WIN << "<font color='red'>" + noteFileName + " NOT FOUND!</font>";
             } else {
                 fileList.removeAt(basketFileIndex);
             }
         }
         note = note->next();
     }
 }
 
 void checkBasket(BasketListViewItem *item, QList<QString> &dirList, QList<QString> &fileList)
 {
     BasketScene *basket = ((BasketListViewItem *)item)->basket();
     QString basketFolderName = basket->folderName();
     int basketFolderIndex = dirList.indexOf(basket->folderName());
     if (basketFolderIndex < 0) {
         DEBUG_WIN << "<font color='red'>" + basketFolderName + " NOT FOUND!</font>";
     } else {
         dirList.removeAt(basketFolderIndex);
     }
     int basketFileIndex = fileList.indexOf(basket->folderName() + ".basket");
     if (basketFileIndex < 0) {
         DEBUG_WIN << "<font color='red'>.basket file of " + basketFolderName + ".basket NOT FOUND!</font>";
     } else {
         fileList.removeAt(basketFileIndex);
     }
     if (!basket->loadingLaunched() && !basket->isLocked()) {
         basket->load();
     }
     DEBUG_WIN << "\t********************************************************************************";
     DEBUG_WIN << basket->basketName() << "(" << basketFolderName << ") loaded.";
     Note *note = basket->firstNote();
     if (!note) {
         DEBUG_WIN << "\tHas NO notes!";
     } else {
         checkNote(note, fileList);
     }
     basket->save();
     qApp->processEvents(QEventLoop::ExcludeUserInputEvents, 100);
     for (int i = 0; i < item->childCount(); i++) {
         checkBasket((BasketListViewItem *)item->child(i), dirList, fileList);
     }
     if (basket != Global::bnpView->currentBasket()) {
         DEBUG_WIN << basket->basketName() << "(" << basketFolderName << ") unloading...";
         DEBUG_WIN << "\t********************************************************************************";
         basket->unbufferizeAll();
     } else {
         DEBUG_WIN << basket->basketName() << "(" << basketFolderName << ") is the current basket, not unloading.";
         DEBUG_WIN << "\t********************************************************************************";
     }
     qApp->processEvents(QEventLoop::ExcludeUserInputEvents, 100);
 }
 
 void BNPView::checkCleanup()
 {
     DEBUG_WIN << "Starting the check, cleanup and reindexing... (" + Global::basketsFolder() + ')';
     QList<QString> dirList;
     QList<QString> fileList;
     QString topDirEntry;
     QString subDirEntry;
     QFileInfo fileInfo;
     QDir topDir(Global::basketsFolder(), QString(), QDir::Name | QDir::IgnoreCase, QDir::TypeMask | QDir::Hidden);
     Q_FOREACH (topDirEntry, topDir.entryList()) {
         if (topDirEntry != QLatin1String(".") && topDirEntry != QLatin1String("..")) {
             fileInfo.setFile(Global::basketsFolder() + '/' + topDirEntry);
             if (fileInfo.isDir()) {
                 dirList << topDirEntry + '/';
                 QDir basketDir(Global::basketsFolder() + '/' + topDirEntry, QString(), QDir::Name | QDir::IgnoreCase, QDir::TypeMask | QDir::Hidden);
                 Q_FOREACH (subDirEntry, basketDir.entryList()) {
                     if (subDirEntry != "." && subDirEntry != "..") {
                         fileList << topDirEntry + '/' + subDirEntry;
                     }
                 }
             } else if (topDirEntry != "." && topDirEntry != ".." && topDirEntry != "baskets.xml") {
                 fileList << topDirEntry;
             }
         }
     }
     DEBUG_WIN << "Directories found: " + QString::number(dirList.count());
     DEBUG_WIN << "Files found: " + QString::number(fileList.count());
 
     DEBUG_WIN << "Checking Baskets:";
     for (int i = 0; i < topLevelItemCount(); i++) {
         checkBasket(topLevelItem(i), dirList, fileList);
     }
     DEBUG_WIN << "Baskets checked.";
     DEBUG_WIN << "Directories remaining (not in any basket): " + QString::number(dirList.count());
     DEBUG_WIN << "Files remaining (not in any basket): " + QString::number(fileList.count());
 
     Q_FOREACH (topDirEntry, dirList) {
         DEBUG_WIN << "<font color='red'>" + topDirEntry + " does not belong to any basket!</font>";
         // Tools::deleteRecursively(Global::basketsFolder() + '/' + topDirEntry);
         // DEBUG_WIN << "<font color='red'>\t" + topDirEntry + " removed!</font>";
         Tools::trashRecursively(Global::basketsFolder() + "/" + topDirEntry);
         DEBUG_WIN << "<font color='red'>\t" + topDirEntry + " trashed!</font>";
         Q_FOREACH (subDirEntry, fileList) {
             fileInfo.setFile(Global::basketsFolder() + '/' + subDirEntry);
             if (!fileInfo.isFile()) {
                 fileList.removeAll(subDirEntry);
                 DEBUG_WIN << "<font color='red'>\t\t" + subDirEntry + " already removed!</font>";
             }
         }
     }
     Q_FOREACH (subDirEntry, fileList) {
         DEBUG_WIN << "<font color='red'>" + subDirEntry + " does not belong to any note!</font>";
         // Tools::deleteRecursively(Global::basketsFolder() + '/' + subDirEntry);
         // DEBUG_WIN << "<font color='red'>\t" + subDirEntry + " removed!</font>";
         Tools::trashRecursively(Global::basketsFolder() + '/' + subDirEntry);
         DEBUG_WIN << "<font color='red'>\t" + subDirEntry + " trashed!</font>";
     }
     DEBUG_WIN << "Check, cleanup and reindexing completed";
 }
 
 void BNPView::countsChanged(BasketScene *basket)
 {
     if (basket == currentBasket())
         notesStateChanged();
 }
 
 void BNPView::notesStateChanged()
 {
     BasketScene *basket = currentBasket();
 
     // Update statusbar message :
     if (currentBasket()->isLocked())
         setSelectionStatus(i18n("Locked"));
     else if (!basket->isLoaded())
         setSelectionStatus(i18n("Loading..."));
     else if (basket->count() == 0)
         setSelectionStatus(i18n("No notes"));
     else {
         QString count = i18np("%1 note", "%1 notes", basket->count());
         QString selecteds = i18np("%1 selected", "%1 selected", basket->countSelecteds());
         QString showns = (currentDecoratedBasket()->filterData().isFiltering ? i18n("all matches") : i18n("no filter"));
         if (basket->countFounds() != basket->count())
             showns = i18np("%1 match", "%1 matches", basket->countFounds());
         setSelectionStatus(i18nc("e.g. '18 notes, 10 matches, 5 selected'", "%1, %2, %3", count, showns, selecteds));
     }
 
     if (currentBasket()->redirectEditActions()) {
         m_actSelectAll->setEnabled(!currentBasket()->selectedAllTextInEditor());
         m_actUnselectAll->setEnabled(currentBasket()->hasSelectedTextInEditor());
     } else {
         m_actSelectAll->setEnabled(basket->countSelecteds() < basket->countFounds());
         m_actUnselectAll->setEnabled(basket->countSelecteds() > 0);
     }
     m_actInvertSelection->setEnabled(basket->countFounds() > 0);
 
     updateNotesActions();
 }
 
 void BNPView::updateNotesActions()
 {
     bool isLocked = currentBasket()->isLocked();
     bool oneSelected = currentBasket()->countSelecteds() == 1;
     bool oneOrSeveralSelected = currentBasket()->countSelecteds() >= 1;
     bool severalSelected = currentBasket()->countSelecteds() >= 2;
 
     // FIXME: m_actCheckNotes is also modified in void BNPView::areSelectedNotesCheckedChanged(bool checked)
     //        bool BasketScene::areSelectedNotesChecked() should return false if bool BasketScene::showCheckBoxes() is false
     //  m_actCheckNotes->setChecked( oneOrSeveralSelected &&
     //                               currentBasket()->areSelectedNotesChecked() &&
     //                               currentBasket()->showCheckBoxes()             );
 
     Note *selectedGroup = (severalSelected ? currentBasket()->selectedGroup() : nullptr);
 
     m_actEditNote->setEnabled(!isLocked && oneSelected && !currentBasket()->isDuringEdit());
     if (currentBasket()->redirectEditActions()) {
         m_actCutNote->setEnabled(currentBasket()->hasSelectedTextInEditor());
         m_actCopyNote->setEnabled(currentBasket()->hasSelectedTextInEditor());
         m_actPaste->setEnabled(true);
         m_actDelNote->setEnabled(currentBasket()->hasSelectedTextInEditor());
     } else {
         m_actCutNote->setEnabled(!isLocked && oneOrSeveralSelected);
         m_actCopyNote->setEnabled(oneOrSeveralSelected);
         m_actPaste->setEnabled(!isLocked);
         m_actDelNote->setEnabled(!isLocked && oneOrSeveralSelected);
     }
     m_actOpenNote->setEnabled(oneOrSeveralSelected);
     m_actOpenNoteWith->setEnabled(oneSelected); // TODO: oneOrSeveralSelected IF SAME TYPE
     m_actSaveNoteAs->setEnabled(oneSelected);   // IDEM?
     m_actGroup->setEnabled(!isLocked && severalSelected && (!selectedGroup || selectedGroup->isColumn()));
     m_actUngroup->setEnabled(!isLocked && selectedGroup && !selectedGroup->isColumn());
     m_actMoveOnTop->setEnabled(!isLocked && oneOrSeveralSelected && !currentBasket()->isFreeLayout());
     m_actMoveNoteUp->setEnabled(!isLocked && oneOrSeveralSelected); // TODO: Disable when unavailable!
     m_actMoveNoteDown->setEnabled(!isLocked && oneOrSeveralSelected);
     m_actMoveOnBottom->setEnabled(!isLocked && oneOrSeveralSelected && !currentBasket()->isFreeLayout());
 
     for (QList<QAction *>::const_iterator action = m_insertActions.constBegin(); action != m_insertActions.constEnd(); ++action)
         (*action)->setEnabled(!isLocked);
 
     // From the old Note::contextMenuEvent(...) :
     /*  if (useFile() || m_type == Link) {
         m_type == Link ? i18n("&Open target")         : i18n("&Open")
         m_type == Link ? i18n("Open target &with...") : i18n("Open &with...")
         m_type == Link ? i18n("&Save target as...")   : i18n("&Save a copy as...")
             // If useFile() there is always a file to open / open with / save, but :
         if (m_type == Link) {
                 if (url().toDisplayString().isEmpty() && runCommand().isEmpty())     // no URL nor runCommand :
         popupMenu->setItemEnabled(7, false);                       //  no possible Open !
                 if (url().toDisplayString().isEmpty())                               // no URL :
         popupMenu->setItemEnabled(8, false);                       //  no possible Open with !
                 if (url().toDisplayString().isEmpty() || url().path().endsWith("/")) // no URL or target a folder :
         popupMenu->setItemEnabled(9, false);                       //  not possible to save target file
     }
     } else if (m_type != Color) {
         popupMenu->insertSeparator();
         popupMenu->insertItem( QIcon::fromTheme("document-save-as"), i18n("&Save a copy as..."), this, SLOT(slotSaveAs()), 0, 10 );
     }*/
 }
 
 // BEGIN Color picker (code from KColorEdit):
 
 /* Activate the mode
  */
 void BNPView::slotColorFromScreen(bool global)
 {
     m_colorPickWasGlobal = global;
 
     currentBasket()->saveInsertionData();
     m_colorPicker->pickColor();
 }
 
 void BNPView::slotColorFromScreenGlobal()
 {
     slotColorFromScreen(true);
 }
 
 void BNPView::colorPicked(const QColor &color)
 {
     if (!currentBasket()->isLoaded()) {
         showPassiveLoading(currentBasket());
         currentBasket()->load();
     }
     currentBasket()->insertColor(color);
 
     if (Settings::usePassivePopup()) {
         showPassiveDropped(i18n("Picked color to basket <i>%1</i>"));
     }
 }
 
 void BNPView::slotConvertTexts()
 {
     /*
         int result = KMessageBox::questionYesNoCancel(
             this,
             i18n(
                 "<p>This will convert every text notes into rich text notes.<br>"
                 "The content of the notes will not change and you will be able to apply formatting to those notes.</p>"
                 "<p>This process cannot be reverted back: you will not be able to convert the rich text notes to plain text ones later.</p>"
                 "<p>As a beta-tester, you are strongly encouraged to do the convert process because it is to test if plain text notes are still needed.<br>"
                 "If nobody complain about not having plain text notes anymore, then the final version is likely to not support plain text notes anymore.</p>"
                 "<p><b>Which basket notes do you want to convert?</b></p>"
             ),
             i18n("Convert Text Notes"),
             KGuiItem(i18n("Only in the Current Basket")),
             KGuiItem(i18n("In Every Baskets"))
         );
         if (result == KMessageBox::Cancel)
             return;
     */
 
     bool conversionsDone;
     //  if (result == KMessageBox::Yes)
     //      conversionsDone = currentBasket()->convertTexts();
     //  else
     conversionsDone = convertTexts();
 
     if (conversionsDone)
         KMessageBox::information(this, i18n("The plain text notes have been converted to rich text."), i18n("Conversion Finished"));
     else
         KMessageBox::information(this, i18n("There are no plain text notes to convert."), i18n("Conversion Finished"));
 }
 
 QMenu *BNPView::popupMenu(const QString &menuName)
 {
     QMenu *menu = nullptr;
 
     if (m_guiClient) {
         qDebug() << "m_guiClient";
         KXMLGUIFactory *factory = m_guiClient->factory();
         if (factory) {
             menu = (QMenu *)factory->container(menuName, m_guiClient);
         }
     }
     if (menu == nullptr) {
         QString basketDataPath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/basket/";
 
         KMessageBox::error(this,
                            i18n("<p><b>The file basketui.rc seems to not exist or is too old.<br>"
                                 "%1 cannot run without it and will stop.</b></p>"
                                 "<p>Please check your installation of %2.</p>"
                                 "<p>If you do not have administrator access to install the application "
                                 "system wide, you can copy the file basketui.rc from the installation "
                                 "archive to the folder <a href='file://%3'>%4</a>.</p>"
                                 "<p>As last resort, if you are sure the application is correctly installed "
                                 "but you had a preview version of it, try to remove the "
                                 "file %5basketui.rc</p>",
                                 QGuiApplication::applicationDisplayName(),
                                 QGuiApplication::applicationDisplayName(),
                                 basketDataPath,
                                 basketDataPath,
                                 basketDataPath),
                            i18n("Resource not Found"),
                            KMessageBox::AllowLink);
         exit(1); // We SHOULD exit right now and aboard everything because the caller except menu != 0 to not crash.
     }
     return menu;
 }
 
 void BNPView::showHideFilterBar(bool show, bool switchFocus)
 {
     //  if (show != m_actShowFilter->isChecked())
     //      m_actShowFilter->setChecked(show);
     m_actShowFilter->setChecked(show);
 
     currentDecoratedBasket()->setFilterBarVisible(show, switchFocus);
     if (!show)
         currentDecoratedBasket()->resetFilter();
 }
 
 void BNPView::insertEmpty(int type)
 {
     if (currentBasket()->isLocked()) {
         showPassiveImpossible(i18n("Cannot add note."));
         return;
     }
     currentBasket()->insertEmptyNote(type);
 }
 
 void BNPView::insertWizard(int type)
 {
     if (currentBasket()->isLocked()) {
         showPassiveImpossible(i18n("Cannot add note."));
         return;
     }
     currentBasket()->insertWizard(type);
 }
 
 // BEGIN Screen Grabbing:
 void BNPView::grabScreenshot(bool global)
 {
     if (m_regionGrabber) {
         KWindowSystem::activateWindow(m_regionGrabber->winId());
         return;
     }
 
     // Delay before to take a screenshot because if we hide the main window OR the systray popup menu,
     // we should wait the windows below to be repainted!!!
     // A special case is where the action is triggered with the global keyboard shortcut.
     // In this case, global is true, and we don't wait.
     // In the future, if global is also defined for other cases, check for
     // enum QAction::ActivationReason { UnknownActivation, EmulatedActivation, AccelActivation, PopupMenuActivation, ToolBarActivation };
     int delay = (isMainWindowActive() ? 500 : (global /*qApp->activePopupWidget()*/ ? 0 : 200));
 
     m_colorPickWasGlobal = global;
     hideMainWindow();
 
     currentBasket()->saveInsertionData();
     usleep(delay * 1000);
     m_regionGrabber = new RegionGrabber;
     connect(m_regionGrabber, &RegionGrabber::regionGrabbed, this, &BNPView::screenshotGrabbed);
 }
 
 void BNPView::hideMainWindow()
 {
     if (isMainWindowActive()) {
         if (Global::activeMainWindow()) {
             m_HiddenMainWindow = Global::activeMainWindow();
             m_HiddenMainWindow->hide();
         }
         m_colorPickWasShown = true;
     } else
         m_colorPickWasShown = false;
 }
 
 void BNPView::grabScreenshotGlobal()
 {
     grabScreenshot(true);
 }
 
 void BNPView::screenshotGrabbed(const QPixmap &pixmap)
 {
     delete m_regionGrabber;
     m_regionGrabber = nullptr;
 
     // Cancelled (pressed Escape):
     if (pixmap.isNull()) {
         if (m_colorPickWasShown)
             showMainWindow();
         return;
     }
 
     if (!currentBasket()->isLoaded()) {
         showPassiveLoading(currentBasket());
         currentBasket()->load();
     }
     currentBasket()->insertImage(pixmap);
 
     if (m_colorPickWasShown)
         showMainWindow();
 
     if (Settings::usePassivePopup())
         showPassiveDropped(i18n("Grabbed screen zone to basket <i>%1</i>"));
 }
 
 BasketScene *BNPView::basketForFolderName(const QString &folderName)
 {
     /*  QPtrList<Basket> basketsList = listBaskets();
         BasketScene *basket;
         for (basket = basketsList.first(); basket; basket = basketsList.next())
         if (basket->folderName() == folderName)
         return basket;
     */
 
     QString name = folderName;
     if (!name.endsWith('/'))
         name += '/';
 
     QTreeWidgetItemIterator it(m_tree);
     while (*it) {
         BasketListViewItem *item = ((BasketListViewItem *)*it);
         if (item->basket()->folderName() == name)
             return item->basket();
         ++it;
     }
 
     return nullptr;
 }
 
 Note *BNPView::noteForFileName(const QString &fileName, BasketScene &basket, Note *note)
 {
     if (!note)
         note = basket.firstNote();
     if (note->fullPath().endsWith(fileName))
         return note;
     Note *child = note->firstChild();
     Note *found;
     while (child) {
         found = noteForFileName(fileName, basket, child);
         if (found)
             return found;
         child = child->next();
     }
     return nullptr;
 }
 
 void BNPView::setFiltering(bool filtering)
 {
     m_actShowFilter->setChecked(filtering);
     m_actResetFilter->setEnabled(filtering);
     if (!filtering)
         m_actFilterAllBaskets->setEnabled(false);
 }
 
 void BNPView::undo()
 {
     // TODO
 }
 
 void BNPView::redo()
 {
     // TODO
 }
 
 void BNPView::pasteToBasket(int /*index*/, QClipboard::Mode /*mode*/)
 {
     // TODO: REMOVE!
     // basketAt(index)->pasteNote(mode);
 }
 
 void BNPView::propBasket()
 {
     BasketPropertiesDialog dialog(currentBasket(), this);
     dialog.exec();
 }
 
 void BNPView::delBasket()
 {
     //  DecoratedBasket *decoBasket    = currentDecoratedBasket();
     BasketScene *basket = currentBasket();
 
     int really = KMessageBox::questionYesNo(this,
                                             i18n("<qt>Do you really want to remove the basket <b>%1</b> and its contents?</qt>", Tools::textToHTMLWithoutP(basket->basketName())),
                                             i18n("Remove Basket"),
                                             KGuiItem(i18n("&Remove Basket"), "edit-delete"),
                                             KStandardGuiItem::cancel());
 
     if (really == KMessageBox::No)
         return;
 
     QStringList basketsList = listViewItemForBasket(basket)->childNamesTree(0);
     if (basketsList.count() > 0) {
         int deleteChilds = KMessageBox::questionYesNoList(this,
                                                           i18n("<qt><b>%1</b> has the following children baskets.<br>Do you want to remove them too?</qt>", Tools::textToHTMLWithoutP(basket->basketName())),
                                                           basketsList,
                                                           i18n("Remove Children Baskets"),
                                                           KGuiItem(i18n("&Remove Children Baskets"), "edit-delete"));
 
         if (deleteChilds == KMessageBox::No)
             return;
     }
 
     QString basketFolderName = basket->folderName();
     doBasketDeletion(basket);
 
     GitWrapper::commitDeleteBasket(basketFolderName);
 }
 
 void BNPView::doBasketDeletion(BasketScene *basket)
 {
     basket->closeEditor();
 
     QTreeWidgetItem *basketItem = listViewItemForBasket(basket);
     for (int i = 0; i < basketItem->childCount(); i++) {
         // First delete the child baskets:
         doBasketDeletion(((BasketListViewItem *)basketItem->child(i))->basket());
     }
     // Then, basket have no child anymore, delete it:
     DecoratedBasket *decoBasket = basket->decoration();
     basket->deleteFiles();
     removeBasket(basket);
     // Remove the action to avoid keyboard-shortcut clashes:
     delete basket->m_action; // FIXME: It's quick&dirty. In the future, the Basket should be deleted, and then the QAction deleted in the Basket destructor.
     delete decoBasket;
     //  delete basket;
 }
 
 void BNPView::password()
 {
 #ifdef HAVE_LIBGPGME
     QPointer<PasswordDlg> dlg = new PasswordDlg(qApp->activeWindow());
     BasketScene *cur = currentBasket();
 
     dlg->setType(cur->encryptionType());
     dlg->setKey(cur->encryptionKey());
     if (dlg->exec()) {
         cur->setProtection(dlg->type(), dlg->key());
         if (cur->encryptionType() != BasketScene::NoEncryption) {
             // Clear metadata
             Tools::deleteMetadataRecursively(cur->fullPath());
             cur->lock();
         }
     }
 #endif
 }
 
 void BNPView::lockBasket()
 {
 #ifdef HAVE_LIBGPGME
     BasketScene *cur = currentBasket();
 
     cur->lock();
 #endif
 }
 
 void BNPView::saveAsArchive()
 {
     BasketScene *basket = currentBasket();
 
     QDir dir;
 
     KConfigGroup config = KSharedConfig::openConfig()->group("Basket Archive");
     QString folder = config.readEntry("lastFolder", QDir::homePath()) + "/";
     QString url = folder + QString(basket->basketName()).replace('/', '_') + ".baskets";
 
     QString filter = "*.baskets|" + i18n("Basket Archives") + "\n*|" + i18n("All Files");
     QString destination = url;
     for (bool askAgain = true; askAgain;) {
         destination = QFileDialog::getSaveFileName(nullptr, i18n("Save as Basket Archive"), destination, filter);
         if (destination.isEmpty()) // User canceled
             return;
         if (dir.exists(destination)) {
             int result = KMessageBox::questionYesNoCancel(
                 this, "<qt>" + i18n("The file <b>%1</b> already exists. Do you really want to override it?", QUrl::fromLocalFile(destination).fileName()), i18n("Override File?"), KGuiItem(i18n("&Override"), "document-save"));
             if (result == KMessageBox::Cancel)
                 return;
             else if (result == KMessageBox::Yes)
                 askAgain = false;
         } else
             askAgain = false;
     }
     bool withSubBaskets = true; // KMessageBox::questionYesNo(this, i18n("Do you want to export sub-baskets too?"), i18n("Save as Basket Archive")) == KMessageBox::Yes;
 
     config.writeEntry("lastFolder", QUrl::fromLocalFile(destination).adjusted(QUrl::RemoveFilename).path());
     config.sync();
 
     Archive::save(basket, withSubBaskets, destination);
 }
 
 QString BNPView::s_fileToOpen;
 
 void BNPView::delayedOpenArchive()
 {
     Archive::open(s_fileToOpen);
 }
 
 QString BNPView::s_basketToOpen;
 
 void BNPView::delayedOpenBasket()
 {
     BasketScene *bv = this->basketForFolderName(s_basketToOpen);
     this->setCurrentBasketInHistory(bv);
 }
 
 void BNPView::openArchive()
 {
     QString filter = QStringLiteral("*.baskets|") + i18n("Basket Archives") + QStringLiteral("\n*|") + i18n("All Files");
     QString path = QFileDialog::getOpenFileName(this, i18n("Open Basket Archive"), QString(), filter);
     if (!path.isEmpty()) { // User has not canceled
         Archive::open(path);
     }
 }
 
 void BNPView::activatedTagShortcut()
 {
     Tag *tag = Tag::tagForKAction((QAction *)sender());
     currentBasket()->activatedTagShortcut(tag);
 }
 
 void BNPView::slotBasketChanged()
 {
     m_actFoldBasket->setEnabled(canFold());
     m_actExpandBasket->setEnabled(canExpand());
     if (currentBasket()->decoration()->filterData().isFiltering)
         currentBasket()->decoration()->filterBar()->show(); // especially important for Filter all
     setFiltering(currentBasket() && currentBasket()->decoration()->filterData().isFiltering);
     this->canUndoRedoChanged();
 }
 
 void BNPView::canUndoRedoChanged()
 {
     if (m_history) {
         m_actPreviousBasket->setEnabled(m_history->canUndo());
         m_actNextBasket->setEnabled(m_history->canRedo());
     }
 }
 
 void BNPView::currentBasketChanged()
 {
 }
 
 void BNPView::isLockedChanged()
 {
     bool isLocked = currentBasket()->isLocked();
 
     setLockStatus(isLocked);
 
     //  m_actLockBasket->setChecked(isLocked);
     m_actPropBasket->setEnabled(!isLocked);
     m_actDelBasket->setEnabled(!isLocked);
     updateNotesActions();
 }
 
 void BNPView::askNewBasket()
 {
     askNewBasket(nullptr, nullptr);
 
     GitWrapper::commitCreateBasket();
 }
 
 void BNPView::askNewBasket(BasketScene *parent, BasketScene *pickProperties)
 {
     NewBasketDefaultProperties properties;
     if (pickProperties) {
         properties.icon = pickProperties->icon();
         properties.backgroundImage = pickProperties->backgroundImageName();
         properties.backgroundColor = pickProperties->backgroundColorSetting();
         properties.textColor = pickProperties->textColorSetting();
         properties.freeLayout = pickProperties->isFreeLayout();
         properties.columnCount = pickProperties->columnsCount();
     }
 
     NewBasketDialog(parent, properties, this).exec();
 }
 
 void BNPView::askNewSubBasket()
 {
     askNewBasket(/*parent=*/currentBasket(), /*pickPropertiesOf=*/currentBasket());
 }
 
 void BNPView::askNewSiblingBasket()
 {
     askNewBasket(/*parent=*/parentBasketOf(currentBasket()), /*pickPropertiesOf=*/currentBasket());
 }
 
 void BNPView::globalPasteInCurrentBasket()
 {
     currentBasket()->setInsertPopupMenu();
     pasteInCurrentBasket();
     currentBasket()->cancelInsertPopupMenu();
 }
 
 void BNPView::pasteInCurrentBasket()
 {
     currentBasket()->pasteNote();
 
     if (Settings::usePassivePopup())
         showPassiveDropped(i18n("Clipboard content pasted to basket <i>%1</i>"));
 }
 
 void BNPView::pasteSelInCurrentBasket()
 {
     currentBasket()->pasteNote(QClipboard::Selection);
 
     if (Settings::usePassivePopup())
         showPassiveDropped(i18n("Selection pasted to basket <i>%1</i>"));
 }
 
 void BNPView::showPassiveDropped(const QString &title)
 {
     if (!currentBasket()->isLocked()) {
         // TODO: Keep basket, so that we show the message only if something was added to a NOT visible basket
         m_passiveDroppedTitle = title;
         m_passiveDroppedSelection = currentBasket()->selectedNotes();
         QTimer::singleShot(c_delayTooltipTime, this, SLOT(showPassiveDroppedDelayed()));
         // DELAY IT BELOW:
     } else
         showPassiveImpossible(i18n("No note was added."));
 }
 
 void BNPView::showPassiveDroppedDelayed()
 {
     if (isMainWindowActive() || m_passiveDroppedSelection == nullptr)
         return;
 
     QString title = m_passiveDroppedTitle;
 
     QImage contentsImage = NoteDrag::feedbackPixmap(m_passiveDroppedSelection).toImage();
     QResource::registerResource(contentsImage.bits(), QStringLiteral(":/images/passivepopup_image"));
 
     if (Settings::useSystray()) {
         /*Uncomment after switching to QSystemTrayIcon or port to KStatusNotifierItem
          See also other occurrences of Global::systemTray below*/
         /*KPassivePopup::message(KPassivePopup::Boxed,
             title.arg(Tools::textToHTMLWithoutP(currentBasket()->basketName())),
             (contentsImage.isNull() ? QString() : QStringLiteral("<img src=\":/images/passivepopup_image\">")),
             KIconLoader::global()->loadIcon(
                 currentBasket()->icon(), KIconLoader::NoGroup, 16,
                 KIconLoader::DefaultState, QStringList(), 0L, true
             ),
             Global::systemTray);*/
     } else {
         KPassivePopup::message(KPassivePopup::Boxed,
                                title.arg(Tools::textToHTMLWithoutP(currentBasket()->basketName())),
                                (contentsImage.isNull() ? QString() : QStringLiteral("<img src=\":/images/passivepopup_image\">")),
                                KIconLoader::global()->loadIcon(currentBasket()->icon(), KIconLoader::NoGroup, 16, KIconLoader::DefaultState, QStringList(), nullptr, true),
                                (QWidget *)this);
     }
 }
 
 void BNPView::showPassiveImpossible(const QString &message)
 {
     if (Settings::useSystray()) {
         /*KPassivePopup::message(KPassivePopup::Boxed,
                         QString("<font color=red>%1</font>")
                         .arg(i18n("Basket <i>%1</i> is locked"))
                         .arg(Tools::textToHTMLWithoutP(currentBasket()->basketName())),
                         message,
                         KIconLoader::global()->loadIcon(
                             currentBasket()->icon(), KIconLoader::NoGroup, 16,
                             KIconLoader::DefaultState, QStringList(), 0L, true
                         ),
         Global::systemTray);*/
     } else {
         /*KPassivePopup::message(KPassivePopup::Boxed,
                         QString("<font color=red>%1</font>")
                         .arg(i18n("Basket <i>%1</i> is locked"))
                         .arg(Tools::textToHTMLWithoutP(currentBasket()->basketName())),
                         message,
                         KIconLoader::global()->loadIcon(
                             currentBasket()->icon(), KIconLoader::NoGroup, 16,
                             KIconLoader::DefaultState, QStringList(), 0L, true
                         ),
         (QWidget*)this);*/
     }
 }
 
 void BNPView::showPassiveContentForced()
 {
     showPassiveContent(/*forceShow=*/true);
 }
 
 void BNPView::showPassiveContent(bool forceShow /* = false*/)
 {
     if (!forceShow && isMainWindowActive())
         return;
 
     // FIXME: Duplicate code (2 times)
     QString message;
 
     if (Settings::useSystray()) {
         /*KPassivePopup::message(KPassivePopup::Boxed,
             "<qt>" + Tools::makeStandardCaption(
                 currentBasket()->isLocked() ? QString("%1 <font color=gray30>%2</font>")
                 .arg(Tools::textToHTMLWithoutP(currentBasket()->basketName()), i18n("(Locked)"))
                 : Tools::textToHTMLWithoutP(currentBasket()->basketName())
             ),
             message,
             KIconLoader::global()->loadIcon(
                 currentBasket()->icon(), KIconLoader::NoGroup, 16,
                 KIconLoader::DefaultState, QStringList(), 0L, true
             ),
         Global::systemTray);*/
     } else {
         KPassivePopup::message(KPassivePopup::Boxed,
                                "<qt>" +
                                    Tools::makeStandardCaption(currentBasket()->isLocked() ? QString("%1 <font color=gray30>%2</font>").arg(Tools::textToHTMLWithoutP(currentBasket()->basketName()), i18n("(Locked)"))
                                                                                           : Tools::textToHTMLWithoutP(currentBasket()->basketName())),
                                message,
                                KIconLoader::global()->loadIcon(currentBasket()->icon(), KIconLoader::NoGroup, 16, KIconLoader::DefaultState, QStringList(), nullptr, true),
                                (QWidget *)this);
     }
 }
 
 void BNPView::showPassiveLoading(BasketScene *basket)
 {
     if (isMainWindowActive())
         return;
 
     if (Settings::useSystray()) {
         /*KPassivePopup::message(KPassivePopup::Boxed,
             Tools::textToHTMLWithoutP(basket->basketName()),
             i18n("Loading..."),
             KIconLoader::global()->loadIcon(
                 basket->icon(), KIconLoader::NoGroup, 16, KIconLoader::DefaultState,
                 QStringList(), 0L, true
             ),
             Global::systemTray);*/
     } else {
         KPassivePopup::message(KPassivePopup::Boxed,
                                Tools::textToHTMLWithoutP(basket->basketName()),
                                i18n("Loading..."),
                                KIconLoader::global()->loadIcon(basket->icon(), KIconLoader::NoGroup, 16, KIconLoader::DefaultState, QStringList(), nullptr, true),
                                (QWidget *)this);
     }
 }
 
 void BNPView::addNoteText()
 {
     showMainWindow();
     currentBasket()->insertEmptyNote(NoteType::Text);
 }
 void BNPView::addNoteHtml()
 {
     showMainWindow();
     currentBasket()->insertEmptyNote(NoteType::Html);
 }
 void BNPView::addNoteImage()
 {
     showMainWindow();
     currentBasket()->insertEmptyNote(NoteType::Image);
 }
 void BNPView::addNoteLink()
 {
     showMainWindow();
     currentBasket()->insertEmptyNote(NoteType::Link);
 }
 void BNPView::addNoteCrossReference()
 {
     showMainWindow();
     currentBasket()->insertEmptyNote(NoteType::CrossReference);
 }
 void BNPView::addNoteColor()
 {
     showMainWindow();
     currentBasket()->insertEmptyNote(NoteType::Color);
 }
 
 void BNPView::aboutToHideNewBasketPopup()
 {
     QTimer::singleShot(0, this, SLOT(cancelNewBasketPopup()));
 }
 
 void BNPView::cancelNewBasketPopup()
 {
     m_newBasketPopup = false;
 }
 
 void BNPView::setNewBasketPopup()
 {
     m_newBasketPopup = true;
 }
 
 void BNPView::setWindowTitle(QString s)
 {
     Q_EMIT setWindowCaption(s);
 }
 
 void BNPView::updateStatusBarHint()
 {
     m_statusbar->updateStatusBarHint();
 }
 
 void BNPView::setSelectionStatus(QString s)
 {
     m_statusbar->setSelectionStatus(s);
 }
 
 void BNPView::setLockStatus(bool isLocked)
 {
     m_statusbar->setLockStatus(isLocked);
 }
 
 void BNPView::postStatusbarMessage(const QString &msg)
 {
     m_statusbar->postStatusbarMessage(msg);
 }
 
 void BNPView::setStatusBarHint(const QString &hint)
 {
     m_statusbar->setStatusBarHint(hint);
 }
 
 void BNPView::setUnsavedStatus(bool isUnsaved)
 {
     m_statusbar->setUnsavedStatus(isUnsaved);
 }
 
 void BNPView::setActive(bool active)
 {
     KMainWindow *win = Global::activeMainWindow();
     if (!win)
         return;
 
     if (active == isMainWindowActive())
         return;
     // qApp->updateUserTimestamp(); // If "activate on mouse hovering systray", or "on drag through systray"
     Global::systemTray->activate();
 }
 
 void BNPView::hideOnEscape()
 {
     if (Settings::useSystray())
         setActive(false);
 }
 
 bool BNPView::isMainWindowActive()
 {
     KMainWindow *main = Global::activeMainWindow();
     if (main && main->isActiveWindow())
         return true;
     return false;
 }
 
 void BNPView::newBasket()
 {
     askNewBasket();
 }
 
 bool BNPView::createNoteHtml(const QString content, const QString basket)
 {
     BasketScene *b = basketForFolderName(basket);
     if (!b)
         return false;
     Note *note = NoteFactory::createNoteHtml(content, b);
     if (!note)
         return false;
     b->insertCreatedNote(note);
     return true;
 }
 
 bool BNPView::changeNoteHtml(const QString content, const QString basket, const QString noteName)
 {
     BasketScene *b = basketForFolderName(basket);
     if (!b)
         return false;
     Note *note = noteForFileName(noteName, *b);
     if (!note || note->content()->type() != NoteType::Html)
         return false;
     HtmlContent *noteContent = (HtmlContent *)note->content();
     noteContent->setHtml(content);
     note->saveAgain();
     return true;
 }
 
 bool BNPView::createNoteFromFile(const QString url, const QString basket)
 {
     BasketScene *b = basketForFolderName(basket);
     if (!b)
         return false;
     QUrl kurl(url);
     if (url.isEmpty())
         return false;
     Note *n = NoteFactory::copyFileAndLoad(kurl, b);
     if (!n)
         return false;
     b->insertCreatedNote(n);
     return true;
 }
 
 QStringList BNPView::listBaskets()
 {
     QStringList basketList;
 
     QTreeWidgetItemIterator it(m_tree);
     while (*it) {
         BasketListViewItem *item = ((BasketListViewItem *)*it);
         basketList.append(item->basket()->basketName());
         basketList.append(item->basket()->folderName());
         ++it;
     }
     return basketList;
 }
 
 void BNPView::handleCommandLine()
 {
     QCommandLineParser *parser = Global::commandLineOpts;
 
     /* Custom data folder */
     QString customDataFolder = parser->value("data-folder");
     if (!customDataFolder.isNull() && !customDataFolder.isEmpty()) {
         Global::setCustomSavesFolder(customDataFolder);
     }
     /* Debug window */
     if (parser->isSet("debug")) {
         new DebugWindow();
         Global::debugWindow->show();
     }
 }
 
 void BNPView::reloadBasket(const QString &folderName)
 {
     basketForFolderName(folderName)->reload();
 }
 
 /** Scenario of "Hide main window to system tray icon when mouse move out of the window" :
  * - At enterEvent() we stop m_tryHideTimer
  * - After that and before next, we are SURE cursor is hovering window
  * - At leaveEvent() we restart m_tryHideTimer
  * - Every 'x' ms, timeoutTryHide() seek if cursor hover a widget of the application or not
  * - If yes, we musn't hide the window
  * - But if not, we start m_hideTimer to hide main window after a configured elapsed time
  * - timeoutTryHide() continue to be called and if cursor move again to one widget of the app, m_hideTimer is stopped
  * - If after the configured time cursor hasn't go back to a widget of the application, timeoutHide() is called
  * - It then hide the main window to systray icon
  * - When the user will show it, enterEvent() will be called the first time he enter mouse to it
  * - ...
  */
 
 /** Why do as this ? Problems with the use of only enterEvent() and leaveEvent() :
  * - Resize window or hover titlebar isn't possible : leave/enterEvent
  *   are
  *   > Use the grip or Alt+rightDND to resize window
  *   > Use Alt+DND to move window
  * - Each menu trigger the leavEvent
  */
 
 void BNPView::enterEvent(QEvent *)
 {
     if (m_tryHideTimer)
         m_tryHideTimer->stop();
     if (m_hideTimer)
         m_hideTimer->stop();
 }
 
 void BNPView::leaveEvent(QEvent *)
 {
     if (Settings::useSystray() && Settings::hideOnMouseOut() && m_tryHideTimer)
         m_tryHideTimer->start(50);
 }
 
 void BNPView::timeoutTryHide()
 {
     // If a menu is displayed, do nothing for the moment
     if (qApp->activePopupWidget() != nullptr)
         return;
 
     if (qApp->widgetAt(QCursor::pos()) != nullptr)
         m_hideTimer->stop();
     else if (!m_hideTimer->isActive()) { // Start only one time
         m_hideTimer->setSingleShot(true);
         m_hideTimer->start(Settings::timeToHideOnMouseOut() * 100);
     }
 
     // If a subdialog is opened, we mustn't hide the main window:
     if (qApp->activeWindow() != nullptr && qApp->activeWindow() != Global::activeMainWindow())
         m_hideTimer->stop();
 }
 
 void BNPView::timeoutHide()
 {
     // We check that because the setting can have been set to off
     if (Settings::useSystray() && Settings::hideOnMouseOut())
         setActive(false);
     m_tryHideTimer->stop();
 }
 
 void BNPView::changedSelectedNotes()
 {
     //  tabChanged(0); // FIXME: NOT OPTIMIZED
 }
 
 /*void BNPView::areSelectedNotesCheckedChanged(bool checked)
 {
     m_actCheckNotes->setChecked(checked && currentBasket()->showCheckBoxes());
 }*/
 
 void BNPView::enableActions()
 {
     BasketScene *basket = currentBasket();
     if (!basket)
         return;
     if (m_actLockBasket)
         m_actLockBasket->setEnabled(!basket->isLocked() && basket->isEncrypted());
     if (m_actPassBasket)
         m_actPassBasket->setEnabled(!basket->isLocked());
     m_actPropBasket->setEnabled(!basket->isLocked());
     m_actDelBasket->setEnabled(!basket->isLocked());
     m_actExportToHtml->setEnabled(!basket->isLocked());
     m_actShowFilter->setEnabled(!basket->isLocked());
     m_actFilterAllBaskets->setEnabled(!basket->isLocked());
     m_actResetFilter->setEnabled(!basket->isLocked());
     basket->decoration()->filterBar()->setEnabled(!basket->isLocked());
 }
 
 void BNPView::showMainWindow()
 {
     if (m_HiddenMainWindow) {
         m_HiddenMainWindow->show();
         m_HiddenMainWindow = nullptr;
     } else {
         KMainWindow *win = Global::activeMainWindow();
 
         if (win) {
             win->show();
         }
     }
 
     setActive(true);
     Q_EMIT showPart();
 }
 
 void BNPView::populateTagsMenu()
 {
     QMenu *menu = (QMenu *)(popupMenu("tags"));
     if (menu == nullptr || currentBasket() == nullptr) // TODO: Display a messagebox. [menu is 0, surely because on first launch, the XMLGUI does not work!]
         return;
     menu->clear();
 
     Note *referenceNote;
     if (currentBasket()->focusedNote() && currentBasket()->focusedNote()->isSelected())
         referenceNote = currentBasket()->focusedNote();
     else
         referenceNote = currentBasket()->firstSelected();
 
     populateTagsMenu(*menu, referenceNote);
 
     m_lastOpenedTagsMenu = menu;
     //connect(menu, &QMenu::aboutToHide, this, &BNPView::disconnectTagsMenu);
 }
 
 void BNPView::populateTagsMenu(QMenu &menu, Note *referenceNote)
 {
     if (currentBasket() == nullptr)
         return;
 
     currentBasket()->m_tagPopupNote = referenceNote;
     bool enable = currentBasket()->countSelecteds() > 0;
 
     QList<Tag *>::iterator it;
     Tag *currentTag;
     State *currentState;
     int i = 10;
     for (it = Tag::all.begin(); it != Tag::all.end(); ++it) {
         // Current tag and first state of it:
         currentTag = *it;
         currentState = currentTag->states().first();
 
         QKeySequence sequence;
         if (!currentTag->shortcut().isEmpty())
             sequence = currentTag->shortcut();
 
         StateAction *mi = new StateAction(currentState, QKeySequence(sequence), this, true);
 
         // The previously set ID will be set in the actions themselves as data.
         mi->setData(i);
 
         if (referenceNote && referenceNote->hasTag(currentTag))
             mi->setChecked(true);
 
         menu.addAction(mi);
 
         if (!currentTag->shortcut().isEmpty())
             m_actionCollection->setDefaultShortcut(mi, sequence);
 
         mi->setEnabled(enable);
         ++i;
     }
 
     menu.addSeparator();
 
     // I don't like how this is implemented; but I can't think of a better way
     // to do this, so I will have to leave it for now
     QAction *act = new QAction(i18n("&Assign new Tag..."), &menu);
     act->setData(1);
     act->setEnabled(enable);
     menu.addAction(act);
 
     act = new QAction(QIcon::fromTheme("edit-delete"), i18n("&Remove All"), &menu);
     act->setData(2);
     if (!currentBasket()->selectedNotesHaveTags())
         act->setEnabled(false);
     menu.addAction(act);
 
     act = new QAction(QIcon::fromTheme("configure"), i18n("&Customize..."), &menu);
     act->setData(3);
     menu.addAction(act);
 
     connect(&menu, &QMenu::triggered, currentBasket(), &BasketScene::toggledTagInMenu);
     connect(&menu, &QMenu::aboutToHide, currentBasket(), &BasketScene::unlockHovering);
     connect(&menu, &QMenu::aboutToHide, currentBasket(), &BasketScene::disableNextClick);
 }
 
 void BNPView::connectTagsMenu()
 {
     connect(popupMenu("tags"), &QMenu::aboutToShow, this, [this]() { this->populateTagsMenu(); });
     connect(popupMenu("tags"), &QMenu::aboutToHide, this, &BNPView::disconnectTagsMenu);
 }
 
 void BNPView::showEvent(QShowEvent *)
 {
     if (m_firstShow) {
         m_firstShow = false;
         onFirstShow();
     }
 }
 
 void BNPView::disconnectTagsMenu()
 {
     QTimer::singleShot(0, this, SLOT(disconnectTagsMenuDelayed()));
 }
 
 void BNPView::disconnectTagsMenuDelayed()
 {
     disconnect(m_lastOpenedTagsMenu, SIGNAL(triggered(QAction *)), currentBasket(), SLOT(toggledTagInMenu(QAction *)));
     disconnect(m_lastOpenedTagsMenu, SIGNAL(aboutToHide()), currentBasket(), SLOT(unlockHovering()));
     disconnect(m_lastOpenedTagsMenu, SIGNAL(aboutToHide()), currentBasket(), SLOT(disableNextClick()));
 }
 
 void BNPView::loadCrossReference(QString link)
 {
     // remove "basket://" and any encoding.
     QString folderName = link.mid(9, link.length() - 9);
     folderName = QUrl::fromPercentEncoding(folderName.toUtf8());
 
     BasketScene *basket = this->basketForFolderName(folderName);
 
     if (!basket)
         return;
 
     this->setCurrentBasketInHistory(basket);
 }
 
 QString BNPView::folderFromBasketNameLink(QStringList pages, QTreeWidgetItem *parent)
 {
     QString found;
 
     QString page = pages.first();
 
     page = QUrl::fromPercentEncoding(page.toUtf8());
     pages.removeFirst();
 
     if (page == "..") {
         QTreeWidgetItem *p;
         if (parent)
             p = parent->parent();
         else
             p = m_tree->currentItem()->parent();
         found = this->folderFromBasketNameLink(pages, p);
     } else if (!parent && page.isEmpty()) {
         parent = m_tree->invisibleRootItem();
         found = this->folderFromBasketNameLink(pages, parent);
     } else {
         if (!parent && (page == "." || !page.isEmpty())) {
             parent = m_tree->currentItem();
         }
         QRegExp re(":\\{([0-9]+)\\}");
         re.setMinimal(true);
         int pos = 0;
 
         pos = re.indexIn(page, pos);
         int basketNum = 1;
 
         if (pos != -1)
             basketNum = re.cap(1).toInt();
 
         page = page.left(page.length() - re.matchedLength());
 
         for (int i = 0; i < parent->childCount(); i++) {
             QTreeWidgetItem *child = parent->child(i);
 
             if (child->text(0).toLower() == page.toLower()) {
                 basketNum--;
                 if (basketNum == 0) {
                     if (pages.count() > 0) {
                         found = this->folderFromBasketNameLink(pages, child);
                         break;
                     } else {
                         found = ((BasketListViewItem *)child)->basket()->folderName();
                         break;
                     }
                 }
             } else
                 found = QString();
         }
     }
 
     return found;
 }
 
 void BNPView::sortChildrenAsc()
 {
     m_tree->currentItem()->sortChildren(0, Qt::AscendingOrder);
 }
 
 void BNPView::sortChildrenDesc()
 {
     m_tree->currentItem()->sortChildren(0, Qt::DescendingOrder);
 }
 
 void BNPView::sortSiblingsAsc()
 {
     QTreeWidgetItem *parent = m_tree->currentItem()->parent();
     if (!parent)
         m_tree->sortItems(0, Qt::AscendingOrder);
     else
         parent->sortChildren(0, Qt::AscendingOrder);
 }
 
 void BNPView::sortSiblingsDesc()
 {
     QTreeWidgetItem *parent = m_tree->currentItem()->parent();
     if (!parent)
         m_tree->sortItems(0, Qt::DescendingOrder);
     else
         parent->sortChildren(0, Qt::DescendingOrder);
 }
diff --git a/src/note.cpp b/src/note.cpp
index 887a72c..464fe87 100644
--- a/src/note.cpp
+++ b/src/note.cpp
@@ -1,2525 +1,2528 @@
 /**
  * SPDX-FileCopyrightText: (C) 2003 Sébastien Laoût <slaout@linux62.org>
  *
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "note.h"
 
 #include <QApplication>
 #include <QGraphicsItemAnimation>
 #include <QGraphicsView>
 #include <QLocale> //For KGLobal::locale(
 #include <QStyle>
 #include <QStyleOption>
 #include <QtCore/QList>
 #include <QtGui/QImage>
 #include <QtGui/QPainter>
 #include <QtGui/QPixmap>
 
 #include <KIconLoader>
 
 #include <math.h>   // sqrt() and pow() functions
 #include <stdlib.h> // rand() function
 
 #include "basketscene.h"
 #include "common.h"
 #include "debugwindow.h"
 #include "filter.h"
 #include "notefactory.h" // For NoteFactory::filteredURL()
 #include "noteselection.h"
 #include "settings.h"
 #include "tag.h"
 #include "tools.h"
 
 /** class Note: */
 
 #define FOR_EACH_CHILD(childVar) for (Note *childVar = firstChild(); childVar; childVar = childVar->next())
 
 class NotePrivate
 {
 public:
     NotePrivate()
         : prev(nullptr)
         , next(nullptr)
         , width(-1)
         , height(Note::MIN_HEIGHT)
     {
     }
     Note *prev;
     Note *next;
     qreal width;
     qreal height;
 };
 
 qreal Note::NOTE_MARGIN = 2;
 qreal Note::INSERTION_HEIGHT = 5;
 qreal Note::EXPANDER_WIDTH = 9;
 qreal Note::EXPANDER_HEIGHT = 9;
 qreal Note::GROUP_WIDTH = 2 * NOTE_MARGIN + EXPANDER_WIDTH;
 qreal Note::HANDLE_WIDTH = GROUP_WIDTH;
 qreal Note::RESIZER_WIDTH = GROUP_WIDTH;
 qreal Note::TAG_ARROW_WIDTH = 5;
 qreal Note::EMBLEM_SIZE = 16;
 qreal Note::MIN_HEIGHT = 2 * NOTE_MARGIN + EMBLEM_SIZE;
 
 Note::Note(BasketScene *parent)
     : d(new NotePrivate)
     , m_groupWidth(250)
     , m_isFolded(false)
     , m_firstChild(nullptr)
     , m_parentNote(nullptr)
     , m_basket(parent)
     , m_content(nullptr)
     , m_addedDate(QDateTime::currentDateTime())
     , m_lastModificationDate(QDateTime::currentDateTime())
     , m_computedAreas(false)
     , m_onTop(false)
     , m_hovered(false)
     , m_hoveredZone(Note::None)
     , m_focused(false)
     , m_selected(false)
     , m_wasInLastSelectionRect(false)
     , m_computedState()
     , m_emblemsCount(0)
     , m_haveInvisibleTags(false)
     , m_matching(true)
 {
     setHeight(MIN_HEIGHT);
     if (m_basket) {
         m_basket->addItem(this);
     }
 }
 
 Note::~Note()
 {
     if (m_basket) {
         if (m_content && m_content->graphicsItem()) {
             m_basket->removeItem(m_content->graphicsItem());
         }
         m_basket->removeItem(this);
     }
     delete m_content;
     deleteChilds();
 }
 
 void Note::setNext(Note *next)
 {
     d->next = next;
 }
 
 Note *Note::next() const
 {
     return d->next;
 }
 
 void Note::setPrev(Note *prev)
 {
     d->prev = prev;
 }
 
 Note *Note::prev() const
 {
     return d->prev;
 }
 
 qreal Note::bottom() const
 {
     return y() + height() - 1;
 }
 
 void Note::setParentBasket(BasketScene *basket)
 {
     if (m_basket)
         m_basket->removeItem(this);
     m_basket = basket;
     if (m_basket)
         m_basket->addItem(this);
 }
 
 QString Note::addedStringDate()
 {
     return m_addedDate.toString();
 }
 
 QString Note::lastModificationStringDate()
 {
     return m_lastModificationDate.toString();
 }
 
 QString Note::toText(const QString &cuttedFullPath)
 {
     if (content()) {
         // Convert note to text:
         QString text = content()->toText(cuttedFullPath);
         // If we should not export tags with the text, return immediately:
         if (!Settings::exportTextTags())
             return text;
         // Compute the text equivalent of the tag states:
         QString firstLine;
         QString otherLines;
         for (State::List::Iterator it = m_states.begin(); it != m_states.end(); ++it) {
             if (!(*it)->textEquivalent().isEmpty()) {
                 firstLine += (*it)->textEquivalent() + ' ';
                 if ((*it)->onAllTextLines())
                     otherLines += (*it)->textEquivalent() + ' ';
             }
         }
         // Merge the texts:
         if (firstLine.isEmpty())
             return text;
         if (otherLines.isEmpty())
             return firstLine + text;
         QStringList lines = text.split('\n');
         QString result = firstLine + lines[0] + (lines.count() > 1 ? "\n" : QString());
         for (int i = 1 /*Skip the first line*/; i < lines.count(); ++i)
             result += otherLines + lines[i] + (i < lines.count() - 1 ? "\n" : QString());
 
         return result;
     } else
         return QString();
 }
 
 bool Note::computeMatching(const FilterData &data)
 {
     // Groups are always matching:
     if (!content())
         return true;
 
     // If we were editing this note and there is a save operation in the middle, then do not hide it suddenly:
     if (basket()->editedNote() == this)
         return true;
 
     bool matching;
     // First match tags (they are fast to compute):
     switch (data.tagFilterType) {
     default:
     case FilterData::DontCareTagsFilter:
         matching = true;
         break;
     case FilterData::NotTaggedFilter:
         matching = m_states.count() <= 0;
         break;
     case FilterData::TaggedFilter:
         matching = m_states.count() > 0;
         break;
     case FilterData::TagFilter:
         matching = hasTag(data.tag);
         break;
     case FilterData::StateFilter:
         matching = hasState(data.state);
         break;
     }
 
     // Don't try to match the content text if we are not matching now (the filter is of 'AND' type) or if we shouldn't try to match the string:
     if (matching && !data.string.isEmpty())
         matching = content()->match(data);
 
     return matching;
 }
 
 int Note::newFilter(const FilterData &data)
 {
     bool wasMatching = matching();
     m_matching = computeMatching(data);
     setOnTop(wasMatching && matching());
     if (!matching()) {
         setSelected(false);
         hide();
     } else if (!wasMatching) {
         show();
     }
 
     int countMatches = (content() && matching() ? 1 : 0);
 
     FOR_EACH_CHILD(child)
     {
         countMatches += child->newFilter(data);
     }
 
     return countMatches;
 }
 
 void Note::deleteSelectedNotes(bool deleteFilesToo, QSet<Note *> *notesToBeDeleted)
 {
     if (content()) {
         if (isSelected()) {
             basket()->unplugNote(this);
             if (deleteFilesToo && content()->useFile()) {
                 Tools::deleteRecursively(fullPath()); // basket()->deleteFiles(fullPath()); // Also delete the folder if it's a folder
             }
             if (notesToBeDeleted) {
                 notesToBeDeleted->insert(this);
             }
         }
         return;
     }
 
     bool isColumn = this->isColumn();
     Note *child = firstChild();
     Note *next;
     while (child) {
         next = child->next(); // If we delete 'child' on the next line, child->next() will be 0!
         child->deleteSelectedNotes(deleteFilesToo, notesToBeDeleted);
         child = next;
     }
 
     // if it remains at least two notes, the group must not be deleted
     if (!isColumn && !(firstChild() && firstChild()->next())) {
         if (notesToBeDeleted) {
             notesToBeDeleted->insert(this);
         }
     }
 }
 
 int Note::count()
 {
     if (content())
         return 1;
 
     int count = 0;
     FOR_EACH_CHILD(child)
     {
         count += child->count();
     }
     return count;
 }
 
 int Note::countDirectChilds()
 {
     int count = 0;
     FOR_EACH_CHILD(child)
     {
         ++count;
     }
     return count;
 }
 
 QString Note::fullPath()
 {
     if (content())
         return basket()->fullPath() + content()->fileName();
     else
         return QString();
 }
 
 /*void Note::update()
 {
     update(0,0,boundingRect().width,boundingRect().height);
 }*/
 
 void Note::setFocused(bool focused)
 {
     if (m_focused == focused)
         return;
 
     m_focused = focused;
     unbufferize();
     update(); // FIXME: ???
 }
 
 void Note::setSelected(bool selected)
 {
     if (isGroup())
         selected = false; // A group cannot be selected!
 
     if (m_selected == selected)
         return;
 
     if (!selected && basket()->editedNote() == this) {
         // basket()->closeEditor();
         return; // To avoid a bug that would count 2 less selected notes instead of 1 less! Because m_selected is modified only below.
     }
 
     if (selected)
         basket()->addSelectedNote();
     else
         basket()->removeSelectedNote();
 
     m_selected = selected;
     unbufferize();
     update(); // FIXME: ???
 }
 
 void Note::resetWasInLastSelectionRect()
 {
     m_wasInLastSelectionRect = false;
 
     FOR_EACH_CHILD(child)
     {
         child->resetWasInLastSelectionRect();
     }
 }
 
 void Note::finishLazyLoad()
 {
     if (content())
         content()->finishLazyLoad();
 
     FOR_EACH_CHILD(child)
     {
         child->finishLazyLoad();
     }
 }
 
 void Note::selectIn(const QRectF &rect, bool invertSelection, bool unselectOthers /*= true*/)
 {
     //  QRect myRect(x(), y(), width(), height());
 
     //  bool intersects = myRect.intersects(rect);
 
     // Only intersects with visible areas.
     // If the note is not visible, the user don't think it will be selected while selecting the note(s) that hide this, so act like the user think:
     bool intersects = false;
     for (QList<QRectF>::iterator it = m_areas.begin(); it != m_areas.end(); ++it) {
         QRectF &r = *it;
         if (r.intersects(rect)) {
             intersects = true;
             break;
         }
     }
 
     bool toSelect = intersects || (!unselectOthers && isSelected());
     if (invertSelection) {
         toSelect = (m_wasInLastSelectionRect == intersects) ? isSelected() : !isSelected();
     }
 
     setSelected(toSelect);
     m_wasInLastSelectionRect = intersects;
 
     Note *child = firstChild();
     bool first = true;
     while (child) {
         if ((showSubNotes() || first) && child->matching())
             child->selectIn(rect, invertSelection, unselectOthers);
         else
             child->setSelectedRecursively(false);
         child = child->next();
         first = false;
     }
 }
 
 bool Note::allSelected()
 {
     if (isGroup()) {
         Note *child = firstChild();
         bool first = true;
         while (child) {
             if ((showSubNotes() || first) && child->matching())
                 if (!child->allSelected())
                     return false;
             ;
             child = child->next();
             first = false;
         }
         return true;
     } else
         return isSelected();
 }
 
 void Note::setSelectedRecursively(bool selected)
 {
     setSelected(selected && matching());
 
     FOR_EACH_CHILD(child)
     {
         child->setSelectedRecursively(selected);
     }
 }
 
 void Note::invertSelectionRecursively()
 {
     if (content())
         setSelected(!isSelected() && matching());
 
     FOR_EACH_CHILD(child)
     {
         child->invertSelectionRecursively();
     }
 }
 
 void Note::unselectAllBut(Note *toSelect)
 {
     if (this == toSelect)
         setSelectedRecursively(true);
     else {
         setSelected(false);
 
         Note *child = firstChild();
         bool first = true;
         while (child) {
             if ((showSubNotes() || first) && child->matching())
                 child->unselectAllBut(toSelect);
             else
                 child->setSelectedRecursively(false);
             child = child->next();
             first = false;
         }
     }
 }
 
 void Note::invertSelectionOf(Note *toSelect)
 {
     if (this == toSelect)
         setSelectedRecursively(!isSelected());
     else {
         Note *child = firstChild();
         bool first = true;
         while (child) {
             if ((showSubNotes() || first) && child->matching())
                 child->invertSelectionOf(toSelect);
             child = child->next();
             first = false;
         }
     }
 }
 
 Note *Note::theSelectedNote()
 {
     if (!isGroup() && isSelected())
         return this;
 
     Note *selectedOne;
     Note *child = firstChild();
     while (child) {
         selectedOne = child->theSelectedNote();
         if (selectedOne)
             return selectedOne;
         child = child->next();
     }
 
     return nullptr;
 }
 
 NoteSelection *Note::selectedNotes()
 {
     if (content()) {
         if (isSelected())
             return new NoteSelection(this);
         else
             return nullptr;
     }
 
     NoteSelection *selection = new NoteSelection(this);
 
     FOR_EACH_CHILD(child)
     {
         selection->append(child->selectedNotes());
     }
 
     if (selection->firstChild) {
         if (selection->firstChild->next)
             return selection;
         else {
             // If 'selection' is a group with only one content, return directly that content:
             NoteSelection *reducedSelection = selection->firstChild;
             //          delete selection; // TODO: Cut all connections of 'selection' before deleting it!
             for (NoteSelection *node = reducedSelection; node; node = node->next)
                 node->parent = nullptr;
             return reducedSelection;
         }
     } else {
         delete selection;
         return nullptr;
     }
 }
 
 bool Note::isAfter(Note *note)
 {
     if (this == nullptr || note == nullptr)
         return true;
 
     Note *next = this;
     while (next) {
         if (next == note)
             return false;
         next = next->nextInStack();
     }
     return true;
 }
 
 bool Note::containsNote(Note *note)
 {
     //  if (this == note)
     //      return true;
 
     while (note)
         if (note == this)
             return true;
         else
             note = note->parentNote();
 
     //  FOR_EACH_CHILD (child)
     //      if (child->containsNote(note))
     //          return true;
     return false;
 }
 
 Note *Note::firstRealChild()
 {
     Note *child = m_firstChild;
     while (child) {
         if (!child->isGroup() /*&& child->matching()*/)
             return child;
         child = child->firstChild();
     }
     // Empty group:
     return nullptr;
 }
 
 Note *Note::lastRealChild()
 {
     Note *child = lastChild();
     while (child) {
         if (child->content())
             return child;
         Note *possibleChild = child->lastRealChild();
         if (possibleChild && possibleChild->content())
             return possibleChild;
         child = child->prev();
     }
     return nullptr;
 }
 
 Note *Note::lastChild()
 {
     Note *child = m_firstChild;
     while (child && child->next())
         child = child->next();
 
     return child;
 }
 
 Note *Note::lastSibling()
 {
     Note *last = this;
     while (last && last->next())
         last = last->next();
 
     return last;
 }
 
 qreal Note::yExpander()
 {
     Note *child = firstRealChild();
     if (child && !child->isShown())
         child = child->nextShownInStack(); // FIXME: Restrict scope to 'this'
 
     if (child)
         return (child->boundingRect().height() - EXPANDER_HEIGHT) / 2;
     else // Groups always have at least 2 notes, except for columns which can have no child (but should exists anyway):
         return 0;
 }
 
 bool Note::isFree() const
 {
     return parentNote() == nullptr && basket() && basket()->isFreeLayout();
 }
 
 bool Note::isColumn() const
 {
     return parentNote() == nullptr && basket() && basket()->isColumnsLayout();
 }
 
 bool Note::hasResizer() const
 {
     // "isFree" || "isColumn but not the last"
     return parentNote() == nullptr && ((basket() && basket()->isFreeLayout()) || d->next != nullptr);
 }
 
 qreal Note::resizerHeight() const
 {
     return (isColumn() ? basket()->sceneRect().height() : d->height);
 }
 
 void Note::setHoveredZone(Zone zone) // TODO: Remove setHovered(bool) and assume it is hovered if zone != None !!!!!!!
 {
     if (m_hoveredZone != zone) {
         if (content())
             content()->setHoveredZone(m_hoveredZone, zone);
         m_hoveredZone = zone;
         unbufferize();
     }
 }
 
 Note::Zone Note::zoneAt(const QPointF &pos, bool toAdd)
 {
     // Keep the resizer highlighted when resizong, even if the cursor is over another note:
     if (basket()->resizingNote() == this)
         return Resizer;
 
     // When dropping/pasting something on a column resizer, add it at the bottom of the column, and don't group it with the whole column:
     if (toAdd && isColumn() && hasResizer()) {
         qreal right = rightLimit() - x();
         if ((pos.x() >= right) && (pos.x() < right + RESIZER_WIDTH) && (pos.y() >= 0) && (pos.y() < resizerHeight())) // Code copied from below
             return BottomColumn;
     }
 
     // Below a column:
     if (isColumn()) {
         if (pos.y() >= height() && pos.x() < rightLimit() - x())
             return BottomColumn;
     }
 
     // If toAdd, return only TopInsert, TopGroup, BottomInsert or BottomGroup
     // (by spanning those areas in 4 equal rectangles in the note):
     if (toAdd) {
         if (!isFree() && !Settings::groupOnInsertionLine()) {
             if (pos.y() < height() / 2)
                 return TopInsert;
             else
                 return BottomInsert;
         }
         if (isColumn() && pos.y() >= height())
             return BottomGroup;
         if (pos.y() < height() / 2)
             if (pos.x() < width() / 2 && !isFree())
                 return TopInsert;
             else
                 return TopGroup;
         else if (pos.x() < width() / 2 && !isFree())
             return BottomInsert;
         else
             return BottomGroup;
     }
 
     // If in the resizer:
     if (hasResizer()) {
         qreal right = rightLimit() - x();
         if ((pos.x() >= right) && (pos.x() < right + RESIZER_WIDTH) && (pos.y() >= 0) && (pos.y() < resizerHeight()))
             return Resizer;
     }
 
     // If isGroup, return only Group, GroupExpander, TopInsert or BottomInsert:
     if (isGroup()) {
         if (pos.y() < INSERTION_HEIGHT) {
             if (isFree())
                 return TopGroup;
             else
                 return TopInsert;
         }
         if (pos.y() >= height() - INSERTION_HEIGHT) {
             if (isFree())
                 return BottomGroup;
             else
                 return BottomInsert;
         }
         if (pos.x() >= NOTE_MARGIN && pos.x() < NOTE_MARGIN + EXPANDER_WIDTH) {
             qreal yExp = yExpander();
             if (pos.y() >= yExp && pos.y() < yExp + EXPANDER_HEIGHT)
                 return GroupExpander;
         }
         if (pos.x() < width())
             return Group;
         else
             return Note::None;
     }
 
     // Else, it's a normal note:
 
     if (pos.x() < HANDLE_WIDTH)
         return Handle;
 
     if (pos.y() < INSERTION_HEIGHT) {
         if ((!isFree() && !Settings::groupOnInsertionLine()) || (pos.x() < width() / 2 && !isFree()))
             return TopInsert;
         else
             return TopGroup;
     }
 
     if (pos.y() >= height() - INSERTION_HEIGHT) {
         if ((!isFree() && !Settings::groupOnInsertionLine()) || (pos.x() < width() / 2 && !isFree()))
             return BottomInsert;
         else
             return BottomGroup;
     }
 
     for (int i = 0; i < m_emblemsCount; i++) {
         if (pos.x() >= HANDLE_WIDTH + (NOTE_MARGIN + EMBLEM_SIZE) * i && pos.x() < HANDLE_WIDTH + (NOTE_MARGIN + EMBLEM_SIZE) * i + NOTE_MARGIN + EMBLEM_SIZE)
             return (Zone)(Emblem0 + i);
     }
 
     if (pos.x() < HANDLE_WIDTH + (NOTE_MARGIN + EMBLEM_SIZE) * m_emblemsCount + NOTE_MARGIN + TAG_ARROW_WIDTH + NOTE_MARGIN)
         return TagsArrow;
 
     if (!linkAt(pos).isEmpty())
         return Link;
 
     int customZone = content()->zoneAt(pos - QPointF(contentX(), NOTE_MARGIN));
     if (customZone)
         return (Note::Zone)customZone;
 
     return Content;
 }
 
 QString Note::linkAt(const QPointF &pos)
 {
     QString link = m_content->linkAt(pos - QPointF(contentX(), NOTE_MARGIN));
     if (link.isEmpty() || link.startsWith(QLatin1String("basket://")))
         return link;
     else
         return NoteFactory::filteredURL(QUrl::fromUserInput(link)).toDisplayString(); // KURIFilter::self()->filteredURI(link);
 }
 
 qreal Note::contentX() const
 {
     return HANDLE_WIDTH + NOTE_MARGIN + (EMBLEM_SIZE + NOTE_MARGIN) * m_emblemsCount + TAG_ARROW_WIDTH + NOTE_MARGIN;
 }
 
 QRectF Note::zoneRect(Note::Zone zone, const QPointF &pos)
 {
     if (zone >= Emblem0)
         return QRect(HANDLE_WIDTH + (NOTE_MARGIN + EMBLEM_SIZE) * (zone - Emblem0), INSERTION_HEIGHT, NOTE_MARGIN + EMBLEM_SIZE, height() - 2 * INSERTION_HEIGHT);
 
     qreal yExp;
     qreal right;
     qreal xGroup = (isFree() ? (isGroup() ? 0 : GROUP_WIDTH) : width() / 2);
     QRectF rect;
     qreal insertSplit = (Settings::groupOnInsertionLine() ? 2 : 1);
     switch (zone) {
     case Note::Handle:
         return QRectF(0, 0, HANDLE_WIDTH, d->height);
     case Note::Group:
         yExp = yExpander();
         if (pos.y() < yExp) {
             return QRectF(0, INSERTION_HEIGHT, d->width, yExp - INSERTION_HEIGHT);
         }
         if (pos.y() > yExp + EXPANDER_HEIGHT) {
             return QRectF(0, yExp + EXPANDER_HEIGHT, d->width, d->height - yExp - EXPANDER_HEIGHT - INSERTION_HEIGHT);
         }
         if (pos.x() < NOTE_MARGIN) {
             return QRectF(0, 0, NOTE_MARGIN, d->height);
         } else {
             return QRectF(d->width - NOTE_MARGIN, 0, NOTE_MARGIN, d->height);
         }
     case Note::TagsArrow:
         return QRectF(HANDLE_WIDTH + (NOTE_MARGIN + EMBLEM_SIZE) * m_emblemsCount, INSERTION_HEIGHT, NOTE_MARGIN + TAG_ARROW_WIDTH + NOTE_MARGIN, d->height - 2 * INSERTION_HEIGHT);
     case Note::Custom0:
     case Note::Content:
         rect = content()->zoneRect(zone, pos - QPointF(contentX(), NOTE_MARGIN));
         rect.translate(contentX(), NOTE_MARGIN);
         return rect.intersected(QRectF(contentX(), INSERTION_HEIGHT, d->width - contentX(), d->height - 2 * INSERTION_HEIGHT)); // Only IN contentRect
     case Note::GroupExpander:
         return QRectF(NOTE_MARGIN, yExpander(), EXPANDER_WIDTH, EXPANDER_HEIGHT);
     case Note::Resizer:
         right = rightLimit();
         return QRectF(right - x(), 0, RESIZER_WIDTH, resizerHeight());
     case Note::Link:
     case Note::TopInsert:
         if (isGroup())
             return QRectF(0, 0, d->width, INSERTION_HEIGHT);
         else
             return QRectF(HANDLE_WIDTH, 0, d->width / insertSplit - HANDLE_WIDTH, INSERTION_HEIGHT);
     case Note::TopGroup:
         return QRectF(xGroup, 0, d->width - xGroup, INSERTION_HEIGHT);
     case Note::BottomInsert:
         if (isGroup())
             return QRectF(0, d->height - INSERTION_HEIGHT, d->width, INSERTION_HEIGHT);
         else
             return QRectF(HANDLE_WIDTH, d->height - INSERTION_HEIGHT, d->width / insertSplit - HANDLE_WIDTH, INSERTION_HEIGHT);
     case Note::BottomGroup:
         return QRectF(xGroup, d->height - INSERTION_HEIGHT, d->width - xGroup, INSERTION_HEIGHT);
     case Note::BottomColumn:
         return QRectF(0, d->height, rightLimit() - x(), basket()->sceneRect().height() - d->height);
     case Note::None:
         return QRectF(/*0, 0, -1, -1*/);
     default:
         return QRectF(/*0, 0, -1, -1*/);
     }
 }
 
 Qt::CursorShape Note::cursorFromZone(Zone zone) const
 {
     switch (zone) {
     case Note::Handle:
     case Note::Group:
         return Qt::SizeAllCursor;
         break;
     case Note::Resizer:
         if (isColumn()) {
             return Qt::SplitHCursor;
         } else {
             return Qt::SizeHorCursor;
         }
         break;
 
     case Note::Custom0:
         return m_content->cursorFromZone(zone);
         break;
 
     case Note::Link:
     case Note::TagsArrow:
     case Note::GroupExpander:
         return Qt::PointingHandCursor;
         break;
 
     case Note::Content:
         return Qt::IBeamCursor;
         break;
 
     case Note::TopInsert:
     case Note::TopGroup:
     case Note::BottomInsert:
     case Note::BottomGroup:
     case Note::BottomColumn:
         return Qt::CrossCursor;
         break;
     case Note::None:
         return Qt::ArrowCursor;
         break;
     default:
         State *state = stateForEmblemNumber(zone - Emblem0);
         if (state && state->parentTag()->states().count() > 1)
             return Qt::PointingHandCursor;
         else
             return Qt::ArrowCursor;
     }
 }
 
 qreal Note::height() const
 {
     return d->height;
 }
 
 void Note::setHeight(qreal height)
 {
     setInitialHeight(height);
 }
 
 void Note::setInitialHeight(qreal height)
 {
     prepareGeometryChange();
     d->height = height;
 }
 
 void Note::unsetWidth()
 {
     prepareGeometryChange();
 
     d->width = 0;
     unbufferize();
 
     FOR_EACH_CHILD(child)
     child->unsetWidth();
 }
 
 qreal Note::width() const
 {
     return (isGroup() ? (isColumn() ? 0 : GROUP_WIDTH) : d->width);
 }
 
 void Note::requestRelayout()
 {
     prepareGeometryChange();
 
     d->width = 0;
     unbufferize();
     basket()->relayoutNotes(); // TODO: A signal that will relayout ONCE and DELAYED if called several times
 }
 
 void Note::setWidth(qreal width) // TODO: inline ?
 {
     if (d->width != width)
         setWidthForceRelayout(width);
 }
 
 void Note::setWidthForceRelayout(qreal width)
 {
     prepareGeometryChange();
     unbufferize();
     d->width = (width < minWidth() ? minWidth() : width);
     int contentWidth = width - contentX() - NOTE_MARGIN;
     if (m_content) { ///// FIXME: is this OK?
         if (contentWidth < 1)
             contentWidth = 1;
         if (contentWidth < m_content->minWidth())
             contentWidth = m_content->minWidth();
         setHeight(m_content->setWidthAndGetHeight(contentWidth /* < 1 ? 1 : contentWidth*/) + 2 * NOTE_MARGIN);
         if (d->height < 3 * INSERTION_HEIGHT) // Assure a minimal size...
             setHeight(3 * INSERTION_HEIGHT);
     }
 }
 
 qreal Note::minWidth() const
 {
     if (m_content)
         return contentX() + m_content->minWidth() + NOTE_MARGIN;
     else
         return GROUP_WIDTH; ///// FIXME: is this OK?
 }
 
 qreal Note::minRight()
 {
     if (isGroup()) {
         qreal right = x() + width();
         Note *child = firstChild();
         bool first = true;
         while (child) {
             if ((showSubNotes() || first) && child->matching())
                 right = qMax(right, child->minRight());
             child = child->next();
             first = false;
         }
         if (isColumn()) {
             qreal minColumnRight = x() + 2 * HANDLE_WIDTH;
             if (right < minColumnRight)
                 return minColumnRight;
         }
         return right;
     } else
         return x() + minWidth();
 }
 
 bool Note::toggleFolded()
 {
     // Close the editor if it was editing a note that we are about to hide after collapsing:
     if (!m_isFolded && basket() && basket()->isDuringEdit()) {
         if (containsNote(basket()->editedNote()) && firstRealChild() != basket()->editedNote())
             basket()->closeEditor();
     }
 
     // Important to close the editor FIRST, because else, the last edited note would not show during folding animation (don't ask me why ;-) ):
     m_isFolded = !m_isFolded;
 
     unbufferize();
 
     return true;
 }
 
 Note *Note::noteAt(QPointF pos)
 {
     if (matching() && hasResizer()) {
         int right = rightLimit();
         // TODO: This code is duplicated 3 times: !!!!
         if ((pos.x() >= right) && (pos.x() < right + RESIZER_WIDTH) && (pos.y() >= y()) && (pos.y() < y() + resizerHeight())) {
             if (!m_computedAreas)
                 recomputeAreas();
             for (QList<QRectF>::iterator it = m_areas.begin(); it != m_areas.end(); ++it) {
                 QRectF &rect = *it;
                 if (rect.contains(pos.x(), pos.y()))
                     return this;
             }
         }
     }
 
     if (isGroup()) {
         if ((pos.x() >= x()) && (pos.x() < x() + width()) && (pos.y() >= y()) && (pos.y() < y() + d->height)) {
             if (!m_computedAreas)
                 recomputeAreas();
             for (QList<QRectF>::iterator it = m_areas.begin(); it != m_areas.end(); ++it) {
                 QRectF &rect = *it;
                 if (rect.contains(pos.x(), pos.y()))
                     return this;
             }
             return nullptr;
         }
         Note *child = firstChild();
         Note *found;
         bool first = true;
         while (child) {
             if ((showSubNotes() || first) && child->matching()) {
                 found = child->noteAt(pos);
                 if (found)
                     return found;
             }
             child = child->next();
             first = false;
         }
     } else if (matching() && pos.y() >= y() && pos.y() < y() + d->height && pos.x() >= x() && pos.x() < x() + d->width) {
         if (!m_computedAreas)
             recomputeAreas();
         for (QList<QRectF>::iterator it = m_areas.begin(); it != m_areas.end(); ++it) {
             QRectF &rect = *it;
             if (rect.contains(pos.x(), pos.y()))
                 return this;
         }
         return nullptr;
     }
 
     return nullptr;
 }
 
 QRectF Note::boundingRect() const
 {
     if (hasResizer()) {
         return QRectF(0, 0, rightLimit() - x() + RESIZER_WIDTH, resizerHeight());
     }
     return QRectF(0, 0, width(), height());
 }
 
 QRectF Note::resizerRect()
 {
     return QRectF(rightLimit(), y(), RESIZER_WIDTH, resizerHeight());
 }
 
 bool Note::showSubNotes()
 {
     return !m_isFolded || basket()->isFiltering();
 }
 
 void Note::relayoutAt(qreal ax, qreal ay)
 {
     if (!matching())
         return;
 
     m_computedAreas = false;
     m_areas.clear();
 
     // Don't relayout free notes one under the other, because by definition they are freely positioned!
     if (isFree()) {
         ax = x();
         ay = y();
         // If it's a column, it always have the same "fixed" position (no animation):
     } else if (isColumn()) {
         ax = (prev() ? prev()->rightLimit() + RESIZER_WIDTH : 0);
         ay = 0;
         setX(ax);
         setY(ay);
         // But relayout others vertically if they are inside such primary groups or if it is a "normal" basket:
     } else {
         setX(ax);
         setY(ay);
     }
 
     // Then, relayout sub-notes (only the first, if the group is folded) and so, assign an height to the group:
     if (isGroup()) {
         qreal h = 0;
         Note *child = firstChild();
         bool first = true;
         while (child) {
             if (child->matching() && (!m_isFolded || first || basket()->isFiltering())) { // Don't use showSubNotes() but use !m_isFolded because we don't want a relayout for the animated collapsing notes
                 child->relayoutAt(ax + width(), ay + h);
                 h += child->height();
                 if (!child->isVisible())
                     child->show();
             } else {                                   // In case the user collapse a group, then move it and then expand it:
                 child->setXRecursively(x() + width()); //  notes SHOULD have a good X coordinate, and not the old one!
                 if (child->isVisible())
                     child->hideRecursively();
             }
             // For future animation when re-match, but on bottom of already matched notes!
             // Find parent primary note and set the Y to THAT y:
             // if (!child->matching())
             //    child->setY(parentPrimaryNote()->y());
             child = child->next();
             first = false;
         }
         if (height() != h || d->height != h) {
             unbufferize();
             /*if (animate)
                 addAnimation(0, 0, h - height());
             else {*/
             setHeight(h);
             unbufferize();
             //}
         }
     } else {
         // If rightLimit is exceeded, set the top-level right limit!!!
         // and NEED RELAYOUT
         setWidth(finalRightLimit() - x());
     }
 
     // Set the basket area limits (but not for child notes: no need, because they will look for their parent note):
     if (!parentNote()) {
         if (basket()->tmpWidth < finalRightLimit() + (hasResizer() ? RESIZER_WIDTH : 0))
             basket()->tmpWidth = finalRightLimit() + (hasResizer() ? RESIZER_WIDTH : 0);
         if (basket()->tmpHeight < y() + height())
             basket()->tmpHeight = y() + height();
         // However, if the note exceed the allowed size, let it! :
     } else if (!isGroup()) {
         if (basket()->tmpWidth < x() + width() + (hasResizer() ? RESIZER_WIDTH : 0))
             basket()->tmpWidth = x() + width() + (hasResizer() ? RESIZER_WIDTH : 0);
         if (basket()->tmpHeight < y() + height())
             basket()->tmpHeight = y() + height();
     }
 }
 
 void Note::setXRecursively(qreal x)
 {
     setX(x);
 
     FOR_EACH_CHILD(child)
     child->setXRecursively(x + width());
 }
 
 void Note::setYRecursively(qreal y)
 {
     setY(y);
 
     FOR_EACH_CHILD(child)
     child->setYRecursively(y);
 }
 
 void Note::hideRecursively()
 {
     hide();
 
     FOR_EACH_CHILD(child)
     child->hideRecursively();
 }
 void Note::setGroupWidth(qreal width)
 {
     m_groupWidth = width;
 }
 
 qreal Note::groupWidth() const
 {
     if (hasResizer())
         return m_groupWidth;
     else
         return rightLimit() - x();
 }
 
 qreal Note::rightLimit() const
 {
     if (isColumn() && d->next == nullptr) // The last column
         return qMax((x() + minWidth()), (qreal)basket()->graphicsView()->viewport()->width());
     else if (parentNote())
         return parentNote()->rightLimit();
     else
         return x() + m_groupWidth;
 }
 
 qreal Note::finalRightLimit() const
 {
     if (isColumn() && d->next == nullptr) // The last column
         return qMax(x() + minWidth(), (qreal)basket()->graphicsView()->viewport()->width());
     else if (parentNote())
         return parentNote()->finalRightLimit();
     else
         return x() + m_groupWidth;
 }
 
 void Note::drawExpander(QPainter *painter, qreal x, qreal y, const QColor &background, bool expand, BasketScene *basket)
 {
     QStyleOption opt;
     opt.state = (expand ? QStyle::State_On : QStyle::State_Off);
     opt.rect = QRect(x, y, 9, 9);
     opt.palette = basket->palette();
     opt.palette.setColor(QPalette::Base, background);
 
     painter->fillRect(opt.rect, background);
 
     QStyle *style = basket->style();
     if (!expand) {
         style->drawPrimitive(QStyle::PE_IndicatorArrowDown, &opt, painter, basket->graphicsView()->viewport());
     } else {
         style->drawPrimitive(QStyle::PE_IndicatorArrowRight, &opt, painter, basket->graphicsView()->viewport());
     }
 }
 
 QColor expanderBackground(qreal height, qreal y, const QColor &foreground)
 {
     // We will divide height per two, subtract one and use that below a division bar:
     // To avoid division by zero error, height should be bigger than 3.
     // And to avoid y errors or if y is on the borders, we return the border color: the background color.
     if (height <= 3 || y <= 0 || y >= height - 1)
         return foreground;
 
     const QColor dark = foreground.darker(110);   // 1/1.1 of brightness
     const QColor light = foreground.lighter(150); // 50% brighter
 
     qreal h1, h2, s1, s2, v1, v2;
     int ng;
     if (y <= (height - 2) / 2) {
         light.getHsvF(&h1, &s1, &v1);
         dark.getHsvF(&h2, &s2, &v2);
         ng = (height - 2) / 2;
         y -= 1;
     } else {
         dark.getHsvF(&h1, &s1, &v1);
         foreground.getHsvF(&h2, &s2, &v2);
         ng = (height - 2) - (height - 2) / 2;
         y -= 1 + (height - 2) / 2;
     }
 
     return QColor::fromHsvF(h1 + ((h2 - h1) * y) / (ng - 1), s1 + ((s2 - s1) * y) / (ng - 1), v1 + ((v2 - v1) * y) / (ng - 1));
 }
 
 void Note::drawHandle(QPainter *painter, qreal x, qreal y, qreal width, qreal height, const QColor &background, const QColor &foreground, const QColor &lightForeground)
 {
     const QPen backgroundPen(background);
     const QPen foregroundPen(foreground);
 
     // Draw the surrounding rectangle:
     painter->setPen(foregroundPen);
     painter->drawLine(0, 0, width - 1, 0);
     painter->drawLine(0, 0, 0, height - 1);
     painter->drawLine(0, height - 1, width - 1, height - 1);
 
     // Draw the gradients:
     painter->fillRect(1 + x, 1 + y, width - 2, height - 2, lightForeground);
 
     // Round the top corner with background color:
     painter->setPen(backgroundPen);
     painter->drawLine(0, 0, 0, 3);
     painter->drawLine(1, 0, 3, 0);
     painter->drawPoint(1, 1);
     // Round the bottom corner with background color:
     painter->drawLine(0, height - 1, 0, height - 4);
     painter->drawLine(1, height - 1, 3, height - 1);
     painter->drawPoint(1, height - 2);
 
     // Surrounding line of the rounded top-left corner:
     painter->setPen(foregroundPen);
     painter->drawLine(1, 2, 1, 3);
     painter->drawLine(2, 1, 3, 1);
     // Surrounding line of the rounded bottom-left corner:
     painter->drawLine(1, height - 3, 1, height - 4);
     painter->drawLine(2, height - 2, 3, height - 2);
 
     // Anti-aliased rounded top corner (1/2):
     painter->setPen(lightForeground);
     painter->drawPoint(0, 3);
     painter->drawPoint(3, 0);
     painter->drawPoint(2, 2);
     // Anti-aliased rounded bottom corner:
     painter->drawPoint(0, height - 4);
     painter->drawPoint(3, height - 1);
     painter->drawPoint(2, height - 3);
 
     // Draw the grips:
     const qreal middleHeight = (height - 1) / 2;
     const qreal middleWidth = width / 2;
     painter->fillRect(middleWidth - 2, middleHeight, 2, 2, foreground);
     painter->fillRect(middleWidth + 2, middleHeight, 2, 2, foreground);
     painter->fillRect(middleWidth - 2, middleHeight - 4, 2, 2, foreground);
     painter->fillRect(middleWidth + 2, middleHeight - 4, 2, 2, foreground);
     painter->fillRect(middleWidth - 2, middleHeight + 4, 2, 2, foreground);
     painter->fillRect(middleWidth + 2, middleHeight + 4, 2, 2, foreground);
 }
 
 void Note::drawResizer(QPainter *painter, qreal x, qreal y, qreal width, qreal height, const QColor &background, const QColor &foreground, bool rounded)
 {
     const QPen backgroundPen(background);
     const QPen foregroundPen(foreground);
 
     const QColor lightForeground = Tools::mixColor(background, foreground, 2);
 
     // Draw the surrounding rectangle:
     painter->setPen(foregroundPen);
     painter->fillRect(0, 0, width, height, lightForeground);
     painter->drawLine(0, 0, width - 2, 0);
     painter->drawLine(0, height - 1, width - 2, height - 1);
     painter->drawLine(width - 1, 2, width - 1, height - 2);
     if (isColumn()) {
         painter->drawLine(0, 2, 0, height - 2);
     }
 
     if (rounded) {
         // Round the top corner with background color:
         painter->setPen(backgroundPen);
         painter->drawLine(width - 1, 0, width - 3, 0);
         painter->drawLine(width - 1, 1, width - 1, 2);
         painter->drawPoint(width - 2, 1);
         // Round the bottom corner with background color:
         painter->drawLine(width - 1, height - 1, width - 1, height - 4);
         painter->drawLine(width - 2, height - 1, width - 4, height - 1);
         painter->drawPoint(width - 2, height - 2);
         // Surrounding line of the rounded top-left corner:
         painter->setPen(foregroundPen);
         painter->drawLine(width - 2, 2, width - 2, 3);
         painter->drawLine(width - 3, 1, width - 4, 1);
         // Surrounding line of the rounded bottom-left corner:
         painter->drawLine(width - 2, height - 3, width - 2, height - 4);
         painter->drawLine(width - 3, height - 2, width - 4, height - 2);
 
         // Anti-aliased rounded top corner (1/2):
         painter->setPen(Tools::mixColor(foreground, background, 2));
         painter->drawPoint(width - 1, 3);
         painter->drawPoint(width - 4, 0);
         // Anti-aliased rounded bottom corner:
         painter->drawPoint(width - 1, height - 4);
         painter->drawPoint(width - 4, height - 1);
         // Anti-aliased rounded top corner (2/2):
         painter->setPen(foreground);
         painter->drawPoint(width - 3, 2);
         // Anti-aliased rounded bottom corner (2/2):
         painter->drawPoint(width - 3, height - 3);
     }
 
     // Draw the arrows:
     qreal xArrow = 2;
     qreal hMargin = 9;
     int countArrows = (height >= hMargin * 4 + 6 * 3 ? 3 : (height >= hMargin * 3 + 6 * 2 ? 2 : 1));
     for (int i = 0; i < countArrows; ++i) {
         qreal yArrow;
         switch (countArrows) {
         default:
         case 1:
             yArrow = (height - 6) / 2;
             break;
         case 2:
             yArrow = (i == 1 ? hMargin : height - hMargin - 6);
             break;
         case 3:
             yArrow = (i == 1 ? hMargin : (i == 2 ? (height - 6) / 2 : height - hMargin - 6));
             break;
         }
         /// Dark color:
         painter->setPen(foreground);
         // Left arrow:
         painter->drawLine(xArrow, yArrow + 2, xArrow + 2, yArrow);
         painter->drawLine(xArrow, yArrow + 2, xArrow + 2, yArrow + 4);
         // Right arrow:
         painter->drawLine(width - 1 - xArrow, yArrow + 2, width - 1 - xArrow - 2, yArrow);
         painter->drawLine(width - 1 - xArrow, yArrow + 2, width - 1 - xArrow - 2, yArrow + 4);
         /// Light color:
         painter->setPen(background);
         // Left arrow:
         painter->drawLine(xArrow, yArrow + 2 + 1, xArrow + 2, yArrow + 1);
         painter->drawLine(xArrow, yArrow + 2 + 1, xArrow + 2, yArrow + 4 + 1);
         // Right arrow:
         painter->drawLine(width - 1 - xArrow, yArrow + 2 + 1, width - 1 - xArrow - 2, yArrow + 1);
         painter->drawLine(width - 1 - xArrow, yArrow + 2 + 1, width - 1 - xArrow - 2, yArrow + 4 + 1);
     }
 }
 
 void Note::drawInactiveResizer(QPainter *painter, qreal x, qreal y, qreal height, const QColor &background, bool column)
 {
     // If background color is too dark, we compute a lighter color instead of a darker:
     QColor darkBgColor = (Tools::tooDark(background) ? background.lighter(120) : background.darker(105));
     painter->fillRect(x, y, RESIZER_WIDTH, height, Tools::mixColor(background, darkBgColor, 2));
 }
 
 QPalette Note::palette() const
 {
     return (m_basket ? m_basket->palette() : qApp->palette());
 }
 
 /* type: 1: topLeft
  *       2: bottomLeft
  *       3: topRight
  *       4: bottomRight
  *       5: fourCorners
  *       6: noteInsideAndOutsideCorners
  * (x,y) relate to the painter origin
  * (width,height) only used for 5:fourCorners type
  */
 void Note::drawRoundings(QPainter *painter, qreal x, qreal y, int type, qreal width, qreal height)
 {
     qreal right;
 
     switch (type) {
     case 1:
         x += this->x();
         y += this->y();
         basket()->blendBackground(*painter, QRectF(x, y, 4, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x, y + 1, 2, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x, y + 2, 1, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x, y + 3, 1, 1), this->x(), this->y());
         break;
     case 2:
         x += this->x();
         y += this->y();
         basket()->blendBackground(*painter, QRectF(x, y - 1, 1, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x, y, 1, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x, y + 1, 2, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x, y + 2, 4, 1), this->x(), this->y());
         break;
     case 3:
         right = rightLimit();
         x += right;
         y += this->y();
         basket()->blendBackground(*painter, QRectF(x - 1, y, 4, 1), right, this->y());
         basket()->blendBackground(*painter, QRectF(x + 1, y + 1, 2, 1), right, this->y());
         basket()->blendBackground(*painter, QRectF(x + 2, y + 2, 1, 1), right, this->y());
         basket()->blendBackground(*painter, QRectF(x + 2, y + 3, 1, 1), right, this->y());
         break;
     case 4:
         right = rightLimit();
         x += right;
         y += this->y();
         basket()->blendBackground(*painter, QRectF(x + 2, y - 1, 1, 1), right, this->y());
         basket()->blendBackground(*painter, QRectF(x + 2, y, 1, 1), right, this->y());
         basket()->blendBackground(*painter, QRectF(x + 1, y + 1, 2, 1), right, this->y());
         basket()->blendBackground(*painter, QRectF(x - 1, y + 2, 4, 1), right, this->y());
         break;
     case 5:
         // First make sure the corners are white (depending on the widget style):
         painter->setPen(basket()->backgroundColor());
         painter->drawPoint(x, y);
         painter->drawPoint(x + width - 1, y);
         painter->drawPoint(x + width - 1, y + height - 1);
         painter->drawPoint(x, y + height - 1);
         // And then blend corners:
         x += this->x();
         y += this->y();
         basket()->blendBackground(*painter, QRectF(x, y, 1, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x + width - 1, y, 1, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x + width - 1, y + height - 1, 1, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x, y + height - 1, 1, 1), this->x(), this->y());
         break;
     case 6:
         x += this->x();
         y += this->y();
         // if (!isSelected()) {
         // Inside left corners:
         basket()->blendBackground(*painter, QRectF(x + HANDLE_WIDTH + 1, y + 1, 1, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x + HANDLE_WIDTH, y + 2, 1, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x + HANDLE_WIDTH + 1, y + height - 2, 1, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x + HANDLE_WIDTH, y + height - 3, 1, 1), this->x(), this->y());
         // Inside right corners:
         basket()->blendBackground(*painter, QRectF(x + width - 4, y + 1, 1, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x + width - 3, y + 2, 1, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x + width - 4, y + height - 2, 1, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x + width - 3, y + height - 3, 1, 1), this->x(), this->y());
         //}
         // Outside right corners:
         basket()->blendBackground(*painter, QRectF(x + width - 1, y, 1, 1), this->x(), this->y());
         basket()->blendBackground(*painter, QRectF(x + width - 1, y + height - 1, 1, 1), this->x(), this->y());
         break;
     }
 }
 
 /// Blank Spaces Drawing:
 
 void Note::setOnTop(bool onTop)
 {
     setZValue(onTop ? 100 : 0);
     m_onTop = onTop;
 
     Note *note = firstChild();
     while (note) {
         note->setOnTop(onTop);
         note = note->next();
     }
 }
 
 void substractRectOnAreas(const QRectF &rectToSubstract, QList<QRectF> &areas, bool andRemove)
 {
     for (int i = 0; i < areas.size();) {
         QRectF &rect = areas[i];
         // Split the rectangle if it intersects with rectToSubstract:
         if (rect.intersects(rectToSubstract)) {
             // Create the top rectangle:
             if (rectToSubstract.top() > rect.top()) {
                 areas.insert(i++, QRectF(rect.left(), rect.top(), rect.width(), rectToSubstract.top() - rect.top()));
                 rect.setTop(rectToSubstract.top());
             }
             // Create the bottom rectangle:
             if (rectToSubstract.bottom() < rect.bottom()) {
                 areas.insert(i++, QRectF(rect.left(), rectToSubstract.bottom(), rect.width(), rect.bottom() - rectToSubstract.bottom()));
                 rect.setBottom(rectToSubstract.bottom());
             }
             // Create the left rectangle:
             if (rectToSubstract.left() > rect.left()) {
                 areas.insert(i++, QRectF(rect.left(), rect.top(), rectToSubstract.left() - rect.left(), rect.height()));
                 rect.setLeft(rectToSubstract.left());
             }
             // Create the right rectangle:
             if (rectToSubstract.right() < rect.right()) {
                 areas.insert(i++, QRectF(rectToSubstract.right(), rect.top(), rect.right() - rectToSubstract.right(), rect.height()));
                 rect.setRight(rectToSubstract.right());
             }
             // Remove the rectangle if it's entirely contained:
             if (andRemove && rectToSubstract.contains(rect))
                 areas.removeAt(i);
             else
                 ++i;
         } else
             ++i;
     }
 }
 
 void Note::recomputeAreas()
 {
     // Initialize the areas with the note rectangle(s):
     m_areas.clear();
     m_areas.append(visibleRect());
     if (hasResizer())
         m_areas.append(resizerRect());
 
     // Cut the areas where other notes are on top of this note:
     Note *note = basket()->firstNote();
     bool noteIsAfterThis = false;
     while (note) {
         noteIsAfterThis = recomputeAreas(note, noteIsAfterThis);
         note = note->next();
     }
 }
 
 bool Note::recomputeAreas(Note *note, bool noteIsAfterThis)
 {
     if (note == this)
         noteIsAfterThis = true;
     // Only compute overlapping of notes AFTER this, or ON TOP this:
     // else if ( note->matching() && noteIsAfterThis && (!isOnTop() || (isOnTop() && note->isOnTop())) || (!isOnTop() && note->isOnTop()) ) {
     else if (note->matching() && noteIsAfterThis && ((!(isOnTop() || isEditing()) || ((isOnTop() || isEditing()) && (note->isOnTop() || note->isEditing()))) || (!(isOnTop() || isEditing()) && (note->isOnTop() || note->isEditing())))) {
         // if (!(isSelected() && !note->isSelected())) { // FIXME: FIXME: FIXME: FIXME: This last condition was added LATE, so we should look if it's ALWAYS good:
         substractRectOnAreas(note->visibleRect(), m_areas, true);
         if (note->hasResizer())
             substractRectOnAreas(note->resizerRect(), m_areas, true);
         //}
     }
 
     if (note->isGroup()) {
         Note *child = note->firstChild();
         bool first = true;
         while (child) {
             if ((note->showSubNotes() || first) && note->matching())
                 noteIsAfterThis = recomputeAreas(child, noteIsAfterThis);
             child = child->next();
             first = false;
         }
     }
 
     return noteIsAfterThis;
 }
 
 bool Note::isEditing()
 {
     return basket()->editedNote() == this;
 }
 
 /* Drawing policy:
  * ==============
  * - Draw the note on a pixmap and then draw the pixmap on screen is faster and
  *   flicker-free, rather than drawing directly on screen
  * - The next time the pixmap can be directly redrawn on screen without
  *   (relatively low, for small texts) time-consuming text-drawing
  * - To keep memory footprint low, we can destruct the bufferPixmap because
  *   redrawing it offscreen and applying it onscreen is nearly as fast as just
  *   drawing the pixmap onscreen
  * - But as drawing the pixmap offscreen is little time consuming we can keep
  *   last visible notes buffered and then the redraw of the entire window is
  *   INSTANTANEOUS
  * - We keep buffered note/group draws BUT NOT the resizer: such objects are
  *   small and fast to draw, so we don't complexify code for that
  */
 
 void Note::draw(QPainter *painter, const QRectF & /*clipRect*/)
 {
     if (!matching())
         return;
 
     /** Compute visible areas: */
     if (!m_computedAreas)
         recomputeAreas();
     if (m_areas.isEmpty())
         return;
 
     /** Directly draw pixmap on screen if it is already buffered: */
     if (isBufferized()) {
         drawBufferOnScreen(painter, m_bufferedPixmap);
         return;
     }
 
     /** If pixmap is Null (size 0), no point in painting: **/
     if (!width() || !height())
         return;
 
     /** Initialise buffer painter: */
     m_bufferedPixmap = QPixmap(width(), height());
-    Q_ASSERT(!m_bufferedPixmap.isNull());
+    if(m_bufferedPixmap.isNull()) {
+        return;
+    }
+
     QPainter painter2(&m_bufferedPixmap);
 
     /** Initialise colors: */
     QColor baseColor(basket()->backgroundColor());
     QColor highColor(palette().color(QPalette::Highlight));
     QColor midColor = Tools::mixColor(baseColor, highColor, 2);
 
     /** Initialise brushes and pens: */
     QBrush baseBrush(baseColor);
     QBrush highBrush(highColor);
     QPen basePen(baseColor);
     QPen highPen(highColor);
     QPen midPen(midColor);
 
     /** Figure out the state of the note: */
     bool hovered = m_hovered && m_hoveredZone != TopInsert && m_hoveredZone != BottomInsert && m_hoveredZone != Resizer;
 
     /** And then draw the group: */
     if (isGroup()) {
         // Draw background or handle:
         if (hovered) {
             drawHandle(&painter2, 0, 0, width(), height(), baseColor, highColor, midColor);
             drawRoundings(&painter2, 0, 0, /*type=*/1);
             drawRoundings(&painter2, 0, height() - 3, /*type=*/2);
         } else {
             painter2.fillRect(0, 0, width(), height(), baseBrush);
             basket()->blendBackground(painter2, boundingRect().translated(x(), y()), -1, -1, /*opaque=*/true);
         }
 
         // Draw expander:
         qreal yExp = yExpander();
         drawExpander(&painter2, NOTE_MARGIN, yExp, hovered ? midColor : baseColor, m_isFolded, basket());
         // Draw expander rounded edges:
         if (hovered) {
             QColor color1 = expanderBackground(height(), yExp, highColor);
             QColor color2 = expanderBackground(height(), yExp + EXPANDER_HEIGHT - 1, highColor);
             painter2.setPen(color1);
             painter2.drawPoint(NOTE_MARGIN, yExp);
             painter2.drawPoint(NOTE_MARGIN + 9 - 1, yExp);
             painter2.setPen(color2);
             painter2.drawPoint(NOTE_MARGIN, yExp + 9 - 1);
             painter2.drawPoint(NOTE_MARGIN + 9 - 1, yExp + 9 - 1);
         } else
             drawRoundings(&painter2, NOTE_MARGIN, yExp, /*type=*/5, 9, 9);
         // Draw on screen:
         painter2.end();
         drawBufferOnScreen(painter, m_bufferedPixmap);
 
         return;
     }
 
     /** Or draw the note: */
     // What are the background colors:
     QColor background;
     if (m_computedState.backgroundColor().isValid()) {
         background = m_computedState.backgroundColor();
     } else {
         background = basket()->backgroundColor();
     }
 
     if (!hovered && !isSelected()) {
         // Draw background:
         painter2.fillRect(0, 0, width(), height(), background);
         basket()->blendBackground(painter2, boundingRect().translated(x(), y()));
     } else {
         // Draw selection background:
         painter2.fillRect(0, 0, width(), height(), midColor);
         // Top/Bottom lines:
         painter2.setPen(highPen);
         painter2.drawLine(0, height() - 1, width(), height() - 1);
         painter2.drawLine(0, 0, width(), 0);
         // The handle:
         drawHandle(&painter2, 0, 0, HANDLE_WIDTH, height(), baseColor, highColor, midColor);
         drawRoundings(&painter2, 0, 0, /*type=*/1);
         drawRoundings(&painter2, 0, height() - 3, /*type=*/2);
         painter2.setPen(midColor);
         drawRoundings(&painter2, 0, 0, /*type=*/6, width(), height());
     }
 
     // Draw the Emblems:
     qreal yIcon = (height() - EMBLEM_SIZE) / 2;
     qreal xIcon = HANDLE_WIDTH + NOTE_MARGIN;
     for (State::List::Iterator it = m_states.begin(); it != m_states.end(); ++it) {
         if (!(*it)->emblem().isEmpty()) {
             QPixmap stateEmblem = KIconLoader::global()->loadIcon((*it)->emblem(), KIconLoader::NoGroup, 16, KIconLoader::DefaultState, QStringList(), nullptr, false);
 
             painter2.drawPixmap(xIcon, yIcon, stateEmblem);
             xIcon += NOTE_MARGIN + EMBLEM_SIZE;
         }
     }
 
     // Determine the colors (for the richText drawing) and the text color (for the tags arrow too):
     QPalette notePalette(basket()->palette());
     notePalette.setColor(QPalette::Text, (m_computedState.textColor().isValid() ? m_computedState.textColor() : basket()->textColor()));
     notePalette.setColor(QPalette::Background, background);
     if (isSelected())
         notePalette.setColor(QPalette::Text, palette().color(QPalette::HighlightedText));
 
     // Draw the Tags Arrow:
     if (hovered) {
         QColor textColor = notePalette.color(QPalette::Text);
         QColor light = Tools::mixColor(textColor, background);
         QColor mid = Tools::mixColor(textColor, light);
         painter2.setPen(light); // QPen(basket()->colorGroup().darker().lighter(150)));
         painter2.drawLine(xIcon, yIcon + 6, xIcon + 4, yIcon + 6);
         painter2.setPen(mid); // QPen(basket()->colorGroup().darker()));
         painter2.drawLine(xIcon + 1, yIcon + 7, xIcon + 3, yIcon + 7);
         painter2.setPen(textColor); // QPen(basket()->colorGroup().foreground()));
         painter2.drawPoint(xIcon + 2, yIcon + 8);
     } else if (m_haveInvisibleTags) {
         painter2.setPen(notePalette.color(QPalette::Text) /*QPen(basket()->colorGroup().foreground())*/);
         painter2.drawPoint(xIcon, yIcon + 7);
         painter2.drawPoint(xIcon + 2, yIcon + 7);
         painter2.drawPoint(xIcon + 4, yIcon + 7);
     }
 
     // Draw on screen:
     painter2.end();
     drawBufferOnScreen(painter, m_bufferedPixmap);
 }
 
 void Note::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
 {
     if (!m_basket->isLoaded())
         return;
 
     if (boundingRect().width() <= 0.1 || boundingRect().height() <= 0.1)
         return;
 
     draw(painter, boundingRect());
 
     if (hasResizer()) {
         qreal right = rightLimit() - x();
         QRectF resizerRect(0, 0, RESIZER_WIDTH, resizerHeight());
         // Prepare to draw the resizer:
         QPixmap pixmap(RESIZER_WIDTH, resizerHeight());
         QPainter painter2(&pixmap);
         // Draw gradient or resizer:
         if ((m_hovered && m_hoveredZone == Resizer) || ((m_hovered || isSelected()) && !isColumn())) {
             QColor baseColor(basket()->backgroundColor());
             QColor highColor(palette().color(QPalette::Highlight));
             drawResizer(&painter2, 0, 0, RESIZER_WIDTH, resizerHeight(), baseColor, highColor, /*rounded=*/!isColumn());
             if (!isColumn()) {
                 drawRoundings(&painter2, RESIZER_WIDTH - 3, 0, /*type=*/3);
                 drawRoundings(&painter2, RESIZER_WIDTH - 3, resizerHeight() - 3, /*type=*/4);
             }
         } else {
             drawInactiveResizer(&painter2, /*x=*/0, /*y=*/0, /*height=*/resizerHeight(), basket()->backgroundColor(), isColumn());
             resizerRect.translate(rightLimit(), y());
             basket()->blendBackground(painter2, resizerRect);
         }
         // Draw on screen:
         painter2.end();
         painter->drawPixmap(right, 0, pixmap);
     }
 }
 
 void Note::drawBufferOnScreen(QPainter *painter, const QPixmap &contentPixmap)
 {
     for (QList<QRectF>::iterator it = m_areas.begin(); it != m_areas.end(); ++it) {
         QRectF rect = (*it).translated(-x(), -y());
 
         if (rect.x() >= width()) // It's a rect of the resizer, don't draw it!
             continue;
 
         painter->drawPixmap(rect.x(), rect.y(), contentPixmap, rect.x(), rect.y(), rect.width(), rect.height());
     }
 }
 
 void Note::setContent(NoteContent *content)
 {
     m_content = content;
 }
 
 /*const */ State::List &Note::states() const
 {
     return (State::List &)m_states;
 }
 
 void Note::addState(State *state, bool orReplace)
 {
     if (!content())
         return;
 
     Tag *tag = state->parentTag();
     State::List::iterator itStates = m_states.begin();
     // Browse all tags, see if the note has it, increment itSates if yes, and then insert the state at this position...
     // For each existing tags:
     for (Tag::List::iterator it = Tag::all.begin(); it != Tag::all.end(); ++it) {
         // If the current tag isn't the one to assign or the current one on the note, go to the next tag:
         if (*it != tag && itStates != m_states.end() && *it != (*itStates)->parentTag())
             continue;
         // We found the tag to insert:
         if (*it == tag) {
             // And the note already have the tag:
             if (itStates != m_states.end() && *it == (*itStates)->parentTag()) {
                 // We replace the state if wanted:
                 if (orReplace) {
                     itStates = m_states.insert(itStates, state);
                     ++itStates;
                     m_states.erase(itStates);
                     recomputeStyle();
                 }
             } else {
                 m_states.insert(itStates, state);
                 recomputeStyle();
             }
             return;
         }
         // The note has this tag:
         if (itStates != m_states.end() && *it == (*itStates)->parentTag())
             ++itStates;
     }
 }
 
 QFont Note::font()
 {
     return m_computedState.font(basket()->QGraphicsScene::font());
 }
 
 QColor Note::backgroundColor()
 {
     if (m_computedState.backgroundColor().isValid())
         return m_computedState.backgroundColor();
     else
         return basket()->backgroundColor();
 }
 
 QColor Note::textColor()
 {
     if (m_computedState.textColor().isValid())
         return m_computedState.textColor();
     else
         return basket()->textColor();
 }
 
 void Note::recomputeStyle()
 {
     State::merge(m_states, &m_computedState, &m_emblemsCount, &m_haveInvisibleTags, basket()->backgroundColor());
     //  unsetWidth();
     if (content()) {
         if (content()->graphicsItem())
             content()->graphicsItem()->setPos(contentX(), NOTE_MARGIN);
         content()->fontChanged();
     }
     //  requestRelayout(); // TODO!
 }
 
 void Note::recomputeAllStyles()
 {
     if (content()) // We do the merge ourself, without calling recomputeStyle(), so there is no infinite recursion:
         // State::merge(m_states, &m_computedState, &m_emblemsCount, &m_haveInvisibleTags, basket()->backgroundColor());
         recomputeStyle();
     else if (isGroup())
         FOR_EACH_CHILD(child)
     child->recomputeAllStyles();
 }
 
 bool Note::removedStates(const QList<State *> &deletedStates)
 {
     bool modifiedBasket = false;
 
     if (!states().isEmpty()) {
         for (QList<State *>::const_iterator it = deletedStates.begin(); it != deletedStates.end(); ++it)
             if (hasState(*it)) {
                 removeState(*it);
                 modifiedBasket = true;
             }
     }
 
     FOR_EACH_CHILD(child)
     if (child->removedStates(deletedStates))
         modifiedBasket = true;
 
     return modifiedBasket;
 }
 
 void Note::addTag(Tag *tag)
 {
     addState(tag->states().first(), /*but do not replace:*/ false);
 }
 
 void Note::removeState(State *state)
 {
     for (State::List::iterator it = m_states.begin(); it != m_states.end(); ++it)
         if (*it == state) {
             m_states.erase(it);
             recomputeStyle();
             return;
         }
 }
 
 void Note::removeTag(Tag *tag)
 {
     for (State::List::iterator it = m_states.begin(); it != m_states.end(); ++it)
         if ((*it)->parentTag() == tag) {
             m_states.erase(it);
             recomputeStyle();
             return;
         }
 }
 
 void Note::removeAllTags()
 {
     m_states.clear();
     recomputeStyle();
 }
 
 void Note::addTagToSelectedNotes(Tag *tag)
 {
     if (content() && isSelected())
         addTag(tag);
 
     FOR_EACH_CHILD(child)
     child->addTagToSelectedNotes(tag);
 }
 
 void Note::removeTagFromSelectedNotes(Tag *tag)
 {
     if (content() && isSelected()) {
         if (hasTag(tag))
             setWidth(0);
         removeTag(tag);
     }
 
     FOR_EACH_CHILD(child)
     child->removeTagFromSelectedNotes(tag);
 }
 
 void Note::removeAllTagsFromSelectedNotes()
 {
     if (content() && isSelected()) {
         if (m_states.count() > 0)
             setWidth(0);
         removeAllTags();
     }
 
     FOR_EACH_CHILD(child)
     child->removeAllTagsFromSelectedNotes();
 }
 
 void Note::addStateToSelectedNotes(State *state, bool orReplace)
 {
     if (content() && isSelected())
         addState(state, orReplace);
 
     FOR_EACH_CHILD(child)
     child->addStateToSelectedNotes(state, orReplace); // TODO: BasketScene::addStateToSelectedNotes() does not have orReplace
 }
 
 void Note::changeStateOfSelectedNotes(State *state)
 {
     if (content() && isSelected() && hasTag(state->parentTag()))
         addState(state);
 
     FOR_EACH_CHILD(child)
     child->changeStateOfSelectedNotes(state);
 }
 
 bool Note::selectedNotesHaveTags()
 {
     if (content() && isSelected() && m_states.count() > 0)
         return true;
 
     FOR_EACH_CHILD(child)
     if (child->selectedNotesHaveTags())
         return true;
     return false;
 }
 
 bool Note::hasState(State *state)
 {
     for (State::List::iterator it = m_states.begin(); it != m_states.end(); ++it)
         if (*it == state)
             return true;
     return false;
 }
 
 bool Note::hasTag(Tag *tag)
 {
     for (State::List::iterator it = m_states.begin(); it != m_states.end(); ++it)
         if ((*it)->parentTag() == tag)
             return true;
     return false;
 }
 
 State *Note::stateOfTag(Tag *tag)
 {
     for (State::List::iterator it = m_states.begin(); it != m_states.end(); ++it)
         if ((*it)->parentTag() == tag)
             return *it;
     return nullptr;
 }
 
 bool Note::allowCrossReferences()
 {
     for (State::List::iterator it = m_states.begin(); it != m_states.end(); ++it)
         if (!(*it)->allowCrossReferences())
             return false;
     return true;
 }
 
 State *Note::stateForEmblemNumber(int number) const
 {
     int i = -1;
     for (State::List::const_iterator it = m_states.begin(); it != m_states.end(); ++it)
         if (!(*it)->emblem().isEmpty()) {
             ++i;
             if (i == number)
                 return *it;
         }
     return nullptr;
 }
 
 bool Note::stateForTagFromSelectedNotes(Tag *tag, State **state)
 {
     if (content() && isSelected()) {
         // What state is the tag on this note?
         State *stateOfTag = this->stateOfTag(tag);
         // This tag is not assigned to this note, the action will assign it, then:
         if (stateOfTag == nullptr)
             *state = nullptr;
         else {
             // Take the LOWEST state of all the selected notes:
             // Say the two selected notes have the state "Done" and "To Do".
             // The first note set *state to "Done".
             // When reaching the second note, we should recognize "To Do" is first in the tag states, then take it
             // Because pressing the tag shortcut key should first change state before removing the tag!
             if (*state == nullptr)
                 *state = stateOfTag;
             else {
                 bool stateIsFirst = true;
                 for (State *nextState = stateOfTag->nextState(); nextState; nextState = nextState->nextState(/*cycle=*/false))
                     if (nextState == *state)
                         stateIsFirst = false;
                 if (!stateIsFirst)
                     *state = stateOfTag;
             }
         }
         return true; // We encountered a selected note
     }
 
     bool encounteredSelectedNote = false;
     FOR_EACH_CHILD(child)
     {
         bool encountered = child->stateForTagFromSelectedNotes(tag, state);
         if (encountered && *state == nullptr)
             return true;
         if (encountered)
             encounteredSelectedNote = true;
     }
     return encounteredSelectedNote;
 }
 
 void Note::inheritTagsOf(Note *note)
 {
     if (!note || !content())
         return;
 
     for (State::List::iterator it = note->states().begin(); it != note->states().end(); ++it)
         if ((*it)->parentTag() && (*it)->parentTag()->inheritedBySiblings())
             addTag((*it)->parentTag());
 }
 
 void Note::unbufferizeAll()
 {
     unbufferize();
 
     if (isGroup()) {
         Note *child = firstChild();
         while (child) {
             child->unbufferizeAll();
             child = child->next();
         }
     }
 }
 
 QRectF Note::visibleRect()
 {
     QList<QRectF> areas;
     areas.append(QRectF(x(), y(), width(), height()));
 
     // When we are folding a parent group, if this note is bigger than the first real note of the group, cut the top of this:
     /*Note *parent = parentNote();
     while (parent) {
         if (parent->expandingOrCollapsing())
             substractRectOnAreas(QRect(x(), parent->y() - height(), width(), height()), areas, true);
         parent = parent->parentNote();
     }*/
 
     if (areas.count() > 0)
         return areas.first();
     else
         return QRectF();
 }
 
 void Note::recomputeBlankRects(QList<QRectF> &blankAreas)
 {
     if (!matching())
         return;
 
     // visibleRect() instead of rect() because if we are folding/expanding a smaller parent group, then some part is hidden!
     // But anyway, a resizer is always a primary note and is never hidden by a parent group, so no visibleResizerRect() method!
     substractRectOnAreas(visibleRect(), blankAreas, true);
     if (hasResizer())
         substractRectOnAreas(resizerRect(), blankAreas, true);
 
     if (isGroup()) {
         Note *child = firstChild();
         bool first = true;
         while (child) {
             if ((showSubNotes() || first) && child->matching())
                 child->recomputeBlankRects(blankAreas);
             child = child->next();
             first = false;
         }
     }
 }
 
 void Note::linkLookChanged()
 {
     if (isGroup()) {
         Note *child = firstChild();
         while (child) {
             child->linkLookChanged();
             child = child->next();
         }
     } else
         content()->linkLookChanged();
 }
 
 Note *Note::noteForFullPath(const QString &path)
 {
     if (content() && fullPath() == path)
         return this;
 
     Note *child = firstChild();
     Note *found;
     while (child) {
         found = child->noteForFullPath(path);
         if (found)
             return found;
         child = child->next();
     }
     return nullptr;
 }
 
 void Note::listUsedTags(QList<Tag *> &list)
 {
     for (State::List::Iterator it = m_states.begin(); it != m_states.end(); ++it) {
         Tag *tag = (*it)->parentTag();
         if (!list.contains(tag))
             list.append(tag);
     }
 
     FOR_EACH_CHILD(child)
     child->listUsedTags(list);
 }
 
 void Note::usedStates(QList<State *> &states)
 {
     if (content())
         for (State::List::Iterator it = m_states.begin(); it != m_states.end(); ++it)
             if (!states.contains(*it))
                 states.append(*it);
 
     FOR_EACH_CHILD(child)
     child->usedStates(states);
 }
 
 Note *Note::nextInStack()
 {
     // First, search in the children:
     if (firstChild()) {
         if (firstChild()->content())
             return firstChild();
         else
             return firstChild()->nextInStack();
     }
     // Then, in the next:
     if (next()) {
         if (next()->content())
             return next();
         else
             return next()->nextInStack();
     }
     // And finally, in the parent:
     Note *note = parentNote();
     while (note)
         if (note->next())
             if (note->next()->content())
                 return note->next();
             else
                 return note->next()->nextInStack();
         else
             note = note->parentNote();
 
     // Not found:
     return nullptr;
 }
 
 Note *Note::prevInStack()
 {
     // First, search in the previous:
     if (prev() && prev()->content())
         return prev();
 
     // Else, it's a group, get the last item in that group:
     if (prev()) {
         Note *note = prev()->lastRealChild();
         if (note)
             return note;
     }
 
     if (parentNote())
         return parentNote()->prevInStack();
     else
         return nullptr;
 }
 
 Note *Note::nextShownInStack()
 {
     Note *next = nextInStack();
     while (next && !next->isShown())
         next = next->nextInStack();
     return next;
 }
 
 Note *Note::prevShownInStack()
 {
     Note *prev = prevInStack();
     while (prev && !prev->isShown())
         prev = prev->prevInStack();
     return prev;
 }
 
 bool Note::isShown()
 {
     // First, the easy one: groups are always shown:
     if (isGroup())
         return true;
 
     // And another easy part: non-matching notes are hidden:
     if (!matching())
         return false;
 
     if (basket()->isFiltering()) // And isMatching() because of the line above!
         return true;
 
     // So, here we go to the complex case: if the note is inside a collapsed group:
     Note *group = parentNote();
     Note *child = this;
     while (group) {
         if (group->isFolded() && group->firstChild() != child)
             return false;
         child = group;
         group = group->parentNote();
     }
     return true;
 }
 
 void Note::debug()
 {
     qDebug() << "Note@" << (quint64)this;
     if (!this) {
         qDebug();
         return;
     }
 
     if (isColumn())
         qDebug() << ": Column";
     else if (isGroup())
         qDebug() << ": Group";
     else
         qDebug() << ": Content[" << content()->lowerTypeName() << "]: " << toText(QString());
     qDebug();
 }
 
 Note *Note::firstSelected()
 {
     if (isSelected())
         return this;
 
     Note *first = nullptr;
     FOR_EACH_CHILD(child)
     {
         first = child->firstSelected();
         if (first)
             break;
     }
     return first;
 }
 
 Note *Note::lastSelected()
 {
     if (isSelected())
         return this;
 
     Note *last = nullptr, *tmp = nullptr;
     FOR_EACH_CHILD(child)
     {
         tmp = child->lastSelected();
         if (tmp)
             last = tmp;
     }
     return last;
 }
 
 Note *Note::selectedGroup()
 {
     if (isGroup() && allSelected() && count() == basket()->countSelecteds())
         return this;
 
     FOR_EACH_CHILD(child)
     {
         Note *selectedGroup = child->selectedGroup();
         if (selectedGroup)
             return selectedGroup;
     }
 
     return nullptr;
 }
 
 void Note::groupIn(Note *group)
 {
     if (this == group)
         return;
 
     if (allSelected() && !isColumn()) {
         basket()->unplugNote(this);
         basket()->insertNote(this, group, Note::BottomColumn);
     } else {
         Note *next;
         Note *child = firstChild();
         while (child) {
             next = child->next();
             child->groupIn(group);
             child = next;
         }
     }
 }
 
 bool Note::tryExpandParent()
 {
     Note *parent = parentNote();
     Note *child = this;
     while (parent) {
         if (parent->firstChild() != child)
             return false;
         if (parent->isColumn())
             return false;
         if (parent->isFolded()) {
             parent->toggleFolded();
             basket()->relayoutNotes();
             return true;
         }
         child = parent;
         parent = parent->parentNote();
     }
     return false;
 }
 
 bool Note::tryFoldParent() // TODO: withCtrl  ? withShift  ?
 {
     Note *parent = parentNote();
     Note *child = this;
     while (parent) {
         if (parent->firstChild() != child)
             return false;
         if (parent->isColumn())
             return false;
         if (!parent->isFolded()) {
             parent->toggleFolded();
             basket()->relayoutNotes();
             return true;
         }
         child = parent;
         parent = parent->parentNote();
     }
     return false;
 }
 
 qreal Note::distanceOnLeftRight(Note *note, int side)
 {
     if (side == BasketScene::RIGHT_SIDE) {
         // If 'note' is on left of 'this': cannot switch from this to note by pressing Right key:
         if (x() > note->x() || finalRightLimit() > note->finalRightLimit())
             return -1;
     } else { /*LEFT_SIDE:*/
         // If 'note' is on left of 'this': cannot switch from this to note by pressing Right key:
         if (x() < note->x() || finalRightLimit() < note->finalRightLimit())
             return -1;
     }
     if (x() == note->x() && finalRightLimit() == note->finalRightLimit())
         return -1;
 
     qreal thisCenterX = x() + (side == BasketScene::LEFT_SIDE ? width() : /*RIGHT_SIDE:*/ 0);
     qreal thisCenterY = y() + height() / 2;
     qreal noteCenterX = note->x() + note->width() / 2;
     qreal noteCenterY = note->y() + note->height() / 2;
 
     if (thisCenterY > note->bottom())
         noteCenterY = note->bottom();
     else if (thisCenterY < note->y())
         noteCenterY = note->y();
     else
         noteCenterY = thisCenterY;
 
     qreal angle = 0;
     if (noteCenterX - thisCenterX != 0)
         angle = 1000 * ((noteCenterY - thisCenterY) / (noteCenterX - thisCenterX));
     if (angle < 0)
         angle = -angle;
 
     return sqrt(pow(noteCenterX - thisCenterX, 2) + pow(noteCenterY - thisCenterY, 2)) + angle;
 }
 
 qreal Note::distanceOnTopBottom(Note *note, int side)
 {
     if (side == BasketScene::BOTTOM_SIDE) {
         // If 'note' is on left of 'this': cannot switch from this to note by pressing Right key:
         if (y() > note->y() || bottom() > note->bottom())
             return -1;
     } else { /*TOP_SIDE:*/
         // If 'note' is on left of 'this': cannot switch from this to note by pressing Right key:
         if (y() < note->y() || bottom() < note->bottom())
             return -1;
     }
     if (y() == note->y() && bottom() == note->bottom())
         return -1;
 
     qreal thisCenterX = x() + width() / 2;
     qreal thisCenterY = y() + (side == BasketScene::TOP_SIDE ? height() : /*BOTTOM_SIDE:*/ 0);
     qreal noteCenterX = note->x() + note->width() / 2;
     qreal noteCenterY = note->y() + note->height() / 2;
 
     if (thisCenterX > note->finalRightLimit())
         noteCenterX = note->finalRightLimit();
     else if (thisCenterX < note->x())
         noteCenterX = note->x();
     else
         noteCenterX = thisCenterX;
 
     qreal angle = 0;
     if (noteCenterX - thisCenterX != 0)
         angle = 1000 * ((noteCenterY - thisCenterY) / (noteCenterX - thisCenterX));
     if (angle < 0)
         angle = -angle;
 
     return sqrt(pow(noteCenterX - thisCenterX, 2) + pow(noteCenterY - thisCenterY, 2)) + angle;
 }
 
 Note *Note::parentPrimaryNote()
 {
     Note *primary = this;
     while (primary->parentNote())
         primary = primary->parentNote();
     return primary;
 }
 
 void Note::deleteChilds()
 {
     Note *child = firstChild();
 
     while (child) {
         Note *tmp = child->next();
         delete child;
         child = tmp;
     }
 }
 
 bool Note::saveAgain()
 {
     bool result = true;
 
     if (content()) {
         if (!content()->saveToFile())
             result = false;
     }
     FOR_EACH_CHILD(child)
     {
         if (!child->saveAgain())
             result = false;
     }
     if (!result) {
         DEBUG_WIN << QString("Note::saveAgain returned false for %1:%2").arg((content() != nullptr) ? content()->typeName() : "null", toText(QString()));
     }
     return result;
 }
 
 bool Note::convertTexts()
 {
     bool convertedNotes = false;
 
     if (content() && content()->lowerTypeName() == "text") {
         QString text = ((TextContent *)content())->text();
         QString html = "<html><head><meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\"><meta name=\"qrichtext\" content=\"1\" /></head><body>" + Tools::textToHTMLWithoutP(text) + "</body></html>";
         FileStorage::saveToFile(fullPath(), html);
         setContent(new HtmlContent(this, content()->fileName()));
         convertedNotes = true;
     }
 
     FOR_EACH_CHILD(child)
     if (child->convertTexts())
         convertedNotes = true;
 
     return convertedNotes;
 }
 
 /* vim: set et sts=4 sw=4 ts=16 tw=78 : */
 /* kate: indent-width 4; replace-tabs on; */
diff --git a/src/noteitem.cpp b/src/noteitem.cpp
index 669a600..f70c001 100644
--- a/src/noteitem.cpp
+++ b/src/noteitem.cpp
@@ -1,281 +1,285 @@
 /*
  * SPDX-FileCopyrightText: (C) 2003 by Sébastien Laoût <slaout@linux62.org>
  * SPDX-FileCopyrightText: (C) 2020 by Ismael Asensio <isma.af@gmail.com>
  * SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "basketscenemodel.h"
 
 #include "notefactory.h"
 #include "xmlwork.h"
 
 #include <QDomElement>
 
 
 namespace {
 
 QString iconNameForType(NoteType::Id type)
 {
     switch (type) {
         case NoteType::Group:  return "package";
         case NoteType::Text: return "text-x-plain";
         case NoteType::Html: return "text-html";
         case NoteType::Image: return "folder-pictures-symbolic";
         case NoteType::Animation: return "folder-video-symbolic";
         case NoteType::Sound: return "folder-music-symbolic";
         case NoteType::File: return "application-x-zerosize";
         case NoteType::Link: return "edit-link";
         case NoteType::CrossReference: return "basket";
         case NoteType::Launcher: return "run-build";
         case NoteType::Color: return "color-profile";
         case NoteType::Unknown: return "application-octet-stream";
     }
     return QString();
 }
 
 }
 
+BasketScene *NoteItem::s_basket;
 
 NoteItem::NoteItem()
     : m_parent(nullptr)
     , m_note(nullptr)
-    , m_helperNote(new Note())
+    , m_helperNote(new Note(s_basket))
 {
 }
 
 NoteItem::~NoteItem()
 {
     delete m_helperNote;
     qDeleteAll(m_children);
 }
 
 
 int NoteItem::row() const
 {
     if (!m_parent) {
         return 0;
     }
     return m_parent->m_children.indexOf(const_cast<NoteItem *>(this));
 }
 
 NoteItem *NoteItem::parent() const
 {
     return m_parent;
 }
 
 void NoteItem::setParent(NoteItem *parent)
 {
     m_parent = parent;
 }
 
 QVector<NoteItem *> NoteItem::children() const
 {
     return m_children;
 }
 
 int NoteItem::childrenCount() const
 {
     return m_children.count();
 }
 
 void NoteItem::insertAt(int row, NoteItem *item)
 {
     if (!item) return;
 
     item->setParent(this);
     if (row >= 0 && row < m_children.count() ) {
         m_children.insert(row, item);
     } else {
         m_children.append(item);
     }
 }
 
 void NoteItem::removeAt(int row)
 {
     if (row < 0 || row >= m_children.count()) {
         return;
     }
     delete m_children[row];
     m_children.remove(row);
 }
 
 NoteItem *NoteItem::takeAt(int row)
 {
     if (row < 0 || row >= m_children.count()) {
         return nullptr;
     }
     return m_children.takeAt(row);
 }
 
 
 NotePtr NoteItem::note() const
 {
     if (!m_note) {
         return m_helperNote;
     }
     return m_note;
 }
 
 void NoteItem::setNote(NotePtr note)
 {
     m_note = note;
 }
 
+void NoteItem::setBasketParent(BasketScene* basket)
+{
+    s_basket = basket;
+}
+
 
 QString NoteItem::displayText() const
 {
     if (!note()) { return QStringLiteral("NULL NOTE"); }
     if (type() == NoteType::Group) { return QStringLiteral("GROUP"); }
     return content()->toText(QString());
 }
 
 QIcon NoteItem::decoration() const
 {
     if (!note()) { return QIcon::fromTheme("data-error"); }
     if (type() == NoteType::Group) { return QIcon::fromTheme("package"); }
     if (!content()) { return QIcon::fromTheme("empty"); }
 
     return QIcon::fromTheme(iconNameForType(content()->type()));
 }
 
 NoteContent *NoteItem::content() const
 {
     if (!note()) {
         return nullptr;
     }
     return note()->content();
 }
 
 NoteType::Id NoteItem::type() const
 {
     if (!note()) {
         return NoteType::Unknown;
     }
     if (!note()->content()) {
         return NoteType::Group;
     }
     return note()->content()->type();
 }
 
 QRect NoteItem::bounds() const
 {
     return QRect(
         note()->x(),
         note()->y(),
         note()->width(),
         note()->height()
     );
 }
 
 NoteItem::EditInfo NoteItem::editInformation() const
 {
     return EditInfo {
         note()->addedDate(),
         note()->lastModificationDate()
     };
 }
 
 
 QString NoteItem::formatAddress(void *ptr) {
     return QString::number(reinterpret_cast<long>(ptr), 16);
 }
 
 QString NoteItem::address() const
 {
     if (!note()) {
         return QStringLiteral("root");
     }
     return formatAddress(note());
 }
 
 QString NoteItem::toolTipInfo() const
 {
     QStringList toolTip;
 
     // fullAddress and position within parent (debug)
     toolTip << QStringLiteral("%1 (@ <%2>[%3])")
                                 .arg(formatAddress(note()))
                                 .arg(m_parent->address())
                                 .arg(row());
 
     // type
     toolTip << QStringLiteral("Type: %1").arg(content() ? content()->typeName() : "Group");
 
     // geometry
     const QRect geometry = bounds();
     toolTip << QStringLiteral("x:%1 y:%2 w:%3 h:%4")
                                 .arg(geometry.x()).arg(geometry.y())
                                 .arg(geometry.width()).arg(geometry.height());
 
     // edition information
     const EditInfo info = editInformation();
     toolTip << QStringLiteral("created: %1\nmodified: %2")
                                 .arg(info.created.toString())
                                 .arg(info.modified.toString());
 
     return toolTip.join(QStringLiteral("\n"));
 }
 
 
 void NoteItem::loadFromXMLNode(const QDomElement& node)
 {
     for (QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling()) {
         QDomElement e = n.toElement();
         if (e.isNull()) {
             continue;
         }
 
         NoteItem *noteItem = new NoteItem();
         noteItem->setParent(this);
         m_children.append(noteItem);
 
         NotePtr note = noteItem->note();    // Helper Note object
 
         if (e.tagName() == "group") {
             // Node is a group. Recursively load from this element
             noteItem->loadFromXMLNode(e);
         } else if (e.tagName() == "note" || e.tagName() == "item") {      // "item" is to keep compatible with 0.6.0 Alpha 1 (required?)
             // Load note content
-/* IT CRASHES. Too dependant on QObject hierarchy?
             NoteFactory::loadNode(XMLWork::getElement(e, "content"),
                                   e.attribute("type"),
                                   note,
                                   true);  //lazyload
-*/
         }
 
         // Load dates
         if (e.hasAttribute("added")) {
             note->setAddedDate(QDateTime::fromString(e.attribute("added"), Qt::ISODate));
         }
         if (e.hasAttribute("lastModification")) {
             note->setLastModificationDate(QDateTime::fromString(e.attribute("lastModification"), Qt::ISODate));
         }
         // Free Note Properties:
         if (note->isFree()) {
             int x = e.attribute("x").toInt();
             int y = e.attribute("y").toInt();
             note->setX(x < 0 ? 0 : x);
             note->setY(y < 0 ? 0 : y);
         }
         // Resizeable Note Properties:
         if (note->hasResizer() || note->isColumn()) {
             note->setGroupWidth(e.attribute("width", "200").toInt());
         }
         // Group Properties:
         if (note->isGroup() && !note->isColumn() && XMLWork::trueOrFalse(e.attribute("folded", "false"))) {
             note->toggleFolded();
         }
         // Tags:
         if (note->content()) {
             const QString tagsString = XMLWork::getElementText(e, QStringLiteral("tags"), QString());
             const QStringList tagsId = tagsString.split(';');
             for (const QString &tagId : tagsId) {
                 State *state = Tag::stateForId(tagId);
                 if (state) {
                     note->addState(state, /*orReplace=*/true);
                 }
             }
         }
     }
 }
diff --git a/src/noteitem.h b/src/noteitem.h
index 55ba138..926304f 100644
--- a/src/noteitem.h
+++ b/src/noteitem.h
@@ -1,81 +1,85 @@
 /*
  * SPDX-FileCopyrightText: 2020 by Ismael Asensio <isma.af@gmail.com>
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #pragma once
 
 #include "note.h"
 #include "notecontent.h"
 
 #include <QMetaType>
 
 
 class QDomElement;
 
 typedef Note * NotePtr;
 
 /** NoteItem: Container that stores a Note object within a tree model
  * Eventually implement the managing functionallity here and use directly the `NoteContent` object
  */
 class NoteItem
 {
 public:
     struct EditInfo
     {
         QDateTime created;
         QDateTime modified;
     };
 
 public:
     explicit NoteItem();
     ~NoteItem();
 
     // Tree structure
     int row() const;
 
     NoteItem *parent() const;
     void setParent(NoteItem *parent);
 
     QVector<NoteItem *> children() const;
     int childrenCount() const;
     void insertAt(int row, NoteItem *item);
     void removeAt(int row);
     NoteItem *takeAt(int row);
 
-    // Accesors to Note object (compatibility with current code)
+    // Accesors for compatibility with current code
     NotePtr note() const;
     void setNote(NotePtr note);
+    static void setBasketParent(BasketScene *basket);
 
     // NoteItem property getters
     QString displayText() const;
     QIcon decoration() const;
     NoteContent *content() const;
     NoteType::Id type() const;
     QRect bounds() const;
     EditInfo editInformation() const;
 
     // Recursive loader from an XML node
     void loadFromXMLNode(const QDomElement &node);
 
     // Find and debug Notes by its pointer address
     static QString formatAddress(void *ptr);
     QString address() const;
 
     QString toolTipInfo() const;
 
+
 private:
     NoteItem *m_parent;
     QVector<NoteItem *> m_children;
 
 // TODO: Remove m_note and store the information here
     NotePtr m_note;
-    NotePtr m_helperNote; // Dummy note to help with the code transition.
+    NotePtr m_helperNote;         // Dummy note to help with the code transition.
+    static BasketScene *s_basket; // Stored to set a parent to the notes (and avoid crashes)
+
 //     NoteContent *m_content;
 //     QRect m_bounds;
 //     EditInfo m_editInfo;
 //     QVector<State> m_tags;
 };
 
 Q_DECLARE_METATYPE(NoteContent *)
 Q_DECLARE_METATYPE(NoteItem::EditInfo)