wagtail 6.2.2__py3-none-any.whl → 6.3rc2__py3-none-any.whl

wagtail/fields.py

@@ -3,7 +3,6 @@ import json
 from django.core.serializers.json import DjangoJSONEncoder
 from django.core.validators import MaxLengthValidator
 from django.db import models
-from django.db.models.fields.json import KeyTransform
 from django.utils.encoding import force_str
 from django.utils.functional import cached_property
 
@@ -185,6 +184,7 @@ class StreamField(models.Field):
         return result
 
     def get_prep_value(self, value):
+        value = super().get_prep_value(value)
         if (
             isinstance(value, StreamValue)
             and not (value)
@@ -197,36 +197,37 @@ class StreamField(models.Field):
             return value.raw_text
         elif isinstance(value, StreamValue):
             # StreamValue instances must be prepared first.
-            return json.dumps(
-                self.stream_block.get_prep_value(value), cls=DjangoJSONEncoder
-            )
+            return self.stream_block.get_prep_value(value)
         else:
-            # When querying with JSONField features, the rhs might not be a StreamValue.
-            # Note: when Django 4.2 is the minimum supported version, this can be removed
-            # as the serialisation is handled in get_db_prep_value instead.
-            return self.json_field.get_prep_value(value)
+            # If the value is not a StreamValue, it's likely the field is being
+            # used in a non-Wagtail context, e.g. in queries with JSONField features.
+            return super().get_prep_value(value)
 
     def get_db_prep_value(self, value, connection, prepared=False):
-        if not isinstance(value, StreamValue):
-            # When querying with JSONField features, the rhs might not be a StreamValue.
-            # As of Django 4.2, JSONField value serialisation is handled in
-            # get_db_prep_value instead of get_prep_value.
-            return self.json_field.get_db_prep_value(value, connection, prepared)
-        return super().get_db_prep_value(value, connection, prepared)
+        # Use JSONField's get_db_prep_value method to handle the serialization,
+        # which may differ between database backends. However, use our own
+        # get_prep_value method to ensure that StreamValue instances are prepared
+        # before being passed to JSONField.
+        if not prepared:
+            value = self.get_prep_value(value)
+        return self.json_field.get_db_prep_value(
+            value, connection=connection, prepared=True
+        )
 
     def from_db_value(self, value, expression, connection):
-        if isinstance(expression, KeyTransform):
-            # This could happen when using JSONField key transforms,
-            # e.g. Page.object.values('body__0').
-            try:
-                # We might be able to properly resolve to the appropriate StreamValue
-                # based on `expression` and `self.stream_block`, but it might be too
-                # complicated to do so. For now, just deserialise the value.
-                return json.loads(value)
-            except ValueError:
-                # Just in case the extracted value is not valid JSON.
-                return value
-
+        # Historically, StreamField's deserialization used to be handled by
+        # to_python, which in turn handled by BaseStreamBlock.to_python. This was
+        # always the case even before and after the use of the JSON data type.
+
+        # However, now that we can be confident all StreamField data has been
+        # migrated to use JSON in the database, we can reuse any special handling
+        # that JSONField.from_db_value provides, e.g. for handling KeyTransforms
+        # on SQLite.
+
+        # This means we are passing a deserialized value to StreamBlock.to_python,
+        # which is a change from the previous behaviour. However, this is fine
+        # because to_python can handle both serialized and deserialized values.
+        value = self.json_field.from_db_value(value, expression, connection)
         return self.to_python(value)
 
     def formfield(self, **kwargs):
@@ -239,8 +240,23 @@ class StreamField(models.Field):
         return super().formfield(**defaults)
 
     def value_to_string(self, obj):
+        # This method is used for serialization using django.core.serializers,
+        # which is used by dumpdata and loaddata for serializing model objects.
+        # Unlike other fields, JSONField only uses value_from_object without
+        # doing the actual serialization, so that it doesn't end up being
+        # double-serialized when the model object is serialized.
+
+        # Unfortunately, this is also used by django-modelcluster, which is used
+        # to serialize model objects to be stored in revisions. When we migrated
+        # StreamField to use the JSON data type, we did not change this method's
+        # behaviour, i.e. it still returns a JSON-shaped string, to ensure that
+        # revisions are still saved in the same format as before – even if it
+        # means StreamField inside the revision data becomes double-serialized.
+
+        # Now that we change get_prep_value to not do the serialization in favor
+        # of get_db_prep_value, we need to add the serialization here too.
         value = self.value_from_object(obj)
-        return self.get_prep_value(value)
+        return json.dumps(self.get_prep_value(value), cls=self.json_field.encoder)
 
     def get_searchable_content(self, value):
         return self.stream_block.get_searchable_content(value)

wagtail/images/admin_urls.py

@@ -6,7 +6,7 @@ app_name = "wagtailimages"
 urlpatterns = [
     path("", images.IndexView.as_view(), name="index"),
     path("results/", images.IndexView.as_view(results_only=True), name="index_results"),
-    path("<int:image_id>/", images.edit, name="edit"),
+    path("<int:image_id>/", images.EditView.as_view(), name="edit"),
     path("<int:image_id>/delete/", images.DeleteView.as_view(), name="delete"),
     path(
         "<int:image_id>/generate_url/",
@@ -19,7 +19,7 @@ urlpatterns = [
         name="generate_url",
     ),
     path("<int:image_id>/preview/<str:filter_spec>/", images.preview, name="preview"),
-    path("add/", images.add, name="add"),
+    path("add/", images.CreateView.as_view(), name="add"),
     path("usage/<int:image_id>/", images.UsageView.as_view(), name="image_usage"),
     path("multiple/add/", multiple.AddView.as_view(), name="add_multiple"),
     path("multiple/<int:image_id>/", multiple.EditView.as_view(), name="edit_multiple"),

wagtail/images/blocks.py

@@ -1,8 +1,14 @@
+from django import forms
+from django.core.exceptions import ValidationError
 from django.template.loader import render_to_string
 from django.utils.functional import cached_property
+from django.utils.translation import gettext_lazy as _
 
-from wagtail.admin.compare import BlockComparison
-from wagtail.blocks import ChooserBlock
+from wagtail.admin.compare import BlockComparison, StructBlockComparison
+from wagtail.blocks import BooleanBlock, CharBlock, ChooserBlock, StructBlock
+from wagtail.blocks.struct_block import StructBlockAdapter, StructBlockValidationError
+from wagtail.images.models import AbstractImage
+from wagtail.telepath import register
 
 from .shortcuts import get_rendition_or_not_found
 
@@ -51,3 +57,225 @@ class ImageChooserBlockComparison(BlockComparison):
                 "image_b": self.val_b,
             },
         )
+
+
+class ImageBlock(StructBlock):
+    """
+    An usage of ImageChooserBlock with support for alt text.
+    For backward compatibility, this block overrides necessary methods to change
+    the StructValue to be an Image model instance, making it compatible in
+    places where ImageChooserBlock was used.
+    """
+
+    image = ImageChooserBlock(required=True)
+    decorative = BooleanBlock(
+        default=False, required=False, label=_("Image is decorative")
+    )
+    alt_text = CharBlock(required=False, label=_("Alt text"))
+
+    def __init__(self, required=True, **kwargs):
+        super().__init__(
+            [
+                ("image", ImageChooserBlock(required=required)),
+                (
+                    "decorative",
+                    BooleanBlock(
+                        default=False, required=False, label=_("Image is decorative")
+                    ),
+                ),
+                ("alt_text", CharBlock(required=False, label=_("Alt text"))),
+            ],
+            **kwargs,
+        )
+
+    def deconstruct(self):
+        """
+        For typical StructBlock subclasses, it makes sense for the deconstructed block object to be a basic StructBlock
+        with the child blocks passed to the constructor (because this is largely functionally identical to the
+        subclass, and avoids embedding a reference to a potentially-volatile custom class in migrations).
+
+        This is not the case for ImageBlock, as it overrides enough of StructBlock's behaviour that a basic StructBlock
+        is not a suitable substitute - and also has an incompatible constructor signature (as we don't want to support
+        passing child blocks to it).
+
+        Therefore, we opt out of the standard StructBlock deconstruction behaviour here, and always
+        deconstruct an ImageBlock as an ImageBlock.
+        """
+        return ("wagtail.images.blocks.ImageBlock", [], self._constructor_kwargs)
+
+    def deconstruct_with_lookup(self, lookup):
+        return self.deconstruct()
+
+    @classmethod
+    def construct_from_lookup(cls, lookup, *args, **kwargs):
+        return cls(**kwargs)
+
+    def get_searchable_content(self, value):
+        if not self.search_index or not value:
+            return []
+
+        return self.child_blocks["alt_text"].get_searchable_content(
+            value.contextual_alt_text
+        )
+
+    def _struct_value_to_image(self, struct_value):
+        image = struct_value.get("image")
+        decorative = struct_value.get("decorative")
+        if image:
+            # If the image is decorative, set alt_text to an empty string
+            image.contextual_alt_text = (
+                "" if decorative else struct_value.get("alt_text")
+            )
+            image.decorative = decorative
+        return image
+
+    def _image_to_struct_value(self, image):
+        return {
+            "image": image,
+            "alt_text": image and image.contextual_alt_text,
+            "decorative": image and image.decorative,
+        }
+
+    def to_python(self, value):
+        # For backward compatibility with ImageChooserBlock
+        if isinstance(value, int):
+            image = self.child_blocks["image"].to_python(value)
+            struct_value = {"image": image, "decorative": False, "alt_text": None}
+        else:
+            struct_value = super().to_python(value)
+        return self._struct_value_to_image(struct_value)
+
+    def bulk_to_python(self, values):
+        values = list(values)
+
+        if not values:
+            return []
+
+        if isinstance(values[0], int):
+            # `values` is a list of image IDs (as we might encounter if an ImageChooserBlock has been
+            # changed to an ImageBlock with no data migration)
+            image_values = self.child_blocks["image"].bulk_to_python(values)
+
+            struct_values = [
+                {
+                    "image": image,
+                    "decorative": False,
+                    "alt_text": None,
+                }
+                for image in image_values
+            ]
+
+        else:
+            # assume `values` is a list of dicts containing `image`, `decorative` and `alt_text` keys
+            # to be handled by the StructBlock superclass
+            struct_values = super().bulk_to_python(values)
+
+        return [
+            self._struct_value_to_image(struct_value) for struct_value in struct_values
+        ]
+
+    def value_from_datadict(self, data, files, prefix):
+        struct_value = super().value_from_datadict(data, files, prefix)
+        return self._struct_value_to_image(struct_value)
+
+    def clean(self, value):
+        try:
+            self.child_blocks["image"].clean(value)
+        except ValidationError as e:
+            raise StructBlockValidationError(
+                block_errors={"image": e},
+            )
+
+        if value and not value.contextual_alt_text and not value.decorative:
+            raise StructBlockValidationError(
+                block_errors={
+                    "alt_text": ValidationError(
+                        _(
+                            "Please add some alt text for your image or mark it as decorative"
+                        )
+                    )
+                }
+            )
+
+        return value
+
+    def normalize(self, value):
+        if value is None or isinstance(value, AbstractImage):
+            return value
+        else:
+            struct_value = super().normalize(value)
+            return self._struct_value_to_image(struct_value)
+
+    def get_form_context(self, value, prefix="", errors=None):
+        dict_value = {
+            "image": value,
+            "alt_text": value and value.contextual_alt_text,
+            "decorative": value and value.decorative,
+        }
+        context = super().get_form_context(dict_value, prefix=prefix, errors=errors)
+        context["suggested_alt_text"] = value
+        return context
+
+    def get_form_state(self, value):
+        return {
+            "image": self.child_blocks["image"].get_form_state(value),
+            "alt_text": value and value.contextual_alt_text,
+            "decorative": value and value.decorative,
+        }
+
+    def get_prep_value(self, value):
+        return {
+            "image": self.child_blocks["image"].get_prep_value(value),
+            "alt_text": value and value.contextual_alt_text,
+            "decorative": value and value.decorative,
+        }
+
+    def extract_references(self, value):
+        return self.child_blocks["image"].extract_references(value)
+
+    def get_comparison_class(self):
+        return ImageBlockComparison
+
+    def get_api_representation(self, value, context=None):
+        return super().get_api_representation(
+            self._image_to_struct_value(value), context=context
+        )
+
+    def render_basic(self, value, context=None):
+        return self.child_blocks["image"].render_basic(value, context=context)
+
+    class Meta:
+        icon = "image"
+        template = "wagtailimages/widgets/image.html"
+
+
+class ImageBlockAdapter(StructBlockAdapter):
+    js_constructor = "wagtail.images.blocks.ImageBlock"
+
+    @cached_property
+    def media(self):
+        structblock_media = super().media
+        return forms.Media(
+            js=structblock_media._js + ["wagtailimages/js/image-block.js"],
+            css=structblock_media._css,
+        )
+
+
+register(ImageBlockAdapter(), ImageBlock)
+
+
+class ImageBlockComparison(StructBlockComparison):
+    def __init__(self, block, exists_a, exists_b, val_a, val_b):
+        super().__init__(
+            block,
+            exists_a,
+            exists_b,
+            block._image_to_struct_value(val_a),
+            block._image_to_struct_value(val_b),
+        )
+
+    def htmlvalue(self, val):
+        if isinstance(val, AbstractImage):
+            return super().htmlvalue(self.block._image_to_struct_value(val))
+        else:
+            return super().htmlvalue(val)

wagtail/images/fields.py

@@ -6,6 +6,7 @@ from django.conf import settings
 from django.core.exceptions import ValidationError
 from django.core.validators import FileExtensionValidator
 from django.forms.fields import FileField, ImageField
+from django.forms.widgets import FileInput
 from django.template.defaultfilters import filesizeformat
 from django.utils.translation import gettext_lazy as _
 
@@ -32,6 +33,8 @@ class WagtailImageField(ImageField):
     default_validators = [ImageFileExtensionValidator]
 
     def __init__(self, *args, **kwargs):
+        self.allowed_image_extensions = get_allowed_image_extensions()
+
         super().__init__(*args, **kwargs)
 
         # Get max upload size from settings
@@ -43,8 +46,6 @@ class WagtailImageField(ImageField):
         )
         self.max_upload_size_text = filesizeformat(self.max_upload_size)
 
