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

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

@@ -0,0 +1,99 @@
+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.course_viewer.tree_widget_data_item import (
+    AnyTreeDataItem,
+    TreeWidgetDataItem,
+)
+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 = TreeWidgetDataItem(
+            id=resource.id,
+            data=resource,
+            strings=[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 isinstance(item, AnyTreeDataItem):
+            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,56 @@
+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
+
+            # Init group_widget lazily to prevent creating pointless tree widgets
+            group_widget: MemoryTreeWidgetItem | None = None
+            items_in_group = set()
+
+            for item in group.content_items:
+                resource_widgets = []
+
+                for resource in item.resources:  # type: db.Resource
+                    if resource.id not in items_in_group:
+                        items_in_group.add(resource.id)
+
+                        if group_widget is None:
+                            group_widget = self._create_group_widget(
+                                group, sync_receipt
+                            )
+
+                        resource_widgets.append(
+                            self._create_resource_widget(resource, sync_receipt)
+                        )
+
+                if len(resource_widgets) > 0:
+                    group_widget.addChildren(resource_widgets)
+
+            if group_widget is not None:
+                widgets.append(group_widget)
+
+        return widgets

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

@@ -5,8 +5,9 @@ import qcanvas_backend.database.types as db
 from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
 from qtpy.QtWidgets import *
 
+from qcanvas import icons
 from qcanvas.ui.course_viewer.content_tree import ContentTree
-from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
+from qcanvas.ui.course_viewer.tree_widget_data_item import TreeWidgetDataItem
 
 _logger = logging.getLogger(__name__)
 
@@ -18,36 +19,35 @@ 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,
             min_width=300,
             indentation=20,
+            alternating_row_colours=True,
         )
 
-        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
-    ) -> Sequence[MemoryTreeWidgetItem]:
+    ) -> Sequence[TreeWidgetDataItem]:
         widgets = []
 
         for message in course.messages:  # type: db.CourseMessage
             message_widget = self._create_mail_widget(message, sync_receipt)
+            message_widget.setIcon(0, icons.tree_items.mail)
             widgets.append(message_widget)
 
         return widgets
 
     def _create_mail_widget(
         self, message: db.CourseMessage, sync_receipt: SyncReceipt
-    ) -> MemoryTreeWidgetItem:
-        message_widget = MemoryTreeWidgetItem(
+    ) -> TreeWidgetDataItem:
+        message_widget = TreeWidgetDataItem(
             id=message.id,
             data=message,
             strings=[message.name, message.sender_name],

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

@@ -1,11 +1,13 @@
 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
 from qtpy.QtCore import Qt
 
+from qcanvas import icons
 from qcanvas.ui.course_viewer.content_tree import ContentTree
+from qcanvas.ui.course_viewer.tree_widget_data_item import TreeWidgetDataItem
 from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
 
 _logger = logging.getLogger(__name__)
@@ -17,6 +19,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 +30,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,25 +42,21 @@ 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)
+        module_widget.setIcon(0, icons.tree_items.module)
 
         return module_widget
 
     def _create_page_widget(
         self, page: db.ModulePage, sync_receipt: SyncReceipt
-    ) -> MemoryTreeWidgetItem:
-        page_widget = MemoryTreeWidgetItem(id=page.id, data=page, strings=[page.name])
+    ) -> TreeWidgetDataItem:
+        page_widget = TreeWidgetDataItem(id=page.id, data=page, strings=[page.name])
         page_widget.setFlags(Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable)
+        page_widget.setIcon(0, icons.tree_items.page)
 
         if sync_receipt.was_updated(page):
             self.mark_as_unseen(page_widget)

qcanvas/ui/course_viewer/tabs/resource_rich_browser.py

@@ -1,3 +1,4 @@
+import html
 import logging
 from typing import Optional
 
@@ -6,12 +7,11 @@ from bs4 import BeautifulSoup, Tag
 from qasync import asyncSlot
 from qcanvas_backend.net.resources.download.resource_manager import ResourceManager
 from qcanvas_backend.net.resources.extracting.no_extractor_error import NoExtractorError
