StartScreen.hpp

#pragma once
#include <score/application/GUIApplicationContext.hpp>
#include <score/model/Skin.hpp>
#include <score/tools/ThreadPool.hpp>
#include <score/widgets/MessageBox.hpp>
#include <score/widgets/Pixmap.hpp>
 
#include <core/document/DefaultLibrary.hpp>
#include <core/document/DocumentTemplates.hpp>
#include <core/document/OnlineExamples.hpp>
#include <core/document/ProjectInfo.hpp>
#include <core/presenter/AboutWidget.hpp>
#include <core/view/QRecentFilesMenu.h>
 
#include <QApplication>
#include <QCloseEvent>
#include <QDate>
#include <QDesktopServices>
#include <QDir>
#include <QFileInfo>
#include <QFontMetrics>
#include <QLayout>
#include <QLineEdit>
#include <QHBoxLayout>
#include <QKeyEvent>
#include <QLabel>
#include <QListWidget>
#include <QMouseEvent>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QNetworkRequest>
#include <QPainter>
#include <QPainterPath>
#include <QPixmap>
#include <QLocale>
#include <QPlainTextEdit>
#include <QPointer>
#include <QMainWindow>
#include <QMenu>
#include <QMessageBox>
#include <QScreen>
#include <QScrollArea>
#include <QSettings>
#include <QStackedWidget>
#include <QTextLayout>
#include <QVBoxLayout>
#include <QVersionNumber>
 
#include <score_git_info.hpp>
 
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <memory>
#include <optional>
#include <vector>
#include <verdigris>
 
namespace score
{
namespace
{
template <typename OnSuccess, typename OnError>
class HTTPGet final : public QNetworkAccessManager
{
public:
  explicit HTTPGet(QUrl url, OnSuccess on_success, OnError on_error) noexcept
      : m_callback{std::move(on_success)}
      , m_error{std::move(on_error)}
  {
    connect(this, &QNetworkAccessManager::finished, this, [this](QNetworkReply* reply) {
      if(reply->error())
      {
        qDebug() << reply->errorString();
        m_error();
      }
      else
      {
        m_callback(reply->readAll());
      }
 
      reply->deleteLater();
      this->deleteLater();
    });
 
    QNetworkRequest req{std::move(url)};
    req.setRawHeader("User-Agent", "curl/7.35.0");
    req.setAttribute(QNetworkRequest::HttpPipeliningAllowedAttribute, true);
    req.setAttribute(
        QNetworkRequest::RedirectPolicyAttribute,
        QNetworkRequest::UserVerifiedRedirectPolicy);
    req.setAttribute(QNetworkRequest::Http2AllowedAttribute, true);
 
    auto reply = get(req);
    connect(reply, &QNetworkReply::redirected, reply, &QNetworkReply::redirectAllowed);
  }
 
private:
  OnSuccess m_callback;
  OnError m_error;
};
 
// Brand colors of the start screen. They match the splash artwork and the
// start screen icon set (see src/lib/resources/icons_svg/readme.md), and are
// deliberately independent from the editor skin.
namespace StartScreenColors
{
static const QColor Panel{
    0x21, 0x1f, 0x1f, 205}; // translucent: the artwork shows through
static const QColor Card{"#2b2929"};
static const QColor CardDark{"#161514"};
static const QColor Scrim{0x16, 0x15, 0x14, 232};
static const QColor Outline{"#3d3a3a"};
static const QColor Text{"#f0f0f0"};
static const QColor Muted{"#8a8a8a"};
static const QColor Hover{"#03C3DD"};
static const QColor Accent{"#f6a019"};
static const QColor Version{"#0092CF"};
}
 
// Crops an image to the given aspect and scales it to exactly `size`.
QPixmap coverPixmap(const QImage& img, QSize size)
{
  if(img.isNull())
    return {};
  QImage scaled
      = img.scaled(size, Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation);
  const QRect crop{
      (scaled.width() - size.width()) / 2, (scaled.height() - size.height()) / 2,
      size.width(), size.height()};
  return QPixmap::fromImage(scaled.copy(crop));
}
 
// Word-wrapped text, eliding the last line that fits.
void drawWrappedText(QPainter& p, const QRect& rect, const QString& text)
{
  const QFontMetrics fm{p.font()};
  const int lineSpacing = fm.lineSpacing();
  int y = rect.top();
 
  QTextLayout layout{text, p.font()};
  layout.beginLayout();
  for(;;)
  {
    QTextLine line = layout.createLine();
    if(!line.isValid())
      break;
    line.setLineWidth(rect.width());
 
    if(y + 2 * lineSpacing <= rect.bottom() + 1)
    {
      line.draw(&p, QPointF{qreal(rect.left()), qreal(y)});
      y += lineSpacing;
    }
    else
    {
      p.drawText(
          QRect{rect.left(), y, rect.width(), lineSpacing}, Qt::AlignLeft | Qt::AlignTop,
          fm.elidedText(text.mid(line.textStart()), Qt::ElideRight, rect.width()));
      break;
    }
  }
  layout.endLayout();
}
}
 
class InteractiveLabel : public QWidget
{
  W_OBJECT(InteractiveLabel)
 
public:
  InteractiveLabel(
      const QFont& font, const QString& text, const QString& url,
      QWidget* parent = nullptr);
 
  void setOpenExternalLink(bool val) { m_openExternalLink = val; }
  void setPixmaps(const QPixmap& pixmap, const QPixmap& pixmapOn);
 
  void disableInteractivity();
  void setActiveColor(const QColor& c);
  void setInactiveColor(const QColor& c);
  void setElideMode(Qt::TextElideMode mode) { m_elideMode = mode; }
  void setLeftPadding(int px) { m_leftPadding = px; }
  void setIconColumn(int px) { m_iconColumn = px; }
  void setItemHeight(int px);
 
  void setCheckable(bool b) { m_checkable = b; }
  void setCheckedBackground(const QColor& c) { m_checkedBackground = c; }
  void setChecked(bool b);
  bool isChecked() const noexcept { return m_checked; }
 
  void setText(const QString& text);
  const QString& text() const noexcept { return m_title; }
  const QString& url() const noexcept { return m_url; }
 
  void labelPressed(const QString& file) W_SIGNAL(labelPressed, file)
  void hovered(bool state) W_SIGNAL(hovered, state)
 
  QSize sizeHint() const override;
  QSize minimumSizeHint() const override;
 
protected:
  void paintEvent(QPaintEvent* event) override;
  void enterEvent(QEnterEvent* event) override;
  void leaveEvent(QEvent* event) override;
  void mousePressEvent(QMouseEvent* event) override;
  void mouseReleaseEvent(QMouseEvent* event) override;
 
private:
  bool highlighted() const noexcept { return m_checked || (m_interactive && m_hovered); }
  int iconWidth() const noexcept { return m_pixmap.isNull() ? 0 : m_iconColumn; }
 
  QFont m_font;
  QString m_title;
  QString m_url;
 
  QPixmap m_pixmap;
  QPixmap m_pixmapOn;
 
  QColor m_activeColor{StartScreenColors::Hover};
  QColor m_inactiveColor{StartScreenColors::Text};
  QColor m_checkedBackground;
 
  Qt::TextElideMode m_elideMode{Qt::ElideRight};
  int m_leftPadding{4};
  int m_iconColumn{34};
  int m_height{30};
 
  bool m_openExternalLink{};
  bool m_interactive{true};
  bool m_hovered{};
  bool m_pressed{};
  bool m_checkable{};
  bool m_checked{};
};
 
InteractiveLabel::InteractiveLabel(
    const QFont& font, const QString& title, const QString& url, QWidget* parent)
    : QWidget{parent}
    , m_font(font)
    , m_title(title)
    , m_url(url)
{
  setCursor(score::Skin::instance().CursorPointingHand);
  setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
  setFixedHeight(m_height);
}
 
void InteractiveLabel::setPixmaps(const QPixmap& pixmap, const QPixmap& pixmapOn)
{
  m_pixmap = pixmap;
  m_pixmapOn = pixmapOn;
  // Never let a big icon overflow the label
  const int h = std::max(
      int(m_pixmap.height() / m_pixmap.devicePixelRatio()),
      int(m_pixmapOn.height() / m_pixmapOn.devicePixelRatio()));
  if(h + 4 > m_height)
    setItemHeight(h + 4);
  updateGeometry();
}
 
void InteractiveLabel::setItemHeight(int px)
{
  m_height = px;
  setFixedHeight(px);
  updateGeometry();
}
 
void InteractiveLabel::disableInteractivity()
{
  m_interactive = false;
  setCursor(score::Skin::instance().CursorPointer);
  update();
}
 
void InteractiveLabel::setActiveColor(const QColor& c)
{
  m_activeColor = c;
  update();
}
 
void InteractiveLabel::setInactiveColor(const QColor& c)
{
  m_inactiveColor = c;
  update();
}
 
void InteractiveLabel::setChecked(bool b)
{
  if(m_checked == b)
    return;
  m_checked = b;
  update();
}
 
void InteractiveLabel::setText(const QString& text)
{
  m_title = text;
  updateGeometry();
  update();
}
 
QSize InteractiveLabel::sizeHint() const
{
  int w = m_leftPadding + iconWidth();
  if(!m_title.isEmpty())
    w += QFontMetrics{m_font}.horizontalAdvance(m_title) + 6;
  return {w, m_height};
}
 
QSize InteractiveLabel::minimumSizeHint() const
{
  // Allow the layout to squeeze us: the text gets elided.
  int w = m_leftPadding + iconWidth();
  if(!m_title.isEmpty())
    w += 40;
  return {w, m_height};
}
 
static QPixmap tintedPixmap(const QPixmap& source, const QColor& color)
{
  if(source.isNull())
    return source;
  static std::map<std::pair<qint64, QRgb>, QPixmap> cache;
  const auto key = std::make_pair(source.cacheKey(), color.rgba());
  if(auto it = cache.find(key); it != cache.end())
    return it->second;
 
  QPixmap res{source.size()};
  res.setDevicePixelRatio(source.devicePixelRatio());
  res.fill(Qt::transparent);
  {
    QPainter p{&res};
    p.drawPixmap(0, 0, source);
    p.setCompositionMode(QPainter::CompositionMode_SourceIn);
    p.fillRect(res.rect(), color);
  }
  return cache.emplace(key, res).first->second;
}
 
void InteractiveLabel::paintEvent(QPaintEvent* event)
{
  QPainter painter(this);
  painter.setRenderHint(QPainter::Antialiasing, true);
  painter.setRenderHint(QPainter::TextAntialiasing, true);
  painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
 
  const bool hl = highlighted();
 
  if(m_checked && m_checkedBackground.isValid())
  {
    painter.fillRect(rect(), m_checkedBackground);
    painter.fillRect(QRect{0, 0, 3, height()}, m_activeColor);
  }
 
  QRectF textRect = rect().adjusted(m_leftPadding, 0, -4, 0);
 
  // The icon always takes the color of the text, whatever the state
  const QColor color = hl ? m_activeColor : m_inactiveColor;
  const QPixmap pm = tintedPixmap(m_pixmap, color);
  if(!pm.isNull())
  {
    const qreal w = pm.width() / pm.devicePixelRatio();
    const qreal h = pm.height() / pm.devicePixelRatio();
    // Icons of different sizes share the same column, centered on the same axis
    painter.drawPixmap(
        QPointF{textRect.x() + (m_iconColumn - 8 - w) / 2., (height() - h) / 2.}, pm);
    textRect.setX(textRect.x() + m_iconColumn);
  }
 
  if(!m_title.isEmpty())
  {
    painter.setPen(QPen{color});
    painter.setFont(m_font);
    const QString txt
        = QFontMetrics{m_font}.elidedText(m_title, m_elideMode, int(textRect.width()));
    painter.drawText(textRect, Qt::AlignLeft | Qt::AlignVCenter, txt);
  }
}
 
void InteractiveLabel::enterEvent(QEnterEvent* event)
{
  m_hovered = true;
  if(m_interactive)
  {
    update();
    hovered(true);
  }
}
 
void InteractiveLabel::leaveEvent(QEvent* event)
{
  m_hovered = false;
  m_pressed = false;
  if(m_interactive)
  {
    update();
    hovered(false);
  }
}
 
void InteractiveLabel::mousePressEvent(QMouseEvent* event)
{
  if(!m_interactive || event->button() != Qt::LeftButton)
    return QWidget::mousePressEvent(event);
  m_pressed = true;
  event->accept();
}
 
void InteractiveLabel::mouseReleaseEvent(QMouseEvent* event)
{
  if(!m_pressed || event->button() != Qt::LeftButton)
    return QWidget::mouseReleaseEvent(event);
  m_pressed = false;
  event->accept();
 
  if(!rect().contains(event->pos()))
    return;
 
  if(m_checkable)
    setChecked(true);
 
  if(m_openExternalLink)
    QDesktopServices::openUrl(QUrl(m_url));
  else
    labelPressed(m_url);
}
 
class ThumbnailPopup final : public QWidget
{
public:
  static constexpr int Width = 264;
  static constexpr int ThumbHeight = 158;
  static constexpr int Margin = 6;
  static constexpr int DescriptionLines = 2;
 
