diff --git a/forms/mainwindow.ui b/forms/mainwindow.ui
index 7d391d3b..53224385 100644
--- a/forms/mainwindow.ui
+++ b/forms/mainwindow.ui
@@ -351,12 +351,6 @@
                      <property name="autoFillBackground">
                       <bool>false</bool>
                      </property>
-                     <property name="transformationAnchor">
-                      <enum>QGraphicsView::ViewportAnchor::AnchorUnderMouse</enum>
-                     </property>
-                     <property name="resizeAnchor">
-                      <enum>QGraphicsView::ViewportAnchor::AnchorUnderMouse</enum>
-                     </property>
                     </widget>
                    </item>
                   </layout>
@@ -2435,6 +2429,9 @@
                   </item>
                   <item row="1" column="0">
                    <widget class="QToolButton" name="button_OpenDiveMap">
+                    <property name="enabled">
+                     <bool>false</bool>
+                    </property>
                     <property name="toolTip">
                      <string>Open the selected Dive Map</string>
                     </property>
@@ -2569,6 +2566,9 @@
                   </item>
                   <item row="0" column="0">
                    <widget class="QToolButton" name="button_OpenEmergeMap">
+                    <property name="enabled">
+                     <bool>false</bool>
+                    </property>
                     <property name="toolTip">
                      <string>Open the selected Emerge Map</string>
                     </property>
@@ -2589,7 +2589,7 @@
                  <property name="orientation">
                   <enum>Qt::Orientation::Horizontal</enum>
                  </property>
-                 <widget class="QGraphicsView" name="graphicsView_Connections">
+                 <widget class="ConnectionsView" name="graphicsView_Connections">
                   <property name="sizePolicy">
                    <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
                     <horstretch>0</horstretch>
@@ -3313,9 +3313,14 @@
   </customwidget>
   <customwidget>
    <class>MapView</class>
-   <extends>QWidget</extends>
+   <extends>QGraphicsView</extends>
    <header>mapview.h</header>
   </customwidget>
+  <customwidget>
+   <class>ConnectionsView</class>
+   <extends>QGraphicsView</extends>
+   <header>graphicsview.h</header>
+  </customwidget>
   <customwidget>
    <class>MapTree</class>
    <extends>QTreeView</extends>
@@ -3324,7 +3329,7 @@
   <customwidget>
    <class>NoScrollGraphicsView</class>
    <extends>QGraphicsView</extends>
-   <header>mapview.h</header>
+   <header>graphicsview.h</header>
   </customwidget>
   <customwidget>
    <class>MapListToolBar</class>
diff --git a/include/core/map.h b/include/core/map.h
index 8c4bead4..43b0619f 100644
--- a/include/core/map.h
+++ b/include/core/map.h
@@ -83,6 +83,7 @@ public:
 
     void deleteConnections();
     QList<MapConnection*> getConnections() const { return m_connections; }
+    MapConnection* getConnection(const QString &direction) const;
     void removeConnection(MapConnection *);
     void addConnection(MapConnection *);
     void loadConnection(MapConnection *);
diff --git a/include/editor.h b/include/editor.h
index 66b367cd..58588b0e 100644
--- a/include/editor.h
+++ b/include/editor.h
@@ -92,14 +92,16 @@ public:
     void setConnectionsVisibility(bool visible);
     void updateDivingMapsVisibility();
     void renderDivingConnections();
-    void addConnection(MapConnection* connection);
+    void addNewConnection(const QString &mapName, const QString &direction);
+    void replaceConnection(const QString &mapName, const QString &direction);
     void removeConnection(MapConnection* connection);
+    void removeSelectedConnection();
     void addNewWildMonGroup(QWidget *window);
     void deleteWildMonGroup();
     void configureEncounterJSON(QWidget *);
     EncounterTableModel* getCurrentWildMonTable();
-    void updateDiveMap(QString mapName);
-    void updateEmergeMap(QString mapName);
+    bool setDivingMapName(const QString &mapName, const QString &direction);
+    QString getDivingMapName(const QString &direction) const;
     void setSelectedConnection(MapConnection *connection);
 
     void updatePrimaryTileset(QString tilesetLabel, bool forceLoad = false);
@@ -219,8 +221,9 @@ private:
     void removeConnectionPixmap(MapConnection *connection);
     void displayConnection(MapConnection *connection);
     void displayDivingConnection(MapConnection *connection);
-    void setDivingMapName(QString mapName, QString direction);
     void removeDivingMapPixmap(MapConnection *connection);
+    void onDivingMapEditingFinished(NoScrollComboBox* combo, const QString &direction);
+    void updateDivingMapButton(QToolButton* button, const QString &mapName);
     void updateEncounterFields(EncounterFields newFields);
     QString getMovementPermissionText(uint16_t collision, uint16_t elevation);
     QString getMetatileDisplayMessage(uint16_t metatileId);
diff --git a/include/mainwindow.h b/include/mainwindow.h
index de790d63..21dcce5a 100644
--- a/include/mainwindow.h
+++ b/include/mainwindow.h
@@ -243,8 +243,6 @@ private slots:
     void on_pushButton_AddConnection_clicked();
     void on_button_OpenDiveMap_clicked();
     void on_button_OpenEmergeMap_clicked();
