passworddialog.cpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2015 Anne Jan Brouwer
// SPDX-License-Identifier: GPL-3.0-or-later
#include "passworddialog.h"
#include "fieldlabel.h"
#include "filecontent.h"
#include "pass.h"
#include "passwordconfiguration.h"
#include "pathvalidator.h"
#include "qtpasssettings.h"
#include "secretlineedit.h"
#include "secretplaintextedit.h"
#include "templateio.h"
#include "totp.h"
#include "ui_passworddialog.h"
#include "util.h"
#include <algorithm>
#include <limits>
 
#include <QAction>
#include <QCheckBox>
#include <QComboBox>
#include <QDialogButtonBox>
#include <QDir>
#include <QFileInfo>
#include <QFormLayout>
#include <QHash>
#include <QIcon>
#include <QLabel>
#include <QLineEdit>
#include <QMessageBox>
#include <QPushButton>
#include <QShortcut>
#include <QSignalBlocker>
#include <QTextDocument>
#include <utility>
 
#include "qtpasslogging.h"
 
namespace {
const char kOtpEditedProperty[] = "qtpassOtpEdited";
const char kOriginalLineProperty[] = "qtpassOriginalLine";
} // namespace
 
PasswordDialog::PasswordDialog(PasswordConfiguration passConfig,
                               QWidget *parent)
    : QDialog(parent), ui(new Ui::PasswordDialog),
      m_passConfig(std::move(passConfig)), m_pass(QtPassSettings::getPass()) {
  // Only reached from tests; production uses the overload taking an
  // explicit Pass* with a caller-controlled lifetime.
  m_templating = false;
  m_isNew = false;
 
  ui->setupUi(this);
  connect(ui->checkBoxShow, &QCheckBox::toggled, this,
          &PasswordDialog::setPasswordVisible);
  reportCopies(ui->lineEditPassword);
  connect(ui->plainTextEdit, &SecretPlainTextEdit::copied, this,
          &PasswordDialog::copied);
  setupTemplateBox();
  setLength(m_passConfig.length);
  setPasswordCharTemplate(m_passConfig.selected);
 
  connect(m_pass, &Pass::finishedShow, this, &PasswordDialog::setPass);
  connect(m_pass, &Pass::finishedInsert, this,
          &PasswordDialog::onInsertFinished);
  connect(m_pass, &Pass::insertFailed, this, &PasswordDialog::onInsertFailed);
}
 
PasswordDialog::PasswordDialog(Pass *pass, const AppSettings &s, QString file,
                               const bool &isNew, QWidget *parent)
    : QDialog(parent), ui(new Ui::PasswordDialog), m_pass(pass),
      m_file(std::move(file)), m_isNew(isNew) {
 
  ui->setupUi(this);
  connect(ui->checkBoxShow, &QCheckBox::toggled, this,
          &PasswordDialog::setPasswordVisible);
  reportCopies(ui->lineEditPassword);
  connect(ui->plainTextEdit, &SecretPlainTextEdit::copied, this,
          &PasswordDialog::copied);
  setupTemplateBox();
  // The name row only appears once setNewEntryLocation() says where a new
  // entry may go; an existing entry keeps its name.
  ui->nameRow->hide();
 
  setWindowTitle(isNew && m_file.isEmpty()
                     ? tr("New password")
                     : this->windowTitle() + " " + m_file);
  m_passConfig = s.passwordConfiguration;
  usePwgen(s.usePwgen);
  setTemplate(s.passTemplate, s.useTemplate);
  templateAll(s.templateAllFields);
 
  setLength(m_passConfig.length);
  setPasswordCharTemplate(m_passConfig.selected);
 
  connect(m_pass, &Pass::finishedShow, this, &PasswordDialog::setPass);
  connect(m_pass, &Pass::processErrorExit, this, &PasswordDialog::onShowError);
  connect(m_pass, &Pass::finishedInsert, this,
          &PasswordDialog::onInsertFinished);
  connect(m_pass, &Pass::insertFailed, this, &PasswordDialog::onInsertFailed);
  connect(this, &PasswordDialog::rejected, this, &PasswordDialog::on_rejected);
 
  if (!isNew) {
    // Show() is asynchronous: until finishedShow lands the fields are empty,
    // so an early Ok would write nothing and the late setPass() would clobber
    // what was typed. Lock the editor and Ok until the decrypt arrives.
    ui->statusLabel->setText(tr("Decrypting…"));
    setEditorEnabled(false);
    ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
    m_pass->Show(m_file);
  }
}
 
