Big commit.

Added indicator showing selected Player.
Added maximum of two bets.
When selecting a different player, his current bets will now be shown.
Creating dialog box for bet input dynamically.

BetInputDialog.qml

@@ -0,0 +1,62 @@
+import QtQuick
+import QtQuick.Controls
+
+import roulette
+
+Dialog {
+    property alias input: input
+    required property int betType /* It wouldn't accept the type defined in PlayerAreaModel so I just used the int since that's what it is*/
+    required property int n
+    required property int squareX
+    required property int squareY
+
+    id: dialog
+    modal: true
+    height: 35
+    width: 80
+
+    TextField {
+        id: input
+        focus: true
+
+        anchors {
+            left: parent.left
+            right: gil.left
+            rightMargin: 5
+            top: parent.top
+            bottom: parent.bottom
+        }
+
+        onActiveFocusChanged: {
+            selectAll()
+            focus = true
+        }
+        onAccepted: {
+            dialog.accept()
+        }
+    }
+
+    Text {
+        id: gil
+        text: "g"
+
+        anchors {
+            right: parent.right
+            verticalCenter: input.verticalCenter
+        }
+    }
+
+    onActiveFocusChanged: {
+        dialog.x = 120 + squareX
+        dialog.y = 60 + squareY
+    }
+
+    onAccepted: {
+        PlayerAreaModel.bet(betType, n, input.text)
+        rouletteTable.numberOfBets += 1
+    }
+
+    onRejected: {
+        PlayerAreaModel.cancelBet(n)
+    }
+}

CMakeLists.txt

