modelmenu.cpp Example File | Qt WebEngine 5.9

Qt 5.9 | Qt WebEngine | WebEngine Demo Browser Example | modelmenu.cpp Example File

Qt 5.9.9 Reference Documentation

# modelmenu.cpp Example File

webenginewidgets/demobrowser/modelmenu.cpp

      /****************************************************************************
      **
      ** Copyright (C) 2016 The Qt Company Ltd.
      ** Contact: https://www.qt.io/licensing/
      **
      ** This file is part of the examples of the Qt Toolkit.
      **
      ** $QT_BEGIN_LICENSE:BSD$
      ** Commercial License Usage
      ** Licensees holding valid commercial Qt licenses may use this file in
      ** accordance with the commercial license agreement provided with the
      ** Software or, alternatively, in accordance with the terms contained in
      ** a written agreement between you and The Qt Company. For licensing terms
      ** and conditions see https://www.qt.io/terms-conditions. For further
      ** information use the contact form at https://www.qt.io/contact-us.
      **
      ** BSD License Usage
      ** Alternatively, you may use this file under the terms of the BSD license
      ** as follows:
      **
      ** "Redistribution and use in source and binary forms, with or without
      ** modification, are permitted provided that the following conditions are
      ** met:
      **   * Redistributions of source code must retain the above copyright
      **     notice, this list of conditions and the following disclaimer.
      **   * Redistributions in binary form must reproduce the above copyright
      **     notice, this list of conditions and the following disclaimer in
      **     the documentation and/or other materials provided with the
      **     distribution.
      **   * Neither the name of The Qt Company Ltd nor the names of its
      **     contributors may be used to endorse or promote products derived
      **     from this software without specific prior written permission.
      **
      **
      ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
      ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
      ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
      ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
      ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
      ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
      **
      ** $QT_END_LICENSE$
      **
      ****************************************************************************/

      #include "modelmenu.h"

      #include <QtCore/QAbstractItemModel>
      #include <qdebug.h>

      ModelMenu::ModelMenu(QWidget * parent)
          : QMenu(parent)
          , m_maxRows(7)
          , m_firstSeparator(-1)
          , m_maxWidth(-1)
          , m_hoverRole(0)
          , m_separatorRole(0)
          , m_model(0)
      {
          connect(this, SIGNAL(aboutToShow()), this, SLOT(aboutToShow()));
      }

      bool ModelMenu::prePopulated()
      {
          return false;
      }

      void ModelMenu::postPopulated()
      {
      }

      void ModelMenu::setModel(QAbstractItemModel *model)
      {
          m_model = model;
      }

      QAbstractItemModel *ModelMenu::model() const
      {
          return m_model;
      }

      void ModelMenu::setMaxRows(int max)
      {
          m_maxRows = max;
      }

      int ModelMenu::maxRows() const
      {
          return m_maxRows;
      }

      void ModelMenu::setFirstSeparator(int offset)
      {
          m_firstSeparator = offset;
      }

      int ModelMenu::firstSeparator() const
      {
          return m_firstSeparator;
      }

      void ModelMenu::setRootIndex(const QModelIndex &index)
      {
          m_root = index;
      }

      QModelIndex ModelMenu::rootIndex() const
      {
          return m_root;
      }

      void ModelMenu::setHoverRole(int role)
      {
          m_hoverRole = role;
      }

      int ModelMenu::hoverRole() const
      {
          return m_hoverRole;
      }

      void ModelMenu::setSeparatorRole(int role)
      {
          m_separatorRole = role;
      }

      int ModelMenu::separatorRole() const
      {
          return m_separatorRole;
      }

      Q_DECLARE_METATYPE(QModelIndex)
      void ModelMenu::aboutToShow()
      {
          if (QMenu *menu = qobject_cast<QMenu*>(sender())) {
              QVariant v = menu->menuAction()->data();
              if (v.canConvert<QModelIndex>()) {
                  QModelIndex idx = qvariant_cast<QModelIndex>(v);
                  createMenu(idx, -1, menu, menu);
                  disconnect(menu, SIGNAL(aboutToShow()), this, SLOT(aboutToShow()));
                  return;
              }
          }

          clear();
          if (prePopulated())
              addSeparator();
          int max = m_maxRows;
          if (max != -1)
              max += m_firstSeparator;
          createMenu(m_root, max, this, this);
          postPopulated();
      }

      void ModelMenu::createMenu(const QModelIndex &parent, int max, QMenu *parentMenu, QMenu *menu)
      {
          if (!menu) {
              QString title = parent.data().toString();
              menu = new QMenu(title, this);
              QIcon icon = qvariant_cast<QIcon>(parent.data(Qt::DecorationRole));
              menu->setIcon(icon);
              parentMenu->addMenu(menu);
              QVariant v;
              v.setValue(parent);
              menu->menuAction()->setData(v);
              connect(menu, SIGNAL(aboutToShow()), this, SLOT(aboutToShow()));
              return;
          }

          int end = m_model->rowCount(parent);
          if (max != -1)
              end = qMin(max, end);

          connect(menu, SIGNAL(triggered(QAction*)), this, SLOT(triggered(QAction*)));
          connect(menu, SIGNAL(hovered(QAction*)), this, SLOT(hovered(QAction*)));

          for (int i = 0; i < end; ++i) {
              QModelIndex idx = m_model->index(i, 0, parent);
              if (m_model->hasChildren(idx)) {
                  createMenu(idx, -1, menu);
              } else {
                  if (m_separatorRole != 0
                      && idx.data(m_separatorRole).toBool())
                      addSeparator();
                  else
                      menu->addAction(makeAction(idx));
              }
              if (menu == this && i == m_firstSeparator - 1)
                  addSeparator();
          }
      }

      QAction *ModelMenu::makeAction(const QModelIndex &index)
      {
          QIcon icon = qvariant_cast<QIcon>(index.data(Qt::DecorationRole));
          QAction *action = makeAction(icon, index.data().toString(), this);
          QVariant v;
          v.setValue(index);
          action->setData(v);
          return action;
      }

      QAction *ModelMenu::makeAction(const QIcon &icon, const QString &text, QObject *parent)
      {
          QFontMetrics fm(font());
          if (-1 == m_maxWidth)
              m_maxWidth = fm.width(QLatin1Char('m')) * 30;
          QString smallText = fm.elidedText(text, Qt::ElideMiddle, m_maxWidth);
          return new QAction(icon, smallText, parent);
      }

      void ModelMenu::triggered(QAction *action)
      {
          QVariant v = action->data();
          if (v.canConvert<QModelIndex>()) {
              QModelIndex idx = qvariant_cast<QModelIndex>(v);
              emit activated(idx);
          }
      }

      void ModelMenu::hovered(QAction *action)
      {
          QVariant v = action->data();
          if (v.canConvert<QModelIndex>()) {
              QModelIndex idx = qvariant_cast<QModelIndex>(v);
              QString hoveredString = idx.data(m_hoverRole).toString();
              if (!hoveredString.isEmpty())
                  emit hovered(hoveredString);
          }
      }