PasswordDialog::~PasswordDialog() {
  // QDialog's destructor hides the window after this body, and losing focus
  // emits editingFinished() into normalizeOtpField() or renameField(), slots
  // of a PasswordDialog already gone. Hide here, while the object is whole.
  hide();
}
 
void PasswordDialog::setPasswordVisible(bool show) {
  if (show) {
    ui->lineEditPassword->setEchoMode(QLineEdit::Normal);
  } else {
    ui->lineEditPassword->setEchoMode(QLineEdit::Password);
  }
}
 
void PasswordDialog::on_createPasswordButton_clicked() {
  ui->widget->setEnabled(false);
  const int currentIndex = ui->passwordTemplateSwitch->currentIndex();
  if (currentIndex < 0 ||
      currentIndex >= static_cast<int>(PasswordConfiguration::CHARSETS_COUNT)) {
    ui->widget->setEnabled(true);
    return;
  }
 
  QString newPass = m_pass->generatePassword(
      static_cast<unsigned int>(ui->spinBox_pwdLength->value()),
      m_passConfig.Characters[static_cast<PasswordConfiguration::CharacterSet>(
          currentIndex)]);
  if (!newPass.isEmpty()) {
    ui->lineEditPassword->setText(newPass);
  }
  ui->widget->setEnabled(true);
}
 
void PasswordDialog::save() {
  // Show is asynchronous: refuse to save an existing entry before its
  // content loads. getPassword() always returns at least a newline, so an
  // isEmpty() check cannot stand in for this.
  if (!m_isNew && !m_contentLoaded) {
    return;
  }
 
  // Canonicalise before serialising: getPassword() stays a dumb serializer.
  normalizeOtpField();
 
  QString newValue = getPassword();
  if (newValue.right(1) != "\n") {
    newValue += "\n";
  }
 
  setSaving(true);
  // A refusal (the name is taken, the .gpg-id is unusable, a linked path)
  // comes through critical() before Insert() returns, with nothing started
  // that could still report.
  QString refusal;
  const QMetaObject::Connection refused =
      connect(m_pass, &Pass::critical, this,
              [&refusal](const QString &, const QString &message) {
                refusal = message;
              });
  // Reports from inserts already queued (an earlier dialog that a hanging
  // queue let close while its save was still pending) must pass before one is
  // taken as this dialog's own. The count is read before our own Insert()
  // queues, so it does not include it.
  m_insertsAhead = m_pass->insertsPending();
  m_pass->Insert(m_file, newValue, !m_isNew);
  disconnect(refused);
  if (m_saving && !refusal.isEmpty()) {
    setSaving(false);
    showNotSaved(refusal);
  }
}
 
void PasswordDialog::setSaving(bool saving) {
  m_saving = saving;
  setEditorEnabled(!saving);
  ui->nameRow->setEnabled(!saving);
  // Another template would rebuild the field rows under a pending insert.
  ui->templateBox->setEnabled(!saving);
  // Cancel stays: a save that never reports (an unanswered PIN prompt, a
  // queue held up by a hanging pull) must not leave quitting as the only
  // way out. reject() asks first.
  ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(!saving);
  ui->statusLabel->setText(saving ? tr("Saving…") : QString());
}
 
auto PasswordDialog::isOwnInsertReport() -> bool {
  if (!m_saving) {
    return false;
  }
  // Since a hanging queue can let a dialog close while its insert is still
  // queued (#1965), more than one insert can be in flight, and neither
  // finishedInsert nor insertFailed says which it is. The Executor runs the
  // queue in order, so the first m_insertsAhead reports belong to inserts
  // queued before this dialog's; let them pass before taking one as our own.
  if (m_insertsAhead > 0) {
    --m_insertsAhead;
    return false;
  }
  return true;
}
 
