contents/ui/ActivityView.qml


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

import QtQuick 2.15
import QtQuick.Layouts 1.15
import QtQuick.Controls 2.15

import org.kde.plasma.plasmoid 2.0
import org.kde.plasma.core 2.0 as PlasmaCore
import org.kde.plasma.components 2.0 as PlasmaComponents
import org.kde.plasma.components 3.0 as PlasmaComponents3
import org.kde.plasma.extras 2.0 as PlasmaExtras

import "activity.js" as Activity

PlasmaComponents.ListItem {
    separatorVisible: false
    RowLayout {
        id: activityView
        width: (type == "announcement" ? announcementsListView : assignmentsListView).width
        Layout.fillWidth: true

        RowLayout {
            Layout.fillWidth: true
            PlasmaComponents3.CheckBox {
                id: activityCheckbox
                checkState: finished ? Qt.Checked : Qt.Unchecked
                onToggled: () => {
                    finished = (checkState == Qt.Checked)
                    activityLabel.font.strikeout = (checkState == Qt.Checked)

                    const configKeys = {
                        announcement: "finishedAnnouncements",
                        assignment: "finishedAssignments",
                    }

                    let finishedActivities = plasmoid.configuration[configKeys[type]]
                    if (finished) {
                        if (!finishedActivities.includes(activityId)) {
                            finishedActivities.push(activityId)
                        }
                    } else {
                        // remove activityId from list
                        finishedActivities.splice(finishedActivities.indexOf(activityId), 1)
                    }
                    // save config
                    plasmoid.configuration[configKeys[type]] = finishedActivities
                }
            }

            ColumnLayout {
                PlasmaComponents3.Label {
                    id: activityLabel
                    text: `[${course}] ${title}`
                    font.bold: important
                    font.strikeout: finished
                    color: important
                        ? PlasmaCore.Theme.negativeTextColor
                        : PlasmaCore.Theme.textColor
                    wrapMode: Text.WordWrap
                    Layout.fillWidth: true
                }

                PlasmaComponents3.Label {
                    id: dueLabel
                    visible: type == "assignment"
                    text: Activity.dueLabelText()
                    color: activityLabel.color
                    Layout.fillWidth: true
                }

                MouseArea {
                    width: parent.width
                    height: parent.height
                    onClicked: () => {
                        activityCheckbox.toggle()  // toggle checkbox
                        activityCheckbox.toggled() // and trigger the onToggled effects
                    }
                }
            }

        }

        RowLayout {
            Layout.alignment: Qt.AlignRight

            PlasmaComponents3.ToolButton {
                icon.name: "view-visible"
                onClicked: () => {
                    Qt.openUrlExternally(url)
                }
            }

            PlasmaComponents3.ToolButton {
                icon.name: "emblem-important-symbolic"
                checked: important

                onClicked: () => {
                    important = !important
                    activityLabel.font.bold = important
                    activityLabel.color = important
                        ? PlasmaCore.Theme.negativeTextColor
                        : PlasmaCore.Theme.textColor

                    const configKeys = {
                        announcement: "importantAnnouncements",
                        assignment: "importantAssignments",
                    }

                    let importantActivities = plasmoid.configuration[configKeys[type]]
                    if (important) {
                        if (!importantActivities.includes(activityId)) {
                            importantActivities.push(activityId)
                        }
                    } else {
                        // remove activityId from list
                        importantActivities.splice(importantActivities.indexOf(activityId), 1)
                    }
                    // save config
                    plasmoid.configuration[configKeys[type]] = importantActivities
                }
            }
        }
    }
}