アドレス帳

struct Contact
{
private:
    Q_GADGET
    Q_PROPERTY(QString name MEMBER name)
    Q_PROPERTY(QString address MEMBER address)

public:
    QString name;
    QString address;

    friend bool comparesEqual(const Contact &lhs, const Contact &rhs) noexcept
    {
        return lhs.name == rhs.name && lhs.address == rhs.address;
    }

    friend Qt::strong_ordering compareThreeWay(const Contact &lhs, const Contact  &rhs) noexcept
    {
        int cmp = lhs.name.compare(rhs.name);
        if (cmp == 0)
            cmp = lhs.address.compare(rhs.address);
        return Qt::compareThreeWay(cmp, 0);
    }

    Q_DECLARE_STRONGLY_ORDERED(Contact)
};

inline QDataStream &operator<<(QDataStream &stream, const Contact &contact)
{
    return stream << contact.name << contact.address;
}

inline QDataStream &operator>>(QDataStream &stream, Contact &contact)
{
    return stream >> contact.name >> contact.address;
}

class AddressWidget : public QTabWidget
{
    Q_OBJECT

public:
    explicit AddressWidget(QWidget *parent = nullptr);

    bool readFromFile();
    bool writeToFile();

    static QString fileName();

public slots:
    void showAddEntryDialog();
    void addEntry(const Contact &contact);
    void editEntry();
    void removeEntry();

signals:
    void selectionChanged (const QItemSelection &selected);

private:
    void setupTabs();

    NewAddressTab *newAddressTab;

    QList<Contact> contacts;
    using Adapter = decltype(QRangeModelAdapter(std::ref(contacts)));
    Adapter adapter;
};

template <>
struct QRangeModel::RowOptions<Contact>
{
    inline static QVariant headerData(int section, int role);
};
QVariant QRangeModel::RowOptions<Contact>::headerData(int section, int role)
{
    if (role == Qt::DisplayRole) {
        switch (section) {
        case 0:
            return AddressWidget::tr("Name");
        case 1:
            return AddressWidget::tr("Address");
        default:
            break;
        }
    }
    return {};
}

AddressWidget::AddressWidget(QWidget *parent)
    : QTabWidget(parent),
      newAddressTab(new NewAddressTab(this)),
      adapter(std::ref(contacts))
{
    connect(newAddressTab, &NewAddressTab::triggered, this, &AddressWidget::showAddEntryDialog);

    addTab(newAddressTab, tr("Address Book"));

    setupTabs();
}

void AddressWidget::setupTabs()
{
    const auto groups = { "ABC"_L1, "DEF"_L1, "GHI"_L1, "JKL"_L1, "MNO"_L1, "PQR"_L1,
                          "STU"_L1, "VW"_L1, "XYZ"_L1 };

    for (QLatin1StringView str : groups) {
        const auto regExp = QRegularExpression(QLatin1StringView("^[%1].*").arg(str),
                                               QRegularExpression::CaseInsensitiveOption);

        auto *proxyModel = new QSortFilterProxyModel(this);
        proxyModel->setSourceModel(adapter.model());
        proxyModel->setFilterRegularExpression(regExp);
        proxyModel->setFilterKeyColumn(0);

        auto *tableView = new QTableView;
        tableView->setModel(proxyModel);
        tableView->setSelectionBehavior(QAbstractItemView::SelectRows);
        tableView->horizontalHeader()->setStretchLastSection(true);
        tableView->verticalHeader()->hide();
        tableView->setEditTriggers(QAbstractItemView::NoEditTriggers);
        tableView->setSelectionMode(QAbstractItemView::SingleSelection);
        tableView->setSortingEnabled(true);

        connect(tableView->selectionModel(), &QItemSelectionModel::selectionChanged,
                this, &AddressWidget::selectionChanged);

        connect(this, &QTabWidget::currentChanged, this, [this, tableView](int tabIndex) {
            if (widget(tabIndex) == tableView)
                emit selectionChanged(tableView->selectionModel()->selection());
        });

        addTab(tableView, str);
    }
}

void AddressWidget::showAddEntryDialog()
{
    AddDialog aDialog(this);

    if (aDialog.exec() == QDialog::Accepted)
        addEntry(aDialog.contact());
}