void PasswordDialog::onInsertFinished() {
  if (!isOwnInsertReport()) {
    return;
  }
  setSaving(false);
  QDialog::accept();
}
 
void PasswordDialog::onInsertFailed(const QString &err, bool written) {
  if (!isOwnInsertReport()) {
    return;
  }
  setSaving(false);
  // The entry is in the store and a later step (git add or commit) failed,
  // which the backend reports ("Saved, not committed"). Saved is saved, so
  // the dialog closes, also for an existing entry: "Not saved" would be
  // wrong, and a new entry could only be tried again under a name it now
  // has.
  if (written) {
    QDialog::accept();
    return;
  }
  showNotSaved(err);
}
 
void PasswordDialog::reject() {
  if (m_saving) {
    const QMessageBox::StandardButton answer = QMessageBox::question(
        this, tr("Still saving"),
        tr("The entry is still being saved. Close the dialog anyway? If "
           "saving then fails, what you typed is lost."),
        QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
    // The insert may have reported while the question was up.
    if (answer != QMessageBox::Yes || !m_saving) {
      return;
    }
    // Whatever the insert reports later, the main window shows it.
    m_saving = false;
  }
  QDialog::reject();
}
 
void PasswordDialog::showNotSaved(const QString &err) {
  if (!m_storeRoot.isEmpty()) {
    validateNewEntry(); // gates OK on the name again
  }
  ui->statusLabel->setText(tr("Not saved: %1").arg(err.trimmed()));
}
 
void PasswordDialog::on_rejected() { setPassword(QString()); }
 
void PasswordDialog::setNewEntryLocation(const QString &storeRoot,
                                         const QStringList &folders,
                                         const QString &currentFolder) {
  m_storeRoot = QDir::cleanPath(storeRoot);
  ui->folderBox->clear();
  int current = 0;
  for (const QString &folder : folders) {
    const QString rel = QDir::cleanPath(folder) == QStringLiteral(".")
                            ? QString()
                            : QDir::cleanPath(folder);
    if (rel == QDir::cleanPath(currentFolder) ||
        (rel.isEmpty() &&
         QDir::cleanPath(currentFolder) == QStringLiteral("."))) {
      current = ui->folderBox->count();
    }
    ui->folderBox->addItem(rel.isEmpty() ? QStringLiteral("/") : rel + u'/',
                           rel);
  }
  ui->folderBox->setCurrentIndex(current);
  m_newEntryFolder = ui->folderBox->currentData().toString();
  ui->nameRow->show();
  connect(ui->nameEdit, &QLineEdit::textChanged, this,
          &PasswordDialog::validateNewEntry);
  connect(ui->folderBox, &QComboBox::currentIndexChanged, this,
          &PasswordDialog::validateNewEntry);
  validateNewEntry();
  ui->nameEdit->setFocus();
}
 
auto PasswordDialog::resolveNewEntry(QString *problem) const -> QString {
  QString name = QDir::fromNativeSeparators(ui->nameEdit->text().trimmed());
  // The suffix belongs to the file, not the entry: Insert() appends it, so a
  // typed "github.gpg" would otherwise become github.gpg.gpg.
  if (name.endsWith(QStringLiteral(".gpg"), Qt::CaseInsensitive)) {
    name.chop(4);
  }
  if (name.isEmpty()) {
    *problem = tr("Give the entry a name.");
    return {};
  }
  if (name.endsWith(u'/')) {
    *problem = tr("A name cannot end in /.");
    return {};
  }
  const QString folder = ui->folderBox->currentData().toString();
  const QString rel =
      QDir::cleanPath(folder.isEmpty() ? name : folder + u'/' + name);
  const QString absolute = QDir(m_storeRoot).filePath(rel);
  if (rel.isEmpty() || rel == QStringLiteral(".") ||
      !PathValidator::isPathInStore(m_storeRoot, absolute)) {
    *problem = tr("That name would resolve outside the password store.");
    return {};
  }
  if (QFileInfo::exists(absolute + QStringLiteral(".gpg"))) {
    *problem = tr("An entry called %1 already exists.").arg(rel);
    return {};
  }
  if (QFileInfo(absolute).isDir()) {
    *problem = tr("%1 is a folder.").arg(rel);
    return {};
  }
  problem->clear();
  return rel;
}
 
// Re-checked on every keystroke; gates OK.
void PasswordDialog::validateNewEntry() {
  QString problem;
  const QString rel = resolveNewEntry(&problem);
  ui->statusLabel->setText(problem);
  ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(!rel.isEmpty());
}
 
void PasswordDialog::accept() {
  if (m_saving) {
    return;
  }
  if (!m_storeRoot.isEmpty()) {
    QString problem;
    const QString rel = resolveNewEntry(&problem);
    if (rel.isEmpty()) {
      ui->statusLabel->setText(problem);
      return;
    }
    // A name like work/vpn may need its folder; gpg does not create it.
    const QString parent = QFileInfo(QDir(m_storeRoot).filePath(rel)).path();
    if (!QDir(parent).exists() && !Util::mkpathForStore(parent)) {
      ui->statusLabel->setText(
          tr("Could not create the folder %1.").arg(parent));
      return;
    }
    m_file = rel;
    setWindowTitle(tr("Password") + QStringLiteral(" ") + m_file);
  }
  save();
}
 
void PasswordDialog::setPassword(const QString &password) {
  // Which lines become fields is the user's choice: forcing allFields
  // (#1138, for #132) made every `key: value` line a label-locked widget,
  // even with templates off (#1766). MainWindow renders by the same rule.
  FileContent fileContent =
      FileContent::parse(password, m_templating ? m_fields : QStringList(),
                         m_templating && m_allFields);
  ui->lineEditPassword->setText(fileContent.getPassword());
 
  QWidget *previous = ui->checkBoxShow;
  NamedValues namedValues = fileContent.getNamedValues();
  for (QLineEdit *line : std::as_const(m_templateLines)) {
    const NamedValue nv = namedValues.takeNamedValue(line->objectName());
    line->setText(nv.value);
    line->setProperty(kOriginalLineProperty, nv.originalLine);
    // The value is the entry's again, whatever the user typed before this
    // reload: not a value normalizeOtpField() may rewrite.
    line->setProperty(kOtpEditedProperty, QVariant());
    previous = line;
  }
  // Remove previously created dynamic widgets to prevent duplicates and leaks
  for (QLineEdit *line : std::as_const(m_otherLines)) {
    ui->formLayout->removeRow(line);
  }
  m_otherLines.clear();
  for (const NamedValue &nv : std::as_const(namedValues)) {
    auto *line = new SecretLineEdit();
    reportCopies(line);
    line->setObjectName(nv.name);
    line->setText(nv.value);
    line->setProperty(kOriginalLineProperty, nv.originalLine);
    auto *label = new FieldLabel(nv.name);
    label->setBuddy(line);
    ui->formLayout->addRow(label, line);
    setTabOrder(previous, line);
    m_otherLines.append(line);
    previous = line;
    // Both widgets are rows of the form; removeRow() deletes them together,
    // so a rename or removal that arrives afterwards finds no receiver.
    connect(label, &FieldLabel::renamed, this,
            [this, line, label](const QString &, const QString &to) {
              renameField(line, label, to);
            });
    connect(label, &FieldLabel::removeRequested, this,
            [this, line] { removeField(line); });
    // The visible way to remove the field; the context menu is the other.
    auto *remove = line->addAction(
        QIcon::fromTheme(QStringLiteral("edit-delete"),
                         QIcon(QStringLiteral(":/icons/edit-delete.svg"))),
        QLineEdit::TrailingPosition);
    remove->setObjectName(QStringLiteral("removeFieldAction"));
    remove->setToolTip(tr("Remove field"));
    connect(remove, &QAction::triggered, this,
            [this, line] { removeField(line); });
  }
 
  // setPlainText, not insertPlainText: re-populating must replace the body,
  // not save back a duplicated copy.
  ui->plainTextEdit->setPlainText(fileContent.getRemainingData());
 
  // m_otherLines was just rebuilt, so the OTP field may be a new widget.
  hookOtpField();
}
 
void PasswordDialog::renameField(QLineEdit *line, FieldLabel *label,
                                 const QString &to) {
  QList<QLineEdit *> allLines(m_templateLines);
  allLines.append(m_otherLines);
  for (QLineEdit *other : std::as_const(allLines)) {
    if (other != line && other->objectName() == to) {
      ui->statusLabel->setText(tr("A field called %1 already exists.").arg(to));
      return;
    }
  }
  ui->statusLabel->clear();
  line->setObjectName(to);
  label->setText(to);
  // The field may have become, or stopped being, the OTP one.
  hookOtpField();
}
 
void PasswordDialog::removeField(QLineEdit *line) {
  m_otherLines.removeAll(line);
  // takeRow(), not removeRow(): removeRow() deletes the widgets while the
  // label's contextMenuEvent() or the action's triggered() is still on the
  // stack. They are deleted once the stack has unwound.
  const QFormLayout::TakeRowResult row = ui->formLayout->takeRow(line);
  // hide() takes the focus from a focused line, and that emits
  // editingFinished(): not into normalizeOtpField() for a field that is
  // being removed.
  disconnect(line, nullptr, this, nullptr);
  if (m_otpLine == line) {
    m_otpLine = nullptr;
  }
  for (QLayoutItem *item : {row.labelItem, row.fieldItem}) {
    if (item == nullptr) {
      continue;
    }
    if (QWidget *widget = item->widget()) {
      widget->hide();
      widget->deleteLater();
    }
    delete item;
  }
  hookOtpField();
}
 
auto PasswordDialog::otpLineEdit() const -> QLineEdit * {
  QList<QLineEdit *> allLines(m_templateLines);
  allLines.append(m_otherLines);
  QLineEdit *firstMatch = nullptr;
  for (QLineEdit *line : std::as_const(allLines)) {
    if (!FileContent::isOtpFieldName(line->objectName())) {
      continue;
    }
    // Prefer a populated field: the default template's empty `OTP` widget
    // would otherwise shadow a `TOTP:` value in m_otherLines, leaving the
    // real secret unvalidated and unnormalised.
    if (!line->text().trimmed().isEmpty()) {
      return line;
    }
    if (firstMatch == nullptr) {
      firstMatch = line;
    }
  }
  return firstMatch;
}
 
void PasswordDialog::hookOtpField() {
  // Only m_otherLines widgets are deleted by removeRow(); a template widget
  // keeps its action, and the next validate would add a second icon.
  // m_otpWarning is a QPointer: null when setPassword() deleted its owner.
  if (!m_otpWarning.isNull()) {
    if (auto *owner = qobject_cast<QWidget *>(m_otpWarning->parent())) {
      owner->removeAction(m_otpWarning);
    }
    delete m_otpWarning;
  }
  m_otpWarning = nullptr;
 
  QLineEdit *otp = otpLineEdit();
  // The field that was the OTP one may not be any more (renamed away, or
  // another one now comes first): it stops being validated and normalised
  // here, so its OTP hooks go with the role. Its copies are still reported.
  if (!m_otpLine.isNull() && m_otpLine != otp) {
    disconnect(m_otpLine, &QLineEdit::textChanged, this,
               &PasswordDialog::validateOtpField);
    disconnect(m_otpLine, &QLineEdit::textEdited, this,
               &PasswordDialog::markOtpFieldEdited);
    disconnect(m_otpLine, &QLineEdit::editingFinished, this,
               &PasswordDialog::normalizeOtpField);
  }
  m_otpLine = otp;
  if (otp == nullptr) {
    return;
  }
  otp->setPlaceholderText(tr("otpauth:// URI or base32 secret"));
  connect(otp, &QLineEdit::textChanged, this, &PasswordDialog::validateOtpField,
          Qt::UniqueConnection);
  // textEdited, not textChanged: it fires only for user input, so programmatic
  // population does not count as the user having touched the field.
  connect(otp, &QLineEdit::textEdited, this,
          &PasswordDialog::markOtpFieldEdited, Qt::UniqueConnection);
  // Canonicalise as soon as the user leaves the field, so the value they end
  // up saving is the value they were shown.
  connect(otp, &QLineEdit::editingFinished, this,
          &PasswordDialog::normalizeOtpField, Qt::UniqueConnection);
  validateOtpField();
}
 
void PasswordDialog::markOtpFieldEdited() {
  if (QObject *line = sender()) {
    line->setProperty(kOtpEditedProperty, true);
  }
}
 
void PasswordDialog::validateOtpField() {
  // m_otpLine, not otpLineEdit(): the signals that bring us here and the
  // edit mark are that line's. The OTP role is settled when fields change.
  QLineEdit *otp = m_otpLine;
  if (otp == nullptr) {
    return;
  }
 
  const QString text = otp->text().trimmed();
  const bool bad = !text.isEmpty() && !Totp::isValid(text);
  if (bad) {
    if (m_otpWarning.isNull()) {
      // Theme-aware indicator: no hardcoded colours and no extra layout row.
      m_otpWarning =
          otp->addAction(QIcon::fromTheme(QStringLiteral("dialog-warning")),
                         QLineEdit::TrailingPosition);
    }
    otp->setToolTip(tr("Invalid OTP secret"));
  } else {
    if (!m_otpWarning.isNull()) {
      otp->removeAction(m_otpWarning);
      delete m_otpWarning;
      m_otpWarning = nullptr;
    }
    otp->setToolTip(QString());
  }
}
 
// Only an otpauth:// URI or a value typed into this field is rewritten.
// Base32::sanitizeInput() maps 1 to L and 8 to B, so a backup code like
// `12345678` passes as base32 and was silently rewritten on any OK. A bare
// secret left alone still works: Totp::parse() accepts one.
void PasswordDialog::normalizeOtpField() {
  QLineEdit *otp = m_otpLine;
  if (otp == nullptr) {
    return;
  }
  const QString text = otp->text().trimmed();
  if (text.isEmpty()) {
    return;
  }
  if (!otp->property(kOtpEditedProperty).toBool() &&
      !FileContent::isOtpUriValue(text)) {
    return;
  }
  // fileName(), not completeBaseName(): the latter truncates at the last dot,
  // turning an entry called github.com into a label of "github". m_file already
  // has its .gpg suffix stripped by MainWindow::getFile().
  const QString canonical = Totp::normalize(text, QFileInfo(m_file).fileName());
  if (!canonical.isEmpty()) {
    otp->setText(canonical);
  }
}
 
auto PasswordDialog::getPassword() -> QString {
  QString passFile = ui->lineEditPassword->text() + "\n";
  QList<QLineEdit *> allLines(m_templateLines);
  allLines.append(m_otherLines);
  for (QLineEdit *line : std::as_const(allLines)) {
    const QString text = line->text();
    const QString name = line->objectName();
    const QString original = line->property(kOriginalLineProperty).toString();
    // A field whose name and value are still exactly what was parsed keeps its
    // source line verbatim: reserialising would turn `key:value` into
    // `key: value`, trim whitespace the value carried, and drop a field with an
    // empty value (`recovery:`) entirely. The widget holds trimmed name/value,
    // so compare against the original line split and trimmed the same way.
    if (!original.isEmpty()) {
      const qsizetype colon = original.indexOf(QLatin1Char(':'));
      if (colon >= 0 && original.left(colon).trimmed() == name &&
          original.right(original.length() - colon - 1).trimmed() == text) {
        passFile += original + "\n";
        continue;
      }
    }
    if (text.isEmpty()) {
      continue;
    }
    passFile += name + ": " + text + "\n";
  }
  // Not toPlainText(): it saves a blank for every no-break space (U+00A0) in
  // the notes, so any OK rewrites even lines the user never touched and a
  // passphrase or recovery code with no-break spaces is corrupted. The raw
  // document text keeps the no-break spaces; only the block and line
  // separators it uses are normalised back to '\n'.
  QString notes = ui->plainTextEdit->document()->toRawText();
  notes.replace(QChar(QChar::ParagraphSeparator), QLatin1Char('\n'));
  notes.replace(QChar(QChar::LineSeparator), QLatin1Char('\n'));
  passFile += notes;
  return passFile;
}
 
void PasswordDialog::setTemplate(const QString &rawFields, bool useTemplate) {
  m_fields = TemplateIO::fieldsIn(rawFields);
  m_templating = useTemplate;
 
  for (QLineEdit *line : std::as_const(m_templateLines)) {
    ui->formLayout->removeRow(line);
  }
  m_templateLines.clear();
 
  // Defensively remove all rows tracked in m_otherLines to prevent accumulation
  // when cycling templates or applying new templates after setPassword
  for (QLineEdit *line : std::as_const(m_otherLines)) {
    ui->formLayout->removeRow(line);
  }
  m_otherLines.clear();
 
  if (m_templating) {
    QWidget *previous = ui->checkBoxShow;
    for (const QString &field : std::as_const(m_fields)) {
      if (field.isEmpty()) {
        continue;
      }
      auto *line = new SecretLineEdit();
      reportCopies(line);
      // Plain text before the name is set: the template comes from the
      // store, and as rich text <img src="/dev/zero"> has Qt read that file
      // without end.
      auto *label = new QLabel();
      label->setTextFormat(Qt::PlainText);
      label->setText(field);
      line->setObjectName(field);
      ui->formLayout->addRow(label, line);
      setTabOrder(previous, line);
      m_templateLines.append(line);
      previous = line;
    }
  }
 
  hookOtpField();
}
 
void PasswordDialog::reportCopies(SecretLineEdit *line) {
  connect(line, &SecretLineEdit::copied, this, &PasswordDialog::copied);
}
 
void PasswordDialog::templateAll(bool templateAll) {
  m_allFields = templateAll;
}
 
void PasswordDialog::setLength(int length) {
  ui->spinBox_pwdLength->setValue(length);
}
 
void PasswordDialog::setPasswordCharTemplate(int templateIndex) {
  ui->passwordTemplateSwitch->setCurrentIndex(templateIndex);
}
 
void PasswordDialog::usePwgen(bool usePwgen) {
  m_usePwgen = usePwgen;
  ui->passwordTemplateSwitch->setDisabled(usePwgen);
  ui->label_characterset->setDisabled(usePwgen);
}
 
// The template row stays hidden until setAvailableTemplates() fills it.
void PasswordDialog::setupTemplateBox() {
  ui->label_template->hide();
  ui->templateBox->hide();
  connect(ui->templateBox, &QComboBox::currentTextChanged, this,
          [this](const QString &name) {
            // applyTemplate() rebuilds the field rows, so only act on a real
            // change; the box is also updated from applyTemplate() itself.
            if (name != m_currentTemplateName) {
              applyTemplate(name);
            }
          });
}
 
void PasswordDialog::setAvailableTemplates(
    const QHash<QString, QStringList> &templates,
    const QString &defaultTemplate) {
  m_availableTemplates = templates;
  QStringList templateNames = templates.keys();
  if (templateNames.isEmpty()) {
    return;
  }
  std::sort(templateNames.begin(), templateNames.end());
  {
    const QSignalBlocker blocker(ui->templateBox);
    ui->templateBox->clear();
    ui->templateBox->addItems(templateNames);
  }
  ui->label_template->show();
  ui->templateBox->show();
  if (!m_templateShortcut) {
    m_templateShortcut = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key_T), this,
                                       this, [this] { cycleTemplate(); });
  }
  QString selected = defaultTemplate;
  if (!templateNames.contains(selected)) {
    selected = templateNames.first();
  }
  applyTemplate(selected);
}
 