-        self.allowed_image_extensions = get_allowed_image_extensions()
-
         self.supported_formats_text = ", ".join(self.allowed_image_extensions).upper()
 
         # Help text
@@ -163,7 +164,7 @@ class WagtailImageField(ImageField):
             # Annotate the python representation of the FileField with the image
             # property so subclasses can reuse it for their own validation
             f.image = willow.Image.open(file)
-            f.content_type = image_format_name_to_content_type(f.image.format_name)
+            f.content_type = f.image.mime_type
 
         except Exception as exc:  # noqa: BLE001
             # Willow doesn't recognize it as an image.
@@ -182,30 +183,17 @@ class WagtailImageField(ImageField):
 
         return f
 
+    def widget_attrs(self, widget):
+        attrs = super().widget_attrs(widget)
+
+        if (
+            isinstance(widget, FileInput)
+            and "accept" not in widget.attrs
+            and attrs.get("accept") == "image/*"
+            and "heic" in self.allowed_image_extensions
+        ):
+            # File upload dialogs (at least on Chrome / Mac) don't count heic as part of image/*, as it's not a
+            # web-safe format, so add it explicitly
+            attrs["accept"] = "image/*, image/heic"
 
-def image_format_name_to_content_type(image_format_name):
-    """
-    Convert a Willow image format name to a content type.
-    TODO: Replace once https://github.com/wagtail/Willow/pull/102 and
-          a new Willow release is out
-    """
-    if image_format_name == "svg":
-        return "image/svg+xml"
-    elif image_format_name == "jpeg":
-        return "image/jpeg"
-    elif image_format_name == "png":
-        return "image/png"
-    elif image_format_name == "gif":
-        return "image/gif"
-    elif image_format_name == "bmp":
-        return "image/bmp"
-    elif image_format_name == "tiff":
-        return "image/tiff"
-    elif image_format_name == "webp":
-        return "image/webp"
-    elif image_format_name == "avif":
-        return "image/avif"
-    elif image_format_name == "ico":
-        return "image/x-icon"
-    else:
-        raise ValueError("Unknown image format name")
+        return attrs

