mirror of
https://github.com/zoriya/noctalia-shell.git
synced 2026-08-06 22:37:06 +00:00
984 lines
33 KiB
QML
984 lines
33 KiB
QML
import QtQuick
|
|
import QtQuick.Layouts
|
|
import QtQuick.Controls
|
|
import Qt.labs.folderlistmodel
|
|
import Quickshell
|
|
import Quickshell.Io
|
|
import qs.Commons
|
|
import qs.Services
|
|
import qs.Widgets
|
|
import "../Helpers/FuzzySort.js" as FuzzySort
|
|
|
|
Popup {
|
|
id: root
|
|
|
|
// Public properties
|
|
property string title: "File Picker"
|
|
property string initialPath: Quickshell.env("HOME") || "/home"
|
|
property bool selectFiles: true
|
|
property bool selectFolders: true
|
|
property var nameFilters: ["*"] // Default to show all files
|
|
property bool showDirs: true
|
|
property real scaling: 1.0
|
|
|
|
// Selected files/folders
|
|
property var selectedPaths: []
|
|
property string currentPath: initialPath
|
|
property bool shouldResetSelection: false
|
|
|
|
// Signals
|
|
signal fileSelected(string path)
|
|
signal filesSelected(var paths)
|
|
signal folderSelected(string path)
|
|
signal cancelled
|
|
|
|
// Override the open function to ensure proper initialization
|
|
function openFileManager() {
|
|
// Ensure we have a valid path
|
|
if (!root.currentPath || root.currentPath === "") {
|
|
root.currentPath = root.initialPath
|
|
}
|
|
// Signal that selection should be reset
|
|
shouldResetSelection = true
|
|
open()
|
|
}
|
|
|
|
// Helper functions
|
|
function getFileIcon(fileName) {
|
|
var extension = fileName.split('.').pop().toLowerCase()
|
|
switch (extension) {
|
|
case 'txt':
|
|
case 'md':
|
|
case 'log':
|
|
return 'file-text'
|
|
case 'jpg':
|
|
case 'jpeg':
|
|
case 'png':
|
|
case 'gif':
|
|
case 'bmp':
|
|
case 'svg':
|
|
return 'photo'
|
|
case 'mp4':
|
|
case 'avi':
|
|
case 'mkv':
|
|
case 'mov':
|
|
return 'video'
|
|
case 'mp3':
|
|
case 'wav':
|
|
case 'flac':
|
|
case 'ogg':
|
|
return 'music'
|
|
case 'zip':
|
|
case 'tar':
|
|
case 'gz':
|
|
case 'rar':
|
|
case '7z':
|
|
return 'archive'
|
|
case 'pdf':
|
|
return 'file-text'
|
|
case 'doc':
|
|
case 'docx':
|
|
return 'file-text'
|
|
case 'xls':
|
|
case 'xlsx':
|
|
return 'table'
|
|
case 'ppt':
|
|
case 'pptx':
|
|
return 'presentation'
|
|
case 'html':
|
|
case 'htm':
|
|
case 'css':
|
|
case 'js':
|
|
case 'json':
|
|
case 'xml':
|
|
return 'code'
|
|
case 'exe':
|
|
case 'app':
|
|
case 'deb':
|
|
case 'rpm':
|
|
return 'settings'
|
|
default:
|
|
return 'file'
|
|
}
|
|
}
|
|
|
|
function formatFileSize(bytes) {
|
|
if (bytes === 0)
|
|
return "0 B"
|
|
var k = 1024
|
|
var sizes = ["B", "KB", "MB", "GB", "TB"]
|
|
var i = Math.floor(Math.log(bytes) / Math.log(k))
|
|
return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i]
|
|
}
|
|
|
|
function confirmSelection() {
|
|
if (filePickerPanel.currentSelection.length === 0) {
|
|
return
|
|
}
|
|
|
|
root.selectedPaths = filePickerPanel.currentSelection
|
|
|
|
if (filePickerPanel.currentSelection.length === 1) {
|
|
var path = filePickerPanel.currentSelection[0]
|
|
if (root.selectFiles && !root.selectFolders) {
|
|
root.fileSelected(path)
|
|
} else if (root.selectFolders && !root.selectFiles) {
|
|
root.folderSelected(path)
|
|
} else {
|
|
// Both files and folders allowed
|
|
var isDir = folderModel.get(folderModel.indexOf(path), "fileIsDir")
|
|
if (isDir) {
|
|
root.folderSelected(path)
|
|
} else {
|
|
root.fileSelected(path)
|
|
}
|
|
}
|
|
} else {
|
|
root.filesSelected(filePickerPanel.currentSelection)
|
|
}
|
|
|
|
root.close()
|
|
}
|
|
|
|
// Function to update the filtered model
|
|
function updateFilteredModel() {
|
|
filteredModel.clear()
|
|
var searchText = filePickerPanel.filterText.toLowerCase()
|
|
|
|
for (var i = 0; i < folderModel.count; i++) {
|
|
var fileName = folderModel.get(i, "fileName")
|
|
var filePath = folderModel.get(i, "filePath")
|
|
var fileIsDir = folderModel.get(i, "fileIsDir")
|
|
var fileSize = folderModel.get(i, "fileSize")
|
|
|
|
// In folder selection mode, only show directories
|
|
if (root.selectFolders && !root.selectFiles && !fileIsDir) {
|
|
continue
|
|
}
|
|
|
|
// If no search text or file name contains search text
|
|
if (searchText === "" || fileName.toLowerCase().includes(searchText)) {
|
|
filteredModel.append({
|
|
"fileName": fileName,
|
|
"filePath": filePath,
|
|
"fileIsDir": fileIsDir,
|
|
"fileSize": fileSize
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
// Function to intelligently truncate filenames
|
|
function truncateFileName(fileName, maxLength) {
|
|
if (fileName.length <= maxLength) {
|
|
return fileName
|
|
}
|
|
|
|
// For files, try to preserve the extension
|
|
var lastDot = fileName.lastIndexOf('.')
|
|
if (lastDot > 0 && lastDot < fileName.length - 1) {
|
|
var name = fileName.substring(0, lastDot)
|
|
var ext = fileName.substring(lastDot)
|
|
var availableForName = maxLength - ext.length - 3 // 3 for "..."
|
|
|
|
if (availableForName > 0) {
|
|
return name.substring(0, availableForName) + "..." + ext
|
|
}
|
|
}
|
|
|
|
// Fallback: just truncate from the end
|
|
return fileName.substring(0, maxLength - 3) + "..."
|
|
}
|
|
|
|
// Popup properties
|
|
width: 900 * scaling
|
|
height: 700 * scaling
|
|
modal: true
|
|
closePolicy: Popup.CloseOnEscape
|
|
anchors.centerIn: Overlay.overlay
|
|
|
|
background: Rectangle {
|
|
color: Color.mSurfaceVariant
|
|
radius: Style.radiusL * scaling
|
|
border.color: Color.mOutline
|
|
border.width: Math.max(1, Style.borderS * scaling)
|
|
}
|
|
|
|
Rectangle {
|
|
id: filePickerPanel
|
|
anchors.fill: parent
|
|
anchors.margins: Style.marginL * scaling
|
|
color: Color.transparent
|
|
|
|
property string filterText: ""
|
|
property var currentSelection: []
|
|
property bool isNavigating: false
|
|
property bool viewMode: true // true = grid, false = list
|
|
property string searchText: ""
|
|
property bool isSearching: false
|
|
property bool showSearchBar: false
|
|
|
|
// Keyboard shortcuts
|
|
Keys.onPressed: event => {
|
|
if (event.modifiers & Qt.ControlModifier && event.key === Qt.Key_F) {
|
|
filePickerPanel.showSearchBar = !filePickerPanel.showSearchBar
|
|
if (filePickerPanel.showSearchBar) {
|
|
// Focus the search input when opening
|
|
Qt.callLater(() => {
|
|
searchInput.forceActiveFocus()
|
|
})
|
|
}
|
|
event.accepted = true
|
|
} else if (event.key === Qt.Key_Escape && filePickerPanel.showSearchBar) {
|
|
// Close search bar on Escape
|
|
filePickerPanel.showSearchBar = false
|
|
filePickerPanel.searchText = ""
|
|
filePickerPanel.isSearching = false
|
|
filePickerPanel.filterText = ""
|
|
root.updateFilteredModel()
|
|
event.accepted = true
|
|
}
|
|
}
|
|
|
|
// Focus the file manager to receive key events
|
|
focus: true
|
|
|
|
ColumnLayout {
|
|
anchors.fill: parent
|
|
spacing: Style.marginM * scaling
|
|
|
|
// Header row (like SettingsPanel)
|
|
RowLayout {
|
|
Layout.fillWidth: true
|
|
spacing: Style.marginM * scaling
|
|
|
|
// Main icon
|
|
NIcon {
|
|
icon: "folder"
|
|
color: Color.mPrimary
|
|
font.pointSize: Style.fontSizeXXL * scaling
|
|
}
|
|
|
|
// Main title
|
|
NText {
|
|
text: root.title
|
|
font.pointSize: Style.fontSizeXL * scaling
|
|
font.weight: Style.fontWeightBold
|
|
color: Color.mPrimary
|
|
Layout.fillWidth: true
|
|
Layout.alignment: Qt.AlignVCenter
|
|
}
|
|
|
|
// Action buttons
|
|
NIconButton {
|
|
icon: "refresh"
|
|
tooltipText: "Refresh"
|
|
Layout.alignment: Qt.AlignVCenter
|
|
onClicked: {
|
|
folderModel.refresh()
|
|
}
|
|
}
|
|
|
|
NIconButton {
|
|
icon: "close"
|
|
tooltipText: "Close"
|
|
Layout.alignment: Qt.AlignVCenter
|
|
onClicked: {
|
|
root.cancelled()
|
|
root.close()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Divider
|
|
NDivider {
|
|
Layout.fillWidth: true
|
|
}
|
|
|
|
// Navigation toolbar
|
|
Rectangle {
|
|
Layout.fillWidth: true
|
|
Layout.preferredHeight: 45 * scaling
|
|
color: Color.mSurfaceVariant
|
|
radius: Style.radiusS * scaling
|
|
border.color: Color.mOutline
|
|
border.width: Math.max(1, Style.borderS * scaling)
|
|
|
|
RowLayout {
|
|
anchors.left: parent.left
|
|
anchors.right: parent.right
|
|
anchors.verticalCenter: parent.verticalCenter
|
|
anchors.margins: Style.marginS * scaling
|
|
spacing: Style.marginS * scaling
|
|
|
|
// Navigation buttons
|
|
NIconButton {
|
|
icon: "arrow-left"
|
|
tooltipText: "Back"
|
|
baseSize: Style.baseWidgetSize * 0.8
|
|
enabled: folderModel.folder.toString() !== "file://" + root.initialPath
|
|
onClicked: {
|
|
var parentPath = folderModel.parentFolder.toString().replace("file://", "")
|
|
if (parentPath !== folderModel.folder.toString().replace("file://", "")) {
|
|
folderModel.folder = "file://" + parentPath
|
|
root.currentPath = parentPath
|
|
}
|
|
}
|
|
}
|
|
|
|
NIconButton {
|
|
icon: "arrow-up"
|
|
tooltipText: "Up"
|
|
baseSize: Style.baseWidgetSize * 0.8
|
|
enabled: folderModel.folder.toString() !== "file:///"
|
|
onClicked: {
|
|
var parentPath = folderModel.parentFolder.toString().replace("file://", "")
|
|
folderModel.folder = "file://" + parentPath
|
|
root.currentPath = parentPath
|
|
}
|
|
}
|
|
|
|
NIconButton {
|
|
icon: "home"
|
|
tooltipText: "Home"
|
|
baseSize: Style.baseWidgetSize * 0.8
|
|
onClicked: {
|
|
var homePath = Quickshell.env("HOME") || "/home"
|
|
folderModel.folder = "file://" + homePath
|
|
root.currentPath = homePath
|
|
}
|
|
}
|
|
|
|
// View mode toggle
|
|
NIconButton {
|
|
icon: filePickerPanel.viewMode ? "layout-grid" : "list"
|
|
tooltipText: filePickerPanel.viewMode ? "List View" : "Grid View"
|
|
baseSize: Style.baseWidgetSize * 0.8
|
|
onClicked: {
|
|
filePickerPanel.viewMode = !filePickerPanel.viewMode
|
|
}
|
|
}
|
|
|
|
// Search toggle
|
|
NIconButton {
|
|
icon: filePickerPanel.showSearchBar ? "x" : "search"
|
|
tooltipText: filePickerPanel.showSearchBar ? "Close Search" : "Search"
|
|
baseSize: Style.baseWidgetSize * 0.8
|
|
onClicked: {
|
|
filePickerPanel.showSearchBar = !filePickerPanel.showSearchBar
|
|
if (!filePickerPanel.showSearchBar) {
|
|
// Clear search when closing
|
|
filePickerPanel.searchText = ""
|
|
filePickerPanel.isSearching = false
|
|
filePickerPanel.filterText = ""
|
|
root.updateFilteredModel()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Location input
|
|
NTextInput {
|
|
id: locationInput
|
|
text: root.currentPath
|
|
placeholderText: "Enter path..."
|
|
Layout.fillWidth: true
|
|
|
|
onEditingFinished: {
|
|
var newPath = text.trim()
|
|
if (newPath !== "" && newPath !== root.currentPath) {
|
|
// Navigate to the path
|
|
folderModel.folder = "file://" + newPath
|
|
root.currentPath = newPath
|
|
} else {
|
|
// Reset to current path if invalid or same
|
|
text = root.currentPath
|
|
}
|
|
}
|
|
|
|
// Update text when currentPath changes from navigation (but not when user is typing)
|
|
Connections {
|
|
target: root
|
|
function onCurrentPathChanged() {
|
|
if (!locationInput.activeFocus) {
|
|
locationInput.text = root.currentPath
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Search bar (appears when search is toggled)
|
|
Rectangle {
|
|
Layout.fillWidth: true
|
|
Layout.preferredHeight: 45 * scaling
|
|
color: Color.mSurfaceVariant
|
|
radius: Style.radiusS * scaling
|
|
border.color: Color.mOutline
|
|
border.width: Math.max(1, Style.borderS * scaling)
|
|
visible: filePickerPanel.showSearchBar
|
|
|
|
RowLayout {
|
|
anchors.left: parent.left
|
|
anchors.right: parent.right
|
|
anchors.verticalCenter: parent.verticalCenter
|
|
anchors.margins: Style.marginS * scaling
|
|
spacing: Style.marginS * scaling
|
|
|
|
NIcon {
|
|
icon: "search"
|
|
color: Color.mOnSurfaceVariant
|
|
font.pointSize: Style.fontSizeS * scaling
|
|
}
|
|
|
|
NTextInput {
|
|
id: searchInput
|
|
placeholderText: "Search files and folders..."
|
|
Layout.fillWidth: true
|
|
text: filePickerPanel.searchText
|
|
|
|
onTextChanged: {
|
|
filePickerPanel.searchText = text
|
|
filePickerPanel.isSearching = text.length > 0
|
|
filePickerPanel.filterText = text
|
|
root.updateFilteredModel()
|
|
}
|
|
|
|
Keys.onEscapePressed: {
|
|
filePickerPanel.showSearchBar = false
|
|
filePickerPanel.searchText = ""
|
|
filePickerPanel.isSearching = false
|
|
filePickerPanel.filterText = ""
|
|
root.updateFilteredModel()
|
|
}
|
|
}
|
|
|
|
NIconButton {
|
|
icon: "x"
|
|
tooltipText: "Clear"
|
|
baseSize: Style.baseWidgetSize * 0.6
|
|
visible: filePickerPanel.searchText.length > 0
|
|
onClicked: {
|
|
searchInput.text = ""
|
|
filePickerPanel.searchText = ""
|
|
filePickerPanel.isSearching = false
|
|
filePickerPanel.filterText = ""
|
|
root.updateFilteredModel()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// File list area
|
|
Rectangle {
|
|
Layout.fillWidth: true
|
|
Layout.fillHeight: true
|
|
color: Color.mSurface
|
|
radius: Style.radiusM * scaling
|
|
border.color: Color.mOutline
|
|
border.width: Math.max(1, Style.borderS * scaling)
|
|
clip: true
|
|
|
|
FolderListModel {
|
|
id: folderModel
|
|
folder: "file://" + root.currentPath
|
|
nameFilters: root.nameFilters
|
|
showDirs: root.showDirs
|
|
showHidden: true
|
|
sortField: FolderListModel.Name
|
|
sortReversed: false
|
|
|
|
onFolderChanged: {
|
|
root.currentPath = folder.toString().replace("file://", "")
|
|
filePickerPanel.currentSelection = []
|
|
}
|
|
|
|
onStatusChanged: {
|
|
if (status === FolderListModel.Error) {
|
|
console.log("FolderListModel error for path:", root.currentPath)
|
|
// Fallback to home directory if there's an error
|
|
if (root.currentPath !== Quickshell.env("HOME")) {
|
|
folder = "file://" + Quickshell.env("HOME")
|
|
root.currentPath = Quickshell.env("HOME")
|
|
}
|
|
} else if (status === FolderListModel.Ready) {
|
|
root.updateFilteredModel()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Filtered model for search functionality
|
|
ListModel {
|
|
id: filteredModel
|
|
}
|
|
|
|
// Grid view
|
|
GridView {
|
|
id: gridView
|
|
anchors.fill: parent
|
|
anchors.margins: Style.marginM * scaling
|
|
model: filteredModel
|
|
visible: filePickerPanel.viewMode
|
|
clip: true
|
|
|
|
property int columns: Math.max(1, Math.floor(width / (120 * scaling)))
|
|
property int itemSize: Math.floor((width - leftMargin - rightMargin - (columns * Style.marginS * scaling)) / columns)
|
|
|
|
cellWidth: Math.floor((width - leftMargin - rightMargin) / columns)
|
|
cellHeight: Math.floor(itemSize * 0.8) + Style.marginXS * scaling + Style.fontSizeS * scaling + Style.marginM * scaling
|
|
|
|
leftMargin: Style.marginS * scaling
|
|
rightMargin: Style.marginS * scaling
|
|
topMargin: Style.marginS * scaling
|
|
bottomMargin: Style.marginS * scaling
|
|
|
|
ScrollBar.vertical: ScrollBar {
|
|
parent: gridView
|
|
x: gridView.mirrored ? 0 : gridView.width - width
|
|
y: 0
|
|
height: gridView.height
|
|
policy: ScrollBar.AsNeeded
|
|
|
|
contentItem: Rectangle {
|
|
implicitWidth: 6 * scaling
|
|
implicitHeight: 100
|
|
radius: Style.radiusM * scaling
|
|
color: parent.pressed ? Qt.alpha(Color.mTertiary, 0.8) : parent.hovered ? Qt.alpha(Color.mTertiary, 0.8) : Qt.alpha(Color.mTertiary, 0.8)
|
|
opacity: parent.policy === ScrollBar.AlwaysOn || parent.active ? 1.0 : 0.0
|
|
|
|
Behavior on opacity {
|
|
NumberAnimation {
|
|
duration: Style.animationFast
|
|
}
|
|
}
|
|
|
|
Behavior on color {
|
|
ColorAnimation {
|
|
duration: Style.animationFast
|
|
}
|
|
}
|
|
}
|
|
|
|
background: Rectangle {
|
|
implicitWidth: 6 * scaling
|
|
implicitHeight: 100
|
|
color: Color.transparent
|
|
opacity: parent.policy === ScrollBar.AlwaysOn || parent.active ? 0.3 : 0.0
|
|
radius: (Style.radiusM * scaling) / 2
|
|
|
|
Behavior on opacity {
|
|
NumberAnimation {
|
|
duration: Style.animationFast
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
delegate: Rectangle {
|
|
id: gridItem
|
|
width: gridView.itemSize
|
|
height: gridView.cellHeight
|
|
color: Color.transparent
|
|
radius: Style.radiusM * scaling
|
|
|
|
property string fileName: model.fileName
|
|
property string filePath: model.filePath
|
|
property bool isDirectory: model.fileIsDir
|
|
property bool isSelected: filePickerPanel.currentSelection.includes(filePath)
|
|
|
|
// Selection background (covers entire item)
|
|
Rectangle {
|
|
anchors.fill: parent
|
|
color: isSelected ? Qt.alpha(Color.mSecondary, 0.15) : Color.transparent
|
|
radius: parent.radius
|
|
border.color: isSelected ? Color.mSecondary : Color.mSurface
|
|
border.width: Math.max(1, Style.borderL * 1.5 * scaling)
|
|
|
|
Behavior on color {
|
|
ColorAnimation {
|
|
duration: Style.animationFast
|
|
}
|
|
}
|
|
}
|
|
|
|
// Hover overlay
|
|
Rectangle {
|
|
anchors.fill: parent
|
|
color: Qt.alpha(Color.mPrimary, 0.1)
|
|
opacity: (mouseArea.containsMouse && !isSelected) ? 1.0 : 0
|
|
radius: parent.radius
|
|
border.color: Qt.alpha(Color.mPrimary, 0.3)
|
|
border.width: Math.max(1, Style.borderS * scaling)
|
|
Behavior on opacity {
|
|
NumberAnimation {
|
|
duration: Style.animationFast
|
|
}
|
|
}
|
|
}
|
|
|
|
ColumnLayout {
|
|
anchors.fill: parent
|
|
anchors.margins: Style.marginS * scaling
|
|
spacing: Style.marginXS * scaling
|
|
|
|
Rectangle {
|
|
id: iconContainer
|
|
Layout.fillWidth: true
|
|
Layout.preferredHeight: Math.round(gridView.itemSize * 0.67)
|
|
color: Color.transparent
|
|
|
|
// Check if file is an image
|
|
property bool isImage: {
|
|
if (isDirectory)
|
|
return false
|
|
var ext = fileName.split('.').pop().toLowerCase()
|
|
return ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp', 'svg', 'ico'].includes(ext)
|
|
}
|
|
|
|
// Show thumbnail for images, icon for others
|
|
Image {
|
|
id: thumbnail
|
|
anchors.fill: parent
|
|
anchors.margins: Style.marginXS * scaling
|
|
source: iconContainer.isImage ? "file://" + filePath : ""
|
|
fillMode: Image.PreserveAspectFit
|
|
visible: iconContainer.isImage && status === Image.Ready
|
|
smooth: false // Disable smooth for faster rendering
|
|
cache: true
|
|
asynchronous: true // Load images asynchronously
|
|
sourceSize.width: 120 * scaling // Limit image size for faster loading
|
|
sourceSize.height: 120 * scaling
|
|
|
|
// Fallback to icon if image fails to load or takes too long
|
|
onStatusChanged: {
|
|
if (status === Image.Error) {
|
|
visible = false
|
|
}
|
|
}
|
|
|
|
// Show loading indicator while image loads
|
|
Rectangle {
|
|
anchors.fill: parent
|
|
color: Color.mSurfaceVariant
|
|
radius: Style.radiusS * scaling
|
|
visible: thumbnail.status === Image.Loading
|
|
|
|
NIcon {
|
|
icon: "photo"
|
|
font.pointSize: Style.fontSizeL * scaling
|
|
color: Color.mOnSurfaceVariant
|
|
anchors.centerIn: parent
|
|
}
|
|
}
|
|
}
|
|
|
|
NIcon {
|
|
icon: isDirectory ? "folder" : root.getFileIcon(fileName)
|
|
font.pointSize: Style.fontSizeXXL * scaling
|
|
color: isDirectory ? Color.mPrimary : Color.mOnSurfaceVariant
|
|
anchors.centerIn: parent
|
|
visible: !iconContainer.isImage || thumbnail.status !== Image.Ready
|
|
}
|
|
|
|
// Selection indicator (like WallpaperSelector)
|
|
Rectangle {
|
|
anchors.top: parent.top
|
|
anchors.right: parent.right
|
|
anchors.margins: Style.marginS * scaling
|
|
width: 24 * scaling
|
|
height: 24 * scaling
|
|
radius: width / 2
|
|
color: Color.mSecondary
|
|
border.color: Color.mOutline
|
|
border.width: Math.max(1, Style.borderS * scaling)
|
|
visible: isSelected
|
|
|
|
NIcon {
|
|
icon: "check"
|
|
font.pointSize: Style.fontSizeS * scaling
|
|
font.weight: Style.fontWeightBold
|
|
color: Color.mOnSecondary
|
|
anchors.centerIn: parent
|
|
}
|
|
}
|
|
}
|
|
|
|
NText {
|
|
text: fileName
|
|
color: isSelected ? Color.mPrimary : Color.mOnSurface
|
|
font.pointSize: Style.fontSizeS * scaling
|
|
font.weight: isSelected ? Style.fontWeightBold : Style.fontWeightRegular
|
|
Layout.fillWidth: true
|
|
horizontalAlignment: Text.AlignHCenter
|
|
wrapMode: Text.WordWrap
|
|
elide: Text.ElideRight
|
|
maximumLineCount: 2
|
|
}
|
|
}
|
|
|
|
MouseArea {
|
|
id: mouseArea
|
|
anchors.fill: parent
|
|
hoverEnabled: true
|
|
acceptedButtons: Qt.LeftButton | Qt.RightButton
|
|
|
|
onClicked: mouse => {
|
|
if (mouse.button === Qt.LeftButton) {
|
|
if (isDirectory) {
|
|
if (root.selectFolders && !root.selectFiles) {
|
|
filePickerPanel.currentSelection = [filePath]
|
|
} else {
|
|
folderModel.folder = "file://" + filePath
|
|
root.currentPath = filePath
|
|
}
|
|
} else {
|
|
if (root.selectFiles) {
|
|
filePickerPanel.currentSelection = [filePath]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
onDoubleClicked: mouse => {
|
|
if (mouse.button === Qt.LeftButton) {
|
|
if (isDirectory) {
|
|
if (root.selectFolders && !root.selectFiles) {
|
|
filePickerPanel.currentSelection = [filePath]
|
|
root.confirmSelection()
|
|
} else {
|
|
folderModel.folder = "file://" + filePath
|
|
root.currentPath = filePath
|
|
}
|
|
} else {
|
|
if (root.selectFiles) {
|
|
filePickerPanel.currentSelection = [filePath]
|
|
root.confirmSelection()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// List view
|
|
ListView {
|
|
id: listView
|
|
anchors.fill: parent
|
|
anchors.margins: Style.marginS * scaling
|
|
model: filteredModel
|
|
visible: !filePickerPanel.viewMode
|
|
clip: true
|
|
|
|
ScrollBar.vertical: ScrollBar {
|
|
parent: listView
|
|
x: listView.mirrored ? 0 : listView.width - width
|
|
y: 0
|
|
height: listView.height
|
|
policy: ScrollBar.AsNeeded
|
|
|
|
contentItem: Rectangle {
|
|
implicitWidth: 6 * scaling
|
|
implicitHeight: 100
|
|
radius: Style.radiusM * scaling
|
|
color: parent.pressed ? Qt.alpha(Color.mTertiary, 0.8) : parent.hovered ? Qt.alpha(Color.mTertiary, 0.8) : Qt.alpha(Color.mTertiary, 0.8)
|
|
opacity: parent.policy === ScrollBar.AlwaysOn || parent.active ? 1.0 : 0.0
|
|
|
|
Behavior on opacity {
|
|
NumberAnimation {
|
|
duration: Style.animationFast
|
|
}
|
|
}
|
|
|
|
Behavior on color {
|
|
ColorAnimation {
|
|
duration: Style.animationFast
|
|
}
|
|
}
|
|
}
|
|
|
|
background: Rectangle {
|
|
implicitWidth: 6 * scaling
|
|
implicitHeight: 100
|
|
color: Color.transparent
|
|
opacity: parent.policy === ScrollBar.AlwaysOn || parent.active ? 0.3 : 0.0
|
|
radius: (Style.radiusM * scaling) / 2
|
|
|
|
Behavior on opacity {
|
|
NumberAnimation {
|
|
duration: Style.animationFast
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
delegate: Rectangle {
|
|
id: listItem
|
|
width: listView.width
|
|
height: 40 * scaling
|
|
color: {
|
|
if (filePickerPanel.currentSelection.includes(filePath)) {
|
|
return Color.mSecondary
|
|
}
|
|
if (mouseArea.containsMouse) {
|
|
return Qt.alpha(Color.mOnSurface, 0.1)
|
|
}
|
|
return Color.transparent
|
|
}
|
|
radius: Style.radiusS * scaling
|
|
|
|
property string fileName: model.fileName
|
|
property string filePath: model.filePath
|
|
property bool isDirectory: model.fileIsDir
|
|
|
|
Behavior on color {
|
|
ColorAnimation {
|
|
duration: Style.animationFast
|
|
}
|
|
}
|
|
|
|
RowLayout {
|
|
anchors.fill: parent
|
|
anchors.leftMargin: Style.marginM * scaling
|
|
anchors.rightMargin: Style.marginM * scaling
|
|
spacing: Style.marginM * scaling
|
|
|
|
NIcon {
|
|
icon: isDirectory ? "folder" : root.getFileIcon(fileName)
|
|
font.pointSize: Style.fontSizeL * scaling
|
|
color: isDirectory ? (filePickerPanel.currentSelection.includes(filePath) ? Color.mOnSecondary : Color.mPrimary) : Color.mOnSurfaceVariant
|
|
}
|
|
|
|
NText {
|
|
text: fileName
|
|
color: filePickerPanel.currentSelection.includes(filePath) ? Color.mOnSecondary : Color.mOnSurface
|
|
font.pointSize: Style.fontSizeM * scaling
|
|
font.weight: filePickerPanel.currentSelection.includes(filePath) ? Style.fontWeightBold : Style.fontWeightRegular
|
|
Layout.fillWidth: true
|
|
elide: Text.ElideRight
|
|
}
|
|
|
|
NText {
|
|
text: isDirectory ? "" : root.formatFileSize(model.fileSize)
|
|
color: filePickerPanel.currentSelection.includes(filePath) ? Color.mOnSecondary : Color.mOnSurfaceVariant
|
|
font.pointSize: Style.fontSizeS * scaling
|
|
visible: !isDirectory
|
|
Layout.preferredWidth: implicitWidth
|
|
}
|
|
}
|
|
|
|
MouseArea {
|
|
id: mouseArea
|
|
anchors.fill: parent
|
|
hoverEnabled: true
|
|
acceptedButtons: Qt.LeftButton | Qt.RightButton
|
|
|
|
onClicked: mouse => {
|
|
if (mouse.button === Qt.LeftButton) {
|
|
if (isDirectory) {
|
|
if (root.selectFolders && !root.selectFiles) {
|
|
filePickerPanel.currentSelection = [filePath]
|
|
} else {
|
|
folderModel.folder = "file://" + filePath
|
|
root.currentPath = filePath
|
|
}
|
|
} else {
|
|
if (root.selectFiles) {
|
|
filePickerPanel.currentSelection = [filePath]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
onDoubleClicked: mouse => {
|
|
if (mouse.button === Qt.LeftButton) {
|
|
if (isDirectory) {
|
|
if (root.selectFolders && !root.selectFiles) {
|
|
filePickerPanel.currentSelection = [filePath]
|
|
root.confirmSelection()
|
|
} else {
|
|
folderModel.folder = "file://" + filePath
|
|
root.currentPath = filePath
|
|
}
|
|
} else {
|
|
if (root.selectFiles) {
|
|
filePickerPanel.currentSelection = [filePath]
|
|
root.confirmSelection()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Status and actions
|
|
RowLayout {
|
|
Layout.fillWidth: true
|
|
spacing: Style.marginM * scaling
|
|
|
|
// Status text
|
|
NText {
|
|
text: {
|
|
if (filePickerPanel.isSearching) {
|
|
return "Searching for: \"" + filePickerPanel.searchText + "\" (" + filteredModel.count + " matches)"
|
|
} else if (filePickerPanel.currentSelection.length > 0) {
|
|
return filePickerPanel.currentSelection.length + " item(s) selected"
|
|
} else {
|
|
return filteredModel.count + " items"
|
|
}
|
|
}
|
|
color: filePickerPanel.isSearching ? Color.mPrimary : Color.mOnSurfaceVariant
|
|
font.pointSize: Style.fontSizeS * scaling
|
|
Layout.fillWidth: true
|
|
}
|
|
|
|
// Action buttons
|
|
NButton {
|
|
text: "Cancel"
|
|
outlined: true
|
|
onClicked: {
|
|
root.cancelled()
|
|
root.close()
|
|
}
|
|
}
|
|
|
|
NButton {
|
|
text: {
|
|
if (root.selectFolders && !root.selectFiles) {
|
|
return "Select Folder"
|
|
} else if (root.selectFiles && !root.selectFolders) {
|
|
return "Select File"
|
|
} else {
|
|
return "Select"
|
|
}
|
|
}
|
|
icon: "check"
|
|
enabled: filePickerPanel.currentSelection.length > 0
|
|
onClicked: root.confirmSelection()
|
|
}
|
|
}
|
|
}
|
|
|
|
// Watch for selection reset flag
|
|
Connections {
|
|
target: root
|
|
function onShouldResetSelectionChanged() {
|
|
if (root.shouldResetSelection) {
|
|
filePickerPanel.currentSelection = []
|
|
root.shouldResetSelection = false
|
|
}
|
|
}
|
|
}
|
|
|
|
Component.onCompleted: {
|
|
// Ensure we have a valid path
|
|
if (!root.currentPath || root.currentPath === "") {
|
|
root.currentPath = root.initialPath
|
|
}
|
|
folderModel.folder = "file://" + root.currentPath
|
|
}
|
|
}
|
|
}
|