void AddressWidget::addEntry(const Contact &contact)
{
    if (contacts.contains(contact)) {
        QMessageBox::information(this, tr("Duplicate Name"),
                                 tr("The name \"%1\" already exists.").arg(contact.name));
        return;
    }

    adapter.insertRow(adapter.rowCount(), contact);

    removeTab(indexOf(newAddressTab));

    const QChar firstChar = contact.name.at(0).toUpper();
    for (int t = 0, tabCount = count(); t < tabCount; ++t) {
        if (tabText(t).contains(firstChar)) {
            setCurrentIndex(t);
            break;
        }
    }
}

void AddressWidget::editEntry()
{
    auto *tableView = static_cast<QTableView *>(currentWidget());
    auto *proxy = static_cast<QSortFilterProxyModel *>(tableView->model());
    QItemSelectionModel *selectionModel = tableView->selectionModel();

    const QModelIndexList indexes = selectionModel->selectedRows();
    if (indexes.isEmpty())
        return;

    const int row = proxy->mapToSource(indexes.constFirst()).row();
    const Contact contact = contacts.at(row);

    AddDialog aDialog(this);
    aDialog.setWindowTitle(tr("Edit a Contact"));
    aDialog.editAddress(contact);

    if (aDialog.exec() == QDialog::Accepted) {
        const Contact newContact = aDialog.contact();
        if (newContact != contact)
            adapter[row] = newContact;
    }
}

void AddressWidget::removeEntry()
{
    auto *tableView = static_cast<QTableView *>(currentWidget());
    auto *proxy = static_cast<QSortFilterProxyModel *>(tableView->model());
    QItemSelectionModel *selectionModel = tableView->selectionModel();

    const QModelIndexList indexes = selectionModel->selectedRows();
    if (indexes.isEmpty())
        return;

    const int row = proxy->mapToSource(indexes.constFirst()).row();
    adapter.removeRow(row);

    if (adapter.rowCount() == 0)
        insertTab(0, newAddressTab, tr("Address Book"));
}

bool AddressWidget::writeToFile()
{
    QFile file(fileName());

    if (!file.open(QIODevice::WriteOnly)) {
        QMessageBox::information(this, tr("Unable to open file"),
                                 tr("Cannot write to %1: %2").arg(QDir::toNativeSeparators(fileName()),
                                                                  file.errorString()));
        return false;
    }

    auto sortedContacts = contacts;
    std::sort(sortedContacts.begin(), sortedContacts.end());

    QDataStream out(&file);
    out << sortedContacts;
    return true;
}

bool AddressWidget::readFromFile()
{
    QFile file(fileName());

    if (!file.open(QIODevice::ReadOnly)) {
        QMessageBox::information(this, tr("Unable to open file"),
                                 tr("Cannot open %1: %2").arg(QDir::toNativeSeparators(fileName()),
                                                              file.errorString()));
        return false;
    }

    QList<Contact> contactsIn;
    QDataStream in(&file);
    in >> contactsIn;

    if (contactsIn.isEmpty()) {
        QMessageBox::information(this, tr("No contacts in file"),
                                 tr("The file you are attempting to open contains no contacts."));
    }

    for (const auto &contact : std::as_const(contactsIn))
        addEntry(contact);

    return true;
}

class NewAddressTab : public QWidget
{
    Q_OBJECT

public:
    explicit NewAddressTab(QWidget *parent = nullptr);

signals:
    void triggered();
};

NewAddressTab::NewAddressTab(QWidget *parent)
    : QWidget(parent)
{
    auto *descriptionLabel = new QLabel(tr("There are currently no contacts in your address book. "
                                           "\nClick Add to add new contacts."));

    auto *addButton = new QPushButton(tr("Add"));

    connect(addButton, &QAbstractButton::clicked, this, &NewAddressTab::triggered);

    auto *mainLayout = new QVBoxLayout(this);
    mainLayout->addWidget(descriptionLabel, 0, Qt::AlignCenter);
    mainLayout->addWidget(addButton, 0, Qt::AlignCenter);
}

class AddDialog : public QDialog
{
    Q_OBJECT

public:
    explicit AddDialog(QWidget *parent = nullptr);

