diff --git a/src/kbookmarkmenu.cpp b/src/kbookmarkmenu.cpp
index 56a4359..41341f6 100644
--- a/src/kbookmarkmenu.cpp
+++ b/src/kbookmarkmenu.cpp
@@ -1,502 +1,513 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2006 Daniel Teske <teske@squorn.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "kbookmarkmenu.h"
 #include "kbookmarkmenu_p.h"
 
 #include "kbookmarkaction.h"
 #include "kbookmarkactionmenu.h"
 #include "kbookmarkcontextmenu.h"
 #include "kbookmarks_debug.h"
 #include "kbookmarkdialog.h"
 #include "kbookmarkowner.h"
 
 #include <KActionCollection>
 #include <KAuthorized>
 #include <KStandardAction>
 
 #include <QApplication>
 #include <QMenu>
 #include <QObject>
 #include <QStandardPaths>
 
 /********************************************************************/
 /********************************************************************/
 /********************************************************************/
 class KBookmarkMenuPrivate
 {
 public:
     KBookmarkMenuPrivate()
         : newBookmarkFolderAction(nullptr),
           addBookmarkAction(nullptr),
           bookmarksToFolderAction(nullptr),
           editBookmarksAction(nullptr),
           numberOfOpenTabs(2)
     {
     }
 
     QAction *newBookmarkFolderAction;
     QAction *addBookmarkAction;
     QAction *bookmarksToFolderAction;
     QAction *editBookmarksAction;
     int numberOfOpenTabs;
 };
 
 #if KBOOKMARKS_BUILD_DEPRECATED_SINCE(5, 69)
 KBookmarkMenu::KBookmarkMenu(KBookmarkManager *mgr,
                              KBookmarkOwner *_owner,
                              QMenu *_parentMenu,
                              KActionCollection *actionCollection)
-    : KBookmarkMenu(mgr, _owner, _parentMenu)
+    : QObject(),
+      m_actionCollection(actionCollection),
+      d(new KBookmarkMenuPrivate()),
+      m_bIsRoot(true),
+      m_pManager(mgr),
+      m_pOwner(_owner),
+      m_parentMenu(_parentMenu),
+      m_parentAddress(QString())   //TODO KBookmarkAdress::root
 {
-    m_actionCollection = actionCollection;
+    init();
 }
+
 #endif
 
 KBookmarkMenu::KBookmarkMenu(KBookmarkManager* manager, KBookmarkOwner* _owner, QMenu* _parentMenu)
     : QObject(),
     m_actionCollection(new KActionCollection(this)),
     d(new KBookmarkMenuPrivate()),
     m_bIsRoot(true),
     m_pManager(manager),
     m_pOwner(_owner),
     m_parentMenu(_parentMenu),
     m_parentAddress(QString())   //TODO KBookmarkAdress::root
 {
     // TODO KDE5 find a QMenu equvalnet for this one
     //m_parentMenu->setKeyboardShortcutsEnabled( true );
 
-    // qCDebug(KBOOKMARKS_LOG) << "KBookmarkMenu::KBookmarkMenu " << this << " address : " << m_parentAddress;
+    init();
+}
 
+void KBookmarkMenu::init()
+{
     connect(m_parentMenu, &QMenu::aboutToShow,
             this, &KBookmarkMenu::slotAboutToShow);
 
     if (KBookmarkSettings::self()->m_contextmenu) {
         m_parentMenu->setContextMenuPolicy(Qt::CustomContextMenu);
         connect(m_parentMenu, &QWidget::customContextMenuRequested, this, &KBookmarkMenu::slotCustomContextMenu);
     }
 
     connect(m_pManager, &KBookmarkManager::changed,
             this, &KBookmarkMenu::slotBookmarksChanged);
 
     m_bDirty = true;
     addActions();
 }
 
 void KBookmarkMenu::addActions()
 {
     if (m_bIsRoot) {
         addAddBookmark();
         addAddBookmarksList();
         addNewFolder();
         addEditBookmarks();
     } else {
         if (!m_parentMenu->actions().isEmpty()) {
             m_parentMenu->addSeparator();
         }
 
         addOpenInTabs();
         addAddBookmark();
         addAddBookmarksList();
         addNewFolder();
     }
 }
 
 KBookmarkMenu::KBookmarkMenu(KBookmarkManager *mgr,
                              KBookmarkOwner *_owner,
                              QMenu *_parentMenu,
                              const QString &parentAddress)
     : QObject(),
       m_actionCollection(new KActionCollection(this)),
       d(new KBookmarkMenuPrivate()),
       m_bIsRoot(false),
       m_pManager(mgr),
       m_pOwner(_owner),
       m_parentMenu(_parentMenu),
       m_parentAddress(parentAddress)
 {
     connect(_parentMenu, &QMenu::aboutToShow, this, &KBookmarkMenu::slotAboutToShow);
     if (KBookmarkSettings::self()->m_contextmenu) {
         m_parentMenu->setContextMenuPolicy(Qt::CustomContextMenu);
         connect(m_parentMenu, &QWidget::customContextMenuRequested, this, &KBookmarkMenu::slotCustomContextMenu);
     }
     m_bDirty = true;
 }
 
 KBookmarkMenu::~KBookmarkMenu()
 {
     qDeleteAll(m_lstSubMenus);
     qDeleteAll(m_actions);
     delete d;
 }
 
 void KBookmarkMenu::ensureUpToDate()
 {
     slotAboutToShow();
 }
 
 void KBookmarkMenu::setNumberOfOpenTabs(int numberOfOpenTabs)
 {
     if (numberOfOpenTabs == d->numberOfOpenTabs) {
         return;
     }
     m_bDirty = (d->numberOfOpenTabs < 2) != (numberOfOpenTabs < 2);
     d->numberOfOpenTabs = numberOfOpenTabs;
 }
 
 int KBookmarkMenu::numberOfOpenTabs() const
 {
     return d->numberOfOpenTabs;
 }
 
 void KBookmarkMenu::slotAboutToShow()
 {
     // Did the bookmarks change since the last time we showed them ?
     if (m_bDirty) {
         m_bDirty = false;
         clear();
         refill();
         m_parentMenu->adjustSize();
     }
 }
 
 void KBookmarkMenu::slotCustomContextMenu(const QPoint &pos)
 {
     QAction *action = m_parentMenu->actionAt(pos);
     QMenu *menu = contextMenu(action);
     if (!menu) {
         return;
     }
     menu->setAttribute(Qt::WA_DeleteOnClose);
     menu->popup(m_parentMenu->mapToGlobal(pos));
 }
 
 QMenu *KBookmarkMenu::contextMenu(QAction *action)
 {
     KBookmarkActionInterface *act = dynamic_cast<KBookmarkActionInterface *>(action);
     if (!act) {
         return nullptr;
     }
     return new KBookmarkContextMenu(act->bookmark(), m_pManager, m_pOwner);
 }
 
 bool KBookmarkMenu::isRoot() const
 {
     return m_bIsRoot;
 }
 
 bool KBookmarkMenu::isDirty() const
 {
     return m_bDirty;
 }
 
 QString KBookmarkMenu::parentAddress() const
 {
     return m_parentAddress;
 }
 
 KBookmarkManager *KBookmarkMenu::manager() const
 {
     return m_pManager;
 }
 
 KBookmarkOwner *KBookmarkMenu::owner() const
 {
     return m_pOwner;
 }
 
 QMenu *KBookmarkMenu::parentMenu() const
 {
     return m_parentMenu;
 }
 
 /********************************************************************/
 /********************************************************************/
 /********************************************************************/
 
 
 /********************************************************************/
 /********************************************************************/
 /********************************************************************/
 
 void KBookmarkMenu::slotBookmarksChanged(const QString &groupAddress)
 {
     qCDebug(KBOOKMARKS_LOG) << "KBookmarkMenu::slotBookmarksChanged groupAddress: " << groupAddress;
     if (groupAddress == m_parentAddress) {
         //qCDebug(KBOOKMARKS_LOG) << "KBookmarkMenu::slotBookmarksChanged -> setting m_bDirty on " << groupAddress;
         m_bDirty = true;
     } else {
         // Iterate recursively into child menus
         for (QList<KBookmarkMenu *>::iterator it = m_lstSubMenus.begin(), end = m_lstSubMenus.end();
                 it != end; ++it) {
             (*it)->slotBookmarksChanged(groupAddress);
         }
     }
 }
 
 void KBookmarkMenu::clear()
 {
     qDeleteAll(m_lstSubMenus);
     m_lstSubMenus.clear();
 
     for (QList<QAction *>::iterator it = m_actions.begin(), end = m_actions.end();
             it != end; ++it) {
         m_parentMenu->removeAction(*it);
         delete *it;
     }
 
     m_parentMenu->clear();
     m_actions.clear();
 }
 
 void KBookmarkMenu::refill()
 {
     //qCDebug(KBOOKMARKS_LOG) << "KBookmarkMenu::refill()";
     if (m_bIsRoot) {
         addActions();
     }
     fillBookmarks();
     if (!m_bIsRoot) {
         addActions();
     }
 }
 
 void KBookmarkMenu::addOpenInTabs()
 {
     if (!m_pOwner || !m_pOwner->supportsTabs() ||
             !KAuthorized::authorizeAction(QStringLiteral("bookmarks"))) {
         return;
     }
 
     QString title = tr("Open Folder in Tabs");
 
     QAction *paOpenFolderInTabs = new QAction(title, this);
     paOpenFolderInTabs->setIcon(QIcon::fromTheme(QStringLiteral("tab-new")));
     paOpenFolderInTabs->setToolTip(tr("Open all bookmarks in this folder as a new tab."));
     paOpenFolderInTabs->setStatusTip(paOpenFolderInTabs->toolTip());
     connect(paOpenFolderInTabs, &QAction::triggered, this, &KBookmarkMenu::slotOpenFolderInTabs);
 
     m_parentMenu->addAction(paOpenFolderInTabs);
     m_actions.append(paOpenFolderInTabs);
 }
 
 void KBookmarkMenu::addAddBookmarksList()
 {
     if (!m_pOwner || !m_pOwner->enableOption(KBookmarkOwner::ShowAddBookmark) || !m_pOwner->supportsTabs() ||
             (d->numberOfOpenTabs < 2) || !KAuthorized::authorizeAction(QStringLiteral("bookmarks"))) {
         return;
     }
 
     if (!d->bookmarksToFolderAction) {
         QString title = tr("Bookmark Tabs as Folder...");
         d->bookmarksToFolderAction = new QAction(title, this);
 
         if (m_bIsRoot) {
             d->bookmarksToFolderAction->setObjectName(QStringLiteral("add_bookmarks_list"));
         }
 
         d->bookmarksToFolderAction->setIcon(QIcon::fromTheme(QStringLiteral("bookmark-new-list")));
         d->bookmarksToFolderAction->setToolTip(tr("Add a folder of bookmarks for all open tabs."));
         d->bookmarksToFolderAction->setStatusTip(d->bookmarksToFolderAction->toolTip());
         connect(d->bookmarksToFolderAction, &QAction::triggered, this, &KBookmarkMenu::slotAddBookmarksList);
 
         if (m_actionCollection) {
             m_actionCollection->addAction(d->bookmarksToFolderAction->objectName(), d->bookmarksToFolderAction);
         }
     }
 
     m_parentMenu->addAction(d->bookmarksToFolderAction);
 }
 
 void KBookmarkMenu::addAddBookmark()
 {
     if (!m_pOwner || !m_pOwner->enableOption(KBookmarkOwner::ShowAddBookmark) ||
             !KAuthorized::authorizeAction(QStringLiteral("bookmarks"))) {
         return;
     }
 
     if (!d->addBookmarkAction) {
         d->addBookmarkAction = KStandardAction::addBookmark(this, SLOT(slotAddBookmark()), this);
         if (m_bIsRoot) {
             d->addBookmarkAction->setObjectName(QStringLiteral("add_bookmark"));
         }
 
         if (m_actionCollection) {
             m_actionCollection->addAction(d->addBookmarkAction->objectName(), d->addBookmarkAction);
         }
 
         if (!m_bIsRoot) {
             d->addBookmarkAction->setShortcut(QKeySequence());
         }
     }
 
     m_parentMenu->addAction(d->addBookmarkAction);
 }
 
 void KBookmarkMenu::addEditBookmarks()
 {
     if ((m_pOwner && !m_pOwner->enableOption(KBookmarkOwner::ShowEditBookmark)) ||
             QStandardPaths::findExecutable(QStringLiteral(KEDITBOOKMARKS_BINARY)).isEmpty() ||
             !KAuthorized::authorizeAction(QStringLiteral("bookmarks"))) {
         return;
     }
 
     d->editBookmarksAction = KStandardAction::editBookmarks(m_pManager, SLOT(slotEditBookmarks()), this);
     d->editBookmarksAction->setObjectName(QStringLiteral("edit_bookmarks"));
 
     m_parentMenu->addAction(d->editBookmarksAction);
     d->editBookmarksAction->setToolTip(tr("Edit your bookmark collection in a separate window"));
     d->editBookmarksAction->setStatusTip(d->editBookmarksAction->toolTip());
 
     if (m_actionCollection) {
         m_actionCollection->addAction(d->editBookmarksAction->objectName(), d->editBookmarksAction);
     }
 }
 
 void KBookmarkMenu::addNewFolder()
 {
     if (!m_pOwner || !m_pOwner->enableOption(KBookmarkOwner::ShowAddBookmark) ||
             !KAuthorized::authorizeAction(QStringLiteral("bookmarks"))) {
         return;
     }
 
     if (!d->newBookmarkFolderAction) {
         d->newBookmarkFolderAction = new QAction(tr("New Bookmark Folder..."), this);
         d->newBookmarkFolderAction->setIcon(QIcon::fromTheme(QStringLiteral("folder-new")));
         d->newBookmarkFolderAction->setToolTip(tr("Create a new bookmark folder in this menu"));
         d->newBookmarkFolderAction->setStatusTip(d->newBookmarkFolderAction->toolTip());
 
         if (m_bIsRoot) {
             d->newBookmarkFolderAction->setObjectName(QStringLiteral("new_bookmark_folder"));
         }
 
         connect(d->newBookmarkFolderAction, &QAction::triggered, this, &KBookmarkMenu::slotNewFolder);
     }
 
     m_parentMenu->addAction(d->newBookmarkFolderAction);
 
 }
 
 void KBookmarkMenu::fillBookmarks()
 {
     KBookmarkGroup parentBookmark = m_pManager->findByAddress(m_parentAddress).toGroup();
     Q_ASSERT(!parentBookmark.isNull());
 
     if (m_bIsRoot && !parentBookmark.first().isNull()) { // at least one bookmark
         m_parentMenu->addSeparator();
     }
 
     for (KBookmark bm = parentBookmark.first(); !bm.isNull();  bm = parentBookmark.next(bm)) {
         m_parentMenu->addAction(actionForBookmark(bm));
     }
 }
 
 QAction *KBookmarkMenu::actionForBookmark(const KBookmark &bm)
 {
     if (bm.isGroup()) {
         //qCDebug(KBOOKMARKS_LOG) << "Creating bookmark submenu named " << bm.text();
         KActionMenu *actionMenu = new KBookmarkActionMenu(bm, this);
         m_actions.append(actionMenu);
         KBookmarkMenu *subMenu = new KBookmarkMenu(m_pManager, m_pOwner, actionMenu->menu(), bm.address());
         m_lstSubMenus.append(subMenu);
         return actionMenu;
     } else if (bm.isSeparator()) {
         QAction *sa = new QAction(this);
         sa->setSeparator(true);
         m_actions.append(sa);
         return sa;
     } else {
         //qCDebug(KBOOKMARKS_LOG) << "Creating bookmark menu item for " << bm.text();
         QAction *action = new KBookmarkAction(bm, m_pOwner, this);
         m_actions.append(action);
         return action;
     }
 }
 
 void KBookmarkMenu::slotAddBookmarksList()
 {
     if (!m_pOwner || !m_pOwner->supportsTabs()) {
         return;
     }
 
     KBookmarkGroup parentBookmark = m_pManager->findByAddress(m_parentAddress).toGroup();
 
     KBookmarkDialog *dlg = m_pOwner->bookmarkDialog(m_pManager, QApplication::activeWindow());
     dlg->addBookmarks(m_pOwner->currentBookmarkList(), QLatin1String(""), parentBookmark);
     delete dlg;
 }
 
 void KBookmarkMenu::slotAddBookmark()
 {
     if (!m_pOwner) {
         return;
     }
     if (m_pOwner->currentTitle().isEmpty() && m_pOwner->currentUrl().isEmpty()) {
         return;
     }
     KBookmarkGroup parentBookmark = m_pManager->findByAddress(m_parentAddress).toGroup();
 
     if (KBookmarkSettings::self()->m_advancedaddbookmark) {
         KBookmarkDialog *dlg = m_pOwner->bookmarkDialog(m_pManager, QApplication::activeWindow());
         dlg->addBookmark(m_pOwner->currentTitle(), m_pOwner->currentUrl(), m_pOwner->currentIcon(), parentBookmark);
         delete dlg;
     } else {
         parentBookmark.addBookmark(m_pOwner->currentTitle(), m_pOwner->currentUrl(), m_pOwner->currentIcon());
         m_pManager->emitChanged(parentBookmark);
     }
 
 }
 
 void KBookmarkMenu::slotOpenFolderInTabs()
 {
     m_pOwner->openFolderinTabs(m_pManager->findByAddress(m_parentAddress).toGroup());
 }
 
 void KBookmarkMenu::slotNewFolder()
 {
     if (!m_pOwner) {
         return;    // this view doesn't handle bookmarks...
     }
     KBookmarkGroup parentBookmark = m_pManager->findByAddress(m_parentAddress).toGroup();
     Q_ASSERT(!parentBookmark.isNull());
     KBookmarkDialog *dlg = m_pOwner->bookmarkDialog(m_pManager, QApplication::activeWindow());
     dlg->createNewFolder(QLatin1String(""), parentBookmark);
     delete dlg;
 }
 
 QAction * KBookmarkMenu::addBookmarkAction() const
 {
     return d->addBookmarkAction;
 }
 
 QAction * KBookmarkMenu::bookmarkTabsAsFolderAction() const
 {
     return d->bookmarksToFolderAction;
 }
 
 QAction *KBookmarkMenu::newBookmarkFolderAction() const
 {
     return d->newBookmarkFolderAction;
 }
 
 QAction * KBookmarkMenu::editBookmarksAction() const
 {
     return d->editBookmarksAction;
 }