  ThumbnailPopup(const QFont& titleFont, const QFont& subFont, QWidget* parent)
      : QWidget{parent}
      , m_titleFont{titleFont}
      , m_subFont{subFont}
  {
    setAttribute(Qt::WA_TransparentForMouseEvents);
    hide();
  }
 
  void setContent(
      const QImage& thumbnail, const QString& title, const QString& author,
      const QString& description, const QString& path)
  {
    m_thumbnail = coverPixmap(thumbnail, {Width - 2 * Margin, ThumbHeight});
    m_title = title;
    m_author = author;
    m_description = description.simplified();
    m_path = path;
 
    const QFontMetrics tm{m_titleFont}, sm{m_subFont};
    int h = 2 * Margin + tm.height();
    if(!m_thumbnail.isNull())
      h += ThumbHeight + Margin;
    if(!m_author.isEmpty())
      h += sm.height();
    if(!m_description.isEmpty())
      h += 4 + DescriptionLines * sm.lineSpacing();
    if(!m_path.isEmpty())
      h += 4 + sm.height();
    resize(Width, h);
    update();
  }
 
  void showFor(QWidget* anchor, const QRect& bounds)
  {
    const QRect a{anchor->mapTo(parentWidget(), QPoint{0, 0}), anchor->size()};
    int x = a.left() - width() - 12;
    if(x < bounds.left())
      x = a.right() + 12;
    if(x + width() > bounds.right())
      x = bounds.right() - width();
    int y = a.center().y() - height() / 2;
    y = std::clamp(y, bounds.top(), std::max(bounds.top(), bounds.bottom() - height()));
    move(x, y);
    raise();
    show();
  }
 
protected:
  void paintEvent(QPaintEvent*) override
  {
    QPainter p{this};
    p.setRenderHint(QPainter::Antialiasing, true);
    p.setRenderHint(QPainter::SmoothPixmapTransform, true);
 
    QPainterPath path;
    path.addRoundedRect(QRectF{rect()}.adjusted(0.5, 0.5, -0.5, -0.5), 4, 4);
    p.fillPath(path, StartScreenColors::CardDark);
    p.setPen(QPen{StartScreenColors::Outline});
    p.drawPath(path);
 
    const int textX = Margin + 2;
    const int textW = width() - 2 * Margin - 4;
    const QFontMetrics tm{m_titleFont}, sm{m_subFont};
    int y = Margin;
    if(!m_thumbnail.isNull())
    {
      p.drawPixmap(Margin, y, m_thumbnail);
      y += ThumbHeight + Margin;
    }
 
    p.setPen(StartScreenColors::Text);
    p.setFont(m_titleFont);
    p.drawText(
        QRect{textX, y, textW, tm.height()}, Qt::AlignLeft | Qt::AlignVCenter,
        tm.elidedText(m_title, Qt::ElideMiddle, textW));
    y += tm.height();
 
    p.setFont(m_subFont);
    if(!m_author.isEmpty())
    {
      p.setPen(StartScreenColors::Hover);
      p.drawText(
          QRect{textX, y, textW, sm.height()}, Qt::AlignLeft | Qt::AlignVCenter,
          sm.elidedText(m_author, Qt::ElideRight, textW));
      y += sm.height();
    }
    if(!m_description.isEmpty())
    {
      y += 4;
      p.setPen(StartScreenColors::Text);
      const QRect descRect{textX, y, textW, DescriptionLines * sm.lineSpacing()};
      p.save();
      p.setClipRect(descRect);
      p.drawText(
          descRect, Qt::AlignLeft | Qt::AlignTop | Qt::TextWordWrap, m_description);
      p.restore();
      y += descRect.height();
    }
    if(!m_path.isEmpty())
    {
      y += 4;
      p.setPen(StartScreenColors::Muted);
      p.drawText(
          QRect{textX, y, textW, sm.height()}, Qt::AlignLeft | Qt::AlignVCenter,
          sm.elidedText(m_path, Qt::ElideMiddle, textW));
    }
  }
 
private:
  QFont m_titleFont;
  QFont m_subFont;
  QPixmap m_thumbnail;
  QString m_title;
  QString m_author;
  QString m_description;
  QString m_path;
};
 
class CategoryDrawer final : public QWidget
{
public:
  CategoryDrawer(
      const QFont& font, const QString& title, int count, int depth, QWidget* parent)
      : QWidget{parent}
      , m_font{font}
      , m_title{title}
      , m_count{count}
      , m_depth{depth}
  {
    m_font.setCapitalization(depth == 0 ? QFont::AllUppercase : QFont::MixedCase);
    m_font.setBold(true);
 
    auto lay = new QVBoxLayout{this};
    lay->setContentsMargins(depth > 0 ? Step : 0, 0, 0, 0);
    lay->setSpacing(Gap);
 
    m_header = new QWidget{this};
    m_header->setFixedHeight(BandHeight);
    m_header->setCursor(score::Skin::instance().CursorPointingHand);
    m_header->installEventFilter(this);
    lay->addWidget(m_header);
 
    m_body = new QWidget{this};
    m_bodyLayout = new QVBoxLayout{m_body};
    m_bodyLayout->setContentsMargins(0, 0, 0, 0);
    m_bodyLayout->setSpacing(Gap);
    lay->addWidget(m_body);
  }
 
  QVBoxLayout* body() const noexcept { return m_bodyLayout; }
  QWidget* header() const noexcept { return m_header; }
 
  bool expanded() const noexcept { return m_expanded; }
  void setExpanded(bool e)
  {
    m_expanded = e;
    m_body->setVisible(e);
    m_header->update();
  }
 
  void setCount(int c)
  {
    m_count = c;
    m_header->update();
  }
 
  static constexpr int BandHeight = 24;
  static constexpr int Gap = 8;
  static constexpr int Step = 16;
 
protected:
  bool eventFilter(QObject* obj, QEvent* ev) override
  {
    if(obj != m_header)
      return QWidget::eventFilter(obj, ev);
 
    switch(ev->type())
    {
      case QEvent::Paint: {
        QPainter p{m_header};
        p.setRenderHint(QPainter::Antialiasing, true);
        const int w = m_header->width();
        const int h = m_header->height();
 
        p.setPen(Qt::NoPen);
        p.setBrush(m_depth == 0 ? StartScreenColors::Outline : StartScreenColors::Card);
        p.drawRoundedRect(QRectF{0, 0, qreal(w), qreal(h)}, 3, 3);
        if(m_depth == 0)
        {
          p.setBrush(StartScreenColors::Accent);
          p.drawRoundedRect(QRectF{0, 0, 3, qreal(h)}, 1.5, 1.5);
        }
 
        // A subsection's triangle sits under its section's title.
        const qreal cy = h / 2.;
        constexpr qreal tx = TextX - Step;
        QPainterPath tri;
        if(m_expanded)
        {
          tri.moveTo(tx - 5, cy - 3);
          tri.lineTo(tx + 5, cy - 3);
          tri.lineTo(tx, cy + 3);
        }
        else
        {
          tri.moveTo(tx - 3, cy - 5);
          tri.lineTo(tx + 3, cy);
          tri.lineTo(tx - 3, cy + 5);
        }
        tri.closeSubpath();
        p.fillPath(
            tri, m_hovered ? StartScreenColors::Hover : StartScreenColors::Muted);
 
        // Capitals and digits centred on the band.
        const QFontMetrics fm{m_font};
        const int baseline = (h + fm.capHeight()) / 2;
        const QString count = QString::number(m_count);
        const int countWidth = fm.horizontalAdvance(count);
        const QString title = fm.elidedText(
            m_title, Qt::ElideRight, std::max(0, w - TextX - CountGap - countWidth - 8));
 
        p.setFont(m_font);
        p.setPen(m_hovered ? StartScreenColors::Hover : StartScreenColors::Text);
        p.drawText(QPointF(TextX, baseline), title);
 
        QFont countFont = m_font;
        countFont.setBold(false);
        p.setFont(countFont);
        p.setPen(StartScreenColors::Muted);
        p.drawText(
            QPointF(TextX + fm.horizontalAdvance(title) + CountGap, baseline), count);
        return true;
      }
      case QEvent::Enter:
        m_hovered = true;
        m_header->update();
        return false;
      case QEvent::Leave:
        m_hovered = false;
        m_header->update();
        return false;
      // On press: a plain QWidget ignores it, and the release goes to the parent.
      case QEvent::MouseButtonPress:
        setExpanded(!m_expanded);
        return true;
      default:
        return QWidget::eventFilter(obj, ev);
    }
  }
 
private:
  static constexpr int TextX = 26;
  static constexpr int CountGap = 8;
 
