Warning, /pim/kube/framework/qml/ConversationListView.qml is written in an unsupported language. File is not indexed.

 /*
  *  Copyright (C) 2016 Michael Bohlender, <michael.bohlender@kdemail.net>
  *  Copyright (C) 2017 Christian Mollekopf, <mollekopf@kolabsystems.com>
  *
  *  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 2 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, write to the Free Software Foundation, Inc.,
  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 import QtQuick 2.7
 import QtQuick.Controls 2
 import QtQuick.Layouts 1.1
 import org.kube.framework 1.0 as Kube
 
 import QtQml 2.2 as QtQml
 
 FocusScope {
     id: root
     property alias model: repeater.model
     property alias delegate: repeater.delegate
     property alias count: repeater.count
     property alias contentHeight: flickable.contentHeight
     property int currentIndex: -1
 
     //We want to avoid interfering with scrolling as soon as the user starts to scroll. This is important if i.e. an html mail loads slowly.
     //However, we have to maintain position as the initial items expand, so we have to react to contentHeight changes. scrollToEnd ensures both.
     property bool scrollToEnd: true
 
     property var currentItem: null
 
     function scrollDown() {
         scrollHelper.scrollDown()
     }
 
     function scrollUp() {
         scrollHelper.scrollUp()
     }
 
     function setCurrentItem() {
         if (currentItem) {
             currentItem.isCurrentItem = false
         }
         if (currentIndex >= 0 && activeFocus) {
             var item = repeater.itemAt(currentIndex)
             if (item) {
                 item.isCurrentItem = true
                 currentItem = item
             }
         } else {
             currentItem = null
         }
     }
 
     onCurrentIndexChanged: {
         setCurrentItem()
     }
 
     onActiveFocusChanged: {
         setCurrentItem()
     }
 
     function incrementCurrentIndex() {
         flickable.incrementCurrentIndex()
     }
 
     function decrementCurrentIndex() {
         flickable.decrementCurrentIndex()
     }
 
     Flickable {
         id: flickable
         anchors.fill: parent
 
         //Optimize for view quality
         pixelAligned: true
 
         contentWidth: width
         contentHeight: col.height
 
         function scrollToIndex(index) {
             var item = repeater.itemAt(index)
             if (item) {
                 scrollToPos(item.y)
             }
         }
 
         function scrollToPos(pos) {
             var scrollToEndPos = (flickable.contentHeight - flickable.height)
             //Avoid scrolling past the end
             if (pos < scrollToEndPos) {
                 flickable.contentY = pos
             } else {
                 flickable.contentY = scrollToEndPos
             }
         }
 
         onMovementStarted: {
             root.scrollToEnd = false
         }
 
         onContentHeightChanged: {
             if (repeater.count && root.scrollToEnd) {
                 //Scroll to the last item
                 root.currentIndex = repeater.count - 1
                 flickable.scrollToIndex(root.currentIndex)
             }
         }
 
         Column {
             id: col
             width: parent.width
             spacing: 2
             Repeater {
                 id: repeater
                 onItemAdded: {
                     root.scrollToEnd = true
                     flickable.scrollToIndex(root.currentIndex)
                 }
             }
         }
 
         function incrementCurrentIndex() {
             if (currentIndex < repeater.count - 1) {
                 currentIndex = currentIndex + 1
             }
             scrollToIndex(currentIndex)
         }
 
         function decrementCurrentIndex() {
             if (currentIndex > 0) {
                 currentIndex = currentIndex - 1
             }
             scrollToIndex(currentIndex)
         }
 
         Keys.onPressed: {
             if (event.matches(StandardKey.MoveToNextLine)) {
                 scrollHelper.scrollDown()
             } else if (event.matches(StandardKey.MoveToPreviousLine)) {
                 scrollHelper.scrollUp()
             }
         }
 
         Kube.ScrollHelper {
             id: scrollHelper
             flickable: flickable
             anchors.fill: parent
         }
 
         //Intercept all scroll events,
         //necessary due to the webengineview
         Kube.MouseProxy {
             anchors.fill: parent
             target: scrollHelper
             forwardWheelEvents: true
         }
 
         ScrollBar.vertical: Kube.ScrollBar {}
 
     }
 }