ScrollableMessageBox.cpp

Go to the documentation of this file.

/*
  ScrollableMessageBox

  COPYRIGHT: (c)2017 Maxim Paperno; All Right Reserved.
  Contact: http://www.WorldDesign.com/contact

  LICENSE:

  Commercial License Usage
  Licensees holding valid commercial licenses may use this file in
  accordance with the terms contained in a written agreement between
  you and the copyright holder.

  GNU General Public License Usage
  Alternatively, this file may be used under the terms of the GNU
  General Public License as published by the Free Software Foundation,
  either version 3 of the License, or (at your option) any later version.

  This program 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 General Public License for more details.

  A copy of the GNU General Public License is available at <http://www.gnu.org/licenses/>.
*/

#include "ScrollableMessageBox.h"

#include <QApplication>
#include <QBoxLayout>
#include <QScreen>
#include <QScrollBar>
#include <QStyle>
#include <QStyleOptionButton>
#include <QWindow>

class TextEdit : public QTextEdit
{
  public:
    using QTextEdit::QTextEdit;
    QSize sizeHint() const override
    {
      // stupid trick to get an idea of necessary size to contain all the text, works for html and plain
      QLabel tmp;
      tmp.setFont(font());
      tmp.setText(toHtml());
      tmp.setWordWrap(wordWrapMode() != QTextOption::NoWrap);
      return tmp.sizeHint() + QSize(verticalScrollBar()->sizeHint().width(), horizontalScrollBar()->sizeHint().height());
    }
};


// This is a close copy of the DetailsButton from QMessageBox code and uses the same translation strings for the button text.
class DetailButton : public QPushButton
{
  public:
    DetailButton(QWidget *parent) : QPushButton(label(false), parent)
    {
      setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
      setCheckable(true);
      connect(this, &QPushButton::toggled, [this](bool on) {
        setText(label(on));
      });
    }

    inline static const QString label(bool on)
    {
      return on ? QMessageBox::tr("Hide Details...") : QMessageBox::tr("Show Details...");
    }

    QSize sizeHint() const override
    {
      ensurePolished();
      QStyleOptionButton opt;
      initStyleOption(&opt);
      const QFontMetrics fm = fontMetrics();
      opt.text = label(false);
      QSize sz = fm.size(Qt::TextShowMnemonic, opt.text);
      QSize ret = style()->sizeFromContents(QStyle::CT_PushButton, &opt, sz, this);
      opt.text = label(true);
      sz = fm.size(Qt::TextShowMnemonic, opt.text);
      ret = ret.expandedTo(style()->sizeFromContents(QStyle::CT_PushButton, &opt, sz, this));
      return ret.expandedTo(QApplication::globalStrut());
    }
};


static QSize defaultIconSize(QWidget *w)
{
  const int extent = w->style()->pixelMetric(QStyle::PM_MessageBoxIconSize, nullptr, w);
  return QSize(extent, extent);
}

static QPixmap standardIcon(QMessageBox::Icon icon, QWidget *w, const QSize &size = QSize())
{
  QIcon tmpIcon;
  switch (icon) {
    case QMessageBox::Information:
      tmpIcon = w->style()->standardIcon(QStyle::SP_MessageBoxInformation, nullptr, w);
      break;
    case QMessageBox::Warning:
      tmpIcon = w->style()->standardIcon(QStyle::SP_MessageBoxWarning, nullptr, w);
      break;
    case QMessageBox::Critical:
      tmpIcon = w->style()->standardIcon(QStyle::SP_MessageBoxCritical, nullptr, w);
      break;
    case QMessageBox::Question:
      tmpIcon = w->style()->standardIcon(QStyle::SP_MessageBoxQuestion, nullptr, w);
      break;
    default:
      break;
  }
  if (tmpIcon.isNull())
    return QPixmap();
  return tmpIcon.pixmap(w->windowHandle(), (size.isEmpty() ? defaultIconSize(w) : size));
}

static Qt::WindowFlags defaultFlags() { return (Qt::WindowTitleHint | Qt::WindowSystemMenuHint | Qt::WindowCloseButtonHint); }


ScrollableMessageBox::ScrollableMessageBox(QWidget *parent, Qt::WindowFlags f) :
  QDialog(parent, f | defaultFlags())
{
  init();
}

ScrollableMessageBox::ScrollableMessageBox(const QString &title, const QString &text, const QString &details, QWidget *parent, Qt::WindowFlags f) :
  QDialog(parent, f | defaultFlags())
{
  init(title, text, details);
}

ScrollableMessageBox::ScrollableMessageBox(const QString &title, QMessageBox::Icon icon, const QString &text, const QString &details, QWidget *parent, Qt::WindowFlags f) :
  QDialog(parent, f | defaultFlags())
{
  init(title, text, details, icon);
}


ScrollableMessageBox::ScrollableMessageBox(QWidget *parent, const QString &title, const QString &text, const QString &details, int buttons, int defaultButtton, Qt::WindowFlags f) :
  QDialog(parent, f | defaultFlags())
{
  init(title, text, details, QMessageBox::NoIcon, buttons, defaultButtton);
}

ScrollableMessageBox::ScrollableMessageBox(QWidget *parent, const QString &title, QMessageBox::Icon icon, const QString &text, const QString &details, int buttons, int defaultButtton, Qt::WindowFlags f) :
  QDialog(parent, f | defaultFlags())
{
  init(title, text, details, icon, buttons, defaultButtton);
}

void ScrollableMessageBox::setText(const QString &text)
{
  if (!m_textLabel)
    return;
  m_textLabel->setText(text);
  updateSize();
}

void ScrollableMessageBox::setDetailedText(const QString &details, Qt::TextFormat format)
{
  if (!m_textEdit)
    return;
  const bool haveDeets = !details.isEmpty();
  if (format == Qt::PlainText || !haveDeets)
    m_textEdit->setPlainText(details);
  else if (format == Qt::RichText)
    m_textEdit->setHtml(details);
  else
    m_textEdit->setText(details);

  if (haveDeets || !showDetailsExpanded(false))
    updateSize();
}

QLabel *ScrollableMessageBox::promptLabel()
{
  if (!m_promptLabel) {
    m_promptLabel = new QLabel(this);
    const int idx = m_btnBox ? layout()->indexOf(m_btnBox) : layout()->count();
    qobject_cast<QVBoxLayout*>(layout())->insertWidget(idx, m_promptLabel, 0, Qt::AlignLeft | Qt::AlignBottom);
    updateSize();
  }
  return m_promptLabel.data();
}

void ScrollableMessageBox::setPromptText(const QString &text)
{
  if (text.isEmpty()) {
    if (m_promptLabel) {
      layout()->removeWidget(m_promptLabel);
      m_promptLabel->setParent(nullptr);
      m_promptLabel->deleteLater();
      m_promptLabel.clear();
      updateSize();
    }
    return;
  }
  promptLabel()->setText(text);
  updateSize();
}

void ScrollableMessageBox::setIcon(const QPixmap &pixmap)
{
  if (!m_iconLabel)
    return;
  m_iconLabel->setPixmap(pixmap);
  static_cast<QHBoxLayout*>(layout()->itemAt(0))->setSpacing(pixmap.isNull() ? 0 : 12);
  if (pixmap.isNull())
    setWindowIcon(QApplication::windowIcon());
  else
    setWindowIcon(QIcon(pixmap));
  updateSize();
}

void ScrollableMessageBox::setIcon(QMessageBox::Icon icon, const QSize &size)
{
  setIcon(standardIcon(icon, this, size));
}

void ScrollableMessageBox::setIcon(const QIcon &icon, const QSize &size)
{
  setIcon(icon.isNull() ? QPixmap() : icon.pixmap(size.isEmpty() ? defaultIconSize(this) : size));
}

void ScrollableMessageBox::setIconAlignment(Qt::AlignmentFlag valign)
{
  if (!m_iconLabel)
    return;
  static_cast<QHBoxLayout*>(layout()->itemAt(0))->setAlignment(m_iconLabel, Qt::AlignLeft | valign);
}

void ScrollableMessageBox::setFontFixedWidth(bool fixed)
{
  if (!m_textEdit)
    return;
  QFont newFont(m_textEdit->font());
  if (fixed) {
    newFont.setFamily("Courier");
    newFont.setStyleHint(QFont::TypeWriter);
  }
  else {
    newFont.setFamily("Helvetica");
    newFont.setStyleHint(QFont::SansSerif);
  }
#ifdef Q_OS_MACOS
  newFont.setPointSize(13);
  textEdit->setAttribute(Qt::WA_MacNormalSize);
#elif defined Q_OS_WIN
  newFont.setPointSize(10);
#endif
  m_textEdit->setFont(newFont);
}