  QFont m_font;
  QString m_title;
  int m_count{};
  int m_depth{};
  QWidget* m_header{};
  QWidget* m_body{};
  QVBoxLayout* m_bodyLayout{};
  bool m_expanded{true};
  bool m_hovered{};
};
 
class ExampleCard final : public QWidget
{
public:
  static constexpr int Width = 190;
  static constexpr int ThumbHeight = 119;
  static constexpr int Height = ThumbHeight + 66;
 
  ExampleCard(
      const QFont& titleFont, const QFont& subFont, const QString& title,
      const QString& subtitle, const QString& path, QWidget* parent)
      : QWidget{parent}
      , m_titleFont{titleFont}
      , m_subFont{subFont}
      , m_title{title}
      , m_subtitle{subtitle}
      , m_path{path}
  {
    setFixedSize(Width, Height);
    setCursor(score::Skin::instance().CursorPointingHand);
    setToolTip(QDir::toNativeSeparators(path));
  }
 
  const QString& path() const noexcept { return m_path; }
 
  void setDownloadSize(qint64 bytes)
  {
    setBadge(
        bytes > 0 ? QLocale{}.formattedDataSize(bytes) : QString{},
        StartScreenColors::Muted);
  }
 
  void setBadge(const QString& text, const QColor& color)
  {
    m_badge = text;
    m_badgeColor = color;
    update();
  }
  const QString& badge() const noexcept { return m_badge; }
 
  void setThumbnailImage(const QImage& img)
  {
    m_thumbnail = coverPixmap(img, {Width, ThumbHeight});
    update();
  }
 
  void setInfo(const ProjectInfo::Info& info)
  {
    if(!info.name.isEmpty())
      m_title = info.name;
    if(!info.author.isEmpty())
      m_subtitle = info.author;
    m_description = info.description.simplified();
    m_thumbnail = coverPixmap(info.thumbnail, {Width, ThumbHeight});
    QString tip = m_title;
    if(!info.author.isEmpty())
      tip += "\n" + info.author;
    if(!info.description.isEmpty())
      tip += "\n\n" + info.description;
    tip += "\n\n" + QDir::toNativeSeparators(m_path);
    setToolTip(tip);
    update();
  }
 
  void setKeywords(const QString& k) { m_keywords = k; }
 
  bool matches(const QStringList& words) const
  {
    for(const auto& w : words)
    {
      if(!m_title.contains(w, Qt::CaseInsensitive)
         && !m_subtitle.contains(w, Qt::CaseInsensitive)
         && !m_description.contains(w, Qt::CaseInsensitive)
         && !m_keywords.contains(w, Qt::CaseInsensitive)
         && !QFileInfo{m_path}.fileName().contains(w, Qt::CaseInsensitive))
        return false;
    }
    return true;
  }
 
  std::function<void(const QString& path, Qt::KeyboardModifiers mods)> onActivated;
  std::function<void(const QPoint& globalPos)> onContextMenu;
 
protected:
  void paintEvent(QPaintEvent*) override
  {
    QPainter p{this};
    p.setRenderHint(QPainter::Antialiasing, true);
    p.setRenderHint(QPainter::SmoothPixmapTransform, true);
 
    QPainterPath path;
    path.addRoundedRect(QRectF{rect()}.adjusted(0.5, 0.5, -0.5, -0.5), 4, 4);
    p.fillPath(path, StartScreenColors::Card);
 
    // Thumbnail area
    p.save();
    p.setClipPath(path);
    const QRect thumbRect{0, 0, Width, ThumbHeight};
    if(!m_thumbnail.isNull())
    {
      p.drawPixmap(thumbRect, m_thumbnail);
    }
    else
    {
      p.fillRect(thumbRect, StartScreenColors::CardDark);
      static const QPixmap placeholder
          = score::get_pixmap(":/icons/load_examples_off.png");
      const qreal w = placeholder.width() / placeholder.devicePixelRatio();
      const qreal h = placeholder.height() / placeholder.devicePixelRatio();
      p.setOpacity(0.35);
      p.drawPixmap(QPointF{(Width - w) / 2., (ThumbHeight - h) / 2.}, placeholder);
      p.setOpacity(1.);
    }
 
    if(!m_badge.isEmpty() && !m_hovered)
    {
      p.setFont(m_subFont);
      const QFontMetrics fm{m_subFont};
      const int w = fm.horizontalAdvance(m_badge) + 10;
      const QRect box{Width - w - 6, 6, w, fm.height() + 4};
      p.fillRect(box, StartScreenColors::Scrim);
      p.setPen(m_badgeColor);
      p.drawText(box, Qt::AlignCenter, m_badge);
    }
 
    if(m_hovered && !m_description.isEmpty())
    {
      p.fillRect(thumbRect, StartScreenColors::Scrim);
      p.setPen(StartScreenColors::Text);
      p.setFont(m_subFont);
      drawWrappedText(p, thumbRect.adjusted(8, 7, -8, -7), m_description);
    }
    p.restore();
 
    p.setPen(QPen{m_hovered ? StartScreenColors::Hover : StartScreenColors::Outline, 1});
    p.drawPath(path);
 
    const int textX = 8;
    const int textW = Width - 16;
    p.setPen(m_hovered ? StartScreenColors::Hover : StartScreenColors::Text);
    p.setFont(m_titleFont);
    const QFontMetrics tm{m_titleFont};
    p.drawText(
        QRect{textX, ThumbHeight + 6, textW, tm.height()},
        Qt::AlignLeft | Qt::AlignVCenter, tm.elidedText(m_title, Qt::ElideRight, textW));
 
    p.setPen(StartScreenColors::Muted);
    p.setFont(m_subFont);
    const QFontMetrics sm{m_subFont};
    p.drawText(
        QRect{textX, ThumbHeight + 6 + tm.height(), textW, sm.height()},
        Qt::AlignLeft | Qt::AlignVCenter,
        sm.elidedText(m_subtitle, Qt::ElideRight, textW));
 
    // Full path, so that the user knows which file is going to be opened
    p.setOpacity(0.7);
    p.drawText(
        QRect{textX, ThumbHeight + 8 + tm.height() + sm.height(), textW, sm.height()},
        Qt::AlignLeft | Qt::AlignVCenter,
        sm.elidedText(QDir::toNativeSeparators(m_path), Qt::ElideMiddle, textW));
    p.setOpacity(1.);
  }
 
  void enterEvent(QEnterEvent*) override
  {
    m_hovered = true;
    update();
  }
  void leaveEvent(QEvent*) override
  {
    m_hovered = false;
    m_pressed = false;
    update();
  }
  void mousePressEvent(QMouseEvent* e) override
  {
    if(e->button() == Qt::LeftButton)
    {
      m_pressed = true;
      e->accept();
    }
  }
  void mouseReleaseEvent(QMouseEvent* e) override
  {
    const bool activate
        = m_pressed && e->button() == Qt::LeftButton && rect().contains(e->pos());
    m_pressed = false;
    if(activate && onActivated)
      onActivated(m_path, e->modifiers());
  }
  void contextMenuEvent(QContextMenuEvent* e) override
  {
    if(!onContextMenu)
      return QWidget::contextMenuEvent(e);
    e->accept();
    onContextMenu(e->globalPos());
  }
 
private:
  QFont m_titleFont;
  QFont m_subFont;
  QString m_title;
  QString m_subtitle;
  QString m_description;
  QString m_keywords;
  QString m_badge;
  QColor m_badgeColor{StartScreenColors::Muted};
  QString m_path;
  QPixmap m_thumbnail;
  bool m_hovered{};
  bool m_pressed{};
};
 
class FilterEdit final : public QLineEdit
{
public:
  using QLineEdit::QLineEdit;
 
  QStringList words() const { return text().simplified().split(' ', Qt::SkipEmptyParts); }
 
protected:
  void keyPressEvent(QKeyEvent* e) override
  {
    if(e->key() == Qt::Key_Escape && !text().isEmpty())
    {
      clear();
      e->accept();
      return;
    }
    QLineEdit::keyPressEvent(e);
    if(e->key() == Qt::Key_Up || e->key() == Qt::Key_Down)
      e->accept();
  }
};
 
class CardFlowLayout final : public QLayout
{
public:
  explicit CardFlowLayout(QWidget* parent, int spacing)
      : QLayout{parent}
      , m_spacing{spacing}
  {
    setContentsMargins(0, 0, 0, 0);
  }
  ~CardFlowLayout() override
  {
    while(auto item = takeAt(0))
      delete item;
  }
 
  void addItem(QLayoutItem* item) override { m_items.push_back(item); }
  int count() const override { return int(m_items.size()); }
  QLayoutItem* itemAt(int i) const override
  {
    return i >= 0 && i < count() ? m_items[i] : nullptr;
  }
  QLayoutItem* takeAt(int i) override
  {
    if(i < 0 || i >= count())
      return nullptr;
    auto item = m_items[i];
    m_items.erase(m_items.begin() + i);
    return item;
  }
 
  Qt::Orientations expandingDirections() const override { return {}; }
  bool hasHeightForWidth() const override { return true; }
  int heightForWidth(int width) const override
  {
    return arrange(QRect{0, 0, width, 0}, false);
  }
  void setGeometry(const QRect& rect) override
  {
    QLayout::setGeometry(rect);
    arrange(rect, true);
  }
  QSize sizeHint() const override { return minimumSize(); }
  QSize minimumSize() const override
  {
    QSize size;
    for(auto* item : m_items)
      size = size.expandedTo(item->minimumSize());
    const auto m = contentsMargins();
    return size + QSize{m.left() + m.right(), m.top() + m.bottom()};
  }
 
private:
  int arrange(const QRect& rect, bool apply) const
  {
    const auto m = contentsMargins();
    const QRect area = rect.adjusted(m.left(), m.top(), -m.right(), -m.bottom());
    int x = area.x();
    int y = area.y();
    int rowHeight = 0;
    for(auto* item : m_items)
    {
      if(item->isEmpty())
        continue;
      const QSize size = item->sizeHint();
      if(x > area.x() && x + size.width() > area.x() + area.width())
      {
        x = area.x();
        y += rowHeight + m_spacing;
        rowHeight = 0;
      }
      if(apply)
        item->setGeometry(QRect{QPoint{x, y}, size});
      x += size.width() + m_spacing;
      rowHeight = std::max(rowHeight, size.height());
    }
    return y + rowHeight - rect.y() + m.bottom();
  }
 
  std::vector<QLayoutItem*> m_items;
  int m_spacing{};
};
 
class StartScreen : public QWidget
{
  W_OBJECT(StartScreen)
public:
  StartScreen(const QPointer<QRecentFilesMenu>& recentFiles, QWidget* parent = nullptr);
  ~StartScreen() override;
 
