diff --git a/src/qt/addressbookpage.cpp b/src/qt/addressbookpage.cpp
index 0e11a2e3a..62b9816f7 100644
--- a/src/qt/addressbookpage.cpp
+++ b/src/qt/addressbookpage.cpp
@@ -1,302 +1,322 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <qt/addressbookpage.h>
 #include <qt/forms/ui_addressbookpage.h>
 
 #include <qt/addresstablemodel.h>
 #include <qt/bitcoingui.h>
 #include <qt/csvmodelwriter.h>
 #include <qt/editaddressdialog.h>
 #include <qt/guiutil.h>
 #include <qt/platformstyle.h>
 
 #include <QIcon>
 #include <QMenu>
 #include <QMessageBox>
 #include <QSortFilterProxyModel>
 
 AddressBookPage::AddressBookPage(const PlatformStyle *platformStyle, Mode _mode,
                                  Tabs _tab, QWidget *parent)
     : QDialog(parent), ui(new Ui::AddressBookPage), model(0), mode(_mode),
       tab(_tab) {
     ui->setupUi(this);
 
     if (!platformStyle->getImagesOnButtons()) {
         ui->newAddress->setIcon(QIcon());
         ui->copyAddress->setIcon(QIcon());
         ui->deleteAddress->setIcon(QIcon());
         ui->exportButton->setIcon(QIcon());
     } else {
         ui->newAddress->setIcon(platformStyle->SingleColorIcon(":/icons/add"));
         ui->copyAddress->setIcon(
             platformStyle->SingleColorIcon(":/icons/editcopy"));
         ui->deleteAddress->setIcon(
             platformStyle->SingleColorIcon(":/icons/remove"));
         ui->exportButton->setIcon(
             platformStyle->SingleColorIcon(":/icons/export"));
     }
 
     switch (mode) {
         case ForSelection:
             switch (tab) {
                 case SendingTab:
                     setWindowTitle(tr("Choose the address to send coins to"));
                     break;
                 case ReceivingTab:
                     setWindowTitle(
                         tr("Choose the address to receive coins with"));
                     break;
             }
             connect(ui->tableView, SIGNAL(doubleClicked(QModelIndex)), this,
                     SLOT(accept()));
             ui->tableView->setEditTriggers(QAbstractItemView::NoEditTriggers);
             ui->tableView->setFocus();
             ui->closeButton->setText(tr("C&hoose"));
             ui->exportButton->hide();
             break;
         case ForEditing:
             switch (tab) {
                 case SendingTab:
                     setWindowTitle(tr("Sending addresses"));
                     break;
                 case ReceivingTab:
                     setWindowTitle(tr("Receiving addresses"));
                     break;
             }
             break;
     }
     switch (tab) {
         case SendingTab:
             ui->labelExplanation->setText(
                 tr("These are your Bitcoin addresses for sending payments. "
                    "Always check the amount and the receiving address before "
                    "sending coins."));
             ui->deleteAddress->setVisible(true);
             break;
         case ReceivingTab:
             ui->labelExplanation->setText(
                 tr("These are your Bitcoin addresses for receiving payments. "
                    "It is recommended to use a new receiving address for each "
                    "transaction."));
             ui->deleteAddress->setVisible(false);
             break;
     }
 
     // Context menu actions
     QAction *copyAddressAction = new QAction(tr("&Copy Address"), this);
     QAction *copyLabelAction = new QAction(tr("Copy &Label"), this);
     QAction *editAction = new QAction(tr("&Edit"), this);
     deleteAction = new QAction(ui->deleteAddress->text(), this);
 
     // Build context menu
     contextMenu = new QMenu(this);
     contextMenu->addAction(copyAddressAction);
     contextMenu->addAction(copyLabelAction);
     contextMenu->addAction(editAction);
-    if (tab == SendingTab) contextMenu->addAction(deleteAction);
+    if (tab == SendingTab) {
+        contextMenu->addAction(deleteAction);
+    }
     contextMenu->addSeparator();
 
     // Connect signals for context menu actions
     connect(copyAddressAction, SIGNAL(triggered()), this,
             SLOT(on_copyAddress_clicked()));
     connect(copyLabelAction, SIGNAL(triggered()), this,
             SLOT(onCopyLabelAction()));
     connect(editAction, SIGNAL(triggered()), this, SLOT(onEditAction()));
     connect(deleteAction, SIGNAL(triggered()), this,
             SLOT(on_deleteAddress_clicked()));
 
     connect(ui->tableView, SIGNAL(customContextMenuRequested(QPoint)), this,
             SLOT(contextualMenu(QPoint)));
 
     connect(ui->closeButton, SIGNAL(clicked()), this, SLOT(accept()));
 }
 
 AddressBookPage::~AddressBookPage() {
     delete ui;
 }
 
 void AddressBookPage::setModel(AddressTableModel *_model) {
     this->model = _model;
-    if (!_model) return;
+    if (!_model) {
+        return;
+    }
 
     proxyModel = new QSortFilterProxyModel(this);
     proxyModel->setSourceModel(_model);
     proxyModel->setDynamicSortFilter(true);
     proxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
     proxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
     switch (tab) {
         case ReceivingTab:
             // Receive filter
             proxyModel->setFilterRole(AddressTableModel::TypeRole);
             proxyModel->setFilterFixedString(AddressTableModel::Receive);
             break;
         case SendingTab:
             // Send filter
             proxyModel->setFilterRole(AddressTableModel::TypeRole);
             proxyModel->setFilterFixedString(AddressTableModel::Send);
             break;
     }
     ui->tableView->setModel(proxyModel);
     ui->tableView->sortByColumn(0, Qt::AscendingOrder);
 
     // Set column widths
     ui->tableView->horizontalHeader()->setSectionResizeMode(
         AddressTableModel::Label, QHeaderView::Stretch);
     ui->tableView->horizontalHeader()->setSectionResizeMode(
         AddressTableModel::Address, QHeaderView::ResizeToContents);
 
     connect(ui->tableView->selectionModel(),
             SIGNAL(selectionChanged(QItemSelection, QItemSelection)), this,
             SLOT(selectionChanged()));
 
     // Select row for newly created address
     connect(_model, SIGNAL(rowsInserted(QModelIndex, int, int)), this,
             SLOT(selectNewAddress(QModelIndex, int, int)));
 
     selectionChanged();
 }
 
 void AddressBookPage::on_copyAddress_clicked() {
     GUIUtil::copyEntryData(ui->tableView, AddressTableModel::Address);
 }
 
 void AddressBookPage::onCopyLabelAction() {
     GUIUtil::copyEntryData(ui->tableView, AddressTableModel::Label);
 }
 
 void AddressBookPage::onEditAction() {
-    if (!model) return;
+    if (!model) {
+        return;
+    }
 
-    if (!ui->tableView->selectionModel()) return;
+    if (!ui->tableView->selectionModel()) {
+        return;
+    }
     QModelIndexList indexes = ui->tableView->selectionModel()->selectedRows();
-    if (indexes.isEmpty()) return;
+    if (indexes.isEmpty()) {
+        return;
+    }
 
     EditAddressDialog dlg(tab == SendingTab
                               ? EditAddressDialog::EditSendingAddress
                               : EditAddressDialog::EditReceivingAddress,
                           this);
     dlg.setModel(model);
     QModelIndex origIndex = proxyModel->mapToSource(indexes.at(0));
     dlg.loadRow(origIndex.row());
     dlg.exec();
 }
 
 void AddressBookPage::on_newAddress_clicked() {
-    if (!model) return;
+    if (!model) {
+        return;
+    }
 
     EditAddressDialog dlg(tab == SendingTab
                               ? EditAddressDialog::NewSendingAddress
                               : EditAddressDialog::NewReceivingAddress,
                           this);
     dlg.setModel(model);
     if (dlg.exec()) {
         newAddressToSelect = dlg.getAddress();
     }
 }
 
 void AddressBookPage::on_deleteAddress_clicked() {
     QTableView *table = ui->tableView;
-    if (!table->selectionModel()) return;
+    if (!table->selectionModel()) {
+        return;
+    }
 
     QModelIndexList indexes = table->selectionModel()->selectedRows();
     if (!indexes.isEmpty()) {
         table->model()->removeRow(indexes.at(0).row());
     }
 }
 
 void AddressBookPage::selectionChanged() {
     // Set button states based on selected tab and selection
     QTableView *table = ui->tableView;
-    if (!table->selectionModel()) return;
+    if (!table->selectionModel()) {
+        return;
+    }
 
     if (table->selectionModel()->hasSelection()) {
         switch (tab) {
             case SendingTab:
                 // In sending tab, allow deletion of selection
                 ui->deleteAddress->setEnabled(true);
                 ui->deleteAddress->setVisible(true);
                 deleteAction->setEnabled(true);
                 break;
             case ReceivingTab:
                 // Deleting receiving addresses, however, is not allowed
                 ui->deleteAddress->setEnabled(false);
                 ui->deleteAddress->setVisible(false);
                 deleteAction->setEnabled(false);
                 break;
         }
         ui->copyAddress->setEnabled(true);
     } else {
         ui->deleteAddress->setEnabled(false);
         ui->copyAddress->setEnabled(false);
     }
 }
 
 void AddressBookPage::done(int retval) {
     QTableView *table = ui->tableView;
-    if (!table->selectionModel() || !table->model()) return;
+    if (!table->selectionModel() || !table->model()) {
+        return;
+    }
 
     // Figure out which address was selected, and return it
     QModelIndexList indexes =
         table->selectionModel()->selectedRows(AddressTableModel::Address);
 
     for (const QModelIndex &index : indexes) {
         QVariant address = table->model()->data(index);
         returnValue = address.toString();
     }
 
     if (returnValue.isEmpty()) {
         // If no address entry selected, return rejected
         retval = Rejected;
     }
 
     QDialog::done(retval);
 }
 
 void AddressBookPage::on_exportButton_clicked() {
     // CSV is currently the only supported format
     QString filename =
         GUIUtil::getSaveFileName(this, tr("Export Address List"), QString(),
                                  tr("Comma separated file (*.csv)"), nullptr);
 
-    if (filename.isNull()) return;
+    if (filename.isNull()) {
+        return;
+    }
 
     CSVModelWriter writer(filename);
 
     // name, column, role
     writer.setModel(proxyModel);
     writer.addColumn("Label", AddressTableModel::Label, Qt::EditRole);
     writer.addColumn("Address", AddressTableModel::Address, Qt::EditRole);
 
     if (!writer.write()) {
         QMessageBox::critical(this, tr("Exporting Failed"),
                               tr("There was an error trying to save the "
                                  "address list to %1. Please try again.")
                                   .arg(filename));
     }
 }
 
 void AddressBookPage::contextualMenu(const QPoint &point) {
     QModelIndex index = ui->tableView->indexAt(point);
     if (index.isValid()) {
         contextMenu->exec(QCursor::pos());
     }
 }
 
 void AddressBookPage::selectNewAddress(const QModelIndex &parent, int begin,
                                        int /*end*/) {
     QModelIndex idx = proxyModel->mapFromSource(
         model->index(begin, AddressTableModel::Address, parent));
     if (idx.isValid() &&
         (idx.data(Qt::EditRole).toString() == newAddressToSelect)) {
         // Select row of newly created address, once
         ui->tableView->setFocus();
         ui->tableView->selectRow(idx.row());
         newAddressToSelect.clear();
     }
 }