void ScrollableMessageBox::setWordWrap(bool wrap)
{
  if (!m_textEdit)
    return;
  m_textEdit->setWordWrapMode(wrap ? QTextOption::WrapAtWordBoundaryOrAnywhere : QTextOption::NoWrap);
  updateSize();
}

void ScrollableMessageBox::setTextWordWrap(bool wrap)
{
  if (!m_textLabel)
    return;
  if (m_textLabel->wordWrap() == wrap)
    return;
  m_textLabel->setWordWrap(wrap);
  updateSize();
}

bool ScrollableMessageBox::detailsExpanded() const
{
  return m_textEdit && m_textEdit->isVisibleTo(this);
}

bool ScrollableMessageBox::showDetailsExpanded(bool on)
{
  if (!m_textEdit || detailsExpanded() == on)
    return false;
  m_textEdit->setVisible(on);
  QSizePolicy sp = m_textEdit->sizePolicy();
  sp.setVerticalPolicy(on ? QSizePolicy::Expanding : QSizePolicy::Ignored);
  //sp.setVerticalStretch(int(on));
  m_textEdit->setSizePolicy(sp);
  if (m_detailsBtn)
    m_detailsBtn->setChecked(on);
  updateSize();
  //adjustSize();
  if (isVisible())
    resize(width(), sizeHint().height());
  return true;
}

bool ScrollableMessageBox::toggleDetailsExpanded()
{
  if (!m_textEdit)
    return false;
  return showDetailsExpanded(!detailsExpanded());
}

bool ScrollableMessageBox::detailsButtonVisible() const
{
  return !m_detailsBtn.isNull();
}

void ScrollableMessageBox::setDetailsButtonVisible(bool visible, bool toggleDetails, bool toggleDetailPosition)
{
  if (!m_textEdit)
    visible = false;
  if (m_detailsBtn.isNull() != visible)
    return;
  if (visible) {
    m_detailsBtn = new DetailButton(this);
    m_detailsBtn->setChecked(!toggleDetails && detailsExpanded());
    m_btnBox->addButton(m_detailsBtn, QDialogButtonBox::ActionRole);
    connect(m_detailsBtn, &QPushButton::clicked, this, &ScrollableMessageBox::showDetailsExpanded);
  }
  else {
    disconnect(m_detailsBtn, &QPushButton::clicked, this, &ScrollableMessageBox::showDetailsExpanded);
    m_btnBox->removeButton(m_detailsBtn);
    m_detailsBtn->deleteLater();
    m_detailsBtn.clear();
  }
  m_updatesSuspended = true;
  if (toggleDetails)
    showDetailsExpanded(!visible);
  if (toggleDetailPosition)
    setShowDetailsBelowButtons(visible);
  m_updatesSuspended = false;
  updateSize();
}

void ScrollableMessageBox::setShowDetailsBelowButtons(bool on)
{
  if (!m_textEdit)
    return;
  QVBoxLayout *l = qobject_cast<QVBoxLayout *>(layout());
  int newIdx = on ? 2 : 1;
  if (on && m_promptLabel)
    ++newIdx;
  if (l->indexOf(m_textEdit) == newIdx)
    return;
  //const bool wasVisible = detailsExpanded();
  l->removeWidget(m_textEdit);
  l->insertWidget(newIdx, m_textEdit);
  //m_textEdit->setVisible(wasVisible);
  updateSize();
}