void PasswordDialog::applyTemplate(const QString &templateName) {
  if (m_saving) {
    return;
  }
  auto it = m_availableTemplates.constFind(templateName);
  if (it != m_availableTemplates.constEnd()) {
    m_currentTemplateName = templateName;
    const QSignalBlocker blocker(ui->templateBox);
    ui->templateBox->setCurrentText(templateName);
    QString fields = it.value().join("\n");
    setTemplate(fields, true);
  }
}
 
void PasswordDialog::cycleTemplate() {
  if (m_availableTemplates.isEmpty()) {
    return;
  }
  QStringList names = m_availableTemplates.keys();
  std::sort(names.begin(), names.end());
 
  qsizetype currentIdx = names.indexOf(m_currentTemplateName);
  qsizetype nextIdx;
  if (currentIdx < 0) {
    nextIdx = 0;
  } else {
    nextIdx = (currentIdx + 1) % names.size();
  }
  applyTemplate(names.at(nextIdx));
}
 
void PasswordDialog::setPass(const QString &output, const QString &file) {
  // finishedShow names its file: a decrypt of any other entry (a tree click
  // that was still queued when the dialog opened) is not ours.
  if (!file.isEmpty() && file != m_file) {
    return;
  }
  // An editor block per line: an entry of millions of lines (a small,
  // compressed one in a shared store can be one) would take QtPass down.
  // Not loaded at all, so nothing can be saved over it from here either.
  // Counted as an editor of the whole entry would hold it: the final
  // newline pass and QtPass write ends the last line, it starts no new one.
  // Password and fields count too, so this is stricter than the display's
  // limit on the remaining text alone.
  if (const qsizetype lines =
          output.count(QLatin1Char('\n')) +
          (output.isEmpty() || output.endsWith(QLatin1Char('\n')) ? 0 : 1);
      lines > FileContent::kMaxDisplayLines) {
    // The count in a variable first, as in FileContent: older lupdate
    // versions lose a tr() with template arguments among its arguments.
    const int n = static_cast<int>(
        std::min<qsizetype>(lines, std::numeric_limits<int>::max()));
    ui->statusLabel->setText(
        tr("This entry has %n line(s), too many to edit here.", nullptr, n));
    return;
  }
  setPassword(output);
  m_contentLoaded = true;
  // Drop the "Decrypting…" note so it cannot be mistaken for a warning.
  ui->statusLabel->clear();
  setEditorEnabled(true);
  ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
}
 