diff --git a/src/qt/addressbookpage.h b/src/qt/addressbookpage.h
index 8d3660450..6cb7b4d7d 100644
--- a/src/qt/addressbookpage.h
+++ b/src/qt/addressbookpage.h
@@ -1,85 +1,88 @@
 // Copyright (c) 2011-2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_QT_ADDRESSBOOKPAGE_H
 #define BITCOIN_QT_ADDRESSBOOKPAGE_H
 
 #include <QDialog>
 
 class AddressTableModel;
 class PlatformStyle;
 
 namespace Ui {
 class AddressBookPage;
 }
 
 QT_BEGIN_NAMESPACE
 class QItemSelection;
 class QMenu;
 class QModelIndex;
 class QSortFilterProxyModel;
 QT_END_NAMESPACE
 
 /** Widget that shows a list of sending or receiving addresses. */
 class AddressBookPage : public QDialog {
     Q_OBJECT
 
 public:
     enum Tabs { SendingTab = 0, ReceivingTab = 1 };
 
     enum Mode {
         ForSelection, /**< Open address book to pick address */
         ForEditing    /**< Open address book for editing */
     };
 
     explicit AddressBookPage(const PlatformStyle *platformStyle, Mode mode,
                              Tabs tab, QWidget *parent);
     ~AddressBookPage();
 
     void setModel(AddressTableModel *model);
     const QString &getReturnValue() const { return returnValue; }
 
 public Q_SLOTS:
     void done(int retval) override;
 
 private:
     Ui::AddressBookPage *ui;
     AddressTableModel *model;
     Mode mode;
     Tabs tab;
     QString returnValue;
     QSortFilterProxyModel *proxyModel;
     QMenu *contextMenu;
     // to be able to explicitly disable it
     QAction *deleteAction;
     QString newAddressToSelect;
 
 private Q_SLOTS:
     /** Delete currently selected address entry */
     void on_deleteAddress_clicked();
-    /** Create a new address for receiving coins and / or add a new address book
-     * entry */
+    /**
+     * Create a new address for receiving coins and / or add a new address book
+     * entry.
+     */
     void on_newAddress_clicked();
     /** Copy address of currently selected address entry to clipboard */
     void on_copyAddress_clicked();
-    /** Copy label of currently selected address entry to clipboard (no button)
+    /**
+     * Copy label of currently selected address entry to clipboard (no button)
      */
     void onCopyLabelAction();
     /** Edit currently selected address entry (no button) */
     void onEditAction();
     /** Export button clicked */
     void on_exportButton_clicked();
 
     /** Set button states based on selected tab and selection */
     void selectionChanged();
     /** Spawn contextual menu (right mouse menu) for address book entry */
     void contextualMenu(const QPoint &point);
     /** New entry/entries were added to address table */
     void selectNewAddress(const QModelIndex &parent, int begin, int /*end*/);
 
 Q_SIGNALS:
     void sendCoins(QString addr);
 };
 
 #endif // BITCOIN_QT_ADDRESSBOOKPAGE_H