-    void on_comboBox_DiveMap_currentTextChanged(const QString &mapName);
-    void on_comboBox_EmergeMap_currentTextChanged(const QString &mapName);
     void on_comboBox_PrimaryTileset_currentTextChanged(const QString &arg1);
     void on_comboBox_SecondaryTileset_currentTextChanged(const QString &arg1);
     void on_pushButton_ChangeDimensions_clicked();
diff --git a/include/ui/connectionpixmapitem.h b/include/ui/connectionpixmapitem.h
index 26b83aa6..32e309f9 100644
--- a/include/ui/connectionpixmapitem.h
+++ b/include/ui/connectionpixmapitem.h
@@ -43,8 +43,6 @@ protected:
     virtual void mousePressEvent(QGraphicsSceneMouseEvent*) override;
     virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent*) override;
     virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent*) override;
-    virtual void keyPressEvent(QKeyEvent*) override;
-    virtual void focusInEvent(QFocusEvent*) override;
 
 signals:
     void connectionItemDoubleClicked(MapConnection*);
diff --git a/include/ui/connectionslistitem.h b/include/ui/connectionslistitem.h
index b63922a9..1b9713cf 100644
--- a/include/ui/connectionslistitem.h
+++ b/include/ui/connectionslistitem.h
@@ -36,19 +36,17 @@ private:
 
 protected:
     virtual void mousePressEvent(QMouseEvent*) override;
-    virtual void focusInEvent(QFocusEvent*) override;
-    virtual void keyPressEvent(QKeyEvent*) override;
+    virtual bool eventFilter(QObject*, QEvent *event) override;
 
 signals:
     void selected();
     void openMapClicked(MapConnection*);
 
-private slots:
-    void on_comboBox_Direction_currentTextChanged(QString direction);
-    void on_comboBox_Map_currentTextChanged(QString mapName);
-    void on_spinBox_Offset_valueChanged(int offset);
-    void on_button_Delete_clicked();
-    void on_button_OpenMap_clicked();
+private:
+    void commitDirection();
+    void commitMap(const QString &mapName);
+    void commitMove(int offset);
+    void commitRemove();
 };
 
 #endif // CONNECTIONSLISTITEM_H
diff --git a/include/ui/graphicsview.h b/include/ui/graphicsview.h
index 92771cf7..0ca36239 100644
--- a/include/ui/graphicsview.h
+++ b/include/ui/graphicsview.h
@@ -32,6 +32,19 @@ signals:
     void clicked(QMouseEvent *event);
 };
 
+class ConnectionsView : public QGraphicsView
+{
+    Q_OBJECT
+public:
+    ConnectionsView(QWidget *parent = nullptr) : QGraphicsView(parent) {}
+
+signals:
+    void pressedDelete();
+
+protected:
+    virtual void keyPressEvent(QKeyEvent *event) override;
+};
+
 class Editor;
 
 // TODO: This should just be MapView. It makes map-based assumptions, and no other class inherits GraphicsView.
diff --git a/include/ui/newmapconnectiondialog.h b/include/ui/newmapconnectiondialog.h
index 4781c971..db9eee49 100644
--- a/include/ui/newmapconnectiondialog.h
+++ b/include/ui/newmapconnectiondialog.h
@@ -20,13 +20,16 @@ public:
     virtual void accept() override;
 
 signals:
-    void accepted(MapConnection *result);
+    void newConnectionedAdded(const QString &mapName, const QString &direction);
+    void connectionReplaced(const QString &mapName, const QString &direction);
 
 private:
     Ui::NewMapConnectionDialog *ui;
+    Map *m_map;
 
     bool mapNameIsValid();
     void setWarningVisible(bool visible);
+    bool askReplaceConnection(MapConnection *connection, const QString &newMapName);
 };
 
 #endif // NEWMAPCONNECTIONDIALOG_H
diff --git a/include/ui/noscrollcombobox.h b/include/ui/noscrollcombobox.h
index 32966b3a..0ae2487c 100644
--- a/include/ui/noscrollcombobox.h
+++ b/include/ui/noscrollcombobox.h
@@ -18,6 +18,9 @@ public:
     void setLineEdit(QLineEdit *edit);
     void setFocusedScrollingEnabled(bool enabled);
 
+signals:
+    void editingFinished();
+
 private:
     void setItem(int index, const QString &text);
 
diff --git a/src/core/map.cpp b/src/core/map.cpp
index b067d6a5..9ecba8e6 100644
--- a/src/core/map.cpp
+++ b/src/core/map.cpp
@@ -289,6 +289,15 @@ void Map::removeConnection(MapConnection *connection) {
     emit connectionRemoved(connection);
 }
 
+// Return the first map connection that has the given direction.
+MapConnection* Map::getConnection(const QString &direction) const {
+    for (const auto &connection : m_connections) {
+        if (connection->direction() == direction)
+            return connection;
+    }
+    return nullptr;
+}
+
 void Map::commit(QUndoCommand *cmd) {
     m_editHistory->push(cmd);
 }
