xcursor-format 0.0.0__tar.gz

xcursor_format-0.0.0/.github/workflows/publish.yml

@@ -0,0 +1,38 @@
+name: Publish to PyPI and Create Release
+on:
+  push:
+    tags: [ "v*" ]
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    environment: pypi
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+      - run: |
+          python -m pip install --upgrade pip
+          pip install build
+      - run: python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1
+
+  create-release:
+    runs-on: ubuntu-latest
+    needs: build-and-publish
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/github-script@v6
+        with:
+          script: |
+            github.rest.repos.createRelease({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              tag_name: context.ref.replace('refs/tags/', ''),
+              name: context.ref.replace('refs/tags/', ''),
+              generate_release_notes: true
+            })

xcursor_format-0.0.0/.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

xcursor_format-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 russiandesman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

xcursor_format-0.0.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: xcursor-format
+Version: 0.0.0
+Summary: Library and CLI tool for Xcursor files
+Author-email: russiandesman <des.maryin@googlemail.com>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow>=10
+Dynamic: license-file
+
+# xcursor-format
+
+Library to work with XCursor files
+
+# xcursor_theme_leftifier
+
+Take cursor theme you like (look at /usr/share/icons/), make it left hand friendly.
+
+Usage:
+
+```
+xcursor_theme_leftifier.py --input=/usr/share/icons/DMZ-Black --output=test
+```
+
+Advanced usage (when you know exactly which cursors need to be flipped and not satisfied with automation results):
+
+```
+xcursor_theme_leftifier.py --input=/usr/share/icons/DMZ-Black --output=test --files=left_ptr,left_ptr_watch
+```
+
+# xcur2png
+
+Drop-in replacement for great and misterious xcur2png (https://github.com/eworm-de/xcur2png)
+
+Usage:
+
+```
+xcur2png --show-hot --outdir=test /usr/share/icons/DMZ-Black/cursors/cross
+```

xcursor_format-0.0.0/README.md

@@ -0,0 +1,29 @@
+# xcursor-format
+
+Library to work with XCursor files
+
+# xcursor_theme_leftifier
+
+Take cursor theme you like (look at /usr/share/icons/), make it left hand friendly.
+
+Usage:
+
+```
+xcursor_theme_leftifier.py --input=/usr/share/icons/DMZ-Black --output=test
+```
+
+Advanced usage (when you know exactly which cursors need to be flipped and not satisfied with automation results):
+
+```
+xcursor_theme_leftifier.py --input=/usr/share/icons/DMZ-Black --output=test --files=left_ptr,left_ptr_watch
+```
+
+# xcur2png
+
+Drop-in replacement for great and misterious xcur2png (https://github.com/eworm-de/xcur2png)
+
+Usage:
+
+```
+xcur2png --show-hot --outdir=test /usr/share/icons/DMZ-Black/cursors/cross
+```

xcursor_format-0.0.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xcursor-format"
+dynamic = ["version"]
+description = "Library and CLI tool for Xcursor files"
+readme = "README.md"
+authors = [{name = "russiandesman", email = "des.maryin@googlemail.com"}]
+license = {text = "MIT"}
+requires-python = ">=3.10"
+dependencies = ["Pillow>=10"]
+
+[project.scripts]
+xcur2png = "xcur2png:main"
+xcursor_theme_leftifier = "xcursor_theme_leftifier:main"
+
+[tool.setuptools]
+py-modules = ["xcursor_format", "xcur2png", "xcursor_theme_leftifier"]
+

xcursor_format-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xcursor_format-0.0.0/xcur2png.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""Extract XCursor files into PNG images + xcursorgen-compatible config."""
+"""drop-in replacement for xcur2png (https://github.com/eworm-de/xcur2png)"""
+
+import argparse
+from pathlib import Path
+from PIL import Image
+
+from xcursor_format import XCursor
+
+def build_png(xcursor_frame, show_hotpoint):
+    def unpremultiply(argb):
+        def cap(color, a):
+            return 0 if a == 0 else min(255, color * 255 // a)
+        b = (argb >> 0) & 0xFF
+        g = (argb >> 8) & 0xFF
+        r = (argb >> 16) & 0xFF
+        a = (argb >> 24) & 0xFF
+        return cap(r, a), cap(g, a), cap(b, a), a
+        
+    img = Image.new("RGBA", (xcursor_frame.width, xcursor_frame.height))
+    img.putdata([unpremultiply(p) for p in xcursor_frame.pixels])
+    if show_hotpoint:
+        img.putpixel((xcursor_frame.xhot, xcursor_frame.yhot),(255, 0, 0, 255))
+
+    return img
+
+def main():
+    ap = argparse.ArgumentParser(description="Extract XCursor to PNGs")
+    ap.add_argument("cursor", help="Input XCursor file")
+    ap.add_argument("-o", "--outdir", help="Output directory (default: next to cursor file)")
+    ap.add_argument("-c", "--conf", help="Config file path (default: <cursor>.conf)")
+    ap.add_argument("-s", "--suffix", type=int, default=0, help="Starting numeric suffix (default: 0)")
+    ap.add_argument("-n", "--dry-run", action="store_true")
+    ap.add_argument("-x", "--show-hot", action="store_true")
+    args = ap.parse_args()
+
+    cursor_path = Path(args.cursor)
+    outdir = Path(args.outdir) if args.outdir else cursor_path.parent
+    conf_path = Path(args.conf) if args.conf else cursor_path.with_suffix(".conf")
+    cursor_bytes = cursor_path.read_bytes()
+    xcursor = XCursor(cursor_bytes)
+
+    if not args.dry_run:
+        outdir.mkdir(parents=True, exist_ok=True)
+
+    suffix = args.suffix
+    conf_lines = []
+
+    for image in xcursor.images:
+        png_name = f"{cursor_path.stem}_{suffix:03d}.png"
+        png_path = outdir / png_name
+
+        try:
+            rel_path = png_path.relative_to(conf_path.parent)
+        except ValueError:
+            rel_path = png_path
+
+        conf_lines.append(f"{image.header.subtype} {image.body.xhot} {image.body.yhot} {rel_path} {image.body.delay}")
+
+        if not args.dry_run:
+            img = build_png(image.body, args.show_hot)
+            img.save(png_path)
+            print(f"  {png_path}")
+
+        suffix += 1
+
+    if not args.dry_run:
+        conf_path.write_text("\n".join(conf_lines) + "\n")
+        print(f"Config: {conf_path}")
+    else:
+        print("\n".join(conf_lines))
+
+
+if __name__ == "__main__":
+    main()

xcursor_format-0.0.0/xcursor_format.egg-info/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: xcursor-format
+Version: 0.0.0
+Summary: Library and CLI tool for Xcursor files
+Author-email: russiandesman <des.maryin@googlemail.com>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow>=10
+Dynamic: license-file
+
+# xcursor-format
+
+Library to work with XCursor files
+
+# xcursor_theme_leftifier
+
+Take cursor theme you like (look at /usr/share/icons/), make it left hand friendly.
+
+Usage:
+
+```
+xcursor_theme_leftifier.py --input=/usr/share/icons/DMZ-Black --output=test
+```
+
+Advanced usage (when you know exactly which cursors need to be flipped and not satisfied with automation results):
+
+```
+xcursor_theme_leftifier.py --input=/usr/share/icons/DMZ-Black --output=test --files=left_ptr,left_ptr_watch
+```
+
+# xcur2png
+
+Drop-in replacement for great and misterious xcur2png (https://github.com/eworm-de/xcur2png)
+
+Usage:
+
+```
+xcur2png --show-hot --outdir=test /usr/share/icons/DMZ-Black/cursors/cross
+```

xcursor_format-0.0.0/xcursor_format.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+.gitignore
+LICENSE
+README.md
+pyproject.toml
+xcur2png.py
+xcursor_format.py
+xcursor_theme_leftifier.py
+.github/workflows/publish.yml
+xcursor_format.egg-info/PKG-INFO
+xcursor_format.egg-info/SOURCES.txt
+xcursor_format.egg-info/dependency_links.txt
+xcursor_format.egg-info/entry_points.txt
+xcursor_format.egg-info/requires.txt
+xcursor_format.egg-info/top_level.txt

xcursor_format-0.0.0/xcursor_format.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

xcursor_format-0.0.0/xcursor_format.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+xcur2png = xcur2png:main
+xcursor_theme_leftifier = xcursor_theme_leftifier:main

xcursor_format-0.0.0/xcursor_format.egg-info/requires.txt

@@ -0,0 +1 @@
+Pillow>=10

xcursor_format-0.0.0/xcursor_format.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+xcur2png
+xcursor_format
+xcursor_theme_leftifier

xcursor_format-0.0.0/xcursor_format.py

@@ -0,0 +1,174 @@
+from dataclasses import dataclass, astuple
+import struct
+
+class XCursorBase:
+    @classmethod
+    def raw_unpack(cls, data: bytes, offset: int, fmt: str):
+        required_size = struct.calcsize(fmt)
+        available_size = len(data) - offset
+        if available_size < required_size:
+            raise ValueError(f"Processing {cls.__name__}; required {required_size} bytes, only {available_size} available")
+        fields = struct.unpack_from(fmt, data, offset)
+        return fields, offset + required_size
+
+    @classmethod
+    def unpack(cls, data: bytes, offset: int, fmt: str | None = None):
+        if fmt is None:
+            fmt = cls.FMT
+        fields, new_offset = cls.raw_unpack(data, offset, fmt)
+        return cls(*fields), new_offset
+
+    def serialize(self):
+        return struct.pack(self.FMT, *astuple(self))
+
+
+@dataclass
+class XCursorHdr(XCursorBase):
+    EXPECTED_MAGIC = 0x72756358  # "Xcur"
+    FMT = "<IIII"
+    magic: int
+    size: int
+    version: int
+    toc_count: int
+
+    @classmethod
+    def unpack(cls, data: bytes, offset: int):
+        instance, new_offset = super().unpack(data, offset)
+        if instance.magic != cls.EXPECTED_MAGIC:
+            raise ValueError(f"Invalid magic number: {instance.magic:#x}, expected {cls.EXPECTED_MAGIC:#x}")
+        return instance, new_offset
+
+    def __repr__(self):
+        return f"[magic={self.magic:#x}, sz={self.size}, ver={self.version:#x}, toc_sz={self.toc_count}]"
+
+
+@dataclass
+class XCursorTocEntry(XCursorBase):
+    FMT = "<III"
+    type: int
+    subtype: int
+    position: int
+
+    def __repr__(self):
+        return f"[type={self.type:#x}, sub={self.subtype:#x}, filepos={self.position}]"
+
+
+@dataclass
+class XCursorChunkHdr(XCursorBase):
+    COMMENT = 0xfffd0001
+    IMAGE = 0xfffd0002
+    FMT = "<IIII"
+    chunk_len: int
+    type: int
+    subtype: int
+    version: int
+
+    def __repr__(self):
+        return f"[len={self.chunk_len}, type={self.type:#x}, sub={self.subtype:#x}, ver={self.version:#x}]"
+
+
+@dataclass
+class XCursorChunkComment(XCursorBase):
+    FMT = "<I"
+    str_len: int
+    string: str
+
+    @classmethod
+    def unpack(cls, data: bytes, offset: int):
+        instance, new_offset = super().unpack(data, offset)
+        string_bytes, new_offset = cls.raw_unpack(data, new_offset, f"{instance.str_len}s")
+        instance.string = string_bytes.decode('utf-8')
+        return instance, new_offset
+
+    def __repr__(self):
+        return f"[len={self.str_len}, s='{self.string}']"
+
+    def serialize(self):
+        return struct.pack(self.FMT + f"{self.str_len}s", self.str_len, self.string.encode('utf-8'))
+
+
+@dataclass
+class XCursorChunkImage(XCursorBase):
+    FMT = "<IIIII" # followed by "157I" for 157 pixels image 
+    width: int
+    height: int
+    xhot: int
+    yhot: int
+    delay: int
+    pixels: tuple[int, ...] = ()
+
+    @classmethod
+    def unpack(cls, data: bytes, offset: int):
+        instance, new_offset = super().unpack(data, offset)
+        instance.pixels, new_offset = cls.raw_unpack(data, new_offset, f"{instance.width * instance.height}I")
+        return instance, new_offset
+
+    def __repr__(self):
+        return f"[{self.width}x{self.height} with {self.xhot}x{self.yhot}, delay={self.delay}, {len(self.pixels)} pixels]"
+
+    def serialize(self):
+        return struct.pack(self.FMT + f"{self.width * self.height}I", *(astuple(self)[:-1] + self.pixels))
+
+
+@dataclass
+class XCursorChunk:
+    header: XCursorChunkHdr
+    body: XCursorChunkComment | XCursorChunkImage
+
+    @classmethod
+    def unpack(cls, data: bytes, offset: int):
+        header, body_offset = XCursorChunkHdr.unpack(data, offset)
+        if header.type == XCursorChunkHdr.COMMENT:
+            body, _ = XCursorChunkComment.unpack(data, body_offset)
+        elif header.type == XCursorChunkHdr.IMAGE:
+            body, _ = XCursorChunkImage.unpack(data, body_offset)
+        else:
+            raise ValueError(f"Unknown chunk type: {header.type:#x}")
+
+        return cls(header, body)
+
+    def __repr__(self):
+        return f"[{self.header}, {self.body}]"
+
+    def serialize(self):
+        return self.header.serialize() + self.body.serialize()
+
+
+class XCursor:
+    def __init__(self, data: bytes):
+        self.toc = []
+        self.chunks = []
+        self.hdr, offset = XCursorHdr.unpack(data, 0)
+        for i in range(self.hdr.toc_count):
+            toc_item, offset = XCursorTocEntry.unpack(data, offset)
+            self.toc.append(toc_item)
+            chunk = XCursorChunk.unpack(data, toc_item.position)
+            self.chunks.append(chunk)
+
+    def serialize(self):
+        result = self.hdr.serialize()
+        for toc_item in self.toc:
+            result += toc_item.serialize()
+        for chunk in self.chunks:
+            result += chunk.serialize()
+        return result
+
+    @property
+    def images(self):
+        for chunk in self.chunks:
+            if isinstance(chunk.body, XCursorChunkImage):
+                yield chunk
+
+    @property
+    def largest_image(self):
+        return max(self.images, key=lambda chunk: chunk.body.width)
+
+    def flip(self):
+        def flip_horizontal(pixels: tuple[int, ...], width: int):
+            for i in range(0, len(pixels), width):
+                yield from reversed(pixels[i:i+width])
+        for chunk in self.images:
+            chunk.body.pixels = tuple(flip_horizontal(chunk.body.pixels, chunk.body.width))
+            chunk.body.xhot = chunk.body.width - 1 - chunk.body.xhot
+
+

xcursor_format-0.0.0/xcursor_theme_leftifier.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""Make cursor theme left-handed. Uses own heuristics to choose which cursors to flip"""
+"""Allows overriding the heuristics by providing own comma-separated --files list"""
+
+import argparse
+import shutil
+from configparser import ConfigParser
+from pathlib import Path
+from xcursor_format import XCursor
+
+ALWAYS_MIRROR = {
+    "hand1", "hand2", "grab", "openhand", "closedhand", "grabbing",
+    "pointer", "pointing_hand",
+    "dnd-ask",
+}
+
+NEVER_MIRROR = {
+    "sb_left_arrow", "sb_right_arrow",
+    "left-arrow", "right-arrow",
+    "left_tee", "right_tee",
+    "ul_angle", "ur_angle", "ll_angle", "lr_angle",
+    "right_ptr",
+}
+
+def should_mirror(name: str, xcursor: XCursor, user_list: set | None) -> bool:
+    if user_list is not None:
+        return name in user_list
+    if name in NEVER_MIRROR:
+        return False
+    if name in ALWAYS_MIRROR:
+        return True
+    frame = xcursor.largest_image.body
+    return frame.xhot / frame.width < 0.4
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--input', '-i', type=Path, required=True)
+    parser.add_argument('--output', '-o', type=Path, required=True)
+    parser.add_argument('--files', type=lambda s: set(s.split(',')))
+
+    args = parser.parse_args()
+    input_dir: Path = args.input
+    output_dir: Path = args.output
+
+    if output_dir.exists():
+        shutil.rmtree(output_dir)
+    shutil.copytree(args.input, args.output, symlinks=True)
+
+    for path in (output_dir / "cursors").iterdir():
+        if path.is_file() and not path.is_symlink():
+            print(f"Processing {path}")
+            name = path.stem
+            try:
+                xcursor = XCursor(path.read_bytes())
+                if should_mirror(name, xcursor, args.files):
+                    xcursor.flip()
+                    path.write_bytes(xcursor.serialize())
+                    print("Flipped")
+                else:
+                    print("Skipped")
+            except Exception as e:
+                print("Irrelevant")
+
+    cfg = ConfigParser()
+    cfg.read(output_dir / "index.theme")
+    lh_theme = f"[LeftHanded] {cfg['Icon Theme']['name']}"
+    cfg['Icon Theme']['name'] = lh_theme
+    with open(output_dir / "index.theme", "w") as f:
+        cfg.write(f, space_around_delimiters=False)
+
+if __name__ == '__main__':
+    main()