@@ -17,8 +17,6 @@ set(SOURCES
     MainWindow.h
     PlayerAreaModel.cpp
     PlayerAreaModel.h
-    StreetBetsModel.cpp
-    StreetBetsModel.h
     ${QRC})
 
 qt_add_executable(roulette-payout
@@ -31,6 +29,7 @@ qt_add_qml_module(roulette-payout
     RESOURCE_PREFIX "/"
     QML_FILES
         Root.qml
+        BetInputDialog.qml
         PlayerAreaView.qml
         Roulette.qml
         StreetBetsView.qml

PlayerAreaModel.cpp

@@ -2,49 +2,65 @@
 
 PlayerAreaModel::PlayerAreaModel(QObject *parent)
 {
+    Player defaultValues;
+
     for(int i = 0; i < 7; i++){
-        playerNames.append("N/A");
+        players.append(defaultValues);
     }
 }
 
-QString PlayerAreaModel::getPlayerName(int n)
+uint PlayerAreaModel::focusedPlayer()
 {
-    return playerNames.at(n);
+    return focusedPlayer_;
-}
-
-void PlayerAreaModel::setPlayerName(QString s, int n)
-{
-    switch(n) {
-        case 0:
-            playerNames[n] = s;
-            break;
-        case 1:
-            playerNames[n] = s;
-            break;
-        case 2:
-            playerNames[n] = s;
-            break;
-        case 3:
-            playerNames[n] = s;
-            break;
-        case 4:
-            playerNames[n] = s;
-            break;
-        case 5:
-            playerNames[n] = s;
-            break;
-        case 6:
-            playerNames[n] = s;
-            break;
-    }
 }
 
 void PlayerAreaModel::setFocusedPlayer(int n)
 {
-    focusedPlayer = n;
+    focusedPlayer_ = n;
+    Player player = players.at(n);
+    BetType b1 = player.bet1.betType;
+    BetType b2 = player.bet2.betType;
+    uint n1 = player.bet1.betSpot;
+    uint n2 = player.bet2.betSpot;
+    emit focusedPlayerChanged(b1, n1, b2, n2);
+}
+
+QString PlayerAreaModel::getPlayerName(int n)
+{
+    return players.at(n).playerName;
+}
+
+void PlayerAreaModel::setPlayerName(QString s, int n)
+{
+    this->players[n].playerName = s;
 }
 
 void PlayerAreaModel::bet(BetType b, int n, int bet)
 {
-    printf("Received %d-%d for player %s for %d gil\n", b, n, playerNames[focusedPlayer].toLocal8Bit().data(), bet);
+    Player *player = &players[focusedPlayer_];
+
+    if (player->bet1.betType == NONE) {
+        player->bet1.betType = b;
+        player->bet1.betValue = bet;
+        player->bet1.betSpot = n;
+    } else if (player->bet2.betType == NONE) {
+        player->bet2.betType = b;
+        player->bet2.betValue = bet;
+        player->bet2.betSpot = n;
     }
+}
+
+void PlayerAreaModel::removeBet(BetType b, int n)
+{
+    Player *player = &players[focusedPlayer_];
+    if (player->bet1.betType != NONE) {
+        player->bet1.betType = NONE;
+    } else {
+        player->bet2.betType = NONE;
+    }
+}
+
+void PlayerAreaModel::cancelBet(int n) {
+    emit betCanceled(n);
+}
+

PlayerAreaModel.h

@@ -13,10 +13,16 @@ class PlayerAreaModel : public QObject
     QML_NAMED_ELEMENT(PlayerAreaModel)
     QML_SINGLETON
 
+    Q_PROPERTY(uint focusedPlayer READ focusedPlayer WRITE setFocusedPlayer NOTIFY focusedPlayerChanged)
+
 public:
     explicit PlayerAreaModel(QObject *parent = nullptr);
 
+    uint focusedPlayer();
+    void setFocusedPlayer(int n);
+
     enum BetType {
+        NONE,
         RED,
         BLACK,
         ODD,
@@ -30,31 +36,33 @@ public:
     };
     Q_ENUM(BetType)
 
+signals:
+    void focusedPlayerChanged(BetType b1, uint n1, BetType b2, uint n2);
+    void betCanceled(uint n);
+
 public slots:
     void setPlayerName(QString s, int n);
     void bet(BetType b, int n, int bet);
+    void removeBet(BetType b, int n);
     QString getPlayerName(int n);
-    void setFocusedPlayer(int n);
+    void cancelBet(int n);
 
 
 private:
 
-    QList<QString> playerNames;
+    struct Bet {
-
+        uint betValue = 0;
-    uint player1Bet1;
+        BetType betType = NONE;
-    uint player1Bet2;
+        uint betSpot = 0;
-    uint player2Bet1;
+    };
-    uint player2Bet2;
+
-    uint player3Bet1;
+    struct Player {
-    uint player3Bet2;
+        QString playerName = "";
-    uint player4Bet1;
+        Bet bet1;
-    uint player4Bet2;
+        Bet bet2;
-    uint player5Bet1;
+    };
-    uint player5Bet2;
+
-    uint player6Bet1;
+    QList<Player> players;
-    uint player6Bet2;
+
-    uint player7Bet1;
+    int focusedPlayer_;
-    uint player7Bet2;
-
-    int focusedPlayer;
 };

PlayerAreaView.qml

@@ -5,6 +5,11 @@ import QtQuick.Layouts
 import roulette
 
 Item {
+    anchors {
+        left: parent.left
+        leftMargin: 10
+    }
+
     Text {
         id: croupier
         text: "Croupier"
@@ -27,12 +32,32 @@ Item {
                     text: "Player " + (index + 1)
                 }
 
+                Rectangle {
+                    id: indicator
+                    color: "red"
+                    height: 10
+                    width: 10
+                    visible: PlayerAreaModel.focusedPlayer == index
+                    opacity: 0.5
+
+                    anchors {
+                        verticalCenter: inputField.verticalCenter
+                        right: inputField.left
+                        rightMargin: 5
+                    }
+                }
+
                 TextField {
+                    id: inputField
                     anchors.top: label.bottom
                     anchors.topMargin: 6
 
                     onTextEdited: PlayerAreaModel.setPlayerName(text, index)
-                    onActiveFocusChanged: PlayerAreaModel.setFocusedPlayer(index)
+                    onActiveFocusChanged: {
+                        if (activeFocus && (focusReason == 0 || focusReason == 1 || focusReason == 2)) {
+                            PlayerAreaModel.focusedPlayer = index
+                        }
+                    }
                 }
             }
         }

Roulette.qml

@@ -4,6 +4,9 @@ import Qt5Compat.GraphicalEffects
 import roulette
 
 Item {
+    property int numberOfBets: 0
+
+    id: rouletteTable
 
     Image {
         source: "qrc:/roulette.png"
@@ -20,4 +23,29 @@ Item {
             id: streetBets
         }
     }
+
+    function destroyOnClose(obj) {
+        if (obj.closing != undefined)
+            obj.closing.connect(() => obj.destroy(1000));
+        else if (obj.aboutToHide != undefined)
+            obj.aboutToHide.connect(() => obj.destroy(1000));
+    }
+
+    function showBetInputDialog(betType, n, squareX, squareY)
+    {
+        var component = Qt.createComponent("BetInputDialog.qml")
+        if (component.status == Component.Ready) {
+            var dialog = component.createObject(rouletteTable, {
+                "betType": betType,
+                "n": n,
+                "squareX": squareX,
+                "squareY": squareY
+            })
+
+            dialog.open()
+            destroyOnClose(dialog)
+        } else {
+            console.error("Something crapped out: " + component.errorString());
+        }
+    }
 }

StreetBetsView.qml

@@ -1,15 +1,14 @@
 import QtQuick
 import QtQuick.Layouts
-import QtQuick.Controls
 
 import roulette
 
+/* 
+ * The very important id 'rouletteTable'
+ * comes from Roulette.qml
+ */
 Item {
 
-    StreetBetsModel {
-        id: streetBetsModel
-    }
-
     RowLayout {
         id: layout
         property int indexForDialog
@@ -28,83 +27,87 @@ Item {
             model: 12
 
             Item {
-                height: 45
-                width: 35
                 property alias selected: selected
 
+                id: betButton
+                height: 45
+                width: 35
+
                 Rectangle {
+                    id: selected
                     visible: true
-                    color: tapHandler1.pressed ? "#999999" : "#EEEEEE"
-                    opacity: hoverHandler.hovered ? 0.4 : 0
                     height: parent.height
                     width: parent.width
+                    border.color: "blue"
+                    border.width: 0
+
+                    color: {
+                        if (rouletteTable.numberOfBets < 2 || border.width == 2) {
+                            if (tapHandler1.pressed) {
+                                "#AA999999"
+                            } else if (hoverHandler.hovered) {
+                                "#AAEEEEEE"
+                            } else {
+                                "#00000000"
+                            }
+                        } else {
+                            "#00000000"
+                        }
+                    }
 
                     HoverHandler {
                         id: hoverHandler
                     }
                     TapHandler {
                         id: tapHandler1
-                    }
-                }
-
-                Rectangle {
-                    id: selected
-
-                    visible: true
-                    color: "transparent"
-                    height: parent.height
-                    width: parent.width
-                    border.color: "blue"
-                    border.width: 0
-
-                    TapHandler {
 
                         onTapped: {
-                            if (parent.border.width == 0) {
+                            if (rouletteTable.numberOfBets < 2 && parent.border.width == 0) {
                                 parent.border.width = 2
                                 layout.indexForDialog = index
-
+                                roulette.showBetInputDialog(PlayerAreaModel.STREET, index, betButton.x, betButton.y)
-                                dialog.open()
+                            } else if (parent.border.width == 2) {
-                            } else {
                                 parent.border.width = 0
-                            }
+                                PlayerAreaModel.removeBet(PlayerAreaModel.STREET, index)
-                        }
+                                rouletteTable.numberOfBets -= 1
-                    }
-                }
                             }
                         }
                     }
 
-    Dialog {
+                    Connections {
-        property alias input: input
+                        target: PlayerAreaModel
 
-        id: dialog
+                        function onFocusedPlayerChanged(b1, n1, b2, n2) {
-        height: 35
+                            if (b1 == PlayerAreaModel.STREET && n1 == index) {
-        width: 65
+                                if (selected.border.width != 0) {
-
+                                    rouletteTable.numberOfBets -=1
-        TextField {
-            id: input
-            focus: true
-
-            anchors {
-                fill: parent
                                 }
 
-            onActiveFocusChanged: {
+                                selected.border.width = 2;
-                selectAll()
+                                rouletteTable.numberOfBets += 1
-                focus = true
+                            } else if (b2 == PlayerAreaModel.STREET && n2 == index) {
+                                if (selected.border.width != 0) {
+                                    rouletteTable.numberOfBets -=1
                                 }
-            onAccepted: {
+
-                dialog.accept()
+                                selected.border.width = 2;
+                                rouletteTable.numberOfBets += 1
+                            } else {
+                                if (selected.border.width != 0) {
+                                    rouletteTable.numberOfBets -=1
+                                }
+                                selected.border.width = 0;
                             }
                         }
 
-        onActiveFocusChanged: {
+                        function onBetCanceled(n) {
-            dialog.x = 120 + repeater.itemAt(layout.indexForDialog).x
+                            if (index == n) {
-            dialog.y = 60 + repeater.itemAt(layout.indexForDialog).y
+                                selected.border.width = 0
-        }
+                            }
-
+                        }
-        onAccepted: PlayerAreaModel.bet(PlayerAreaModel.STREET, layout.indexForDialog, input.text)
+                    }
-        onRejected: repeater.itemAt(layout.indexForDialog).selected.border.width = 0
+                }
+            }
+        }
     }
 }