void ScrollableMessageBox::init(const QString &title, const QString &text, const QString &details, QMessageBox::Icon icon, int buttons, int defaultBtn)
{
  m_textLabel = new QLabel(this);
  m_textLabel->setTextInteractionFlags(Qt::TextInteractionFlags(style()->styleHint(QStyle::SH_MessageBox_TextInteractionFlags, nullptr, this)));
  m_textLabel->setAlignment(Qt::AlignLeft | Qt::AlignVCenter);
  m_textLabel->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
  m_textLabel->setOpenExternalLinks(true);
  //m_textLabel->setWordWrap(true);

  m_iconLabel = new QLabel(this);
  m_iconLabel->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);

  m_textEdit = new TextEdit(this);
  m_textEdit->setReadOnly(true);
  m_textEdit->setTextInteractionFlags(Qt::TextBrowserInteraction | Qt::TextSelectableByKeyboard);
  m_textEdit->setFocusPolicy(Qt::NoFocus);
  QSizePolicy sp(m_textEdit->sizePolicy());
  sp.setHorizontalPolicy(QSizePolicy::Expanding);
  sp.setVerticalPolicy(QSizePolicy::Expanding);
  sp.setVerticalStretch(1);
  m_textEdit->setSizePolicy(sp);

  m_btnBox = new QDialogButtonBox(QDialogButtonBox::StandardButtons(buttons & ~ShowDetails), this);
  m_btnBox->setCenterButtons(style()->styleHint(QStyle::SH_MessageBox_CenterButtons, nullptr, this));

  QHBoxLayout *labelLo = new QHBoxLayout();
  labelLo->setSpacing(0);
  labelLo->addWidget(m_iconLabel, 0, Qt::AlignLeft | Qt::AlignTop);
  labelLo->addWidget(m_textLabel, 1);

  QVBoxLayout *lo = new QVBoxLayout(this);
  lo->setSpacing(8);
  lo->addLayout(labelLo);
  lo->addWidget(m_textEdit, 1);
  lo->addWidget(m_btnBox);

  setSizeGripEnabled(true);
  setFontFixedWidth(false);
  setWordWrap(true);

  if (!title.isEmpty())
    setWindowTitle(title);
  if (!text.isEmpty())
    setText(text);
  if (icon != QMessageBox::NoIcon)
    setIcon(icon);
  setDetailedText(details);

  if (buttons & ShowDetails)
    setDetailsButtonVisible();

  if (defaultBtn != QDialogButtonBox::NoButton && (buttons & defaultBtn)) {
    if (defaultBtn == ShowDetails)
      m_detailsBtn->setDefault(true);
    else
      m_btnBox->button(QDialogButtonBox::StandardButton(defaultBtn))->setDefault(true);
  }

  connect(m_btnBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
  connect(m_btnBox, &QDialogButtonBox::rejected, this, &QDialog::reject);

  m_updatesSuspended = false;
  updateSize();
}

static inline int layoutMinWidth(QLayout *l)
{
  l->update();
  return l->totalMinimumSize().width();
}

// Calculate an a resonable minimum size for the dialog.
// Also prevents a warning from QWindowsWindow::setGeometry about window being too small on initial show.
// Some of this code is from QMessageBoxPrivate::updateSize()
void ScrollableMessageBox::updateSize()
{
  if (m_updatesSuspended)
    return;
  const QSize screenSz = windowHandle() ? windowHandle()->screen()->availableSize() : QApplication::screenAt(QCursor::pos())->size();
  const int maxWidth = screenSz.width() <= 1024 ? screenSz.width() : qMin(int(screenSz.width() * 0.66f), 1000);  // largest minimum width
  const int maxHeight = qMin(int(screenSz.height() * 0.66f), 750);  // largest minimum height

  int width = layoutMinWidth(layout());
  if (width > maxWidth && m_textLabel && !m_textLabel->wordWrap()) {
    m_textLabel->setWordWrap(true);
    width = layoutMinWidth(layout());
  }
  if (width > maxWidth && m_promptLabel) {
    m_promptLabel->setWordWrap(true);
    width = layoutMinWidth(layout());
  }
  width = qMax(QFontMetrics(QApplication::font("QMdiSubWindowTitleBar")).horizontalAdvance(windowTitle()) + 50, width);
  if (m_textEdit)
    width = qMax(m_textEdit->sizeHint().width(), width);

  const int height = (layout()->hasHeightForWidth() ? layout()->totalHeightForWidth(width) : layout()->totalMinimumSize().height());
  //if (m_textEdit && m_textLabel && m_textLabel->wordWrap() && !detailsExpanded())
  //  height -= layout()->spacing() * 3;

  const QSize minSize = QSize(maxWidth, maxHeight).boundedTo(QSize(width, height).expandedTo(QSize(200, 100)));  // 200x100 is minimum top-level widget size as per QWidget::adjustSize()
  setMinimumSize(minSize);
  QCoreApplication::removePostedEvents(this, QEvent::LayoutRequest);
}

void ScrollableMessageBox::showEvent(QShowEvent *e)
{
  updateSize();
  QDialog::showEvent(e);
  adjustSize();
}