diff --git a/src/editor.cpp b/src/editor.cpp
index ca076970..0f6991ba 100644
--- a/src/editor.cpp
+++ b/src/editor.cpp
@@ -53,6 +53,19 @@ Editor::Editor(Ui::MainWindow* ui)
     connect(ui->actionOpen_Project_in_Text_Editor, &QAction::triggered, this, &Editor::openProjectInTextEditor);
     connect(ui->checkBox_ToggleGrid, &QCheckBox::toggled, this, &Editor::toggleGrid);
     connect(ui->mapCustomAttributesFrame->table(), &CustomAttributesTable::edited, this, &Editor::updateCustomMapAttributes);
+
+    connect(ui->comboBox_DiveMap, &NoScrollComboBox::editingFinished, [this] {
+        onDivingMapEditingFinished(this->ui->comboBox_DiveMap, "dive");
+    });
+    connect(ui->comboBox_EmergeMap, &NoScrollComboBox::editingFinished, [this] {
+        onDivingMapEditingFinished(this->ui->comboBox_EmergeMap, "emerge");
+    });
+    connect(ui->comboBox_DiveMap, &NoScrollComboBox::currentTextChanged, [this] {
+        updateDivingMapButton(this->ui->button_OpenDiveMap, this->ui->comboBox_DiveMap->currentText());
+    });
+    connect(ui->comboBox_EmergeMap, &NoScrollComboBox::currentTextChanged, [this] {
+        updateDivingMapButton(this->ui->button_OpenEmergeMap, this->ui->comboBox_EmergeMap->currentText());
+    });
 }
 
 Editor::~Editor()
@@ -807,23 +820,41 @@ void Editor::displayConnection(MapConnection *connection) {
     }
 }
 