diff --git a/src/qt/addresstablemodel.cpp b/src/qt/addresstablemodel.cpp
index 3914dd79e..6d0007d58 100644
--- a/src/qt/addresstablemodel.cpp
+++ b/src/qt/addresstablemodel.cpp
@@ -1,400 +1,406 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/addresstablemodel.h>
 
 #include <dstencode.h>
 #include <interfaces/node.h>
 #include <qt/guiutil.h>
 #include <qt/walletmodel.h>
 #include <wallet/wallet.h>
 
 #include <QDebug>
 #include <QFont>
 
 const QString AddressTableModel::Send = "S";
 const QString AddressTableModel::Receive = "R";
 
 struct AddressTableEntry {
     enum Type {
         Sending,
         Receiving,
         /* QSortFilterProxyModel will filter these out */
         Hidden
     };
 
     Type type;
     QString label;
     QString address;
 
     AddressTableEntry() {}
     AddressTableEntry(Type _type, const QString &_label,
                       const QString &_address)
         : type(_type), label(_label), address(_address) {}
 };
 
 struct AddressTableEntryLessThan {
     bool operator()(const AddressTableEntry &a,
                     const AddressTableEntry &b) const {
         return a.address < b.address;
     }
     bool operator()(const AddressTableEntry &a, const QString &b) const {
         return a.address < b;
     }
     bool operator()(const QString &a, const AddressTableEntry &b) const {
         return a < b.address;
     }
 };
 
 /* Determine address type from address purpose */
 static AddressTableEntry::Type
 translateTransactionType(const QString &strPurpose, bool isMine) {
     AddressTableEntry::Type addressType = AddressTableEntry::Hidden;
     // "refund" addresses aren't shown, and change addresses aren't in
     // mapAddressBook at all.
-    if (strPurpose == "send")
+    if (strPurpose == "send") {
         addressType = AddressTableEntry::Sending;
-    else if (strPurpose == "receive")
+    } else if (strPurpose == "receive") {
         addressType = AddressTableEntry::Receiving;
-    else if (strPurpose == "unknown" || strPurpose == "") {
+    } else if (strPurpose == "unknown" || strPurpose == "") {
         // if purpose not set, guess
         addressType = (isMine ? AddressTableEntry::Receiving
                               : AddressTableEntry::Sending);
     }
     return addressType;
 }
 
 // Private implementation
 class AddressTablePriv {
 public:
     QList<AddressTableEntry> cachedAddressTable;
     AddressTableModel *parent;
 
     AddressTablePriv(AddressTableModel *_parent) : parent(_parent) {}
 
     void refreshAddressTable(interfaces::Wallet &wallet) {
         cachedAddressTable.clear();
         for (const auto &address : wallet.getAddresses()) {
             AddressTableEntry::Type addressType = translateTransactionType(
                 QString::fromStdString(address.purpose), address.is_mine);
             cachedAddressTable.append(AddressTableEntry(
                 addressType, QString::fromStdString(address.name),
                 QString::fromStdString(EncodeDestination(address.dest))));
         }
         // qLowerBound() and qUpperBound() require our cachedAddressTable list
         // to be sorted in asc order. Even though the map is already sorted this
         // re-sorting step is needed because the originating map is sorted by
         // binary address, not by base58() address.
         qSort(cachedAddressTable.begin(), cachedAddressTable.end(),
               AddressTableEntryLessThan());
     }
 
     void updateEntry(const QString &address, const QString &label, bool isMine,
                      const QString &purpose, int status) {
         // Find address / label in model
         QList<AddressTableEntry>::iterator lower =
             qLowerBound(cachedAddressTable.begin(), cachedAddressTable.end(),
                         address, AddressTableEntryLessThan());
         QList<AddressTableEntry>::iterator upper =
             qUpperBound(cachedAddressTable.begin(), cachedAddressTable.end(),
                         address, AddressTableEntryLessThan());
         int lowerIndex = (lower - cachedAddressTable.begin());
         int upperIndex = (upper - cachedAddressTable.begin());
         bool inModel = (lower != upper);
         AddressTableEntry::Type newEntryType =
             translateTransactionType(purpose, isMine);
 
         switch (status) {
             case CT_NEW:
                 if (inModel) {
                     qWarning() << "AddressTablePriv::updateEntry: Warning: Got "
                                   "CT_NEW, but entry is already in model";
                     break;
                 }
                 parent->beginInsertRows(QModelIndex(), lowerIndex, lowerIndex);
                 cachedAddressTable.insert(
                     lowerIndex,
                     AddressTableEntry(newEntryType, label, address));
                 parent->endInsertRows();
                 break;
             case CT_UPDATED:
                 if (!inModel) {
                     qWarning() << "AddressTablePriv::updateEntry: Warning: Got "
                                   "CT_UPDATED, but entry is not in model";
                     break;
                 }
                 lower->type = newEntryType;
                 lower->label = label;
                 parent->emitDataChanged(lowerIndex);
                 break;
             case CT_DELETED:
                 if (!inModel) {
                     qWarning() << "AddressTablePriv::updateEntry: Warning: Got "
                                   "CT_DELETED, but entry is not in model";
                     break;
                 }
                 parent->beginRemoveRows(QModelIndex(), lowerIndex,
                                         upperIndex - 1);
                 cachedAddressTable.erase(lower, upper);
                 parent->endRemoveRows();
                 break;
         }
     }
 
     int size() { return cachedAddressTable.size(); }
 
     AddressTableEntry *index(int idx) {
         if (idx >= 0 && idx < cachedAddressTable.size()) {
             return &cachedAddressTable[idx];
         } else {
             return nullptr;
         }
     }
 };
 
 AddressTableModel::AddressTableModel(WalletModel *parent)
     : QAbstractTableModel(parent), walletModel(parent), priv(0) {
     columns << tr("Label") << tr("Address");
     priv = new AddressTablePriv(this);
     priv->refreshAddressTable(parent->wallet());
 }
 
 AddressTableModel::~AddressTableModel() {
     delete priv;
 }
 
 int AddressTableModel::rowCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return priv->size();
 }
 
 int AddressTableModel::columnCount(const QModelIndex &parent) const {
     Q_UNUSED(parent);
     return columns.length();
 }
 
 QVariant AddressTableModel::data(const QModelIndex &index, int role) const {
-    if (!index.isValid()) return QVariant();
+    if (!index.isValid()) {
+        return QVariant();
+    }
 
     AddressTableEntry *rec =
         static_cast<AddressTableEntry *>(index.internalPointer());
 
     if (role == Qt::DisplayRole || role == Qt::EditRole) {
         switch (index.column()) {
             case Label:
                 if (rec->label.isEmpty() && role == Qt::DisplayRole) {
                     return tr("(no label)");
                 } else {
                     return rec->label;
                 }
             case Address:
                 return rec->address;
         }
     } else if (role == Qt::FontRole) {
         QFont font;
         if (index.column() == Address) {
             font = GUIUtil::fixedPitchFont();
         }
         return font;
     } else if (role == TypeRole) {
         switch (rec->type) {
             case AddressTableEntry::Sending:
                 return Send;
             case AddressTableEntry::Receiving:
                 return Receive;
             default:
                 break;
         }
     }
     return QVariant();
 }
 
 bool AddressTableModel::setData(const QModelIndex &index, const QVariant &value,
                                 int role) {
-    if (!index.isValid()) return false;
+    if (!index.isValid()) {
+        return false;
+    }
     AddressTableEntry *rec =
         static_cast<AddressTableEntry *>(index.internalPointer());
     std::string strPurpose =
         (rec->type == AddressTableEntry::Sending ? "send" : "receive");
     editStatus = OK;
 
     if (role == Qt::EditRole) {
         CTxDestination curAddress = DecodeDestination(
             rec->address.toStdString(), walletModel->getChainParams());
         if (index.column() == Label) {
             // Do nothing, if old label == new label
             if (rec->label == value.toString()) {
                 editStatus = NO_CHANGES;
                 return false;
             }
             walletModel->wallet().setAddressBook(
                 curAddress, value.toString().toStdString(), strPurpose);
         } else if (index.column() == Address) {
             CTxDestination newAddress = DecodeDestination(
                 value.toString().toStdString(), walletModel->getChainParams());
             // Refuse to set invalid address, set error status and return false
             if (boost::get<CNoDestination>(&newAddress)) {
                 editStatus = INVALID_ADDRESS;
                 return false;
             }
             // Do nothing, if old address == new address
             else if (newAddress == curAddress) {
                 editStatus = NO_CHANGES;
                 return false;
             }
             // Check for duplicate addresses to prevent accidental deletion of
             // addresses, if you try to paste an existing address over another
             // address (with a different label)
             if (walletModel->wallet().getAddress(newAddress)) {
                 editStatus = DUPLICATE_ADDRESS;
                 return false;
             }
             // Double-check that we're not overwriting a receiving address
             else if (rec->type == AddressTableEntry::Sending) {
                 // Remove old entry
                 walletModel->wallet().delAddressBook(curAddress);
                 // Add new entry with new address
                 walletModel->wallet().setAddressBook(
                     newAddress, value.toString().toStdString(), strPurpose);
             }
         }
         return true;
     }
     return false;
 }
 
 QVariant AddressTableModel::headerData(int section, Qt::Orientation orientation,
                                        int role) const {
     if (orientation == Qt::Horizontal) {
         if (role == Qt::DisplayRole && section < columns.size()) {
             return columns[section];
         }
     }
     return QVariant();
 }
 
 Qt::ItemFlags AddressTableModel::flags(const QModelIndex &index) const {
-    if (!index.isValid()) return 0;
+    if (!index.isValid()) {
+        return 0;
+    }
     AddressTableEntry *rec =
         static_cast<AddressTableEntry *>(index.internalPointer());
 
     Qt::ItemFlags retval = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
     // Can edit address and label for sending addresses, and only label for
     // receiving addresses.
     if (rec->type == AddressTableEntry::Sending ||
         (rec->type == AddressTableEntry::Receiving &&
          index.column() == Label)) {
         retval |= Qt::ItemIsEditable;
     }
     return retval;
 }
 
 QModelIndex AddressTableModel::index(int row, int column,
                                      const QModelIndex &parent) const {
     Q_UNUSED(parent);
     AddressTableEntry *data = priv->index(row);
     if (data) {
         return createIndex(row, column, priv->index(row));
     } else {
         return QModelIndex();
     }
 }
 
 void AddressTableModel::updateEntry(const QString &address,
                                     const QString &label, bool isMine,
                                     const QString &purpose, int status) {
     // Update address book model from Bitcoin core
     priv->updateEntry(address, label, isMine, purpose, status);
 }
 
 QString AddressTableModel::addRow(const QString &type, const QString &label,
                                   const QString &address) {
     std::string strLabel = label.toStdString();
     std::string strAddress = address.toStdString();
 
     editStatus = OK;
 
     if (type == Send) {
         if (!walletModel->validateAddress(address)) {
             editStatus = INVALID_ADDRESS;
             return QString();
         }
         // Check for duplicate addresses
         if (walletModel->wallet().getAddress(
                 DecodeDestination(strAddress, walletModel->getChainParams()))) {
             editStatus = DUPLICATE_ADDRESS;
             return QString();
         }
     } else if (type == Receive) {
         // Generate a new address to associate with given label
         CPubKey newKey;
         if (!walletModel->wallet().getKeyFromPool(false /* internal */,
                                                   newKey)) {
             WalletModel::UnlockContext ctx(walletModel->requestUnlock());
             if (!ctx.isValid()) {
                 // Unlock wallet failed or was cancelled
                 editStatus = WALLET_UNLOCK_FAILURE;
                 return QString();
             }
             if (!walletModel->wallet().getKeyFromPool(false /* internal */,
                                                       newKey)) {
                 editStatus = KEY_GENERATION_FAILURE;
                 return QString();
             }
         }
         walletModel->wallet().learnRelatedScripts(newKey, g_address_type);
         strAddress =
             EncodeDestination(GetDestinationForKey(newKey, g_address_type));
     } else {
         return QString();
     }
 
     // Add entry
     walletModel->wallet().setAddressBook(
         DecodeDestination(strAddress, walletModel->getChainParams()), strLabel,
         (type == Send ? "send" : "receive"));
     return QString::fromStdString(strAddress);
 }
 
 bool AddressTableModel::removeRows(int row, int count,
                                    const QModelIndex &parent) {
     Q_UNUSED(parent);
     AddressTableEntry *rec = priv->index(row);
     if (count != 1 || !rec || rec->type == AddressTableEntry::Receiving) {
         // Can only remove one row at a time, and cannot remove rows not in
         // model.
         // Also refuse to remove receiving addresses.
         return false;
     }
     walletModel->wallet().delAddressBook(DecodeDestination(
         rec->address.toStdString(), walletModel->getChainParams()));
     return true;
 }
 
 /* Look up label for address in address book, if not found return empty string.
  */
 QString AddressTableModel::labelForAddress(const QString &address) const {
     CTxDestination destination =
         DecodeDestination(address.toStdString(), walletModel->getChainParams());
     std::string name;
     if (walletModel->wallet().getAddress(destination, &name)) {
         return QString::fromStdString(name);
     }
     return QString();
 }
 
 int AddressTableModel::lookupAddress(const QString &address) const {
     QModelIndexList lst = match(index(0, Address, QModelIndex()), Qt::EditRole,
                                 address, 1, Qt::MatchExactly);
     if (lst.isEmpty()) {
         return -1;
     } else {
         return lst.at(0).row();
     }
 }
 
 void AddressTableModel::emitDataChanged(int idx) {
     Q_EMIT dataChanged(index(idx, 0, QModelIndex()),
                        index(idx, columns.length() - 1, QModelIndex()));
 }