diff --git a/src/kbookmarkmenu.h b/src/kbookmarkmenu.h
index a64bb0e..332a137 100644
--- a/src/kbookmarkmenu.h
+++ b/src/kbookmarkmenu.h
@@ -1,278 +1,280 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2006 Daniel Teske <teske@squorn.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef __kbookmarkmenu_h__
 #define __kbookmarkmenu_h__
 
 #include <kbookmarks_export.h>
 
 #include <QObject>
 
 class QAction;
 class QMenu;
 class KBookmark;
 class KActionCollection;
 class KBookmarkManager;
 class KBookmarkOwner;
 class KBookmarkMenu;
 class KBookmarkActionInterface;
 
 class KBookmarkMenuPrivate; // Not implemented
 
 /**
  * This class provides a bookmark menu.  It is typically used in
  * cooperation with KActionMenu but doesn't have to be.
  *
  * If you use this class by itself, then it will use KDE defaults for
  * everything -- the bookmark path, bookmark editor, bookmark launcher..
  * everything.  These defaults reside in the classes
  * KBookmarkOwner (editing bookmarks) and KBookmarkManager
  * (almost everything else).  If you wish to change the defaults in
  * any way, you must reimplement either this class or KBookmarkOwner.
  *
  * Using this class is very simple:
  *
  * 1) Create a popup menu (either KActionMenu or QMenu will do)
  * 2) Instantiate a new KBookmarkMenu object using the above popup
  *    menu as a parameter
  * 3) Insert your (now full) popup menu wherever you wish
  *
  * The functionality of this class can be disabled with the "action/bookmarks"
  * Kiosk action (see the KAuthorized namespace).
  */
 class KBOOKMARKS_EXPORT KBookmarkMenu : public QObject
 {
     Q_OBJECT
 public:
 #if KBOOKMARKS_ENABLE_DEPRECATED_SINCE(5, 69)
     /**
      * Fills a bookmark menu
      * (one instance of KBookmarkMenu is created for the toplevel menu,
      *  but also one per submenu).
      *
      * @param mgr The bookmark manager to use (i.e. for reading and writing)
      * @param owner implementation of the KBookmarkOwner callback interface.
      * Note: If you pass a null KBookmarkOwner to the constructor, the
      * openBookmark signal is not emitted, instead QDesktopServices::openUrl is used to open the bookmark.
      * @param parentMenu menu to be filled
      * @param collec parent collection for the KActions.
      *
      * @todo KDE 5: give ownership of the bookmarkmenu to another qobject, e.g. parentMenu.
      * Currently this is a QObject without a parent, use setParent to benefit from automatic deletion.
      *
      * @deprecated since 5.69. Use overload without KActionCollection and add actions manually to your actioncollection if desired.
      * @code
      * KBookmarkMenu *menu = new KBookmarkMenu(manager, owner, parentMenu);
      *
      * QAction *addAction = menu->addBookmarkAction();
      * actionCollection()->addAction(addAction->objectName(), addAction);
      *
      * QAction *bookmarkTabsAction = menu->bookmarkTabsAsFolderAction();
      * actionCollection()->addAction(bookmarkTabsAction->objectName(), bookmarkTabsAction);
      *
      * QAction *editAction = menu->editBookmarksAction();
      * actionCollection()->addAction(editAction->objectName(), editAction);
      * @endcode
      *
      * Alternatively you can get a list of the actions from @p parentMenu, and add them to your
      * actionCollection:
      * @code
      * KBookmarkMenu *menu = new KBookmarkMenu(manager, owner, parentMenu);
      * actionCollection()->addActions(parentMenu->actions());
      * @endcode
      *
      * Note that adding the actions to your KActionCollection will make them show up in the shortcuts editor
      * dialog.
      *
      */
     KBOOKMARKS_DEPRECATED_VERSION(5, 69, "Use overload without KActionCollection and add actions manually to your actionCollection if desired")
     KBookmarkMenu(KBookmarkManager *mgr, KBookmarkOwner *owner, QMenu *parentMenu, KActionCollection *collec);
 #endif
 
     /**
      * Fills a bookmark menu
      * (one instance of KBookmarkMenu is created for the toplevel menu,
      *  but also one per submenu).
      *
      * @param manager the bookmark manager to use (i.e. for reading and writing)
      * @param owner implementation of the KBookmarkOwner callback interface.
      * @note If you pass a null KBookmarkOwner to the constructor, the
      * openBookmark signal is not emitted, instead QDesktopServices::openUrl is used to open the bookmark.
      * @param parentMenu menu to be filled
      * @since 5.69
      */
     KBookmarkMenu(KBookmarkManager *manager, KBookmarkOwner *owner, QMenu *parentMenu);
 
     /**
      * Creates a bookmark submenu
      *
      * @todo KF6: give ownership of the bookmarkmenu to another qobject, e.g. parentMenu.
      * Currently this is a QObject without a parent, use setParent to benefit from automatic deletion.
      */
     KBookmarkMenu(KBookmarkManager *mgr, KBookmarkOwner *owner,
                   QMenu *parentMenu, const QString &parentAddress);
 
     ~KBookmarkMenu();
 
     /**
      * Call ensureUpToDate() if you need KBookmarkMenu to adjust to its
      * final size before it is executed.
      **/
     void ensureUpToDate();
 
     /**
      * @brief Sets the number of currently open tabs
      * @param numberOfOpenTabs The number of currently open tabs
      * @see numberOfOpenTabs()
      * @since 5.58
      */
     void setNumberOfOpenTabs(int numberOfOpenTabs);
     /**
      * This function returns how many (if any) tabs the application has open.
      * This is used to determine if the Add a folder for all open
      * tabs should be added to the menu, so if the application has more than
      * one tab open, then the menu will be added.
      * Default returns @c 2.
      * @since 5.58
      */
     int numberOfOpenTabs() const;
 
     /**
      * Returns the action for adding a bookmark. If you are using KXmlGui, you can add it to your
      * action collection.
      * @code
      * KBookmarkMenu *menu = new KBookmarkMenu(manager, owner, parentMenu);
      * QAction *addAction = menu->addBookmarkAction();
      * actionCollection()->addAction(addAction->objectName(), addAction);
      * @endcode
      * @return the action for adding a bookmark.
      * @since 5.69
      */
     QAction *addBookmarkAction() const;
 
     /**
      * Returns the action for adding all current tabs as bookmarks. If you are using KXmlGui, you can
      * add it to your action collection.
      * @code
      * KBookmarkMenu *menu = new KBookmarkMenu(manager, owner, parentMenu);
      * QAction *bookmarkTabsAction = menu->bookmarkTabsAsFolderAction();
      * actionCollection()->addAction(bookmarkTabsAction->objectName(), bookmarkTabsAction);
      * @endcode
      * @return the action for adding all current tabs as bookmarks.
      * @since 5.69
      */
     QAction *bookmarkTabsAsFolderAction() const;
 
     /**
      * Returns the action for adding a new bookmarks folder. If you are using KXmlGui, you can add it
      * to your action collection.
      * @code
      * KBookmarkMenu *menu = new KBookmarkMenu(manager, owner, parentMenu);
      * QAction *newBookmarkFolderAction = menu->bookmarkTabsAsFolderAction();
      * actionCollection()->addAction(newBookmarkFolderAction->objectName(), newBookmarkFolderAction);
      * @endcode
      * @return the action for adding a new bookmarks folder
      * @since 5.70
      */
     QAction *newBookmarkFolderAction() const;
 
     /**
      * Returns the action for editing bookmarks.  If you are using KXmlGui, you can add it to your
      * action collection.
      * @code
      * KBookmarkMenu *menu = new KBookmarkMenu(manager, owner, parentMenu);
      * QAction *editAction = menu->editBookmarksAction();
      * actionCollection()->addAction(editAction->objectName(), editAction);
      * @endcode
      * @return the action for editing bookmarks.
      * @since 5.69
      */
     QAction *editBookmarksAction() const;
 
 public Q_SLOTS:
     // public for KonqBookmarkBar
     void slotBookmarksChanged(const QString &);
 
 protected Q_SLOTS:
     void slotAboutToShow();
     void slotAddBookmarksList();
     void slotAddBookmark();
     void slotNewFolder();
     void slotOpenFolderInTabs();
 
 protected:
     virtual void clear();
     virtual void refill();
     virtual QAction *actionForBookmark(const KBookmark &bm);
     virtual QMenu *contextMenu(QAction *action);
 
     void addActions();
     void fillBookmarks();
     void addAddBookmark();
     void addAddBookmarksList();
     void addEditBookmarks();
     void addNewFolder();
     void addOpenInTabs();
 
     bool isRoot() const;
     bool isDirty() const;
 
     /**
      * Parent bookmark for this menu.
      */
     QString parentAddress() const;
 
     KBookmarkManager *manager() const;
     KBookmarkOwner *owner() const;
     /**
      * The menu in which we insert our actions
      * Supplied in the constructor.
      */
     QMenu *parentMenu() const;
 
     /**
      * List of our sub menus
      */
     QList<KBookmarkMenu *> m_lstSubMenus;
 
     // This is used to "export" our actions into an actionlist
     // we got in the constructor. So that the program can show our
     // actions in their shortcut dialog
     KActionCollection *m_actionCollection;
     /**
      * List of our actions.
      */
     QList<QAction *> m_actions;
 
 private Q_SLOTS:
     void slotCustomContextMenu(const QPoint &);
 
 private:
+    void init();
+
     KBookmarkMenuPrivate *d;
 
     bool m_bIsRoot;
     bool m_bDirty;
     KBookmarkManager *m_pManager;
     KBookmarkOwner *m_pOwner;
     QMenu *m_parentMenu;
     QString m_parentAddress;
 };
 
 #endif