edof 4.2.2__tar.gz → 4.2.4__tar.gz

{edof-4.2.2 → edof-4.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edof
-Version: 4.2.2
+Version: 4.2.4
 Summary: Easy Document Format – programmatic document creation, editing and export with vector PDF, rich text, tables and PDF import
 License: MIT License
         

edof-4.2.4/edof/_apps/_assoc_dialog.py

@@ -0,0 +1,92 @@
+"""Shared .edof file-association dialog.
+
+The user chooses *here* (inside the EDOF app) which app opens .edof files on
+double-click; the choice is then registered with the OS. Used by both the
+editor and the viewer so the experience is identical.
+"""
+from __future__ import annotations
+
+
+def manage_association(parent=None):
+    from PyQt6.QtWidgets import (
+        QDialog, QVBoxLayout, QHBoxLayout, QLabel, QRadioButton, QButtonGroup,
+        QPushButton, QMessageBox, QFrame,
+    )
+    from edof._apps.file_assoc import (
+        associate_edof_files, unassociate_edof_files, current_association_status,
+    )
+
+    status = current_association_status()
+    is_assoc = "associated" in status.lower() and "not " not in status.lower()
+    editor_default = "editor" in status.lower()
+
+    dlg = QDialog(parent)
+    dlg.setWindowTitle("File association (.edof)")
+    dlg.setMinimumWidth(420)
+    v = QVBoxLayout(dlg)
+
+    v.addWidget(QLabel(f"<b>Current status:</b> {status}"))
+    info = QLabel(
+        "Choose which app opens a <code>.edof</code> file when you double-click "
+        "it. You decide here, inside EDOF; the other app stays available via "
+        "right-click \u2192 Open With. Files show the EDOF icon either way."
+    )
+    info.setWordWrap(True)
+    v.addWidget(info)
+
+    rb_view = QRadioButton("Open with EDOF Viewer (read-only)")
+    rb_edit = QRadioButton("Open with EDOF Editor")
+    grp = QButtonGroup(dlg)
+    grp.addButton(rb_view)
+    grp.addButton(rb_edit)
+    (rb_edit if editor_default else rb_view).setChecked(True)
+    v.addWidget(rb_view)
+    v.addWidget(rb_edit)
+
+    line = QFrame()
+    line.setFrameShape(QFrame.Shape.HLine)
+    v.addWidget(line)
+
+    row = QHBoxLayout()
+    btn_reg = QPushButton("Register / Update")
+    btn_rm = QPushButton("Remove association")
+    btn_rm.setEnabled(is_assoc)
+    btn_close = QPushButton("Close")
+    row.addWidget(btn_reg)
+    row.addWidget(btn_rm)
+    row.addStretch(1)
+    row.addWidget(btn_close)
+    v.addLayout(row)
+
+    note = QLabel(
+        "<small>On Windows this is per-user (no admin needed); you may need to "
+        "log out and back in for the Explorer icon to refresh.</small>"
+    )
+    note.setWordWrap(True)
+    v.addWidget(note)
+
+    def _do_register():
+        app = "editor" if rb_edit.isChecked() else "viewer"
+        try:
+            ok, msg = associate_edof_files(default_app=app)
+            (QMessageBox.information if ok else QMessageBox.warning)(
+                dlg, "File association", msg)
+            if ok:
+                dlg.accept()
+        except Exception as e:  # noqa: BLE001
+            QMessageBox.critical(dlg, "File association", str(e))
+
+    def _do_remove():
+        try:
+            ok, msg = unassociate_edof_files()
+            (QMessageBox.information if ok else QMessageBox.warning)(
+                dlg, "File association", msg)
+            if ok:
+                dlg.accept()
+        except Exception as e:  # noqa: BLE001
+            QMessageBox.critical(dlg, "File association", str(e))
+
+    btn_reg.clicked.connect(_do_register)
+    btn_rm.clicked.connect(_do_remove)
+    btn_close.clicked.connect(dlg.reject)
+    dlg.exec()

{edof-4.2.2 → edof-4.2.4}/edof/_apps/assets/__init__.py

@@ -32,3 +32,21 @@ def app_icon_name(kind: str, ext: str = "ico") -> str:
     """Map a logical kind to an icon file name. kind in {editor,viewer,document}."""
     kind = kind if kind in ("editor", "viewer", "document") else "document"
     return f"edof-{kind}.{ext}"
+
+
+def set_windows_app_id(app_id: str) -> None:
+    """Give this process its own Windows taskbar identity.
+
+    Without this, a GUI launched under python/pythonw is grouped under the host
+    interpreter and the taskbar shows the interpreter's icon instead of the
+    app's window icon. Must be called early, before any window is shown. No-op
+    off Windows.
+    """
+    import sys
+    if sys.platform != "win32":
+        return
+    try:
+        import ctypes
+        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(str(app_id))
+    except Exception:
+        pass

{edof-4.2.2 → edof-4.2.4}/edof/_apps/cli.py

@@ -796,6 +796,8 @@ Examples:
                      help="Remove the .edof file association instead of adding it")
     pa.add_argument("--status", action="store_true",
                      help="Show current association status and exit")
+    pa.add_argument("--app", choices=["viewer", "editor"], default="viewer",
+                     help="Which app opens .edof on double-click (default: viewer)")
 
     return p
 
@@ -817,9 +819,8 @@ def cmd_associate_files(args):
             sys.exit(1)
     else:
         try:
-            associate_edof_files()
-            print("OK: .edof files now associated with edof-viewer.")
-            print("  Double-clicking a .edof file will now open it in edof-viewer.")
+            ok, info = associate_edof_files(default_app=getattr(args, "app", "viewer"))
+            print(("OK: " if ok else "WARN: ") + info)
             print("  On Windows, you may need to log out and back in for icons to refresh.")
         except Exception as e:
             print(f"ERROR: {e}")

{edof-4.2.2 → edof-4.2.4}/edof/_apps/editor.py

@@ -10305,44 +10305,14 @@ class EdofEditor(QMainWindow):
         dlg.exec()
 
     def _open_file_assoc_dialog(self):
-        """Manage the .edof file association (register / remove)."""
+        """Manage the .edof file association (choose app in-app, register/remove)."""
         try:
-            from edof._apps.file_assoc import (
-                associate_edof_files, unassociate_edof_files,
-                current_association_status,
-            )
+            from edof._apps._assoc_dialog import manage_association
         except Exception as e:
             QMessageBox.warning(self, "File association",
                                   f"Could not load file association module: {e}")
             return
-        status = current_association_status()
-        is_assoc = "associated" in status.lower() and "not " not in status.lower()
-        msg = (f"<h3>File association</h3>"
-               f"<p>Current status: <b>{status}</b></p>"
-               f"<p>When .edof files are registered, they show the EDOF icon in "
-               f"your file manager and the first time you open one the system "
-               f"lets you choose <b>EDOF Viewer</b> or <b>EDOF Editor</b>. No "
-               f"default is forced, so you stay in control of which app opens "
-               f"them.</p>"
-               f"<p>{'<b>Currently registered.</b> Click OK to remove the association.' if is_assoc else 'Click OK to register .edof files.'}</p>")
-        bb_text = "Unassociate" if is_assoc else "Associate"
-        ret = QMessageBox.question(self, "File association", msg,
-                                     QMessageBox.StandardButton.Ok | QMessageBox.StandardButton.Cancel)
-        if ret != QMessageBox.StandardButton.Ok: return
-        try:
-            if is_assoc:
-                ok, info = unassociate_edof_files()
-            else:
-                ok, info = associate_edof_files()
-            if ok:
-                QMessageBox.information(self, "File association",
-                                          f"<p><b>Success.</b></p><p>{info}</p>")
-            else:
-                QMessageBox.warning(self, "File association",
-                                       f"<p><b>Failed.</b></p><p>{info}</p>")
-        except Exception as e:
-            QMessageBox.critical(self, "File association",
-                                   f"Error: {e}")
+        manage_association(self)
 
     # ─────────────────────────────────────────────────────────────────────
     # v4.1.2: Multi-window support for embedded sub-documents
@@ -12310,6 +12280,13 @@ def _tpl_invoice():
 
 
 def main():
+    # v4.2.4: own taskbar identity so Windows shows the EDOF icon, not Python's.
+    try:
+        from edof._apps.assets import set_windows_app_id
+        set_windows_app_id("DavidSchobl.EDOF.Editor")
+    except Exception:
+        pass
+
     # Remove Qt image allocation limit (default 256 MB blocks large print jobs)
     try:
         from PyQt6.QtGui import QImageReader
@@ -12351,6 +12328,13 @@ def main():
 
     app=QApplication(sys.argv); app.setApplicationName("EDOF Editor")
     app.setApplicationVersion(edof.__version__)
+    try:
+        from edof._apps.assets import icon_path
+        _ip = icon_path("edof-editor.ico") or icon_path("edof-editor.png")
+        if _ip:
+            app.setWindowIcon(QIcon(_ip))
+    except Exception:
+        pass
     try:
         win=EdofEditor(sys.argv[1] if len(sys.argv)>1 else None)
         win.show()

{edof-4.2.2 → edof-4.2.4}/edof/_apps/file_assoc.py

@@ -17,31 +17,46 @@ import subprocess
 from pathlib import Path
 
 
-def _find_viewer_executable():
-    """Locate the edof-viewer command in PATH."""
-    exe = shutil.which("edof-viewer")
-    if exe:
-        return exe
-    # Fallback: try Python module invocation
+def _find_app_executable(cmd_name: str, module: str) -> str:
+    """Locate a GUI launcher as an ABSOLUTE path, never a .bat/.cmd.
+
+    Order: (1) the generated exe next to the interpreter (Scripts/ for pip
+    installs), (2) PATH via shutil.which but rejecting .bat/.cmd and forced to
+    absolute, (3) fall back to running the module with the interpreter
+    (pythonw on Windows so no console appears). This avoids picking up a
+    launcher .bat from the current directory, which has no icon and breaks when
+    invoked with a relative path.
+    """
+    exe_dir = os.path.dirname(os.path.abspath(sys.executable)) if sys.executable else ""
+    names = [cmd_name + ".exe", cmd_name] if os.name == "nt" else [cmd_name]
+    for d in ([os.path.join(exe_dir, "Scripts"), exe_dir] if exe_dir else []):
+        for n in names:
+            p = os.path.join(d, n)
+            if os.path.isfile(p) and not p.lower().endswith((".bat", ".cmd")):
+                return os.path.abspath(p)
+    found = shutil.which(cmd_name)
+    if found and not found.lower().endswith((".bat", ".cmd")):
+        return os.path.abspath(found)
     if sys.executable:
-        return f'"{sys.executable}" -m edof._apps.viewer'
+        py = os.path.abspath(sys.executable)
+        if os.name == "nt":
+            pyw = os.path.join(os.path.dirname(py), "pythonw.exe")
+            if os.path.isfile(pyw):
+                py = pyw
+        return f'"{py}" -m {module}'
     raise RuntimeError(
-        "Could not locate edof-viewer executable. "
-        "Make sure edof[viewer] is installed: pip install 'edof[viewer]'"
+        f"Could not locate {cmd_name}. Install with: pip install 'edof[all]'"
     )
 
 
+def _find_viewer_executable():
+    """Locate the edof-viewer launcher (absolute path, never a .bat)."""
+    return _find_app_executable("edof-viewer", "edof._apps.viewer")
+
+
 def _find_editor_executable():
-    """Locate the edof-editor command in PATH (fallback to module invocation)."""
-    exe = shutil.which("edof-editor")
-    if exe:
-        return exe
-    if sys.executable:
-        return f'"{sys.executable}" -m edof._apps.editor'
-    raise RuntimeError(
-        "Could not locate edof-editor executable. "
-        "Make sure edof[editor] is installed: pip install 'edof[all]'"
-    )
+    """Locate the edof-editor launcher (absolute path, never a .bat)."""
+    return _find_app_executable("edof-editor", "edof._apps.editor")
 
 
 def _cmd_with_arg(exe: str) -> str:
@@ -58,12 +73,12 @@ def current_association_status() -> str:
             import winreg
             with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, ".edof") as k:
                 cls, _ = winreg.QueryValueEx(k, "")
+            if cls == "edof.Document.Editor":
+                return "associated (opens in EDOF Editor on double-click)"
+            if cls == "edof.Document.Viewer":
+                return "associated (opens in EDOF Viewer on double-click)"
             if cls and cls.startswith("edof.Document"):
-                # Our document type. With the v4.2.2 model the type has no
-                # default opener, so check whether the open-with choices exist.
-                return ("associated (EDOF icon set; Windows asks which app "
-                        "to open with)")
-            # Some other progid claims .edof
+                return "associated (no default app set yet)"
             try:
                 with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT,
                                     f"{cls}\\shell\\open\\command") as k:
@@ -74,14 +89,18 @@ def current_association_status() -> str:
         except OSError:
             return "not associated"
     elif sys.platform.startswith("linux"):
-        # Check xdg-mime
         try:
             r = subprocess.run(
                 ["xdg-mime", "query", "default", "application/x-edof"],
                 capture_output=True, text=True, timeout=5
             )
-            if r.returncode == 0 and r.stdout.strip():
-                return f"associated with: {r.stdout.strip()}"
+            d = r.stdout.strip() if r.returncode == 0 else ""
+            if d == "edof-editor.desktop":
+                return "associated (opens in EDOF Editor on double-click)"
+            if d == "edof-viewer.desktop":
+                return "associated (opens in EDOF Viewer on double-click)"
+            if d:
+                return f"associated with: {d}"
         except (FileNotFoundError, subprocess.TimeoutExpired):
             pass
         return "not associated"
@@ -90,12 +109,18 @@ def current_association_status() -> str:
     return "unknown platform"
 
 
-def associate_edof_files():
-    """Register .edof files with edof-viewer for the current user."""
+def associate_edof_files(default_app: str = "viewer"):
+    """Register .edof files for the current user.
+
+    `default_app` selects which app opens a .edof file on double-click and is
+    chosen *inside the EDOF app*, not by the OS picker. Accepts "viewer" or
+    "editor"; falls back to the viewer if the editor is not found.
+    """
+    default_app = "editor" if str(default_app).lower().startswith("e") else "viewer"
     if sys.platform == "win32":
-        return _associate_windows()
+        return _associate_windows(default_app)
     if sys.platform.startswith("linux"):
-        return _associate_linux()
+        return _associate_linux(default_app)
     if sys.platform == "darwin":
         raise NotImplementedError(
             "macOS file association requires building edof-viewer as an .app "
@@ -118,22 +143,19 @@ def unassociate_edof_files():
 # Windows
 # ─────────────────────────────────────────────────────────────────────────────
 
-def _associate_windows():
+def _associate_windows(default_app: str = "viewer"):
     """Register .edof in HKCU\\Software\\Classes (per-user, no admin needed).
 
-    v4.2.2: the association does NOT force a default opener. `.edof` is mapped
-    to a document *type* progid (icon + friendly name, no open command), and the
-    Viewer and Editor are registered as the two "Open with" choices. The first
-    time the user double-clicks a `.edof` file Windows asks which app to use, so
-    the user picks their own default (and can change it any time). Files still
-    show the document icon in Explorer.
+    v4.2.3: the default opener is whatever the user chose *in the EDOF app*
+    (`default_app` = "viewer" or "editor"). That progid is set as the `.edof`
+    default so double-click opens it directly, no OS prompt. Both apps stay in
+    "Open with", and `.edof` files show the EDOF document icon either way.
     """
     import winreg
 
     classes = r"Software\Classes"
-    progid_doc = "edof.Document"          # file type: icon + name, no opener
-    progid_view = "edof.Document.Viewer"  # Open-with choice: Viewer
-    progid_edit = "edof.Document.Editor"  # Open-with choice: Editor
+    progid_view = "edof.Document.Viewer"
+    progid_edit = "edof.Document.Editor"
 
     viewer = _find_viewer_executable()
     cmd_view = _cmd_with_arg(viewer)
@@ -144,6 +166,11 @@ def _associate_windows():
         editor = None
         cmd_edit = None
 
+    # If the editor was requested but is unavailable, fall back to the viewer.
+    if default_app == "editor" and not editor:
+        default_app = "viewer"
+    default_progid = progid_edit if default_app == "editor" else progid_view
+
     try:
         from edof._apps.assets import icon_path
     except Exception:
@@ -157,12 +184,10 @@ def _associate_windows():
                                 0, winreg.KEY_WRITE) as k:
             winreg.SetValueEx(k, "", 0, winreg.REG_SZ, value)
 
-    # 1. .edof → the document TYPE progid (gives icon + name) and the open-with
-    #    list. No "default opener" is set on the type, so Windows prompts the
-    #    user to choose between the Viewer and the Editor.
+    # 1. .edof → the chosen default progid + the open-with list (both apps).
     with winreg.CreateKeyEx(winreg.HKEY_CURRENT_USER, f"{classes}\\.edof",
                             0, winreg.KEY_WRITE) as k:
-        winreg.SetValueEx(k, "", 0, winreg.REG_SZ, progid_doc)
+        winreg.SetValueEx(k, "", 0, winreg.REG_SZ, default_progid)
         winreg.SetValueEx(k, "Content Type", 0, winreg.REG_SZ, "application/x-edof")
     with winreg.CreateKeyEx(winreg.HKEY_CURRENT_USER,
                             f"{classes}\\.edof\\OpenWithProgids",
@@ -171,32 +196,32 @@ def _associate_windows():
         if editor:
             winreg.SetValueEx(k, progid_edit, 0, winreg.REG_NONE, b"")
 
-    # 2. Document type: friendly name + icon, deliberately NO shell\open\command.
-    with winreg.CreateKeyEx(winreg.HKEY_CURRENT_USER, f"{classes}\\{progid_doc}",
-                            0, winreg.KEY_WRITE) as k:
-        winreg.SetValueEx(k, "", 0, winreg.REG_SZ, "EDOF Document")
-        winreg.SetValueEx(k, "FriendlyTypeName", 0, winreg.REG_SZ,
-                          "Easy Document Format File")
-    if doc_icon and os.path.isfile(doc_icon):
-        _set_default(f"{progid_doc}\\DefaultIcon", f'"{doc_icon}",0')
-
-    # 3. Viewer open-with choice (own name + icon + open command).
+    # 2. Viewer progid: name + open command.
     with winreg.CreateKeyEx(winreg.HKEY_CURRENT_USER, f"{classes}\\{progid_view}",
                             0, winreg.KEY_WRITE) as k:
         winreg.SetValueEx(k, "", 0, winreg.REG_SZ, "EDOF Viewer")
-    if view_icon and os.path.isfile(view_icon):
-        _set_default(f"{progid_view}\\DefaultIcon", f'"{view_icon}",0')
+        winreg.SetValueEx(k, "FriendlyTypeName", 0, winreg.REG_SZ,
+                          "Easy Document Format File")
     _set_default(f"{progid_view}\\shell\\open\\command", cmd_view)
 
-    # 4. Editor open-with choice.
+    # 3. Editor progid: name + open command.
     if cmd_edit:
         with winreg.CreateKeyEx(winreg.HKEY_CURRENT_USER, f"{classes}\\{progid_edit}",
                                 0, winreg.KEY_WRITE) as k:
             winreg.SetValueEx(k, "", 0, winreg.REG_SZ, "EDOF Editor")
-        if edit_icon and os.path.isfile(edit_icon):
-            _set_default(f"{progid_edit}\\DefaultIcon", f'"{edit_icon}",0')
+            winreg.SetValueEx(k, "FriendlyTypeName", 0, winreg.REG_SZ,
+                              "Easy Document Format File")
         _set_default(f"{progid_edit}\\shell\\open\\command", cmd_edit)
 
+    # 4. Icons. The DEFAULT progid drives the Explorer file icon, so it gets the
+    #    document icon; the other progid shows its own app icon under "Open with".
+    if doc_icon and os.path.isfile(doc_icon):
+        _set_default(f"{default_progid}\\DefaultIcon", f'"{doc_icon}",0')
+    if default_progid != progid_view and view_icon and os.path.isfile(view_icon):
+        _set_default(f"{progid_view}\\DefaultIcon", f'"{view_icon}",0')
+    if editor and default_progid != progid_edit and edit_icon and os.path.isfile(edit_icon):
+        _set_default(f"{progid_edit}\\DefaultIcon", f'"{edit_icon}",0')
+
     # 5. Notify the shell that associations changed
     try:
         import ctypes
@@ -207,12 +232,10 @@ def _associate_windows():
     except Exception:
         pass
 
-    if editor:
-        return True, (".edof registered. Files now show the EDOF icon, and the "
-                      "first time you open one Windows lets you choose the "
-                      "Viewer or the Editor (no default is forced).")
-    return True, (".edof registered with the Viewer as an open-with choice. "
-                  "(Editor not found, so only the Viewer was registered.)")
+    chosen = "Editor" if default_progid == progid_edit else "Viewer"
+    return True, (f".edof registered. Double-click opens the {chosen}; the other "
+                  f"app stays available under right-click \u2192 Open with. "
+                  f"Files show the EDOF icon.")
 
 
 def _unassociate_windows():
@@ -267,12 +290,12 @@ def _unassociate_windows():
 DESKTOP_ENTRY = """\
 [Desktop Entry]
 Type=Application
-Name=EDOF Viewer
-Comment=View EDOF documents
+Name={name}
+Comment={comment}
 Exec={exec_cmd} %f
-Terminal=false
+{icon_line}Terminal=false
 MimeType=application/x-edof;
-Categories=Office;Viewer;
+Categories=Office;
 """
 
 MIME_XML = """\
@@ -286,40 +309,67 @@ MIME_XML = """\
 """
 
 
-def _associate_linux():
+def _associate_linux(default_app: str = "viewer"):
     home = Path.home()
     apps_dir = home / ".local" / "share" / "applications"
     mime_dir = home / ".local" / "share" / "mime" / "packages"
     apps_dir.mkdir(parents=True, exist_ok=True)
     mime_dir.mkdir(parents=True, exist_ok=True)
 
-    viewer = _find_viewer_executable()
+    try:
+        from edof._apps.assets import icon_path
+    except Exception:
+        icon_path = lambda *_a, **_k: None  # noqa: E731
+
+    def _icon_line(name):
+        p = icon_path(name)
+        return f"Icon={p}\n" if p and os.path.isfile(p) else ""
 
     # 1. MIME type
     (mime_dir / "edof.xml").write_text(MIME_XML, encoding="utf-8")
 
-    # 2. .desktop file
-    desktop_path = apps_dir / "edof-viewer.desktop"
-    desktop_path.write_text(
-        DESKTOP_ENTRY.format(exec_cmd=viewer),
-        encoding="utf-8",
-    )
-    desktop_path.chmod(0o755)
+    # 2. .desktop files for BOTH apps (so either can be the default).
+    viewer = _find_viewer_executable()
+    (apps_dir / "edof-viewer.desktop").write_text(
+        DESKTOP_ENTRY.format(name="EDOF Viewer", comment="View EDOF documents",
+                             exec_cmd=viewer, icon_line=_icon_line("edof-viewer.png")),
+        encoding="utf-8")
+    (apps_dir / "edof-viewer.desktop").chmod(0o755)
+
+    editor_ok = False
+    try:
+        editor = _find_editor_executable()
+        (apps_dir / "edof-editor.desktop").write_text(
+            DESKTOP_ENTRY.format(name="EDOF Editor", comment="Edit EDOF documents",
+                                 exec_cmd=editor, icon_line=_icon_line("edof-editor.png")),
+            encoding="utf-8")
+        (apps_dir / "edof-editor.desktop").chmod(0o755)
+        editor_ok = True
+    except RuntimeError:
+        pass
+
+    if default_app == "editor" and not editor_ok:
+        default_app = "viewer"
+    default_desktop = ("edof-editor.desktop" if default_app == "editor"
+                       else "edof-viewer.desktop")
 
-    # 3. Update database
+    # 3. Update databases + set the chosen default handler.
     for cmd in (["update-mime-database", str(home / ".local" / "share" / "mime")],
-                 ["update-desktop-database", str(apps_dir)],
-                 ["xdg-mime", "default", "edof-viewer.desktop", "application/x-edof"]):
+                ["update-desktop-database", str(apps_dir)],
+                ["xdg-mime", "default", default_desktop, "application/x-edof"]):
         try:
             subprocess.run(cmd, check=False, capture_output=True, timeout=10)
         except (FileNotFoundError, subprocess.TimeoutExpired):
             pass
-    return True, ".edof associated with edof-viewer (Linux desktop entry installed)."
+    chosen = "Editor" if default_desktop.endswith("editor.desktop") else "Viewer"
+    return True, (f".edof associated; double-click opens the {chosen}. "
+                  f"Both apps are available via right-click \u2192 Open With.")
 
 
 def _unassociate_linux():
     home = Path.home()
     for f in (home / ".local" / "share" / "applications" / "edof-viewer.desktop",
+              home / ".local" / "share" / "applications" / "edof-editor.desktop",
               home / ".local" / "share" / "mime" / "packages" / "edof.xml"):
         try:
             f.unlink(missing_ok=True)

{edof-4.2.2 → edof-4.2.4}/edof/_apps/viewer.py

@@ -534,43 +534,13 @@ class EdofViewer(QMainWindow):
         )
 
     def _on_associate(self):
-        from edof._apps.file_assoc import (
-            associate_edof_files, unassociate_edof_files,
-            current_association_status,
-        )
-        status = current_association_status()
-        is_assoc = "associated" in status.lower() and "not " not in status.lower()
-        if is_assoc:
-            msg = ("Remove the .edof file association?\n\n"
-                   "Explorer will stop showing the EDOF icon for .edof files "
-                   "and will no longer offer EDOF apps to open them.\n\n"
-                   f"Current status: {status}")
-            title, verb = "Remove association", "remove"
-        else:
-            msg = ("Register .edof files?\n\n"
-                   "Files will show the EDOF icon, and the first time you open "
-                   "one your system will let you choose the Viewer or the "
-                   "Editor (no default is forced).\n\n"
-                   f"Current status: {status}")
-            title, verb = "Register .edof files", "register"
-        reply = QMessageBox.question(self, title, msg,
-            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
-        if reply != QMessageBox.StandardButton.Yes:
-            return
         try:
-            ok, info = (unassociate_edof_files() if is_assoc
-                        else associate_edof_files())
-            if ok:
-                QMessageBox.information(self, "Done",
-                    f"{info}\n\n"
-                    "On Windows you may need to log out and back in for the "
-                    "icons in Explorer to refresh.")
-            else:
-                QMessageBox.warning(self, "Could not " + verb, info)
+            from edof._apps._assoc_dialog import manage_association
         except Exception as e:
-            QMessageBox.warning(self, "Could not " + verb,
-                f"Failed to {verb} file types:\n\n{e}\n\n"
-                f"On Windows this is per-user and should not need admin rights.")
+            QMessageBox.warning(self, "File association",
+                                f"Could not load file association module: {e}")
+            return
+        manage_association(self)
 
     def _on_donate(self):
         try:
@@ -611,9 +581,23 @@ def main():
         print("Install with: pip install edof[viewer]")
         sys.exit(1)
 
+    # v4.2.4: own taskbar identity so Windows shows the EDOF icon, not Python's.
+    try:
+        from edof._apps.assets import set_windows_app_id
+        set_windows_app_id("DavidSchobl.EDOF.Viewer")
+    except Exception:
+        pass
+
     app = QApplication(sys.argv)
     app.setApplicationName("EDOF Viewer")
     app.setApplicationVersion(edof.__version__)
+    try:
+        from edof._apps.assets import icon_path
+        _ip = icon_path("edof-viewer.ico") or icon_path("edof-viewer.png")
+        if _ip:
+            app.setWindowIcon(QIcon(_ip))
+    except Exception:
+        pass
 
     # Optional file argument
     filepath = None

{edof-4.2.2 → edof-4.2.4}/edof/version.py

@@ -9,7 +9,7 @@ typography values in pt and are migrated on load.
 """
 
 from __future__ import annotations
-__version__ = "4.2.2"
+__version__ = "4.2.4"
 FORMAT_MAJOR        = 4
 FORMAT_MINOR        = 2
 FORMAT_PATCH        = 0

{edof-4.2.2 → edof-4.2.4}/edof.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edof
-Version: 4.2.2
+Version: 4.2.4
 Summary: Easy Document Format – programmatic document creation, editing and export with vector PDF, rich text, tables and PDF import
 License: MIT License
         

{edof-4.2.2 → edof-4.2.4}/edof.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ edof.egg-info/entry_points.txt
 edof.egg-info/requires.txt
 edof.egg-info/top_level.txt
 edof/_apps/__init__.py
+edof/_apps/_assoc_dialog.py
 edof/_apps/cli.py
 edof/_apps/editor.py
 edof/_apps/edof_text_editor.py

{edof-4.2.2 → edof-4.2.4}/edof.egg-info/entry_points.txt

@@ -1,4 +1,6 @@
 [console_scripts]
 edof-cli = edof._apps.cli:main
+
+[gui_scripts]
 edof-editor = edof._apps.editor:main
 edof-viewer = edof._apps.viewer:main

{edof-4.2.2 → edof-4.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name            = "edof"
-version         = "4.2.2"
+version         = "4.2.4"
 description     = "Easy Document Format – programmatic document creation, editing and export with vector PDF, rich text, tables and PDF import"
 readme          = "README.md"
 license         = { file = "LICENSE" }
@@ -89,6 +89,8 @@ addopts   = "-v --tb=short"
 source = ["edof"]
 
 [project.scripts]
+edof-cli    = "edof._apps.cli:main"
+
+[project.gui-scripts]
 edof-editor = "edof._apps.editor:main"
 edof-viewer = "edof._apps.viewer:main"
-edof-cli    = "edof._apps.cli:main"