diff --git a/src/qt/editaddressdialog.cpp b/src/qt/editaddressdialog.cpp
index 4b01731f3..8b6c05cb9 100644
--- a/src/qt/editaddressdialog.cpp
+++ b/src/qt/editaddressdialog.cpp
@@ -1,128 +1,134 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <qt/editaddressdialog.h>
 #include <qt/forms/ui_editaddressdialog.h>
 
 #include <qt/addresstablemodel.h>
 #include <qt/guiutil.h>
 
 #include <QDataWidgetMapper>
 #include <QMessageBox>
 
 EditAddressDialog::EditAddressDialog(Mode _mode, QWidget *parent)
     : QDialog(parent), ui(new Ui::EditAddressDialog), mapper(0), mode(_mode),
       model(0) {
     ui->setupUi(this);
 
     GUIUtil::setupAddressWidget(ui->addressEdit, this);
 
     switch (mode) {
         case NewReceivingAddress:
             setWindowTitle(tr("New receiving address"));
             ui->addressEdit->setEnabled(false);
             break;
         case NewSendingAddress:
             setWindowTitle(tr("New sending address"));
             break;
         case EditReceivingAddress:
             setWindowTitle(tr("Edit receiving address"));
             ui->addressEdit->setEnabled(false);
             break;
         case EditSendingAddress:
             setWindowTitle(tr("Edit sending address"));
             break;
     }
 
     mapper = new QDataWidgetMapper(this);
     mapper->setSubmitPolicy(QDataWidgetMapper::ManualSubmit);
 }
 
 EditAddressDialog::~EditAddressDialog() {
     delete ui;
 }
 
 void EditAddressDialog::setModel(AddressTableModel *_model) {
     this->model = _model;
-    if (!_model) return;
+    if (!_model) {
+        return;
+    }
 
     mapper->setModel(_model);
     mapper->addMapping(ui->labelEdit, AddressTableModel::Label);
     mapper->addMapping(ui->addressEdit, AddressTableModel::Address);
 }
 
 void EditAddressDialog::loadRow(int row) {
     mapper->setCurrentIndex(row);
 }
 
 bool EditAddressDialog::saveCurrentRow() {
-    if (!model) return false;
+    if (!model) {
+        return false;
+    }
 
     switch (mode) {
         case NewReceivingAddress:
         case NewSendingAddress:
             address = model->addRow(
                 mode == NewSendingAddress ? AddressTableModel::Send
                                           : AddressTableModel::Receive,
                 ui->labelEdit->text(), ui->addressEdit->text());
             break;
         case EditReceivingAddress:
         case EditSendingAddress:
             if (mapper->submit()) {
                 address = ui->addressEdit->text();
             }
             break;
     }
     return !address.isEmpty();
 }
 
 void EditAddressDialog::accept() {
-    if (!model) return;
+    if (!model) {
+        return;
+    }
 
     if (!saveCurrentRow()) {
         switch (model->getEditStatus()) {
             case AddressTableModel::OK:
                 // Failed with unknown reason. Just reject.
                 break;
             case AddressTableModel::NO_CHANGES:
                 // No changes were made during edit operation. Just reject.
                 break;
             case AddressTableModel::INVALID_ADDRESS:
                 QMessageBox::warning(this, windowTitle(),
                                      tr("The entered address \"%1\" is not a "
                                         "valid Bitcoin address.")
                                          .arg(ui->addressEdit->text()),
                                      QMessageBox::Ok, QMessageBox::Ok);
                 break;
             case AddressTableModel::DUPLICATE_ADDRESS:
                 QMessageBox::warning(this, windowTitle(),
                                      tr("The entered address \"%1\" is already "
                                         "in the address book.")
                                          .arg(ui->addressEdit->text()),
                                      QMessageBox::Ok, QMessageBox::Ok);
                 break;
             case AddressTableModel::WALLET_UNLOCK_FAILURE:
                 QMessageBox::critical(this, windowTitle(),
                                       tr("Could not unlock wallet."),
                                       QMessageBox::Ok, QMessageBox::Ok);
                 break;
             case AddressTableModel::KEY_GENERATION_FAILURE:
                 QMessageBox::critical(this, windowTitle(),
                                       tr("New key generation failed."),
                                       QMessageBox::Ok, QMessageBox::Ok);
                 break;
         }
         return;
     }
     QDialog::accept();
 }
 
 QString EditAddressDialog::getAddress() const {
     return address;
 }
 
 void EditAddressDialog::setAddress(const QString &_address) {
     this->address = _address;
     ui->addressEdit->setText(_address);
 }
