Warning, /plasma/plasma-workspace/applets/mediacontroller/package/contents/ui/AlbumArtStackView.qml is written in an unsupported language. File is not indexed.

 /*
     SPDX-FileCopyrightText: 2013 Marco Martin <mart@kde.org>
     SPDX-FileCopyrightText: 2014 Sebastian Kügler <sebas@kde.org>
     SPDX-FileCopyrightText: 2014 Kai Uwe Broulik <kde@privat.broulik.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 import QtQuick 2.15
 import QtQuick.Controls 2.15
 import QtQuick.Window 2.15
 
 import org.kde.plasma.plasmoid 2.0
 import org.kde.plasma.components 3.0 as PC3
 import org.kde.plasma.extras 2.0 as PlasmaExtras
 import org.kde.plasma.private.mpris as Mpris
 import org.kde.kirigami 2.20 as Kirigami
 
 Item {
     id: container
 
     /**
      * Whether the album art image is available or in loading status
      */
     readonly property bool hasImage: (pendingImage !== null && (pendingImage.status === Image.Ready || pendingImage.status === Image.Loading))
         || (albumArt.currentItem instanceof Image && albumArt.currentItem.status === Image.Ready)
 
     readonly property bool animating: exitTransition.running || popExitTransition.running
 
     /**
      * Whether the component is used in the compact representation
      */
     property bool inCompactRepresentation: false
 
     /**
      * Provides source item for \ShaderEffectSource
      */
     readonly property alias albumArt: albumArt
 
     property Image pendingImage: null
 
     function loadAlbumArt() {
         if (pendingImage !== null) {
             pendingImage.destroy();
             pendingImage = null;
         }
 
         if (!root.albumArt) {
             albumArt.clear(StackView.PopTransition);
             return;
         }
 
         const oldImageRatio = albumArt.currentItem instanceof Image ? albumArt.currentItem.sourceSize.width / albumArt.currentItem.sourceSize.height : 1;
         pendingImage = albumArtComponent.createObject(albumArt, {
             "source": root.albumArt,
             "sourceSize": Qt.size(container.width * Screen.devicePixelRatio, container.height * Screen.devicePixelRatio),
             "opacity": 0,
         });
 
         function replaceWhenLoaded() {
             // There can be a potential race: when the previous player is gone but the pending image is just ready in time,
             // pendingImage.destroy() -> QQuickImage::deleteLater(), so in the event queue statusChanged may be emitted
             // before pendingImage is deleted, but pendingImage is already set to null when the previous player is gone.
             if (pendingImage === null || pendingImage.status === Image.Loading) {
                 return;
             }
 
             if (pendingImage.status === Image.Ready) {
                 const newImageRatio = pendingImage.sourceSize.width / pendingImage.sourceSize.height;
                 exitTransitionOpacityAnimator.duration = oldImageRatio === newImageRatio ? 0 : Kirigami.Units.longDuration;
             } else {
                 // Load placeholder icon, but keep the invalid image to avoid flashing application icons
                 exitTransitionOpacityAnimator.duration = 0;
             }
 
             pendingImage.statusChanged.disconnect(replaceWhenLoaded);
             albumArt.replace(pendingImage, {}, StackView.ReplaceTransition);
             pendingImage = null;
         }
 
         pendingImage.statusChanged.connect(replaceWhenLoaded);
         replaceWhenLoaded();
     }
 
     Connections {
         enabled: root.expanded // BUG 477866
         target: container
         function onWidthChanged() {
             geometryChangeTimer.restart();
         }
         function onHeightChanged() {
             geometryChangeTimer.restart();
         }
     }
 
     // Reload album art when size of container changes
     Timer {
         id: geometryChangeTimer
         interval: 250
         onTriggered: container.loadAlbumArt();
     }
 
     StackView {
         id: albumArt
 
         anchors.fill: parent
 
         readonly property string icon: root.iconName || "media-album-cover"
 
         replaceEnter: Transition {
             OpacityAnimator {
                 from: 0
                 to: 1
                 duration: Kirigami.Units.longDuration
             }
         }
 
         replaceExit: Transition {
             id: exitTransition
 
             SequentialAnimation {
                 PauseAnimation {
                     duration: Kirigami.Units.longDuration
                 }
 
                 /**
                 * If the new ratio and the old ratio are different,
                 * perform a fade-out animation for the old image
                 * to prevent it from suddenly disappearing.
                 */
                 OpacityAnimator {
                     id: exitTransitionOpacityAnimator
                     from: 1
                     to: 0
                     duration: 0
                 }
             }
         }
 
         popExit: Transition {
             id: popExitTransition
 
             OpacityAnimator {
                 from: 1
                 to: 0
                 duration: Kirigami.Units.longDuration
             }
         }
 
         Component {
             id: albumArtComponent
 
             Image { // Album Art
                 horizontalAlignment: Image.AlignHCenter
                 verticalAlignment: Image.AlignVCenter
                 fillMode: container.inCompactRepresentation ? Image.PreserveAspectCrop : Image.PreserveAspectFit
 
                 asynchronous: true
                 cache: false
 
                 // onRemoved only fires when all transitions end. If a user switches songs quickly this adds up
                 // Given it's such a heavy item, try to cleanup as early as possible
                 StackView.onDeactivated: destroy()
                 StackView.onRemoved: destroy()
             }
         }
 
         Component {
             id: fallbackIconItem
 
             Kirigami.Icon { // Fallback
                 id: fallbackIcon
 
                 anchors.margins: Kirigami.Units.gridUnit * 2
                 opacity: 0
                 source: albumArt.icon
 
                 NumberAnimation {
                     duration: Kirigami.Units.longDuration
                     easing.type: Easing.OutCubic
                     property: "opacity"
                     running: true
                     target: fallbackIcon
                     to: 1
                 }
             }
         }
 
         // "No media playing" placeholder message
         Component {
             id: placeholderMessage
 
             // Put PlaceholderMessage in Item so PlaceholderMessage will not fill its parent.
             Item {
                 property alias source: message.iconName
 
                 PlasmaExtras.PlaceholderMessage {
                     id: message
                     anchors.centerIn: parent
                     width: parent.width // For text wrap
                     iconName: albumArt.icon
                     text: root.playbackStatus > Mpris.PlaybackStatus.Stopped ? i18n("No title") : i18n("No media playing")
                 }
             }
         }
 
         Component {
             id: busyComponent
 
             Item {
                 PC3.BusyIndicator {
                     id: busyIndicator
                     anchors.centerIn: parent
                     running: false
                 }
 
                 SequentialAnimation {
                     running: true
 
                     PauseAnimation {
                         duration: Kirigami.Units.longDuration
                     }
                     PropertyAction {
                         property: "running"
                         target: busyIndicator
                         value: true
                     }
                 }
             }
 
         }
     }
 
     Loader {
         anchors.fill: parent
         visible: active
 
         readonly property bool isLoadingImage: pendingImage !== null && pendingImage.status === Image.Loading
 
         active: (inCompactRepresentation || root.expanded) && (!container.hasImage || isLoadingImage)
         asynchronous: true
         sourceComponent: root.track ? (isLoadingImage ? busyComponent : fallbackIconItem) : placeholderMessage
     }
 }