wagtail/images/image_operations.py

@@ -409,7 +409,7 @@ class WebPQualityOperation(FilterOperation):
 
 
 class FormatOperation(FilterOperation):
-    supported_formats = ["jpeg", "png", "gif", "webp", "avif", "ico"]
+    supported_formats = ["jpeg", "png", "gif", "webp", "avif", "ico", "heic"]
 
     def construct(self, format, *options):
         self.format = format

wagtail/images/locale/cy/LC_MESSAGES/django.po

@@ -6,13 +6,14 @@
 # Adam Hughes <adamhughes31@gmail.com>, 2020
 # Philip Crisp, 2022
 # Philip Crisp, 2022
+# Philip Lindsay-Crisp, 2024
 msgid ""
 msgstr ""
 "Project-Id-Version: Wagtail\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2024-08-07 10:06+0100\n"
 "PO-Revision-Date: 2014-02-20 21:05+0000\n"
-"Last-Translator: Philip Crisp, 2022\n"
+"Last-Translator: Philip Lindsay-Crisp, 2024\n"
 "Language-Team: Welsh (http://app.transifex.com/torchbox/wagtail/language/"
 "cy/)\n"
 "MIME-Version: 1.0\n"
@@ -162,6 +163,14 @@ msgstr "delwedd"
 msgid "images"
 msgstr "delweddau"
 
+#, python-format
+msgid "Add tags to 1 image"
+msgid_plural "Add tags to %(counter)s images"
+msgstr[0] "Ychwanegu 1 tag i l;lun"
+msgstr[1] "Ychwanegu tagiau i %(counter)s llun"
+msgstr[2] "Ychwanegu tagiau i %(counter)s llun"
+msgstr[3] "Ychwanegu tagiau i %(counter)s llun"
+
 msgid "Add tags to images"
 msgstr "Ychwanegu tagiau i lluniau"
 
@@ -185,6 +194,14 @@ msgstr "Ia, ychwanegu"
 msgid "No, don't add"
 msgstr "Na, paid a ychwanegu"
 
+#, python-format
+msgid "Add 1 image to new collection"
+msgid_plural "Add %(counter)s images to new collection"
+msgstr[0] "Ychwanegu 1 casgliad newydd"
+msgstr[1] "Ychwanegu %(counter)s defnyddio casgliad newydd"
+msgstr[2] "Ychwanegu %(counter)s defnyddio casgliad newydd"
+msgstr[3] "Ychwanegu %(counter)s defnyddio casgliad newydd"
+
 msgid "Add images to collection"
 msgstr "Ychwanegu lluniau i'r casgliad"
 
@@ -254,18 +271,72 @@ msgstr "Na, peidiwch a ddileu"
 msgid "Popular tags"
 msgstr "Tagiau poblogaidd"
 
