Support multiple connections in same direction, and darken non-selected connections

editor.cpp

     if (objects_group) {
         objects_group->setVisible(false);
     }
-    if (connection_item) {
-        connection_item->setVisible(false);
-        connection_item->setEnabled(false);
-    }
+    setBorderItemsVisible(true);
+    setConnectionItemsVisible(false);
 }
 
 void Editor::setEditingCollision() {
     if (objects_group) {
         objects_group->setVisible(false);
     }
-    if (connection_item) {
-        connection_item->setVisible(false);
-        connection_item->setEnabled(false);
-    }
+    setBorderItemsVisible(true);
+    setConnectionItemsVisible(false);
 }
 
 void Editor::setEditingObjects() {
     if (collision_item) {
         collision_item->setVisible(false);
     }
-    if (connection_item) {
-        connection_item->setVisible(false);
-        connection_item->setEnabled(false);
-    }
+    setBorderItemsVisible(true);
+    setConnectionItemsVisible(false);
 }
 
-void Editor::setEditingConnections(QString direction) {
+void Editor::setEditingConnections() {
     current_view = map_item;
     if (map_item) {
         map_item->draw();
         ui->comboBox_ConnectedMap->addItems(*project->mapNames);
         ui->comboBox_ConnectedMap->blockSignals(false);
         setConnectionsVisibility(false);
-        showCurrentConnectionMap(direction);
+        if (current_connection_edit_item) {
+            onConnectionOffsetChanged(current_connection_edit_item->connection->offset.toInt());
+            updateConnectionMap(current_connection_edit_item->connection->map_name, current_connection_edit_item->connection->direction);
+        }
     }
     if (collision_item) {
         collision_item->setVisible(false);
     if (objects_group) {
         objects_group->setVisible(false);
     }
+    setBorderItemsVisible(true, 0.4);
+    setConnectionItemsVisible(true);
 }
 
-void Editor::showCurrentConnectionMap(QString curDirection) {
-    bool connectionExists = false;
-    for (Connection* connection : map->connections) {
-        if (connection->direction != curDirection) continue;
-        if (connection_item) {
-            scene->removeItem(connection_item);
-            delete connection_item;
-            connection_item = NULL;
-        }
-
-        connectionExists = true;
-        Map *connected_map = project->getMap(connection->map_name);
-        QPixmap pixmap = connected_map->renderConnection(*connection);
-        int offset = connection->offset.toInt(nullptr, 0);
-        int x = 0, y = 0;
-        if (connection->direction == "up") {
-            x = offset * 16;
-            y = -pixmap.height();
-        } else if (connection->direction == "down") {
-            x = offset * 16;
-            y = map->getHeight() * 16;
-        } else if (connection->direction == "left") {
-            x = -pixmap.width();
-            y = offset * 16;
-        } else if (connection->direction == "right") {
-            x = map->getWidth() * 16;
-            y = offset * 16;
-        }
-
-        QPainter painter(&pixmap);
-        painter.setPen(QColor(255, 0, 255));
-        painter.drawRect(0, 0, pixmap.width() - 1, pixmap.height() - 1);
-        painter.end();
-        connection_item = new ConnectionPixmapItem(pixmap, connection, x, y);
-        connection_item->setX(x);
-        connection_item->setY(y);
-        connection_item->setZValue(21);
-        scene->addItem(connection_item);
-
-        connect(connection_item, SIGNAL(connectionMoved(int)), this, SLOT(onConnectionOffsetChanged(int)));
-        onConnectionOffsetChanged(connection->offset.toInt());
-
-        ui->comboBox_ConnectedMap->setCurrentText(connection->map_name);
-        break;
+void Editor::setConnectionItemsVisible(bool visible) {
+    for (ConnectionPixmapItem* item : connection_edit_items) {
+        item->setVisible(visible);
+        item->setEnabled(visible);
     }
+}
 
-    if (!connectionExists) {
-        if (connection_item) {
-            delete connection_item;
-            connection_item = NULL;
+void Editor::setBorderItemsVisible(bool visible, qreal opacity) {
+    for (QGraphicsPixmapItem* item : borderItems) {
+        item->setVisible(visible);
+        item->setOpacity(opacity);
+    }
+}
 
-            if (map->connection_items.contains(curDirection)) {
-                delete map->connection_items.value(curDirection);
-                map->connection_items.remove(curDirection);
-            }
-        }
+void Editor::setCurrentConnectionDirection(QString curDirection) {
+    if (!current_connection_edit_item)
+        return;
 
-        ui->comboBox_ConnectedMap->setCurrentText("");
-        ui->spinBox_ConnectionOffset->setDisabled(true);
-        ui->spinBox_ConnectionOffset->setValue(0);
-    } else {
-        ui->spinBox_ConnectionOffset->setDisabled(false);
-    }
+    current_connection_edit_item->connection->direction = curDirection;
+    Map *connected_map = project->getMap(current_connection_edit_item->connection->map_name);
+    QPixmap pixmap = connected_map->renderConnection(*current_connection_edit_item->connection);
+    int offset = current_connection_edit_item->connection->offset.toInt(nullptr, 0);
+    current_connection_edit_item->initialOffset = offset;
+    int x = 0, y = 0;
+    if (current_connection_edit_item->connection->direction == "up") {
+        x = offset * 16;
+        y = -pixmap.height();
+    } else if (current_connection_edit_item->connection->direction == "down") {
+        x = offset * 16;
+        y = map->getHeight() * 16;
+    } else if (current_connection_edit_item->connection->direction == "left") {
+        x = -pixmap.width();
+        y = offset * 16;
+    } else if (current_connection_edit_item->connection->direction == "right") {
+        x = map->getWidth() * 16;
+        y = offset * 16;
+    }
+
+    current_connection_edit_item->basePixmap = pixmap;
+    QPainter painter(&pixmap);
+    painter.setPen(QColor(255, 0, 255));
+    painter.drawRect(0, 0, pixmap.width() - 1, pixmap.height() - 1);
+    painter.end();
+    current_connection_edit_item->setPixmap(pixmap);
+    current_connection_edit_item->initialX = x;
+    current_connection_edit_item->initialY = y;
+    current_connection_edit_item->blockSignals(true);
+    current_connection_edit_item->setX(x);
+    current_connection_edit_item->setY(y);
+    current_connection_edit_item->setZValue(-1);
+    current_connection_edit_item->blockSignals(false);
+
+    setConnectionEditControlValues(current_connection_edit_item->connection);
 }
 
 void Editor::onConnectionOffsetChanged(int newOffset) {
     ui->spinBox_ConnectionOffset->blockSignals(false);
 }
 
+void Editor::setConnectionEditControlValues(Connection* connection) {
+    ui->comboBox_ConnectedMap->blockSignals(true);
+    ui->comboBox_ConnectionDirection->blockSignals(true);
+    ui->spinBox_ConnectionOffset->blockSignals(true);
+
+    ui->comboBox_ConnectedMap->setCurrentText(connection->map_name);
+    ui->comboBox_ConnectionDirection->setCurrentText(connection->direction);
+    ui->spinBox_ConnectionOffset->setValue(connection->offset.toInt());
+
+    ui->comboBox_ConnectedMap->blockSignals(false);
+    ui->comboBox_ConnectionDirection->blockSignals(false);
+    ui->spinBox_ConnectionOffset->blockSignals(false);
+}
+
+void Editor::setConnectionEditControlsEnabled(bool enabled) {
+    ui->comboBox_ConnectionDirection->setEnabled(enabled);
+    ui->comboBox_ConnectedMap->setEnabled(enabled);
+    ui->spinBox_ConnectionOffset->setEnabled(enabled);
+}
+
+void Editor::onConnectionItemSelected(ConnectionPixmapItem* connectionItem) {
+    for (ConnectionPixmapItem* item : connection_edit_items) {
+        bool isSelectedItem = item == connectionItem;
+        int zValue = isSelectedItem ? 0 : -1;
+        qreal opacity = isSelectedItem ? 1 : 0.75;
+        item->setZValue(zValue);
+        item->render(opacity);
+        if (isSelectedItem) {
+            QPixmap pixmap = item->pixmap();
+            QPainter painter(&pixmap);
+            painter.setPen(QColor(255, 0, 255));
+            painter.drawRect(0, 0, pixmap.width() - 1, pixmap.height() - 1);
+            painter.end();
+            item->setPixmap(pixmap);
+        }
+    }
+    current_connection_edit_item = connectionItem;
+    current_connection_edit_item->setZValue(0);
+    setConnectionEditControlsEnabled(true);
+    setConnectionEditControlValues(current_connection_edit_item->connection);
+}
+
+void Editor::onConnectionDirectionChanged(QString newDirection) {
+    ui->comboBox_ConnectionDirection->blockSignals(true);
+    ui->comboBox_ConnectionDirection->setCurrentText(newDirection);
+    ui->comboBox_ConnectionDirection->blockSignals(false);
+}
+
 void Editor::setConnectionsVisibility(bool visible) {
     for (QGraphicsPixmapItem* item : map->connection_items) {
         item->setVisible(visible);
 }
 
 void Editor::displayMapConnections() {
-    for (QString key : map->connection_items.keys()) {
-        scene->removeItem(map->connection_items.value(key));
-        delete map->connection_items.value(key);
+    for (QGraphicsPixmapItem* item : map->connection_items) {
+        scene->removeItem(item);
+        delete item;
     }
+    map->connection_items.clear();
+
+    for (ConnectionPixmapItem* item : connection_edit_items) {
+        delete item;
+    }
+    connection_edit_items.clear();
 
     for (Connection *connection : map->connections) {
         if (connection->direction == "dive" || connection->direction == "emerge") {
             x = map->getWidth() * 16;
             y = offset * 16;
         }
+
         QGraphicsPixmapItem *item = new QGraphicsPixmapItem(pixmap);
         item->setZValue(-1);
         item->setX(x);
         item->setY(y);
         scene->addItem(item);
-        map->connection_items.insert(connection->direction, item);
+        map->connection_items.append(item);
+
+        ConnectionPixmapItem *connection_edit_item = new ConnectionPixmapItem(pixmap, connection, x, y);
+        connection_edit_item->setX(x);
+        connection_edit_item->setY(y);
+        connection_edit_item->setZValue(-1);
+        scene->addItem(connection_edit_item);
+        connect(connection_edit_item, SIGNAL(connectionMoved(int)), this, SLOT(onConnectionOffsetChanged(int)));
+        connect(connection_edit_item, SIGNAL(connectionItemSelected(ConnectionPixmapItem*)), this, SLOT(onConnectionItemSelected(ConnectionPixmapItem*)));
+        connection_edit_items.append(connection_edit_item);
+    }
+
+    if (!connection_edit_items.empty()) {
+        onConnectionItemSelected(connection_edit_items.first());
     }
 }
 
         item->setY(y * 16);
         item->setZValue(-2);
         scene->addItem(item);
+        borderItems.append(item);
     }
 }
 
 }
 
 void Editor::updateConnectionOffset(int offset) {
-    if (!connection_item)
+    if (!current_connection_edit_item)
         return;
 
-    connection_item->blockSignals(true);
-    connection_item->connection->offset = QString::number(offset);
-    if (connection_item->connection->direction == "up" || connection_item->connection->direction == "down") {
-        connection_item->setX(connection_item->initialX + (offset - connection_item->initialOffset) * 16);
+    current_connection_edit_item->blockSignals(true);
+    current_connection_edit_item->connection->offset = QString::number(offset);
+    if (current_connection_edit_item->connection->direction == "up" || current_connection_edit_item->connection->direction == "down") {
+        current_connection_edit_item->setX(current_connection_edit_item->initialX + (offset - current_connection_edit_item->initialOffset) * 16);
     } else {
-        connection_item->setY(connection_item->initialY + (offset - connection_item->initialOffset) * 16);
+        current_connection_edit_item->setY(current_connection_edit_item->initialY + (offset - current_connection_edit_item->initialOffset) * 16);
     }
-    connection_item->blockSignals(false);
+    current_connection_edit_item->blockSignals(false);
 }
 
 void Editor::updateConnectionMap(QString mapName, QString direction) {
         qDebug() << "Invalid map name " << mapName << " specified for connection.";
         return;
     }
+    if (!current_connection_edit_item)
+        return;
 
-    if (connection_item) {
-        // Find the connection we are updating.
-        bool foundConnection = false;
-        for (Connection* connection : map->connections) {
-            if (connection->direction == direction) {
-                foundConnection = true;
-                if (mapName.isEmpty()) {
-                    map->connections.removeOne(connection);
-                } else {
-                    connection->map_name = mapName;
-                }
-                break;
-            }
-        }
-    } else if (!mapName.isEmpty()) {
-        // Create a brand new connection.
-        Connection* newConnection = new Connection;
-        newConnection->direction = direction;
-        newConnection->offset = "0";
-        newConnection->map_name = mapName;
-        map->connections.append(newConnection);
+    if (mapName.isEmpty()) {
+        map->connections.removeOne(current_connection_edit_item->connection);
+        connection_edit_items.removeOne(current_connection_edit_item);
+        scene->removeItem(current_connection_edit_item);
+        delete current_connection_edit_item;
+        current_connection_edit_item = NULL;
+        setConnectionEditControlsEnabled(false);
+        ui->spinBox_ConnectionOffset->setValue(0);
+        return;
+    } else {
+        setConnectionEditControlsEnabled(true);
     }
 
-    showCurrentConnectionMap(direction);
+    current_connection_edit_item->connection->map_name = mapName;
+    setCurrentConnectionDirection(direction);
 }
 
 void MetatilesPixmapItem::paintTileChanged(Map *map) {
         return QGraphicsItem::itemChange(change, value);
     }
 }
-void ConnectionPixmapItem::dragEnterEvent(QGraphicsSceneDragDropEvent *event) {
-    QPointF pos = event->pos();
-    qDebug() << "enter: " << pos.x() << ", " << pos.y();
-}
-void ConnectionPixmapItem::dragMoveEvent(QGraphicsSceneDragDropEvent *event) {
-    QPointF pos = event->pos();
-    qDebug() << "drag: " << pos.x() << ", " << pos.y();
-}
-void ConnectionPixmapItem::dragLeaveEvent(QGraphicsSceneDragDropEvent *event) {
-    QPointF pos = event->pos();
-    qDebug() << "leave: " << pos.x() << ", " << pos.y();
-}
-void ConnectionPixmapItem::dropEvent(QGraphicsSceneDragDropEvent *event) {
-    QPointF pos = event->pos();
-    qDebug() << "drop: " << pos.x() << ", " << pos.y();
-}
 void ConnectionPixmapItem::mousePressEvent(QGraphicsSceneMouseEvent* event) {
-    QPointF pos = event->pos();
+    emit connectionItemSelected(this);
 }
 
 void ElevationMetatilesPixmapItem::updateCurHoveredMetatile(QPointF pos) {
         if (left && IS_SMART_PATH_TILE(left))
             id += 8;
 
-        if (block) {
-            qDebug() << "tile: " << block->tile << "base: " << map->paint_tile << "id: " << id;
-        }
-
         block->tile = map->paint_tile + smartPathTable[id];;
         map->_setBlock(actualX, actualY, *block);
     }

editor.h

     void setEditingMap();
     void setEditingCollision();
     void setEditingObjects();
-    void setEditingConnections(QString direction);
-    void showCurrentConnectionMap(QString curDirection);
+    void setEditingConnections();
+    void setCurrentConnectionDirection(QString curDirection);
     void setConnectionsVisibility(bool visible);
     void updateConnectionOffset(int offset);
     void updateConnectionMap(QString mapName, QString direction);
     QGraphicsScene *scene = NULL;
     QGraphicsPixmapItem *current_view = NULL;
     MapPixmapItem *map_item = NULL;
-    ConnectionPixmapItem *connection_item = NULL;
+    ConnectionPixmapItem* current_connection_edit_item = NULL;
+    QList<ConnectionPixmapItem*> connection_edit_items;
     CollisionPixmapItem *collision_item = NULL;
     QGraphicsItemGroup *objects_group = NULL;
+    QList<QGraphicsPixmapItem*> borderItems;
 
     QGraphicsScene *scene_metatiles = NULL;
     QGraphicsScene *scene_collision_metatiles = NULL;
     void objectsView_onMouseMove(QMouseEvent *event);
     void objectsView_onMouseRelease(QMouseEvent *event);
 
+private:
+    void setConnectionItemsVisible(bool);
+    void setBorderItemsVisible(bool, qreal = 1);
+    void setConnectionEditControlValues(Connection*);
+    void setConnectionEditControlsEnabled(bool);
+
 private slots:
     void mouseEvent_map(QGraphicsSceneMouseEvent *event, MapPixmapItem *item);
     void mouseEvent_collision(QGraphicsSceneMouseEvent *event, CollisionPixmapItem *item);
     void onConnectionOffsetChanged(int newOffset);
+    void onConnectionItemSelected(ConnectionPixmapItem* connectionItem);
+    void onConnectionDirectionChanged(QString newDirection);
 
 signals:
     void objectsChanged();
     Q_OBJECT
 public:
     ConnectionPixmapItem(QPixmap pixmap, Connection* connection, int x, int y): QGraphicsPixmapItem(pixmap) {
+        this->basePixmap = pixmap;
         this->connection = connection;
         setFlag(ItemIsMovable);
         setFlag(ItemSendsGeometryChanges);
         this->initialY = y;
         this->initialOffset = connection->offset.toInt();
     }
+    void render(qreal opacity = 1) {
+        QPixmap newPixmap = basePixmap.copy(0, 0, basePixmap.width(), basePixmap.height());
+        if (opacity < 1) {
+            QPainter painter(&newPixmap);
+            int alpha = (int)(255 * (1 - opacity));
+            painter.fillRect(0, 0, newPixmap.width(), newPixmap.height(), QColor(0, 0, 0, alpha));
+            painter.end();
+        }
+        this->setPixmap(newPixmap);
+    }
+    QPixmap basePixmap;
     Connection* connection;
     int initialX;
     int initialY;
     int initialOffset;
 protected:
     QVariant itemChange(GraphicsItemChange change, const QVariant &value);
-    void dragEnterEvent(QGraphicsSceneDragDropEvent *event) override;
-    void dragLeaveEvent(QGraphicsSceneDragDropEvent *event) override;
-    void dropEvent(QGraphicsSceneDragDropEvent *event) override;
-    void dragMoveEvent(QGraphicsSceneDragDropEvent *event) override;
     void mousePressEvent(QGraphicsSceneMouseEvent*);
 signals:
+    void connectionItemSelected(ConnectionPixmapItem* connectionItem);
     void connectionMoved(int offset);
 };
 

mainwindow.cpp

     } else if (index == 1) {
         editor->setEditingObjects();
     } else if (index == 3) {
-        editor->setEditingConnections(ui->comboBox_ConnectionDirection->currentText().toLower());
+        editor->setEditingConnections();
     }
 }
 
 
 void MainWindow::on_comboBox_ConnectionDirection_currentIndexChanged(const QString &direction)
 {
-    editor->showCurrentConnectionMap(direction.toLower());
+    editor->setCurrentConnectionDirection(direction);
 }
 
 void MainWindow::on_spinBox_ConnectionOffset_valueChanged(int offset)

mainwindow.ui

                 <widget class="QComboBox" name="comboBox_ConnectionDirection">
                  <item>
                   <property name="text">
-                   <string>Up</string>
+                   <string>up</string>
                   </property>
                  </item>
                  <item>
                   <property name="text">
-                   <string>Right</string>
+                   <string>right</string>
                   </property>
                  </item>
                  <item>
                   <property name="text">
-                   <string>Down</string>
+                   <string>down</string>
                   </property>
                  </item>
                  <item>
                   <property name="text">
-                   <string>Left</string>
+                   <string>left</string>
                   </property>
                  </item>
                 </widget>
                <item>
                 <widget class="QSpinBox" name="spinBox_ConnectionOffset">
                  <property name="minimum">
-                  <number>-99</number>
+                  <number>-999</number>
+                 </property>
+                 <property name="maximum">
+                  <number>999</number>
                  </property>
                 </widget>
                </item>
                   </property>
                   <layout class="QGridLayout" name="gridLayout_14">
                    <item row="1" column="1">
-                    <widget class="QGraphicsView" name="graphicsView_Connections"/>
+                    <widget class="QGraphicsView" name="graphicsView_Connections">
+                     <property name="backgroundBrush">
+                      <brush brushstyle="SolidPattern">
+                       <color alpha="255">
+                        <red>0</red>
+                        <green>0</green>
+                        <blue>0</blue>
+                       </color>
+                      </brush>
+                     </property>
+                    </widget>
                    </item>
                    <item row="1" column="0">
                     <spacer name="horizontalSpacer_7">

map.h

     QMap<QString, QList<Event*>> events;
 
     QList<Connection*> connections;
-    QMap<QString, QGraphicsPixmapItem*> connection_items;
+    QList<QGraphicsPixmapItem*> connection_items;
     QPixmap renderConnection(Connection);
 
     QImage border_image;