-from qcanvas_backend.net.resources.scanning.resource_scanner import ResourceScanner
+from qcanvas_backend.util import is_link_invisible
 from qtpy.QtCore import QUrl, Slot
 from qtpy.QtGui import QDesktopServices
 from qtpy.QtWidgets import QTextBrowser
 
-from qcanvas import icons
 from qcanvas.backend_connectors import FrontendResourceManager
 from qcanvas.util.html_cleaner import clean_up_html
 from qcanvas.util.qurl_util import file_url
@@ -19,22 +19,6 @@ from qcanvas.util.qurl_util import file_url
 _logger = logging.getLogger(__name__)
 
 
-# class _DarkListener(QObject):
-#     theme_changed = Signal(str)
-#
-#     def __init__(self):
-#         super().__init__()
-#
-#         self._thread = threading.Thread(target=darkdetect.listener, args=(self._emit,))
-#         self._thread.daemon = True
-#         self._thread.start()
-#
-#     def _emit(self, theme: str) -> None:
-#         self.theme_changed.emit(theme)
-#
-# _dark_listener = _DarkListener()
-
-
 class ResourceRichBrowser(QTextBrowser):
     def __init__(self, downloader: ResourceManager):
         super().__init__()
@@ -85,8 +69,7 @@ class ResourceRichBrowser(QTextBrowser):
                 extractor = self._extractors.extractor_for_tag(resource_link)
                 resource_id = extractor.resource_id_from_tag(resource_link)
 
-                # FIXME private method
-                if ResourceScanner._is_link_invisible(resource_link):
+                if is_link_invisible(resource_link):
                     _logger.debug("Found dead link for %s, removing", resource_id)
                     resource_link.decompose()
                     continue
@@ -97,7 +80,7 @@ class ResourceRichBrowser(QTextBrowser):
                     continue
 
                 file_link_tag = self._create_resource_link_tag(
-                    doc, resource_id, resource_link.name == "img"
+                    resource_id, resource_link.name == "img"
                 )
                 resource_link.replace_with(file_link_tag)
             except NoExtractorError:
@@ -105,9 +88,7 @@ class ResourceRichBrowser(QTextBrowser):
 
         return str(doc)
 
-    def _create_resource_link_tag(
-        self, doc: BeautifulSoup, resource_id: str, is_image: bool
-    ) -> Tag:
+    def _create_resource_link_tag(self, resource_id: str, is_image: bool) -> Tag:
         resource = self._current_content_resources[resource_id]
 
         # todo not sure if this is a good idea or not
@@ -121,40 +102,34 @@ class ResourceRichBrowser(QTextBrowser):
         #         },
         #     )
         # else:
-        file_link_tag = doc.new_tag(
-            "a",
-            attrs={
-                "href": f"data:{resource_id}",
-            },
-        )
-
-        file_link_tag.append(self._file_icon_tag(doc, resource.download_state))
-        file_link_tag.append("\N{NO-BREAK SPACE}" + resource.file_name)
-
-        _logger.debug(str(file_link_tag))
-
-        return file_link_tag
-
-    def _file_icon_tag(
-        self, document: BeautifulSoup, download_state: db.ResourceDownloadState
-    ) -> Tag:
-        return document.new_tag(
-            "img",
-            attrs={
-                "src": self._download_state_icon(download_state),
-                "style": "vertical-align:middle",
-                "width": 18,
-            },
-        )
+
+        return BeautifulSoup(
+            markup=f"""
+            <a href="data:{html.escape(resource_id)}" style="font-weight: normal">
+                <!--<table style="vertical-align: middle; border-collapse: collapse;">
+                    <tr>
+                        <td style="text-decoration: none;">-->
+                            <img height="16" src="{html.escape(self._download_state_icon(resource.download_state))}"/>
+                        <!--</td>
+                        <td>-->
+                            {html.escape(resource.file_name)}
+                        <!--</td>
+                    </tr>
+                </table>-->
+            </a>
+            """,
+            features="html.parser",
+        ).a
 
     def _download_state_icon(self, download_state: db.ResourceDownloadState) -> str:
+        icon_path = ":icons/universal/downloads"
         match download_state:
             case db.ResourceDownloadState.DOWNLOADED:
-                return icons.file_downloaded
+                return f"{icon_path}/downloaded.svg"
             case db.ResourceDownloadState.NOT_DOWNLOADED:
-                return icons.file_not_downloaded
+                return f"{icon_path}/not_downloaded.svg"
             case db.ResourceDownloadState.FAILED:
-                return icons.file_download_failed
+                return f"{icon_path}/download_failed.svg"
             case _:
                 raise ValueError()
 
@@ -183,4 +158,21 @@ class ResourceRichBrowser(QTextBrowser):
     @Slot(db.Resource)
     def _download_updated(self, resource: db.Resource) -> None:
         if self._content is not None and resource.id in self._current_content_resources:
+            # BANDAID FIX: In the following situation:
+            # - Download is started
+            # - Synchronisation is started
+            # - Download finishes AFTER the sync
+            # --> `resource` is NOT `self._current_content_resources[resource.id]`, because the sync will reload the
+            # resource from the DB, but the downloader will still only know about the old resource object.
+            # This causes resources not update their download state in the viewer. This line "fixes" that, but does NOT
+            # address the root cause. I think reloading the resource from the DB somewhere is the only true fix for this
+
+            if self._current_content_resources[resource.id] is not resource:
+                _logger.warning(
+                    "Resource has diverged from current loaded data, applying bandaid fix"
+                )
+                self._current_content_resources[resource.id].download_state = (
+                    resource.download_state
+                )
+
             self._show_page_content(self._content)

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/course_viewer/tree_widget_data_item.py

@@ -0,0 +1,22 @@
+from typing import List, Optional
+
+from qtpy.QtWidgets import QTreeWidgetItem
+
+from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
+
+
+class TreeWidgetDataItem(QTreeWidgetItem):
+    def __init__(
+        self, id: str, data: Optional[object], strings: Optional[List[str]] = None
+    ):
+        super().__init__(strings)
+        # Still needs ID because it is used to reselect the item
+        self._id = id
+        self.extra_data = data
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+
+AnyTreeDataItem = TreeWidgetDataItem | MemoryTreeWidgetItem

qcanvas/ui/main_ui/course_viewer_container.py

@@ -1,30 +1,68 @@
 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.QtWidgets import *
 
+from qcanvas import icons
 from qcanvas.ui.course_viewer.course_viewer import CourseViewer
+from qcanvas.util import themes
 
 _logger = logging.getLogger(__name__)
 
 
+class _PlaceholderLogo(QLabel):
+    """
+    Automatically resizing logo icon for when no course is selected
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._icon = icons.branding.logo_transparent
+        self._old_width = -1
+        self._old_height = -1
+        self.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Ignored)
+        # Because we are using a pixmap for the icon, it will not get updated like a normal QIcon when the theme changes,
+        # So we need to update it ourselves
+        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
+            self.setPixmap(self._icon.pixmap(width, height))
+
+
 class CourseViewerContainer(QStackedWidget):
     def __init__(self, downloader: ResourceManager):
         super().__init__()
         self._course_viewers: dict[str, CourseViewer] = {}
         self._downloader = downloader
         self._last_course_id: Optional[str] = None
+        self._selected_course: Optional[db.Course] = 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:
         self._last_course_id = None
+        self._selected_course = None
         self.setCurrentWidget(self._placeholder)
 
     def load_course(self, course: db.Course) -> None:
@@ -40,6 +78,7 @@ class CourseViewerContainer(QStackedWidget):
             viewer = self._course_viewers[course.id]
 
         self.setCurrentWidget(viewer)
+        self._selected_course = course
         self._last_course_id = course.id
 
     async def reload_all(
@@ -50,3 +89,7 @@ class CourseViewerContainer(QStackedWidget):
             if course.id in self._course_viewers:
                 viewer = self._course_viewers[course.id]
                 viewer.reload(course, sync_receipt=sync_receipt)
+
+    @property
+    def selected_course(self) -> Optional[db.Course]:
+        return self._selected_course

qcanvas/ui/main_ui/options/auto_download_resources_option.py

@@ -5,6 +5,7 @@ from qtpy.QtCore import Slot
 from qtpy.QtGui import QAction
 from qtpy.QtWidgets import QMenu
 
+from qcanvas import icons
 from qcanvas.util import settings
 
 _logger = logging.getLogger(__name__)
@@ -36,6 +37,7 @@ class _EnableVideoDownloadOption(QAction):
 
 class AutoDownloadResourcesMenu(QMenu):
     def __init__(self, parent: Optional[QMenu] = None):
-        super().__init__("Download new resources", parent)
+        super().__init__("Auto download resources", parent)
         self.addAction(_EnableAutoDownloadOption(self))
         self.addAction(_EnableVideoDownloadOption(self))
+        self.setIcon(icons.options.auto_download)

qcanvas/ui/main_ui/options/theme_selection_menu.py

@@ -4,6 +4,7 @@ from qtpy.QtCore import Slot
 from qtpy.QtGui import QAction, QActionGroup
 from qtpy.QtWidgets import QMenu
 
+from qcanvas import icons
 from qcanvas.util import settings, themes
 
 _logger = logging.getLogger(__name__)
@@ -38,6 +39,7 @@ class ThemeSelectionMenu(QMenu):
         actions = [auto_theme, light_theme, dark_theme, native_theme]
 
         self.addActions(actions)
+        self.setIcon(icons.options.theme)
 
         for theme in actions:
             action_group.addAction(theme)

qcanvas/ui/main_ui/qcanvas_window.py

@@ -9,7 +9,7 @@ from qcanvas_backend.database.data_monolith import DataMonolith
 from qcanvas_backend.net.sync.sync_receipt import SyncReceipt, empty_receipt
 from qcanvas_backend.qcanvas import QCanvas
 from qtpy.QtCore import QUrl, Signal, Slot
-from qtpy.QtGui import QDesktopServices, QIcon, QKeySequence
+from qtpy.QtGui import QDesktopServices, QKeySequence
 from qtpy.QtWidgets import *
 
 from qcanvas import icons
@@ -37,7 +37,7 @@ class QCanvasWindow(QMainWindow):
         super().__init__()
 
         self.setWindowTitle("QCanvas")
-        self.setWindowIcon(QIcon(icons.main_icon))
+        self.setWindowIcon(icons.branding.main_icon)
 
         self._operation_semaphore = BoundedSemaphore()
         self._data: Optional[DataMonolith] = None
@@ -74,6 +74,7 @@ class QCanvasWindow(QMainWindow):
             shortcut=QKeySequence("Ctrl+S"),
             triggered=self._synchronise_requested,
             parent=app_menu,
+            icon=icons.actions.sync,
         )
 
         create_qaction(
@@ -81,17 +82,22 @@ class QCanvasWindow(QMainWindow):
             shortcut=QKeySequence("Ctrl+D"),
             triggered=self._open_downloads_folder,
             parent=app_menu,
+            icon=icons.actions.open_downloads,
         )
 
         create_qaction(
-            name="Quick canvas login",
+            name="Open Canvas in browser",
             shortcut=QKeySequence("Ctrl+O"),
             triggered=self._open_quick_auth_in_browser,
             parent=app_menu,
+            icon=icons.actions.quick_login,
         )
 
         create_qaction(
-            name="Mark all as seen", triggered=self._clear_new_items, parent=app_menu
+            name="Mark all as seen",
+            triggered=self._clear_new_items,
+            parent=app_menu,
+            icon=icons.actions.mark_all_read,
         )
 
         create_qaction(
@@ -99,6 +105,7 @@ class QCanvasWindow(QMainWindow):
             shortcut=QKeySequence("Ctrl+Q"),
             triggered=lambda: self.close(),
             parent=app_menu,
+            icon=icons.actions.exit,
         )
 
         options_menu = menu_bar.addMenu("Options")
@@ -229,6 +236,12 @@ class QCanvasWindow(QMainWindow):
     @Slot()
     def _open_downloads_folder(self) -> None:
         directory = self._qcanvas.resource_manager.downloads_folder
+
+        if self._course_viewer_container.selected_course is not None:
+            directory /= self._qcanvas.resource_manager.course_folder_name(
+                self._course_viewer_container.selected_course
+            )
+
         directory.mkdir(parents=True, exist_ok=True)
 
         QDesktopServices.openUrl(file_url(directory))