diff --git a/src/qt/editaddressdialog.h b/src/qt/editaddressdialog.h
index 6af8a6fe3..ac90c9884 100644
--- a/src/qt/editaddressdialog.h
+++ b/src/qt/editaddressdialog.h
@@ -1,56 +1,57 @@
 // Copyright (c) 2011-2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_QT_EDITADDRESSDIALOG_H
 #define BITCOIN_QT_EDITADDRESSDIALOG_H
 
 #include <QDialog>
 
 class AddressTableModel;
 
 namespace Ui {
 class EditAddressDialog;
 }
 
 QT_BEGIN_NAMESPACE
 class QDataWidgetMapper;
 QT_END_NAMESPACE
 
-/** Dialog for editing an address and associated information.
+/**
+ * Dialog for editing an address and associated information.
  */
 class EditAddressDialog : public QDialog {
     Q_OBJECT
 
 public:
     enum Mode {
         NewReceivingAddress,
         NewSendingAddress,
         EditReceivingAddress,
         EditSendingAddress
     };
 
     explicit EditAddressDialog(Mode mode, QWidget *parent);
     ~EditAddressDialog();
 
     void setModel(AddressTableModel *model);
     void loadRow(int row);
 
     QString getAddress() const;
     void setAddress(const QString &address);
 
 public Q_SLOTS:
     void accept() override;
 
 private:
     bool saveCurrentRow();
 
     Ui::EditAddressDialog *ui;
     QDataWidgetMapper *mapper;
     Mode mode;
     AddressTableModel *model;
 
     QString address;
 };
 
 #endif // BITCOIN_QT_EDITADDRESSDIALOG_H