490 lines
21 KiB
QML
490 lines
21 KiB
QML
/*
|
|
blueROCK - for digital rock
|
|
Copyright (C) 2019 Dorian Zedler
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
import QtQuick 2.10
|
|
import QtQuick.Controls 2.4
|
|
import QtQuick.Layouts 1.3
|
|
import QtQuick.Controls.Material 2.1
|
|
import QtGraphicalEffects 1.0
|
|
|
|
Item {
|
|
id: control
|
|
|
|
property var flowchartData
|
|
property var allFlowchartData
|
|
property int rounds: 0
|
|
|
|
property int refreshes: 0
|
|
property int roundRefreshes: 1
|
|
|
|
property int roundCount: 0
|
|
|
|
onFlowchartDataChanged: {
|
|
prepareData()
|
|
}
|
|
|
|
function prepareData() {
|
|
|
|
if(!control.enabled || control.flowchartData === undefined || control.flowchartData['route_names'] === undefined)
|
|
return
|
|
/*refreshes += 1
|
|
|
|
if(refreshes > 2){
|
|
roundRefreshes += 1
|
|
}
|
|
|
|
console.log("refreshes: " + refreshes + " rounds: " + roundRefreshes)
|
|
|
|
// create competition like data (just testing)
|
|
for(var part in flowchartData['participants']){
|
|
if(flowchartData['participants'].hasOwnProperty(part)){
|
|
|
|
for(var r = 2 + roundRefreshes; r < 7; r++){
|
|
delete flowchartData['participants'][part]["result"+r]
|
|
delete flowchartData['participants'][part]["result_rank"+r]
|
|
}
|
|
|
|
if(parseInt(flowchartData['participants'][part]["result_rank0"]) > 14 + refreshes) {
|
|
delete flowchartData['participants'][part]["result_rank2"]
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
delete flowchartData['route_names'][2]
|
|
delete flowchartData['route_names'][3]
|
|
delete flowchartData['route_names'][4]
|
|
delete flowchartData['route_names'][5]
|
|
delete flowchartData['route_names'][6]
|
|
*/
|
|
|
|
//flowchartData['route_names'] = flowchartData['route_names'].slice(0,)
|
|
|
|
// array to store the restructured data
|
|
var allData = []
|
|
control.allFlowchartData = []
|
|
|
|
control.rounds = Object.keys(control.flowchartData['route_names']).length > 2 ? control.flowchartData['route_names']["2"].includes("8") ? 2:1 : 0
|
|
|
|
//console.log(JSON.stringify(flowchartData['route_names']))
|
|
|
|
for(var round in flowchartData['route_names']){
|
|
if(flowchartData['route_names'].hasOwnProperty(round) && parseInt(round) >= 0){
|
|
//console.log(round)
|
|
|
|
if(parseInt(round) === 0){
|
|
// this is the first round
|
|
|
|
// find pairs (always wors vs. best (1-16; 1-15; ...)) (they are sorted by the rank of the better athlete (1-2-3-4-5-6-7-8)
|
|
|
|
var qualificationResults = []
|
|
|
|
for(var x = 0; x < flowchartData['participants'].length; x++){
|
|
qualificationResults.push(flowchartData['participants'][x])
|
|
}
|
|
|
|
qualificationResults.sort(function(a, b) {
|
|
return parseInt(a["result_rank0"]) - parseInt(b["result_rank0"]);
|
|
});
|
|
|
|
var nextRoundPairs = []
|
|
var totalMatches = (parseInt(Object.keys(control.flowchartData['route_names']).length > 2 ? control.flowchartData['route_names']["2"].includes("8") ? 2:1 : 0) + 2)
|
|
var nextRoundMatches = Math.pow(2, totalMatches-1)
|
|
|
|
for(var i = 0; i < nextRoundMatches; i++){
|
|
nextRoundPairs.push([qualificationResults[i], qualificationResults[nextRoundMatches*2-i-1]])
|
|
}
|
|
|
|
// build second round pairs (sorted by the rank of the better athlete and worst vs. best (1-8; 2-7; ... ))
|
|
|
|
var sortedFirstRoundPairs = []
|
|
|
|
for(i = 0; i < nextRoundMatches; i += 1){
|
|
sortedFirstRoundPairs.push([nextRoundPairs.shift(), nextRoundPairs.pop()])
|
|
}
|
|
|
|
// sort these pairs (containing two pairs of athletes) by the rank of the better athlete (1-4;2-3)
|
|
|
|
var finalSortedFirstRoundPairs = []
|
|
|
|
for(i=0; i < nextRoundMatches/4; i++){
|
|
finalSortedFirstRoundPairs.push(sortedFirstRoundPairs[i])
|
|
finalSortedFirstRoundPairs.push(sortedFirstRoundPairs[nextRoundMatches/2-i-1])
|
|
}
|
|
|
|
// convert the list of pairs of pairs of athletes back to a single list of pairs of athletes
|
|
|
|
var finalFirstRoundPairs = []
|
|
|
|
for(i=0; i < finalSortedFirstRoundPairs.length; i++){
|
|
finalFirstRoundPairs.push(finalSortedFirstRoundPairs[i][0])
|
|
finalFirstRoundPairs.push(finalSortedFirstRoundPairs[i][1])
|
|
}
|
|
|
|
// push the first round to all data
|
|
finalFirstRoundPairs.push(2)
|
|
finalFirstRoundPairs.push(flowchartData['route_names'][2])
|
|
allData.push(finalFirstRoundPairs)
|
|
|
|
}
|
|
else if(parseInt(round) > 0 ){
|
|
// this is not the first round
|
|
|
|
var nextRound = []
|
|
|
|
// only used when the current round is the 1/2 final
|
|
var smallFinal = []
|
|
var Final = []
|
|
|
|
for(var i = 0; i < allData[allData.length-1].length-2; i+=1){
|
|
|
|
var thisPair = allData[allData.length-1][i]
|
|
var thisWinner
|
|
var thisLooser
|
|
var thisWinnerIsFirstOfNewPair = i%2 === 0
|
|
|
|
if(thisPair[0] === undefined || thisPair[1] === undefined){
|
|
continue
|
|
}
|
|
|
|
if(thisWinnerIsFirstOfNewPair){
|
|
nextRound.push([])
|
|
}
|
|
|
|
//thisPair[0]["result_rank"] = thisPair[0]["result_rank"+round]
|
|
//thisPair[1]["result_rank"] = thisPair[1]["result_rank"+round]
|
|
|
|
if(parseInt(thisPair[0]["result_rank"+round]) < parseInt(thisPair[1]["result_rank"+round])){
|
|
thisWinner = thisPair[0]
|
|
thisLooser = thisPair[1]
|
|
}
|
|
else if(parseInt(thisPair[0]["result_rank"+round]) > parseInt(thisPair[1]["result_rank"+round])) {
|
|
thisWinner = thisPair[1]
|
|
thisLooser = thisPair[0]
|
|
}
|
|
else {
|
|
// no result yet!!
|
|
//console.log("got no winner yet, rank 0: " + thisPair[0]["result_rank"+round] + " rank 1: " + thisPair[1]["result_rank"+round])
|
|
continue
|
|
}
|
|
|
|
//console.log(thisWinner['firstname']+" has won in round " + round)
|
|
|
|
if(round - control.rounds === 2){
|
|
// if we are in the 1/2 final
|
|
|
|
Final.push(thisWinner)
|
|
smallFinal.push(thisLooser)
|
|
}
|
|
else {
|
|
nextRound[nextRound.length-1].push(thisWinner)
|
|
}
|
|
}
|
|
|
|
if(smallFinal.length > 0 && Final.length > 0){
|
|
|
|
// Final
|
|
allData.push([Final, parseInt(round)+2, flowchartData['route_names'][String(parseInt(round)+2)] + " / " + flowchartData['route_names'][String(parseInt(round)+1)] ])
|
|
// small Final
|
|
allData.push([smallFinal, parseInt(round)+1])
|
|
|
|
//break
|
|
}
|
|
else {
|
|
nextRound.push(parseInt(round) + 1 )
|
|
nextRound.push(flowchartData['route_names'][parseInt(round) + 1])
|
|
allData.push(nextRound)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
control.allFlowchartData = allData
|
|
control.roundCount = (parseInt(Object.keys(control.flowchartData['route_names']).length > 2 ? control.flowchartData['route_names']["2"].includes("8") ? 2:1 : 0) + 2)
|
|
//console.log(JSON.stringify(allData))
|
|
}
|
|
|
|
ListView {
|
|
id: roundListView
|
|
|
|
property int columnWidth: height * 0.3
|
|
property int columnHeight: height
|
|
|
|
anchors {
|
|
top: parent.top
|
|
bottom: parent.bottom
|
|
horizontalCenter: parent.horizontalCenter
|
|
}
|
|
|
|
width: Math.min((columnWidth + spacing) * model, control.width)
|
|
|
|
spacing: app.height * 0.05
|
|
|
|
orientation: ListView.LeftToRight
|
|
boundsBehavior: ListView.StopAtBounds
|
|
|
|
model: control.roundCount
|
|
|
|
delegate: Item {
|
|
id: roundItem
|
|
|
|
property int thisIndex: index
|
|
property int thisRound: thisRoundIsValid ? control.allFlowchartData[roundItem.thisIndex][control.allFlowchartData[roundItem.thisIndex].length-2]:-1
|
|
property bool thisRoundIsValid: control.allFlowchartData !== undefined
|
|
&& control.allFlowchartData[roundItem.thisIndex] !== undefined
|
|
&& control.allFlowchartData[roundItem.thisIndex].length > 2
|
|
|
|
property bool thisIsLastRound: thisIndex === control.roundCount - 1
|
|
property bool thisIsSemiFinal: thisIndex === control.roundCount - 2 && rectRep.model === 2
|
|
|
|
property int tileSize: (roundItem.height / 8 - roundNameLa.height) * 1.45
|
|
|
|
width: roundListView.columnWidth
|
|
height: roundListView.columnHeight
|
|
|
|
Column {
|
|
id: roundCol
|
|
|
|
anchors.fill: parent
|
|
|
|
Label {
|
|
id: roundNameLa
|
|
width: parent.width
|
|
height: control.height * 0.05
|
|
horizontalAlignment: Text.AlignHCenter
|
|
verticalAlignment: Text.AlignVCenter
|
|
fontSizeMode: Text.Fit
|
|
font.pixelSize: height * 0.6
|
|
minimumPixelSize: 1
|
|
font.bold: true
|
|
text: roundItem.thisRoundIsValid
|
|
&& control.allFlowchartData[roundItem.thisIndex][control.allFlowchartData[roundItem.thisIndex].length-1] !== undefined ?
|
|
control.allFlowchartData[roundItem.thisIndex][control.allFlowchartData[roundItem.thisIndex].length-1] :
|
|
"-"
|
|
}
|
|
|
|
Repeater {
|
|
id: rectRep
|
|
model: Math.max( Math.pow(2, control.roundCount-1) * Math.pow(0.5, (roundItem.thisIndex)), 2)
|
|
delegate: Item {
|
|
id: matchItm
|
|
|
|
property bool lowerPart: (index%2 > 0)
|
|
|
|
property var matchData: roundItem.thisRoundIsValid ?
|
|
control.allFlowchartData[
|
|
thisIsSmallFinal ?
|
|
roundItem.thisIndex+1 :
|
|
roundItem.thisIndex
|
|
][ thisIsSmallFinal ? 0:matchItm.thisIndex]:
|
|
undefined
|
|
|
|
property int thisIndex: index
|
|
property int thisRound: parseInt(roundItem.thisRound) - (thisIsSmallFinal ? 1:0)
|
|
property var thisMatchData: thisMatchDataIsValid ? matchData:[]
|
|
|
|
property bool thisMatchDataIsValid: (matchData !== undefined && matchData !== null && typeof matchData === "object" && matchData.length > 0)
|
|
property bool thisMatchIsOver: thisMatchDataIsValid && thisMatchData[0]['result_rank'+thisRound] !== undefined && thisMatchData[1]['result_rank'+thisRound] !== undefined
|
|
|
|
property bool thisIsFinal: roundItem.thisIsLastRound && thisIndex === rectRep.model - 2
|
|
property bool thisIsSmallFinal: roundItem.thisIsLastRound && thisIndex === rectRep.model - 1
|
|
|
|
property int winnerIndex: thisMatchIsOver ? (parseInt(thisMatchData[0]['result_rank'+thisRound]) < parseInt(thisMatchData[1]['result_rank'+thisRound]) ? 0:1) : -1
|
|
|
|
height: !roundItem.thisIsLastRound ?
|
|
(roundItem.height - roundNameLa.height) / rectRep.model - roundCol.spacing :
|
|
(thisIsFinal ?
|
|
(roundItem.height - roundNameLa.height) * 0.5 + roundItem.tileSize * 0.5 :
|
|
(roundItem.height - roundNameLa.height) - (roundItem.height - roundNameLa.height) * 0.5 + roundItem.tileSize * 0.5
|
|
)
|
|
|
|
width: roundItem.width
|
|
|
|
onMatchDataChanged: {
|
|
fadeInPa.start()
|
|
}
|
|
|
|
ParallelAnimation {
|
|
id: fadeInPa
|
|
NumberAnimation { target: matchItm; property: "opacity"; from: 0; to: 1.0; duration: 400 }
|
|
NumberAnimation { target: matchItm; property: "scale"; from: 0.8; to: 1.0; duration: 400 }
|
|
}
|
|
|
|
Canvas {
|
|
id: lineCanvas
|
|
width: app.width; height: app.height
|
|
contextType: "2d"
|
|
|
|
visible: !roundItem.thisIsLastRound
|
|
|
|
property int targetYFactor: matchItm.lowerPart ? -1:1
|
|
|
|
Path {
|
|
id: firstPartPath
|
|
startX: matchItm.width
|
|
startY: matchItm.height * 0.5
|
|
|
|
PathQuad {
|
|
id: firstPartPathQuad
|
|
relativeX: roundListView.spacing * 0.5
|
|
relativeY: matchItm.height * 0.25 * lineCanvas.targetYFactor
|
|
relativeControlX: relativeX
|
|
relativeControlY: 0
|
|
}
|
|
|
|
PathQuad {
|
|
relativeX: roundListView.spacing * 0.5
|
|
relativeY: matchItm.height * 0.25 * lineCanvas.targetYFactor
|
|
relativeControlX: 0
|
|
relativeControlY: relativeY
|
|
}
|
|
}
|
|
|
|
onPaint: {
|
|
context.strokeStyle = "lightgrey"
|
|
context.lineWidth = matchRect.height * 0.05
|
|
context.path = firstPartPath;
|
|
context.stroke();
|
|
}
|
|
}
|
|
|
|
RectangularGlow {
|
|
id: effect
|
|
anchors.fill: matchRect
|
|
glowRadius: 0
|
|
spread: 0
|
|
opacity: 0.3
|
|
color: "black"
|
|
cornerRadius: matchRect.radius
|
|
}
|
|
|
|
Rectangle {
|
|
id: matchRect
|
|
|
|
anchors {
|
|
centerIn: !matchItm.thisIsFinal ? parent:undefined
|
|
bottom: matchItm.thisIsFinal ? parent.bottom:undefined
|
|
}
|
|
|
|
//anchors.verticalCenterOffset: matchItm.lowerPart ? 10:10
|
|
width: parent.width
|
|
height: roundItem.tileSize
|
|
//scale: 0.9
|
|
color: Material.dialogColor
|
|
border.color: "lightgrey"
|
|
border.width: 0
|
|
radius: height * 0.2
|
|
|
|
Column {
|
|
spacing: 0
|
|
|
|
anchors.fill: parent
|
|
anchors.margins: matchRect.radius * 0.5
|
|
|
|
Repeater {
|
|
// for the two athletes
|
|
model: 2
|
|
|
|
delegate: RowLayout {
|
|
|
|
height: parent.height / 2 - parent.spacing
|
|
width: parent.width
|
|
|
|
spacing: height * 0.1
|
|
|
|
Label {
|
|
Layout.preferredHeight: parent.height
|
|
Layout.preferredWidth: parent.width * 0.15
|
|
|
|
verticalAlignment: Text.AlignVCenter
|
|
horizontalAlignment: Text.AlignLeft
|
|
font.pixelSize: height * 0.7
|
|
fontSizeMode: Text.Fit
|
|
minimumPixelSize: 1
|
|
|
|
text: matchItm.thisMatchData[index] !== undefined ?
|
|
(
|
|
parseInt(matchItm.thisMatchData[index]['result_rank0']) < 10 ?
|
|
matchItm.thisMatchData[index]['result_rank0'] + " ":
|
|
matchItm.thisMatchData[index]['result_rank0']
|
|
):
|
|
""
|
|
}
|
|
|
|
Label {
|
|
Layout.preferredHeight: parent.height
|
|
Layout.fillWidth: true
|
|
|
|
height: parent.height
|
|
|
|
verticalAlignment: Text.AlignVCenter
|
|
horizontalAlignment: Text.AlignLeft
|
|
font.pixelSize: height * 0.5
|
|
font.bold: matchItm.winnerIndex === index
|
|
elide: "ElideRight"
|
|
|
|
color: matchItm.winnerIndex === index ? Material.color(Material.Green):Material.primaryTextColor
|
|
|
|
text: matchItm.thisMatchData[index] !== undefined ? matchItm.thisMatchData[index]['firstname'] + " " + matchItm.thisMatchData[index]['lastname'] :"-"
|
|
}
|
|
|
|
Label {
|
|
Layout.preferredHeight: parent.height
|
|
|
|
height: parent.height
|
|
|
|
verticalAlignment: Text.AlignVCenter
|
|
font.pixelSize: height * 0.5
|
|
|
|
text: matchItm.thisMatchData[index] !== undefined && matchItm.thisMatchData[index]['result'+matchItm.thisRound] !== undefined ?
|
|
( parseFloat(matchItm.thisMatchData[index]['result'+matchItm.thisRound]) ?
|
|
(parseFloat(matchItm.thisMatchData[index]['result'+matchItm.thisRound]).toFixed(2))
|
|
: matchItm.thisMatchData[index]['result'+matchItm.thisRound] )
|
|
: "-"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
Loader {
|
|
id: blueRockBadgeLoader
|
|
|
|
x: (parent.width - width) / 2
|
|
y: (parent.height - roundNameLa.height - height) / 2 + roundNameLa.height
|
|
|
|
sourceComponent: roundItem.thisIsSemiFinal ? blueRockBadgeComponent:undefined
|
|
|
|
Component {
|
|
id: blueRockBadgeComponent
|
|
|
|
BlueRockBadge {
|
|
width: roundItem.width
|
|
height: width * 0.25
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|