+msgid ""
+"Upload successful. However, your new image seems to be a duplicate of an "
+"existing image. You may delete it if it wasn't required."
+msgstr ""
+"Llwytho i fyny yn llwyddiannus. Fodd bynnag, mae'n ymddangos bod eich llun "
+"newydd yn ddyblyg o llun sy'n bodoli eisoes. Gallwch ei ddileu os nad oedd "
+"ei angen."
+
+msgid "Existing"
+msgstr "Presennol"
+
 msgid "New"
 msgstr "Newydd"
 
+msgid "Use new image"
+msgstr "Defyddio llun newydd."
+
+msgid "Use existing and delete new"
+msgstr "Defnyddio presennol a dileu'r newydd"
+
 msgid "Latest images"
 msgstr "Lluniau diweddaraf"
 
+#, python-format
+msgid "Select %(title)s"
+msgstr "Dewis %(title)s"
+
+msgid "You haven't uploaded any images in this collection."
+msgstr "Nid ydych wedi uwchlwytho unrhyw ddelweddau yn y casgliad hwn."
+
+msgid "You haven't uploaded any images."
+msgstr "Nid ydych wedi uwchlwytho unrhyw ddelweddau."
+
+msgid ""
+"Why not <a class=\"upload-one-now\" href=\"#tab-upload\" data-tab-"
+"trigger>upload one now</a>?"
+msgstr ""
+"Beth am <a class=\"upload-one-now\" href=\"#tab-upload\" data-tab-"
+"trigger>uwchlwytho un rwan</a>?"
+
 msgid "Choose a format"
 msgstr "Dewisiwch fformat"
 
 msgid "Insert image"
 msgstr "Mewnosod llun"
 
+#, python-format
+msgid ""
+"<span>%(total)s</span> Image <span class=\"w-sr-only\">created in "
+"%(site_name)s</span>"
+msgid_plural ""
+"<span>%(total)s</span> Images <span class=\"w-sr-only\">created in "
+"%(site_name)s</span>"
+msgstr[0] ""
+"<span>%(total)s</span> llun <span class=\"w-sr-only\">wedi'i greu i "
+"%(site_name)s</span>"
+msgstr[1] ""
+"<span>%(total)s</span> lluniau <span class=\"w-sr-only\">wedi'i greu "
+"%(site_name)s</span>"
+msgstr[2] ""
+"<span>%(total)s</span> lluniau <span class=\"w-sr-only\">wedi'i greu "
+"%(site_name)s</span>"
+msgstr[3] ""
+"<span>%(total)s</span> lluniau <span class=\"w-sr-only\">wedi'i greu i "
+"%(site_name)s</span>"
+
 msgid "Change image file:"
 msgstr "Newid ffeil llun:"
 
@@ -278,6 +349,12 @@ msgstr "Ychwanegu llun"
 msgid "Save"
 msgstr "Cadw"
 
+msgid "Keep new image"
+msgstr "Cadw llun newydd"
+
+msgid "Delete new image"
+msgstr "Dileu llun newydd"
+
 #, python-format
 msgid "Editing image %(title)s"
 msgstr "Golygu llun %(title)s"
@@ -288,6 +365,9 @@ msgstr "Golygu"
 msgid "Delete image"
 msgstr "Dileu delwedd"
 
+msgid "Image focal point"
+msgstr "Ffocws llun"
+
 msgid "URL Generator"
 msgstr "Cynhyrchydd URL"
 
@@ -322,6 +402,9 @@ msgstr "Ffeil heb ei chanfod"
 msgid "Usage"
 msgstr "Defnydd"
 
+msgid "Sort by"
+msgstr "Trefnu un ôl"
+
 msgid "Select all images in listing"
 msgstr "Dewiswch yr holl lluniau yn y rhestr"
 
@@ -352,6 +435,18 @@ msgstr "Rhagolwg"
 msgid "URL"
 msgstr "URL"
 
+msgid "Image URL"
+msgstr "URL Llun"
+
+msgid "Copy URL"
+msgstr "URL Copi"
+
+msgid "Copied to clipboard"
+msgstr "Wedi'i gopïo i'r clipfwrdd"
+
+msgid "Copying to clipboard failed"
+msgstr "Methodd copïo i'r clipfwrdd"
+
 msgid "Add multiple images"
 msgstr "Ychwanegu lluniau lluosog"
 
@@ -376,6 +471,14 @@ msgstr ""
 "priodol, os oes angen. Gallwch hefyd ddileu'r llun yn gyfan gwbl os nad oedd "
 "angen yr uwchlwythiad."
 
+msgid ""
+"Upload successful. However, your new image seems to be a duplicate of this "
+"existing image. You may delete it if it wasn't required."
+msgstr ""
+"Llwytho i fyny yn llwyddiannus. Fodd bynnag, mae'n ymddangos bod eich llun "
+"newydd yn ddyblyg o'r llun bresennol hon. Gallwch ei ddileu os nad oedd ei "
+"angen."
+
 msgid "Sorry, upload failed."
 msgstr "Mae'n ddrwg gennym, ni fu modd uwchlwytho."
 
@@ -397,6 +500,9 @@ msgstr "Caniatadau llun"
 msgid "Add an image permission"
 msgstr "Ychwanegu caniatad llun"
 
+msgid "Tags"
+msgstr "Tagiau"
+
 msgid "Tag"
 msgstr "Tag"
 
@@ -452,9 +558,30 @@ msgstr "Wrthi'n uwchlwytho…"
 msgid "Choose an image"
 msgstr "Dewis delwedd"
 
+msgid "Choose another image"
+msgstr "Dewisiwch llun arall"
+
 msgid "Edit this image"
 msgstr "Golygu'r llun hon"
 
+msgid "Newest"
+msgstr "Ieuengaf"
+
+msgid "Oldest"
+msgstr "Hynaf"
+
+msgid "Title: (A -> Z)"
+msgstr "Teitl: (A -> Z)"
+
+msgid "Title: (Z -> A)"
+msgstr "Teitl: (Z -> A)"
+
+msgid "File size: (low to high)"
+msgstr "Maint ffeil: (isel i uchel)"
+
+msgid "File size: (high to low)"
+msgstr "Maint ffeil: (uchel i isel)"
+
 msgid "Images"
 msgstr "Delweddau"