void PasswordDialog::onShowError(int /* exitCode */, const QString &err) {
  // React only while the dialog is still waiting for its own decrypt.
  // processErrorExit carries no request identity, but for an existing entry
  // the only Pass operation in flight is the Show() that opened this dialog.
  if (m_isNew || m_contentLoaded) {
    return;
  }
  ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
  setEditorEnabled(false);
  ui->statusLabel->setText(err);
}
 
void PasswordDialog::setEditorEnabled(bool enabled) {
  ui->lineEditPassword->setEnabled(enabled);
  ui->createPasswordButton->setEnabled(enabled);
  ui->checkBoxShow->setEnabled(enabled);
  ui->passwordTemplateSwitch->setEnabled(enabled);
  ui->label_characterset->setEnabled(enabled);
  ui->spinBox_pwdLength->setEnabled(enabled);
  ui->plainTextEdit->setEnabled(enabled);
  for (QLineEdit *line : std::as_const(m_templateLines)) {
    line->setEnabled(enabled);
  }
  for (QLineEdit *line : std::as_const(m_otherLines)) {
    line->setEnabled(enabled);
  }
  // Re-apply the pwgen policy on the way back up, or the two widgets usePwgen()
  // locks would be spuriously re-enabled with the rest of the editor.
  if (enabled && m_usePwgen) {
    usePwgen(true);
  }
}