-void Editor::addConnection(MapConnection *connection) {
-    if (!connection)
+void Editor::addNewConnection(const QString &mapName, const QString &direction) {
+    if (!this->map)
         return;
 
+    MapConnection *connection = new MapConnection(mapName, direction);
+
     // Mark this connection to be selected once its display elements have been created.
     // It's possible this is a Dive/Emerge connection, but that's ok (no selection will occur).
-    connection_to_select = connection;
+    this->connection_to_select = connection;
 
     this->map->commit(new MapConnectionAdd(this->map, connection));
 }
 
+void Editor::replaceConnection(const QString &mapName, const QString &direction) {
+    if (!this->map)
+        return;
+
+    MapConnection *connection = this->map->getConnection(direction);
+    if (!connection || connection->targetMapName() == mapName)
+        return;
+
+    this->map->commit(new MapConnectionChangeMap(connection, mapName));
+}
+
 void Editor::removeConnection(MapConnection *connection) {
-    if (!connection)
+    if (!this->map || !connection)
         return;
     this->map->commit(new MapConnectionRemove(this->map, connection));
 }
 
+void Editor::removeSelectedConnection() {
+    if (selected_connection_item)
+        removeConnection(selected_connection_item->connection);
+}
+
 void Editor::removeConnectionPixmap(MapConnection *connection) {
     if (!connection)
         return;
@@ -916,21 +947,18 @@ void Editor::removeDivingMapPixmap(MapConnection *connection) {
     updateDivingMapsVisibility();
 }
 
-void Editor::updateDiveMap(QString mapName) {
-    setDivingMapName(mapName, "dive");
-}
+bool Editor::setDivingMapName(const QString &mapName, const QString &direction) {
+    if (!mapName.isEmpty() && !this->project->mapNames.contains(mapName))
+        return false;
+    if (!MapConnection::isDiving(direction))
+        return false;
 
-void Editor::updateEmergeMap(QString mapName) {
-    setDivingMapName(mapName, "emerge");
-}
-
-void Editor::setDivingMapName(QString mapName, QString direction) {
     auto pixmapItem = diving_map_items.value(direction);
     MapConnection *connection = pixmapItem ? pixmapItem->connection() : nullptr;
 
     if (connection) {
         if (mapName == connection->targetMapName())
-            return; // No change
+            return true; // No change
 
         // Update existing connection
         if (mapName.isEmpty()) {
@@ -940,8 +968,25 @@ void Editor::setDivingMapName(QString mapName, QString direction) {
         }
     } else if (!mapName.isEmpty()) {
         // Create new connection
-        addConnection(new MapConnection(mapName, direction));
+        addNewConnection(mapName, direction);
     }
+    return true;
+}
+
+QString Editor::getDivingMapName(const QString &direction) const {
+    auto pixmapItem = diving_map_items.value(direction);
+    return (pixmapItem && pixmapItem->connection()) ? pixmapItem->connection()->targetMapName() : QString();
+}
+
+void Editor::onDivingMapEditingFinished(NoScrollComboBox *combo, const QString &direction) {
+    if (!setDivingMapName(combo->currentText(), direction)) {
+        // If user input was invalid, restore the combo to the previously-valid text.
+        combo->setCurrentText(getDivingMapName(direction));
+    }
+}
+
+void Editor::updateDivingMapButton(QToolButton* button, const QString &mapName) {
+    if (this->project) button->setDisabled(!this->project->mapNames.contains(mapName));
 }
 
 void Editor::updateDivingMapsVisibility() {
@@ -1725,8 +1770,6 @@ void Editor::clearMapConnections() {
     }
     connection_items.clear();
 
-    const QSignalBlocker blocker1(ui->comboBox_DiveMap);
-    const QSignalBlocker blocker2(ui->comboBox_EmergeMap);
     ui->comboBox_DiveMap->setCurrentText("");
     ui->comboBox_EmergeMap->setCurrentText("");
 
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index d81bd2a0..365c0d1c 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -261,6 +261,10 @@ void MainWindow::initCustomUI() {
     // Create map header data widget
     this->mapHeaderForm = new MapHeaderForm();
     ui->layout_HeaderData->addWidget(this->mapHeaderForm);
+
+    // Center zooming on the mouse
+    ui->graphicsView_Map->setTransformationAnchor(QGraphicsView::ViewportAnchor::AnchorUnderMouse);
+    ui->graphicsView_Map->setResizeAnchor(QGraphicsView::ViewportAnchor::AnchorUnderMouse);
 }
 
 void MainWindow::initExtraSignals() {
@@ -348,6 +352,7 @@ void MainWindow::initEditor() {
     connect(this->editor, &Editor::tilesetUpdated, this, &Scripting::cb_TilesetUpdated);
     connect(ui->newEventToolButton, &NewEventToolButton::newEventAdded, this->editor, &Editor::addNewEvent);
     connect(ui->toolButton_deleteEvent, &QAbstractButton::clicked, this->editor, &Editor::deleteSelectedEvents);
+    connect(ui->graphicsView_Connections, &ConnectionsView::pressedDelete, this->editor, &Editor::removeSelectedConnection);
 
     this->loadUserSettings();
 
@@ -1217,10 +1222,7 @@ void MainWindow::clearProjectUI() {
     const QSignalBlocker b_SecondaryTileset(ui->comboBox_SecondaryTileset);
     ui->comboBox_SecondaryTileset->clear();
 
-    const QSignalBlocker b_DiveMap(ui->comboBox_DiveMap);
     ui->comboBox_DiveMap->clear();
-
-    const QSignalBlocker b_EmergeMap(ui->comboBox_EmergeMap);
     ui->comboBox_EmergeMap->clear();
 
     const QSignalBlocker b_LayoutSelector(ui->comboBox_LayoutSelector);
@@ -1381,8 +1383,6 @@ void MainWindow::onNewMapCreated(Map *newMap, const QString &groupName) {
     // (other combo boxes like for warp destinations are repopulated when the map changes).
     int mapIndex = this->editor->project->mapNames.indexOf(newMap->name());
     if (mapIndex >= 0) {
-        const QSignalBlocker b_DiveMap(ui->comboBox_DiveMap);
-        const QSignalBlocker b_EmergeMap(ui->comboBox_EmergeMap);
         ui->comboBox_DiveMap->insertItem(mapIndex, newMap->name());
         ui->comboBox_EmergeMap->insertItem(mapIndex, newMap->name());
     }
@@ -2594,7 +2594,8 @@ void MainWindow::on_pushButton_AddConnection_clicked() {
         return;
 
     auto dialog = new NewMapConnectionDialog(this, this->editor->map, this->editor->project->mapNames);
-    connect(dialog, &NewMapConnectionDialog::accepted, this->editor, &Editor::addConnection);
+    connect(dialog, &NewMapConnectionDialog::newConnectionedAdded, this->editor, &Editor::addNewConnection);
+    connect(dialog, &NewMapConnectionDialog::connectionReplaced, this->editor, &Editor::replaceConnection);
     dialog->open();
 }
 
@@ -2647,17 +2648,6 @@ void MainWindow::on_button_OpenEmergeMap_clicked() {
     userSetMap(ui->comboBox_EmergeMap->currentText());
 }
 
-void MainWindow::on_comboBox_DiveMap_currentTextChanged(const QString &mapName) {
-    // Include empty names as an update (user is deleting the connection)
-    if (mapName.isEmpty() || editor->project->mapNames.contains(mapName))
-        editor->updateDiveMap(mapName);
-}
-
-void MainWindow::on_comboBox_EmergeMap_currentTextChanged(const QString &mapName) {
-    if (mapName.isEmpty() || editor->project->mapNames.contains(mapName))
-        editor->updateEmergeMap(mapName);
-}
-
 void MainWindow::on_comboBox_PrimaryTileset_currentTextChanged(const QString &tilesetLabel)
 {
     if (editor->project->primaryTilesetLabels.contains(tilesetLabel) && editor->layout) {
diff --git a/src/ui/connectionpixmapitem.cpp b/src/ui/connectionpixmapitem.cpp
index f1bceac5..7ea5f820 100644
--- a/src/ui/connectionpixmapitem.cpp
+++ b/src/ui/connectionpixmapitem.cpp
@@ -9,7 +9,6 @@ ConnectionPixmapItem::ConnectionPixmapItem(MapConnection* connection)
       connection(connection)
 {
     this->setEditable(true);
-    setFlag(ItemIsFocusable, true);
     this->basePixmap = pixmap();
     updateOrigin();
     render(false);
@@ -118,10 +117,6 @@ bool ConnectionPixmapItem::getEditable() {
 }
 
 void ConnectionPixmapItem::setSelected(bool selected) {
-    if (selected && !hasFocus()) {
-        setFocus(Qt::OtherFocusReason);
-    }
-
     if (this->selected == selected)
         return;
     this->selected = selected;
@@ -131,7 +126,7 @@ void ConnectionPixmapItem::setSelected(bool selected) {
 }
 
 void ConnectionPixmapItem::mousePressEvent(QGraphicsSceneMouseEvent *) {
-    setFocus(Qt::MouseFocusReason);
+    this->setSelected(true);
 }
 
 void ConnectionPixmapItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) {
@@ -142,18 +137,3 @@ void ConnectionPixmapItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) {
 void ConnectionPixmapItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *) {
     emit connectionItemDoubleClicked(this->connection);
 }
-
-void ConnectionPixmapItem::keyPressEvent(QKeyEvent* event) {
-    if (event->key() == Qt::Key_Delete || event->key() == Qt::Key_Backspace) {
-        emit deleteRequested(this->connection);
-    } else {
-        QGraphicsPixmapItem::keyPressEvent(event);
-    }
-}
-
-void ConnectionPixmapItem::focusInEvent(QFocusEvent* event) {
-    if (!this->getEditable())
-        return;
-    this->setSelected(true);
-    QGraphicsPixmapItem::focusInEvent(event);
-}
diff --git a/src/ui/connectionslistitem.cpp b/src/ui/connectionslistitem.cpp
index 5b21a12c..86df9525 100644
--- a/src/ui/connectionslistitem.cpp
+++ b/src/ui/connectionslistitem.cpp
@@ -7,44 +7,55 @@
 
 ConnectionsListItem::ConnectionsListItem(QWidget *parent, MapConnection * connection, const QStringList &mapNames) :
     QFrame(parent),
-    ui(new Ui::ConnectionsListItem)
+    ui(new Ui::ConnectionsListItem),
+    connection(connection),
+    map(connection->parentMap())
 {
     ui->setupUi(this);
     setFocusPolicy(Qt::StrongFocus);
 
-    const QSignalBlocker blocker1(ui->comboBox_Direction);
-    const QSignalBlocker blocker2(ui->comboBox_Map);
-    const QSignalBlocker blocker3(ui->spinBox_Offset);
-
-    ui->comboBox_Direction->setEditable(false);
+    // Direction
+    const QSignalBlocker b_Direction(ui->comboBox_Direction);
     ui->comboBox_Direction->setMinimumContentsLength(0);
     ui->comboBox_Direction->addItems(MapConnection::cardinalDirections);
+    ui->comboBox_Direction->installEventFilter(this);
 
+    connect(ui->comboBox_Direction, &NoScrollComboBox::editingFinished, this, &ConnectionsListItem::commitDirection);
+
+    // Map
+    const QSignalBlocker b_Map(ui->comboBox_Map);
     ui->comboBox_Map->setMinimumContentsLength(6);
     ui->comboBox_Map->addItems(mapNames);
     ui->comboBox_Map->setFocusedScrollingEnabled(false); // Scrolling could cause rapid changes to many different maps
     ui->comboBox_Map->setInsertPolicy(QComboBox::NoInsert);
+    ui->comboBox_Map->installEventFilter(this);
 
-    ui->spinBox_Offset->setMinimum(INT_MIN);
-    ui->spinBox_Offset->setMaximum(INT_MAX);
+    connect(ui->comboBox_Map, &QComboBox::currentTextChanged, this, &ConnectionsListItem::commitMap);
 
     // Invalid map names are not considered a change. If editing finishes with an invalid name, restore the previous name.
     connect(ui->comboBox_Map->lineEdit(), &QLineEdit::editingFinished, [this] {
-        const QSignalBlocker blocker(ui->comboBox_Map);
-        if (ui->comboBox_Map->findText(ui->comboBox_Map->currentText()) < 0)
+        const QSignalBlocker b(ui->comboBox_Map);
+        if (this->connection && ui->comboBox_Map->findText(ui->comboBox_Map->currentText()) < 0)
             ui->comboBox_Map->setTextItem(this->connection->targetMapName());
     });
 
-    // Distinguish between move actions for the edit history
-    connect(ui->spinBox_Offset, &QSpinBox::editingFinished, [this] { this->actionId++; });
+    // Offset
+    const QSignalBlocker b_Offset(ui->spinBox_Offset);
+    ui->spinBox_Offset->setMinimum(INT_MIN);
+    ui->spinBox_Offset->setMaximum(INT_MAX);
+    ui->spinBox_Offset->installEventFilter(this);
+
+    connect(ui->spinBox_Offset, &QSpinBox::editingFinished, [this] { this->actionId++; }); // Distinguish between move actions for the edit history
+    connect(ui->spinBox_Offset, QOverload<int>::of(&QSpinBox::valueChanged), this, &ConnectionsListItem::commitMove);
 
     // If the connection changes externally we want to update to reflect the change.
     connect(connection, &MapConnection::offsetChanged, this, &ConnectionsListItem::updateUI);
     connect(connection, &MapConnection::directionChanged, this, &ConnectionsListItem::updateUI);
     connect(connection, &MapConnection::targetMapNameChanged, this, &ConnectionsListItem::updateUI);
 
-    this->connection = connection;
-    this->map = connection->parentMap();
+    connect(ui->button_Delete, &QToolButton::clicked, this, &ConnectionsListItem::commitRemove);
+    connect(ui->button_OpenMap, &QToolButton::clicked, [this] { emit openMapClicked(this->connection); });
+
     this->updateUI();
 }
 
@@ -66,13 +77,19 @@ void ConnectionsListItem::updateUI() {
     ui->spinBox_Offset->setValue(this->connection->offset());
 }
 
+bool ConnectionsListItem::eventFilter(QObject*, QEvent *event) {
+    if (event->type() == QEvent::FocusIn)
+        this->setSelected(true);
+    return false;
+}
+
 void ConnectionsListItem::setSelected(bool selected) {
     if (selected == this->isSelected)
         return;
     this->isSelected = selected;
 
-    this->setStyleSheet(selected ? ".ConnectionsListItem { border: 1px solid rgb(255, 0, 255); }"
-                                 : ".ConnectionsListItem { border-width: 1px; }");
+    this->setStyleSheet(selected ? QStringLiteral(".ConnectionsListItem { border: 1px solid rgb(255, 0, 255); }")
+                                 : QStringLiteral(".ConnectionsListItem { border-width: 1px; }"));
     if (selected)
         emit this->selected();
 }
@@ -81,42 +98,34 @@ void ConnectionsListItem::mousePressEvent(QMouseEvent *) {
     this->setSelected(true);
 }
 
-void ConnectionsListItem::on_comboBox_Direction_currentTextChanged(QString direction) {
-    this->setSelected(true);
-    if (this->map)
+void ConnectionsListItem::commitDirection() {
+    const QString direction = ui->comboBox_Direction->currentText();
+    if (!this->connection || this->connection->direction() == direction)
+        return;
+
+    if (MapConnection::isDiving(direction)) {
+        // Diving maps are displayed separately, no support right now for replacing a list item with a diving map.
+        // For now just restore the original direction.
+        ui->comboBox_Direction->setCurrentText(this->connection->direction());
+        return;
+    }
+
+    if (this->map) {
         this->map->commit(new MapConnectionChangeDirection(this->connection, direction));
+    }
 }
 
-void ConnectionsListItem::on_comboBox_Map_currentTextChanged(QString mapName) {
-    this->setSelected(true);
+void ConnectionsListItem::commitMap(const QString &mapName) {
     if (this->map && ui->comboBox_Map->findText(mapName) >= 0)
         this->map->commit(new MapConnectionChangeMap(this->connection, mapName));
 }
 
-void ConnectionsListItem::on_spinBox_Offset_valueChanged(int offset) {
-    this->setSelected(true);
+void ConnectionsListItem::commitMove(int offset) {
     if (this->map)
         this->map->commit(new MapConnectionMove(this->connection, offset, this->actionId));
 }
 
-void ConnectionsListItem::on_button_Delete_clicked() {
+void ConnectionsListItem::commitRemove() {
     if (this->map)
         this->map->commit(new MapConnectionRemove(this->map, this->connection));
 }
-
-void ConnectionsListItem::on_button_OpenMap_clicked() {
-    emit openMapClicked(this->connection);
-}
-
-void ConnectionsListItem::focusInEvent(QFocusEvent* event) {
-    this->setSelected(true);
-    QFrame::focusInEvent(event);
-}
-
-void ConnectionsListItem::keyPressEvent(QKeyEvent* event) {
-    if (event->key() == Qt::Key_Delete || event->key() == Qt::Key_Backspace) {
-        on_button_Delete_clicked();
-    } else {
-        QFrame::keyPressEvent(event);
-    }
-}
diff --git a/src/ui/divingmappixmapitem.cpp b/src/ui/divingmappixmapitem.cpp
index e20b8f25..b774b1e9 100644
--- a/src/ui/divingmappixmapitem.cpp
+++ b/src/ui/divingmappixmapitem.cpp
@@ -38,9 +38,5 @@ void DivingMapPixmapItem::onTargetMapChanged() {
 }
 
 void DivingMapPixmapItem::setComboText(const QString &text) {
-    if (!m_combo)
-        return;
-
-    const QSignalBlocker blocker(m_combo);
-    m_combo->setCurrentText(text);
+    if (m_combo) m_combo->setCurrentText(text);
 }
diff --git a/src/ui/graphicsview.cpp b/src/ui/graphicsview.cpp
index 68479e98..1297102e 100644
--- a/src/ui/graphicsview.cpp
+++ b/src/ui/graphicsview.cpp
@@ -79,3 +79,12 @@ Overlay * MapView::getOverlay(int layer) {
     }
     return overlay;
 }
+
+void ConnectionsView::keyPressEvent(QKeyEvent *event) {
+    if (event->key() == Qt::Key_Delete || event->key() == Qt::Key_Backspace) {
+        emit pressedDelete();
+        event->accept();
+    } else {
+        QGraphicsView::keyPressEvent(event);
+    }
+}
diff --git a/src/ui/mapimageexporter.cpp b/src/ui/mapimageexporter.cpp
index acb1f538..76c124d6 100644
--- a/src/ui/mapimageexporter.cpp
+++ b/src/ui/mapimageexporter.cpp
@@ -55,10 +55,7 @@ MapImageExporter::MapImageExporter(QWidget *parent, Project *project, Map *map,
     connect(ui->pushButton_Save,   &QPushButton::pressed, this, &MapImageExporter::saveImage);
     connect(ui->pushButton_Cancel, &QPushButton::pressed, this, &MapImageExporter::close);
 
-    // Update the map selector when the text changes.
-    // We don't use QComboBox::currentTextChanged to avoid unnecessary re-rendering.
-    connect(ui->comboBox_MapSelection, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &MapImageExporter::updateMapSelection);
-    connect(ui->comboBox_MapSelection->lineEdit(), &QLineEdit::editingFinished, this, &MapImageExporter::updateMapSelection);
+    connect(ui->comboBox_MapSelection, &NoScrollComboBox::editingFinished, this, &MapImageExporter::updateMapSelection);
 
     connect(ui->checkBox_Objects,               &QCheckBox::toggled, this, &MapImageExporter::setShowObjects);
     connect(ui->checkBox_Warps,                 &QCheckBox::toggled, this, &MapImageExporter::setShowWarps);
diff --git a/src/ui/newlayoutform.cpp b/src/ui/newlayoutform.cpp
index b88b4f3f..22edd753 100644
--- a/src/ui/newlayoutform.cpp
+++ b/src/ui/newlayoutform.cpp
@@ -18,8 +18,8 @@ NewLayoutForm::NewLayoutForm(QWidget *parent)
     connect(ui->spinBox_MapWidth,  QOverload<int>::of(&QSpinBox::valueChanged), [=](int){ validateMapDimensions(); });
     connect(ui->spinBox_MapHeight, QOverload<int>::of(&QSpinBox::valueChanged), [=](int){ validateMapDimensions(); });
 
-    connect(ui->comboBox_PrimaryTileset->lineEdit(),   &QLineEdit::editingFinished, [this]{ validatePrimaryTileset(true); });
-    connect(ui->comboBox_SecondaryTileset->lineEdit(), &QLineEdit::editingFinished, [this]{ validateSecondaryTileset(true); });
+    connect(ui->comboBox_PrimaryTileset,   &NoScrollComboBox::editingFinished, [this]{ validatePrimaryTileset(true); });
+    connect(ui->comboBox_SecondaryTileset, &NoScrollComboBox::editingFinished, [this]{ validateSecondaryTileset(true); });
 }
 
 NewLayoutForm::~NewLayoutForm()
diff --git a/src/ui/newmapconnectiondialog.cpp b/src/ui/newmapconnectiondialog.cpp
index def341fd..b9938f3e 100644
--- a/src/ui/newmapconnectiondialog.cpp
+++ b/src/ui/newmapconnectiondialog.cpp
@@ -1,14 +1,15 @@
 #include "newmapconnectiondialog.h"
 #include "ui_newmapconnectiondialog.h"
+#include "message.h"
 
 NewMapConnectionDialog::NewMapConnectionDialog(QWidget *parent, Map* map, const QStringList &mapNames) :
     QDialog(parent),
-    ui(new Ui::NewMapConnectionDialog)
+    ui(new Ui::NewMapConnectionDialog),
+    m_map(map)
 {
     ui->setupUi(this);
     setAttribute(Qt::WA_DeleteOnClose);
 
-    ui->comboBox_Direction->setEditable(false);
     ui->comboBox_Direction->addItems(MapConnection::cardinalDirections);
 
     ui->comboBox_Map->addItems(mapNames);
@@ -16,7 +17,7 @@ NewMapConnectionDialog::NewMapConnectionDialog(QWidget *parent, Map* map, const
 
     // Choose default direction
     QMap<QString, int> directionCounts;
-    for (auto connection : map->getConnections()) {
+    for (auto connection : m_map->getConnections()) {
         directionCounts[connection->direction()]++;
     }
     QString defaultDirection;
@@ -33,7 +34,7 @@ NewMapConnectionDialog::NewMapConnectionDialog(QWidget *parent, Map* map, const
     QString defaultMapName;
     if (mapNames.isEmpty()) {
         defaultMapName = QString();
-    } else if (mapNames.first() == map->name() && mapNames.length() > 1) {
+    } else if (mapNames.first() == m_map->name() && mapNames.length() > 1) {
         // Prefer not to connect the map to itself
         defaultMapName = mapNames.at(1);
     } else {
@@ -62,11 +63,43 @@ void NewMapConnectionDialog::setWarningVisible(bool visible) {
     adjustSize();
 }
 
+bool NewMapConnectionDialog::askReplaceConnection(MapConnection *connection, const QString &newMapName) {
+    QString message = QString("%1 already has a %2 connection to '%3'. Replace it with a %2 connection to '%4'?")
+                                .arg(m_map->name())
+                                .arg(connection->direction())
+                                .arg(connection->targetMapName())
+                                .arg(newMapName);
+    return QuestionMessage::show(message, this) == QMessageBox::Yes;
+}
+
 void NewMapConnectionDialog::accept() {
     if (!mapNameIsValid()) {
         setWarningVisible(true);
         return;
     }
-    emit accepted(new MapConnection(ui->comboBox_Map->currentText(), ui->comboBox_Direction->currentText()));
+
+    const QString direction = ui->comboBox_Direction->currentText();
+    const QString targetMapName = ui->comboBox_Map->currentText();
+
+    // This is a very niche use case. Normally the user should add Dive/Emerge map connections using the line edits at the top of
+    // the Connections tab, but because we allow custom direction names in this dialog's Direction drop-down, a user could type
+    // in "dive" or "emerge" and we have to decide what to do. If there's no existing Dive/Emerge map we can just add it normally
+    // as if they had typed in the regular line edits. If there's already an existing connection we need to replace it.
+    if (MapConnection::isDiving(direction)) {
+        MapConnection *connection = m_map->getConnection(direction);
+        if (connection) {
+            if (connection->targetMapName() != targetMapName) {
+                if (!askReplaceConnection(connection, targetMapName))
+                    return; // Canceled
+                emit connectionReplaced(targetMapName, direction);
+            }
+            // Replaced the diving connection (or no-op, if adding a diving connection with the same map name)
+            QDialog::accept();
+            return;
+        }
+        // Adding a new diving connection that doesn't exist yet, proceed normally.
+    }
+
+    emit newConnectionedAdded(targetMapName, direction);
     QDialog::accept();
 }
diff --git a/src/ui/noscrollcombobox.cpp b/src/ui/noscrollcombobox.cpp
index 21de55a8..191c5c45 100644
--- a/src/ui/noscrollcombobox.cpp
+++ b/src/ui/noscrollcombobox.cpp
@@ -23,6 +23,11 @@ NoScrollComboBox::NoScrollComboBox(QWidget *parent)
     static const QRegularExpression re("[^\\s]*");
     QValidator *validator = new QRegularExpressionValidator(re, this);
     this->setValidator(validator);
+
+    // QComboBox (as of writing) has no 'editing finished' signal to capture
+    // changes made either through the text edit or the drop-down.
+    connect(this, QOverload<int>::of(&QComboBox::activated), this, &NoScrollComboBox::editingFinished);
+    connect(this->lineEdit(), &QLineEdit::editingFinished, this, &NoScrollComboBox::editingFinished);
 }
 
 // On macOS QComboBox::setEditable and QComboBox::setLineEdit will override our changes to the focus policy, so we enforce it here.
diff --git a/src/ui/tileseteditor.cpp b/src/ui/tileseteditor.cpp
index f9a09ce8..eedc4215 100644
--- a/src/ui/tileseteditor.cpp
+++ b/src/ui/tileseteditor.cpp
@@ -127,16 +127,10 @@ void TilesetEditor::setTilesets(QString primaryTilesetLabel, QString secondaryTi
 }
 
 void TilesetEditor::initAttributesUi() {
-    // Update the metatile's attributes values when the attribute combo boxes are edited.
-    // We avoid using the 'currentTextChanged' signal here, we want to know when we can clean up the input field and commit changes.
-    connect(ui->comboBox_metatileBehaviors->lineEdit(), &QLineEdit::editingFinished, this, &TilesetEditor::commitMetatileBehavior);
-    connect(ui->comboBox_encounterType->lineEdit(), &QLineEdit::editingFinished, this, &TilesetEditor::commitEncounterType);
-    connect(ui->comboBox_terrainType->lineEdit(), &QLineEdit::editingFinished, this, &TilesetEditor::commitTerrainType);
-    connect(ui->comboBox_layerType->lineEdit(), &QLineEdit::editingFinished, this, &TilesetEditor::commitLayerType);
-    connect(ui->comboBox_metatileBehaviors, QOverload<int>::of(&QComboBox::activated), this, &TilesetEditor::commitMetatileBehavior);
-    connect(ui->comboBox_encounterType,  QOverload<int>::of(&QComboBox::activated), this, &TilesetEditor::commitEncounterType);
-    connect(ui->comboBox_terrainType, QOverload<int>::of(&QComboBox::activated), this, &TilesetEditor::commitTerrainType);
-    connect(ui->comboBox_layerType, QOverload<int>::of(&QComboBox::activated), this, &TilesetEditor::commitLayerType);
+    connect(ui->comboBox_metatileBehaviors, &NoScrollComboBox::editingFinished, this, &TilesetEditor::commitMetatileBehavior);
+    connect(ui->comboBox_encounterType,     &NoScrollComboBox::editingFinished, this, &TilesetEditor::commitEncounterType);
+    connect(ui->comboBox_terrainType,       &NoScrollComboBox::editingFinished, this, &TilesetEditor::commitTerrainType);
+    connect(ui->comboBox_layerType,         &NoScrollComboBox::editingFinished, this, &TilesetEditor::commitLayerType);
 
     // Behavior
     if (projectConfig.metatileBehaviorMask) {