  void openNewDocument() W_SIGNAL(openNewDocument)
  void openFile(const QString& file) W_SIGNAL(openFile, file)
  void openTemplate(const QString& file) W_SIGNAL(openTemplate, file)
  void openFileDialog() W_SIGNAL(openFileDialog)
  void loadCrashedSession() W_SIGNAL(loadCrashedSession)
  void joinSession() W_SIGNAL(joinSession)
  void exitApp() W_SIGNAL(exitApp)
 
  void addLoadCrashedSession();
  void addJoinSession();
  void dismiss();
  void reopen();
 
  static constexpr int Width = 880;
  static constexpr int Height = 640;
  static constexpr int HeaderHeight = 220;
  static constexpr int NavWidth = 190;
  static constexpr int MaxRecentFiles = 8;
 
protected:
  void paintEvent(QPaintEvent* event) override;
  bool eventFilter(QObject* watched, QEvent* event) override;
  void keyPressEvent(QKeyEvent* event) override;
  void closeEvent(QCloseEvent* event) override;
  void showEvent(QShowEvent* event) override;
  void hideEvent(QHideEvent* event) override;
 
private:
  struct Link
  {
    QString text;
    QString url;
    QString icon; // base name in :/icons, without the _on / _off suffix
    QString tooltip;
  };
 
  QWidget* createHeader();
  QWidget* createNavigation();
  int addPage(const QString& name, const QString& icon, std::function<QWidget*()> make);
  QWidget* createHomePage(const QPointer<QRecentFilesMenu>& recentFiles);
  void refreshRecentFiles();
  QWidget* createTemplatesPage();
  QWidget* createAboutPage();
  QWidget* createExamplesPage(bool online);
  QWidget* createCardsPage(
      const QString& title, const QString& hint, const QString& emptyHint,
      const std::vector<DocumentTemplate>& docs,
      std::function<void(const QString&)> onActivated, const Link& more);
  QWidget* createLinksPage(const QString& title, const std::vector<Link>& links);
  struct ExampleEntry
  {
    QString name;
    QString category;    
    QString path;        
    const OnlineExample* online{};
  };
 
  QWidget* makeCardGrid(
      const std::vector<ExampleEntry>& docs, std::vector<ExampleCard*>& cards,
      QWidget* parent);
  std::vector<ExampleEntry> gatherExamples() const;
  void openOnlineExample(const OnlineExample& ex, bool direct, bool openPage);
  void showOnlineExampleMenu(const OnlineExample& ex, const QPoint& globalPos);
  void replaceLocalCopy(const OnlineExample& ex);
  std::set<QString> m_replaceAsked;
  void refreshExamplesPage();
  void refreshExamplesPage(int index, bool online);
  void requestThumbnail(const OnlineExample& ex, ExampleCard* card);
 
  int addPage(const QString& name, const QString& icon, QWidget* page);
  void setCurrentPage(int index);
 
  QLabel* makeSectionTitle(const QString& text, QWidget* parent);
  QLabel* makeHint(const QString& text, QWidget* parent);
  FilterEdit* makeTitleWithFilter(const QString& title, QVBoxLayout* lay, QWidget* page);
  InteractiveLabel* makeItem(
      const QString& text, const QString& icon, const QString& url, QWidget* parent);
  InteractiveLabel* makeAccentItem(
      const QString& text, const QString& icon, const QString& url, QWidget* parent);
  InteractiveLabel* makeExternalLink(const Link& link, QWidget* parent);
  InteractiveLabel* makeScoreItem(
      const QString& text, const QString& icon, const QString& path, bool asTemplate,
      QWidget* parent);
 
  // Wraps the emission of the choice signals: once the user chose something,
  // closing the window must not additionally open a new document.
  template <typename F>
  void choose(F&& emitSignal)
  {
    if(m_actionTaken)
      return;
    m_actionTaken = true;
    emitSignal();
  }
 
  void openExample(const QString& path, bool direct, bool openPage);
  void requestInfo(const QString& path);
  void requestInfo(const QString& path, ExampleCard& card);
  void onInfoLoaded(const QString& path, const std::optional<ProjectInfo::Info>& info);
  void showPreview(InteractiveLabel* label);
 
  void checkForNewVersion();
  void showUpdateAvailable(const QString& version);
 
  QWidget*
  makeLibraryNotice(QWidget* parent, const QMargins& margins, bool linksToTemplates);
  void updateLibraryNotices();
  void onLibraryChanged();
  void rebuildTemplatesPage();
 
  struct LibraryNotice
  {
    QPointer<QWidget> box;
    QPointer<QLabel> hint;
    QPointer<InteractiveLabel> action;
    bool linksToTemplates{};
  };
  std::vector<LibraryNotice> m_libraryNotices;
  DefaultLibrary::State m_libraryState{DefaultLibrary::State::Current};
  bool m_libraryInstalled{};
  bool m_libraryViewRegistered{};
 
  QFont m_navFont;
  QFont m_sectionFont;
  QFont m_itemFont;
  QFont m_smallFont;
  QFont m_versionFont;
 
  QPixmap m_background;
  QPixmap m_logo;
 
  QStackedWidget* m_pages{};
  std::vector<InteractiveLabel*> m_navItems;
  std::vector<std::function<QWidget*()>> m_pageFactories; 
  QVBoxLayout* m_navLayout{};
 
  InteractiveLabel* m_updateLabel{};
  InteractiveLabel* m_crashLabel{};
  InteractiveLabel* m_joinLabel{};
  QPointer<QRecentFilesMenu> m_recentFiles;
  QWidget* m_recentPage{};
  QVBoxLayout* m_recentList{};
  int m_templatesPage{};
  int m_examplesPage{};
  int m_onlineExamplesPage{};
  OnlineExamples m_online;
  ThumbnailPopup* m_preview{};
 
  std::map<QString, std::optional<ProjectInfo::Info>> m_infos;
  std::vector<ExampleCard*> m_cards;
 