    Contact contact() const;
    void setContact(const Contact &c);

    void editAddress(const Contact &c);

private slots:
    void updateEnabled();

private:
    QDialogButtonBox *buttonBox;
    QLineEdit *nameText;
    QPlainTextEdit *addressText;
};

AddDialog::AddDialog(QWidget *parent)
    : QDialog(parent),
      buttonBox(new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, this)),
      nameText(new QLineEdit),
      addressText(new QPlainTextEdit)
{
    auto *formLayout = new QFormLayout;
    formLayout->addRow(tr("Name"), nameText);
    formLayout->addRow(tr("Address"), addressText);

    auto *mainLayout = new QVBoxLayout(this);
    mainLayout->addLayout(formLayout);
    mainLayout->addWidget(buttonBox);

    connect(buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
    connect(nameText, &QLineEdit::textChanged, this, &AddDialog::updateEnabled);
    connect(addressText, &QPlainTextEdit::textChanged, this, &AddDialog::updateEnabled);

    setWindowTitle(tr("Add a Contact"));

    updateEnabled();
}

void AddDialog::updateEnabled()
{
    Contact c = contact();
    const bool valid = !c.name.isEmpty() && c.name.front().isLetter() && !c.address.isEmpty();
    buttonBox->button(QDialogButtonBox::Ok)->setEnabled(valid);
}

Contact AddDialog::contact() const
{
    return { nameText->text().trimmed(), addressText->toPlainText().trimmed() };
}

void AddDialog::setContact(const Contact &c)
{
    nameText->setText(c.name);
    addressText->setPlainText(c.address);
    updateEnabled();
}

void AddDialog::editAddress(const Contact &c)
{
    nameText->setReadOnly(true);
    setContact(c);
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow();

private slots:
    void updateActions(const QItemSelection &selection);
    void openFile();
    void saveFile();

private:
    void createMenus();

    AddressWidget *addressWidget;
    QAction *editAct;
    QAction *removeAct;
};

MainWindow::MainWindow()
    : QMainWindow(),
      addressWidget(new AddressWidget)
{
    setCentralWidget(addressWidget);
    createMenus();
    setWindowTitle(tr("Address Book"));
}

void MainWindow::createMenus()
{
    QMenu *fileMenu = menuBar()->addMenu(tr("&File"));

    auto *openAct = new QAction(QIcon::fromTheme(QIcon::ThemeIcon::DocumentOpen),
                                tr("&Open..."), this);
    openAct->setShortcut(QKeySequence(QKeySequence::Open));
    fileMenu->addAction(openAct);
    connect(openAct, &QAction::triggered, this, &MainWindow::openFile);
    ...

    editAct = new QAction(tr("&Edit Entry..."), this);
    editAct->setEnabled(false);
    toolMenu->addAction(editAct);
    connect(editAct, &QAction::triggered, addressWidget, &AddressWidget::editEntry);

    toolMenu->addSeparator();

    removeAct = new QAction(tr("&Remove Entry"), this);
    removeAct->setEnabled(false);
    toolMenu->addAction(removeAct);
    connect(removeAct, &QAction::triggered, addressWidget, &AddressWidget::removeEntry);

    connect(addressWidget, &AddressWidget::selectionChanged,
            this, &MainWindow::updateActions);
}

void MainWindow::openFile()
{
    if (addressWidget->readFromFile())
        statusBar()->showMessage(tr("Read %1").arg(QDir::toNativeSeparators(AddressWidget::fileName())));
}

void MainWindow::saveFile()
{
    if (addressWidget->writeToFile())
        statusBar()->showMessage(tr("Wrote %1").arg(QDir::toNativeSeparators(AddressWidget::fileName())));
}

void MainWindow::updateActions(const QItemSelection &selection)
{
    const QModelIndexList indexes = selection.indexes();

    removeAct->setEnabled(!indexes.isEmpty());
    editAct->setEnabled(!indexes.isEmpty());
}

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    MainWindow mw;
    const auto availableGeometry = mw.screen()->availableGeometry();
    mw.resize(availableGeometry.width() / 3, availableGeometry.height() / 3);
    mw.show();
    return QApplication::exec();
}