qcanvas 1.1.0__py3-none-any.whl → 1.2.0a1__py3-none-any.whl

qcanvas/ui/course_viewer/content_tree.py

@@ -61,6 +61,19 @@ class ContentTree(MemoryTreeWidget, Generic[T]):
         if min_width is not None:
             self.setMinimumWidth(min_width)
 
+    def set_columns_resize_mode(
+        self,
+        resize_mode_for_columns: list[QHeaderView.ResizeMode],
+        *,
+        stretch_last: bool = False,
+    ) -> None:
+        header = self.header()
+
+        for index, mode in enumerate(resize_mode_for_columns):
+            header.setSectionResizeMode(index, mode)
+
+        header.setStretchLastSection(stretch_last)
+
     def reload(self, data: T, *, sync_receipt: SyncReceipt) -> None:
         self._reloading = True
 

qcanvas/ui/course_viewer/course_viewer.py

@@ -7,6 +7,7 @@ from qtpy.QtCore import Slot
 from qtpy.QtWidgets import *
 
 from qcanvas.ui.course_viewer.tabs.assignment_tab import AssignmentTab
+from qcanvas.ui.course_viewer.tabs.file_tab import FileTab
 from qcanvas.ui.course_viewer.tabs.mail_tab import MailTab
 from qcanvas.ui.course_viewer.tabs.page_tab import PageTab
 from qcanvas.util.basic_fonts import bold_font
@@ -47,12 +48,17 @@ class CourseViewer(QWidget):
             downloader=downloader,
             sync_receipt=sync_receipt,
         )
+        self._files_tab = FileTab.create_from_receipt(
+            course=course,
+            downloader=downloader,
+            sync_receipt=sync_receipt,
+        )
 
         self._tabs = QTabWidget()
+        self._tabs.addTab(self._files_tab, "Files")
         self._tabs.addTab(self._pages_tab, "Pages")
         self._tabs.addTab(self._assignments_tab, "Assignments")
         self._tabs.addTab(self._mail_tab, "Mail")
-        self._tabs.addTab(QLabel("Not implemented"), "Files")
         # self._tabs.addTab(QLabel("Not implemented"), "Panopto")  # The meme lives on!
 
         self.setLayout(layout(QVBoxLayout, self._course_label, self._tabs))
@@ -63,10 +69,10 @@ class CourseViewer(QWidget):
         self._unhighlight_tab(0)  # Because the first tab always gets auto-selected
 
     def reload(self, course: db.Course, *, sync_receipt: SyncReceipt) -> None:
+        self._files_tab.reload(course, sync_receipt=sync_receipt)
         self._pages_tab.reload(course, sync_receipt=sync_receipt)
         self._assignments_tab.reload(course, sync_receipt=sync_receipt)
         self._mail_tab.reload(course, sync_receipt=sync_receipt)
-
         self._highlight_tabs(sync_receipt)
 
     @Slot(int)
@@ -78,14 +84,17 @@ class CourseViewer(QWidget):
         updates = sync_receipt.updates_by_course.get(self._course_id, None)
 
         if updates is not None:
-            if len(updates.updated_pages) > 0:
+            if len(updates.updated_resources) > 0:
                 self._highlight_tab(0)
 
-            if len(updates.updated_assignments) > 0:
+            if len(updates.updated_pages) > 0:
                 self._highlight_tab(1)
 
-            if len(updates.updated_messages) > 0:
+            if len(updates.updated_assignments) > 0:
                 self._highlight_tab(2)
+
+            if len(updates.updated_messages) > 0:
+                self._highlight_tab(3)
         else:
             for index in range(0, 4):
                 self._unhighlight_tab(index)

qcanvas/ui/course_viewer/tabs/assignment_tab/assignment_tree.py

@@ -18,6 +18,7 @@ class AssignmentTree(ContentTree[db.Course]):
             tree_name=f"course.{course_id}.assignment_groups",
             emit_selection_signal_for_type=db.Assignment,
         )
+
         self.ui_setup(
             header_text=["Assignments", "Weight"],
             indentation=15,
@@ -25,13 +26,9 @@ class AssignmentTree(ContentTree[db.Course]):
             min_width=150,
         )
 
-        self._adjust_header()
-
-    def _adjust_header(self) -> None:
-        header = self.header()
-        header.setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
-        header.setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
-        header.setStretchLastSection(False)
+        self.set_columns_resize_mode(
+            [QHeaderView.ResizeMode.Stretch, QHeaderView.ResizeMode.ResizeToContents]
+        )
 
     def create_tree_items(
         self, course: db.Course, sync_receipt: SyncReceipt
@@ -39,8 +36,11 @@ class AssignmentTree(ContentTree[db.Course]):
         widgets = []
 
         for assignment_group in course.assignment_groups:  # type: db.AssignmentGroup
+            if len(assignment_group.assignments) == 0:
+                continue
+
             assignment_group_widget = self._create_assignment_group_widget(
-                assignment_group, sync_receipt
+                assignment_group
             )
 
             widgets.append(assignment_group_widget)
@@ -54,7 +54,7 @@ class AssignmentTree(ContentTree[db.Course]):
         return widgets
 
     def _create_assignment_group_widget(
-        self, assignment_group: db.AssignmentGroup, sync_receipt: SyncReceipt
+        self, assignment_group: db.AssignmentGroup
     ) -> MemoryTreeWidgetItem:
         assignment_group_widget = MemoryTreeWidgetItem(
             id=assignment_group.id,
@@ -64,9 +64,6 @@ class AssignmentTree(ContentTree[db.Course]):
 
         assignment_group_widget.setFlags(Qt.ItemFlag.ItemIsEnabled)
 
-        if sync_receipt.was_updated(assignment_group):
-            self.mark_as_unseen(assignment_group_widget)
-
         return assignment_group_widget
 
     def _create_assignment_widget(

qcanvas/ui/course_viewer/tabs/file_tab/__init__.py

@@ -0,0 +1 @@
+from .file_tab import FileTab

qcanvas/ui/course_viewer/tabs/file_tab/file_tab.py

@@ -0,0 +1,46 @@
+import logging
+
+import qcanvas_backend.database.types as db
+from qcanvas_backend.net.resources.download.resource_manager import ResourceManager
+from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
+from qtpy.QtWidgets import *
+
+from qcanvas.ui.course_viewer.tabs.file_tab.pages_file_tree import PagesFileTree
+from qcanvas.util.layouts import layout
+
+_logger = logging.getLogger(__name__)
+
+
+class FileTab(QWidget):
+    @staticmethod
+    def create_from_receipt(
+        *,
+        course: db.Course,
+        sync_receipt: SyncReceipt,
+        downloader: ResourceManager,
+    ) -> "FileTab":
+        return FileTab(course=course, sync_receipt=sync_receipt, downloader=downloader)
+
+    def __init__(
+        self,
+        course: db.Course,
+        downloader: ResourceManager,
+        *,
+        sync_receipt: SyncReceipt = None,
+    ):
+        super().__init__()
+
+        self._page_file_tree = PagesFileTree.create_from_receipt(
+            course, sync_receipt=sync_receipt, resource_manager=downloader
+        )
+        # self._assignment_file_tree = FileTree.create_from_receipt(
+        #     course,
+        #     sync_receipt=sync_receipt,
+        #     mode="assignments",
+        #     resource_manager=downloader,
+        # )
+
+        self.setLayout(layout(QHBoxLayout, self._page_file_tree))
+
+    def reload(self, course: db.Course, *, sync_receipt: SyncReceipt) -> None:
+        pass

qcanvas/ui/course_viewer/tabs/file_tab/file_tree.py

@@ -0,0 +1,95 @@
+import logging
+from typing import *
+
+import qcanvas_backend.database.types as db
+from qcanvas_backend.net.resources.download.resource_manager import ResourceManager
+from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
+from qtpy.QtCore import QPoint, Qt, Slot
+from qtpy.QtWidgets import *
+
+from qcanvas.ui.course_viewer.content_tree import ContentTree
+from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
+from qcanvas.util.file_icons import icon_for_filename
+from qcanvas.util.ui_tools import create_qaction
+
+_logger = logging.getLogger(__name__)
+
+
+T = TypeVar("T")
+
+
+class FileTree(ContentTree[db.Course]):
+    @classmethod
+    def create_from_receipt(
+        cls,
+        course: db.Course,
+        *,
+        sync_receipt: SyncReceipt,
+        resource_manager: ResourceManager,
+    ) -> "FileTree":
+        tree = cls(tree_name=course.id, resource_manager=resource_manager)
+        tree.reload(course, sync_receipt=sync_receipt)
+        return tree
+
+    def __init__(self, tree_name: str, *, resource_manager: ResourceManager):
+        super().__init__(tree_name, emit_selection_signal_for_type=object)
+        self._resource_manager = resource_manager
+
+        self.ui_setup(header_text=["File", "Date"])
+        self.set_columns_resize_mode(
+            [QHeaderView.ResizeMode.Stretch, QHeaderView.ResizeMode.ResizeToContents]
+        )
+
+        self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.customContextMenuRequested.connect(self._context_menu)
+
+    def _create_group_widget(
+        self, group: db.ContentGroup, sync_receipt: SyncReceipt
+    ) -> MemoryTreeWidgetItem:
+        group_widget = MemoryTreeWidgetItem(
+            id=group.id, data=group, strings=[group.name]
+        )
+
+        group_widget.setFlags(Qt.ItemFlag.ItemIsEnabled)
+
+        if sync_receipt.was_updated(group):
+            self.mark_as_unseen(group_widget)
+
+        return group_widget
+
+    def _create_resource_widget(
+        self, resource: db.Resource, sync_receipt: SyncReceipt
+    ) -> QTreeWidgetItem:
+        # fixme the reesource widget items shouls NOT be a memory widget item because they can't be collapsed, but
+        #  mostly because the same file can appear in the tree multiple times in different places, which memory tree
+        #  can NOT deal with!
+        item_widget = QTreeWidgetItem(
+            [resource.file_name, str(resource.discovery_date.date())],
+        )
+        item_widget.setIcon(
+            0,
+            icon_for_filename(resource.file_name),
+        )
+        item_widget.setFlags(Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable)
+
+        if sync_receipt.was_updated(resource):
+            self.mark_as_unseen(item_widget)
+
+        return item_widget
+
+    @Slot(QPoint)
+    def _context_menu(self, point: QPoint) -> None:
+        item = self.itemAt(point)
+
+        if item is None or not isinstance(item, MemoryTreeWidgetItem):
+            return
+
+        menu = QMenu()
+        create_qaction(
+            name="Test",
+            parent=menu,
+            triggered=lambda: print(f"Clicked {item.extra_data.file_name}"),
+        )
+        menu.addAction("Another thing")
+
+        menu.exec(self.mapToGlobal(point))

qcanvas/ui/course_viewer/tabs/file_tab/pages_file_tree.py

@@ -0,0 +1,50 @@
+import logging
+from typing import *
+
+import qcanvas_backend.database.types as db
+from qcanvas_backend.net.resources.download.resource_manager import ResourceManager
+from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
+
+from qcanvas.ui.course_viewer.tabs.file_tab.file_tree import FileTree
+from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
+
+_logger = logging.getLogger(__name__)
+
+
+class PagesFileTree(FileTree):
+
+    def __init__(self, tree_name: str, *, resource_manager: ResourceManager):
+        super().__init__(
+            tree_name=f"{tree_name}.pages", resource_manager=resource_manager
+        )
+
+    def create_tree_items(
+        self, data: db.Course, sync_receipt: SyncReceipt
+    ) -> Sequence[MemoryTreeWidgetItem]:
+        widgets = []
+
+        for group in data.modules:  # type: db.Module
+            if len(group.content_items) == 0:
+                continue
+
+            group_widget = self._create_group_widget(group, sync_receipt)
+            items_in_group = set()
+
+            for item in group.content_items:
+                for resource in item.resources:  # type: db.Resource
+
+                    if resource.id not in items_in_group:
+                        items_in_group.add(resource.id)
+                    else:
+                        continue
+
+                    resource_widget = self._create_resource_widget(
+                        resource, sync_receipt
+                    )
+
+                    group_widget.addChild(resource_widget)
+
+            if group_widget.childCount() > 0:
+                widgets.append(group_widget)
+
+        return widgets

qcanvas/ui/course_viewer/tabs/mail_tab/mail_tree.py

@@ -18,6 +18,7 @@ class MailTree(ContentTree[db.Course]):
             tree_name=f"course.{course_id}.mail",
             emit_selection_signal_for_type=db.CourseMessage,
         )
+
         self.ui_setup(
             header_text=["Subject", "Sender"],
             max_width=500,
@@ -25,13 +26,9 @@ class MailTree(ContentTree[db.Course]):
             indentation=20,
         )
 
-        self._adjust_header()
-
-    def _adjust_header(self) -> None:
-        header = self.header()
-        header.setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
-        header.setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
-        header.setStretchLastSection(False)
+        self.set_columns_resize_mode(
+            [QHeaderView.ResizeMode.Stretch, QHeaderView.ResizeMode.ResizeToContents]
+        )
 
     def create_tree_items(
         self, course: db.Course, sync_receipt: SyncReceipt

qcanvas/ui/course_viewer/tabs/page_tab/page_tree.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Optional, Sequence
+from typing import Sequence
 
 import qcanvas_backend.database.types as db
 from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
@@ -17,6 +17,7 @@ class PageTree(ContentTree[db.Course]):
             tree_name=f"course.{course_id}.modules",
             emit_selection_signal_for_type=db.ModulePage,
         )
+
         self.ui_setup(
             header_text="Content", indentation=15, max_width=300, min_width=150
         )
@@ -27,7 +28,10 @@ class PageTree(ContentTree[db.Course]):
         widgets = []
 
         for module in course.modules:  # type: db.Module
-            module_widget = self._create_module_widget(module, sync_receipt)
+            if len(module.pages) == 0:
+                continue
+
+            module_widget = self._create_module_widget(module)
             widgets.append(module_widget)
 
             for page in module.pages:  # type: db.ModulePage
@@ -36,18 +40,12 @@ class PageTree(ContentTree[db.Course]):
 
         return widgets
 
-    def _create_module_widget(
-        self, module: db.Module, sync_receipt: SyncReceipt
-    ) -> MemoryTreeWidgetItem:
+    def _create_module_widget(self, module: db.Module) -> MemoryTreeWidgetItem:
         module_widget = MemoryTreeWidgetItem(
             id=module.id, data=module, strings=[module.name]
         )
         module_widget.setFlags(Qt.ItemFlag.ItemIsEnabled)
 
-        # Todo not sure if modules should get highlighted since they can't be unhighlighted by selecting them...
-        if sync_receipt.was_updated(module):
-            self.mark_as_unseen(module_widget)
-
         return module_widget
 
     def _create_page_widget(

qcanvas/ui/course_viewer/tabs/util.py

@@ -1 +1,11 @@
+from typing import Protocol
+
+import qcanvas_backend.database.types as db
+from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
+
 date_strftime_format = "%A, %Y-%m-%d, %H:%M:%S"
+
+
+# todo what the hell is the point of this?
+class SupportsReload(Protocol):
+    def reload(self, course: db.Course, *, sync_receipt: SyncReceipt) -> None: ...

qcanvas/ui/main_ui/course_viewer_container.py

@@ -1,17 +1,60 @@
 import logging
+from math import floor
 from typing import *
 
 import qcanvas_backend.database.types as db
 from qcanvas_backend.net.resources.download.resource_manager import ResourceManager
 from qcanvas_backend.net.sync.sync_receipt import SyncReceipt, empty_receipt
-from qtpy.QtCore import Qt
+from qtpy.QtCore import Qt, Slot
+from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import *
 
+from qcanvas import icons
 from qcanvas.ui.course_viewer.course_viewer import CourseViewer
+from qcanvas.util import themes
 
 _logger = logging.getLogger(__name__)
 
 
+# todo needs to handle dark mode
+class _PlaceholderLogo(QLabel):
+    """
+    Automatically resizing logo icon for when no course is selected
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._light_icon = QIcon(icons.logo_transparent_light)
+        self._dark_icon = QIcon(icons.logo_transparent_dark)
+        self._old_width = -1
+        self._old_height = -1
+        self.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Ignored)
+        themes.theme_changed().connect(self._theme_changed)
+
+    def resizeEvent(self, event) -> None:
+        self._update_image()
+
+    @Slot()
+    def _theme_changed(self) -> None:
+        self._update_image(force=True)
+
+    def _update_image(self, force: bool = False) -> None:
+        # Calculate the size of the logo as half of the width/height with a max size of 1000x1000
+        width = min(floor(self.width() * 0.5), 500)
+        height = min(floor(self.height() * 0.5), 500)
+
+        if force or (width != self._old_width and height != self._old_height):
+            self._old_width = width
+            self._old_height = height
+        else:
+            return
+
+        icon = self._dark_icon if themes.is_dark_mode() else self._light_icon
+
+        self.setPixmap(icon.pixmap(width, height))
+
+
 class CourseViewerContainer(QStackedWidget):
     def __init__(self, downloader: ResourceManager):
         super().__init__()
@@ -19,8 +62,7 @@ class CourseViewerContainer(QStackedWidget):
         self._downloader = downloader
         self._last_course_id: Optional[str] = None
         self._last_sync_receipt: SyncReceipt = empty_receipt()
-        self._placeholder = QLabel("No Course Selected")
-        self._placeholder.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self._placeholder = _PlaceholderLogo()
         self.addWidget(self._placeholder)
 
     def show_blank(self) -> None:

qcanvas/ui/main_ui/status_bar_progress_display.py

@@ -77,10 +77,13 @@ class StatusBarProgressDisplay(QStatusBar):
         async with self._lock:
             if self._has_no_tasks:
                 self._show_done()
-            elif self._has_single_task:
-                self._show_single_task_progress(list(self._tasks.items())[0])
             else:
-                self._show_multiple_tasks_progress(list(self._tasks.values()))
+                tasks = list(self._tasks.items())
+
+                if self._has_single_task:
+                    self._show_single_task_progress(tasks[0])
+                else:
+                    self._show_multiple_tasks_progress(tasks)
 
     def _show_done(self) -> None:
         _logger.info("Finished tasks. Tasks: %s", self._tasks)
@@ -94,18 +97,24 @@ class StatusBarProgressDisplay(QStatusBar):
         self._show_progress(progress)
         self.showMessage(id.step_name)
 
-    def _show_multiple_tasks_progress(self, tasks: list[_TaskProgress]) -> None:
+    def _show_multiple_tasks_progress(
+        self, tasks: list[Tuple[TaskID, _TaskProgress]]
+    ) -> None:
         _logger.debug("Multiple tasks %s", tasks)
-        self.showMessage(f"{len(tasks)} tasks in progress")
+        self.showMessage(
+            f"{len(tasks)} tasks in progress - {', '.join([task[0].step_name for task in tasks])}"
+        )
         self._show_progress(self._calculate_progress(tasks))
 
-    def _calculate_progress(self, tasks: list[_TaskProgress]) -> _TaskProgress:
-        # Used to represent 0..1 progress as 0..multiplier
+    def _calculate_progress(
+        self, tasks: list[Tuple[TaskID, _TaskProgress]]
+    ) -> _TaskProgress:
+        # Task progresses are floats from 0 to 1, multiplier is used to turn them into ints
         multiplier = 1000
         current_sum = 0
         total_sum = 0
 
-        for task in tasks:
+        for _, task in tasks:
             if task.total != 0:
                 current_sum += (task.current / task.total) * multiplier
 

qcanvas/util/file_icons.py

@@ -0,0 +1,36 @@
+import logging
+
+from qtpy.QtCore import QFileInfo, QMimeDatabase
+from qtpy.QtGui import QIcon
+from qtpy.QtWidgets import QApplication, QFileIconProvider, QStyle
+
+import qcanvas.util.runtime as runtime
+
+_logger = logging.getLogger(__name__)
+
+# Windows and linux have different ways of doing this
+if runtime.is_running_on_windows:
+    _icon_provider = QFileIconProvider()
+
+    def icon_for_filename(file_name: str) -> QIcon:
+        return _icon_provider.icon(QFileInfo(file_name))
+
+else:
+    _mime_database = QMimeDatabase()
+    _default_icon = None
+
+    def icon_for_filename(file_name: str) -> QIcon:
+        global _default_icon
+
+        for mime_type in _mime_database.mimeTypesForFileName(file_name):
+            icon = QIcon.fromTheme(mime_type.iconName())
+
+            if not icon.isNull():
+                return icon
+
+        if _default_icon is None:
+            _default_icon = QApplication.style().standardIcon(
+                QStyle.StandardPixmap.SP_FileIcon
+            )
+
+        return _default_icon

qcanvas/util/themes/__init__.py

@@ -0,0 +1,2 @@
+from ._theme_changed_event import theme_changed
+from ._theme_changer import apply, default_theme, ensure_theme_is_valid, is_dark_mode

qcanvas/util/themes/_colour_scheme_helper.py

@@ -0,0 +1,38 @@
+import logging
+
+from qtpy.QtCore import QObject, Signal, Slot
+from qtpy.QtGui import QGuiApplication, Qt
+
+_logger = logging.getLogger(__name__)
+
+
+def colour_scheme() -> Qt.ColorScheme:
+    return QGuiApplication.styleHints().colorScheme()
+
+
+def is_dark_colour_scheme() -> bool:
+    return colour_scheme() == Qt.ColorScheme.Dark
+
+
+class ColourSchemeChangeEvent(QObject):
+    theme_changed = Signal()
+
+    def __init__(self):
+        super().__init__(None)
+        self._last_theme = colour_scheme()
+        QGuiApplication.styleHints().colorSchemeChanged.connect(self._theme_changed)
+
+    @Slot(Qt.ColorScheme)
+    def _theme_changed(self, colour_scheme: Qt.ColorScheme) -> None:
+        # Ensure the signal isn't fired when there wasn't actually a change
+        if colour_scheme != self._last_theme:
+            self._last_theme = colour_scheme
+            self.theme_changed.emit()
+
+
+_theme_changed_listener = ColourSchemeChangeEvent()
+
+
+def colour_scheme_changed() -> Signal:
+    global _theme_changed_listener
+    return _theme_changed_listener.theme_changed

qcanvas/util/themes/_selected_theme.py

@@ -0,0 +1,10 @@
+import logging
+from enum import Enum
+
+_logger = logging.getLogger(__name__)
+
+
+class SelectedTheme(Enum):
+    AUTO = 0
+    NATIVE = 1
+    OVERRIDE = 2

qcanvas/util/themes/_theme_changed_event.py

@@ -0,0 +1,17 @@
+import logging
+
+from qtpy.QtCore import QObject, Signal
+
+_logger = logging.getLogger(__name__)
+
+
+class ThemeChangedEvent(QObject):
+    theme_changed = Signal()
+
+
+theme_changed_event = ThemeChangedEvent(None)
+
+
+def theme_changed() -> Signal:
+    global theme_changed_event
+    return theme_changed_event.theme_changed