606 lines
26 KiB
QML
606 lines
26 KiB
QML
import QtQuick
|
|
import QtQuick.Layouts
|
|
import Quickshell
|
|
import Quickshell.Hyprland
|
|
import Quickshell.Io
|
|
import Quickshell.Services.UPower
|
|
import "../../config"
|
|
|
|
// Battery + power-profile panel, ported from omarchy's power panel
|
|
// (github.com/basecamp/omarchy shell/plugins/panels/power/{Model.js,Panel.qml})
|
|
// onto this project's own conventions: Quickshell's native UPower/PowerProfiles
|
|
// bindings instead of omarchy's `omarchy-battery-status` /
|
|
// `omarchy-powerprofiles-list` / `omarchy-powerprofiles-set` helper scripts
|
|
// (which don't exist outside omarchy), and Material Symbols glyphs instead of
|
|
// Nerd Font ones. The charge-threshold ("Holding"/limited-charge) concept from
|
|
// the original is hardware-specific (vendor charge-limit sysfs knobs) and has
|
|
// no equivalent in Quickshell's UPower binding, so it's dropped rather than
|
|
// guessed at; "Battery health" (computed from sysfs energy_full/design) is shown in its
|
|
// place, using data UPower actually reports.
|
|
Item {
|
|
id: root
|
|
|
|
readonly property var device: UPower.displayDevice
|
|
// isLaptopBattery (type === Battery && powerSupply === true) is the
|
|
// Quickshell-recommended check for "is this actually a battery" — more
|
|
// precise than isPresent, which the docs note is only meaningful once
|
|
// you already know the device is of Battery type.
|
|
readonly property bool batteryPresent: !!(root.device && root.device.ready && root.device.isLaptopBattery)
|
|
|
|
// Hidden entirely on a desktop with no battery — RowLayout skips
|
|
// invisible children for both sizing and spacing, so this just vanishes
|
|
// from the bar rather than leaving a gap.
|
|
visible: root.batteryPresent
|
|
implicitWidth: root.batteryPresent ? label.implicitWidth : 0
|
|
implicitHeight: Appearance.barHeight
|
|
|
|
// The bar's own PanelWindow — passed in from Bar.qml so this popup can
|
|
// anchor to the bar itself rather than to this icon, keeping it a fixed
|
|
// distance from the bar and the screen edge regardless of where this
|
|
// icon sits in the row.
|
|
required property var barWindow
|
|
|
|
readonly property bool onBattery: UPower.onBattery
|
|
// Named deviceState, not "state" — Item already has a built-in `state`
|
|
// property (the property-based state-machine one) that this would
|
|
// otherwise collide with.
|
|
readonly property int deviceState: root.batteryPresent ? root.device.state : UPowerDeviceState.Unknown
|
|
readonly property bool fullyCharged: root.deviceState === UPowerDeviceState.FullyCharged
|
|
readonly property bool charging: root.batteryPresent && !root.onBattery && !root.fullyCharged
|
|
// device.percentage is a 0..1 fraction despite the name (same convention
|
|
// Volume.qml relies on for Pipewire's audio.volume).
|
|
readonly property real fraction: root.batteryPresent ? Math.max(0, Math.min(1, root.device.percentage)) : 0
|
|
readonly property bool low: root.batteryPresent && root.fraction <= 0.15 && !root.charging
|
|
|
|
// Quickshell's UPower binding has no charge-cycle property (see the
|
|
// file-header comment on why the old charge-until threshold was
|
|
// dropped) — it comes straight from sysfs instead.
|
|
//
|
|
// device.nativePath turned out to be empty on real hardware (tested
|
|
// live), so rather than build a path from it, a shell glob finds
|
|
// whichever BAT* directory actually exists — same shell-out-to-a-CLI
|
|
// convention TailscaleIndicator.qml uses for its own live stats.
|
|
// This barely changes during a session, so one read at startup is
|
|
// enough; no polling timer.
|
|
property int cycleCount: -1
|
|
|
|
Process {
|
|
id: cycleCountProc
|
|
command: ["sh", "-c", "cat \"$(ls -d /sys/class/power_supply/BAT* 2>/dev/null | head -n1)/cycle_count\" 2>/dev/null"]
|
|
running: root.batteryPresent
|
|
stdout: StdioCollector {
|
|
id: cycleCountCollector
|
|
onStreamFinished: {
|
|
const n = parseInt(cycleCountCollector.text.trim(), 10)
|
|
root.cycleCount = (isNaN(n) || n <= 0) ? -1 : n
|
|
}
|
|
}
|
|
}
|
|
|
|
// device.healthPercentage/healthSupported come from upowerd over D-Bus,
|
|
// and upowerd has been observed reporting energy-full as a flat 0 (a
|
|
// live daemon glitch, `upower -i` shows it too) while sysfs still has
|
|
// the real numbers underneath — same class of unreliability that put
|
|
// cycle_count on sysfs above instead of trusting upowerd's own
|
|
// charge-cycles field. Health is computed the same way UPower computes
|
|
// it (current full-charge capacity over the battery's original design
|
|
// capacity), just read directly so a daemon hiccup doesn't blank it.
|
|
property real energyFullWh: -1
|
|
property real energyFullDesignWh: -1
|
|
readonly property real healthPercent: (root.energyFullWh > 0 && root.energyFullDesignWh > 0)
|
|
? Math.min(100, (root.energyFullWh / root.energyFullDesignWh) * 100) : -1
|
|
|
|
Process {
|
|
id: energyFullProc
|
|
command: ["sh", "-c", "cat \"$(ls -d /sys/class/power_supply/BAT* 2>/dev/null | head -n1)/energy_full\" 2>/dev/null"]
|
|
running: root.batteryPresent
|
|
stdout: StdioCollector {
|
|
id: energyFullCollector
|
|
onStreamFinished: {
|
|
const n = parseFloat(energyFullCollector.text.trim())
|
|
root.energyFullWh = (isNaN(n) || n <= 0) ? -1 : (n / 1000000)
|
|
}
|
|
}
|
|
}
|
|
|
|
Process {
|
|
id: energyFullDesignProc
|
|
command: ["sh", "-c", "cat \"$(ls -d /sys/class/power_supply/BAT* 2>/dev/null | head -n1)/energy_full_design\" 2>/dev/null"]
|
|
running: root.batteryPresent
|
|
stdout: StdioCollector {
|
|
id: energyFullDesignCollector
|
|
onStreamFinished: {
|
|
const n = parseFloat(energyFullDesignCollector.text.trim())
|
|
root.energyFullDesignWh = (isNaN(n) || n <= 0) ? -1 : (n / 1000000)
|
|
}
|
|
}
|
|
}
|
|
|
|
// device.timeToFull/timeToEmpty are computed by Quickshell from
|
|
// energy/energyCapacity/changeRate — when upowerd's EnergyFull glitches
|
|
// to 0 (the same daemon flake HEALTH routes around above), that formula
|
|
// divides by a bogus capacity and comes out negative rather than a
|
|
// real estimate (confirmed live: timeToFull sat at -3751 while `upower
|
|
// -i` itself still reported a normal 26.7 minutes). This recomputes
|
|
// the same estimate straight from sysfs as a fallback, only used when
|
|
// Quickshell's own value isn't positive. Unlike cycle_count/design
|
|
// capacity above, energy_now and power_now change continuously while
|
|
// (dis)charging, so this polls on a timer instead of reading once.
|
|
property real sysfsEnergyNowWh: -1
|
|
property real sysfsPowerNowW: -1
|
|
|
|
readonly property real fallbackTimeToFullSeconds: (root.sysfsPowerNowW > 0 && root.energyFullWh > 0 && root.sysfsEnergyNowWh >= 0)
|
|
? Math.max(0, (root.energyFullWh - root.sysfsEnergyNowWh) / root.sysfsPowerNowW * 3600) : -1
|
|
readonly property real fallbackTimeToEmptySeconds: (root.sysfsPowerNowW > 0 && root.sysfsEnergyNowWh > 0)
|
|
? (root.sysfsEnergyNowWh / root.sysfsPowerNowW * 3600) : -1
|
|
|
|
// Prefers upowerd's own live estimate when it's sane; only falls back
|
|
// to the sysfs-computed one when upowerd's has gone zero/negative.
|
|
readonly property real timeRemainingSeconds: {
|
|
const primary = root.onBattery ? root.device.timeToEmpty : root.device.timeToFull
|
|
if (primary > 0) return primary
|
|
return root.onBattery ? root.fallbackTimeToEmptySeconds : root.fallbackTimeToFullSeconds
|
|
}
|
|
|
|
Timer {
|
|
id: sysfsRateTimer
|
|
interval: 15000
|
|
repeat: true
|
|
running: root.batteryPresent
|
|
triggeredOnStart: true
|
|
onTriggered: {
|
|
if (!sysfsEnergyNowProc.running) sysfsEnergyNowProc.running = true
|
|
if (!sysfsPowerNowProc.running) sysfsPowerNowProc.running = true
|
|
}
|
|
}
|
|
|
|
Process {
|
|
id: sysfsEnergyNowProc
|
|
command: ["sh", "-c", "cat \"$(ls -d /sys/class/power_supply/BAT* 2>/dev/null | head -n1)/energy_now\" 2>/dev/null"]
|
|
stdout: StdioCollector {
|
|
id: sysfsEnergyNowCollector
|
|
onStreamFinished: {
|
|
const n = parseFloat(sysfsEnergyNowCollector.text.trim())
|
|
root.sysfsEnergyNowWh = (isNaN(n) || n < 0) ? -1 : (n / 1000000)
|
|
}
|
|
}
|
|
}
|
|
|
|
Process {
|
|
id: sysfsPowerNowProc
|
|
command: ["sh", "-c", "cat \"$(ls -d /sys/class/power_supply/BAT* 2>/dev/null | head -n1)/power_now\" 2>/dev/null"]
|
|
stdout: StdioCollector {
|
|
id: sysfsPowerNowCollector
|
|
onStreamFinished: {
|
|
const n = parseFloat(sysfsPowerNowCollector.text.trim())
|
|
root.sysfsPowerNowW = (isNaN(n) || n <= 0) ? -1 : (n / 1000000)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Raw UPower state string (Charging/Discharging/PendingCharge/…) — more
|
|
// granular than modeLabel below, which collapses those down to the
|
|
// three phrases the hero text and STATE row show.
|
|
readonly property string rawStateLabel: root.batteryPresent
|
|
? UPowerDeviceState.toString(root.deviceState) : "—"
|
|
|
|
// Material Symbols' charging glyphs aren't an evenly-spaced "_bar"
|
|
// scale like the non-charging ones below — they're fixed at these
|
|
// seven breakpoints (confirmed against the installed font's ligature
|
|
// table), so this picks the highest one at or below the current
|
|
// percentage rather than rounding to an index.
|
|
function chargingIcon(fraction) {
|
|
const percent = fraction * 100
|
|
const thresholds = [20, 30, 50, 60, 80, 90, 100]
|
|
const icons = [
|
|
"battery_charging_20", "battery_charging_30", "battery_charging_50", "battery_charging_60",
|
|
"battery_charging_80", "battery_charging_90", "battery_charging_full"
|
|
]
|
|
for (let i = thresholds.length - 1; i >= 0; i--) {
|
|
if (percent >= thresholds[i]) return icons[i]
|
|
}
|
|
// Below 20% there's no lower charging glyph — it's still the
|
|
// truthful floor of what's available while current is flowing in.
|
|
return icons[0]
|
|
}
|
|
|
|
function batteryIcon() {
|
|
if (!root.batteryPresent) return "battery_unknown"
|
|
if (root.fullyCharged) return "battery_full"
|
|
if (root.charging) return root.chargingIcon(root.fraction)
|
|
if (root.fraction <= 0.1) return "battery_alert"
|
|
const bars = ["battery_0_bar", "battery_1_bar", "battery_2_bar", "battery_3_bar", "battery_4_bar", "battery_5_bar", "battery_full"]
|
|
return bars[Math.max(0, Math.min(bars.length - 1, Math.round(root.fraction * (bars.length - 1))))]
|
|
}
|
|
|
|
function formatDuration(seconds) {
|
|
const s = Math.max(0, Math.round(seconds || 0))
|
|
if (s <= 0) return "—"
|
|
const h = Math.floor(s / 3600)
|
|
const m = Math.round((s % 3600) / 60)
|
|
return h > 0 ? (h + "h " + m + "m") : (m + "m")
|
|
}
|
|
|
|
readonly property string modeLabel: {
|
|
if (!root.batteryPresent) return ""
|
|
if (root.fullyCharged) return "Fully charged"
|
|
return root.onBattery ? "On battery" : "Charging"
|
|
}
|
|
|
|
// Info grid rows — same shape as NetworkIndicator.qml's statRows/
|
|
// statCells: a flat label/value list, flattened again into individual
|
|
// grid cells (label, value, label, value, …) so a 4-column GridLayout
|
|
// lays them out as two label/value pairs per row.
|
|
readonly property var statRows: [
|
|
{
|
|
label: "HEALTH",
|
|
value: root.healthPercent > 0 ? Math.round(root.healthPercent) + "%" : "—"
|
|
},
|
|
{
|
|
label: root.onBattery ? "TIME LEFT" : "TIME TO FULL",
|
|
value: root.batteryPresent ? root.formatDuration(root.timeRemainingSeconds) : "—"
|
|
},
|
|
{ label: "STATUS", value: root.rawStateLabel },
|
|
{ label: "CYCLES", value: root.cycleCount > 0 ? String(root.cycleCount) : "—" }
|
|
]
|
|
|
|
readonly property var statCells: {
|
|
const cells = []
|
|
for (let i = 0; i < root.statRows.length; i++) {
|
|
cells.push({ text: root.statRows[i].label, isLabel: true })
|
|
cells.push({ text: root.statRows[i].value, isLabel: false })
|
|
}
|
|
return cells
|
|
}
|
|
|
|
// Cute rotating status phrases while current is actually flowing —
|
|
// ported as-is from omarchy's power panel, which pairs the same phrase
|
|
// sets with the same charging/on-battery states.
|
|
readonly property var chargingPhrases: [
|
|
"Pumping power", "Injecting electrons", "Pouring juice", "Amassing watts",
|
|
"Hoarding joules", "Sucking volts", "Topping reserves", "Soaking amps", "Inhaling kilowatts"
|
|
]
|
|
readonly property var onBatteryPhrases: [
|
|
"Slurping power", "Spending joules", "Draining watts", "Burning electrons",
|
|
"Sipping juice", "Spending coulombs", "Bleeding amps", "Guzzling volts", "Munching reserves"
|
|
]
|
|
readonly property var activePhrases: root.fullyCharged ? []
|
|
: (root.charging ? root.chargingPhrases : (root.onBattery ? root.onBatteryPhrases : []))
|
|
readonly property bool rotatingPhrases: root.activePhrases.length > 0
|
|
property int phraseIndex: 0
|
|
readonly property string heroStatusText: root.rotatingPhrases
|
|
? root.activePhrases[root.phraseIndex % root.activePhrases.length]
|
|
: root.modeLabel
|
|
|
|
// Only rotates while the panel is open and actually charging/discharging.
|
|
Timer {
|
|
id: phraseTimer
|
|
interval: 2800
|
|
running: panel.visible && root.rotatingPhrases
|
|
repeat: true
|
|
triggeredOnStart: false
|
|
onTriggered: phraseSwap.restart()
|
|
}
|
|
|
|
SequentialAnimation {
|
|
id: phraseSwap
|
|
PropertyAnimation { target: heroStatus; property: "opacity"; to: 0.0; duration: 180; easing.type: Easing.OutQuad }
|
|
ScriptAction {
|
|
script: {
|
|
const n = root.activePhrases.length
|
|
if (n > 0) root.phraseIndex = (root.phraseIndex + 1) % n
|
|
}
|
|
}
|
|
PropertyAnimation { target: heroStatus; property: "opacity"; to: 1.0; duration: 260; easing.type: Easing.InQuad }
|
|
}
|
|
|
|
// If we leave a rotating state mid-swap (e.g. unplugged mid-fade),
|
|
// snap back to full opacity so the new state reads immediately.
|
|
Connections {
|
|
target: root
|
|
function onRotatingPhrasesChanged() {
|
|
if (!root.rotatingPhrases) {
|
|
phraseSwap.stop()
|
|
heroStatus.opacity = 1.0
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- Power profile list ------------------------------------------------
|
|
// power-profiles-daemon only ever exposes these three fixed profiles;
|
|
// Performance is conditional on hasPerformanceProfile (e.g. absent on
|
|
// battery-only/thermally-limited hardware) — same gating omarchy's own
|
|
// Model.js applies via its profile-list script.
|
|
readonly property var profileEntries: {
|
|
const entries = [
|
|
{ value: PowerProfile.PowerSaver, label: "Saver", icon: "eco" },
|
|
{ value: PowerProfile.Balanced, label: "Balanced", icon: "balance" }
|
|
]
|
|
if (PowerProfiles.hasPerformanceProfile)
|
|
entries.push({ value: PowerProfile.Performance, label: "Performance", icon: "bolt" })
|
|
return entries
|
|
}
|
|
|
|
// --- Automatic power profile --------------------------------------
|
|
// Battery-state-driven, on top of the manual picker above: below 20%
|
|
// → Power Saver (protect what's left), plugged in → Performance,
|
|
// unplugged and healthy → Balanced. Low battery wins even if a weak
|
|
// charger is still plugged in — running low is the more urgent signal.
|
|
// Performance only gets requested when the daemon actually reports it
|
|
// as available, falling back to Balanced instead of erroring on
|
|
// hardware without a performance profile (e.g. the ERROR this exact
|
|
// widget hit before power-profiles-daemon was installed).
|
|
//
|
|
// This only ever writes when the *target* changes (crossing the 20%
|
|
// line, plugging/unplugging) rather than on every poll, so a manual
|
|
// pick from the buttons above still sticks until the next real
|
|
// transition instead of being fought immediately.
|
|
readonly property int desiredProfile: {
|
|
if (root.fraction <= 0.20) return PowerProfile.PowerSaver
|
|
if (!root.onBattery) return PowerProfiles.hasPerformanceProfile ? PowerProfile.Performance : PowerProfile.Balanced
|
|
return PowerProfile.Balanced
|
|
}
|
|
|
|
function applyDesiredProfile() {
|
|
if (!root.batteryPresent) return
|
|
if (PowerProfiles.profile !== root.desiredProfile) PowerProfiles.profile = root.desiredProfile
|
|
}
|
|
|
|
onDesiredProfileChanged: root.applyDesiredProfile()
|
|
Component.onCompleted: Qt.callLater(root.applyDesiredProfile)
|
|
|
|
Text {
|
|
id: label
|
|
anchors.centerIn: parent
|
|
font.family: Appearance.iconFontFamilyRounded
|
|
font.variableAxes: Appearance.iconFontAxes
|
|
font.pixelSize: 16
|
|
color: root.low ? Colors.urgent : Colors.foreground
|
|
text: root.batteryIcon()
|
|
}
|
|
|
|
MouseArea {
|
|
anchors.fill: parent
|
|
cursorShape: Qt.PointingHandCursor
|
|
onClicked: {
|
|
panel.visible = !panel.visible
|
|
grab.active = panel.visible
|
|
}
|
|
}
|
|
|
|
// --- Reusable pieces -----------------------------------------------
|
|
|
|
component ProfileButton: Rectangle {
|
|
id: profBtn
|
|
required property string label
|
|
required property string icon
|
|
required property bool active
|
|
signal activate()
|
|
width: parent ? parent.width : 0
|
|
radius: 0
|
|
implicitHeight: 44
|
|
color: mouse.containsMouse ? Colors.primary
|
|
: (profBtn.active ? Qt.rgba(Colors.primary.r, Colors.primary.g, Colors.primary.b, 0.18) : "transparent")
|
|
|
|
// Hover-only outline, offset outside the button rather than drawn on
|
|
// its own edge — same treatment as this project's other selectable
|
|
// rows (e.g. Volume.qml's DeviceRow).
|
|
Rectangle {
|
|
anchors.fill: parent
|
|
anchors.margins: -3
|
|
radius: 0
|
|
color: "transparent"
|
|
border.color: Colors.foreground
|
|
border.width: mouse.containsMouse ? 1 : 0
|
|
}
|
|
|
|
Column {
|
|
anchors.centerIn: parent
|
|
spacing: 2
|
|
Text {
|
|
anchors.horizontalCenter: parent.horizontalCenter
|
|
text: profBtn.icon
|
|
font.family: Appearance.iconFontFamilyRounded
|
|
font.variableAxes: Appearance.iconFontAxes
|
|
font.pixelSize: 18
|
|
color: mouse.containsMouse ? Colors.primaryText : Colors.foreground
|
|
}
|
|
Text {
|
|
anchors.horizontalCenter: parent.horizontalCenter
|
|
text: profBtn.label
|
|
font.family: Appearance.fontFamily
|
|
font.pixelSize: Appearance.fontSizeSmall
|
|
font.bold: profBtn.active
|
|
color: mouse.containsMouse ? Colors.primaryText : Colors.foreground
|
|
}
|
|
}
|
|
|
|
MouseArea {
|
|
id: mouse
|
|
anchors.fill: parent
|
|
hoverEnabled: true
|
|
cursorShape: Qt.PointingHandCursor
|
|
onClicked: profBtn.activate()
|
|
}
|
|
}
|
|
|
|
// --- Panel -----------------------------------------------------------
|
|
|
|
PopupWindow {
|
|
id: panel
|
|
visible: false
|
|
color: "transparent"
|
|
// Wider than before (244) to give the 2-column info grid's
|
|
// label/value pairs enough room per half without eliding —
|
|
// same reasoning as NetworkIndicator.qml's own wider panel.
|
|
readonly property int contentWidth: 280
|
|
readonly property int contentPadding: 16
|
|
implicitWidth: contentWidth + contentPadding * 2
|
|
implicitHeight: mainColumn.implicitHeight + contentPadding * 2
|
|
|
|
anchor {
|
|
window: root.barWindow
|
|
// Unlike anchor.item, anchor.window doesn't default rect to the
|
|
// window's own bounds — set it explicitly so edges/gravity below
|
|
// resolve against the full bar (and thus the true screen edges)
|
|
// instead of a near-zero rect at the window's origin.
|
|
rect.x: 0
|
|
rect.y: 0
|
|
rect.width: root.barWindow.width
|
|
rect.height: root.barWindow.height
|
|
edges: Edges.Bottom | Edges.Right
|
|
gravity: Edges.Bottom | Edges.Left
|
|
margins.bottom: -4
|
|
margins.right: 0
|
|
}
|
|
|
|
HyprlandFocusGrab {
|
|
id: grab
|
|
windows: [panel]
|
|
onCleared: panel.visible = false
|
|
}
|
|
|
|
Rectangle {
|
|
anchors.fill: parent
|
|
radius: 0
|
|
color: Colors.surface
|
|
border.color: Colors.muted
|
|
border.width: 3
|
|
|
|
Column {
|
|
id: mainColumn
|
|
anchors.fill: parent
|
|
anchors.margins: panel.contentPadding
|
|
spacing: 10
|
|
|
|
// Hero: icon · title/status · percentage
|
|
RowLayout {
|
|
width: parent.width
|
|
spacing: 10
|
|
|
|
Text {
|
|
text: root.batteryIcon()
|
|
font.family: Appearance.iconFontFamilyRounded
|
|
font.variableAxes: Appearance.iconFontAxes
|
|
font.pixelSize: 30
|
|
color: root.low ? Colors.urgent : Colors.foreground
|
|
}
|
|
|
|
Column {
|
|
Layout.fillWidth: true
|
|
spacing: 2
|
|
Text {
|
|
width: parent.width
|
|
text: "Battery"
|
|
elide: Text.ElideRight
|
|
font.family: Appearance.fontFamily
|
|
font.pixelSize: 18
|
|
font.bold: true
|
|
color: Colors.foreground
|
|
}
|
|
Text {
|
|
id: heroStatus
|
|
width: parent.width
|
|
text: root.heroStatusText
|
|
elide: Text.ElideRight
|
|
font.family: Appearance.fontFamily
|
|
font.pixelSize: Appearance.fontSizeSmall
|
|
color: Colors.muted
|
|
}
|
|
}
|
|
|
|
Text {
|
|
text: Math.round(root.fraction * 100) + "%"
|
|
font.family: Appearance.fontFamily
|
|
font.pixelSize: 20
|
|
font.bold: true
|
|
color: Colors.foreground
|
|
}
|
|
}
|
|
|
|
// Charge level bar
|
|
Item {
|
|
width: parent.width
|
|
height: 4
|
|
|
|
Rectangle {
|
|
anchors.fill: parent
|
|
radius: 0
|
|
color: Colors.muted
|
|
opacity: 0.35
|
|
}
|
|
Rectangle {
|
|
anchors.left: parent.left
|
|
anchors.top: parent.top
|
|
anchors.bottom: parent.bottom
|
|
radius: 0
|
|
color: root.low ? Colors.urgent : Colors.primary
|
|
width: Math.max(height, parent.width * root.fraction)
|
|
Behavior on width { NumberAnimation { duration: 320; easing.type: Easing.OutCubic } }
|
|
}
|
|
}
|
|
|
|
// Stats — a 2-column, 2-row info grid, same layout
|
|
// NetworkIndicator.qml uses for its own live stats: a
|
|
// 4-column GridLayout fed a flattened label/value/label/value
|
|
// list, so each row holds two label/value pairs side by side
|
|
// with the values right-aligned against their own half.
|
|
GridLayout {
|
|
width: parent.width
|
|
columns: 4
|
|
columnSpacing: 12
|
|
rowSpacing: 5
|
|
|
|
Repeater {
|
|
model: root.statCells
|
|
Text {
|
|
required property var modelData
|
|
Layout.fillWidth: !modelData.isLabel
|
|
horizontalAlignment: modelData.isLabel ? Text.AlignLeft : Text.AlignRight
|
|
text: modelData.text
|
|
font.family: Appearance.fontFamily
|
|
font.pixelSize: Appearance.fontSizeSmall
|
|
color: modelData.isLabel ? Colors.muted : Colors.foreground
|
|
}
|
|
}
|
|
}
|
|
|
|
// Power profile picker
|
|
Column {
|
|
width: parent.width
|
|
spacing: 6
|
|
|
|
Text {
|
|
text: "POWER PROFILE"
|
|
font.family: Appearance.fontFamily
|
|
font.pixelSize: Appearance.fontSizeSmall
|
|
color: Colors.muted
|
|
}
|
|
|
|
Row {
|
|
id: profileRow
|
|
width: parent.width
|
|
spacing: 6
|
|
|
|
readonly property real cellWidth: root.profileEntries.length > 0
|
|
? (width - spacing * (root.profileEntries.length - 1)) / root.profileEntries.length
|
|
: 0
|
|
|
|
Repeater {
|
|
model: root.profileEntries
|
|
ProfileButton {
|
|
required property var modelData
|
|
width: profileRow.cellWidth
|
|
label: modelData.label
|
|
icon: modelData.icon
|
|
active: PowerProfiles.profile === modelData.value
|
|
onActivate: PowerProfiles.profile = modelData.value
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|