  bool m_firstRun{};
  bool m_actionTaken{};
};
 
StartScreen::StartScreen(const QPointer<QRecentFilesMenu>& recentFiles, QWidget* parent)
    : QWidget(parent)
{
  auto& skin = score::Skin::instance();
  setCursor(skin.CursorPointer);
  setFocusPolicy(Qt::StrongFocus);
  setMinimumSize(Width, Height);
  // Covers the whole main window, and follows its size.
  if(parent)
  {
    parent->installEventFilter(this);
    setGeometry(parent->rect());
  }
 
  {
    QSettings s;
    m_firstRun = !s.value("score/StartScreenSeen", false).toBool();
    s.setValue("score/StartScreenSeen", true);
  }
 
  m_libraryState = DefaultLibrary::instance().state();
  connect(
      &DefaultLibrary::instance(), &DefaultLibrary::changed, this,
      &StartScreen::onLibraryChanged);
 
  // px, not pt: pt would shrink on macOS' 72 DPI.
  m_navFont = QFont("Montserrat");
  m_navFont.setPixelSize(16);
  m_navFont.setWeight(QFont::DemiBold);
  m_sectionFont = QFont("Montserrat");
  m_sectionFont.setPixelSize(13);
  m_sectionFont.setWeight(QFont::Medium);
  m_sectionFont.setCapitalization(QFont::AllUppercase);
  m_sectionFont.setLetterSpacing(QFont::PercentageSpacing, 108);
  m_itemFont = QFont("Ubuntu");
  m_itemFont.setPixelSize(16);
  m_itemFont.setHintingPreference(QFont::HintingPreference::PreferFullHinting);
  m_itemFont.setStyleStrategy(QFont::PreferAntialias);
  m_smallFont = QFont("Ubuntu");
  m_smallFont.setPixelSize(13);
  m_smallFont.setHintingPreference(QFont::HintingPreference::PreferFullHinting);
  m_smallFont.setStyleStrategy(QFont::PreferAntialias);
  m_versionFont = QFont("Ubuntu");
  m_versionFont.setPixelSize(19);
  m_versionFont.setWeight(QFont::Light);
  m_versionFont.setHintingPreference(QFont::HintingPreference::PreferFullHinting);
  m_versionFont.setStyleStrategy(QFont::PreferAntialias);
 
  m_background = score::get_pixmap(":/startscreen/startscreen-background.png");
  m_logo = score::get_pixmap(":/startscreen/startscreen-logo.png");
 
  auto mainLayout = new QVBoxLayout{this};
  mainLayout->setContentsMargins(0, 0, 0, 0);
  mainLayout->setSpacing(0);
 
  mainLayout->addWidget(createHeader());
 
  auto body = new QHBoxLayout;
  body->setContentsMargins(0, 0, 0, 0);
  body->setSpacing(0);
 
  m_pages = new QStackedWidget{this};
  body->addWidget(createNavigation());
  body->addWidget(m_pages, 1);
  mainLayout->addLayout(body, 1);
 
  addPage(tr("Home"), "home", createHomePage(recentFiles));
  m_templatesPage
      = addPage(tr("Templates"), "new_file", [this] { return createTemplatesPage(); });
  m_examplesPage = addPage(
      tr("Local examples"), "load_examples",
      [this] { return createExamplesPage(false); });
  m_onlineExamplesPage = addPage(
      tr("Online examples"), "net_session",
      [this] { return createExamplesPage(true); });
 
  m_online.loadCache();
  connect(&m_online, &OnlineExamples::updated, this, [this] {
    refreshExamplesPage();
  });
  m_online.refresh();
  addPage(
      tr("Learn"), "learn",
      createLinksPage(
          tr("Learn ossia score"),
          {{tr("Quick start guide"), "https://ossia.io/score-docs/quick-start.html",
            "version", tr("The recommended starting point if you are new to score")},
           {tr("Video tutorials"),
            "https://www.youtube.com/"
            "watch?v=R-3d8K6gQkw&list=PLIHLSiZpIa6YoY1_aW1yetDgZ7tZcxfEC",
            "tutorials",
            {}},
              {tr("Documentation"), "https://ossia.io/score-docs/", "learn", {}},
              {tr("Process reference"), "https://ossia.io/score-docs/processes.html", "learn", {}},
              {tr("Device reference"), "https://ossia.io/score-docs/devices.html", "learn", {}},
              {tr("Web version"), "https://ossia.io/score-web/", "tutorials", {}},
          }));
  addPage(
      tr("Community"), "community",
      createLinksPage(
          tr("Get involved"),
          {{tr("GitHub Discussions"), "https://github.com/ossia/score/discussions",
            "forum", tr("Ask questions and share what you do with score")},
           {tr("Discord Chat"), "https://discord.gg/8Hzm4UduaS", "chat", {}},
           {tr("Report a bug or suggest a feature"),
            "https://github.com/ossia/score/issues",
            "new_file",
            {}},
           {tr("Support ossia score through the Suite SAT"), "https://suite.sat.qc.ca/en",
            "contribute",
            tr("ossia score is free software: donations fund its development")},
           {tr("Donate on Open Collective"), "https://opencollective.com/ossia",
            "contribute", tr("ossia score is free software: donations fund its development")},
           {tr("Contributing"), "https://ossia.io/score-docs/development", "contribute",
               tr("Come implement your dream feature!")},
          }));
  addPage(tr("About"), "about", [this] { return createAboutPage(); });
 
  m_navLayout->addStretch();
 
#if !defined(__EMSCRIPTEN__)
  auto exitLabel = makeItem(tr("Exit"), "exit", "", this);
  exitLabel->setLeftPadding(20);
  exitLabel->setItemHeight(40);
  connect(exitLabel, &InteractiveLabel::labelPressed, this, [this] {
    choose([this] { exitApp(); });
  });
  m_navLayout->addWidget(exitLabel);
#endif
 
  // Created last so that it is above every page
  m_preview = new ThumbnailPopup{m_itemFont, m_smallFont, this};
 
  setCurrentPage(0);
  updateLibraryNotices();
 
  checkForNewVersion();
}
 
StartScreen::~StartScreen()
{
  if(std::exchange(m_libraryViewRegistered, false))
    DefaultLibrary::instance().removeView();
}
 
QWidget* StartScreen::createHeader()
{
  // The artwork itself is painted in paintEvent; this widget only hosts the
  // controls that sit on top of it.
  auto header = new QWidget{this};
  header->setFixedHeight(HeaderHeight);
  auto lay = new QHBoxLayout{header};
  lay->setContentsMargins(0, 10, 10, 0);
  lay->setSpacing(12);
  lay->addStretch();
 
  m_updateLabel = new InteractiveLabel{
      m_navFont, {}, "https://github.com/ossia/score/releases/latest/", header};
  m_updateLabel->setOpenExternalLink(true);
  m_updateLabel->setPixmaps(
      score::get_pixmap(":/icons/version_off.png"),
      score::get_pixmap(":/icons/version_on.png"));
  m_updateLabel->setInactiveColor(StartScreenColors::Accent);
  m_updateLabel->hide();
  lay->addWidget(m_updateLabel, 0, Qt::AlignTop);
 
  auto closeLabel = new InteractiveLabel{m_navFont, {}, "", header};
  closeLabel->setPixmaps(
      score::get_pixmap(":/icons/close_window_off.png"),
      score::get_pixmap(":/icons/close_window_on.png"));
  closeLabel->setLeftPadding(0);
  closeLabel->setIconColumn(32);
  closeLabel->setFixedWidth(32);
  closeLabel->setToolTip(tr("Close this window and start with an empty score"));
  connect(closeLabel, &InteractiveLabel::labelPressed, this, [this] {
    choose([this] { openNewDocument(); });
  });
  lay->addWidget(closeLabel, 0, Qt::AlignTop);
 
  return header;
}
 
QWidget* StartScreen::createNavigation()
{
  auto nav = new QWidget{this};
  nav->setFixedWidth(NavWidth);
  m_navLayout = new QVBoxLayout{nav};
  // The first entry starts exactly where the page panel starts
  m_navLayout->setContentsMargins(0, 0, 0, 16);
  m_navLayout->setSpacing(4);
  return nav;
}
 
int StartScreen::addPage(const QString& name, const QString& icon, QWidget* page)
{
  const int index = addPage(name, icon, std::function<QWidget*()>{});
  m_pages->widget(index)->layout()->addWidget(page);
  return index;
}
 
int StartScreen::addPage(
    const QString& name, const QString& icon, std::function<QWidget*()> make)
{
  // A host widget per page; the content is added to it now or on first display
  auto host = new QWidget;
  auto hostLayout = new QVBoxLayout{host};
  hostLayout->setContentsMargins(0, 0, 0, 0);
  const int index = m_pages->addWidget(host);
  m_pageFactories.resize(index + 1);
  m_pageFactories[index] = std::move(make);
 
  auto item = makeItem(name, icon, "", this);
  item->setCheckable(true);
  item->setCheckedBackground(StartScreenColors::Panel);
  item->setLeftPadding(20);
  item->setItemHeight(44);
  connect(item, &InteractiveLabel::labelPressed, this, [this, index] {
    setCurrentPage(index);
  });
 
  m_navItems.push_back(item);
  m_navLayout->addWidget(item);
  return index;
}
 
void StartScreen::setCurrentPage(int index)
{
  if(index >= 0 && index < int(m_pageFactories.size()))
  {
    if(auto make = std::exchange(m_pageFactories[index], {}))
      m_pages->widget(index)->layout()->addWidget(make());
  }
  m_pages->setCurrentIndex(index);
  for(int i = 0; i < int(m_navItems.size()); i++)
    m_navItems[i]->setChecked(i == index);
  if(m_preview)
    m_preview->hide();
}
 
QLabel* StartScreen::makeSectionTitle(const QString& text, QWidget* parent)
{
  auto label = new QLabel{text, parent};
  label->setFont(m_sectionFont);
  QPalette pal = label->palette();
  pal.setColor(QPalette::WindowText, StartScreenColors::Muted);
  label->setPalette(pal);
  return label;
}
 
QLabel* StartScreen::makeHint(const QString& text, QWidget* parent)
{
  auto hint = new QLabel{text, parent};
  hint->setFont(m_itemFont);
  hint->setWordWrap(true);
  QPalette pal = hint->palette();
  pal.setColor(QPalette::WindowText, StartScreenColors::Muted);
  hint->setPalette(pal);
  return hint;
}
 
FilterEdit*
StartScreen::makeTitleWithFilter(const QString& title, QVBoxLayout* lay, QWidget* page)
{
  auto row = new QHBoxLayout;
  row->setContentsMargins(0, 0, 8, 0);
  row->addWidget(makeSectionTitle(title, page));
  row->addStretch();
 
  auto filter = new FilterEdit{page};
  filter->setFont(m_smallFont);
  filter->setPlaceholderText(tr("Filter"));
  filter->setClearButtonEnabled(true);
  filter->setFixedWidth(220);
  row->addWidget(filter);
 
  lay->addLayout(row);
  return filter;
}
 
InteractiveLabel* StartScreen::makeItem(
    const QString& text, const QString& icon, const QString& url, QWidget* parent)
{
  auto label = new InteractiveLabel{m_itemFont, text, url, parent};
  if(!icon.isEmpty())
  {
    label->setPixmaps(
        score::get_pixmap(QString(":/icons/%1_off.png").arg(icon)),
        score::get_pixmap(QString(":/icons/%1_on.png").arg(icon)));
  }
  return label;
}
 
InteractiveLabel* StartScreen::makeAccentItem(
    const QString& text, const QString& icon, const QString& url, QWidget* parent)
{
  // Accent text at rest; hovering behaves like every other item
  auto label = makeItem(text, icon, url, parent);
  label->setInactiveColor(StartScreenColors::Accent);
  return label;
}
 
InteractiveLabel* StartScreen::makeExternalLink(const Link& link, QWidget* parent)
{
  auto label = makeItem(link.text, link.icon, link.url, parent);
  label->setOpenExternalLink(true);
  label->setToolTip(link.tooltip.isEmpty() ? link.url : link.tooltip);
  return label;
}
 
InteractiveLabel* StartScreen::makeScoreItem(
    const QString& text, const QString& icon, const QString& path, bool asTemplate,
    QWidget* parent)
{
  auto label = makeItem(text, icon, path, parent);
  label->setElideMode(Qt::ElideMiddle);
  if(asTemplate)
  {
    connect(label, &InteractiveLabel::labelPressed, this, [this](const QString& file) {
      choose([&] { openTemplate(file); });
    });
  }
  else
  {
    connect(label, &InteractiveLabel::labelPressed, this, [this](const QString& file) {
      choose([&] { openFile(file); });
    });
  }
  connect(label, &InteractiveLabel::hovered, this, [this, label](bool on) {
    if(on)
      showPreview(label);
    else
      m_preview->hide();
  });
 
  requestInfo(path);
  return label;
}
 
QWidget* StartScreen::createHomePage(const QPointer<QRecentFilesMenu>& recentFiles)
{
  auto page = new QWidget;
  auto lay = new QHBoxLayout{page};
  lay->setContentsMargins(28, 24, 28, 24);
  lay->setSpacing(32);
 
  const QString firstRunScore = firstRunDocumentTemplate();
 
  // Left column: create
  {
    auto col = new QVBoxLayout;
    col->setSpacing(6);
    col->addWidget(makeSectionTitle(tr("Start"), page));
 
    auto newLabel = makeItem(tr("New empty score"), "new_file", "", page);
    connect(newLabel, &InteractiveLabel::labelPressed, this, [this] {
      choose([this] { openNewDocument(); });
    });
    col->addWidget(newLabel);
 
    auto templatesLabel = makeItem(tr("Start from a template"), "new_file", "", page);
    connect(templatesLabel, &InteractiveLabel::labelPressed, this, [this] {
      setCurrentPage(m_templatesPage);
    });
    col->addWidget(templatesLabel);
 
    auto openLabel = makeItem(tr("Open a score file"), "load", "", page);
    connect(openLabel, &InteractiveLabel::labelPressed, this, [this] {
      choose([this] { openFileDialog(); });
    });
    col->addWidget(openLabel);
 
    m_joinLabel
        = makeItem(tr("Join a collaborative session..."), "net_session", "", page);
    m_joinLabel->setToolTip(tr("Connect to a score session hosted on another computer"));
    m_joinLabel->hide();
    connect(m_joinLabel, &InteractiveLabel::labelPressed, this, [this] {
      choose([this] { joinSession(); });
    });
    col->addWidget(m_joinLabel);
 
    col->addWidget(makeLibraryNotice(page, {0, 18, 0, 0}, true));
 
    col->addSpacing(18);
    col->addWidget(makeSectionTitle(tr("New to ossia score?"), page));
 
    if(!firstRunScore.isEmpty())
    {
      if(m_firstRun)
      {
        col->addWidget(makeHint(
            tr("Welcome! This guided score shows you around the interface and "
               "the main concepts in a few minutes."),
            page));
      }
      auto guided = makeAccentItem(
          tr("Open the demo project"), "version", firstRunScore, page);
      connect(guided, &InteractiveLabel::labelPressed, this, [this](const QString& f) {
        choose([&] { openTemplate(f); });
      });
      col->addWidget(guided);
 
      col->addWidget(makeExternalLink(
          {tr("Read the quick start guide"),
           "https://ossia.io/score-docs/quick-start.html",
           "version",
           {}},
          page));
    }
    else
    {
      col->addWidget(makeHint(
          tr("Start with the quick start guide: it walks you through the "
             "interface and your first score."),
          page));
      auto guide = makeAccentItem(
          tr("Read the quick start guide"), "version",
          "https://ossia.io/score-docs/quick-start.html", page);
      guide->setOpenExternalLink(true);
      col->addWidget(guide);
    }
 
    col->addStretch();
    lay->addLayout(col, 1);
  }
 
  // Right column: open
  {
    auto col = new QVBoxLayout;
    col->setSpacing(6);
    col->addWidget(makeSectionTitle(tr("Recent"), page));
 
    m_recentFiles = recentFiles;
    m_recentPage = page;
    m_recentList = new QVBoxLayout;
    m_recentList->setSpacing(6);
    col->addLayout(m_recentList);
    refreshRecentFiles();
 
    col->addSpacing(6);
 
    m_crashLabel = makeAccentItem(tr("Restore last session"), "reload_crash", "", page);
    m_crashLabel->setToolTip(
        tr("score did not exit cleanly last time: reopen the documents that were open"));
    m_crashLabel->hide();
    connect(m_crashLabel, &InteractiveLabel::labelPressed, this, [this] {
      choose([this] { loadCrashedSession(); });
    });
    col->addWidget(m_crashLabel);
 
    col->addStretch();
    lay->addLayout(col, 1);
  }
 
  return page;
}
 
void StartScreen::refreshRecentFiles()
{
  if(m_preview)
    m_preview->hide();
  // deleteLater: the entry that was clicked may still be on the stack.
  while(auto item = m_recentList->takeAt(0))
  {
    if(auto w = item->widget())
    {
      w->hide();
      w->deleteLater();
    }
    delete item;
  }
 
  int shown = 0;
  if(m_recentFiles)
  {
    for(const auto& action : m_recentFiles->actions())
    {
      if(shown++ >= MaxRecentFiles)
        break;
 
      // Read again: the file may have been saved with a new thumbnail since.
      const QString path = action->data().toString();
      if(auto it = m_infos.find(path); it != m_infos.end() && it->second)
        m_infos.erase(it);
      m_recentList->addWidget(makeScoreItem(
          QFileInfo{path}.fileName(), "load", path, false, m_recentPage));
    }
  }
 
  if(shown == 0)
  {
    auto none = makeItem(tr("No recent scores yet"), "", "", m_recentPage);
    none->disableInteractivity();
    none->setInactiveColor(StartScreenColors::Muted);
    m_recentList->addWidget(none);
  }
}
 
QWidget* StartScreen::createTemplatesPage()
{
  auto page = new QWidget;
  auto lay = new QVBoxLayout{page};
  lay->setContentsMargins(0, 0, 0, 0);
  lay->setSpacing(0);
 
  // Same side margins as the page below it.
  lay->addWidget(makeLibraryNotice(page, {28, 20, 28, 0}, false));
 
  lay->addWidget(createCardsPage(
      tr("Templates"),
      tr("A template opens as a new untitled score with devices, processes and a "
         "structure already in place."),
      tr("No templates are installed yet. Templates are .score files in the "
         "Templates folder of your user library (%1) or of an installed package.")
          .arg(QDir::toNativeSeparators(libraryRootPath())),
      availableDocumentTemplates(),
      [this](const QString& path) { choose([&] { openTemplate(path); }); },
      {tr("Learn how to write your own templates"),
       "https://ossia.io/score-docs/",
       "learn",
       {}}), 1);
 
  updateLibraryNotices();
  return page;
}
 
QWidget* StartScreen::createAboutPage()
{
  // Shared with Help > About
  score::AboutWidget::Style style;
  style.sectionFont = m_sectionFont;
  style.itemFont = m_itemFont;
  style.smallFont = m_smallFont;
  style.text = StartScreenColors::Text;
  style.muted = StartScreenColors::Muted;
  style.hover = StartScreenColors::Hover;
  style.version = StartScreenColors::Version;
  style.outline = StartScreenColors::Outline;
 
  auto page = new QWidget;
  auto lay = new QVBoxLayout{page};
  lay->setContentsMargins(28, 20, 28, 16);
  lay->addWidget(new score::AboutWidget{style, page});
  return page;
}
 
QWidget* StartScreen::createExamplesPage(bool online)
{
  std::vector<ExampleEntry> docs;
  for(auto& doc : gatherExamples())
    if((doc.online != nullptr) == online)
      docs.push_back(std::move(doc));
 
  const QString title = online ? tr("Online examples") : tr("Local examples");
  if(docs.empty())
  {
    return createCardsPage(
        title, {},
        online
            ? tr("The examples of the documentation site show here once their list "
                 "has been downloaded. Check your internet connection.")
            : tr("No example scores are installed yet. Examples are .score files in "
                 "the Examples folder of your user library (%1) or of an installed "
                 "package.")
                  .arg(QDir::toNativeSeparators(libraryRootPath())),
        {}, {},
        {tr("More examples online"),
         "https://ossia.io/score-docs/examples",
         "load_examples",
         {}});
  }
 
  auto page = new QWidget;
  auto lay = new QVBoxLayout{page};
  lay->setContentsMargins(28, 24, 28, 16);
  lay->setSpacing(8);
  auto filter = makeTitleWithFilter(title, lay, page);
  lay->addWidget(makeHint(
      online ? tr("Each example is downloaded into your library the first time it "
                  "is opened, then opens as a new, untitled score. Ctrl-click opens "
                  "the example file itself, Alt-click does not open its web page.")
             : tr("Each example opens as a new, untitled score. Ctrl-click opens the "
                  "example file itself, Alt-click does not open its web page."),
      page));
  auto noMatch = makeHint(tr("Nothing matches this filter."), page);
  noMatch->hide();
  lay->addWidget(noMatch);
 
  auto scroll = new QScrollArea{page};
  scroll->setFrameShape(QFrame::NoFrame);
  scroll->setWidgetResizable(true);
  scroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
  scroll->viewport()->setAutoFillBackground(false);
 
  auto container = new QWidget;
  container->setAutoFillBackground(false);
  auto containerLay = new QVBoxLayout{container};
  // Bands reach the scroll bar; the first one is a row's gap from the top.
  containerLay->setContentsMargins(
      0, CategoryDrawer::Gap, 0, CategoryDrawer::Gap);
  containerLay->setSpacing(CategoryDrawer::Gap);
 
  // Two levels at most; anything deeper folds into its parent.
  std::map<QString, std::map<QString, std::vector<ExampleEntry>>> tree;
  for(const auto& doc : docs)
  {
    auto parts = doc.category.split('/', Qt::SkipEmptyParts);
    for(auto& p : parts)
      p = p.trimmed();
    const QString top = parts.empty() ? tr("Uncategorized") : parts.front();
    const QString sub = parts.size() > 1 ? parts[1] : QString{};
    tree[top][sub].push_back(doc);
  }
 
  struct Drawer
  {
    CategoryDrawer* drawer{};
    std::vector<ExampleCard*> cards;
    bool expanded{}; 
  };
  auto drawers = std::make_shared<std::vector<Drawer>>();
  auto cards = std::make_shared<std::vector<ExampleCard*>>();
 
  // Every drawer starts open.
  for(const auto& [top, subs] : tree)
  {
    int total = 0;
    for(const auto& [sub, list] : subs)
      total += list.size();
 
    auto drawer = new CategoryDrawer{m_sectionFont, top, total, 0, container};
    containerLay->addWidget(drawer);
    const auto topCards = cards->size();
 
    for(const auto& [sub, list] : subs)
    {
      if(sub.isEmpty())
      {
        drawer->body()->addWidget(makeCardGrid(list, *cards, drawer));
      }
      else
      {
        auto inner
            = new CategoryDrawer{m_itemFont, sub, int(list.size()), 1, drawer};
        const auto innerCards = cards->size();
        inner->body()->addWidget(makeCardGrid(list, *cards, inner));
        drawer->body()->addWidget(inner);
        drawers->push_back({inner, {cards->begin() + innerCards, cards->end()}});
      }
    }
    drawers->push_back({drawer, {cards->begin() + topCards, cards->end()}});
  }
 
  // While filtering, every drawer with a match is open; clearing the filter
  // puts back the drawers the user had opened.
  connect(
      filter, &QLineEdit::textChanged, container,
      [filter, noMatch, drawers, cards, filtering = false]() mutable {
    const auto words = filter->words();
    if(!words.empty() && !filtering)
      for(auto& d : *drawers)
        d.expanded = d.drawer->expanded();
 
    for(auto card : *cards)
      card->setVisible(card->matches(words));
 
    bool any = false;
    for(auto& d : *drawers)
    {
      const int count = std::count_if(
          d.cards.begin(), d.cards.end(), [](auto* c) { return !c->isHidden(); });
      d.drawer->setCount(count);
      d.drawer->setVisible(count > 0);
      if(!words.empty())
        d.drawer->setExpanded(count > 0);
      else if(filtering)
        d.drawer->setExpanded(d.expanded);
      any |= count > 0;
    }
 
    filtering = !words.empty();
    noMatch->setVisible(!any);
  });
 
  containerLay->addStretch();
  scroll->setWidget(container);
  lay->addWidget(scroll, 1);
 
  lay->addWidget(makeExternalLink(
      {tr("More examples online"), "https://ossia.io/score-docs/examples",
       "load_examples", {}},
      page));
  return page;
}
 
std::vector<StartScreen::ExampleEntry> StartScreen::gatherExamples() const
{
  std::vector<ExampleEntry> out;
 
  for(const auto& doc : availableExampleDocuments())
    out.push_back({doc.name, doc.category, doc.path, nullptr});
 
  // A downloaded example is listed on both pages: online, its entry tells that
  // there is a copy, and whether the online version changed since.
  for(const auto& ex : m_online.examples())
  {
    QString category = ex.section;
    if(!ex.group.isEmpty())
      category += " / " + ex.group;
    out.push_back({ex.name, category, OnlineExamples::localPath(ex), &ex});
  }
 
  return out;
}
 
void StartScreen::openOnlineExample(const OnlineExample& ex, bool direct, bool openPage)
{
  if(m_actionTaken)
    return;
 
  if(openPage && !ex.page.isEmpty())
  {
    if(const QUrl url{ex.page}; url.isValid() && !url.scheme().isEmpty())
      QDesktopServices::openUrl(url);
  }
 
  m_online.install(ex, [this, direct](QString path) {
    if(path.isEmpty())
    {
      score::warning(
          this, tr("Download failed"),
          tr("This example could not be downloaded. Check your connection and "
             "try again."));
      return;
    }
    choose([&] { direct ? openFile(path) : openTemplate(path); });
  });
}
 
void StartScreen::showOnlineExampleMenu(const OnlineExample& ex, const QPoint& globalPos)
{
  if(m_actionTaken)
    return;
  m_preview->hide();
 
  const bool local = !OnlineExamples::localPath(ex).isEmpty();
 
  // Not exec(): its event loop would keep the card's contextMenuEvent on the
  // stack, while a new manifest or an installed library rebuilds the cards.
  // The menu belongs to the start screen and its actions hold a copy of the
  // example, so that they still work when the card is gone. They run once the
  // menu has returned to the event loop, as they may ask with a dialog.
  auto menu = new QMenu{this};
  menu->setAttribute(Qt::WA_DeleteOnClose);
  const auto add = [this, menu](const QString& text, auto&& f) {
    auto action = menu->addAction(text);
    connect(action, &QAction::triggered, this, std::forward<decltype(f)>(f),
            Qt::QueuedConnection);
    return action;
  };
 
  add(local ? tr("Open your copy as a new score") : tr("Download and open as a new score"),
      [this, ex] { openOnlineExample(ex, false, false); });
  add(local ? tr("Open the example file") : tr("Download and open the example file"),
      [this, ex] { openOnlineExample(ex, true, false); });
  if(!ex.page.isEmpty())
  {
    add(tr("Open the web page"), [ex] {
      if(const QUrl url{ex.page}; url.isValid() && !url.scheme().isEmpty())
        QDesktopServices::openUrl(url);
    });
  }
  if(local)
  {
    menu->addSeparator();
    if(m_online.isDownloading(ex))
    {
      menu->addAction(tr("Downloading"))->setEnabled(false);
    }
    else
    {
      add(OnlineExamples::changedOnline(ex) ? tr("Download the new online version")
                                            : tr("Download the online version again"),
          [this, ex] { replaceLocalCopy(ex); });
    }
  }
  menu->popup(globalPos);
}
 
void StartScreen::replaceLocalCopy(const OnlineExample& ex)
{
  // Asked again while the dialog below or the download is under way.
  if(m_online.isDownloading(ex) || m_replaceAsked.contains(ex.id))
    return;
 
  const auto path = OnlineExamples::localPath(ex);
  if(!path.isEmpty())
  {
    const bool folder = ex.format == QLatin1String{"zip"};
    const auto copy = folder ? OnlineExamples::installFolder(ex) : path;
 
    m_replaceAsked.insert(ex.id);
    const auto answer = score::question(
        this, tr("Download again"),
        (folder ? tr("Replace your copy of %1 with the online version? Changes and "
                     "files added to its folder are lost.\n\n%2")
                : tr("Replace your copy of %1 with the online version? Changes to "
                     "it are lost.\n\n%2"))
            .arg(ex.name, QDir::toNativeSeparators(copy)));
    m_replaceAsked.erase(ex.id);
    if(answer != QMessageBox::Yes)
      return;
  }
 
  m_online.install(ex, [self = QPointer{this}](const QString& path) {
    if(!self)
      return;
    if(path.isEmpty())
    {
      score::warning(
          self, tr("Download failed"),
          tr("The example could not be downloaded. Your copy is unchanged."));
      return;
    }
    self->m_infos.erase(path);
    self->refreshExamplesPage();
  }, true);
}
 
void StartScreen::requestThumbnail(const OnlineExample& ex, ExampleCard* card)
{
  new HTTPGet{
      QUrl{ex.image},
      [card = QPointer{card}](const QByteArray& data) {
    if(!card)
      return;
    if(QImage img; img.loadFromData(data))
      card->setThumbnailImage(img);
  },
      [] { }};
}
 
void StartScreen::refreshExamplesPage()
{
  // An online example that got installed shows on the local page too.
  refreshExamplesPage(m_examplesPage, false);
  refreshExamplesPage(m_onlineExamplesPage, true);
}
 
void StartScreen::refreshExamplesPage(int index, bool online)
{
  // Not yet built: it will use the new list when it first opens.
  if(index <= 0 || m_pageFactories[index])
    return;
 
  auto host = m_pages->widget(index);
  QString filter;
  bool focused{};
  if(auto edit = host->findChild<QLineEdit*>())
  {
    filter = edit->text();
    focused = edit->hasFocus();
  }
 
  std::erase_if(m_cards, [host](auto* card) { return host->isAncestorOf(card); });
  qDeleteAll(host->findChildren<QWidget*>(Qt::FindDirectChildrenOnly));
  host->layout()->addWidget(createExamplesPage(online));
 
  if(auto edit = host->findChild<QLineEdit*>())
  {
    edit->setText(filter);
    if(focused)
      edit->setFocus();
  }
}
 
QWidget* StartScreen::makeCardGrid(
    const std::vector<ExampleEntry>& docs, std::vector<ExampleCard*>& cards,
    QWidget* parent)
{
  auto holder = new QWidget{parent};
  holder->setAutoFillBackground(false);
  auto grid = new CardFlowLayout{holder, 14};
 
  for(const auto& doc : docs)
  {
    auto card = new ExampleCard{m_itemFont, m_smallFont, doc.name, {},
                                doc.path,   holder};
 
    if(const auto* online = doc.online)
    {
      ProjectInfo::Info info;
      info.name = online->name;
      info.description = online->description;
      info.url = online->page;
      card->setInfo(info);
 
      QString tip = online->name;
      if(!online->description.isEmpty())
        tip += "\n\n" + online->description;
      if(doc.path.isEmpty())
      {
        card->setDownloadSize(online->size);
      }
      else
      {
        const bool changed = OnlineExamples::changedOnline(*online);
        card->setBadge(
            changed ? tr("Updated online") : tr("In your library"),
            changed ? StartScreenColors::Accent : StartScreenColors::Muted);
        tip += "\n\n";
        if(changed)
          tip += tr("Changed online. Right-click to download it again.") + "\n";
        tip += QDir::toNativeSeparators(doc.path);
      }
      card->setToolTip(tip);
      if(!online->image.isEmpty())
        requestThumbnail(*online, card);
 
      card->onContextMenu = [this, ex = *online](const QPoint& pos) {
        showOnlineExampleMenu(ex, pos);
      };
 
      card->onActivated
          = [this, ex = *online](const QString&, Qt::KeyboardModifiers mods) {
        openOnlineExample(
            ex, mods & Qt::ControlModifier, !(mods & Qt::AltModifier));
      };
    }
    else
    {
      card->onActivated = [this](const QString& path, Qt::KeyboardModifiers mods) {
        openExample(path, mods & Qt::ControlModifier, !(mods & Qt::AltModifier));
      };
      requestInfo(doc.path, *card);
    }
 
    card->setKeywords(doc.category);
    grid->addWidget(card);
    m_cards.push_back(card);
    cards.push_back(card);
  }
  return holder;
}
 
QWidget* StartScreen::createCardsPage(
    const QString& title, const QString& hint, const QString& emptyHint,
    const std::vector<DocumentTemplate>& docs,
    std::function<void(const QString&)> onActivated, const Link& more)
{
  auto page = new QWidget;
  auto lay = new QVBoxLayout{page};
  lay->setContentsMargins(28, 24, 28, 16);
  lay->setSpacing(8);
 
  if(docs.empty())
  {
    lay->addWidget(makeSectionTitle(title, page));
    lay->addWidget(makeHint(emptyHint, page));
  }
  else
  {
    auto filter = makeTitleWithFilter(title, lay, page);
    lay->addWidget(makeHint(hint, page));
    auto noMatch = makeHint(tr("Nothing matches this filter."), page);
    noMatch->hide();
    lay->addWidget(noMatch);
 
    auto scroll = new QScrollArea{page};
    scroll->setFrameShape(QFrame::NoFrame);
    scroll->setWidgetResizable(true);
    scroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    scroll->viewport()->setAutoFillBackground(false);
 
    auto container = new QWidget;
    container->setAutoFillBackground(false);
    auto grid = new CardFlowLayout{container, 14};
    grid->setContentsMargins(0, 4, 8, 4);
    std::vector<ExampleCard*> cards;
 
    for(const auto& doc : docs)
    {
      const QString subtitle = !doc.category.isEmpty()   ? doc.category
                               : doc.source == "library" ? tr("User library")
                                                         : doc.source;
      auto card = new ExampleCard{m_itemFont, m_smallFont, doc.name,
                                  subtitle,   doc.path,    container};
      card->onActivated = [onActivated](const QString& path, Qt::KeyboardModifiers) {
        onActivated(path);
      };
      card->setKeywords(doc.source);
      grid->addWidget(card);
      m_cards.push_back(card);
      cards.push_back(card);
      requestInfo(doc.path, *card);
    }
 
    connect(
        filter, &QLineEdit::textChanged, container,
        [filter, noMatch, cards = std::move(cards)] {
      const auto words = filter->words();
      bool any = false;
      for(auto card : cards)
      {
        const bool m = card->matches(words);
        card->setVisible(m);
        any |= m;
      }
      noMatch->setVisible(!any);
    });
 
    scroll->setWidget(container);
    lay->addWidget(scroll, 1);
  }
 
  lay->addWidget(makeExternalLink(more, page));
 
  if(docs.empty())
    lay->addStretch();
 
  return page;
}
 
QWidget*
StartScreen::createLinksPage(const QString& title, const std::vector<Link>& links)
{
  auto page = new QWidget;
  auto lay = new QVBoxLayout{page};
  lay->setContentsMargins(28, 24, 28, 24);
  lay->setSpacing(6);
 
  lay->addWidget(makeSectionTitle(title, page));
  for(const auto& link : links)
    lay->addWidget(makeExternalLink(link, page));
  lay->addStretch();
 
  return page;
}
 
void StartScreen::openExample(const QString& path, bool direct, bool openPage)
{
  if(m_actionTaken)
    return;
 
  if(openPage)
  {
    // The information is normally already loaded in the background; if the
    // user was faster than the parser, read it now.
    std::optional<ProjectInfo::Info> info;
    if(auto it = m_infos.find(path); it != m_infos.end() && it->second)
      info = it->second;
    else
      info = ProjectInfo::peek(path);
 
    if(info && !info->url.isEmpty())
    {
      if(const QUrl url{info->url}; url.isValid() && !url.scheme().isEmpty())
        QDesktopServices::openUrl(url);
    }
  }
 
  choose([&] { direct ? openFile(path) : openTemplate(path); });
}
 
void StartScreen::requestInfo(const QString& path)
{
  if(m_infos.find(path) != m_infos.end())
    return;
  m_infos.emplace(path, std::nullopt);
 
  // Parsing a big .score file can take a moment: do it off the GUI thread.
  score::TaskPool::instance().post([path, self = QPointer{this}] {
    auto info = ProjectInfo::peek(path);
    QMetaObject::invokeMethod(
        QCoreApplication::instance(), [self, path, info = std::move(info)] {
      if(self)
        self->onInfoLoaded(path, info);
    }, Qt::QueuedConnection);
  });
}
 
void StartScreen::requestInfo(const QString& path, ExampleCard& card)
{
  if(auto it = m_infos.find(path); it != m_infos.end())
  {
    if(it->second)
      card.setInfo(*it->second);
    return;
  }
  requestInfo(path);
}
 
void StartScreen::onInfoLoaded(
    const QString& path, const std::optional<ProjectInfo::Info>& info)
{
  m_infos[path] = info;
  if(!info)
    return;
 
  for(auto card : m_cards)
    if(card->path() == path)
      card->setInfo(*info);
}
 
void StartScreen::showPreview(InteractiveLabel* label)
{
  const QString& path = label->url();
  ProjectInfo::Info info;
  if(auto it = m_infos.find(path); it != m_infos.end() && it->second)
    info = *it->second;
 
  m_preview->setContent(
      info.thumbnail, info.name.isEmpty() ? label->text() : info.name, info.author,
      info.description, QDir::toNativeSeparators(path));
  // Not Width x Height: the start screen follows the main window's size.
  m_preview->showFor(label, m_pages->geometry().adjusted(8, 8, -8, -8));
}
 
void StartScreen::addLoadCrashedSession()
{
  m_crashLabel->show();
  update();
}
 
void StartScreen::addJoinSession()
{
  m_joinLabel->show();
  update();
}
 
void StartScreen::dismiss()
{
  m_actionTaken = true;
  close();
}
 
void StartScreen::reopen()
{
  m_actionTaken = false;
  refreshRecentFiles();
  show();
  raise();
  setFocus();
}
 
void StartScreen::checkForNewVersion()
{
#if defined(__EMSCRIPTEN__)
  return;
#else
  // The request itself is asynchronous (QNetworkAccessManager); the reply is
  // handled on the GUI thread and only then touches the widgets.
  auto& tp = score::ThreadPool::instance();
  auto t = tp.acquireThread();
  QMetaObject::invokeMethod(t, [t, self = QPointer{this}] {
    auto getLastVersion = new HTTPGet{
        QUrl("https://ossia.io/score-last-version.txt"), [self](const QByteArray& data) {
      const auto version = QString::fromUtf8(data.simplified());
      if(QVersionNumber::fromString(version)
         > QVersionNumber::fromString(SCORE_TAG_NO_V))
      {
        QMetaObject::invokeMethod(QCoreApplication::instance(), [self, version] {
          if(self)
            self->showUpdateAvailable(version);
        });
      }
    }, [] { }};
    connect(getLastVersion, &QObject::destroyed, t, [] {
      QMetaObject::invokeMethod(QCoreApplication::instance(), [] {
        auto& tp = score::ThreadPool::instance();
        tp.releaseThread();
      });
    });
  });
#endif
}
 
void StartScreen::showUpdateAvailable(const QString& version)
{
  m_updateLabel->setText(
      tr("New version %1 is available, click to update").arg(version));
  m_updateLabel->setToolTip(tr("Open the download page in your browser"));
  m_updateLabel->show();
}
 
QWidget* StartScreen::makeLibraryNotice(
    QWidget* parent, const QMargins& margins, bool linksToTemplates)
{
  auto box = new QWidget{parent};
  auto lay = new QVBoxLayout{box};
  lay->setContentsMargins(margins);
  lay->setSpacing(6);
  lay->addWidget(makeSectionTitle(tr("Default library"), box));
 
  auto hint = makeHint({}, box);
  lay->addWidget(hint);
 
  auto action = makeAccentItem({}, "library", "", box);
  connect(action, &InteractiveLabel::labelPressed, this, [this] {
    if(m_libraryInstalled)
      setCurrentPage(m_templatesPage);
    else
      DefaultLibrary::instance().install();
  });
  lay->addWidget(action);
 
  box->hide();
  m_libraryNotices.push_back({box, hint, action, linksToTemplates});
  return box;
}
 
void StartScreen::onLibraryChanged()
{
  const auto previous = std::exchange(m_libraryState, DefaultLibrary::instance().state());
  if(previous == DefaultLibrary::State::Installing
     && m_libraryState == DefaultLibrary::State::Current)
  {
    m_libraryInstalled = true;
    // The templates and examples it brings are on disk now.
    rebuildTemplatesPage();
    refreshExamplesPage();
  }
  else if(m_libraryState != DefaultLibrary::State::Current)
  {
    m_libraryInstalled = false;
  }
  updateLibraryNotices();
}
 
void StartScreen::updateLibraryNotices()
{
  using State = DefaultLibrary::State;
  const auto& lib = DefaultLibrary::instance();
  const auto state = m_libraryState;
 
  QString hint;
  QString action;
  switch(state)
  {
    case State::Current:
      if(m_libraryInstalled)
      {
        hint = tr("The default library is installed.");
        action = tr("Show the templates");
      }
      break;
    case State::Missing:
      hint = tr("The default library is not installed. It provides the templates, "
                "presets and media used by the examples.");
      action = lib.downloadSize() > 0
                   ? tr("Install the default library (%1)")
                         .arg(QLocale{}.formattedDataSize(lib.downloadSize()))
                   : tr("Install the default library");
      break;
    case State::UpdateAvailable:
      hint = tr("A new version of the default library is available.");
      action = lib.downloadSize() > 0
                   ? tr("Update the default library (%1)")
                         .arg(QLocale{}.formattedDataSize(lib.downloadSize()))
                   : tr("Update the default library");
      break;
    case State::Installing:
      hint = lib.progress() >= 0.
                 ? tr("Downloading the default library: %1%")
                       .arg(int(lib.progress() * 100.))
                 : tr("Downloading the default library");
      break;
    case State::Failed:
      hint = lib.error().isEmpty()
                 ? tr("The default library could not be installed.")
                 : tr("The default library could not be installed: %1").arg(lib.error());
      action = tr("Try again");
      break;
  }
 
  const bool installAction = state == State::Missing || state == State::UpdateAvailable
                             || state == State::Failed;
  if(installAction && !lib.canInstall())
  {
    hint += " " + tr("Install it from the Packages settings.");
    action.clear();
  }
 
  std::erase_if(m_libraryNotices, [](const LibraryNotice& n) { return !n.box; });
  for(auto& n : m_libraryNotices)
  {
    const bool showAction
        = !action.isEmpty() && (n.linksToTemplates || !m_libraryInstalled);
    n.hint->setText(hint);
    n.action->setText(action);
    n.action->setVisible(showAction);
    n.box->setVisible(!hint.isEmpty());
  }
}
 
void StartScreen::rebuildTemplatesPage()
{
  // Not yet built: it will find the new templates when it first opens.
  if(m_templatesPage <= 0 || m_pageFactories[m_templatesPage])
    return;
 
  auto host = m_pages->widget(m_templatesPage);
  std::erase_if(m_cards, [host](auto* card) { return host->isAncestorOf(card); });
  for(auto* w : host->findChildren<QWidget*>(Qt::FindDirectChildrenOnly))
  {
    w->hide();
    w->deleteLater();
  }
  host->layout()->addWidget(createTemplatesPage());
}
 
void StartScreen::paintEvent(QPaintEvent* event)
{
  QPainter painter(this);
  painter.setRenderHint(QPainter::Antialiasing, true);
  painter.setRenderHint(QPainter::TextAntialiasing, true);
  painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
 
  // The decorations cover the window, anchored bottom-left where they gather;
  // the overflow is cropped at the top or the right.
  painter.fillRect(rect(), Qt::black);
  if(!m_background.isNull())
  {
    const QSizeF logical = m_background.deviceIndependentSize();
    const qreal cover
        = std::max(width() / logical.width(), height() / logical.height());
    const QSizeF size = logical * cover;
    painter.drawPixmap(
        QRectF{QPointF{0, height() - size.height()}, size}, m_background,
        m_background.rect());
  }
 
  // Scaled up, the decorations reach into the header: fade them out behind the
  // logo, the tagline and the version.
  {
    QLinearGradient fade{QPointF{0, 0}, QPointF{0, qreal(HeaderHeight)}};
    fade.setColorAt(0, QColor{0, 0, 0, 255});
    fade.setColorAt(0.92, QColor{0, 0, 0, 255});
    fade.setColorAt(1, QColor{0, 0, 0, 0});
    painter.fillRect(QRect{0, 0, width(), HeaderHeight}, fade);
  }
 
  // The logo and tagline keep the scale they have at the minimum size, so that
  // they line up with HeaderHeight.
  qreal scale = 1.;
  if(!m_logo.isNull())
  {
    const QSizeF logical = m_logo.deviceIndependentSize();
    scale = std::max(Width / logical.width(), Height / logical.height());
    painter.drawPixmap(QRectF{QPointF{}, logical * scale}, m_logo, m_logo.rect());
  }
 
  // The version sits under the tagline, which is part of the artwork
  painter.setFont(m_versionFont);
  painter.setPen(QPen{StartScreenColors::Version});
  {
    // Branch builds carry the branch name: keep it inside the header
    const qreal x = 217 * scale;
    const QFontMetrics fm{m_versionFont};
    painter.drawText(
        QPointF(x, 188 * scale), fm.elidedText(
                                     QCoreApplication::applicationVersion(),
                                     Qt::ElideMiddle, int(width() - x - 60)));
  }
 
  // Dim the artwork behind the navigation so that its text stays readable
  painter.fillRect(
      QRect{0, HeaderHeight, NavWidth, height() - HeaderHeight}, QColor{0, 0, 0, 120});
 
  // Page panel. The selected navigation item paints itself with the panel
  // color so that it visually connects to the page.
  painter.fillRect(
      QRect{NavWidth, HeaderHeight, width() - NavWidth, height() - HeaderHeight},
      StartScreenColors::Panel);
}
 
void StartScreen::showEvent(QShowEvent* event)
{
  QWidget::showEvent(event);
  if(!std::exchange(m_libraryViewRegistered, true))
    DefaultLibrary::instance().addView();
  if(auto* p = parentWidget())
    setGeometry(p->rect());
  raise();
  setFocus();
}
 
void StartScreen::hideEvent(QHideEvent* event)
{
  QWidget::hideEvent(event);
  if(std::exchange(m_libraryViewRegistered, false))
    DefaultLibrary::instance().removeView();
}
 
bool StartScreen::eventFilter(QObject* watched, QEvent* event)
{
  if(watched == parentWidget() && event->type() == QEvent::Resize)
    setGeometry(parentWidget()->rect());
  return QWidget::eventFilter(watched, event);
}
 
void StartScreen::keyPressEvent(QKeyEvent* event)
{
  switch(event->key())
  {
    case Qt::Key_Escape:
      choose([this] { openNewDocument(); });
      event->accept();
      return;
    case Qt::Key_Left:
    case Qt::Key_Up:
      setCurrentPage(
          (m_pages->currentIndex() + m_pages->count() - 1) % m_pages->count());
      event->accept();
      return;
    case Qt::Key_Right:
    case Qt::Key_Down:
      setCurrentPage((m_pages->currentIndex() + 1) % m_pages->count());
      event->accept();
      return;
    default:
      QWidget::keyPressEvent(event);
  }
}
 
void StartScreen::closeEvent(QCloseEvent* event)
{
  // Closed by other means (e.g. the window manager): make sure that the user
  // does not end up with an empty application window.
  choose([this] { openNewDocument(); });
  QWidget::closeEvent(event);
}
}