`# ADB File Explorer
Copyright (C) 2
file_selection_action = QAction('Select Multiple Files', self)
file_selection_action.triggered.connect(self.select_multiple_files)
self.file_menu.addAction(file_selection_action)
022 Azat Aldeshov
import sys
from typing import Any
from PyQt5 import QtCore, QtGui
from PyQt5.QtCore import Qt, QPoint, QModelIndex, QAbstractListModel, QVariant, QRect, QSize, QEvent, QObject
from PyQt5.QtGui import QPixmap, QColor, QPalette, QMovie, QKeySequence
from PyQt5.QtWidgets import QMenu, QAction, QMessageBox, QFileDialog, QStyle, QWidget, QStyledItemDelegate,
QStyleOptionViewItem, QApplication, QListView, QVBoxLayout, QLabel, QSizePolicy, QHBoxLayout, QTextEdit,
QMainWindow
from app.core.configurations import Resources
from app.core.main import Adb
from app.core.managers import Global
from app.data.models import FileType, MessageData, MessageType
from app.data.repositories import FileRepository
from app.gui.explorer.toolbar import ParentButton, UploadTools, PathBar
from app.helpers.tools import AsyncRepositoryWorker, ProgressCallbackHelper, read_string_from_file
class FileHeaderWidget(QWidget):
def init(self, parent=None):
super(FileHeaderWidget, self).init(parent)
self.setLayout(QHBoxLayout(self))
policy = QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred)
self.file = QLabel('File', self)
self.file.setContentsMargins(45, 0, 0, 0)
policy.setHorizontalStretch(39)
self.file.setSizePolicy(policy)
self.layout().addWidget(self.file)
self.permissions = QLabel('Permissions', self)
self.permissions.setAlignment(Qt.AlignCenter)
policy.setHorizontalStretch(18)
self.permissions.setSizePolicy(policy)
self.layout().addWidget(self.permissions)
self.size = QLabel('Size', self)
self.size.setAlignment(Qt.AlignCenter)
policy.setHorizontalStretch(21)
self.size.setSizePolicy(policy)
self.layout().addWidget(self.size)
self.date = QLabel('Date', self)
self.date.setAlignment(Qt.AlignCenter)
policy.setHorizontalStretch(22)
self.date.setSizePolicy(policy)
self.layout().addWidget(self.date)
self.setStyleSheet("QWidget { background-color: #E5E5E5; font-weight: 500; border: 1px solid #C0C0C0 }")
class FileExplorerToolbar(QWidget):
def init(self, parent=None):
super(FileExplorerToolbar, self).init(parent)
self.setLayout(QHBoxLayout(self))
policy = QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred)
policy.setHorizontalStretch(1)
self.upload_tools = UploadTools(self)
self.upload_tools.setSizePolicy(policy)
self.layout().addWidget(self.upload_tools)
self.parent_button = ParentButton(self)
self.parent_button.setSizePolicy(policy)
self.layout().addWidget(self.parent_button)
self.path_bar = PathBar(self)
policy.setHorizontalStretch(8)
self.path_bar.setSizePolicy(policy)
self.layout().addWidget(self.path_bar)
class FileItemDelegate(QStyledItemDelegate):
def sizeHint(self, option: 'QStyleOptionViewItem', index: QtCore.QModelIndex) -> QtCore.QSize:
result = super(FileItemDelegate, self).sizeHint(option, index)
result.setHeight(40)
return result
def setEditorData(self, editor: QWidget, index: QtCore.QModelIndex):
editor.setText(index.model().data(index, Qt.EditRole))
def updateEditorGeometry(self, editor: QWidget, option: 'QStyleOptionViewItem', index: QtCore.QModelIndex):
editor.setGeometry(
option.rect.left() + 48, option.rect.top(), int(option.rect.width() / 2.5) - 55, option.rect.height()
)
def setModelData(self, editor: QWidget, model: QtCore.QAbstractItemModel, index: QtCore.QModelIndex):
model.setData(index, editor.text(), Qt.EditRole)
@staticmethod
def paint_line(painter: QtGui.QPainter, color: QColor, x, y, w, h):
painter.setPen(color)
painter.drawLine(x, y, w, h)
@staticmethod
def paint_text(painter: QtGui.QPainter, text: str, color: QColor, options, x, y, w, h):
painter.setPen(color)
painter.drawText(QRect(x, y, w, h), options, text)
def paint(self, painter: QtGui.QPainter, option: 'QStyleOptionViewItem', index: QtCore.QModelIndex):
if not index.data():
return super(FileItemDelegate, self).paint(painter, option, index)
self.initStyleOption(option, index)
style = option.widget.style() if option.widget else QApplication.style()
style.drawControl(QStyle.CE_ItemViewItem, option, painter, option.widget)
line_color = QColor("#CCCCCC")
text_color = option.palette.color(QPalette.Normal, QPalette.Text)
top = option.rect.top()
bottom = option.rect.height()
first_start = option.rect.left() + 50
second_start = option.rect.left() + int(option.rect.width() / 2.5)
third_start = option.rect.left() + int(option.rect.width() / 1.75)
fourth_start = option.rect.left() + int(option.rect.width() / 1.25)
end = option.rect.width() + option.rect.left()
self.paint_text(
painter, index.data().name, text_color, option.displayAlignment,
first_start, top, second_start - first_start - 4, bottom
)
self.paint_line(painter, line_color, second_start - 2, top, second_start - 1, bottom)
self.paint_text(
painter, index.data().permissions, text_color, Qt.AlignCenter | option.displayAlignment,
second_start, top, third_start - second_start - 4, bottom
)
self.paint_line(painter, line_color, third_start - 2, top, third_start - 1, bottom)
self.paint_text(
painter, index.data().size, text_color, Qt.AlignCenter | option.displayAlignment,
third_start, top, fourth_start - third_start - 4, bottom
)
self.paint_line(painter, line_color, fourth_start - 2, top, fourth_start - 1, bottom)
self.paint_text(
painter, index.data().date, text_color, Qt.AlignCenter | option.displayAlignment,
fourth_start, top, end - fourth_start, bottom
)
class FileListModel(QAbstractListModel):
def init(self, parent=None):
super().init(parent)
self.items = []
def clear(self):
self.beginResetModel()
self.items.clear()
self.endResetModel()
def populate(self, files: list):
self.beginResetModel()
self.items.clear()
self.items = files
self.endResetModel()
def rowCount(self, parent: QModelIndex = ...) -> int:
return len(self.items)
def icon_path(self, index: QModelIndex = ...):
file_type = self.items[index.row()].type
if file_type == FileType.DIRECTORY:
return Resources.icon_folder
elif file_type == FileType.FILE:
return Resources.icon_file
elif file_type == FileType.LINK:
link_type = self.items[index.row()].link_type
if link_type == FileType.DIRECTORY:
return Resources.icon_link_folder
elif link_type == FileType.FILE:
return Resources.icon_link_file
return Resources.icon_link_file_unknown
return Resources.icon_file_unknown
def flags(self, index: QModelIndex) -> Qt.ItemFlags:
if not index.isValid():
return Qt.NoItemFlags
return Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable
def setData(self, index: QModelIndex, value: Any, role: int = ...) -> bool:
if role == Qt.EditRole and value:
data, error = FileRepository.rename(self.items[index.row()], value)
if error:
Global().communicate.notification.emit(
MessageData(
timeout=10000,
title="Rename",
body="<span style='color: red; font-weight: 600'> %s </span>" % error,
)
)
Global.communicate.files__refresh.emit()
return super(FileListModel, self).setData(index, value, role)
def data(self, index: QModelIndex, role: int = ...) -> Any:
if not index.isValid():
return QVariant()
if role == Qt.DisplayRole:
return self.items[index.row()]
elif role == Qt.EditRole:
return self.items[index.row()].name
elif role == Qt.DecorationRole:
return QPixmap(self.icon_path(index)).scaled(32, 32, Qt.KeepAspectRatio)
return QVariant()
class FileExplorerWidget(QWidget):
FILES_WORKER_ID = 300
DOWNLOAD_WORKER_ID = 399
def __init__(self, parent=None):
super(FileExplorerWidget, self).__init__(parent)
self.main_layout = QVBoxLayout(self)
self.toolbar = FileExplorerToolbar(self)
self.main_layout.addWidget(self.toolbar)
self.header = FileHeaderWidget(self)
self.main_layout.addWidget(self.header)
self.list = QListView(self)
self.model = FileListModel(self.list)
self.list.setSpacing(1)
self.list.setModel(self.model)
self.list.installEventFilter(self)
self.list.doubleClicked.connect(self.open)
self.list.setItemDelegate(FileItemDelegate(self.list))
self.list.setContextMenuPolicy(Qt.CustomContextMenu)
self.list.customContextMenuRequested.connect(self.context_menu)
self.list.setStyleSheet(read_string_from_file(Resources.style_file_list))
self.list.setSelectionMode(QListView.SelectionMode.ExtendedSelection)
self.layout().addWidget(self.list)
self.loading = QLabel(self)
self.loading.setAlignment(Qt.AlignCenter)
self.loading_movie = QMovie(Resources.anim_loading, parent=self.loading)
self.loading_movie.setScaledSize(QSize(48, 48))
self.loading.setMovie(self.loading_movie)
self.main_layout.addWidget(self.loading)
self.empty_label = QLabel("Folder is empty", self)
self.empty_label.setAlignment(Qt.AlignCenter)
self.empty_label.setStyleSheet("color: #969696; border: 1px solid #969696")
self.layout().addWidget(self.empty_label)
self.main_layout.setStretch(self.layout().count() - 1, 1)
self.main_layout.setStretch(self.layout().count() - 2, 1)
self.text_view_window = None
self.setLayout(self.main_layout)
Global().communicate.files__refresh.connect(self.update)
@property
def file(self):
if self.list and self.list.currentIndex():
return self.model.items[self.list.currentIndex().row()]
@property
def files(self):
if self.list and len(self.list.selectedIndexes()) > 0:
return map(lambda index: self.model.items[index.row()], self.list.selectedIndexes())
def update(self):
super(FileExplorerWidget, self).update()
worker = AsyncRepositoryWorker(
name="Files",
worker_id=self.FILES_WORKER_ID,
repository_method=FileRepository.files,
response_callback=self._async_response,
arguments=()
)
if Adb.worker().work(worker):
# First Setup loading view
self.model.clear()
self.list.setHidden(True)
self.loading.setHidden(False)
self.empty_label.setHidden(True)
self.loading_movie.start()
# Then start async worker
worker.start()
Global().communicate.path_toolbar__refresh.emit()
def close(self) -> bool:
Global().communicate.files__refresh.disconnect()
return super(FileExplorerWidget, self).close()
def _async_response(self, files: list, error: str):
self.loading_movie.stop()
self.loading.setHidden(True)
if error:
print(error, file=sys.stderr)
if not files:
Global().communicate.notification.emit(
MessageData(
title='Files',
timeout=15000,
body="<span style='color: red; font-weight: 600'> %s </span>" % error
)
)
if not files:
self.empty_label.setHidden(False)
else:
self.list.setHidden(False)
self.model.populate(files)
self.list.setFocus()
def eventFilter(self, obj: 'QObject', event: 'QEvent') -> bool:
if obj == self.list and \
event.type() == QEvent.KeyPress and \
event.matches(QKeySequence.InsertParagraphSeparator) and \
not self.list.isPersistentEditorOpen(self.list.currentIndex()):
self.open(self.list.currentIndex())
return super(FileExplorerWidget, self).eventFilter(obj, event)
def open(self, index: QModelIndex = ...):
if Adb.manager().open(self.model.items[index.row()]):
Global().communicate.files__refresh.emit()
def context_menu(self, pos: QPoint):
menu = QMenu()
menu.addSection("Actions")
action_copy = QAction('Copy to...', self)
action_copy.setDisabled(True)
menu.addAction(action_copy)
action_move = QAction('Move to...', self)
action_move.setDisabled(True)
menu.addAction(action_move)
action_rename = QAction('Rename', self)
action_rename.triggered.connect(self.rename)
menu.addAction(action_rename)
action_open_file = QAction('Open', self)
action_open_file.triggered.connect(self.open_file)
menu.addAction(action_open_file)
action_delete = QAction('Delete', self)
action_delete.triggered.connect(self.delete)
menu.addAction(action_delete)
action_download = QAction('Download', self)
action_download.triggered.connect(self.download_files)
menu.addAction(action_download)
action_download_to = QAction('Download to...', self)
action_download_to.triggered.connect(self.download_to)
menu.addAction(action_download_to)
menu.addSeparator()
action_properties = QAction('Properties', self)
action_properties.triggered.connect(self.file_properties)
menu.addAction(action_properties)
menu.exec(self.mapToGlobal(pos))
@staticmethod
def default_response(data, error):
if error:
Global().communicate.notification.emit(
MessageData(
title='Download error',
timeout=15000,
body="<span style='color: red; font-weight: 600'> %s </span>" % error
)
)
if data:
Global().communicate.notification.emit(
MessageData(
title='Downloaded',
timeout=15000,
body=data
)
)
def rename(self):
self.list.edit(self.list.currentIndex())
def open_file(self):
# QDesktopServices.openUrl(QUrl.fromLocalFile("downloaded_path")) open via external app
if not self.file.isdir:
data, error = FileRepository.open_file(self.file)
if error:
Global().communicate.notification.emit(
MessageData(
title='File',
timeout=15000,
body="<span style='color: red; font-weight: 600'> %s </span>" % error
)
)
else:
self.text_view_window = TextView(self.file.name, data)
self.text_view_window.show()
def delete(self):
file_names = ', '.join(map(lambda f: f.name, self.files))
reply = QMessageBox.critical(
self,
'Delete',
"Do you want to delete '%s'? It cannot be undone!" % file_names,
QMessageBox.Yes | QMessageBox.No, QMessageBox.No
)
if reply == QMessageBox.Yes:
for file in self.files:
data, error = FileRepository.delete(file)
if data:
Global().communicate.notification.emit(
MessageData(
timeout=10000,
title="Delete",
body=data,
)
)
if error:
Global().communicate.notification.emit(
MessageData(
timeout=10000,
title="Delete",
body="<span style='color: red; font-weight: 600'> %s </span>" % error,
)
)
Global.communicate.files__refresh.emit()
def download_to(self):
dir_name = QFileDialog.getExistingDirectory(self, 'Download to', '~')
if dir_name:
self.download_files(dir_name)
def download_files(self, destination: str = None):
for file in self.files:
helper = ProgressCallbackHelper()
worker = AsyncRepositoryWorker(
worker_id=self.DOWNLOAD_WORKER_ID,
name="Download",
repository_method=FileRepository.download,
response_callback=self.default_response,
arguments=(
helper.progress_callback.emit, file.path, destination
)
)
if Adb.worker().work(worker):
Global().communicate.notification.emit(
MessageData(
title="Downloading to",
message_type=MessageType.LOADING_MESSAGE,
message_catcher=worker.set_loading_widget
)
)
helper.setup(worker, worker.update_loading_widget)
worker.start()
def file_properties(self):
file, error = FileRepository.file(self.file.path)
file = file if file else self.file
if error:
Global().communicate.notification.emit(
MessageData(
timeout=10000,
title="Opening folder",
body="<span style='color: red; font-weight: 600'> %s </span>" % error,
)
)
info = "<br/><u><b>%s</b></u><br/>" % str(file)
info += "<pre>Name: %s</pre>" % file.name or '-'
info += "<pre>Owner: %s</pre>" % file.owner or '-'
info += "<pre>Group: %s</pre>" % file.group or '-'
info += "<pre>Size: %s</pre>" % file.raw_size or '-'
info += "<pre>Permissions: %s</pre>" % file.permissions or '-'
info += "<pre>Date: %s</pre>" % file.raw_date or '-'
info += "<pre>Type: %s</pre>" % file.type or '-'
if file.type == FileType.LINK:
info += "<pre>Links to: %s</pre>" % file.link or '-'
properties = QMessageBox(self)
properties.setStyleSheet("background-color: #DDDDDD")
properties.setIconPixmap(
QPixmap(self.model.icon_path(self.list.currentIndex())).scaled(128, 128, Qt.KeepAspectRatio)
)
properties.setWindowTitle('Properties')
properties.setInformativeText(info)
properties.exec_()
class TextView(QMainWindow):
def init(self, filename, data):
QMainWindow.init(self)
self.setMinimumSize(QSize(500, 300))
self.setWindowTitle(filename)
self.text_edit = QTextEdit(self)
self.setCentralWidget(self.text_edit)
self.text_edit.insertPlainText(data)
self.text_edit.move(10, 10)
def select_multiple_files(self):
file_names, _ = QFileDialog.getOpenFileNames(self, 'Select Files')
if file_names:
self.handle_selected_files(file_names)
def handle_selected_files(self, file_names: list):
# Implement your logic here
# For now, let's just print the selected files
print("Selected files:", file_names)
`
modified_files.zip
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent