miniword 0.1.0__py3-none-any.whl

miniword/__init__.py

@@ -0,0 +1 @@
+import wx.lib.wxcairo as wxcairo

miniword/__main__.py

@@ -0,0 +1,76 @@
+import sys
+import wx
+from .core.document import Document
+from .core.config import get_config
+from .ui.mainwindow import MainFrame
+from .ui.unitentry import LengthInput, UnitPrefs
+from .layout import pagebuilder
+
+
+def _enable_dpi_awareness():
+    """Enable Per-Monitor DPI awareness on Windows to avoid blurry rendering."""
+    if sys.platform != 'win32':
+        return
+    try:
+        import ctypes
+        ctypes.windll.shcore.SetProcessDpiAwareness(2)  # Per-Monitor DPI aware
+    except Exception:
+        try:
+            ctypes.windll.user32.SetProcessDPIAware()
+        except Exception:
+            pass
+
+def _enable_dpi_awareness():
+    """Enable Per-Monitor DPI awareness v2 on Windows."""
+    if sys.platform != 'win32':
+        return
+    try:
+        # Windows 10 v1703+: Using SetProcessDpiAwarenessContext mit v2
+        # -4 entspricht DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2
+        ctypes.windll.user32.SetProcessDpiAwarenessContext(-4)
+    except Exception:
+        try:
+            # Fallback for Windows 8.1 / early Win 10 (2 = Process_Per_Monitor_DPI_Aware)
+            ctypes.windll.shcore.SetProcessDpiAwareness(2)
+        except Exception:
+            try:
+                # Fallback for Windows Vista / 7
+                ctypes.windll.user32.SetProcessDPIAware()
+            except Exception:
+                pass
+            
+def main():
+    args = sys.argv[1:]
+    if '--debug' in args:
+        pagebuilder.DEBUG = True
+        args = [a for a in args if a != '--debug']
+    path = args[0] if args else None
+
+    _enable_dpi_awareness()
+    config = get_config()
+    LengthInput.prefs = UnitPrefs(
+        layout=config.get("layout_unit"),
+        typographic=config.get("typographic_unit"),
+    )
+    app = wx.App(redirect=False)
+    app.SetAppName("miniword")
+    from .ui.mainwindow import load_plugins
+    load_plugins()
+    if path:
+        from .io import importexport
+        try:
+            doc = importexport.open_file(path)
+        except Exception as e:
+            print("Error opening '%s': %s" % (path, e))
+            return
+        frame = MainFrame(doc)
+        frame._current_path = path
+        frame._update_title()
+    else:
+        frame = MainFrame(Document())
+    frame.Show()
+    app.MainLoop()
+
+
+if __name__ == '__main__':
+    main()

miniword/core/config.py

@@ -0,0 +1,34 @@
+import json
+from pathlib import Path
+
+_path = Path.home() / ".config" / "miniword" / "config.json"
+_defaults = {"layout_unit": "mm", "typographic_unit": "mm"}
+
+_instance = None
+
+
+def get_config():
+    global _instance
+    if _instance is None:
+        _instance = Config()
+    return _instance
+
+
+class Config:
+    """Persistent user preferences, stored in ~/.config/miniword/config.json."""
+
+    def __init__(self):
+        self._data = {**_defaults}
+        if _path.exists():
+            try:
+                self._data.update(json.loads(_path.read_text()))
+            except Exception:
+                pass
+
+    def get(self, key):
+        return self._data.get(key, _defaults.get(key))
+
+    def set(self, key, value):
+        self._data[key] = value
+        _path.parent.mkdir(parents=True, exist_ok=True)
+        _path.write_text(json.dumps(self._data, indent=2))

miniword/core/document.py

@@ -0,0 +1,90 @@
+from ..textmodel.modelbase import Model
+from ..textmodel.textmodel import TextModel
+from .stylesheet import StyleSheet
+from .units import cm, mm
+from .styles import normal as _normal_style
+
+
+settings_default = {
+    "title":         "",
+    "author":        "",
+    "paper":         "A4",        # "A4" / "Letter" / "custom"
+    "paper_width":   210 * mm,    # used when paper == "custom"
+    "paper_height":  297 * mm,
+    "margin_top":    2.5 * cm,
+    "margin_right":  2.5 * cm,
+    "margin_bottom": 2.5 * cm,
+    "margin_left":   2.5 * cm,
+}
+
+
+class Document(Model):
+    def __init__(self):
+        self.basestyles = StyleSheet()
+        self.basestyles.set_owner(self, 'basestyles')
+        self.basestyles.set('normal', _normal_style)
+        self.textmodel = TextModel()
+        self.settings = {}
+        self.blobs = {}        # {blob_id: bytes}
+        self.home_format = 'txl'   # native format; set to ext on import
+
+    def set_setting(self, name, value):
+        if name in self.settings:
+            old = self.settings[name]
+        else:
+            old = settings_default[name]
+        if value != old:
+            if settings_default[name] == value:
+                del self.settings[name]
+            else:
+                self.settings[name] = value
+            self.notify_views('setting_changed', name, old)
+        return old
+
+    def save(self, path):
+        from ..io import txlio
+        txlio.save(self, path)
+
+    @classmethod
+    def load(cls, path):
+        from ..io.importexport import open_file
+        return open_file(path)
+        
+    def basestyles_changed(self, *args, **kwds):
+        self.notify_views('basestyles_changed')
+        
+
+        
+class TestDocument(Document):
+    def attribute_changed(self, *args, **kwds):
+        self.msg = args, kwds
+
+
+def test_00():
+    "receiving child messages via fallback handler"
+    doc = TestDocument()
+    doc.xyzstyles = StyleSheet()
+    doc.xyzstyles.set_owner(doc, 'xyzstyles')
+    doc.msg = None
+    doc.xyzstyles.set("x", {})
+    assert doc.msg == ((doc.xyzstyles,), {})
+
+
+def test_01():
+    "forwarding basestyles changes to views"
+    from ..textmodel.viewbase import ViewBase
+
+    class TestView(ViewBase):
+        def basestyles_changed(self, *args, **kwds):
+            self.msg = "basestyles_changed", args, kwds
+
+        def model_changed(self, *args, **kwds):
+            self.msg = "model_changed", args, kwds
+
+    doc = Document()
+    view = TestView()
+    view.model = doc
+
+    doc.basestyles.set('normal', dict(fontsize=9, dolor="black"))
+    assert view.msg == ('basestyles_changed', (doc,), {})
+

miniword/core/documentnode.py

@@ -0,0 +1,22 @@
+from ..textmodel.modelbase import Model
+
+
+class DocumentNode(Model):
+    owner = None
+    name = None
+    def set_owner(self, owner, name):
+        """Set the attribute owner and the attribute name."""
+        self.owner = owner
+        self.name = name
+        
+    def notify(self, message='model_changed', *args, **kwds):
+        """Inform all observers and the owner about the change."""
+        self.notify_views(message, *args, **kwds)
+        owner = self.owner
+        if owner is None:
+            return
+        if not self._call_if_present(owner, self.name+'_changed', self,
+                                     *args, **kwds):
+            self._call_if_present(owner, 'attribute_changed', self)
+        
+        

miniword/core/fontfinder.py

@@ -0,0 +1,274 @@
+"""Platform-independent font discovery.
+
+Linux/macOS: delegates to fc-match (fontconfig CLI, fast).
+Windows:     uses the FontLink registry for script fallback, fonttools for
+             codepoint verification.  Font files are opened on-demand and
+             cached so each file is read at most once per session.
+"""
+import sys
+import os
+import subprocess
+
+_path_cache = {}     # (family, bold, italic) -> path | None
+_fallback_cache = {} # codepoint -> (path, family) | (None, None)
+
+
+# ── Windows backend ──────────────────────────────────────────────────────────
+
+if sys.platform == 'win32':
+    import winreg
+    import threading
+
+    try:
+        from fontTools.ttLib import TTFont as _TTFont
+    except ImportError:
+        try:
+            from fonttools.ttLib import TTFont as _TTFont
+        except ImportError:
+            _TTFont = None
+            print(
+                'Warning: fonttools not found — font fallback for non-Latin '
+                'scripts disabled on Windows.  Install with: pip install fonttools',
+                file=sys.stderr,
+            )
+
+    _FONTS_DIR = os.path.join(os.environ.get('WINDIR', r'C:\Windows'), 'Fonts')
+    _win_index = None      # {family_lower: {(bold, italic): path}}
+    _win_font_link = None  # family_lower -> [(path, display_name), ...]
+    _win_coverage = {}     # path -> [(codepoint_set, display_name)] — on-demand
+    _preload_thread = None
+
+    def _build_win_index():
+        global _win_index
+        _win_index = {}
+        key_path = r'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts'
+        try:
+            key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, key_path)
+        except OSError:
+            return
+        i = 0
+        while True:
+            try:
+                name, value, _ = winreg.EnumValue(key, i)
+            except OSError:
+                break
+            i += 1
+            name = name.split('(')[0].strip()
+            bold = italic = False
+            for suffix, b, it in [
+                (' Bold Italic', True,  True),
+                (' Bold',        True,  False),
+                (' Italic',      False, True),
+            ]:
+                if name.endswith(suffix):
+                    name = name[:-len(suffix)]
+                    bold, italic = b, it
+                    break
+            path = value if os.path.isabs(value) else os.path.join(_FONTS_DIR, value)
+            # Registry entries like "MS Gothic & MS UI Gothic & MS PGothic" list
+            # several family names for one file — register each part individually.
+            for part in name.split('&'):
+                family = part.strip().lower()
+                if family:
+                    _win_index.setdefault(family, {})[(bold, italic)] = path
+        winreg.CloseKey(key)
+
+    def _build_font_link_index():
+        r"""Read FontLink\SystemLink into _win_font_link.
+
+        Each entry is a REG_MULTI_SZ of strings like
+        'MSGOTHIC.TTC,MS UI Gothic' or 'MALGUN.TTF,Malgun Gothic,128,96'.
+        """
+        global _win_font_link
+        _win_font_link = {}
+        key_path = r'SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink'
+        try:
+            key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, key_path)
+        except OSError:
+            return
+        i = 0
+        while True:
+            try:
+                name, entries, _ = winreg.EnumValue(key, i)
+            except OSError:
+                break
+            i += 1
+            chain = []
+            for entry in entries:
+                parts = entry.split(',')
+                if len(parts) < 2:
+                    continue
+                filename = parts[0].strip()
+                display = parts[1].strip()
+                path = (filename if os.path.isabs(filename)
+                        else os.path.join(_FONTS_DIR, filename))
+                chain.append((path, display))
+            _win_font_link[name.lower()] = chain
+        winreg.CloseKey(key)
+        _start_preload()
+
+    def _preload_font_link_coverage():
+        if _TTFont is None:
+            return
+        for path, _ in _font_link_candidates():
+            if path not in _win_coverage:
+                _coverage_for_path(path)
+
+    def _start_preload():
+        global _preload_thread
+        if _preload_thread is not None:
+            return
+        _preload_thread = threading.Thread(
+            target=_preload_font_link_coverage,
+            daemon=True,
+            name='fontlink-preload',
+        )
+        _preload_thread.start()
+
+    def _coverage_for_path(path):
+        """Return cached [(codepoint_set, display_name)] for path.
+
+        Reads and caches the cmap of every sub-font in the file the first
+        time it is requested; subsequent calls are a dict lookup.
+        """
+        if path in _win_coverage:
+            return _win_coverage[path]
+        entries = []
+        if path.lower().endswith('.ttc'):
+            n = 0
+            while True:
+                try:
+                    font = _TTFont(path, fontNumber=n, lazy=True)
+                    cmap = font.getBestCmap()
+                    name = font['name'].getDebugName(1) or ''
+                    entries.append((set(cmap.keys()) if cmap else set(), name))
+                    n += 1
+                except Exception:
+                    break
+        else:
+            try:
+                font = _TTFont(path, lazy=True)
+                cmap = font.getBestCmap()
+                name = font['name'].getDebugName(1) or ''
+                entries.append((set(cmap.keys()) if cmap else set(), name))
+            except Exception:
+                pass
+        _win_coverage[path] = entries
+        return entries
+
+    def _font_link_candidates():
+        """Ordered list of (path, display_name) from the FontLink registry.
+
+        Uses the chains of 'Tahoma' and 'Segoe UI' as representative
+        references — they together cover all common scripts on Windows.
+        Duplicates are removed while preserving order.
+        """
+        seen = set()
+        candidates = []
+        for ref in ('tahoma', 'segoe ui', 'microsoft sans serif'):
+            for path, name in _win_font_link.get(ref, []):
+                if path not in seen:
+                    seen.add(path)
+                    candidates.append((path, name))
+        return candidates
+
+    def _resolve_windows(family, bold, italic):
+        if _win_index is None:
+            _build_win_index()
+        styles = _win_index.get(family.lower(), {})
+        for b, i in [(bold, italic), (bold, False), (False, False)]:
+            if (b, i) in styles:
+                return styles[(b, i)]
+        # prefix fallback
+        prefix = family.lower()
+        for fam, styles in _win_index.items():
+            if fam.startswith(prefix) and styles:
+                return next(iter(styles.values()))
+        return None
+
+    def _fallback_windows(codepoint):
+        if _TTFont is None:
+            return None, None
+
+        if _win_index is None:
+            _build_win_index()
+        if _win_font_link is None:
+            _build_font_link_index()
+
+        # Fast path: check FontLink candidates (typically ~9 fonts, no pre-scan needed)
+        for path, _ in _font_link_candidates():
+            for codepoint_set, display_name in _coverage_for_path(path):
+                if codepoint in codepoint_set:
+                    return path, display_name
+
+        # Slow path: check every installed font (exotic scripts, user-installed fonts)
+        link_paths = {p for p, _ in _font_link_candidates()}
+        for styles in _win_index.values():
+            path = next(iter(styles.values()))
+            if path in link_paths:
+                continue
+            for codepoint_set, display_name in _coverage_for_path(path):
+                if codepoint in codepoint_set:
+                    return path, display_name
+
+        return None, None
+
+
+# ── Public API ────────────────────────────────────────────────────────────────
+
+def init_preload():
+    """Start background font-index preload. Call once at startup when HarfBuzz is available."""
+    if sys.platform == 'win32':
+        _build_font_link_index()
+
+def resolve_font_path(family, bold, italic):
+    """Return the file path for the best matching font, or None."""
+    key = (family, bold, italic)
+    if key in _path_cache:
+        return _path_cache[key]
+
+    if sys.platform == 'win32':
+        path = _resolve_windows(family, bold, italic)
+    else:
+        pattern = family
+        if bold and italic:
+            pattern += ':bold:italic'
+        elif bold:
+            pattern += ':bold'
+        elif italic:
+            pattern += ':italic'
+        try:
+            result = subprocess.run(
+                ['fc-match', pattern, '--format=%{file}'],
+                capture_output=True, text=True, timeout=2)
+            path = result.stdout.strip() or None
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            path = None
+
+    _path_cache[key] = path
+    return path
+
+
+def find_fallback_info(codepoint):
+    """Return (path, family) of a font covering codepoint, or (None, None)."""
+    if codepoint in _fallback_cache:
+        return _fallback_cache[codepoint]
+
+    if sys.platform == 'win32':
+        info = _fallback_windows(codepoint)
+    else:
+        try:
+            result = subprocess.run(
+                ['fc-match', f':charset={codepoint:04x}', '--format=%{file}\t%{family}'],
+                capture_output=True, text=True, timeout=2)
+            line = result.stdout.strip()
+            if '\t' in line:
+                path, fam = line.split('\t', 1)
+                info = (path or None, fam.split(',')[0].strip() or None)
+            else:
+                info = (None, None)
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            info = (None, None)
+
+    _fallback_cache[codepoint] = info
+    return info

miniword/core/papersizes.py

@@ -0,0 +1,13 @@
+from .units import mm
+
+PAPER_SIZES = {
+    'A3':      (297 * mm, 420 * mm),
+    'A4':      (210 * mm, 297 * mm),
+    'A5':      (148 * mm, 210 * mm),
+    'A6':      (105 * mm, 148 * mm),
+    'B4':      (250 * mm, 353 * mm),
+    'B5':      (176 * mm, 250 * mm),
+    'Letter':  (215.9 * mm, 279.4 * mm),
+    'Legal':   (215.9 * mm, 355.6 * mm),
+    'Tabloid': (279.4 * mm, 431.8 * mm),
+}

miniword/core/styles.py

@@ -0,0 +1,158 @@
+# -*- coding. utf-8 -*-
+
+"""
+Conceptual notes and open questions:
+
+List values (i.e. indent_levels) are still conceptually problematic.
+
+- Should they be treated as if there were 10 distinct values
+  like indent_01, indent_02, ...?
+- What constitutes an override — a single value or the entire list?
+
+This issue arises for:
+- offsets
+- marker
+- marker_pos
+- marker_alignment
+- numbering_style
+
+
+This module consolidates style computation. The goal is to decouple
+other modules from implementation details so the style model can be
+changed easily.
+
+A known issue with the current implementation is that text formatting
+(styling) is not distinguished from paragraph layout parameters
+(alignment, indent, ...). As a result, every box ends up with its own
+dict containing many entries.
+
+A cleaner approach might be to store only text formatting attributes
+directly in ParStyle, and keep layout parameters in a separate
+attribute.
+"""
+
+from collections import OrderedDict
+from .units import pt, inch, cm, mm
+
+n_levels = 9  # 0–8, displayed as 1–9
+defaultbullets = ("▪", "•", "◦", "–")
+
+
+text_default = {
+    "font_family":  "Arial",
+    "font_size":    12,
+    "bold":         False,
+    "italic":       False,
+    "underline":    False,
+    "strike":       False,
+    "href":         "",
+    "color":        "black",
+    "bgcolor":      "white",
+    # "letter_spacing":    0,        # normal
+    "vertical_position": "normal",  # normal / superscript / subscript
+}
+
+structure_default = {                
+    "paragraph_type":  "normal",     # normal / list / numbered
+    "fixed_indent":    None,         # None = free, 0–8 = fixed at that level
+    "indent_levels":   tuple(i * cm for i in range(n_levels)),
+    "first_line_indent": 0,          # hanging indent: use negative values
+    "list_indent":      1 * cm,      # extra indent applied to list/numbered paragraphs
+    "marker":          defaultbullets + ("–",) * (n_levels-len(defaultbullets)),
+    "marker_pos":      (-0.8 * cm,) * n_levels,
+    # "marker_alignment": ('right',) * n_levels,
+    "marker_size":     (1,) * n_levels,
+    "marker_color":    ("black",) * n_levels,
+    "numbering_style": ("1.",) * n_levels,  # e.g. "1.", "1.1", "a."
+    "start_number":    None,               # None or int (for numbered lists)
+    "counter":         "item",             # item / section
+}
+
+layout_default = {
+    "alignment":         "left",    # left / center / right / justify
+    "space_before":      0,         # in pt
+    "space_after":       0,         # in pt
+    "line_spacing":      1.0,       # 1 = single spacing
+    # "min_line_height": None,
+    # "keep_together":   False,
+    # "tab_stops":       ...,       # TODO
+
+    "page_break_before": False,     # start on a new page
+    # "keep_with_next":       False, # keep together with next paragraph
+    # "keep_lines_together":  False, # prevent paragraph from breaking across pages
+    # "widow_control":        True,  # avoid widows
+    # "orphan_control":       True,  # avoid orphans
+    # "border_top":           None,  # top border
+    # "border_bottom":        None,  # bottom border
+    "block_color":          None,   # paragraph background color
+    "block_padding":        0,      # padding around block_color rect
+}
+
+other_default = {
+    "next_style": "standard",
+    "role":        None,    # semantic role for export (e.g. markdown)
+}
+
+
+# Keys that live exclusively on individual paragraphs and must never be
+# promoted to base styles or treated as style overrides (no red triangle).
+PARAGRAPH_ONLY_KEYS = frozenset({'start_number'})
+
+
+style_default = {
+    **text_default,
+    **structure_default,
+    **layout_default,
+    **other_default,
+}
+
+
+def updated(default, *styles):
+    """Merges dicts by updating from left to right."""
+    r = default.copy()
+    for s in styles:
+        r.update(s)
+    return r
+
+
+# This stylesheet is intended for internal testing:
+normal = updated(
+    text_default,
+    structure_default,
+    layout_default,
+    other_default,
+    dict(name="Normal"),
+)
+
+h0 = updated(normal, dict(name="Heading 1", role="h1", font_size=18, bold=True,
+                          page_break_before=True))
+h1 = updated(normal, dict(name="Heading 2", role="h2", font_size=16, bold=True,
+                          color="red"))
+h2 = updated(normal, dict(name="Heading 3", role="h3", font_size=14, bold=True))
+h3 = updated(normal, dict(name="Heading 4", role="h4", font_size=12, bold=True))
+
+from .stylesheet import StyleSheet
+
+testsheet = StyleSheet()
+testsheet.set('normal', normal)
+testsheet.set('h0', h0)
+testsheet.set('h1', h1)
+testsheet.set('h2', h2)
+testsheet.set('h3', h3)
+
+
+def mk_style(stylesheet, parstyle, style):
+    basestyle = stylesheet[parstyle.get("base", "normal")]
+    return updated(basestyle, parstyle, style)
+
+
+def mk_parstyle(stylesheet, parstyle):
+    basestyle = stylesheet[parstyle.get("base", "normal")]
+    return updated(basestyle, parstyle)
+
+
+def test_00():
+    assert (21*cm - 595.27) < 0.1
+    
+def test_01():
+    testsheet.get('normal')['font_size'] == 12