*.spec
*.pdf
*.mtgproxies
mtg_proxy_printer/resources/translations/*.qm
mtg_proxy_printer/resources/translations/mtgproxyprinter_sources.ts
Screenshots/*.txt
*.png
requirements*.txt

# Changelog

# Next version (in development)

## New features

- Improved custom card support
  - Adding custom cards via drag & drop now opens a dialog to customize the import
    - Allows setting the number of copies to add for each card. Vastly improves the workflow when you want
      to print multiple copies. 
    - Shown card name is now derived from the file name, instead of defaulting to "Custom Card"
  - The import dialog can also be accessed from the File menu. Access to printing custom cards no longer
    requires the use of drag & drop.
  - It is now possible to save custom cards and empty slots in the apps save file format.
    Custom cards are no longer lost when saving.

## Changed features

- The card table in the deck import wizard now has an editable Copies column to state the number of copies per card,
  instead of duplicating the card for that many rows. This makes it possible to edit the number of copies per card
- When splitting exported PDFs, zero-pad the sequence numbers appended to the file name 
  so that all have the same length. This gives a more consistent sorting of output files.
  - This avoids having output files sorted like "1.pdf", "11.pdf", "12.pdf", …, "2.pdf", "21.pdf", …
- The page content table no longer uses a fancy multi selection behavior, as it interfered with editing entries.
  The new behavior is in line with how other applications allow selections in tables.

# Version 0.30.1 (2025-03-11)  <a name="v0_30_1"></a>

## Fixed issues

- Fixed that some start-up tasks were not run on the Windows 10+ build. Fixes that the deck list translation and 
  default card language setting in the application settings did not offer any language choices.

import sys

# Make sure to find this checkout, and not any system- or user-wide installed versions that may be present
root_path = pathlib.Path(__file__).parent.absolute().resolve()
sys.path.insert(0, str(root_path))

import mtg_proxy_printer.model.carddb
from mtg_proxy_printer.__main__ import main


# These methods are wrapped by the profile() function
# if this script is run using the kernprof line profiler.
to_be_profiled_functions = {
    mtg_proxy_printer.model.carddb.CardDatabase: [
        "get_all_languages",

from abc import abstractmethod
import typing

from PyQt5.QtCore import QObject, pyqtSignal as Signal

from mtg_proxy_printer.model.carddb import CardDatabase, CardIdentificationData
from mtg_proxy_printer.model.card import Card, AnyCardType
from mtg_proxy_printer.model.imagedb import ImageDatabase
import mtg_proxy_printer.settings
from mtg_proxy_printer.logger import get_logger
logger = get_logger(__name__)
del get_logger

__all__ = [

    # noinspection PyUnresolvedReferences,PyUnboundLocalVariable
    profile
except NameError:
    # If not defined, use this identity decorator as a replacement
    def profile(func):
        return func

CardCounter = typing.Counter[AnyCardType]
ParsedDeck = typing.Tuple[CardCounter, typing.List[str]]


class ParserBase(QObject):

    @staticmethod
    def supported_file_types() -> typing.Dict[str, typing.List[str]]:

import abc
import collections
import csv
import typing

from PyQt5.QtCore import QObject, QCoreApplication

from mtg_proxy_printer.model.carddb import CardDatabase, CardIdentificationData
from ..model.card import Card
from mtg_proxy_printer.model.imagedb import ImageDatabase

from .common import ParsedDeck, ParserBase
from mtg_proxy_printer.logger import get_logger
logger = get_logger(__name__)
del get_logger

from collections import Counter
import re
import typing

from PyQt5.QtCore import QObject, QCoreApplication

from mtg_proxy_printer.decklist_parser.common import ParsedDeck, ParserBase
from mtg_proxy_printer.model.carddb import CardDatabase, CardIdentificationData
from mtg_proxy_printer.model.card import Card
from mtg_proxy_printer.model.imagedb import ImageDatabase
from mtg_proxy_printer.logger import get_logger
logger = get_logger(__name__)
del get_logger

MatchType = typing.Dict[str, str]

    @abstractmethod
    def undo(self, document: "Document") -> Self:
        """
        Reverses the application of the action to the given document, undoing its effects.
        For this to work properly, this action must have been the most recent action applied to the document.
        """
        return self

    def __eq__(self, other) -> bool:
        return isinstance(other, self.__class__) and all(
            map(
                operator.eq,
                map((partial(getattr, self)), self.COMPARISON_ATTRIBUTES),
                map((partial(getattr, other)), self.COMPARISON_ATTRIBUTES)

import functools
import itertools
import math
import typing

from ..model.card import Card, AnyCardType

if typing.TYPE_CHECKING:
    from mtg_proxy_printer.model.document import Document
from mtg_proxy_printer.model.document_page import Page
from mtg_proxy_printer.natsort import to_list_of_ranges
from ._interface import DocumentAction, IllegalStateError, Self, split_iterable
from .page_actions import ActionNewPage, ActionRemovePage
from mtg_proxy_printer.logger import get_logger

logger = get_logger(__name__)
del get_logger
__all__ = [

    def as_str(self):
        card_count = sum(upper-lower+1 for lower, upper in self.card_ranges_to_remove)
        page_number = self.page_number+1
        return self.translate(
            "ActionRemoveCards", "Remove %n card(s) from page {page_number}",
            "Undo/redo tooltip text", card_count
        ).format(page_number=page_number)

#  Copyright © 2020-2025  Thomas Hess <thomas.hess@udo.edu>
#
#  This program is free software: you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation, either version 3 of the License, or
#  (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program. If not, see <http://www.gnu.org/licenses/>.


import functools
import typing

from PyQt5.QtCore import QModelIndex, Qt
if typing.TYPE_CHECKING:
    from mtg_proxy_printer.model.document import Document
from mtg_proxy_printer.model.document_page import CardContainer, PageColumns
from ._interface import DocumentAction, Self

from mtg_proxy_printer.logger import get_logger
logger = get_logger(__name__)
del get_logger
__all__ = [
    "ActionEditCustomCard",
]
ItemDataRole = Qt.ItemDataRole


class ActionEditCustomCard(DocumentAction):
    """
    Edits a field of a custom card. Ensures that the dataChanged signal is sent for all copies of the given card
    """
    COMPARISON_ATTRIBUTES = ["old_value", "new_value", "page", "row", "column"]

    def __init__(self, index: QModelIndex, value):
        self.page = index.parent().row()
        self.row = index.row()
        self.column = PageColumns(index.column())
        self.old_value = index.data(ItemDataRole.EditRole)
        self.new_value = value
        self.new_display_value = None
        document = index.model()
        self.header_text = document.headerData(self.column, Qt.Orientation.Horizontal, ItemDataRole.DisplayRole)

    def apply(self, document: "Document") -> Self:
        self._set_data_for_custom_card(document, self.new_value)
        index = document.index(self.row, self.column, document.index(self.page, 0))
        self.new_display_value = index.data(ItemDataRole.DisplayRole)
        return super().apply(document)

    def undo(self, document: "Document") -> Self:
        self._set_data_for_custom_card(document, self.old_value)
        return super().undo(document)

    def _set_data_for_custom_card(self, document: "Document", value: typing.Any):
        row, column = self.row, self.column
        index = document.index(row, column, document.index(self.page, 0))
        container: CardContainer = index.internalPointer()
        card = container.card
        logger.debug(f"Setting page data on custom card for {column=} to {value}")
        if column == PageColumns.CardName:
            # This also affects the page overview. find_relevant_index_ranges()
            # takes care of that by also returning relevant Page indices
            card.name = value
        elif column == PageColumns.CollectorNumber:
            card.collector_number = value
        elif column == PageColumns.Language:
            card.language = value
        elif column == PageColumns.IsFront:
            card.is_front = value
            card.face_number = int(not value)
        elif column == PageColumns.Set:
            card.set = value
        for lower, upper in document.find_relevant_index_ranges(card, column):
            document.dataChanged.emit(lower, upper, [ItemDataRole.DisplayRole, ItemDataRole.EditRole])

    @functools.cached_property
    def as_str(self):
        return self.translate(
            "ActionEditCustomCard", "Edit custom card, set {column_header_text} to {new_value}",
            "Undo/redo tooltip text").format(column_header_text=self.header_text, new_value=self.new_display_value)

import pathlib
import typing

if typing.TYPE_CHECKING:
    from mtg_proxy_printer.model.page_layout import PageLayoutSettings
    from mtg_proxy_printer.model.document import Document

from mtg_proxy_printer.model.card import CardList
from ._interface import DocumentAction, IllegalStateError, ActionList, Self
from .page_actions import ActionNewPage
from .card_actions import ActionAddCard
from .new_document import ActionNewDocument
from .edit_document_settings import ActionEditDocumentSettings

from mtg_proxy_printer.logger import get_logger

import functools
import typing

if typing.TYPE_CHECKING:
    from mtg_proxy_printer.model.document import Document
from mtg_proxy_printer.model.document_page import Page
from ..model.card import AnyCardType
from ._interface import DocumentAction, IllegalStateError, Self
from mtg_proxy_printer.logger import get_logger

logger = get_logger(__name__)
del get_logger
__all__ = [
    "ActionNewPage",

import functools
import typing

from PyQt5.QtCore import Qt

from ..model.card import Card

if typing.TYPE_CHECKING:
    from mtg_proxy_printer.model.document_page import CardContainer
    from mtg_proxy_printer.model.document import Document

from ._interface import DocumentAction, Self, ActionList
from .card_actions import ActionRemoveCards, ActionAddCard

if typing.TYPE_CHECKING:
    from mtg_proxy_printer.model.document import Document

from ._interface import DocumentAction, Self
from mtg_proxy_printer.sqlite_helpers import open_database, cached_dedent
from mtg_proxy_printer.units_and_sizes import CardSizes, UUID
from mtg_proxy_printer.model.page_layout import PageLayoutSettings
from ..model.card import AnyCardType, CustomCard
from mtg_proxy_printer.model.document_loader import CardType
from mtg_proxy_printer.save_file_migrations import migrate_database

from mtg_proxy_printer.logger import get_logger

logger = get_logger(__name__)
del get_logger

    def __init__(self, file_path: Path):
        super().__init__()
        self.file_path = file_path

    def apply(self, document: "Document") -> Self:
        logger.debug(f"About to save document to {self.file_path}")
        layout = document.page_layout
        with open_database(self.file_path, "document-v7") as db:
            db.execute("BEGIN IMMEDIATE TRANSACTION  -- apply()\n")
            migrate_database(db, layout)
            self._clear_cards_and_pages(db)
            self._save_pages(db, document)
            self._save_cards(db, document)
            self.save_settings(db, layout)
            self._clean_unused_custom_cards(db)
            db.commit()
            if db.execute(cached_dedent("""\
                SELECT cast(freelist_count AS real)/page_count > 0.1 AS "should vacuum" -- apply() 
                  FROM pragma_page_count
                  INNER JOIN pragma_freelist_count
                """)).fetchone()[0]:
                db.execute("VACUUM -- apply()\n")
        logger.debug("Database saved and closed.")

    @staticmethod
    def save_settings(save_file: sqlite3.Connection, layout: PageLayoutSettings):
        settings, dimensions = layout.to_save_file_data()
        save_file.executemany(
            'INSERT OR REPLACE INTO DocumentSettings ("key", value) VALUES (?, ?) -- save_settings()\n',
            settings)
        save_file.executemany(
            'INSERT OR REPLACE INTO DocumentDimensions ("key", value) VALUES (?, ?) -- save_settings()\n',
            dimensions)
        logger.debug("Written document settings")

    @staticmethod
    def _clear_cards_and_pages(save_file: sqlite3.Connection):
        save_file.execute("DELETE FROM Card -- _clear_cards_and_pages()\n")
        save_file.execute("DELETE FROM Page -- _clear_cards_and_pages()\n")

    @staticmethod
    def _save_pages(save_file: sqlite3.Connection, document: "Document"):
        pages = (
            (number, CardSizes.for_page_type(page.page_type()).to_save_data())
            for number, page in enumerate(document.pages, start=1)
            if page
        )
        save_file.executemany(
            "INSERT INTO Page (page, image_size) VALUES (?, ?) -- _save_pages()\n",
            pages
        )

    @staticmethod
    def _save_cards(save_file: sqlite3.Connection, document: "Document"):
        empty_slot = cached_dedent("""\
        INSERT INTO Card (page, slot, is_front, type) -- _save_cards()
            VALUES (?, ? ,?, ?)\n""")
        official_card = cached_dedent("""\
        INSERT INTO Card (page, slot, is_front, type, scryfall_id) -- _save_cards()
            VALUES (?, ?, ? ,?, ?)\n""")
        for page_number, page in enumerate(document.pages, start=1):
            for slot, container in enumerate(page, start=1):
                card = container.card
                if card.image_file is document.image_db.get_blank(card.size):
                    # Empty slot
                    save_file.execute(

                        empty_slot,(page_number, slot, card.is_front, CardType.from_card(card))
                    )
                elif card.is_custom_card:
                    ActionSaveDocument._save_custom_card(save_file, page_number, slot, card)
                else:
                    save_file.execute(

                        official_card,
                        (page_number, slot, card.is_front, CardType.from_card(card), card.scryfall_id)
                    )
        logger.debug(f"Written {save_file.execute('SELECT count(1) FROM Card').fetchone()[0]} cards.")

    @staticmethod
    def _save_custom_card(save_file: sqlite3.Connection, page_number: int, slot: int, card: AnyCardType):












        custom_card_data = (

            card.scryfall_id, card.source_image_file, card.name, card.set.name, card.set_code,
            card.collector_number, card.is_front)
        save_file.execute(cached_dedent("""\

            INSERT INTO CustomCardData -- _save_custom_card()
                (card_id, image, name, set_name, set_code, collector_number, is_front)
                VALUES (?, ?, ?, ?, ?, ?, ?)
                ON CONFLICT (card_id) DO UPDATE
                    SET name = excluded.name,
                        set_name = excluded.set_name,
                        set_code = excluded.set_code,
                        collector_number = excluded.collector_number,
                        is_front = excluded.is_front
                    WHERE name <> excluded.name
                       OR set_name <> excluded.set_name
                       OR set_code <> excluded.set_code
                       OR collector_number <> excluded.collector_number
                       OR is_front <> excluded.is_front
                """),
            custom_card_data
        )

        card_data = (page_number, slot, card.is_front, CardType.from_card(card), card.scryfall_id)
        save_file.execute(cached_dedent("""\


            INSERT INTO Card (page, slot, is_front, type, custom_card_id) -- _save_custom_card()
                VALUES (?, ?, ? ,?, ?)\n"""),
            card_data








        )

    @staticmethod
    def _clean_unused_custom_cards(save_file: sqlite3.Connection):
        save_file.execute(cached_dedent("""\
            DELETE FROM CustomCardData  -- _clean_unused_custom_cards()
              WHERE card_id NOT IN (
                SELECT custom_card_id
                  FROM Card
                  WHERE custom_card_id IS NOT NULL)
            """))

    def undo(self, document: "Document") -> Self:
        raise NotImplementedError("Undoing saving to disk is unsupported.")

    @functools.cached_property
    def as_str(self):
        return self.translate(
            "ActionSaveDocument", "Save document to '{save_file_path}'."
        ).format(save_file_path=self.file_path)

    from secrets import token_bytes as randbytes

import typing

from PyQt5.QtCore import Qt, QModelIndex

from ._interface import DocumentAction, IllegalStateError, Self
from ..model.card import Card
from mtg_proxy_printer.model.document_page import CardContainer, PageColumns
from mtg_proxy_printer.model.document import Document
from mtg_proxy_printer.units_and_sizes import PageType
__all__ = [
    "ActionShuffleDocument",
]

IndexedCards = typing.List[typing.Tuple[int, Card]]
ModelIndexList = typing.List[QModelIndex]

#  Copyright © 2020-2025  Thomas Hess <thomas.hess@udo.edu>
#
#  This program is free software: you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation, either version 3 of the License, or
#  (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program. If not, see <http://www.gnu.org/licenses/>.

import dataclasses
import hashlib
import enum
import functools
import typing

from PyQt5.QtCore import QRect, QPoint, QSize, Qt, QPointF
from PyQt5.QtGui import QPixmap, QColor, QColorConstants, QPainter, QTransform

from mtg_proxy_printer.units_and_sizes import CardSize, PageType, CardSizes, UUID

ItemDataRole = Qt.ItemDataRole
RenderHint = QPainter.RenderHint
SmoothTransformation = Qt.TransformationMode.SmoothTransformation

@dataclasses.dataclass(frozen=True)
class MTGSet:
    code: str
    name: str

    def data(self, role: ItemDataRole):
        """data getter used for Qt Model API based access"""
        if role == ItemDataRole.EditRole:
            return self
        elif role == ItemDataRole.DisplayRole:
            return f"{self.name} ({self.code.upper()})"
        elif role == ItemDataRole.ToolTipRole:
            return self.name
        else:
            return None


@enum.unique
class CardCorner(enum.Enum):
    """
    The four corners of a card. Values are relative image positions in X and Y.
    These are fractions so that they work properly for both regular and oversized cards

    Values are tuned to return the top-left corner of a 10x10 area
    centered around (20,20) away from the respective corner.
    """
    TOP_LEFT = (15/745, 15/1040)
    TOP_RIGHT = (1-25/745, 15/1040)
    BOTTOM_LEFT = (15/745, 1-25/1040)
    BOTTOM_RIGHT = (1-25/745, 1-25/1040)


@dataclasses.dataclass(unsafe_hash=True)
class Card:
    name: str = dataclasses.field(compare=True)
    set: MTGSet = dataclasses.field(compare=True)
    collector_number: str = dataclasses.field(compare=True)
    language: str = dataclasses.field(compare=True)
    scryfall_id: str = dataclasses.field(compare=True)
    is_front: bool = dataclasses.field(compare=True)
    oracle_id: str = dataclasses.field(compare=True)
    image_uri: str = dataclasses.field(compare=True)
    highres_image: bool = dataclasses.field(compare=False)
    size: CardSize = dataclasses.field(compare=False)
    face_number: int = dataclasses.field(compare=True)
    is_dfc: bool = dataclasses.field(compare=True)
    image_file: typing.Optional[QPixmap] = dataclasses.field(default=None, compare=False)

    def set_image_file(self, image: QPixmap):
        self.image_file = image
        self.corner_color.cache_clear()

    def requested_page_type(self) -> PageType:
        if self.image_file is None:
            return PageType.OVERSIZED if self.is_oversized else PageType.REGULAR
        return PageType.OVERSIZED if self.image_file.size() == CardSizes.OVERSIZED.as_qsize_px() else PageType.REGULAR

    @functools.lru_cache(maxsize=len(CardCorner))
    def corner_color(self, corner: CardCorner) -> QColor:
        """Returns the color of the card at the given corner. """
        if self.image_file is None:
            return QColorConstants.Transparent
        sample_area = self.image_file.copy(QRect(
            QPoint(
                round(self.image_file.width() * corner.value[0]),
                round(self.image_file.height() * corner.value[1])),
            QSize(10, 10)
        ))
        average_color = sample_area.scaled(
            1, 1, transformMode=SmoothTransformation).toImage().pixelColor(0, 0)
        return average_color

    def display_string(self):
        return f'"{self.name}" [{self.set.code.upper()}:{self.collector_number}]'

    @property
    def set_code(self):  # Compatibility with CardIdentificationData
        return self.set.code

    @property
    def is_custom_card(self) -> bool:
        return False

    @property
    def is_oversized(self) -> bool:
        return self.size == CardSizes.OVERSIZED


@dataclasses.dataclass(unsafe_hash=True)
class CustomCard:
    name: str = dataclasses.field(compare=True)
    set: MTGSet = dataclasses.field(compare=True)
    collector_number: str = dataclasses.field(compare=True)
    language: str = dataclasses.field(compare=True)
    is_front: bool = dataclasses.field(compare=True)
    image_uri: str = dataclasses.field(compare=True)
    highres_image: bool = dataclasses.field(compare=False)
    size: CardSize = dataclasses.field(compare=False)
    face_number: int = dataclasses.field(compare=True)
    is_dfc: bool = dataclasses.field(compare=True)
    source_image_file: bytes = dataclasses.field(default=None, compare=False)

    def requested_page_type(self) -> PageType:
        if self.image_file is None:
            return PageType.OVERSIZED if self.is_oversized else PageType.REGULAR
        return PageType.OVERSIZED if self.image_file.size() == CardSizes.OVERSIZED.as_qsize_px() else PageType.REGULAR

    @functools.lru_cache(maxsize=len(CardCorner))
    def corner_color(self, corner: CardCorner) -> QColor:
        """Returns the color of the card at the given corner. """
        if self.image_file is None:
            return QColorConstants.Transparent
        sample_area = self.image_file.copy(QRect(
            QPoint(
                round(self.image_file.width() * corner.value[0]),
                round(self.image_file.height() * corner.value[1])),
            QSize(10, 10)
        ))
        average_color = sample_area.scaled(
            1, 1, transformMode=SmoothTransformation).toImage().pixelColor(0, 0)
        return average_color

    def display_string(self):
        return f'"{self.name}" [{self.set.code.upper()}:{self.collector_number}]'

    @property
    def oracle_id(self):
        return ""

    @property
    def set_code(self):  # Compatibility with CardIdentificationData
        return self.set.code

    @property
    def is_oversized(self) -> bool:
        return self.size == CardSizes.OVERSIZED

    @property
    def is_custom_card(self) -> bool:
        return True

    @functools.cached_property
    def image_file(self) -> QPixmap:
        source = QPixmap()
        source.loadFromData(self.source_image_file)
        target_size = self.size.as_qsize_px()
        return source if source.size() == target_size else source.scaled(target_size, transformMode=SmoothTransformation)

    @functools.cached_property
    def scryfall_id(self) -> UUID:
        hd = hashlib.md5(self.source_image_file).hexdigest()  # TODO: Maybe use something else instead of md5?
        return UUID(f"{hd[:8]}-{hd[8:12]}-{hd[12:16]}-{hd[16:20]}-{hd[20:]}")


@dataclasses.dataclass(unsafe_hash=True)
class CheckCard:
    front: Card
    back: Card

    @property
    def name(self) -> str:
        return f"{self.front.name} // {self.back.name}"

    @property
    def set(self) -> MTGSet:
        return self.front.set

    @set.setter
    def set(self, value: MTGSet):
        self.front.set = value
        self.back.set = value

    @property
    def collector_number(self) -> str:
        return self.front.collector_number

    @property
    def language(self) -> str:
        return self.front.language

    @property
    def scryfall_id(self) -> str:
        return self.front.scryfall_id

    @property
    def is_front(self) -> bool:
        return True

    @property
    def oracle_id(self) -> str:
        return self.front.oracle_id

    @property
    def size(self):
        return self.front.size

    @property
    def image_uri(self) -> str:
        return ""

    @property
    def set_code(self):
        return self.front.set_code

    @property
    def highres_image(self) -> bool:
        return self.front.highres_image and self.back.highres_image

    @property
    def is_oversized(self):
        return self.front.is_oversized

    @property
    def face_number(self) -> int:
        return 1

    @property
    def is_dfc(self) -> bool:
        return False

    @property
    def is_custom_card(self):
        return self.front.is_custom_card

    @property
    def image_file(self) -> typing.Optional[QPixmap]:
        if self.front.image_file is None or self.back.image_file is None:
            return None
        card_size = self.front.image_file.size()
        # Unlike metric paper sizes, the MTG card aspect ratio does not follow the golden ratio.
        # Cards thus can’t be scaled using a singular factor of sqrt(2) on both axis.
        # The scaled cards get a bit compressed horizontally.
        vertical_scaling_factor = card_size.width() / card_size.height()
        horizontal_scaling_factor = card_size.height() / (2 * card_size.width())
        combined_image = QPixmap(card_size)
        combined_image.fill(QColorConstants.Transparent)
        painter = QPainter(combined_image)
        painter.setRenderHints(RenderHint.SmoothPixmapTransform | RenderHint.HighQualityAntialiasing)
        transformation = QTransform()
        transformation.rotate(90)
        transformation.scale(horizontal_scaling_factor, vertical_scaling_factor)
        painter.setTransform(transformation)
        painter.drawPixmap(QPointF(card_size.width(), -card_size.height()), self.back.image_file)
        painter.drawPixmap(QPointF(0, -card_size.height()), self.front.image_file)

        return combined_image

    def requested_page_type(self) -> PageType:
        return self.front.requested_page_type()

    @functools.lru_cache(maxsize=len(CardCorner))
    def corner_color(self, corner: CardCorner) -> QColor:
        """Returns the color of the card at the given corner. """
        if corner == CardCorner.TOP_LEFT:
            return self.front.corner_color(CardCorner.BOTTOM_LEFT)
        elif corner == CardCorner.TOP_RIGHT:
            return self.front.corner_color(CardCorner.TOP_LEFT)
        elif corner == CardCorner.BOTTOM_LEFT:
            return self.back.corner_color(CardCorner.BOTTOM_RIGHT)
        elif corner == CardCorner.BOTTOM_RIGHT:
            return self.back.corner_color(CardCorner.TOP_RIGHT)
        return QColorConstants.Transparent

    def display_string(self):
        return f'"{self.name}" [{self.set.code.upper()}:{self.collector_number}]'


AnyCardType = typing.Union[Card, CheckCard, CustomCard]
CardList = typing.List[AnyCardType]
OptionalCard = typing.Optional[AnyCardType]
# Py3.8 compatibility hack, because isinstance(a, AnyCardType) fails on 3.8
AnyCardTypeForTypeCheck = typing.get_args(AnyCardType)

from collections import Counter
import dataclasses
import enum
import itertools
import typing

from PyQt5.QtCore import QAbstractTableModel, QModelIndex, Qt, pyqtSignal as Signal, QItemSelection
from PyQt5.QtGui import QIcon

from mtg_proxy_printer.document_controller import DocumentAction
from mtg_proxy_printer.document_controller.edit_custom_card import ActionEditCustomCard
from mtg_proxy_printer.model.document import Document
from mtg_proxy_printer.model.document_page import PageColumns
from mtg_proxy_printer.ui.common import get_card_image_tooltip
from mtg_proxy_printer.decklist_parser.common import CardCounter
from mtg_proxy_printer.model.carddb import CardIdentificationData
from mtg_proxy_printer.model.card import Card, AnyCardType, CustomCard
from mtg_proxy_printer.logger import get_logger

logger = get_logger(__name__)
del get_logger
ItemDataRole = Qt.ItemDataRole
ItemFlag = Qt.ItemFlag

__all__ = [
    "CardListColumns",
    "CardListModel",
]
INVALID_INDEX = QModelIndex()

@dataclasses.dataclass
class CardListModelRow:
    card: AnyCardType
    copies: int


class CardListColumns(enum.IntEnum):
    Copies = 0
    CardName = enum.auto()
    Set = enum.auto()
    CollectorNumber = enum.auto()
    Language = enum.auto()
    IsFront = enum.auto()

    def to_page_column(self):
        return CardListToPageColumnMapping[self]


CardList = typing.List[CardListModelRow]
CardListToPageColumnMapping = {
    CardListColumns.CardName: PageColumns.CardName,
    CardListColumns.Set: PageColumns.Set,
    CardListColumns.CollectorNumber: PageColumns.CollectorNumber,
    CardListColumns.Language: PageColumns.Language,
    CardListColumns.IsFront: PageColumns.IsFront,
}

class CardListModel(QAbstractTableModel):
    """
    This is a model for holding a list of cards.
    """
    EDITABLE_COLUMNS = {
        CardListColumns.Copies, CardListColumns.Set, CardListColumns.CollectorNumber, CardListColumns.Language,
    }
    oversized_card_count_changed = Signal(int)
    request_action = Signal(DocumentAction)

    def __init__(self, document: Document, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.header = {
            CardListColumns.Copies: self.tr("Copies"),
            CardListColumns.CardName: self.tr("Card name"),
            CardListColumns.Set: self.tr("Set"),
            CardListColumns.CollectorNumber: self.tr("Collector #"),
            CardListColumns.Language: self.tr("Language"),
            CardListColumns.IsFront: self.tr("Side"),
        }
        self.document = document
        self.card_db = document.card_db
        self.rows: CardList = []
        self.oversized_card_count = 0
        self._oversized_icon = QIcon.fromTheme("data-warning")

    def rowCount(self, parent: QModelIndex = INVALID_INDEX) -> int:
        return 0 if parent.isValid() else len(self.rows)

        if role in (ItemDataRole.DisplayRole, ItemDataRole.EditRole):
            if column == CardListColumns.Copies:
                return self.rows[row].copies
            elif column == CardListColumns.CardName:
                return card.name
            elif column == CardListColumns.Set:
                if role == ItemDataRole.EditRole:
                    return card.set
                else:
                    set_ = card.set
                    return f"{set_.name} ({set_.code.upper()})"
            elif column == CardListColumns.CollectorNumber:
                return card.collector_number
            elif column == CardListColumns.Language:
                return card.language
            elif column == CardListColumns.IsFront:
                if role == ItemDataRole.EditRole:
                    return card.is_front
                return self.tr("Front") if card.is_front else self.tr("Back")
        if card.is_custom_card and column == CardListColumns.CardName and role == ItemDataRole.ToolTipRole:
            return get_card_image_tooltip(card.source_image_file)
        elif card.is_oversized and role == ItemDataRole.ToolTipRole:
            return self.tr("Beware: Potentially oversized card!\nThis card may not fit in your deck.")
        if card.is_oversized and role == ItemDataRole.DecorationRole:
            return self._oversized_icon
        return None

    def flags(self, index: QModelIndex) -> Qt.ItemFlags:
        flags = super().flags(index)
        if index.column() in self.EDITABLE_COLUMNS or self.rows[index.row()].card.is_custom_card:
            flags |= ItemFlag.ItemIsEditable
        return flags

    def setData(self, index: QModelIndex, value: typing.Any, role: ItemDataRole = ItemDataRole.EditRole) -> bool:
        row, column = index.row(), index.column()
        container = self.rows[row]
        card = container.card
        if not card.is_custom_card and role == ItemDataRole.EditRole and column in self.EDITABLE_COLUMNS:
            return self._set_data_for_official_card(index, value)
        elif card.is_custom_card and role == ItemDataRole.EditRole:
            return self._set_data_for_custom_card(index, value)
        return False

    def _set_data_for_official_card(self, index: QModelIndex, value: typing.Any) -> bool:
        row, column = index.row(), index.column()
        container = self.rows[row]
        card = container.card
        logger.debug(f"Setting card list model data on official card for column {column} to {value}")
        if column == CardListColumns.Copies:




            return self._set_copies_value(container, card, value)
        elif column == CardListColumns.CollectorNumber:
            card_data = CardIdentificationData(
                card.language, card.name, card.set_code, value, is_front=card.is_front)
        elif column == CardListColumns.Set:
            card_data = CardIdentificationData(
                card.language, card.name, value.code, is_front=card.is_front
            )
        else:
            card_data = self.card_db.translate_card(card, value)
            if card_data == card:
                return False
        return self._request_replacement_card(index, card_data)

    def _set_data_for_custom_card(self, index: QModelIndex, value: typing.Any) -> bool:
        row, column = index.row(), CardListColumns(index.column())
        container = self.rows[row]
        card = container.card
        logger.debug(f"Setting card list model data on custom card for column {column} to {value}")
        action = None
        if document_indices := list(self.document.find_relevant_index_ranges(card, column.to_page_column())):
            # Create the action before updating the card to gather the old data for undo purposes
            # Take the first index found as the reference
            document_card_index = i if (i := document_indices[0][0]).parent().isValid() else document_indices[1][0]
            action = ActionEditCustomCard(document_card_index, value)

        if column == CardListColumns.Copies:
            return self._set_copies_value(container, card, value)
        if column == CardListColumns.CardName:
            card.name = value
        elif column == CardListColumns.CollectorNumber:
            card.collector_number = value
        elif column == CardListColumns.Language:
            card.language = value
        elif column == CardListColumns.IsFront:
            card.is_front = value
            card.face_number = int(not value)
        elif column == CardListColumns.Set:
            card.set = value
        if card_indices := list(self.document.find_relevant_index_ranges(card, column.to_page_column())):
            logger.info(
                f"Edited custom card present in {len(card_indices)} locations in the document."
                f"Applying the change to the current document.")
        if action is not None:
            self.request_action.emit(action)
        return True

    def _set_copies_value(self, container: CardListModelRow, card: AnyCardType, value: int) -> bool:
        old_value, container.copies = container.copies, value
        if card.is_oversized and (difference := value - old_value):
            self.oversized_card_count += difference
            self.oversized_card_count_changed.emit(self.oversized_card_count)
        return value != old_value

    def _request_replacement_card(
            self, index: QModelIndex, card_data: typing.Union[CardIdentificationData, AnyCardType]):
        row, column = index.row(), index.column()
        if isinstance(card_data, CardIdentificationData):
            logger.debug(f"Requesting replacement for {card_data}")
            result = self.card_db.get_cards_from_data(card_data)
        else:
            result = [card_data]
        if result:
            # Simply choose the first match. The user can’t make a choice at this point, so just use one of the results.

            new_card = result[0]
            logger.debug(f"Replacing with {new_card}")
            top_left = index.sibling(row, column)
            bottom_right = top_left.siblingAtColumn(len(CardListColumns)-1)
            old_row = self.rows[row]
            self.rows[row] = new_row = CardListModelRow(new_card, old_row.copies)
            self.dataChanged.emit(

            self.oversized_card_count_changed.emit(self.oversized_card_count)

    def _remove_card_handle_oversized_flag(self, row: CardListModelRow):
        if row.card.is_oversized:
            self.oversized_card_count -= row.copies
            self.oversized_card_count_changed.emit(self.oversized_card_count)


    def remove_multi_selection(self, indices: QItemSelection) -> int:
        """
        Remove all cards in the given multi-selection.
        :return: Number of cards removed
        """

        selected_ranges = sorted(
            (selected_range.top(), selected_range.bottom()) for selected_range in indices
        )
        # This both minimizes the number of model changes needed and de-duplicates the data received from the
        # selection model. If the user selects a row, the UI returns a range for each cell selected, creating many
        # duplicates that have to be removed.
        selected_ranges = self._merge_ranges(selected_ranges)

            (index, index)
            for index, row in enumerate(self.rows)
            if row.card.oracle_id in basic_land_oracle_ids
        )
        merged = reversed(self._merge_ranges(to_remove_rows))
        removed_cards = sum(itertools.starmap(self.remove_cards, merged))
        logger.info(f"User requested removal of basic lands, removed {removed_cards} cards")

    def set_copies_to(self, indices: QItemSelection, value: int):
        """
        Sets the number of copies for all selected cards to value.
        If no card is selected, set the count for all cards.
        """
        if indices.isEmpty():
            selected_ranges = [
                (0, self.rowCount()-1)
            ]
        else:
            selected_ranges = sorted(
                (selected_range.top(), selected_range.bottom()) for selected_range in indices
            )
            # This both minimizes the number of model changes needed and de-duplicates the data received from the
            # selection model. If the user selects a row, the UI returns a range for each cell selected, creating many
            # duplicates that have to be removed.
            selected_ranges = self._merge_ranges(selected_ranges)
        column = CardListColumns.Copies
        roles = [ItemDataRole.DisplayRole, ItemDataRole.EditRole]
        for top, bottom in selected_ranges:
            for item in self.rows[top:bottom+1]:
                item.copies = value
            self.dataChanged.emit(self.index(top, column), self.index(bottom, column), roles)

#  You should have received a copy of the GNU General Public License
#  along with this program. If not, see <http://www.gnu.org/licenses/>.


import atexit
import dataclasses
import datetime

from itertools import starmap
import functools
from pathlib import Path
import sqlite3
import threading
from typing import Literal, Union, Dict, List, Tuple, NamedTuple, TypeVar, Optional, Set, Sequence, Any


from PyQt5.QtWidgets import QApplication

from PyQt5.QtCore import QObject, pyqtSignal as Signal, pyqtSlot as Slot

from mtg_proxy_printer.model.card import MTGSet, Card, CheckCard, OptionalCard, CardList, CustomCard
from mtg_proxy_printer.model.imagedb_files import CacheContent
import mtg_proxy_printer.app_dirs
from mtg_proxy_printer.natsort import natural_sorted
import mtg_proxy_printer.meta_data
from mtg_proxy_printer.sqlite_helpers import cached_dedent, open_database, validate_database_schema
import mtg_proxy_printer.settings
from mtg_proxy_printer.units_and_sizes import StringList, OptStr, CardSizes, CardSize, UUID
from mtg_proxy_printer.logger import get_logger

logger = get_logger(__name__)
del get_logger


OLD_DATABASE_LOCATION = mtg_proxy_printer.app_dirs.data_directories.user_cache_path / "CardDataCache.sqlite3"
DEFAULT_DATABASE_LOCATION = mtg_proxy_printer.app_dirs.data_directories.user_data_path / "CardDatabase.sqlite3"


SCHEMA_NAME = "carddb"
# The card data is mostly stable, Scryfall recommends fetching the card bulk data only in larger intervals, like
# once per month or so.
MINIMUM_REFRESH_DELAY = datetime.timedelta(days=14)
T = TypeVar("T", Card, CheckCard, CustomCard)
write_semaphore = threading.BoundedSemaphore()


__all__ = [
    "CardIdentificationData",






    "CardDatabase",

    "OLD_DATABASE_LOCATION",
    "DEFAULT_DATABASE_LOCATION",
    "with_database_write_lock",
    "SCHEMA_NAME",
]


@dataclasses.dataclass
class CardIdentificationData:
    language: OptStr = None
    name: OptStr = None
    set_code: OptStr = None
    collector_number: OptStr = None
    scryfall_id: OptStr = None
    is_front: Optional[bool] = None
    oracle_id: OptStr = None
































































































































































































class ImageDatabaseCards(NamedTuple):
    visible: List[Tuple[Card, CacheContent]] = []
    hidden: List[Tuple[Card, CacheContent]] = []
    unknown: List[CacheContent] = []











def with_database_write_lock(semaphore: threading.BoundedSemaphore = write_semaphore):
    """Decorator managing the database lock. Used to serialize database write transactions."""
    def decorator(func):
        @functools.wraps(func)
        def wrapped(*args, **kwargs):

class CardDatabase(QObject):
    """
    Holds the connection to the local SQLite database that contains the relevant card data.
    Provides methods for data access.
    """
    card_data_updated = Signal()
    custom_cards: Dict[UUID, CustomCard] = {}

    def __init__(self, db_path: Union[Literal[":memory:"], Path] = DEFAULT_DATABASE_LOCATION, parent: QObject = None,
                 check_same_thread: bool = True, register_exit_hooks: bool = True):
        """
        :param db_path: Path to the database file. May be “:memory:” to create an in-memory database for testing
            purposes.
        """
        super().__init__(parent)
        logger.info(f"Creating {self.__class__.__name__} instance.")
        self._db_check_same_thread = check_same_thread
        self.db_path = db_path
        self.db: sqlite3.Connection = None
        self._db_is_temporary = False
        self.reopen_database()
        self._exit_hook = None
        if db_path != ":memory:" and register_exit_hooks:
            self._register_exit_hook()

    @Slot()
    def reopen_database(self) -> None:
        logger.info(f"About to open card database from {self.db_path}")
        db = open_database(self.db_path, SCHEMA_NAME, check_same_thread=self._db_check_same_thread)
        outdated_on_disk = mtg_proxy_printer.sqlite_helpers.check_database_schema_version(db, SCHEMA_NAME) > 0

    def begin_transaction(self):
        logger.info("Starting new read transaction")
        self.db.execute("BEGIN DEFERRED TRANSACTION; --begin_transaction()\n")

    def has_data(self) -> bool:
        return bool(self._read_optional_scalar_from_db("SELECT EXISTS(SELECT * FROM Card) -- has_data()\n"))

    def get_last_card_data_update_timestamp(self) -> Optional[datetime.datetime]:
        """Returns the last card data update timestamp, or None, if no card data was ever imported"""
        query = "SELECT MAX(update_timestamp) FROM LastDatabaseUpdate -- get_last_card_data_update_timestamp\n"
        result: str = self._read_optional_scalar_from_db(query)
        return datetime.datetime.fromisoformat(result) if result else None

    def allow_updating_card_data(self) -> bool:
        """

            query = query.format(name_filter='AND card_name LIKE ?')
            parameters.append(f"{card_name_filter}%")
        else:
            query = query.format(name_filter='')
        return self._read_scalar_list_from_db(query, parameters)

    def get_basic_land_oracle_ids(
            self, include_wastes: bool = False, include_snow_basics: bool = False) -> Set[str]:
        """Returns the oracle ids of all Basic lands."""
        names = ['Plains', 'Island', 'Swamp', 'Mountain', 'Forest']
        # Ordering matters: This order also supports Snow-Covered Wastes
        if include_wastes:
            names.append("Wastes")
        if include_snow_basics:
            names += [f"Snow-Covered {name}" for name in names]

        for related_oracle_id in self._read_scalar_list_from_db(query, (card.oracle_id,)):
            # Prefer same set over other sets, which is important for multi-component cards like Meld cards. If it
            # isn't available, take from any other set. As a last-ditch fallback, resort to English printings.
            # The last case is most likely hit with non-English token-producing cards,
            # as long as Scryfall does not provide localized tokens.
            related_cards = \
                self.get_cards_from_data(
                    CardIdentificationData(card.language, set_code=card.set_code, oracle_id=related_oracle_id),
                    order_by_print_count=True) or \
                self.get_cards_from_data(
                    CardIdentificationData(card.language, oracle_id=related_oracle_id),
                    order_by_print_count=True) or \
                self.get_cards_from_data(
                    CardIdentificationData("en", oracle_id=related_oracle_id),
                    order_by_print_count=True)

              AND set_code = ?
              AND card_name = ?
        ''')
        return natural_sorted(item for item, in self.db.execute(query, (language, set_code, card_name)))

    def find_sets_matching(
            self, card_name: str, language: str, set_name_filter: str = None,
            *, is_front: bool = None) -> List[MTGSet]:
        """
        Finds all matching sets that the given card was printed in.

        :param card_name: Card name, matched exactly
        :param language: card language, matched exactly
        :param set_name_filter: If provided, only return sets with set code or full name beginning with this.
          Used as a LIKE pattern, supporting SQLite wildcards.

            size = CardSizes.from_bool(is_oversized)
            return Card(
                name, MTGSet(set_code, set_name), collector_number,
                language, scryfall_id, bool(is_front), oracle_id, image_uri,
                bool(highres_image), size, face_number, bool(is_dfc),
            )

    def get_all_cards_from_image_cache(self, cache_content: List[CacheContent]) -> ImageDatabaseCards:
        """
        Partitions the content of the ImageDatabase disk cache into three lists:
        - All visible card printings
        - All hidden card printings
        - All unknown images

        Visible and invisible printings are returned as lists containing tuples (Card, CacheContent),

            SELECT scryfall_id, is_front
              FROM Printing
              JOIN CardFace USING (printing_id)
          )
        ''')
        cards = ImageDatabaseCards([], [], [])
        cards.unknown[:] = (
            CacheContent(scryfall_id, bool(is_front), bool(highres_on_disk), Path(abs_path))
            for scryfall_id, is_front, highres_on_disk, abs_path
            in db.execute(unknown_images_query))
        for scryfall_id, is_front, highres_on_disk, abs_path, \
                name, set_code, set_name, collector_number, language, image_uri, oracle_id, \
                is_oversized, face_number, is_dfc, is_hidden \
                in db.execute(known_images_query):
            cache_item = CacheContent(scryfall_id, bool(is_front), bool(highres_on_disk), Path(abs_path))
            size = CardSizes.from_bool(is_oversized)
            card = Card(
                name, MTGSet(set_code, set_name), collector_number,
                language, cache_item.scryfall_id, cache_item.is_front, oracle_id, image_uri,
                bool(highres_on_disk), size, face_number, is_dfc
            )
            if is_hidden:
                cards.hidden.append((card, cache_item))
            else:
                cards.visible.append((card, cache_item))
        db.execute("ROLLBACK TRANSACTION TO SAVEPOINT 'partition_image_cache' -- get_all_cards_from_image_cache()\n")
        return cards

    def get_opposing_face(self, card) -> OptionalCard:
        """
        Returns the opposing face for double faced cards, or None for single-faced cards.
        """
        return self.get_card_with_scryfall_id(card.scryfall_id, not card.is_front)

    def guess_language_from_name(self, name: str) -> Optional[str]:
        """Guesses the card language from the card name. Returns None, if no result was found."""
        query = cached_dedent('''\
        SELECT "language" -- guess_language_from_name()
            FROM FaceName
            JOIN PrintLanguage USING (language_id)
            WHERE card_name = ?
            -- Assume English by default to not match other languages in case their entry misses the proper

        query = cached_dedent('''
        SELECT is_dfc -- is_dfc()
          FROM AllPrintings
          WHERE "scryfall_id" = ?
        ''')
        return bool(self._read_optional_scalar_from_db(query, (scryfall_id,)))

    def translate_card_name(self, card_data: Union[CardIdentificationData, Card], target_language: str,
                            include_hidden_names: bool = False) -> OptStr:
        """
        Translates a card into the target_language. Uses the language in the card data as the source language, if given.
        If not, card names across all languages are searched.

        :return: String with the translated card name, or None, if either unknown or unavailable in the target language.
        """

              AND Printing.is_hidden IS FALSE
          )
          ORDER BY language ASC;
        """)
        parameters = card.language, card.oracle_id
        return self._read_scalar_list_from_db(query, parameters)

    def get_available_sets_for_card(self, card: Card) -> List[MTGSet]:
        """
        Returns a list of MTG sets the card with the given Oracle ID is in, ordered by release date from old to new.
        """
        query = cached_dedent("""\
        SELECT DISTINCT set_code, set_name FROM ( -- get_available_sets_for_card()
          SELECT set_code, set_name, release_date
          FROM MTGSet

          UNION ALL
          SELECT set_code, set_name, release_date
            FROM MTGSet
            WHERE set_code = ?
          )
          ORDER BY release_date ASC
        """)
        parameters = card.oracle_id, card.language, card.set_code
        result = list(starmap(MTGSet, self.db.execute(query, parameters)))
        if not result:
            result.append(card.set)
        return result

    def get_available_collector_numbers_for_card_in_set(self, card: Card) -> StringList:
        query = cached_dedent("""\

            WHERE Printing.is_hidden IS FALSE
              AND FaceName.is_hidden IS FALSE
              AND oracle_id = ?
              AND set_code = ?
              AND language = ?
          )
        """)
        parameters = (card.collector_number, card.oracle_id, card.set_code, card.language)
        return natural_sorted((number for number, in self.db.execute(query, parameters)))

    def _read_optional_scalar_from_db(self, query: str, parameters: Sequence[Any] = ()):
        """
        Runs the query with the given parameters that is expected to return either a singular value or None,
        and returns the result
        """
        if result := self.db.execute(query, parameters).fetchone():
            return result[0]
        else:
            return None

    def _read_scalar_list_from_db(
            self, query: str, parameters: Sequence[Any] = ()) -> List[Any]:
        """Runs the query with the given parameters, returning a list of singular items"""
        return [item for item, in self.db.execute(query, parameters)]

    def is_removed_printing(self, scryfall_id: str) -> bool:
        logger.debug(f"Query RemovedPrintings table for scryfall id {scryfall_id}")
        parameters = scryfall_id,
        query = cached_dedent("""\
        SELECT oracle_id -- is_removed_printing()
            FROM RemovedPrintings
            WHERE scryfall_id = ?
        """)
        return bool(self._read_optional_scalar_from_db(query, parameters))

    def cards_not_used_since(self, keys: List[Tuple[str, bool]], date: datetime.date) -> List[int]:
        """
        Filters the given list of card keys (tuple scryfall_id, is_front). Returns a new list containing the indices
        into the input list that correspond to cards that were not used since the given date.
        """
        query = cached_dedent("""\
        SELECT last_use_date < ? AS last_use_was_before_threshold -- cards_not_used_since()
            FROM LastImageUseTimestamps
            WHERE scryfall_id = ?
              AND is_front = ?
        """)
        cards_not_used_since = []
        for index, (scryfall_id, is_front) in enumerate(keys):
            result = self._read_optional_scalar_from_db(query, (date.isoformat(), scryfall_id, is_front))
            if result is None or result:
                cards_not_used_since.append(index)
        return cards_not_used_since

    def cards_used_less_often_then(self,  keys: List[Tuple[str, bool]], count: int) -> List[int]:
        """
        Filters the given list of card keys (tuple scryfall_id, is_front). Returns a new list containing the indices
        into the input list that correspond to cards that are used less often than the given count.
        If count is zero or less, returns an empty list.
        """
        if count <= 0:
            return []

            return None
        size = CardSizes.from_bool(is_oversized)
        return Card(
            name, MTGSet(set_code, set_name), collector_number,
            language_override, scryfall_id, card.is_front, card.oracle_id, image_uri,
            bool(highres_image), size, face_number, bool(is_dfc),
        )

    def get_custom_card(
            self, name: str, set_code: str, set_name: str, collector_number: str,
            size: CardSize, is_front: bool, image: bytes) -> CustomCard:
        card = CustomCard(
            name, MTGSet(set_code, set_name), collector_number, "en",
            is_front, "", True, size, 1 + (not is_front), False, image)
        custom_card_id = card.scryfall_id
        card = self.custom_cards.get(custom_card_id, card)
        self.custom_cards[custom_card_id] = card
        return card

  card_id TEXT NOT NULL PRIMARY KEY CHECK (card_id GLOB '[a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9]-[a-f0-9][a-f0-9][a-f0-9][a-f0-9]-[a-f0-9][a-f0-9][a-f0-9][a-f0-9]-[a-f0-9][a-f0-9][a-f0-9][a-f0-9]-[a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9]'),
  image BLOB NOT NULL,  -- The raw image content
  name TEXT NOT NULL DEFAULT '',
  set_name TEXT NOT NULL DEFAULT '',
  set_code TEXT NOT NULL DEFAULT '',
  collector_number TEXT NOT NULL DEFAULT '',
  is_front BOOLEAN_INTEGER NOT NULL CHECK (is_front IN (TRUE, FALSE)) DEFAULT TRUE,

  other_face TEXT REFERENCES CustomCardData(card_id)  -- If this is a DFC, this references the other side
);

CREATE TABLE Page (
  page INTEGER NOT NULL PRIMARY KEY CHECK (page > 0),
  image_size TEXT NOT NULL CHECK(image_size <> '')
);

import pathlib
import sys
import typing

from PyQt5.QtCore import QAbstractItemModel, QModelIndex, Qt, pyqtSlot as Slot, pyqtSignal as Signal, \
    QPersistentModelIndex

from mtg_proxy_printer.natsort import to_list_of_ranges
from mtg_proxy_printer.document_controller.edit_custom_card import ActionEditCustomCard
from mtg_proxy_printer.model.document_page import CardContainer, Page, PageColumns
from mtg_proxy_printer.units_and_sizes import PageType, CardSizes, CardSize
from mtg_proxy_printer.model.carddb import CardDatabase, CardIdentificationData
from mtg_proxy_printer.model.card import MTGSet, Card, AnyCardType
from mtg_proxy_printer.model.page_layout import PageLayoutSettings
from mtg_proxy_printer.model.document_loader import DocumentLoader
from mtg_proxy_printer.model.imagedb import ImageDatabase
from mtg_proxy_printer.logger import get_logger

from mtg_proxy_printer.document_controller import DocumentAction
from mtg_proxy_printer.document_controller.replace_card import ActionReplaceCard
from mtg_proxy_printer.document_controller.save_document import ActionSaveDocument

logger = get_logger(__name__)
del get_logger

if sys.version_info[:2] >= (3, 9):
    Counter = collections.Counter
else:
    Counter = typing.Counter

__all__ = [
    "Document",

]


class DocumentColumns(enum.IntEnum):
    Page = 0











INVALID_INDEX = QModelIndex()
ActionStack = typing.Deque[DocumentAction]
AnyIndex = typing.Union[QModelIndex, QPersistentModelIndex]
ItemDataRole = Qt.ItemDataRole
Orientation = Qt.Orientation
ItemFlag = Qt.ItemFlag

        self.redo_stack: ActionStack = collections.deque()
        self.save_file_path: typing.Optional[pathlib.Path] = None
        self.card_db = card_db
        self.image_db = image_db
        self.loader = DocumentLoader(self)
        self.loader.loading_state_changed.connect(self.loading_state_changed)
        self.loader.load_requested.connect(self.apply)
        self.pages: typing.List[Page] = [first_page := Page()]
        # Mapping from page id() to list index in the page list
        self.page_index_cache: typing.Dict[int, int] = {id(first_page): 0}
        self.currently_edited_page = first_page
        self.page_layout = PageLayoutSettings.create_from_settings()
        logger.debug(f"Loaded document settings from configuration file: {self.page_layout}")
        logger.info(f"Created {self.__class__.__name__} instance")

        else:  # Page
            return self._data_page(index, role)

    def flags(self, index: AnyIndex) -> Qt.ItemFlags:
        index = self._to_index(index)
        data = index.internalPointer()
        flags = super().flags(index)
        if isinstance(data, CardContainer) and (index.column() in self.EDITABLE_COLUMNS or data.card.is_custom_card):
            flags |= ItemFlag.ItemIsEditable
        return flags

    def setData(self, index: AnyIndex, value: typing.Any, role: ItemDataRole = ItemDataRole.EditRole) -> bool:
        index = self._to_index(index)
        data: CardContainer = index.internalPointer()
        if not isinstance(data, CardContainer) or role != ItemDataRole.EditRole:
            return False
        column = index.column()
        card = data.card
        if card.is_custom_card:
            self.apply(ActionEditCustomCard(index, value))
            return True
        elif column in self.EDITABLE_COLUMNS:
            logger.debug(f"Setting page data on official card for {column=} to {value}")

            if column == PageColumns.CollectorNumber:
                card_data = CardIdentificationData(
                    card.language, card.name, card.set.code, value, is_front=card.is_front)
            elif column == PageColumns.Set:
                card_data = CardIdentificationData(
                    card.language, card.name, value.code, is_front=card.is_front
                )
            else:
                replacement = self.card_db.translate_card(card, value)
                if replacement != card:
                    action = ActionReplaceCard(replacement, index.parent().row(), index.row())
                    self.request_fill_image_for_action.emit(action)
                    return True

        ))

    def recreate_page_index_cache(self):
        self.page_index_cache.clear()
        self.page_index_cache.update(
            (id(page), index) for index, page in enumerate(self.pages)
        )

    def find_relevant_index_ranges(self, to_find: AnyCardType, column: PageColumns):
        """Finds all indices relevant for the given card."""
        # TODO: This runs in O(n)
        for page_row, page in enumerate(self.pages):
            instance_rows = to_list_of_ranges(
                # Use is to find exact same instances
                (row for row, container in enumerate(page) if container.card is to_find)
            )
            if instance_rows:
                parent = self.index(page_row, 0)
                if column == PageColumns.CardName:
                    yield parent, parent
                for lower, upper in instance_rows:
                    yield self.index(lower, column, parent), self.index(upper, column, parent)

import collections
import enum
import functools
import itertools
import pathlib
import sqlite3
import textwrap
from pathlib import Path
from typing import Counter, Dict, Iterable, List, NamedTuple, Optional, Tuple, TYPE_CHECKING, TypeVar, Union, Literal
from unittest.mock import patch

import pint
from PyQt5.QtCore import QObject, pyqtSignal as Signal, QThreadPool, Qt
from PyQt5.QtGui import QPixmap
from hamcrest import assert_that, all_of, instance_of, greater_than_or_equal_to, matches_regexp, is_in, \
    has_properties, is_, any_of, none, has_item, has_property, equal_to


try:
    from hamcrest import contains_exactly
except ImportError:
    # Compatibility with PyHamcrest < 1.10
    from hamcrest import contains as contains_exactly

import mtg_proxy_printer.settings
from mtg_proxy_printer.sqlite_helpers import cached_dedent, open_database, validate_database_schema
from mtg_proxy_printer.model.carddb import CardIdentificationData, SCHEMA_NAME, CardDatabase
from mtg_proxy_printer.model.card import MTGSet, Card, CheckCard, CardList, AnyCardType, CustomCard
from mtg_proxy_printer.model.imagedb import ImageDownloader
from mtg_proxy_printer.model.page_layout import PageLayoutSettings
from mtg_proxy_printer.logger import get_logger
from mtg_proxy_printer.units_and_sizes import PageType, QuantityT, UUID, CardSizes, OptStr, unit_registry, CardSize
from mtg_proxy_printer.document_controller import DocumentAction
from mtg_proxy_printer.runner import Runnable
from mtg_proxy_printer.save_file_migrations import migrate_database

if TYPE_CHECKING:
    from mtg_proxy_printer.model.document import Document
logger = get_logger(__name__)

class CardType(str, enum.Enum):
    REGULAR = "r"
    CHECK_CARD = "d"

    @classmethod
    def from_card(cls, card: AnyCardType) -> "CardType":
        if isinstance(card, (Card, CustomCard)):
            return cls.REGULAR
        elif isinstance(card, CheckCard):
            return cls.CHECK_CARD
        else:
            raise NotImplementedError()


class DatabaseLoadResult(NamedTuple):
    card: AnyCardType
    was_migrated: bool


class CardRow(NamedTuple):
    is_front: bool
    card_type: CardType
    scryfall_id: Optional[UUID]
    custom_card_id: Optional[UUID]


sqlite3.register_adapter(CardType, lambda item: item.value)
CustomCards = Dict[str, Card]
T = TypeVar("T")


def split_iterable(iterable: Iterable[T], chunk_size: int, /) -> Iterable[Tuple[T, ...]]:
    """Split the given iterable into chunks of size chunk_size. Does not add padding values to the last item."""
    iterable = iter(iterable)

    This class uses an internal worker to push that work off the GUI thread to keep the application
    responsive during a loading process.
    """

    loading_state_changed = Signal(bool)

    def __init__(self, document: "Document"):
        super().__init__(None)
        self.document = document

        disable_loading_state_on_completion = functools.partial(self.loading_state_changed.emit, False)
        self.finished.connect(disable_loading_state_on_completion, Qt.ConnectionType.DirectConnection)

    def load_document(self, save_file_path: pathlib.Path):
        logger.info(f"Loading document from {save_file_path}")
        self.loading_state_changed.emit(True)
        QThreadPool.globalInstance().start(LoaderRunner(save_file_path, self))

            self.worker.load_document()
        finally:
            self.release_instance()

    def _create_worker(self):
        parent = self.parent
        worker = Worker(parent.document, self.path)


        # The blocking connection causes the worker to wait for the document in the main thread to complete the loading
        worker.load_requested.connect(parent.load_requested, Qt.ConnectionType.BlockingQueuedConnection)
        worker.loading_file_failed.connect(parent.loading_file_failed)
        worker.unknown_scryfall_ids_found.connect(parent.unknown_scryfall_ids_found)
        worker.loading_file_successful.connect(parent.on_loading_file_successful)
        worker.network_error_occurred.connect(parent.network_error_occurred)
        worker.finished.connect(parent.finished)

    """
    loading_file_successful = Signal(pathlib.Path)

    def __init__(self, document: "Document", path: pathlib.Path):
        super().__init__(None)
        self.document = document
        self.save_path = path
        self.card_db = self._open_carddb(document)
        self.image_db = image_db = document.image_db

        # Create our own ImageDownloader, instead of using the ImageDownloader embedded in the ImageDatabase.
        # That one lives in its own thread and runs asynchronously and is thus unusable for loading documents.
        # So create a separate instance and use it synchronously inside this worker thread.
        self.image_loader = image_loader = ImageDownloader(image_db, self)
        image_loader.download_begins.connect(image_db.card_download_starting)
        image_loader.download_finished.connect(image_db.card_download_finished)
        image_loader.download_progress.connect(image_db.card_download_progress)
        image_loader.network_error_occurred.connect(self.on_network_error_occurred)
        self.network_errors_during_load: Counter[str] = collections.Counter()
        self.finished.connect(self.propagate_errors_during_load)
        self.should_run: bool = True
        self.unknown_ids = 0
        self.migrated_ids = 0
        self.current_progress = 0
        self.prefer_already_downloaded = mtg_proxy_printer.settings.settings["decklist-import"].getboolean(
            "prefer-already-downloaded-images")

    def _open_carddb(self, document: "Document") -> CardDatabase:
        db_path = document.card_db.db_path



        card_db = CardDatabase(db_path, self, register_exit_hooks=False)
        if db_path == ":memory:":  # For testing, copy the in-memory database of the passed card database instance
            document.card_db.db.backup(card_db.db)
        return card_db

    def propagate_errors_during_load(self):
        if error_count := sum(self.network_errors_during_load.values()):
            logger.warning(f"{error_count} errors occurred during document load, reporting to the user")
            self.network_error_occurred.emit(
                f"Some cards may be missing images, proceed with caution.\n"
                f"Error count: {error_count}. Most common error message:\n"

            self._load_document()
        except (AssertionError, sqlite3.DatabaseError) as e:
            logger.exception(
                "Selected file is not a known MTGProxyPrinter document or contains invalid data. Not loading it.")
            self.loading_file_failed.emit(self.save_path, str(e))
            self.finished.emit()  # Release UI in failure case. _load_document() emits this during regular operation
        finally:
            self.card_db.db.rollback()
            self.card_db.db.close()
            self.card_db = None

    def _complete_loading(self):
        if self.unknown_ids or self.migrated_ids:
            self.unknown_scryfall_ids_found.emit(self.unknown_ids, self.migrated_ids)
            self.unknown_ids = self.migrated_ids = 0
        self.loading_file_successful.emit(self.save_path)
        self.finished.emit()

    def _load_document(self):
        # Imported here to break a circular import. TODO: Investigate a better fix
        from mtg_proxy_printer.document_controller.load_document import ActionLoadDocument
        additional_steps = 2

        save_db = self._open_validate_and_migrate_save_file(self.save_path)
        total_cards = save_db.execute("SELECT count(1) FROM Card").fetchone()[0]
        self.begin_loading_loop.emit(total_cards+additional_steps, "Loading document:")
        page_layout = self._load_document_settings(save_db)
        self._advance_progress()
        logger.debug(f"About to load {total_cards} cards.")
        pages = self._load_cards(save_db) if total_cards else []
        save_db.rollback()
        save_db.close()
        self._fix_mixed_pages(pages, page_layout)
        self._advance_progress()
        action = ActionLoadDocument(self.save_path, pages, page_layout)
        self.load_requested.emit(action)
        self._complete_loading()

    def _advance_progress(self):
        self.current_progress += 1
        self.progress_loading_loop.emit(self.current_progress)

    @staticmethod
    def _open_validate_and_migrate_save_file(save_path: pathlib.Path) -> sqlite3.Connection:
        """
        Opens the save database, validates the schema and migrates the content to the newest
        save file version.

        :param save_path: File system path to open
        :return: The opened database connection."""
        db = open_database(save_path, f"document-v7")
        try:
            user_version = Worker._validate_database_schema(db)
            if user_version not in range(2, 8):
                raise AssertionError(f"Unknown database schema version: {user_version}")
            logger.info(f"Save file version is {user_version}")
            migrate_database(db, PageLayoutSettings.create_from_settings())
        except Exception:
            db.rollback()
            db.close()
            raise
        return db


    def _load_cards(self, save_db: sqlite3.Connection) -> List[CardList]:
        custom_cards: CustomCards = {}
        assert_that(
            save_db.execute("SELECT min(page) FROM Page").fetchone(),
            contains_exactly(all_of(instance_of(int), greater_than_or_equal_to(1))
        ))
        pages: List[CardList] = []
        allowed_sizes = {CardSizes.REGULAR.to_save_data(), CardSizes.OVERSIZED.to_save_data()}
        for page, expected_size in save_db.execute(
                "SELECT page, image_size FROM Page ORDER BY page ASC").fetchall():  # type: int, str
            assert_that(page, is_(instance_of(int)))
            assert_that(expected_size, is_in(allowed_sizes))
            pages.append(self._load_cards_on_page(save_db, page, expected_size, custom_cards))
        return pages


    def _load_cards_on_page(
            self, save_db: sqlite3.Connection, page: int, expected_size: str, custom_cards: CustomCards) -> CardList:

        query = textwrap.dedent("""\
            SELECT slot, is_front, type, scryfall_id, custom_card_id -- _load_cards_on_page()
                FROM Card
                WHERE page = ?
                ORDER BY page ASC, slot ASC""")
        db_data: Iterable[Tuple[int, bool, str, OptStr, OptStr]] = save_db.execute(query, (page,))
        valid_card_types = {v.value for v in CardType}
        is_positive_int = all_of(instance_of(int), greater_than_or_equal_to(1))
        result: CardList = []
        card_size = CardSizes.REGULAR if expected_size == CardSizes.REGULAR.to_save_data() else CardSizes.OVERSIZED
        for item in db_data:
            self._validate_save_db_card_row(is_positive_int, item, valid_card_types)
            slot, is_front, card_type_str, scryfall_id, custom_card_id = item
            card_row = CardRow(is_front, CardType(card_type_str), scryfall_id, custom_card_id)
            if custom_card_id:
                if custom_card_id in custom_cards:
                    result.append(custom_cards[custom_card_id])
                else:
                    card = self._load_custom_card_from_save(save_db, card_size, card_row)
                    if card.image_file:
                        result.append(card)
                        custom_cards[custom_card_id] = card
                    else:
                        logger.warning("Skipping loading custom card with invalid image")
                        continue

            elif scryfall_id:
                loaded = self._load_official_card_from_card_db(card_row)
                result.append(loaded.card)
                if loaded.was_migrated:
                    self.migrated_ids += 1
            else:
                result.append(self.document.get_empty_card_for_size(card_size))
            self._advance_progress()
        return result


    @staticmethod
    def _validate_save_db_card_row(is_positive_int, item, valid_card_types):
        assert_that(item, contains_exactly(
            is_positive_int,
            is_in({True, False}),
            is_in(valid_card_types),
            any_of(none(), matches_regexp(UUID.uuid_re.pattern)),
            any_of(none(), matches_regexp(UUID.uuid_re.pattern)),
        ))
        _, _, card_type_str, scryfall_id, custom_card_id = item
        card_type = CardType(card_type_str)
        if card_type == CardType.CHECK_CARD and custom_card_id:
            raise AssertionError("Check cards for custom DFCs currently not supported.")
        assert_that(
            (scryfall_id, custom_card_id), has_item(none()),
            "Scryfall ID and custom card ID must not be both present")


    def _load_official_card_from_card_db(self, data: CardRow) -> Optional[DatabaseLoadResult]:
        if data.card_type == CardType.CHECK_CARD:
            return self._load_check_card(data)
        else:
            return self._load_official_card(data)

            filtered_choices = []
            if prefer_already_downloaded:
                filtered_choices = self.image_db.filter_already_downloaded(choices)
            card = filtered_choices[0] if filtered_choices else choices[0]
            logger.info(f"Found suitable replacement card: {card}")
        return card


    def _load_custom_card_from_save(self, save_db: sqlite3.Connection, card_size: CardSize, card_row: CardRow) -> CustomCard:
        query = cached_dedent("""\
        SELECT name, set_code, set_name, collector_number, image
          FROM CustomCardData 
          WHERE card_id = ? AND is_front = ?

        """)
        name, set_code, set_name, collector_number, image_bytes = save_db.execute(

            query, (card_row.custom_card_id, card_row.is_front)
        ).fetchone()  # type: str, str, str, str, bytes


        return self.card_db.get_custom_card(
            name, set_code, set_name, collector_number, card_size, card_row.is_front, image_bytes)


    def _fix_mixed_pages(self, pages: List[CardList], page_settings: PageLayoutSettings):
        """
        Documents saved with older versions (or specifically crafted save files) can contain images with mixed
        sizes on the same page.
        This method is called when the document loading finishes and moves cards away from these mixed pages so that
        all pages only contain a single image size.

            f"'{key}'" for key, value in settings.__annotations__.items() if value is QuantityT)
        document_dimensions_query = textwrap.dedent(f"""\
            SELECT "key", value
                FROM DocumentDimensions
                WHERE "key" in ({keys})
            """)
        settings.update(db.execute(document_dimensions_query))
        is_distance = all_of(
            instance_of(pint.Quantity),
            has_property("dimensionality", equal_to(unit_registry.mm.dimensionality)))
        is_bool_str = is_in(("True", "False"))
        assert_that(
            settings,
            has_properties(
                card_bleed=is_distance,
                page_height=is_distance,
                page_width=is_distance,
                margin_top=is_distance,
                margin_bottom=is_distance,
                margin_left=is_distance,
                margin_right=is_distance,
                row_spacing=is_distance,
                column_spacing=is_distance,
                draw_cut_markers=is_bool_str,
                draw_sharp_corners=is_bool_str,
                draw_page_numbers=is_bool_str,
                document_name=instance_of(str),
            ),
            "Document settings contain invalid data or data types"
        )

        for key, annotated_type in PageLayoutSettings.__annotations__.items():
            value = getattr(settings, key)
            if annotated_type is bool:
                value = mtg_proxy_printer.settings.settings._convert_to_boolean(value)
            elif annotated_type is QuantityT:

                # Ensure all floats are within the allowed bounds.
                value = mtg_proxy_printer.settings.clamp_to_supported_range(
                    value, mtg_proxy_printer.settings.MIN_SIZE, mtg_proxy_printer.settings.MAX_SIZE)
            elif annotated_type is str:
                 pass
            setattr(settings, key, value)
        assert_that(

#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program. If not, see <http://www.gnu.org/licenses/>.


import dataclasses
import enum
from functools import partial
import typing

from mtg_proxy_printer.model.card import AnyCardType, AnyCardTypeForTypeCheck
from mtg_proxy_printer.units_and_sizes import PageType


class PageColumns(enum.IntEnum):
    CardName = 0
    Set = enum.auto()
    CollectorNumber = enum.auto()
    Language = enum.auto()
    IsFront = enum.auto()
    Image = enum.auto()


@dataclasses.dataclass
class CardContainer:
    parent: "Page"
    card: AnyCardType

        super().insert(__index, container)
        return container

    def append(self, __object: AnyCardType) -> CardContainer:
        container = CardContainer(self, __object)
        super().append(container)
        return container

from mtg_proxy_printer.document_controller.import_deck_list import ActionImportDeckList
from mtg_proxy_printer.document_controller import DocumentAction
from .imagedb_files import ImageKey, CacheContent
import mtg_proxy_printer.app_dirs
import mtg_proxy_printer.downloader_base
import mtg_proxy_printer.http_file
from mtg_proxy_printer.units_and_sizes import CardSizes, CardSize
from .card import Card, CheckCard, AnyCardType
from mtg_proxy_printer.runner import Runnable
from mtg_proxy_printer.logger import get_logger
logger = get_logger(__name__)
del get_logger

ItemDataRole = Qt.ItemDataRole
DEFAULT_DATABASE_LOCATION = mtg_proxy_printer.app_dirs.data_directories.user_cache_path / "CardImages"

    def compute_page_column_count(self, page_type: PageType = PageType.REGULAR) -> int:
        """Returns the total number of card columns that fit on this page."""
        card_size: CardSize = CardSizes.for_page_type(page_type)
        card_width: QuantityT = card_size.width.to("mm", "print")
        available_width: QuantityT = self.page_width - (self.margin_left + self.margin_right)

        if available_width <= card_width:
            return 0
        cards = 1 + math.floor(
            (available_width - card_width) /
            (card_width + self.column_spacing))
        return cards

    def compute_page_row_count(self, page_type: PageType = PageType.REGULAR) -> int:
        """Returns the total number of card rows that fit on this page."""
        card_size: CardSize = CardSizes.for_page_type(page_type)
        card_height: QuantityT = card_size.height.to("mm", "print")
        available_height: QuantityT = self.page_height - (self.margin_top + self.margin_bottom)

        if available_height <= card_height:
            return 0
        cards = 1 + math.floor(
            (available_height - card_height) /
            (card_height + self.row_spacing)
        )
        return cards

#  along with this program. If not, see <http://www.gnu.org/licenses/>.


import typing

from PyQt5.QtCore import QAbstractListModel, Qt, QObject, QModelIndex

from mtg_proxy_printer.model.card import MTGSet


__all__ = [
    "PrettySetListModel",
]
INVALID_INDEX = QModelIndex()
ItemDataRole = Qt.ItemDataRole
Orientation = Qt.Orientation

#  along with this program. If not, see <http://www.gnu.org/licenses/>.


"""
Natural sorting for lists or other iterables of strings.
"""

import itertools
import re
import typing

from PyQt5.QtCore import QSortFilterProxyModel, QModelIndex

__all__ = [
    "natural_sorted",
    "str_less_than",
    "NaturallySortedSortFilterProxyModel",
    "to_list_of_ranges"
]

_NUMBER_GROUP_REG_EXP = re.compile(r"(\d+)")


def try_convert_int(s: str):
    try:

        return super().lessThan(left, right)

    def row_sort_order(self) -> typing.List[int]:
        """Returns the row numbers of the source model in the current sort order."""
        return [
            self.mapToSource(self.index(row, 0)).row() for row in range(self.rowCount())
        ]


def to_list_of_ranges(sequence: typing.Iterable[int]) -> typing.List[typing.Tuple[int, int]]:
    sequence = sorted(sequence)
    ranges: typing.List[typing.Tuple[int, int]] = []
    sequence = itertools.chain(sequence, (sentinel := object(),))
    lower = upper = next(sequence)
    for item in sequence:
        if item is sentinel or upper != item-1:
            ranges.append((lower, upper))
            lower = upper = item
        else:
            upper = item
    return ranges

      <source>Third party licenses</source>
      <translation>Drittanbieter-Lizenzen</translation>
    </message>
  </context>
  <context>
    <name>ActionAddCard</name>
    <message numerus="yes">
      <location filename="../../document_controller/card_actions.py" line="161"/>
      <source>Add {count} × {card_display_string} to page {target}</source>
      <comment>Undo/redo tooltip text. Plural form refers to {target}, not {count}. {target} can be multiple ranges of multiple pages each</comment>
      <translation>
        <numerusform>Füge {count} × {card_display_string} zu Seite {target} hinzu</numerusform>
        <numerusform>Füge {count} × {card_display_string} zu Seiten {target} hinzu</numerusform>
      </translation>
    </message>
  </context>
  <context>
    <name>ActionCompactDocument</name>
    <message numerus="yes">
      <location filename="../../document_controller/compact_document.py" line="109"/>
      <source>Compact document, removing %n page(s)</source>
      <comment>Undo/redo tooltip text</comment>
      <translation>
        <numerusform>Kompaktiere Dokument, entferne %n Seite</numerusform>
        <numerusform>Kompaktiere Dokument, entferne %n Seiten</numerusform>
      </translation>
    </message>
  </context>
  <context>
    <name>ActionEditCustomCard</name>
    <message>
      <location filename="../../document_controller/edit_custom_card.py" line="85"/>
      <source>Edit custom card, set {column_header_text} to {new_value}</source>
      <comment>Undo/redo tooltip text</comment>
      <translation>Inoffizielle Karte bearbeiten, {column_header_text} auf {new_value} setzen</translation>
    </message>
  </context>
  <context>
    <name>ActionEditDocumentSettings</name>
    <message>
      <location filename="../../document_controller/edit_document_settings.py" line="133"/>
      <source>Update document settings</source>
      <comment>Undo/redo tooltip text</comment>
      <translation>Dokumenteneinstellungen ändern</translation>

        <numerusform>Ersetze Dokument durch importierte Deckliste mit %n Karten</numerusform>
      </translation>
    </message>
  </context>
  <context>
    <name>ActionLoadDocument</name>
    <message numerus="yes">
      <location filename="../../document_controller/load_document.py" line="77"/>
      <source>Load document from &apos;{save_path}&apos;,
containing %n page(s) {cards_total}</source>
      <comment>Undo/redo tooltip text.</comment>
      <translation>
        <numerusform>Lade Dokument von &apos;{save_path}&apos;,
mit %n Seite {cards_total}</numerusform>
        <numerusform>Lade Dokument von &apos;{save_path}&apos;,
mit %n Seiten {cards_total}</numerusform>
      </translation>
    </message>
  </context>
  <context>
    <name>ActionLoadDocument. Card total</name>
    <message numerus="yes">
      <location filename="../../document_controller/load_document.py" line="73"/>
      <source>with %n card(s) total</source>
      <comment>Undo/redo tooltip text. Will be inserted as {cards_total}</comment>
      <translation>
        <numerusform>und insgesamt %n Karte</numerusform>
        <numerusform>und insgesamt %n Karten</numerusform>
      </translation>
    </message>

        <numerusform>Seiten {pages} hinzufügen</numerusform>
      </translation>
    </message>
  </context>
  <context>
    <name>ActionRemoveCards</name>
    <message numerus="yes">
      <location filename="../../document_controller/card_actions.py" line="219"/>
      <source>Remove %n card(s) from page {page_number}</source>
      <comment>Undo/redo tooltip text</comment>
      <translation>
        <numerusform>Entferne %n Karte von Seite {page_number}</numerusform>
        <numerusform>Entferne %n Karten von Seite {page_number}</numerusform>
      </translation>
    </message>

        <numerusform>Seiten {formatted_pages} {formatted_card_count} entfernt</numerusform>
      </translation>
    </message>
  </context>
  <context>
    <name>ActionReplaceCard</name>
    <message>
      <location filename="../../document_controller/replace_card.py" line="99"/>
      <source>Replace card {old_card} on page {page_number} with {new_card}</source>
      <comment>Undo/redo tooltip text</comment>
      <translation>Ersetze {old_card} auf Seite {page_number} durch {new_card}</translation>
    </message>
  </context>
  <context>
    <name>ActionSaveDocument</name>
    <message>
      <location filename="../../document_controller/save_document.py" line="172"/>
      <source>Save document to &apos;{save_file_path}&apos;.</source>
      <translation>Dokument in &apos;{save_file_path}&apos; speichern.</translation>
    </message>
  </context>
  <context>
    <name>ActionShuffleDocument</name>
    <message>
      <location filename="../../document_controller/shuffle_document.py" line="102"/>
      <source>Shuffle document</source>
      <comment>Undo/redo tooltip text</comment>
      <translation>Dokument mischen</translation>
    </message>
  </context>
  <context>
    <name>CacheCleanupWizard</name>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="457"/>
      <source>Cleanup locally stored card images</source>
      <comment>Dialog window title</comment>
      <translation>Lokal gespeicherte Kartenbilder bereinigen</translation>
    </message>
  </context>
  <context>
    <name>CardFilterPage</name>

      <source>Unknown images:</source>
      <translation>Unbekannte Bilder:</translation>
    </message>
  </context>
  <context>
    <name>CardListModel</name>
    <message>
      <location filename="../../model/card_list.py" line="87"/>





      <source>Card name</source>
      <translation>Kartenname</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="88"/>
      <source>Set</source>
      <translation>Set</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="89"/>
      <source>Collector #</source>
      <translation>Sammler #</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="90"/>
      <source>Language</source>
      <translation>Sprache</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="91"/>
      <source>Side</source>
      <translation>Seite</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="128"/>
      <source>Front</source>
      <translation>Vorderseite</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="128"/>
      <source>Back</source>
      <translation>Rückseite</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="132"/>
      <source>Beware: Potentially oversized card!
This card may not fit in your deck.</source>
      <translation>Achtung: Potenziell übergroße Karte!
Diese Karte könnte nicht in Ihr Deck passen.</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="322"/>
      <source>Double-click on entries to
switch the selected printing.</source>
      <translation>Doppelklicken Sie auf Einträge, um den Ausdruck
zu wechseln.</translation>
    </message>












    <message>
      <location filename="../../model/card_list.py" line="86"/>
















      <source>Copies</source>
      <translation>Kopien</translation>
    </message>





  </context>
  <context>


    <name>CardSideSelectionDelegate</name>

    <message>
      <location filename="../../ui/item_delegates.py" line="72"/>
      <source>Front</source>
      <translation>Vorderseite</translation>
    </message>
    <message>
      <location filename="../../ui/item_delegates.py" line="73"/>
      <source>Back</source>
      <translation>Rückseite</translation>
    </message>
  </context>
  <context>
    <name>ColumnarCentralWidget</name>
    <message>
      <location filename="../ui/central_widget/columnar.ui" line="61"/>
      <source>All pages:</source>
      <translation>Alle Seiten:</translation>
    </message>
    <message>
      <location filename="../ui/central_widget/columnar.ui" line="68"/>
      <source>Current page:</source>
      <translation>Aktuelle Seite:</translation>
    </message>
    <message>
      <location filename="../ui/central_widget/columnar.ui" line="78"/>
      <source>Remove selected</source>
      <translation>Ausgewählte entfernen</translation>
    </message>
    <message>
      <location filename="../ui/central_widget/columnar.ui" line="88"/>
      <source>Add new cards:</source>
      <translation>Karten hinzufügen:</translation>
    </message>
  </context>
  <context>
    <name>CustomCardImportDialog</name>
    <message>
      <location filename="../ui/custom_card_import_dialog.ui" line="14"/>
      <source>Import custom cards</source>
      <translation>Inoffizielle Karten importieren</translation>
    </message>
    <message>
      <location filename="../ui/custom_card_import_dialog.ui" line="20"/>
      <source>Set Copies to …</source>
      <translation>Kopien auf … setzen</translation>
    </message>
    <message>
      <location filename="../ui/custom_card_import_dialog.ui" line="40"/>
      <source>Remove selected</source>
      <translation>Ausgewählte entfernen</translation>
    </message>
    <message>
      <location filename="../ui/custom_card_import_dialog.ui" line="50"/>
      <source>Load images</source>
      <translation>Bilder laden</translation>
    </message>
  </context>
  <context>
    <name>DatabaseImportWorker</name>
    <message>
      <location filename="../../card_info_downloader.py" line="424"/>
      <source>Error during import from file:

      <source>Open the Cutelog homepage</source>
      <translation>Öffne die Cutelog-Homepage</translation>
    </message>
  </context>
  <context>
    <name>DeckImportWizard</name>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="606"/>
      <source>Import a deck list</source>
      <translation>Deckliste importieren</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="628"/>
      <source>Oversized cards present</source>
      <translation>Übergroße Karten vorhanden</translation>
    </message>
    <message numerus="yes">
      <location filename="../../ui/deck_import_wizard.py" line="628"/>
      <source>There are %n possibly oversized cards in the deck list that may not fit into a deck, when printed out.

Continue and use these cards as-is?</source>
      <translation>
        <numerusform>Es gibt eine möglicherweise übergroße Karte in der Deckliste, die nach dem Ausdrucken nicht in ein Deck passen könnte.

Trotzdem mit der Deckliste fortfahren?</numerusform>
        <numerusform>Es gibt %n möglicherweise übergroße Karten in der Deckliste, die nach dem Ausdrucken nicht in ein Deck passen könnten.

Trotzdem mit der Deckliste fortfahren?</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="639"/>
      <source>Incompatible file selected</source>
      <translation>Inkompatible Datei ausgewählt</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="639"/>
      <source>Unable to parse the given deck list, no results were obtained.
Maybe you selected the wrong deck list type?</source>
      <translation>Die gegebene Deck-Liste konnte nicht analysiert werden. Es wurden keine Ergebnisse abgerufen.
Vielleicht haben Sie den falschen Deck-Listentyp ausgewählt?</translation>
    </message>
  </context>
  <context>

      <source>Default settings for new documents</source>
      <translation>Standardeinstellungen für neue Dokumente</translation>
    </message>
  </context>
  <context>
    <name>Document</name>
    <message>
      <location filename="../../model/document.py" line="91"/>
      <source>Card name</source>
      <translation>Kartenname</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="92"/>
      <source>Set</source>
      <translation>Set</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="93"/>
      <source>Collector #</source>
      <translation>Sammler #</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="94"/>
      <source>Language</source>
      <translation>Sprache</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="95"/>
      <source>Image</source>
      <translation>Bild</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="96"/>
      <source>Side</source>
      <translation>Seite</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="174"/>
      <source>Double-click on entries to
switch the selected printing.</source>
      <translation>Doppelklicken Sie auf Einträge, um den Ausdruck
zu wechseln.</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="287"/>
      <source>Page {current}/{total}</source>
      <translation>Seite {current}/{total}</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="317"/>
      <source>Front</source>
      <translation>Vorderseite</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="317"/>
      <source>Back</source>
      <translation>Rückseite</translation>
    </message>
    <message numerus="yes">
      <location filename="../../model/document.py" line="322"/>
      <source>%n× {name}</source>
      <comment>Used to display a card name and amount of copies in the page overview. Only needs translation for RTL language support</comment>
      <translation>
        <numerusform>%n× {name}</numerusform>
        <numerusform>%n× {name}</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="379"/>
      <source>Empty Placeholder</source>
      <translation>Leerer Platzhalter</translation>
    </message>
  </context>
  <context>
    <name>DocumentAction</name>
    <message>
      <location filename="../../document_controller/_interface.py" line="105"/>
      <source>{first}-{last}</source>
      <comment>Inclusive, formatted number range, from first to last</comment>
      <translation>{first}-{last}</translation>
    </message>
  </context>
  <context>
    <name>DocumentSettingsDialog</name>
    <message>
      <location filename="../../ui/dialogs.py" line="323"/>
      <source>These settings only affect the current document</source>
      <translation>Diese Einstellungen betreffen nur das aktuelle Dokument</translation>
    </message>
    <message>
      <location filename="../ui/document_settings_dialog.ui" line="6"/>
      <source>Set Document settings</source>
      <translation>Einstellungen dieses Dokuments</translation>

    </message>
    <message>
      <location filename="../ui/settings_window/general_settings_page.ui" line="51"/>
      <source>Application language</source>
      <translation>Sprache der Anwendung</translation>
    </message>
    <message>











      <location filename="../ui/settings_window/general_settings_page.ui" line="77"/>
      <source>Double-faced cards</source>
      <translation>Doppelseitige Karten</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/general_settings_page.ui" line="83"/>
      <source>When adding double-faced cards, automatically add the same number of copies of the other side.
Uses the appropriate, matching other card side.
Uncheck to disable this automatism.</source>
      <translation>Beim Hinzufügen von doppelseitigen Karten automatisch die gleiche Anzahl von Kopien der anderen Seite hinzufügen.
Verwendet die zugehörige, passende andere Kartenseite.
Deaktivieren um diesen Automatismus zu deaktivieren.</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/general_settings_page.ui" line="88"/>
      <source>Automatically add the other side of double-faced cards</source>
      <translation>Automatisch die andere Seite von doppelseitigen Karten hinzufügen</translation>
    </message>
    <message>





      <location filename="../ui/settings_window/general_settings_page.ui" line="101"/>
      <source>Preferred card language:</source>
      <translation>Bevorzugte Kartensprache:</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/general_settings_page.ui" line="114"/>
      <source>Automatic update checks</source>

      <translation>Wenn gesetzt, verwende dies als Standard-Speicherort für Dokumente.</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/general_settings_page.ui" line="195"/>
      <source>Path to a directory</source>
      <translation>Pfad zu einem Verzeichnis</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/general_settings_page.ui" line="67"/>
      <source>Language choices will default to the chosen language here.
Entries use the language codes as listed on Scryfall.

Note: Cards in deck lists use the language as given by the deck list. To overwrite, use the deck list translation option.</source>
      <translation>Kartenauswahl wird standardmäßig die hier gewählte Sprache verwenden.
Einträge verwenden die Sprachcodes wie auf Scryfall.

Hinweis: Decklistenimports verwenden die Sprache, wie in der Deckliste angegeben. Zum Überschreiben verwenden Sie die Option der Decklistenübersetzung.</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/general_settings_page.ui" line="98"/>
      <source>Card language selected at application start and default language when enabling deck list translations</source>
      <translation>Beim Start der Anwendung ausgewählte Kartensprache und Standardsprache beim Aktivieren der Decklistenübersetzung</translation>
    </message>
  </context>
  <context>
    <name>GroupedCentralWidget</name>
    <message>
      <location filename="../ui/central_widget/grouped.ui" line="58"/>
      <source>Remove selected</source>
      <translation>Ausgewählte entfernen</translation>
    </message>
    <message>
      <location filename="../ui/central_widget/grouped.ui" line="103"/>
      <source>All pages:</source>
      <translation>Alle Seiten:</translation>
    </message>
    <message>
      <location filename="../ui/central_widget/grouped.ui" line="110"/>
      <source>Add new cards:</source>
      <translation>Karten hinzufügen:</translation>
    </message>
  </context>
  <context>
    <name>HidePrintingsPage</name>
    <message>

      <source>Copies:</source>
      <translation>Kopien:</translation>
    </message>
  </context>
  <context>
    <name>ImageDownloader</name>
    <message>
      <location filename="../../model/imagedb.py" line="309"/>
      <source>Importing deck list</source>
      <comment>Progress bar label text</comment>
      <translation>Deckliste importieren</translation>
    </message>
    <message>
      <location filename="../../model/imagedb.py" line="329"/>
      <source>Fetching missing images</source>
      <comment>Progress bar label text</comment>
      <translation>Abrufen fehlender Bilder</translation>
    </message>
    <message>
      <location filename="../../model/imagedb.py" line="424"/>
      <source>Downloading &apos;{card_name}&apos;</source>
      <comment>Progress bar label text</comment>
      <translation>Lade '{card_name}' herunter</translation>
    </message>
  </context>
  <context>
    <name>KnownCardImageModel</name>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="132"/>
      <source>Name</source>
      <translation>Name</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="133"/>
      <source>Set</source>
      <translation>Set</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="134"/>
      <source>Collector #</source>
      <translation>Sammler #</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="135"/>
      <source>Is Hidden</source>
      <translation>Versteckt</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="136"/>
      <source>Front/Back</source>
      <translation>Vorder-/Rückseite</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="137"/>
      <source>High resolution?</source>
      <translation>Hohe Qualität?</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="138"/>
      <source>Size</source>
      <translation>Größe</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="139"/>
      <source>Scryfall ID</source>
      <translation>Scryfall ID</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="140"/>
      <source>Path</source>
      <translation>Dateipfad</translation>
    </message>
  </context>
  <context>
    <name>KnownCardRow</name>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="111"/>
      <source>Yes</source>
      <translation>Ja</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="111"/>
      <source>No</source>
      <translation>Nein</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="99"/>
      <source>This printing is hidden by an enabled card filter
and is thus unavailable for printing.</source>
      <comment>Tooltip for cells with hidden cards</comment>
      <translation>Dieser Druck wird durch einen aktivierten Kartenfilter
versteckt und ist daher nicht verfügbar.</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="105"/>
      <source>Front</source>
      <comment>Card side</comment>
      <translation>Vorderseite</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="105"/>
      <source>Back</source>
      <comment>Card side</comment>
      <translation>Rückseite</translation>
    </message>
  </context>
  <context>
    <name>LoadDocumentDialog</name>
    <message>
      <location filename="../../ui/dialogs.py" line="164"/>
      <source>Load MTGProxyPrinter document</source>
      <translation>MTGProxyPrinter-Dokument laden</translation>
    </message>
  </context>
  <context>
    <name>LoadListPage</name>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="120"/>
      <source>Supported websites:
{supported_sites}</source>
      <translation>Unterstützte Webseiten:
{supported_sites}</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="216"/>
      <source>Overwrite existing deck list?</source>
      <translation>Vorhandene Deckliste überschreiben?</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="170"/>
      <source>Selecting a file will overwrite the existing deck list. Continue?</source>
      <translation>Das Auswählen einer Datei überschreibt die vorhandene Deckliste. Fortfahren?</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="178"/>
      <source>Select deck file</source>
      <translation>Decklisten-Datei auswählen</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="188"/>
      <source>All files (*)</source>
      <translation>Alle Dateien (*)</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="199"/>
      <source>All Supported </source>
      <translation>Alle unterstützten </translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="216"/>
      <source>Downloading a deck list will overwrite the existing deck list. Continue?</source>
      <translation>Das Herunterladen einer Deckliste überschreibt die vorhandene Deckliste. Fortfahren?</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="229"/>
      <source>Download failed with HTTP error {http_error_code}.

{bad_request_msg}</source>
      <translation>Download fehlgeschlagen mit HTTP-Fehler {http_error_code}.

{bad_request_msg}</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="240"/>
      <source>Deck list download failed</source>
      <translation>Download der Deckliste fehlgeschlagen</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="235"/>
      <source>Download failed.

Check your internet connection, verify that the URL is valid, reachable, and that the deck list is set to public. This program cannot download private deck lists. If this persists, please report a bug in the issue tracker on the homepage.</source>
      <translation>Download fehlgeschlagen.

Überprüfen Sie Ihre Internetverbindung, ob die URL gültig und erreichbar ist, und dass die Deckliste öffentlich ist. Dieses Programm kann keine privaten Deck-Listen herunterladen. Falls das Problem weiterhin besteht, melden Sie bitte einen Fehler im Issue-Tracker auf der Homepage.</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="266"/>
      <source>Unable to read file content</source>
      <translation>Dateiinhalt konnte nicht gelesen werden</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="266"/>
      <source>Unable to read the content of file {file_path} as plain text.
Failed to load the content.</source>
      <translation>Kann den Inhalt der Datei {file_path} nicht als Text lesen.
Fehler beim Laden des Inhalts.</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="278"/>
      <source>Load large file?</source>
      <translation>Große Datei laden?</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="278"/>
      <source>The selected file {file_path} is unexpectedly large ({formatted_size}). Load anyway?</source>
      <translation>Die ausgewählte Datei {file_path} ist mit {formatted_size} unerwartet groß. Trotzdem laden?</translation>
    </message>
    <message>
      <location filename="../ui/deck_import_wizard/load_list_page.ui" line="17"/>
      <source>Import a deck list for printing</source>
      <translation>Deckliste zum Drucken importieren</translation>

      <source>Download deck list</source>
      <translation>Deckliste herunterladen</translation>
    </message>
  </context>
  <context>
    <name>LoadSaveDialog</name>
    <message>
      <location filename="../../ui/dialogs.py" line="121"/>
      <source>MTGProxyPrinter document (*.{default_save_suffix})</source>
      <comment>Human-readable file type name</comment>
      <translation>MTGProxyPrinter-Dokument (*.{default_save_suffix})</translation>
    </message>
  </context>
  <context>
    <name>MTGArenaParser</name>
    <message>
      <location filename="../../decklist_parser/re_parsers.py" line="201"/>
      <source>Magic Arena deck file</source>
      <translation>Magic Arena Deckliste</translation>
    </message>
  </context>
  <context>
    <name>MTGOnlineParser</name>
    <message>
      <location filename="../../decklist_parser/re_parsers.py" line="235"/>
      <source>Magic Online (MTGO) deck file</source>
      <translation>Magic Online (MTGO) Deckliste</translation>
    </message>
  </context>
  <context>
    <name>MagicWorkstationDeckDataFormatParser</name>
    <message>
      <location filename="../../decklist_parser/re_parsers.py" line="179"/>
      <source>Magic Workstation Deck Data Format</source>
      <translation>Magic Workstation Deck Data (mwDeck)</translation>
    </message>
  </context>
  <context>
    <name>MainWindow</name>
    <message>
      <location filename="../../ui/main_window.py" line="220"/>
      <source>Undo:
{top_entry}</source>
      <translation>Rückgängig:
{top_entry}</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="222"/>
      <source>Redo:
{top_entry}</source>
      <translation>Wiederholen:
{top_entry}</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="286"/>
      <source>printing</source>
      <comment>This is passed as the {action} when asking the user about compacting the document if that can save pages</comment>
      <translation>dem Drucken</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="298"/>
      <source>exporting as a PDF</source>
      <comment>This is passed as the {action} when asking the user about compacting the document if that can save pages</comment>
      <translation>dem PDF-Export</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="314"/>
      <source>Network error</source>
      <translation>Netzwerkfehler</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="314"/>
      <source>Operation failed, because a network error occurred.
Check your internet connection. Reported error message:

{message}</source>
      <translation>Vorgang fehlgeschlagen, da ein Netzwerkfehler aufgetreten ist.
Überprüfen Sie Ihre Internetverbindung. Fehlermeldung:

{message}</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="322"/>
      <source>Error</source>
      <translation>Fehler</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="322"/>
      <source>Operation failed, because an internal error occurred.
Reported error message:

{message}</source>
      <translation>Vorgang fehlgeschlagen, da ein interner Fehler aufgetreten ist.
Berichtete Fehlermeldung:

{message}</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="331"/>
      <source>Saving pages possible</source>
      <translation>Einsparen von Seiten möglich</translation>
    </message>
    <message numerus="yes">
      <location filename="../../ui/main_window.py" line="331"/>
      <source>It is possible to save %n pages when printing this document.
Do you want to compact the document now to minimize the page count prior to {action}?</source>
      <translation>
        <numerusform>Es ist möglich, %n Seite beim Drucken dieses Dokuments zu sparen.
Möchten Sie das Dokument jetzt komprimieren, um die Seitenanzahl vor {action} zu minimieren?</numerusform>
        <numerusform>Es ist möglich, %n Seiten beim Drucken dieses Dokuments zu sparen.
Möchten Sie das Dokument jetzt komprimieren, um die Seitenanzahl vor {action} zu minimieren?</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="347"/>
      <source>Download required Card data from Scryfall?</source>
      <translation>Benötigte Kartendaten von Scryfall herunterladen?</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="347"/>
      <source>This program requires downloading additional card data from Scryfall to operate the card search.
Download the required data from Scryfall now?
Without the data, you can only print custom cards by drag&amp;dropping the image files onto the main window.</source>
      <translation>Dieses Programm erfordert das Herunterladen zusätzlicher Kartendaten von Scryfall, um die Kartensuche zu ermöglichen.
Jetzt die benötigten Daten von Scryfall herunterladen?
Ohne die Daten können Sie nur nutzererstellte Karten drucken, indem Sie die Bilddateien per Drag &amp; Drop in das Hauptfenster ziehen.</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="395"/>
      <source>Document loading failed</source>
      <translation>Laden des Dokuments fehlgeschlagen</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="395"/>
      <source>Loading file &quot;{failed_path}&quot; failed. The file was not recognized as a {program_name} document. If you want to load a deck list, use the &quot;{function_text}&quot; function instead.
Reported failure reason: {reason}</source>
      <translation>Laden der Datei "{failed_path}" fehlgeschlagen. Die Datei wurde nicht als {program_name}-Dokument erkannt. Wenn Sie eine Deckliste laden möchten, verwenden Sie die "{function_text}"-Funktion stattdessen.
Berichteter Fehlergrund: {reason}</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="408"/>
      <source>Unavailable printings replaced</source>
      <translation>Nicht verfügbare Drucke ersetzt</translation>
    </message>
    <message numerus="yes">
      <location filename="../../ui/main_window.py" line="408"/>
      <source>The document contained %n unavailable printings of cards that were automatically replaced with other printings. The replaced printings are unavailable, because they match a configured card filter.</source>
      <translation>
        <numerusform>Das Dokument enthielt einen nicht verfügbaren Druck einer Karte, der automatisch durch einen anderen Druck ersetzt wurden. Der ausgetauschten Druck ist nicht verfügbar, da er mit einem konfigurierten Kartenfilter übereinstimmt.</numerusform>
        <numerusform>Das Dokument enthielt %n nicht verfügbare Drucke von Karten, die automatisch durch andere Drucke ersetzt wurden. Die ausgetauschten Drucke sind nicht verfügbar, da sie mit einem konfigurierten Kartenfilter übereinstimmen.</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="417"/>
      <source>Unrecognized cards in loaded document found</source>
      <translation>Nicht erkannte Karten im geladenen Dokument gefunden</translation>
    </message>
    <message numerus="yes">
      <location filename="../../ui/main_window.py" line="417"/>
      <source>Skipped %n unrecognized cards in the loaded document. Saving the document will remove these entries permanently.

The locally stored card data may be outdated or the document was tampered with.</source>
      <translation>
        <numerusform>Eine unbekannte Karte im geladenen Dokument übersprungen. Speichern des Dokuments wird diese dauerhaft entfernen.

Die lokalen Kartendaten sind möglicherweise veraltet oder das Dokument wurde manipuliert.</numerusform>
        <numerusform>%n unbekannte Karten im geladenen Dokument übersprungen. Speichern des Dokuments wird diese dauerhaft entfernen.

Die lokalen Kartendaten sind möglicherweise veraltet oder das Dokument wurde manipuliert.</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="427"/>
      <source>Application update available. Visit website?</source>
      <translation>Anwendungsaktualisierung verfügbar. Website besuchen?</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="427"/>
      <source>An application update is available: Version {newer_version}
You are currently using version {current_version}.

Open the {program_name} website in your web browser to download the new version?</source>
      <translation>Ein Anwendungs-Update ist verfügbar: Version {newer_version}
Sie verwenden derzeit Version {current_version}.

Die {program_name}-Webseite mit Ihrem Web-Browser besuchen, um die neue Version herunterzuladen?</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="442"/>
      <source>New card data available</source>
      <translation>Neue Kartendaten verfügbar</translation>
    </message>
    <message numerus="yes">
      <location filename="../../ui/main_window.py" line="442"/>
      <source>There are %n new printings available on Scryfall. Update the local data now?</source>
      <translation>
        <numerusform>Es ist %n neue Karte auf Scryfall verfügbar. Lokale Daten jetzt aktualisieren?</numerusform>
        <numerusform>Es sind %n neue Karten auf Scryfall verfügbar. Lokale Daten jetzt aktualisieren?</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="458"/>
      <source>Check for application updates?</source>
      <translation>Nach Anwendungsaktualisierungen suchen?</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="458"/>
      <source>Automatically check for application updates whenever you start {program_name}?</source>
      <translation>Beim Anwendungsstart automatisch nach Updates suchen?</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="470"/>
      <source>Check for card data updates?</source>
      <translation>Suche nach Kartendaten-Updates?</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="470"/>
      <source>Automatically check for card data updates on Scryfall whenever you start {program_name}?</source>
      <translation>Automatisch nach Kartenupdates auf Scryfall prüfen, wann immer Sie {program_name} starten?</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="480"/>
      <source>{question}
You can change this later in the settings.</source>
      <translation>{question}
Sie können dies später in den Einstellungen ändern.</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="14"/>
      <source>MTGProxyPrinter</source>
      <translation>MTGProxyPrinter</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="31"/>
      <source>Fi&amp;le</source>
      <translation>&amp;Datei</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="171"/>
      <source>Settings</source>
      <translation>Einstellungen</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="60"/>
      <source>Edit</source>
      <translation>Bearbeiten</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="302"/>
      <source>Show toolbar</source>
      <translation>Werkzeugleiste anzeigen</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="110"/>
      <source>&amp;Quit</source>
      <translation>&amp;Beenden</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="113"/>
      <source>Ctrl+Q</source>
      <translation>Strg+Q</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="124"/>
      <source>&amp;Print</source>
      <translation>&amp;Drucken</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="127"/>
      <source>Print the current document</source>
      <translation>Aktuelles Dokument drucken</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="130"/>
      <source>Ctrl+P</source>
      <translation>Strg+P</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="138"/>
      <source>&amp;Show print preview</source>
      <translation>Druckvorschau</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="141"/>
      <source>Show print preview window</source>
      <translation>Druckvorschau anzeigen</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="149"/>
      <source>&amp;Create PDF</source>
      <translation>PDF erzeugen</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="152"/>
      <source>Create a PDF document</source>
      <translation>Als PDF-Dokument exportieren</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="160"/>
      <source>Discard page</source>
      <translation>Seite verwerfen</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="163"/>
      <source>Discard this page.</source>
      <translation>Diese Seite verwerfen.</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="182"/>
      <source>Update card data</source>
      <translation>Kartendaten aktualisieren</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="190"/>
      <source>New Page</source>
      <translation>Neue Seite</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="193"/>
      <source>Add a new, empty page.</source>
      <translation>Neue, leere Seite hinzufügen.</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="201"/>
      <source>Save</source>
      <translation>Speichern</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="204"/>
      <source>Ctrl+S</source>
      <translation>Strg+S</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="212"/>
      <source>New</source>
      <translation>Neu</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="215"/>
      <source>Ctrl+N</source>
      <translation>Strg+N</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="223"/>
      <source>Load</source>
      <translation>Laden</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="226"/>
      <source>Ctrl+L</source>
      <translation>Strg+L</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="234"/>
      <source>Save as …</source>
      <translation>Speichern unter …</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="239"/>
      <source>About …</source>
      <translation>Über …</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="247"/>
      <source>Show Changelog</source>
      <translation>Änderungsprotokoll anzeigen</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="255"/>
      <source>Compact document</source>
      <translation>Dokument kompaktieren</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="258"/>
      <source>Minimize page count: Fill empty slots on pages by moving cards from the end of the document</source>
      <translation>Seitenzahl minimieren: Leerstellen auf Seiten durch das Verschieben von Karten vom Dokumentenende füllen</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="266"/>
      <source>Edit document settings</source>
      <translation>Einstellungen dieses Dokuments</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="269"/>
      <source>Configure page size, margins, image spacings for the currently edited document.</source>
      <translation>Einstellungen des aktuellen Dokuments, wie Papiergröße, Rand- und Bildabstände anpassen.</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="280"/>





      <source>Import a deck list from online sources</source>
      <translation>Eine Deckliste aus dem Internet importieren</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="288"/>
      <source>Cleanup card images</source>
      <translation>Kartenbilder bereinigen/löschen</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="291"/>
      <source>Delete locally stored card images you no longer need.</source>
      <translation>Nicht mehr benötigte, gespeicherte Kartenbilder löschen.</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="305"/>
      <source>Ctrl+M</source>
      <translation>Strg+M</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="313"/>
      <source>Download missing card images</source>
      <translation>Fehlende Kartenbilder herunterladen</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="321"/>
      <source>Shuffle document</source>
      <translation>Dokument mischen</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="324"/>
      <source>Randomly rearrange all card image.
If you want to quickly print a full deck for playing,
use this to reduce the initial deck shuffling required</source>
      <translation>Alle Karten zufällig neu anordnen.
Wenn Sie schnell ein komplettes Deck für das Spielen drucken möchten,
können Sie dies verwenden, um den Aufwand beim initialen Mischen zu reduzieren</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="337"/>
      <source>Undo</source>
      <translation>Rückgängig</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="348"/>
      <source>Redo</source>
      <translation>Wiederholen</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="277"/>
      <source>Import deck list</source>
      <translation>Deckliste importieren</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="356"/>
      <source>Add empty card to page</source>
      <translation>Leere Karte zur Seite hinzufügen</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="359"/>
      <source>Add an empty spacer filling a card slot</source>
      <translation>Ein Feld auf der aktuellen Seite leer halten</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="367"/>
      <source>Add custom cards</source>
      <translation>Inoffizielle Karten hinzufügen</translation>
    </message>
  </context>
  <context>
    <name>PDFSettingsPage</name>
    <message>
      <location filename="../../ui/settings_window_pages.py" line="558"/>
      <source>PDF export settings</source>
      <translation>PDF-Exporteinstellungen</translation>

    </message>
    <message>
      <location filename="../ui/settings_window/pdf_settings_page.ui" line="124"/>
      <source>Enable landscape workaround: Rotate landscape PDFs by 90°</source>
      <translation>Querformat-Workaround: Querformat-Dokumente um 90° drehen</translation>
    </message>
  </context>
  <context>
    <name>PageCardTableView</name>
    <message numerus="yes">
      <location filename="../../ui/page_card_table_view.py" line="128"/>
      <source>Add %n copies</source>
      <comment>Context menu action: Add additional card copies to the document</comment>
      <translation>
        <numerusform>Kopie hinzufügen</numerusform>
        <numerusform>%n Kopien hinzufügen</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="134"/>
      <source>Add copies …</source>
      <comment>Context menu action: Add additional card copies to the document. User will be asked for a number</comment>
      <translation>Kopien hinzufügen …</translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="121"/>
      <source>Generate DFC check card</source>
      <translation>Platzhalterkarte generieren</translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="148"/>
      <source>All related cards</source>
      <translation>Alle zugehörigen Karten</translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="156"/>
      <source>Add copies</source>
      <translation>Kopien hinzufügen</translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="156"/>
      <source>Add copies of {card_name}</source>
      <comment>Asks the user for a number. Does not need plural forms</comment>
      <translation>Kopien von {card_name} hinzufügen</translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="182"/>
      <source>Export image</source>
      <translation>Bild exportieren</translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="197"/>
      <source>Save card image</source>
      <translation>Kartenbild speichern</translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="197"/>
      <source>Images (*.png *.bmp *.jpg)</source>
      <translation>Bilder (*.png *.bmp *.jpg)</translation>
    </message>
  </context>
  <context>
    <name>PageConfigPreviewArea</name>
    <message>
      <location filename="../ui/page_config_preview_area.ui" line="36"/>
      <source> cards</source>
      <translation> Karten</translation>
    </message>

      <source>Oversized</source>
      <translation>Übergroß</translation>
    </message>
  </context>
  <context>
    <name>PageConfigWidget</name>
    <message numerus="yes">
      <location filename="../../ui/page_config_widget.py" line="101"/>
      <source>%n regular card(s)</source>
      <comment>Display of the resulting page capacity for regular-sized cards</comment>
      <translation>
        <numerusform>%n reguläre Karte</numerusform>
        <numerusform>%n reguläre Karten</numerusform>
      </translation>
    </message>
    <message numerus="yes">
      <location filename="../../ui/page_config_widget.py" line="105"/>
      <source>%n oversized card(s)</source>
      <comment>Display of the resulting page capacity for oversized cards</comment>
      <translation>
        <numerusform>%n übergroße Karte</numerusform>
        <numerusform>%n übergroße Karten</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/page_config_widget.py" line="110"/>
      <source>{regular_text}, {oversized_text}</source>
      <comment>Combination of the page capacities for regular, and oversized cards</comment>
      <translation>{regular_text}, {oversized_text}</translation>
    </message>
    <message>
      <location filename="../ui/page_config_widget.ui" line="14"/>
      <source>Default settings for new documents</source>

Zoom in: {zoom_in_shortcuts}
Zoom aus: {zoom_out_shortcuts}</translation>
    </message>
  </context>
  <context>
    <name>ParserBase</name>
    <message>
      <location filename="../../decklist_parser/common.py" line="71"/>
      <source>All files (*)</source>
      <translation>Alle Dateien (*)</translation>
    </message>
  </context>
  <context>
    <name>PrettySetListModel</name>
    <message>
      <location filename="../../model/string_list.py" line="36"/>
      <source>Set</source>
      <comment>MTG set name</comment>
      <translation>Set</translation>
    </message>
  </context>
  <context>
    <name>PrinterSettingsPage</name>
    <message>
      <location filename="../../ui/settings_window_pages.py" line="507"/>
      <source>Printer settings</source>
      <translation>Druckereinstellungen</translation>
    </message>
    <message>
      <location filename="../../ui/settings_window_pages.py" line="507"/>
      <source>Configure the printer</source>
      <translation>Drucker konfigurieren</translation>
    </message>
    <message>






























      <location filename="../ui/settings_window/printer_settings_page.ui" line="62"/>
      <source>When enabled, instruct the printer to use borderless mode and let MTGProxyPrinter manage the printing margins.
Disable this, if your printer keeps scaling print-outs up or down.

When disabled, managing the page margins is delegated to the printer driver,
which should increase compatibility, at the expense of drawing shorter cut helper lines.</source>
      <translation>Wenn diese Option aktiviert ist, wird der Drucker angewiesen, den randlosen Modus zu verwenden und MTGProxyPrinter die Verwaltung der Druckränder zu überlassen.
Deaktivieren Sie diese Option, wenn Ihr Drucker die Ausdrucke ständig hoch- oder herunterskaliert.

Wenn deaktiviert, wird die Verwaltung der Seitenränder an den Druckertreiber delegiert.
Dies sollte die Kompatibilität erhöhen, allerdings auf Kosten des Zeichnens kürzerer Hilfslinien.</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/printer_settings_page.ui" line="69"/>
      <source>Configure printer for borderless printing</source>
      <translation>Drucker auf randloses Drucken einstellen</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/printer_settings_page.ui" line="48"/>
      <source>If enabled, print landscape documents in portrait mode with all content rotated by 90°.
Enable this, if printing landscape documents results in portrait printouts with cropped-off sides.</source>
      <translation>Wenn aktiviert, werden Querformat-Dokumente stattdessen im Hochformat mit allen Inhalten um 90° gedreht ausgedruckt.
Aktivieren Sie dies, wenn das Drucken von Querformat-Dokumenten zu Ausdrucken im Hochformat mit abgeschnittenen Seiten führt.</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/printer_settings_page.ui" line="52"/>
      <source>Enable landscape workaround: Rotate prints by 90°</source>
      <translation>Querformat-Workaround: Drucke um 90° drehen</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/printer_settings_page.ui" line="17"/>
      <source>Horizontal printing offset</source>
      <translation>Horizontaler Druckversatz</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/printer_settings_page.ui" line="24"/>
      <source>Globally shifts the printing area to correct physical offsets in the printer.
Positive values shift to the right.
Negative offsets shift to the left.</source>
      <translation>Verschiebt den Druckbereich, um einen physikalischen Versatz im Drucker auszugleichen und die Zentrierung zu verbessern.
Positive Werte verschieben nach rechts, negative nach links.</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/printer_settings_page.ui" line="32"/>
      <source> mm</source>
      <translation> mm</translation>
    </message>
  </context>
  <context>
    <name>PrintingFilterUpdater.store_current_printing_filters()</name>
    <message>
      <location filename="../../printing_filter_updater.py" line="118"/>
      <source>Processing updated card filters:</source>
      <translation>Verarbeite aktualisierte Kartenfilter:</translation>
    </message>
  </context>
  <context>
    <name>SaveDocumentAsDialog</name>
    <message>
      <location filename="../../ui/dialogs.py" line="134"/>
      <source>Save document as …</source>
      <translation>Dokument speichern unter …</translation>
    </message>
  </context>
  <context>
    <name>SavePDFDialog</name>
    <message>
      <location filename="../../ui/dialogs.py" line="80"/>
      <source>Export as PDF</source>
      <translation>Als PDF exportieren</translation>
    </message>
    <message>
      <location filename="../../ui/dialogs.py" line="81"/>
      <source>PDF documents (*.pdf)</source>
      <translation>PDF-Dokument (*.pdf)</translation>
    </message>
  </context>
  <context>
    <name>ScryfallCSVParser</name>
    <message>
      <location filename="../../decklist_parser/csv_parsers.py" line="118"/>
      <source>Scryfall CSV export</source>
      <translation>Scryfall CSV-Export</translation>
    </message>
  </context>
  <context>
    <name>SelectDeckParserPage</name>
    <message>

    </message>
    <message>
      <location filename="../ui/deck_import_wizard/select_deck_parser_page.ui" line="317"/>
      <source>Magic Workstation Deck Data (mwDeck)</source>
      <translation>Magic Workstation Deck Data (mwDeck)</translation>
    </message>
  </context>
  <context>
    <name>SetEditor</name>
    <message>
      <location filename="../ui/set_editor_widget.ui" line="35"/>
      <source>Set name</source>
      <translation>Setname</translation>
    </message>
    <message>
      <location filename="../ui/set_editor_widget.ui" line="61"/>
      <source>CODE</source>
      <translation>CODE</translation>
    </message>
  </context>
  <context>
    <name>SettingsWindow</name>
    <message>
      <location filename="../../ui/settings_window.py" line="207"/>
      <source>Apply settings to the current document?</source>
      <translation>Einstellungen auf das aktuelle Dokument anwenden?</translation>
    </message>

      <location filename="../ui/settings_window/settings_window.ui" line="17"/>
      <source>Settings</source>
      <translation>Einstellungen</translation>
    </message>
  </context>
  <context>
    <name>SummaryPage</name>










    <message numerus="yes">
      <location filename="../../ui/deck_import_wizard.py" line="474"/>
      <source>Beware: The card list currently contains %n potentially oversized card(s).</source>
      <comment>Warning emitted, if at least 1 card has the oversized flag set. The Scryfall server *may* still return a regular-sized image, so not *all* printings marked as oversized are actually so when fetched.</comment>
      <translation>
        <numerusform>Achtung: Die Deckliste enthält derzeit %n potenziell übergroße Karte.</numerusform>
        <numerusform>Achtung: Die Deckliste enthält derzeit %n potenziell übergroße Karten.</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="494"/>
      <source>Replace document content with the identified cards</source>
      <translation>Dokumenteninhalt durch identifizierte Karten ersetzen</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="497"/>
      <source>Append identified cards to the document</source>
      <translation>Identifizierte Karten an das Dokument anhängen</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="533"/>
      <source>Remove basic lands</source>
      <translation>Standardländer entfernen</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="534"/>
      <source>Remove all basic lands in the deck list above</source>
      <translation>Entferne alle Standardländer in der obrigen Deckliste</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="539"/>
      <source>Remove selected</source>
      <translation>Ausgewählte entfernen</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="540"/>
      <source>Remove all selected cards in the deck list above</source>
      <translation>Entferne alle ausgewählten Karten in der obrigen Deckliste</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="437"/>
      <source>Images about to be deleted: {count}</source>
      <translation>Zu löschende Bilder: {count}</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="438"/>
      <source>Disk space that will be freed: {disk_space_freed}</source>
      <translation>Frei werdender Speicherplatz: {disk_space_freed}</translation>
    </message>
    <message>
      <location filename="../ui/cache_cleanup_wizard/summary_page.ui" line="14"/>
      <source>Summary</source>
      <translation>Überblick</translation>
    </message>
    <message>
      <location filename="../ui/deck_import_wizard/parser_result_page.ui" line="14"/>

    </message>
    <message>
      <location filename="../ui/central_widget/tabbed_vertical.ui" line="43"/>
      <source>Current page</source>
      <translation>Aktuelle Seite</translation>
    </message>
    <message>
      <location filename="../ui/central_widget/tabbed_vertical.ui" line="89"/>
      <source>Remove selected</source>
      <translation>Ausgewählte entfernen</translation>
    </message>
    <message>
      <location filename="../ui/central_widget/tabbed_vertical.ui" line="100"/>
      <source>Preview</source>
      <translation>Vorschau</translation>
    </message>
  </context>
  <context>
    <name>TappedOutCSVParser</name>
    <message>
      <location filename="../../decklist_parser/csv_parsers.py" line="197"/>
      <source>Tappedout CSV export</source>
      <translation>Tappedout CSV-Export</translation>
    </message>
  </context>
  <context>
    <name>UnknownCardImageModel</name>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="255"/>
      <source>Scryfall ID</source>
      <translation>Scryfall ID</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="256"/>
      <source>Front/Back</source>
      <translation>Vorder-/Rückseite</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="257"/>
      <source>High resolution?</source>
      <translation>Hohe Qualität?</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="258"/>
      <source>Size</source>
      <translation>Größe</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="259"/>
      <source>Path</source>
      <translation>Dateipfad</translation>
    </message>
  </context>
  <context>
    <name>UnknownCardRow</name>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="229"/>
      <source>Front</source>
      <translation>Vorderseite</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="229"/>
      <source>Back</source>
      <translation>Rückseite</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="235"/>
      <source>Yes</source>
      <translation>Ja</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="235"/>
      <source>No</source>
      <translation>Nein</translation>
    </message>
  </context>
  <context>
    <name>VerticalAddCardWidget</name>
    <message>

      <source>Copies:</source>
      <translation>Kopien:</translation>
    </message>
  </context>
  <context>
    <name>XMageParser</name>
    <message>
      <location filename="../../decklist_parser/re_parsers.py" line="257"/>
      <source>XMage Deck file</source>
      <translation>XMage Deck-Datei</translation>
    </message>
  </context>
  <context>
    <name>format_size</name>
    <message>
      <location filename="../../ui/common.py" line="138"/>
      <source>{size} {unit}</source>
      <comment>A formatted file size in SI bytes</comment>
      <translation>{size} {unit}</translation>
    </message>
  </context>
</TS>

      <source>Third party licenses</source>
      <translation>Third Party licenses</translation>
    </message>
  </context>
  <context>
    <name>ActionAddCard</name>
    <message numerus="yes">
      <location filename="../../document_controller/card_actions.py" line="161"/>
      <source>Add {count} × {card_display_string} to page {target}</source>
      <comment>Undo/redo tooltip text. Plural form refers to {target}, not {count}. {target} can be multiple ranges of multiple pages each</comment>
      <translation>
        <numerusform>Add {count} × {card_display_string} to page {target}</numerusform>
        <numerusform>Add {count} × {card_display_string} to pages {target}</numerusform>
      </translation>
    </message>
  </context>
  <context>
    <name>ActionCompactDocument</name>
    <message numerus="yes">
      <location filename="../../document_controller/compact_document.py" line="109"/>
      <source>Compact document, removing %n page(s)</source>
      <comment>Undo/redo tooltip text</comment>
      <translation>
        <numerusform>Compact document, removing %n page</numerusform>
        <numerusform>Compact document, removing %n pages</numerusform>
      </translation>
    </message>
  </context>
  <context>
    <name>ActionEditCustomCard</name>
    <message>
      <location filename="../../document_controller/edit_custom_card.py" line="85"/>
      <source>Edit custom card, set {column_header_text} to {new_value}</source>
      <comment>Undo/redo tooltip text</comment>
      <translation>Edit custom card, set {column_header_text} to {new_value}</translation>
    </message>
  </context>
  <context>
    <name>ActionEditDocumentSettings</name>
    <message>
      <location filename="../../document_controller/edit_document_settings.py" line="133"/>
      <source>Update document settings</source>
      <comment>Undo/redo tooltip text</comment>
      <translation>Update document settings</translation>

        <numerusform>Replace document with imported deck list containing %n cards</numerusform>
      </translation>
    </message>
  </context>
  <context>
    <name>ActionLoadDocument</name>
    <message numerus="yes">
      <location filename="../../document_controller/load_document.py" line="77"/>
      <source>Load document from &apos;{save_path}&apos;,
containing %n page(s) {cards_total}</source>
      <comment>Undo/redo tooltip text.</comment>
      <translation>
        <numerusform>Load document from &apos;{save_path}&apos;,
containing %n page {cards_total}</numerusform>
        <numerusform>Load document from &apos;{save_path}&apos;,
containing %n pages {cards_total}</numerusform>
      </translation>
    </message>
  </context>
  <context>
    <name>ActionLoadDocument. Card total</name>
    <message numerus="yes">
      <location filename="../../document_controller/load_document.py" line="73"/>
      <source>with %n card(s) total</source>
      <comment>Undo/redo tooltip text. Will be inserted as {cards_total}</comment>
      <translation>
        <numerusform>with %n card total</numerusform>
        <numerusform>with %n cards total</numerusform>
      </translation>
    </message>

        <numerusform>Add pages {pages}</numerusform>
      </translation>
    </message>
  </context>
  <context>
    <name>ActionRemoveCards</name>
    <message numerus="yes">
      <location filename="../../document_controller/card_actions.py" line="219"/>
      <source>Remove %n card(s) from page {page_number}</source>
      <comment>Undo/redo tooltip text</comment>
      <translation>
        <numerusform>Remove %n card from page {page_number}</numerusform>
        <numerusform>Remove %n cards from page {page_number}</numerusform>
      </translation>
    </message>

        <numerusform>Remove pages {formatted_pages} containing {formatted_card_count}</numerusform>
      </translation>
    </message>
  </context>
  <context>
    <name>ActionReplaceCard</name>
    <message>
      <location filename="../../document_controller/replace_card.py" line="99"/>
      <source>Replace card {old_card} on page {page_number} with {new_card}</source>
      <comment>Undo/redo tooltip text</comment>
      <translation>Replace card {old_card} on page {page_number} with {new_card}</translation>
    </message>
  </context>
  <context>
    <name>ActionSaveDocument</name>
    <message>
      <location filename="../../document_controller/save_document.py" line="172"/>
      <source>Save document to &apos;{save_file_path}&apos;.</source>
      <translation>Save document to &apos;{save_file_path}&apos;.</translation>
    </message>
  </context>
  <context>
    <name>ActionShuffleDocument</name>
    <message>
      <location filename="../../document_controller/shuffle_document.py" line="102"/>
      <source>Shuffle document</source>
      <comment>Undo/redo tooltip text</comment>
      <translation>Shuffle document</translation>
    </message>
  </context>
  <context>
    <name>CacheCleanupWizard</name>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="457"/>
      <source>Cleanup locally stored card images</source>
      <comment>Dialog window title</comment>
      <translation>Cleanup locally stored card images</translation>
    </message>
  </context>
  <context>
    <name>CardFilterPage</name>

      <source>Unknown images:</source>
      <translation>Unknown images:</translation>
    </message>
  </context>
  <context>
    <name>CardListModel</name>
    <message>
      <location filename="../../model/card_list.py" line="87"/>





      <source>Card name</source>
      <translation>Card name</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="88"/>
      <source>Set</source>
      <translation>Set</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="89"/>
      <source>Collector #</source>
      <translation>Collector #</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="90"/>
      <source>Language</source>
      <translation>Language</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="91"/>
      <source>Side</source>
      <translation>Side</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="128"/>
      <source>Front</source>
      <translation>Front</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="128"/>
      <source>Back</source>
      <translation>Back</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="132"/>
      <source>Beware: Potentially oversized card!
This card may not fit in your deck.</source>
      <translation>Beware: Potentially oversized card!
This card may not fit in your deck.</translation>
    </message>
    <message>
      <location filename="../../model/card_list.py" line="322"/>
      <source>Double-click on entries to
switch the selected printing.</source>
      <translation>Double-click on entries to
switch the selected printing.</translation>
    </message>



    <message>
      <location filename="../../model/card_list.py" line="86"/>
      <source>Copies</source>

      <translation>Copies</translation>



    </message>





  </context>
  <context>







    <name>CardSideSelectionDelegate</name>

    <message>
      <location filename="../../ui/item_delegates.py" line="72"/>
      <source>Front</source>
      <translation>Front</translation>
    </message>
    <message>
      <location filename="../../ui/item_delegates.py" line="73"/>






      <source>Back</source>
      <translation>Back</translation>










    </message>
  </context>
  <context>
    <name>ColumnarCentralWidget</name>
    <message>
      <location filename="../ui/central_widget/columnar.ui" line="61"/>
      <source>All pages:</source>
      <translation>All pages:</translation>
    </message>
    <message>
      <location filename="../ui/central_widget/columnar.ui" line="68"/>
      <source>Current page:</source>
      <translation>Current page:</translation>
    </message>
    <message>
      <location filename="../ui/central_widget/columnar.ui" line="78"/>
      <source>Remove selected</source>
      <translation>Remove selected</translation>
    </message>
    <message>
      <location filename="../ui/central_widget/columnar.ui" line="88"/>
      <source>Add new cards:</source>
      <translation>Add new cards:</translation>
    </message>
  </context>
  <context>
    <name>CustomCardImportDialog</name>
    <message>
      <location filename="../ui/custom_card_import_dialog.ui" line="14"/>
      <source>Import custom cards</source>
      <translation>Import custom cards</translation>
    </message>
    <message>
      <location filename="../ui/custom_card_import_dialog.ui" line="20"/>
      <source>Set Copies to …</source>
      <translation>Set Copies to …</translation>
    </message>
    <message>
      <location filename="../ui/custom_card_import_dialog.ui" line="40"/>
      <source>Remove selected</source>
      <translation>Remove selected</translation>
    </message>
    <message>
      <location filename="../ui/custom_card_import_dialog.ui" line="50"/>
      <source>Load images</source>
      <translation>Load images</translation>
    </message>
  </context>
  <context>
    <name>DatabaseImportWorker</name>
    <message>
      <location filename="../../card_info_downloader.py" line="424"/>
      <source>Error during import from file:

      <source>Open the Cutelog homepage</source>
      <translation>Open the Cutelog homepage</translation>
    </message>
  </context>
  <context>
    <name>DeckImportWizard</name>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="606"/>
      <source>Import a deck list</source>
      <translation>Import a deck list</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="628"/>
      <source>Oversized cards present</source>
      <translation>Oversized cards present</translation>
    </message>
    <message numerus="yes">
      <location filename="../../ui/deck_import_wizard.py" line="628"/>
      <source>There are %n possibly oversized cards in the deck list that may not fit into a deck, when printed out.

Continue and use these cards as-is?</source>
      <translation>
        <numerusform>There is %n possibly oversized card in the deck list that may not fit into a deck, when printed out.

Continue and use the card as-is?</numerusform>
        <numerusform>There are %n possibly oversized cards in the deck list that may not fit into a deck, when printed out.

Continue and use these cards as-is?</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="639"/>
      <source>Incompatible file selected</source>
      <translation>Incompatible file selected</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="639"/>
      <source>Unable to parse the given deck list, no results were obtained.
Maybe you selected the wrong deck list type?</source>
      <translation>Unable to parse the given deck list, no results were obtained.
Maybe you selected the wrong deck list type?</translation>
    </message>
  </context>
  <context>

      <source>Default settings for new documents</source>
      <translation>Default settings for new documents</translation>
    </message>
  </context>
  <context>
    <name>Document</name>
    <message>
      <location filename="../../model/document.py" line="91"/>
      <source>Card name</source>
      <translation>Card name</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="92"/>
      <source>Set</source>
      <translation>Set</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="93"/>
      <source>Collector #</source>
      <translation>Collector #</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="94"/>
      <source>Language</source>
      <translation>Language</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="95"/>
      <source>Image</source>
      <translation>Image</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="96"/>
      <source>Side</source>
      <translation>Side</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="174"/>
      <source>Double-click on entries to
switch the selected printing.</source>
      <translation>Double-click on entries to
switch the selected printing.</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="287"/>
      <source>Page {current}/{total}</source>
      <translation>Page {current}/{total}</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="317"/>
      <source>Front</source>
      <translation>Front</translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="317"/>
      <source>Back</source>
      <translation>Back</translation>
    </message>
    <message numerus="yes">
      <location filename="../../model/document.py" line="322"/>
      <source>%n× {name}</source>
      <comment>Used to display a card name and amount of copies in the page overview. Only needs translation for RTL language support</comment>
      <translation>
        <numerusform>%n× {name}</numerusform>
        <numerusform>%n× {name}</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../model/document.py" line="379"/>
      <source>Empty Placeholder</source>
      <translation>Empty Placeholder</translation>
    </message>
  </context>
  <context>
    <name>DocumentAction</name>
    <message>
      <location filename="../../document_controller/_interface.py" line="105"/>
      <source>{first}-{last}</source>
      <comment>Inclusive, formatted number range, from first to last</comment>
      <translation>{first}-{last}</translation>
    </message>
  </context>
  <context>
    <name>DocumentSettingsDialog</name>
    <message>
      <location filename="../../ui/dialogs.py" line="323"/>
      <source>These settings only affect the current document</source>
      <translation>These settings only affect the current document</translation>
    </message>
    <message>
      <location filename="../ui/document_settings_dialog.ui" line="6"/>
      <source>Set Document settings</source>
      <translation>Set Document settings</translation>

    </message>
    <message>
      <location filename="../ui/settings_window/general_settings_page.ui" line="51"/>
      <source>Application language</source>
      <translation>Application language</translation>
    </message>
    <message>











      <location filename="../ui/settings_window/general_settings_page.ui" line="77"/>
      <source>Double-faced cards</source>
      <translation>Double-faced cards</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/general_settings_page.ui" line="83"/>
      <source>When adding double-faced cards, automatically add the same number of copies of the other side.
Uses the appropriate, matching other card side.
Uncheck to disable this automatism.</source>
      <translation>When adding double-faced cards, automatically add the same number of copies of the other side.
Uses the appropriate, matching other card side.
Uncheck to disable this automatism.</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/general_settings_page.ui" line="88"/>
      <source>Automatically add the other side of double-faced cards</source>
      <translation>Automatically add the other side of double-faced cards</translation>
    </message>
    <message>





      <location filename="../ui/settings_window/general_settings_page.ui" line="101"/>
      <source>Preferred card language:</source>
      <translation>Preferred card language:</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/general_settings_page.ui" line="114"/>
      <source>Automatic update checks</source>

      <translation>If set, use this as the default location for saving documents.</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/general_settings_page.ui" line="195"/>
      <source>Path to a directory</source>
      <translation>Path to a directory</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/general_settings_page.ui" line="67"/>
      <source>Language choices will default to the chosen language here.
Entries use the language codes as listed on Scryfall.

Note: Cards in deck lists use the language as given by the deck list. To overwrite, use the deck list translation option.</source>
      <translation>Language choices will default to the chosen language here.
Entries use the language codes as listed on Scryfall.

Note: Cards in deck lists use the language as given by the deck list. To overwrite, use the deck list translation option.</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/general_settings_page.ui" line="98"/>
      <source>Card language selected at application start and default language when enabling deck list translations</source>
      <translation>Card language selected at application start and default language when enabling deck list translations</translation>
    </message>
  </context>
  <context>
    <name>GroupedCentralWidget</name>
    <message>
      <location filename="../ui/central_widget/grouped.ui" line="58"/>
      <source>Remove selected</source>
      <translation>Remove selected</translation>
    </message>
    <message>
      <location filename="../ui/central_widget/grouped.ui" line="103"/>
      <source>All pages:</source>
      <translation>All pages:</translation>
    </message>
    <message>
      <location filename="../ui/central_widget/grouped.ui" line="110"/>
      <source>Add new cards:</source>
      <translation>Add new cards:</translation>
    </message>
  </context>
  <context>
    <name>HidePrintingsPage</name>
    <message>

      <source>Copies:</source>
      <translation>Copies:</translation>
    </message>
  </context>
  <context>
    <name>ImageDownloader</name>
    <message>
      <location filename="../../model/imagedb.py" line="309"/>
      <source>Importing deck list</source>
      <comment>Progress bar label text</comment>
      <translation>Importing deck list</translation>
    </message>
    <message>
      <location filename="../../model/imagedb.py" line="329"/>
      <source>Fetching missing images</source>
      <comment>Progress bar label text</comment>
      <translation>Fetching missing images</translation>
    </message>
    <message>
      <location filename="../../model/imagedb.py" line="424"/>
      <source>Downloading &apos;{card_name}&apos;</source>
      <comment>Progress bar label text</comment>
      <translation>Downloading &apos;{card_name}&apos;</translation>
    </message>
  </context>
  <context>
    <name>KnownCardImageModel</name>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="132"/>
      <source>Name</source>
      <translation>Name</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="133"/>
      <source>Set</source>
      <translation>Set</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="134"/>
      <source>Collector #</source>
      <translation>Collector #</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="135"/>
      <source>Is Hidden</source>
      <translation>Is Hidden</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="136"/>
      <source>Front/Back</source>
      <translation>Front/Back</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="137"/>
      <source>High resolution?</source>
      <translation>High resolution?</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="138"/>
      <source>Size</source>
      <translation>Size</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="139"/>
      <source>Scryfall ID</source>
      <translation>Scryfall ID</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="140"/>
      <source>Path</source>
      <translation>Path</translation>
    </message>
  </context>
  <context>
    <name>KnownCardRow</name>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="111"/>
      <source>Yes</source>
      <translation>Yes</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="111"/>
      <source>No</source>
      <translation>No</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="99"/>
      <source>This printing is hidden by an enabled card filter
and is thus unavailable for printing.</source>
      <comment>Tooltip for cells with hidden cards</comment>
      <translation>This printing is hidden by an enabled card filter
and is thus unavailable for printing.</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="105"/>
      <source>Front</source>
      <comment>Card side</comment>
      <translation>Front</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="105"/>
      <source>Back</source>
      <comment>Card side</comment>
      <translation>Back</translation>
    </message>
  </context>
  <context>
    <name>LoadDocumentDialog</name>
    <message>
      <location filename="../../ui/dialogs.py" line="164"/>
      <source>Load MTGProxyPrinter document</source>
      <translation>Load MTGProxyPrinter document</translation>
    </message>
  </context>
  <context>
    <name>LoadListPage</name>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="120"/>
      <source>Supported websites:
{supported_sites}</source>
      <translation>Supported websites:
{supported_sites}</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="216"/>
      <source>Overwrite existing deck list?</source>
      <translation>Overwrite existing deck list?</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="170"/>
      <source>Selecting a file will overwrite the existing deck list. Continue?</source>
      <translation>Selecting a file will overwrite the existing deck list. Continue?</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="178"/>
      <source>Select deck file</source>
      <translation>Select deck file</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="188"/>
      <source>All files (*)</source>
      <translation>All files (*)</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="199"/>
      <source>All Supported </source>
      <translation>All Supported </translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="216"/>
      <source>Downloading a deck list will overwrite the existing deck list. Continue?</source>
      <translation>Downloading a deck list will overwrite the existing deck list. Continue?</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="229"/>
      <source>Download failed with HTTP error {http_error_code}.

{bad_request_msg}</source>
      <translation>Download failed with HTTP error {http_error_code}.

{bad_request_msg}</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="240"/>
      <source>Deck list download failed</source>
      <translation>Deck list download failed</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="235"/>
      <source>Download failed.

Check your internet connection, verify that the URL is valid, reachable, and that the deck list is set to public. This program cannot download private deck lists. If this persists, please report a bug in the issue tracker on the homepage.</source>
      <translation>Download failed.

Check your internet connection, verify that the URL is valid, reachable, and that the deck list is set to public. This program cannot download private deck lists. If this persists, please report a bug in the issue tracker on the homepage.</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="266"/>
      <source>Unable to read file content</source>
      <translation>Unable to read file content</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="266"/>
      <source>Unable to read the content of file {file_path} as plain text.
Failed to load the content.</source>
      <translation>Unable to read the content of file {file_path} as plain text.
Failed to load the content.</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="278"/>
      <source>Load large file?</source>
      <translation>Load large file?</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="278"/>
      <source>The selected file {file_path} is unexpectedly large ({formatted_size}). Load anyway?</source>
      <translation>The selected file {file_path} is unexpectedly large ({formatted_size}). Load anyway?</translation>
    </message>
    <message>
      <location filename="../ui/deck_import_wizard/load_list_page.ui" line="17"/>
      <source>Import a deck list for printing</source>
      <translation>Import a deck list for printing</translation>

      <source>Download deck list</source>
      <translation>Download deck list</translation>
    </message>
  </context>
  <context>
    <name>LoadSaveDialog</name>
    <message>
      <location filename="../../ui/dialogs.py" line="121"/>
      <source>MTGProxyPrinter document (*.{default_save_suffix})</source>
      <comment>Human-readable file type name</comment>
      <translation>MTGProxyPrinter document (*.{default_save_suffix})</translation>
    </message>
  </context>
  <context>
    <name>MTGArenaParser</name>
    <message>
      <location filename="../../decklist_parser/re_parsers.py" line="201"/>
      <source>Magic Arena deck file</source>
      <translation>Magic Arena deck file</translation>
    </message>
  </context>
  <context>
    <name>MTGOnlineParser</name>
    <message>
      <location filename="../../decklist_parser/re_parsers.py" line="235"/>
      <source>Magic Online (MTGO) deck file</source>
      <translation>Magic Online (MTGO) deck file</translation>
    </message>
  </context>
  <context>
    <name>MagicWorkstationDeckDataFormatParser</name>
    <message>
      <location filename="../../decklist_parser/re_parsers.py" line="179"/>
      <source>Magic Workstation Deck Data Format</source>
      <translation>Magic Workstation Deck Data Format</translation>
    </message>
  </context>
  <context>
    <name>MainWindow</name>
    <message>
      <location filename="../../ui/main_window.py" line="220"/>
      <source>Undo:
{top_entry}</source>
      <translation>Undo:
{top_entry}</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="222"/>
      <source>Redo:
{top_entry}</source>
      <translation>Redo:
{top_entry}</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="286"/>
      <source>printing</source>
      <comment>This is passed as the {action} when asking the user about compacting the document if that can save pages</comment>
      <translation>printing</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="298"/>
      <source>exporting as a PDF</source>
      <comment>This is passed as the {action} when asking the user about compacting the document if that can save pages</comment>
      <translation>exporting as a PDF</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="314"/>
      <source>Network error</source>
      <translation>Network error</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="314"/>
      <source>Operation failed, because a network error occurred.
Check your internet connection. Reported error message:

{message}</source>
      <translation>Operation failed, because a network error occurred.
Check your internet connection. Reported error message:

{message}</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="322"/>
      <source>Error</source>
      <translation>Error</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="322"/>
      <source>Operation failed, because an internal error occurred.
Reported error message:

{message}</source>
      <translation>Operation failed, because an internal error occurred.
Reported error message:

{message}</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="331"/>
      <source>Saving pages possible</source>
      <translation>Saving pages possible</translation>
    </message>
    <message numerus="yes">
      <location filename="../../ui/main_window.py" line="331"/>
      <source>It is possible to save %n pages when printing this document.
Do you want to compact the document now to minimize the page count prior to {action}?</source>
      <translation>
        <numerusform>It is possible to save %n page when printing this document.
Do you want to compact the document now to minimize the page count prior to {action}?</numerusform>
        <numerusform>It is possible to save %n pages when printing this document.
Do you want to compact the document now to minimize the page count prior to {action}?</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="347"/>
      <source>Download required Card data from Scryfall?</source>
      <translation>Download required Card data from Scryfall?</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="347"/>
      <source>This program requires downloading additional card data from Scryfall to operate the card search.
Download the required data from Scryfall now?
Without the data, you can only print custom cards by drag&amp;dropping the image files onto the main window.</source>
      <translation>This program requires downloading additional card data from Scryfall to operate the card search.
Download the required data from Scryfall now?
Without the data, you can only print custom cards by drag&amp;dropping the image files onto the main window.</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="395"/>
      <source>Document loading failed</source>
      <translation>Document loading failed</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="395"/>
      <source>Loading file &quot;{failed_path}&quot; failed. The file was not recognized as a {program_name} document. If you want to load a deck list, use the &quot;{function_text}&quot; function instead.
Reported failure reason: {reason}</source>
      <translation>Loading file &quot;{failed_path}&quot; failed. The file was not recognized as a {program_name} document. If you want to load a deck list, use the &quot;{function_text}&quot; function instead.
Reported failure reason: {reason}</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="408"/>
      <source>Unavailable printings replaced</source>
      <translation>Unavailable printings replaced</translation>
    </message>
    <message numerus="yes">
      <location filename="../../ui/main_window.py" line="408"/>
      <source>The document contained %n unavailable printings of cards that were automatically replaced with other printings. The replaced printings are unavailable, because they match a configured card filter.</source>
      <translation>
        <numerusform>The document contained %n unavailable printing of a card that was automatically replaced with another printing. The replaced printing is unavailable, because it matches a configured card filter.</numerusform>
        <numerusform>The document contained %n unavailable printings of cards that were automatically replaced with other printings. The replaced printings are unavailable, because they match a configured card filter.</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="417"/>
      <source>Unrecognized cards in loaded document found</source>
      <translation>Unrecognized cards in loaded document found</translation>
    </message>
    <message numerus="yes">
      <location filename="../../ui/main_window.py" line="417"/>
      <source>Skipped %n unrecognized cards in the loaded document. Saving the document will remove these entries permanently.

The locally stored card data may be outdated or the document was tampered with.</source>
      <translation>
        <numerusform>Skipped %n unrecognized card in the loaded document. Saving the document will remove this entry permanently.

The locally stored card data may be outdated or the document was tampered with.</numerusform>
        <numerusform>Skipped %n unrecognized cards in the loaded document. Saving the document will remove these entries permanently.

The locally stored card data may be outdated or the document was tampered with.</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="427"/>
      <source>Application update available. Visit website?</source>
      <translation>Application update available. Visit website?</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="427"/>
      <source>An application update is available: Version {newer_version}
You are currently using version {current_version}.

Open the {program_name} website in your web browser to download the new version?</source>
      <translation>An application update is available: Version {newer_version}
You are currently using version {current_version}.

Open the {program_name} website in your web browser to download the new version?</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="442"/>
      <source>New card data available</source>
      <translation>New card data available</translation>
    </message>
    <message numerus="yes">
      <location filename="../../ui/main_window.py" line="442"/>
      <source>There are %n new printings available on Scryfall. Update the local data now?</source>
      <translation>
        <numerusform>There is %n new printing available on Scryfall. Update the local data now?</numerusform>
        <numerusform>There are %n new printings available on Scryfall. Update the local data now?</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="458"/>
      <source>Check for application updates?</source>
      <translation>Check for application updates?</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="458"/>
      <source>Automatically check for application updates whenever you start {program_name}?</source>
      <translation>Automatically check for application updates whenever you start {program_name}?</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="470"/>
      <source>Check for card data updates?</source>
      <translation>Check for card data updates?</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="470"/>
      <source>Automatically check for card data updates on Scryfall whenever you start {program_name}?</source>
      <translation>Automatically check for card data updates on Scryfall whenever you start {program_name}?</translation>
    </message>
    <message>
      <location filename="../../ui/main_window.py" line="480"/>
      <source>{question}
You can change this later in the settings.</source>
      <translation>{question}
You can change this later in the settings.</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="14"/>
      <source>MTGProxyPrinter</source>
      <translation>MTGProxyPrinter</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="31"/>
      <source>Fi&amp;le</source>
      <translation>Fi&amp;le</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="171"/>
      <source>Settings</source>
      <translation>Settings</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="60"/>
      <source>Edit</source>
      <translation>Edit</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="302"/>
      <source>Show toolbar</source>
      <translation>Show toolbar</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="110"/>
      <source>&amp;Quit</source>
      <translation>&amp;Quit</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="113"/>
      <source>Ctrl+Q</source>
      <translation>Ctrl+Q</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="124"/>
      <source>&amp;Print</source>
      <translation>&amp;Print</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="127"/>
      <source>Print the current document</source>
      <translation>Print the current document</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="130"/>
      <source>Ctrl+P</source>
      <translation>Ctrl+P</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="138"/>
      <source>&amp;Show print preview</source>
      <translation>&amp;Show print preview</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="141"/>
      <source>Show print preview window</source>
      <translation>Show print preview window</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="149"/>
      <source>&amp;Create PDF</source>
      <translation>&amp;Create PDF</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="152"/>
      <source>Create a PDF document</source>
      <translation>Create a PDF document</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="160"/>
      <source>Discard page</source>
      <translation>Discard page</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="163"/>
      <source>Discard this page.</source>
      <translation>Discard this page.</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="182"/>
      <source>Update card data</source>
      <translation>Update card data</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="190"/>
      <source>New Page</source>
      <translation>New Page</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="193"/>
      <source>Add a new, empty page.</source>
      <translation>Add a new, empty page.</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="201"/>
      <source>Save</source>
      <translation>Save</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="204"/>
      <source>Ctrl+S</source>
      <translation>Ctrl+S</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="212"/>
      <source>New</source>
      <translation>New</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="215"/>
      <source>Ctrl+N</source>
      <translation>Ctrl+N</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="223"/>
      <source>Load</source>
      <translation>Load</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="226"/>
      <source>Ctrl+L</source>
      <translation>Ctrl+L</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="234"/>
      <source>Save as …</source>
      <translation>Save as …</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="239"/>
      <source>About …</source>
      <translation>About …</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="247"/>
      <source>Show Changelog</source>
      <translation>Show change-log</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="255"/>
      <source>Compact document</source>
      <translation>Compact document</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="258"/>
      <source>Minimize page count: Fill empty slots on pages by moving cards from the end of the document</source>
      <translation>Minimize page count: Fill empty slots on pages by moving cards from the end of the document</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="266"/>
      <source>Edit document settings</source>
      <translation>Edit document settings</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="269"/>
      <source>Configure page size, margins, image spacings for the currently edited document.</source>
      <translation>Configure page size, margins, image spacings for the currently edited document.</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="280"/>





      <source>Import a deck list from online sources</source>
      <translation>Import a deck list from online sources</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="288"/>
      <source>Cleanup card images</source>
      <translation>Cleanup card images</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="291"/>
      <source>Delete locally stored card images you no longer need.</source>
      <translation>Delete locally stored card images you no longer need.</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="305"/>
      <source>Ctrl+M</source>
      <translation>Ctrl+M</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="313"/>
      <source>Download missing card images</source>
      <translation>Download missing card images</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="321"/>
      <source>Shuffle document</source>
      <translation>Shuffle document</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="324"/>
      <source>Randomly rearrange all card image.
If you want to quickly print a full deck for playing,
use this to reduce the initial deck shuffling required</source>
      <translation>Randomly rearrange all card image.
If you want to quickly print a full deck for playing,
use this to reduce the initial deck shuffling required</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="337"/>
      <source>Undo</source>
      <translation>Undo</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="348"/>
      <source>Redo</source>
      <translation>Redo</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="277"/>
      <source>Import deck list</source>
      <translation>Import deck list</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="356"/>
      <source>Add empty card to page</source>
      <translation>Add empty card to page</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="359"/>
      <source>Add an empty spacer filling a card slot</source>
      <translation>Add an empty spacer filling a card slot</translation>
    </message>
    <message>
      <location filename="../ui/main_window.ui" line="367"/>
      <source>Add custom cards</source>
      <translation>Add custom cards</translation>
    </message>
  </context>
  <context>
    <name>PDFSettingsPage</name>
    <message>
      <location filename="../../ui/settings_window_pages.py" line="558"/>
      <source>PDF export settings</source>
      <translation>PDF export settings</translation>

    </message>
    <message>
      <location filename="../ui/settings_window/pdf_settings_page.ui" line="124"/>
      <source>Enable landscape workaround: Rotate landscape PDFs by 90°</source>
      <translation>Enable landscape workaround: Rotate landscape PDFs by 90°</translation>
    </message>
  </context>
  <context>
    <name>PageCardTableView</name>
    <message numerus="yes">
      <location filename="../../ui/page_card_table_view.py" line="128"/>
      <source>Add %n copies</source>
      <comment>Context menu action: Add additional card copies to the document</comment>
      <translation>
        <numerusform>Add copy</numerusform>
        <numerusform>Add %n copies</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="134"/>
      <source>Add copies …</source>
      <comment>Context menu action: Add additional card copies to the document. User will be asked for a number</comment>
      <translation>Add copies …</translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="121"/>
      <source>Generate DFC check card</source>
      <translation>Generate DFC check card</translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="148"/>
      <source>All related cards</source>
      <translation>All related cards</translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="156"/>
      <source>Add copies</source>
      <translation>Add copies</translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="156"/>
      <source>Add copies of {card_name}</source>
      <comment>Asks the user for a number. Does not need plural forms</comment>
      <translation>Add copies of {card_name}</translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="182"/>
      <source>Export image</source>
      <translation>Export image</translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="197"/>
      <source>Save card image</source>
      <translation>Save card image</translation>
    </message>
    <message>
      <location filename="../../ui/page_card_table_view.py" line="197"/>
      <source>Images (*.png *.bmp *.jpg)</source>
      <translation>Images (*.png *.bmp *.jpg)</translation>
    </message>
  </context>
  <context>
    <name>PageConfigPreviewArea</name>
    <message>
      <location filename="../ui/page_config_preview_area.ui" line="36"/>
      <source> cards</source>
      <translation> cards</translation>
    </message>

      <source>Oversized</source>
      <translation>Oversized</translation>
    </message>
  </context>
  <context>
    <name>PageConfigWidget</name>
    <message numerus="yes">
      <location filename="../../ui/page_config_widget.py" line="101"/>
      <source>%n regular card(s)</source>
      <comment>Display of the resulting page capacity for regular-sized cards</comment>
      <translation>
        <numerusform>%n regular card</numerusform>
        <numerusform>%n regular cards</numerusform>
      </translation>
    </message>
    <message numerus="yes">
      <location filename="../../ui/page_config_widget.py" line="105"/>
      <source>%n oversized card(s)</source>
      <comment>Display of the resulting page capacity for oversized cards</comment>
      <translation>
        <numerusform>%n oversized card</numerusform>
        <numerusform>%n oversized cards</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/page_config_widget.py" line="110"/>
      <source>{regular_text}, {oversized_text}</source>
      <comment>Combination of the page capacities for regular, and oversized cards</comment>
      <translation>{regular_text}, {oversized_text}</translation>
    </message>
    <message>
      <location filename="../ui/page_config_widget.ui" line="14"/>
      <source>Default settings for new documents</source>

Zoom in: {zoom_in_shortcuts}
Zoom out: {zoom_out_shortcuts}</translation>
    </message>
  </context>
  <context>
    <name>ParserBase</name>
    <message>
      <location filename="../../decklist_parser/common.py" line="71"/>
      <source>All files (*)</source>
      <translation>All files (*)</translation>
    </message>
  </context>
  <context>
    <name>PrettySetListModel</name>
    <message>
      <location filename="../../model/string_list.py" line="36"/>
      <source>Set</source>
      <comment>MTG set name</comment>
      <translation>Set</translation>
    </message>
  </context>
  <context>
    <name>PrinterSettingsPage</name>
    <message>
      <location filename="../../ui/settings_window_pages.py" line="507"/>
      <source>Printer settings</source>
      <translation>Printer settings</translation>
    </message>
    <message>
      <location filename="../../ui/settings_window_pages.py" line="507"/>
      <source>Configure the printer</source>
      <translation>Configure the printer</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/printer_settings_page.ui" line="62"/>
      <source>When enabled, instruct the printer to use borderless mode and let MTGProxyPrinter manage the printing margins.
Disable this, if your printer keeps scaling print-outs up or down.

When disabled, managing the page margins is delegated to the printer driver,
which should increase compatibility, at the expense of drawing shorter cut helper lines.</source>
      <translation>When enabled, instruct the printer to use borderless mode and let MTGProxyPrinter manage the printing margins.
Disable this, if your printer keeps scaling print-outs up or down.

When disabled, managing the page margins is delegated to the printer driver,
which should increase compatibility, at the expense of drawing shorter cut helper lines.</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/printer_settings_page.ui" line="69"/>
      <source>Configure printer for borderless printing</source>
      <translation>Configure printer for borderless printing</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/printer_settings_page.ui" line="48"/>
      <source>If enabled, print landscape documents in portrait mode with all content rotated by 90°.
Enable this, if printing landscape documents results in portrait printouts with cropped-off sides.</source>
      <translation>If enabled, print landscape documents in portrait mode with all content rotated by 90°.
Enable this, if printing landscape documents results in portrait printouts with cropped-off sides.</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/printer_settings_page.ui" line="52"/>
      <source>Enable landscape workaround: Rotate prints by 90°</source>
      <translation>Enable landscape workaround: Rotate prints by 90°</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/printer_settings_page.ui" line="17"/>
      <source>Horizontal printing offset</source>
      <translation>Horizontal printing offset</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/printer_settings_page.ui" line="24"/>
      <source>Globally shifts the printing area to correct physical offsets in the printer.
Positive values shift to the right.
Negative offsets shift to the left.</source>
      <translation>Globally shifts the printing area to correct physical offsets in the printer.
Positive values shift to the right.
Negative offsets shift to the left.</translation>
    </message>
    <message>
      <location filename="../ui/settings_window/printer_settings_page.ui" line="32"/>
      <source> mm</source>
      <translation> mm</translation>
    </message>






























  </context>
  <context>
    <name>PrintingFilterUpdater.store_current_printing_filters()</name>
    <message>
      <location filename="../../printing_filter_updater.py" line="118"/>
      <source>Processing updated card filters:</source>
      <translation>Processing updated card filters:</translation>
    </message>
  </context>
  <context>
    <name>SaveDocumentAsDialog</name>
    <message>
      <location filename="../../ui/dialogs.py" line="134"/>
      <source>Save document as …</source>
      <translation>Save document as …</translation>
    </message>
  </context>
  <context>
    <name>SavePDFDialog</name>
    <message>
      <location filename="../../ui/dialogs.py" line="80"/>
      <source>Export as PDF</source>
      <translation>Export as PDF</translation>
    </message>
    <message>
      <location filename="../../ui/dialogs.py" line="81"/>
      <source>PDF documents (*.pdf)</source>
      <translation>PDF documents (*.pdf)</translation>
    </message>
  </context>
  <context>
    <name>ScryfallCSVParser</name>
    <message>
      <location filename="../../decklist_parser/csv_parsers.py" line="118"/>
      <source>Scryfall CSV export</source>
      <translation>Scryfall CSV export</translation>
    </message>
  </context>
  <context>
    <name>SelectDeckParserPage</name>
    <message>

    </message>
    <message>
      <location filename="../ui/deck_import_wizard/select_deck_parser_page.ui" line="317"/>
      <source>Magic Workstation Deck Data (mwDeck)</source>
      <translation>Magic Workstation Deck Data (mwDeck)</translation>
    </message>
  </context>
  <context>
    <name>SetEditor</name>
    <message>
      <location filename="../ui/set_editor_widget.ui" line="35"/>
      <source>Set name</source>
      <translation>Set name</translation>
    </message>
    <message>
      <location filename="../ui/set_editor_widget.ui" line="61"/>
      <source>CODE</source>
      <translation>CODE</translation>
    </message>
  </context>
  <context>
    <name>SettingsWindow</name>
    <message>
      <location filename="../../ui/settings_window.py" line="207"/>
      <source>Apply settings to the current document?</source>
      <translation>Apply settings to the current document?</translation>
    </message>

      <location filename="../ui/settings_window/settings_window.ui" line="17"/>
      <source>Settings</source>
      <translation>Settings</translation>
    </message>
  </context>
  <context>
    <name>SummaryPage</name>










    <message numerus="yes">
      <location filename="../../ui/deck_import_wizard.py" line="474"/>
      <source>Beware: The card list currently contains %n potentially oversized card(s).</source>
      <comment>Warning emitted, if at least 1 card has the oversized flag set. The Scryfall server *may* still return a regular-sized image, so not *all* printings marked as oversized are actually so when fetched.</comment>
      <translation>
        <numerusform>Beware: The card list currently contains %n potentially oversized card.</numerusform>
        <numerusform>Beware: The card list currently contains %n potentially oversized cards.</numerusform>
      </translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="494"/>
      <source>Replace document content with the identified cards</source>
      <translation>Replace document content with the identified cards</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="497"/>
      <source>Append identified cards to the document</source>
      <translation>Append identified cards to the document</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="533"/>
      <source>Remove basic lands</source>
      <translation>Remove basic lands</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="534"/>
      <source>Remove all basic lands in the deck list above</source>
      <translation>Remove all basic lands in the deck list above</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="539"/>
      <source>Remove selected</source>
      <translation>Remove selected</translation>
    </message>
    <message>
      <location filename="../../ui/deck_import_wizard.py" line="540"/>
      <source>Remove all selected cards in the deck list above</source>
      <translation>Remove all selected cards in the deck list above</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="437"/>
      <source>Images about to be deleted: {count}</source>
      <translation>Images about to be deleted: {count}</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="438"/>
      <source>Disk space that will be freed: {disk_space_freed}</source>
      <translation>Disk space that will be freed: {disk_space_freed}</translation>
    </message>
    <message>
      <location filename="../ui/cache_cleanup_wizard/summary_page.ui" line="14"/>
      <source>Summary</source>
      <translation>Summary</translation>
    </message>
    <message>
      <location filename="../ui/deck_import_wizard/parser_result_page.ui" line="14"/>

    </message>
    <message>
      <location filename="../ui/central_widget/tabbed_vertical.ui" line="43"/>
      <source>Current page</source>
      <translation>Current page</translation>
    </message>
    <message>
      <location filename="../ui/central_widget/tabbed_vertical.ui" line="89"/>
      <source>Remove selected</source>
      <translation>Remove selected</translation>
    </message>
    <message>
      <location filename="../ui/central_widget/tabbed_vertical.ui" line="100"/>
      <source>Preview</source>
      <translation>Preview</translation>
    </message>
  </context>
  <context>
    <name>TappedOutCSVParser</name>
    <message>
      <location filename="../../decklist_parser/csv_parsers.py" line="197"/>
      <source>Tappedout CSV export</source>
      <translation>Tappedout CSV export</translation>
    </message>
  </context>
  <context>
    <name>UnknownCardImageModel</name>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="255"/>
      <source>Scryfall ID</source>
      <translation>Scryfall ID</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="256"/>
      <source>Front/Back</source>
      <translation>Front/Back</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="257"/>
      <source>High resolution?</source>
      <translation>High resolution?</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="258"/>
      <source>Size</source>
      <translation>Size</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="259"/>
      <source>Path</source>
      <translation>Path</translation>
    </message>
  </context>
  <context>
    <name>UnknownCardRow</name>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="229"/>
      <source>Front</source>
      <translation>Front</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="229"/>
      <source>Back</source>
      <translation>Back</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="235"/>
      <source>Yes</source>
      <translation>Yes</translation>
    </message>
    <message>
      <location filename="../../ui/cache_cleanup_wizard.py" line="235"/>
      <source>No</source>
      <translation>No</translation>
    </message>
  </context>
  <context>
    <name>VerticalAddCardWidget</name>
    <message>

      <source>Copies:</source>
      <translation>Copies:</translation>
    </message>
  </context>
  <context>
    <name>XMageParser</name>
    <message>
      <location filename="../../decklist_parser/re_parsers.py" line="257"/>
      <source>XMage Deck file</source>
      <translation>XMage Deck file</translation>
    </message>
  </context>
  <context>
    <name>format_size</name>
    <message>
      <location filename="../../ui/common.py" line="138"/>
      <source>{size} {unit}</source>
      <comment>A formatted file size in SI bytes</comment>
      <translation>{size} {unit}</translation>
    </message>
  </context>
</TS>

     </property>
     <property name="lineWidth">
      <number>0</number>
     </property>
     <property name="alternatingRowColors">
      <bool>true</bool>
     </property>



     <property name="selectionBehavior">
      <enum>QAbstractItemView::SelectRows</enum>
     </property>
     <attribute name="verticalHeaderVisible">
      <bool>false</bool>
     </attribute>
    </widget>

     </property>
     <property name="lineWidth">
      <number>0</number>
     </property>
     <property name="alternatingRowColors">
      <bool>true</bool>
     </property>



     <property name="selectionBehavior">
      <enum>QAbstractItemView::SelectRows</enum>
     </property>
     <attribute name="verticalHeaderVisible">
      <bool>false</bool>
     </attribute>
    </widget>

         </property>
         <property name="lineWidth">
          <number>0</number>
         </property>
         <property name="alternatingRowColors">
          <bool>true</bool>
         </property>



         <property name="selectionBehavior">
          <enum>QAbstractItemView::SelectRows</enum>
         </property>
         <attribute name="verticalHeaderVisible">
          <bool>false</bool>
         </attribute>
        </widget>

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>CustomCardImportDialog</class>
 <widget class="QDialog" name="CustomCardImportDialog">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>900</width>
    <height>500</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Import custom cards</string>
  </property>
  <layout class="QGridLayout" name="gridLayout">
   <item row="6" column="3">
    <widget class="QPushButton" name="set_copies_to">
     <property name="text">
      <string>Set Copies to …</string>
     </property>
     <property name="icon">
      <iconset theme="document-edit"/>
     </property>
    </widget>
   </item>
   <item row="6" column="4">
    <widget class="QSpinBox" name="card_copies">
     <property name="minimum">
      <number>1</number>
     </property>
    </widget>
   </item>
   <item row="1" column="2" rowspan="11">
    <widget class="CardListTableView" name="card_table"/>
   </item>
   <item row="3" column="3" colspan="2">
    <widget class="QPushButton" name="remove_selected">
     <property name="text">
      <string>Remove selected</string>
     </property>
     <property name="icon">
      <iconset theme="edit-delete"/>
     </property>
    </widget>
   </item>
   <item row="2" column="3" colspan="2">
    <widget class="QPushButton" name="add_cards">
     <property name="text">
      <string>Load images</string>
     </property>
     <property name="icon">
      <iconset theme="document-import"/>
     </property>
    </widget>
   </item>
   <item row="8" column="3" colspan="2">
    <widget class="QDialogButtonBox" name="button_box">
     <property name="sizePolicy">
      <sizepolicy hsizetype="Minimum" vsizetype="Maximum">
       <horstretch>0</horstretch>
       <verstretch>0</verstretch>
      </sizepolicy>
     </property>
     <property name="orientation">
      <enum>Qt::Vertical</enum>
     </property>
     <property name="standardButtons">
      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
     </property>
    </widget>
   </item>
   <item row="7" column="3">
    <spacer name="verticalSpacer">
     <property name="orientation">
      <enum>Qt::Vertical</enum>
     </property>
     <property name="sizeHint" stdset="0">
      <size>
       <width>20</width>
       <height>40</height>
      </size>
     </property>
    </spacer>
   </item>
  </layout>
 </widget>
 <customwidgets>
  <customwidget>
   <class>CardListTableView</class>
   <extends>QTableView</extends>
   <header>mtg_proxy_printer.ui.card_list_table_view</header>
  </customwidget>
 </customwidgets>
 <resources/>
 <connections>
  <connection>
   <sender>button_box</sender>
   <signal>accepted()</signal>
   <receiver>CustomCardImportDialog</receiver>
   <slot>accept()</slot>
   <hints>
    <hint type="sourcelabel">
     <x>248</x>
     <y>254</y>
    </hint>
    <hint type="destinationlabel">
     <x>157</x>
     <y>274</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>button_box</sender>
   <signal>rejected()</signal>
   <receiver>CustomCardImportDialog</receiver>
   <slot>reject()</slot>
   <hints>
    <hint type="sourcelabel">
     <x>316</x>
     <y>260</y>
    </hint>
    <hint type="destinationlabel">
     <x>286</x>
     <y>274</y>
    </hint>
   </hints>
  </connection>
 </connections>
</ui>

    <widget class="QLabel" name="parsed_cards_label">
     <property name="text">
      <string>These cards were successfully identified:</string>
     </property>
    </widget>
   </item>
   <item>
    <widget class="CardListTableView" name="parsed_cards_table">
     <property name="sizePolicy">
      <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
       <horstretch>0</horstretch>
       <verstretch>65</verstretch>
      </sizepolicy>
     </property>
     <property name="sizeAdjustPolicy">

     <property name="openLinks">
      <bool>false</bool>
     </property>
    </widget>
   </item>
  </layout>
 </widget>
 <customwidgets>
  <customwidget>
   <class>CardListTableView</class>
   <extends>QTableView</extends>
   <header>mtg_proxy_printer.ui.card_list_table_view</header>
  </customwidget>
 </customwidgets>
 <resources/>
 <connections/>
</ui>

  <widget class="CentralWidget" name="central_widget"/>
  <widget class="QMenuBar" name="menubar">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>1050</width>
     <height>28</height>
    </rect>
   </property>
   <widget class="QMenu" name="menu_file">
    <property name="title">
     <string>Fi&amp;le</string>
    </property>
    <addaction name="action_new_document"/>
    <addaction name="action_load_document"/>
    <addaction name="action_save_document"/>
    <addaction name="action_save_as"/>
    <addaction name="action_print_preview"/>
    <addaction name="action_print"/>
    <addaction name="action_print_pdf"/>
    <addaction name="separator"/>
    <addaction name="action_import_deck_list"/>
    <addaction name="action_add_custom_cards"/>
    <addaction name="separator"/>
    <addaction name="action_quit"/>
   </widget>
   <widget class="QMenu" name="menu_settings">
    <property name="title">
     <string>Settings</string>
    </property>

   </property>
  </action>
  <action name="action_import_deck_list">
   <property name="icon">
    <iconset theme="document-import"/>
   </property>
   <property name="text">
    <string>Import deck list</string>
   </property>
   <property name="toolTip">
    <string>Import a deck list from online sources</string>
   </property>
  </action>
  <action name="action_cleanup_local_image_cache">
   <property name="icon">

   </property>
   <property name="text">
    <string>Add empty card to page</string>
   </property>
   <property name="toolTip">
    <string>Add an empty spacer filling a card slot</string>
   </property>
  </action>
  <action name="action_add_custom_cards">
   <property name="icon">
    <iconset theme="list-add"/>
   </property>
   <property name="text">
    <string>Add custom cards</string>
   </property>
  </action>
 </widget>
 <customwidgets>
  <customwidget>
   <class>CentralWidget</class>
   <extends>QWidget</extends>
   <header>mtg_proxy_printer.ui.central_widget</header>

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>SetEditor</class>
 <widget class="QWidget" name="SetEditor">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>280</width>
    <height>36</height>
   </rect>
  </property>
  <layout class="QHBoxLayout" name="horizontal_layout">
   <property name="spacing">
    <number>0</number>
   </property>
   <property name="leftMargin">
    <number>0</number>
   </property>
   <property name="topMargin">
    <number>0</number>
   </property>
   <property name="rightMargin">
    <number>0</number>
   </property>
   <item>
    <widget class="QLineEdit" name="name_editor">
     <property name="sizePolicy">
      <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
       <horstretch>15</horstretch>
       <verstretch>0</verstretch>
      </sizepolicy>
     </property>
     <property name="placeholderText">
      <string>Set name</string>
     </property>
    </widget>
   </item>
   <item>
    <widget class="QLabel" name="opening_parenthesis">
     <property name="text">
      <string notr="true">(</string>
     </property>
    </widget>
   </item>
   <item>
    <widget class="QLineEdit" name="code_edit">
     <property name="sizePolicy">
      <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
       <horstretch>7</horstretch>
       <verstretch>0</verstretch>
      </sizepolicy>
     </property>
     <property name="inputMethodHints">
      <set>Qt::ImhUppercaseOnly</set>
     </property>
     <property name="maxLength">
      <number>6</number>
     </property>
     <property name="placeholderText">
      <string>CODE</string>
     </property>
    </widget>
   </item>
   <item>
    <widget class="QLabel" name="closing_parenthesis">
     <property name="text">
      <string notr="true">)</string>
     </property>
    </widget>
   </item>
  </layout>
 </widget>
 <tabstops>
  <tabstop>name_editor</tabstop>
  <tabstop>code_edit</tabstop>
 </tabstops>
 <resources/>
 <connections/>
</ui>

          card_id TEXT NOT NULL PRIMARY KEY CHECK (card_id GLOB '[a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9]-[a-f0-9][a-f0-9][a-f0-9][a-f0-9]-[a-f0-9][a-f0-9][a-f0-9][a-f0-9]-[a-f0-9][a-f0-9][a-f0-9][a-f0-9]-[a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9]'),
          image BLOB NOT NULL,  -- The raw image content
          name TEXT NOT NULL DEFAULT '',
          set_name TEXT NOT NULL DEFAULT '',
          set_code TEXT NOT NULL DEFAULT '',
          collector_number TEXT NOT NULL DEFAULT '',
          is_front BOOLEAN_INTEGER NOT NULL CHECK (is_front IN (TRUE, FALSE)) DEFAULT TRUE,

          other_face TEXT REFERENCES CustomCardData(card_id)  -- If this is a DFC, this references the other side
        )"""),
        "ALTER TABLE Card RENAME TO Card_old",
        textwrap.dedent("""\
        CREATE TABLE Page (
          page INTEGER NOT NULL PRIMARY KEY CHECK (page > 0),
          image_size TEXT NOT NULL CHECK(image_size <> '')

import re
import sqlite3
import sys
import textwrap
import typing

from hamcrest import assert_that, contains_exactly


from mtg_proxy_printer.units_and_sizes import unit_registry
from mtg_proxy_printer.logger import get_logger
logger = get_logger(__name__)
del get_logger

__all__ = [

from typing import Union, Type, Optional

from PyQt5.QtCore import QStringListModel, pyqtSlot as Slot, pyqtSignal as Signal, Qt, QItemSelectionModel, QItemSelection
from PyQt5.QtWidgets import QWidget, QDialogButtonBox
from PyQt5.QtGui import QIcon

import mtg_proxy_printer.model.card
from mtg_proxy_printer.document_controller.card_actions import ActionAddCard
import mtg_proxy_printer.model.string_list
import mtg_proxy_printer.model.carddb
import mtg_proxy_printer.model.document
import mtg_proxy_printer.settings
from mtg_proxy_printer.model.card import MTGSet
from mtg_proxy_printer.ui.common import load_ui_from_file

from mtg_proxy_printer.logger import get_logger
logger = get_logger(__name__)
del get_logger

try:

            self.ui.collector_number_list.selectionModel().clearSelection()
            return
        logger.debug("Currently selected set changed.")
        current_model_index = current.indexes()[0]
        valid = current_model_index.isValid()
        self.ui.collector_number_box.setEnabled(valid)
        if valid:
            mtg_set: MTGSet = current_model_index.data(ItemDataRole.EditRole)
            collector_numbers = self.card_database.find_collector_numbers_matching(
                self.current_card_name, mtg_set.code, self.current_language
            )
            logger.debug(
                f'Selected: "{mtg_set.code}", language: {self.current_language}, matching {len(collector_numbers)} prints')
            self.collector_number_model.setStringList(collector_numbers)
            self.ui.collector_number_list.selectionModel().select(
                self.collector_number_model.createIndex(0, 0), QItemSelectionModel.ClearAndSelect)

    @Slot(QItemSelection)
    def collector_number_list_selection_changed(self, current: QItemSelection):
        self.ui.button_box.button(StandardButton.Ok).setEnabled(bool(current.indexes()))

        if add_opposing_faces_enabled and (opposing_face := self.card_database.get_opposing_face(card)) is not None:
            logger.info(
                "Card is double faced and adding opposing faces is enabled, automatically adding the other face.")
            self._log_added_card(opposing_face, copies)
            self.request_action.emit(ActionAddCard(opposing_face, copies))

    @staticmethod
    def _log_added_card(card: mtg_proxy_printer.model.card.Card, copies: int):
        logger.debug(f"Adding {copies}× [{card.set.code.upper()}:{card.collector_number}] {card.name}")

    @Slot()
    def reset(self):
        logger.info("User hit the Reset button, resetting…")
        self.ui.collector_number_list.clearSelection()
        self.collector_number_model.setStringList([])

        else:
            return None

    @property
    def current_set_name(self) -> Optional[str]:
        selected = self.ui.set_name_list.selectedIndexes()
        if selected:
            return selected[0].data(ItemDataRole.EditRole).code
        else:
            return None

    @property
    def current_collector_number(self) -> Optional[str]:
        selected = self.ui.collector_number_list.selectedIndexes()
        if selected:

#  You should have received a copy of the GNU General Public License
#  along with this program. If not, see <http://www.gnu.org/licenses/>.


import dataclasses
import datetime
import enum

import math
import pathlib
import typing

from PyQt5.QtCore import QAbstractTableModel, Qt, QModelIndex, QObject, QItemSelectionModel, QSize
from PyQt5.QtGui import QIcon
from PyQt5.QtWidgets import QWidget, QWizard, QWizardPage

import mtg_proxy_printer.settings
from mtg_proxy_printer.natsort import NaturallySortedSortFilterProxyModel
from mtg_proxy_printer.model.carddb import CardDatabase
from mtg_proxy_printer.model.card import MTGSet, Card
from mtg_proxy_printer.model.imagedb import ImageDatabase
from mtg_proxy_printer.model.imagedb_files import CacheContent as ImageCacheContent, ImageKey
from mtg_proxy_printer.ui.common import load_ui_from_file, format_size, WizardBase, get_card_image_tooltip
from mtg_proxy_printer.units_and_sizes import OptStr
from mtg_proxy_printer.logger import get_logger
logger = get_logger(__name__)
del get_logger

try:
    from mtg_proxy_printer.ui.generated.cache_cleanup_wizard.card_filter_page import Ui_CardFilterPage

    "CacheCleanupWizard",
]
INVALID_INDEX = QModelIndex()
SelectRows = QItemSelectionModel.SelectionFlag.Select | QItemSelectionModel.SelectionFlag.Rows
ItemDataRole = Qt.ItemDataRole
Orientation = Qt.Orientation


















class KnownCardColumns(enum.IntEnum):
    Name = 0
    Set = enum.auto()
    CollectorNumber = enum.auto()
    IsHidden = enum.auto()
    IsFront = enum.auto()

    def __post_init__(self):
        super().__init__(self._parent)  # Call QObject.__init__() without interfering with the dataclass internals

    def data(self, column: int, role: ItemDataRole):
        if column == KnownCardColumns.Name and role in (ItemDataRole.DisplayRole, ItemDataRole.EditRole):
            data = self.name
        elif column == KnownCardColumns.Name and role == ItemDataRole.ToolTipRole:
            data = get_card_image_tooltip(self.path, self.preferred_language_name)
        elif column == KnownCardColumns.Set:
            data = self.set.data(role)
        elif column == KnownCardColumns.CollectorNumber and role in (ItemDataRole.DisplayRole, ItemDataRole.EditRole):
            data = self.collector_number
        elif column == KnownCardColumns.IsHidden and role == ItemDataRole.DisplayRole:
            data = self.tr("Yes") if self.is_hidden else self.tr("No")
        elif column == KnownCardColumns.IsHidden and role == ItemDataRole.ToolTipRole and self.is_hidden:

            image.absolute_path.stat().st_size, image.absolute_path
        )

    def data(self, column: int, role: ItemDataRole):
        if column == UnknownCardColumns.ScryfallId and role in (ItemDataRole.DisplayRole, ItemDataRole.EditRole):
            data = self.scryfall_id
        elif column == UnknownCardColumns.ScryfallId and role == ItemDataRole.ToolTipRole:
            data = get_card_image_tooltip(self.path)
        elif column == UnknownCardColumns.IsFront and role == ItemDataRole.DisplayRole:
            data = self.tr("Front") if self.is_front else self.tr("Back")
        elif column == UnknownCardColumns.IsFront and role == ItemDataRole.EditRole:
            data = self.is_front
        elif column == UnknownCardColumns.HasHighResolution and role == ItemDataRole.EditRole:
            data = self.has_high_resolution
        elif column == UnknownCardColumns.HasHighResolution and role == ItemDataRole.DisplayRole:

    def reject(self) -> None:
        super().reject()
        logger.info("User canceled the cache cleanup.")
        self._clear_tooltip_cache()

    @staticmethod
    def _clear_tooltip_cache():
        logger.debug(f"Tooltip cache efficiency: {get_card_image_tooltip.cache_info()}")
        # Free memory by clearing the cached, base64 encoded PNGs used for tooltip display
        get_card_image_tooltip.cache_clear()

#  Copyright © 2020-2025  Thomas Hess <thomas.hess@udo.edu>
#
#  This program is free software: you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation, either version 3 of the License, or
#  (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program. If not, see <http://www.gnu.org/licenses/>.

import math

from PyQt5.QtCore import Qt, pyqtSignal as Signal, pyqtSlot as Slot
from PyQt5.QtWidgets import QTableView, QWidget

from mtg_proxy_printer.model.card_list import CardListColumns, CardListModel
from mtg_proxy_printer.natsort import NaturallySortedSortFilterProxyModel
from mtg_proxy_printer.ui.item_delegates import CollectorNumberEditorDelegate, BoundedCopiesSpinboxDelegate, \
    CardSideSelectionDelegate, SetEditorDelegate, LanguageEditorDelegate

from mtg_proxy_printer.logger import get_logger
logger = get_logger(__name__)
del get_logger
ItemDataRole = Qt.ItemDataRole


class CardListTableView(QTableView):
    """
    This table view shows a CardListModel, and sets up all item delegates used for proper display and validation.

    """
    changed_selection_is_empty = Signal(bool)

    def __init__(self, parent: QWidget = None):
        super().__init__(parent)
        self._column_delegates = (
            self._setup_combo_box_item_delegate(),
            self._setup_language_delegate(),
            self._setup_copies_delegate(),
            self._setup_side_delegate(),
            self._setup_set_delegate(),
        )
        self.sort_model = NaturallySortedSortFilterProxyModel(self)

    def setModel(self, model: CardListModel):
        self.sort_model.setSourceModel(model)
        super().setModel(self.sort_model)
        # Has to be set up here, because setModel() implicitly creates the QItemSelectionModel
        self.selectionModel().selectionChanged.connect(self._on_selection_changed)
        # Now that the model is set and columns are discovered, set the column widths to reasonable values.
        self._setup_default_column_widths()

    @Slot()
    def _on_selection_changed(self):
        selection = self.selectionModel().selection()
        is_empty = selection.isEmpty()
        logger.debug(f"Selection changed: Currently selected cells: {selection.count()}")
        self.changed_selection_is_empty.emit(is_empty)

    def _setup_language_delegate(self):
        delegate = LanguageEditorDelegate(self)
        self.setItemDelegateForColumn(CardListColumns.Language, delegate)
        return delegate

    def _setup_combo_box_item_delegate(self) -> CollectorNumberEditorDelegate:
        delegate = CollectorNumberEditorDelegate(self)
        self.setItemDelegateForColumn(CardListColumns.CollectorNumber, delegate)
        return delegate

    def _setup_copies_delegate(self) -> BoundedCopiesSpinboxDelegate:
        delegate = BoundedCopiesSpinboxDelegate(self)
        self.setItemDelegateForColumn(CardListColumns.Copies, delegate)
        return delegate

    def _setup_side_delegate(self) -> CardSideSelectionDelegate:
        delegate = CardSideSelectionDelegate(self)
        self.setItemDelegateForColumn(CardListColumns.IsFront, delegate)
        return delegate

    def _setup_set_delegate(self) -> SetEditorDelegate:
        delegate = SetEditorDelegate(self)
        self.setItemDelegateForColumn(CardListColumns.Set, delegate)
        return delegate

    def _setup_default_column_widths(self):
        # These factors are empirically determined to give reasonable column sizes
        for column, scaling_factor in (
                (CardListColumns.Copies, 0.9),
                (CardListColumns.CardName, 2),
                (CardListColumns.Set, 2.75),
                (CardListColumns.CollectorNumber, 0.95),
                (CardListColumns.Language, 0.9)):
            new_size = math.floor(self.columnWidth(column) * scaling_factor)
            self.setColumnWidth(column, new_size)

#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program. If not, see <http://www.gnu.org/licenses/>.

import functools
from pathlib import Path
import platform
from typing import Union, Dict

from PyQt5.QtCore import QFile, QUrl, QObject, QSize, QCoreApplication, Qt, QBuffer, QIODevice
from PyQt5.QtWidgets import QLabel, QWizard, QWidget, QGraphicsColorizeEffect, QTextEdit
from PyQt5.QtGui import QIcon, QPixmap
# noinspection PyUnresolvedReferences
from PyQt5 import uic

from mtg_proxy_printer.units_and_sizes import OptStr
from mtg_proxy_printer.logger import get_logger
logger = get_logger(__name__)
del get_logger

__all__ = [
    "RESOURCE_PATH_PREFIX",
    "ICON_PATH_PREFIX",
    "HAS_COMPILED_RESOURCES",
    "highlight_widget",
    "BlockedSignals",

    "load_ui_from_file",
    "format_size",
    "WizardBase",
    "get_card_image_tooltip",
]

try:
    import mtg_proxy_printer.ui.compiled_resources
except ModuleNotFoundError:
    RESOURCE_PATH_PREFIX = str(Path(__file__).resolve().parent.with_name("resources"))
    ICON_PATH_PREFIX = str(Path(__file__).resolve().parent.with_name("resources") / "icons")
    HAS_COMPILED_RESOURCES = False
else:
    import atexit
    # Compiled resources found, so use it.
    RESOURCE_PATH_PREFIX = ":"
    ICON_PATH_PREFIX = ":/icons"
    HAS_COMPILED_RESOURCES = True
    atexit.register(mtg_proxy_printer.ui.compiled_resources.qCleanupResources)


@functools.lru_cache(maxsize=256)
def get_card_image_tooltip(image: Union[bytes, Path], card_name: OptStr = None, scaling_factor: int = 3) -> str:
    """
    Returns a tooltip string showing a scaled down image for the given path.
    :param image: Filesystem path to the image file or raw image content as bytes
    :param card_name: Optional card name. If given, it is centered above the image
    :param scaling_factor: Scales the source by factor to 1/scaling_factor
    :return: HTML fragment with the image embedded as a base64 encoded PNG
    """
    if isinstance(image, bytes):
        source = QPixmap()
        source.loadFromData(image)
    else:
        source = QPixmap(str(image))
    pixmap = source.scaledToWidth(source.width() // scaling_factor, Qt.TransformationMode.SmoothTransformation)
    buffer = QBuffer()
    buffer.open(QIODevice.OpenModeFlag.WriteOnly)
    pixmap.save(buffer, "PNG", quality=100)
    image = buffer.data().toBase64().data().decode()
    card_name = f'<p style="text-align:center">{card_name}</p><br>' if card_name else ""
    return f'{card_name}<img src="data:image/png;base64,{image}">'


def highlight_widget(widget: QWidget) -> None:
    """Sets a visual highlight on the given widget to make it stand out"""
    palette = widget.palette()
    highlight_color = palette.color(palette.currentColorGroup(), palette.ColorRole.Highlight)
    effect = QGraphicsColorizeEffect(widget)
    effect.setColor(highlight_color)

    def __enter__(self):
        self.qt_object.blockSignals(True)

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.qt_object.blockSignals(False)















def load_ui_from_file(name: str):
    """
    Returns the Ui class type from uic.loadUiType(), loading the ui file with the given name.

    :param name: Path to the UI file
    :return: class implementing the requested Ui

            return template.format(size=f"{size:3.2f}", unit=unit)
        size /= 1024
    return template.format(size=f"{size:.2f}", unit="YiB")


class WizardBase(QWizard):
    """Base class for wizards based on QWizard"""
    BUTTON_ICONS: Dict[QWizard.WizardButton, str] = {}

    def __init__(self, window_size: QSize, parent: QWidget, flags):
        super().__init__(parent, flags)
        if platform.system() == "Windows":
            # Avoid Aero style on Windows, which does not support dark mode
            target_style = QWizard.WizardStyle.ModernStyle
            logger.debug(f"Creating a QWizard on Windows, explicitly setting style to {target_style}")

# Copyright (C) 2020-2024 Thomas Hess <thomas.hess@udo.edu>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.

from collections import Counter
from pathlib import Path
import typing

from PyQt5.QtCore import Qt, pyqtSignal as Signal, pyqtSlot as Slot
from PyQt5.QtGui import QDragEnterEvent, QDropEvent, QPixmap
from PyQt5.QtWidgets import QDialog, QWidget, QFileDialog, QPushButton

from mtg_proxy_printer.document_controller import DocumentAction
from mtg_proxy_printer.document_controller.import_deck_list import ActionImportDeckList
from mtg_proxy_printer.model.card import CustomCard
from mtg_proxy_printer.model.document import Document
from mtg_proxy_printer.units_and_sizes import CardSizes

try:
    from mtg_proxy_printer.ui.generated.custom_card_import_dialog import Ui_CustomCardImportDialog
except ModuleNotFoundError:
    from mtg_proxy_printer.ui.common import load_ui_from_file
    Ui_CustomCardImportDialog = load_ui_from_file("custom_card_import_dialog")

from mtg_proxy_printer.model.card_list import CardListModel
import mtg_proxy_printer.units_and_sizes
from mtg_proxy_printer.app_dirs import data_directories
from mtg_proxy_printer.logger import get_logger
logger = get_logger(__name__)
del get_logger
TransformationMode = Qt.TransformationMode
EventTypes = typing.Union[QDragEnterEvent, QDropEvent]


class CustomCardImportDialog(QDialog):

    request_action = Signal(DocumentAction)

    def __init__(self, document: Document, parent: QWidget = None, flags=Qt.WindowFlags()):
        super().__init__(parent, flags)
        self.ui = ui = Ui_CustomCardImportDialog()
        ui.setupUi(self)
        self.ok_button.setEnabled(False)
        ui.remove_selected.setDisabled(True)
        self.model = model = CardListModel(document)
        model.request_action.connect(self.request_action)
        ui.card_table.setModel(model)
        ui.card_table.selectionModel().selectionChanged.connect(self.on_card_table_selection_changed)
        model.rowsInserted.connect(self.on_rows_inserted)
        model.rowsRemoved.connect(self.on_rows_removed)
        model.modelReset.connect(self.on_rows_removed)
        logger.info(f"Created {self.__class__.__name__} instance")

    @property
    def currently_selected_cards(self):
        return self.ui.card_table.selectionModel().selection()

    @property
    def ok_button(self) -> QPushButton:
        return self.ui.button_box.button(self.ui.button_box.StandardButton.Ok)

    @staticmethod
    def dragdrop_acceptable(event: EventTypes) -> bool:
        urls = event.mimeData().urls()
        local_paths = [Path(url.toLocalFile()) for url in urls]
        acceptable = local_paths and all((path.is_file() for path in local_paths))
        return acceptable

    @Slot()
    def on_card_table_selection_changed(self):
        cards_selected = self.currently_selected_cards.isEmpty()
        self.ui.remove_selected.setDisabled(cards_selected)

    @Slot()
    def on_rows_inserted(self):
        self.ok_button.setEnabled(True)

    @Slot()
    def on_rows_removed(self):
        has_cards = bool(self.model.rowCount())
        self.ok_button.setEnabled(has_cards)

    @Slot()
    def on_add_cards_clicked(self):
        logger.info("User about to add additional card images")
        default_path = getattr(data_directories, "user_pictures_dir", str(Path.home()))
        files, _ = QFileDialog.getOpenFileNames(self, self.tr("Import custom cards"), default_path)
        logger.debug(f"User selected {len(files)} paths")
        file_paths = list(map(Path, files))
        cards = self.create_cards(file_paths)
        self.model.add_cards(cards)
        logger.info(f"Added {len(cards)} cards from the selected files.")

    @Slot()
    def on_remove_selected_clicked(self):
        logger.info("User about to delete all selected cards from the card table")
        self.model.remove_multi_selection(self.currently_selected_cards)

    @Slot()
    def on_set_copies_to_clicked(self):
        value = self.ui.card_copies.value()
        selection = self.currently_selected_cards
        self.model.set_copies_to(selection, value)
        scope = "All" if selection.isEmpty() else "Selected"
        logger.info(f"{scope} copy counts set to {value}")

    def show_from_drop_event(self, event: QDropEvent):
        urls = event.mimeData().urls()
        local_paths = [Path(url.toLocalFile()) for url in urls]
        cards = self.create_cards(local_paths)
        self.model.add_cards(cards)
        self.show()

    def create_cards(self, paths: typing.List[Path]) -> typing.Counter[CustomCard]:
        result: typing.Counter[CustomCard] = Counter()
        regular = mtg_proxy_printer.units_and_sizes.CardSizes.REGULAR
        card_db = self.model.card_db
        for path in paths:
            if not QPixmap(str(path)).isNull():
                # This read should stay guarded by the Pixmap constructor to prevent accidental DoS by reading huge files
                pixmap_bytes = path.read_bytes()
                card = card_db.get_custom_card(
                    path.stem, "" , "", "", regular, True, pixmap_bytes)
                result[card] += 1
        return result

    def accept(self):
        action = ActionImportDeckList(self.model.as_cards(), False)
        self.request_action.emit(action)
        super().accept()

#
#  You should have received a copy of the GNU General Public License
#  along with this program. If not, see <http://www.gnu.org/licenses/>.



import itertools

import pathlib
import re
import typing
import urllib.error
import urllib.parse

from PyQt5.QtCore import pyqtSlot as Slot, pyqtSignal as Signal, pyqtProperty as Property, QStringListModel, Qt, \
    QSize, QUrl
from PyQt5.QtGui import QValidator, QIcon, QDesktopServices
from PyQt5.QtWidgets import QWizard, QFileDialog, QMessageBox, QWizardPage, QWidget, QRadioButton

from mtg_proxy_printer.model.document import Document
from mtg_proxy_printer.units_and_sizes import SectionProxy
import mtg_proxy_printer.settings
from mtg_proxy_printer.decklist_parser import re_parsers, common, csv_parsers
from mtg_proxy_printer.decklist_downloader import IsIdentifyingDeckUrlValidator, AVAILABLE_DOWNLOADERS, \
    get_downloader_class, ParserBase
from mtg_proxy_printer.model.carddb import CardDatabase
from mtg_proxy_printer.model.imagedb import ImageDatabase
from mtg_proxy_printer.model.card_list import CardListModel
from mtg_proxy_printer.natsort import NaturallySortedSortFilterProxyModel
from mtg_proxy_printer.ui.common import load_ui_from_file, format_size, WizardBase, markdown_to_html

from mtg_proxy_printer.document_controller.import_deck_list import ActionImportDeckList

try:
    from mtg_proxy_printer.ui.generated.deck_import_wizard.load_list_page import Ui_LoadListPage
    from mtg_proxy_printer.ui.generated.deck_import_wizard.parser_result_page import Ui_SummaryPage
    from mtg_proxy_printer.ui.generated.deck_import_wizard.select_deck_parser_page import Ui_SelectDeckParserPage
except ModuleNotFoundError:

        self.setField("selected_parser", parser)

    @selected_parser.getter
    def selected_parser(self) -> common.ParserBase:
        logger.debug(f"Reading selected parser {self._selected_parser.__class__.__name__}")
        return self._selected_parser

    def __init__(self, document: Document, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.ui = Ui_SelectDeckParserPage()
        self.ui.setupUi(self)
        self.card_db = document.card_db
        self.image_db = document.image_db
        self._selected_parser = None
        self.parser_creator: typing.Callable[[], None] = (lambda: None)
        group_names = ', '.join(sorted(re_parsers.GenericRegularExpressionDeckParser.SUPPORTED_GROUP_NAMES))
        custom_re_input = self.ui.custom_re_input
        custom_re_input.setToolTip(custom_re_input.toolTip().format(group_names=group_names))
        custom_re_input.setWhatsThis(markdown_to_html(custom_re_input.whatsThis()))
        custom_re_input.setValidator(IsDecklistParserRegularExpressionValidator(self))

        # here.
        self.selected_parser.incompatible_file_format.connect(self.wizard().on_incompatible_deck_file_selected)
        logger.info(f"Created parser: {self.selected_parser.__class__.__name__}")
        return self.isComplete()


class SummaryPage(QWizardPage):

    # Give the generic enum constants a semantic name
    BasicLandRemovalOption = WizardOption.HaveCustomButton1
    BasicLandRemovalButton = WizardButton.CustomButton1
    SelectedRemovalOption = WizardOption.HaveCustomButton2
    SelectedRemovalButton = WizardButton.CustomButton2

    def __init__(self, document: Document, *args, **kwargs):

        super().__init__(*args, **kwargs)
        self.ui = ui = Ui_SummaryPage()
        ui.setupUi(self)
        self.setCommitPage(True)
        self.card_list = CardListModel(document, self)

        self.card_list.oversized_card_count_changed.connect(self._update_accept_button_on_oversized_card_count_changed)
        ui.parsed_cards_table.setModel(self.card_list)


        self.registerField("should_replace_document", self.ui.should_replace_document)
        ui.should_replace_document.toggled[bool].connect(
            self._update_accept_button_on_replace_document_option_toggled)
        logger.info(f"Created {self.__class__.__name__} instance.")

    def _create_sort_model(self, source_model: CardListModel) -> NaturallySortedSortFilterProxyModel:
        proxy_model = NaturallySortedSortFilterProxyModel(self)
        proxy_model.setSourceModel(source_model)
        proxy_model.setSortRole(Qt.ItemDataRole.EditRole)

        if enabled:
            accept_button.setIcon(QIcon.fromTheme("document-replace"))
            accept_button.setToolTip(self.tr("Replace document content with the identified cards"))
        else:
            accept_button.setIcon(QIcon.fromTheme("dialog-ok"))
            accept_button.setToolTip(self.tr("Append identified cards to the document"))



















    def initializePage(self) -> None:
        super().initializePage()

        parser: common.ParserBase = self.field("selected_parser")
        decklist_import_section = mtg_proxy_printer.settings.settings["decklist-import"]
        logger.debug(f"About to parse the deck list using parser {parser.__class__.__name__}")
        if self.field("translate-deck-list-enable"):
            language_override = self.field("translate-deck-list-target-language")
            logger.info(f"Language override enabled. Will translate deck list to language {language_override}")
        else: