Translate Kavita filters to Korean

src/all/kavita/build.gradle

@@ -2,7 +2,7 @@ ext {
     kmkVersionCode = 1
     extName = 'Kavita'
     extClass = '.KavitaFactory'
-    extVersionCode = 36
+    extVersionCode = 37
     isNsfw = false
 }
 

src/all/kavita/src/eu/kanade/tachiyomi/extension/all/kavita/Filters.kt

@@ -4,34 +4,34 @@ import eu.kanade.tachiyomi.extension.all.kavita.KavitaConstants.noSmartFilterSel
 import eu.kanade.tachiyomi.source.model.Filter
 
 class SmartFiltersFilter(smartFilters: Array<String>) :
-    Filter.Select<String>("Smart Filters", arrayOf(noSmartFilterSelected) + smartFilters)
-class SortFilter(sortables: Array<String>) : Filter.Sort("Sort by", sortables, Selection(0, true))
+    Filter.Select<String>("스마트 필터", arrayOf(noSmartFilterSelected) + smartFilters)
+class SortFilter(sortables: Array<String>) : Filter.Sort("정렬", sortables, Selection(0, true))
 
 val sortableList = listOf(
-    Pair("Sort name", 1),
-    Pair("Created", 2),
-    Pair("Last modified", 3),
-    Pair("Item added", 4),
-    Pair("Time to Read", 5),
-    Pair("Release year", 6),
-    Pair("Read Progress", 7),
-    Pair("Average Rating", 8),
-    Pair("Random", 9),
+    Pair("정렬명", 1),
+    Pair("생성일", 2),
+    Pair("마지막 수정", 3),
+    Pair("추가일", 4),
+    Pair("읽는 시간", 5),
+    Pair("발매 연도", 6),
+    Pair("읽은 진행률", 7),
+    Pair("평균 평점", 8),
+    Pair("무작위", 9),
 )
 
-class SpecialListFilter(name: String = "Special Lists") : Filter.Select<String>(
+class SpecialListFilter(name: String = "특수 목록") : Filter.Select<String>(
     name,
-    arrayOf("None", "Want to Read", "Reading Lists"),
+    arrayOf("없음", "읽고 싶음", "읽기 목록"),
 )
 
 class StatusFilter : Filter.Select<String>(
-    "Status",
-    arrayOf("Any", "Unread", "In Progress", "Read"),
+    "읽기 상태",
+    arrayOf("전체", "안 읽음", "읽는 중", "읽음"),
 )
 class StatusSeparator :
     Filter.Separator()
 
-class StatusFilterGroup(name: String = "Status") : Filter.Group<StatusFilter>(
+class StatusFilterGroup(name: String = "읽기 상태") : Filter.Group<StatusFilter>(
     name,
     listOf(StatusFilter()),
 )
@@ -39,56 +39,56 @@ class StatusFilterGroup(name: String = "Status") : Filter.Group<StatusFilter>(
 // Use Filter.Text directly for release year range
 class ReleaseYearRange(name: String) : Filter.Text(name, "")
 class ReleaseYearRangeGroup(filters: List<ReleaseYearRange>) :
-    Filter.Group<ReleaseYearRange>("Release Year", filters)
+    Filter.Group<ReleaseYearRange>("발매 연도", filters)
 
 // Use Filter.TriState for genres/tags/age ratings/collections/languages/libraries
 class GenreFilter(name: String) : Filter.TriState(name)
 class GenreFilterGroup(genres: List<GenreFilter>) :
-    Filter.Group<GenreFilter>("Genres", genres)
+    Filter.Group<GenreFilter>("장르", genres)
 
 class TagFilter(name: String) : Filter.TriState(name)
 class TagFilterGroup(tags: List<TagFilter>) :
-    Filter.Group<TagFilter>("Tags", tags)
+    Filter.Group<TagFilter>("태그", tags)
 
 class AgeRatingFilter(name: String) : Filter.TriState(name)
 class AgeRatingFilterGroup(ageRatings: List<AgeRatingFilter>) :
-    Filter.Group<AgeRatingFilter>("Age Rating", ageRatings)
+    Filter.Group<AgeRatingFilter>("연령 등급", ageRatings)
 
 class FormatFilter(name: String) : Filter.CheckBox(name, false)
 class FormatsFilterGroup(formats: List<FormatFilter>) :
-    Filter.Group<FormatFilter>("Formats", formats)
+    Filter.Group<FormatFilter>("형식", formats)
 
 class CollectionFilter(name: String) : Filter.TriState(name)
 class CollectionFilterGroup(collections: List<CollectionFilter>) :
-    Filter.Group<CollectionFilter>("Collection", collections)
+    Filter.Group<CollectionFilter>("컬렉션", collections)
 
 class LanguageFilter(name: String) : Filter.TriState(name)
 class LanguageFilterGroup(languages: List<LanguageFilter>) :
-    Filter.Group<LanguageFilter>("Language", languages)
+    Filter.Group<LanguageFilter>("언어", languages)
 
 class LibraryFilter(library: String) : Filter.TriState(library)
 class LibrariesFilterGroup(libraries: List<LibraryFilter>) :
-    Filter.Group<LibraryFilter>("Libraries", libraries)
+    Filter.Group<LibraryFilter>("라이브러리", libraries)
 
 class PubStatusFilter(name: String) : Filter.CheckBox(name, false)
 class PubStatusFilterGroup(status: List<PubStatusFilter>) :
-    Filter.Group<PubStatusFilter>("Publication Status", status)
+    Filter.Group<PubStatusFilter>("연재 상태", status)
 
 class UserRating : Filter.Select<Int>(
-    "Minimum Rating",
+    "최소 평점",
     arrayOf(
-        "Any",
-        "1 star",
-        "2 stars",
-        "3 stars",
-        "4 stars",
-        "5 stars",
+        "전체",
+        "1점",
+        "2점",
+        "3점",
+        "4점",
+        "5점",
     ).mapIndexed { index, _ -> index }.toTypedArray(),
 ) {
     override fun toString(): String {
         return when (state) {
-            0 -> "Any"
-            else -> "$state star${if (state > 1) "s" else ""}"
+            0 -> "전체"
+            else -> "${state}점"
         }
     }
 }
@@ -102,40 +102,40 @@ class PeopleSeparatorFilter :
 
 class WriterPeopleFilter(name: String) : Filter.CheckBox(name, false)
 class WriterPeopleFilterGroup(peoples: List<WriterPeopleFilter>) :
-    Filter.Group<WriterPeopleFilter>("Writer", peoples)
+    Filter.Group<WriterPeopleFilter>("작가", peoples)
 
 class PencillerPeopleFilter(name: String) : Filter.CheckBox(name, false)
 class PencillerPeopleFilterGroup(peoples: List<PencillerPeopleFilter>) :
-    Filter.Group<PencillerPeopleFilter>("Penciller", peoples)
+    Filter.Group<PencillerPeopleFilter>("펜슬러", peoples)
 
 class InkerPeopleFilter(name: String) : Filter.CheckBox(name, false)
 class InkerPeopleFilterGroup(peoples: List<InkerPeopleFilter>) :
-    Filter.Group<InkerPeopleFilter>("Inker", peoples)
+    Filter.Group<InkerPeopleFilter>("잉커", peoples)
 
 class ColoristPeopleFilter(name: String) : Filter.CheckBox(name, false)
 class ColoristPeopleFilterGroup(peoples: List<ColoristPeopleFilter>) :
-    Filter.Group<ColoristPeopleFilter>("Colorist", peoples)
+    Filter.Group<ColoristPeopleFilter>("컬러리스트", peoples)
 
 class LettererPeopleFilter(name: String) : Filter.CheckBox(name, false)
 class LettererPeopleFilterGroup(peoples: List<LettererPeopleFilter>) :
-    Filter.Group<LettererPeopleFilter>("Letterer", peoples)
+    Filter.Group<LettererPeopleFilter>("레터러", peoples)
 
 class CoverArtistPeopleFilter(name: String) : Filter.CheckBox(name, false)
 class CoverArtistPeopleFilterGroup(peoples: List<CoverArtistPeopleFilter>) :
-    Filter.Group<CoverArtistPeopleFilter>("Cover Artist", peoples)
+    Filter.Group<CoverArtistPeopleFilter>("표지 작가", peoples)
 
 class EditorPeopleFilter(name: String) : Filter.CheckBox(name, false)
 class EditorPeopleFilterGroup(peoples: List<EditorPeopleFilter>) :
-    Filter.Group<EditorPeopleFilter>("Editor", peoples)
+    Filter.Group<EditorPeopleFilter>("편집자", peoples)
 
 class PublisherPeopleFilter(name: String) : Filter.CheckBox(name, false)
 class PublisherPeopleFilterGroup(peoples: List<PublisherPeopleFilter>) :
-    Filter.Group<PublisherPeopleFilter>("Publisher", peoples)
+    Filter.Group<PublisherPeopleFilter>("출판사", peoples)
 
 class CharacterPeopleFilter(name: String) : Filter.CheckBox(name, false)
 class CharacterPeopleFilterGroup(peoples: List<CharacterPeopleFilter>) :
-    Filter.Group<CharacterPeopleFilter>("Character", peoples)
+    Filter.Group<CharacterPeopleFilter>("캐릭터", peoples)
 
 class TranslatorPeopleFilter(name: String) : Filter.CheckBox(name, false)
 class TranslatorPeopleFilterGroup(peoples: List<TranslatorPeopleFilter>) :
-    Filter.Group<TranslatorPeopleFilter>("Translator", peoples)
+    Filter.Group<TranslatorPeopleFilter>("번역자", peoples)

src/all/kavita/src/eu/kanade/tachiyomi/extension/all/kavita/Kavita.kt

@@ -586,12 +586,12 @@ class Kavita(private val suffix: String = "") : ConfigurableSource, UnmeteredSou
                             filter.state.forEach { rangeFilter ->
                                 if ((rangeFilter as Filter.Text).state.isNotEmpty()) {
                                     when (rangeFilter.name) {
-                                        "Min" -> filterV2.addStatement(
+                                        "Min", "최소" -> filterV2.addStatement(
                                             FilterComparison.GreaterThanEqual,
                                             FilterField.ReleaseYear,
                                             rangeFilter.state,
                                         )
-                                        "Max" -> filterV2.addStatement(
+                                        "Max", "최대" -> filterV2.addStatement(
                                             FilterComparison.LessThanEqual,
                                             FilterField.ReleaseYear,
                                             rangeFilter.state,
@@ -653,12 +653,12 @@ class Kavita(private val suffix: String = "") : ConfigurableSource, UnmeteredSou
                             val included = filter.state
                                 .filter { it.state == STATE_INCLUDE }
                                 .mapNotNull { ageFilter ->
-                                    ageRatingsListMeta.find { it.title == ageFilter.name }?.value?.toString()
+                                    ageRatingsListMeta.find { it.title == ageFilter.name || translateAgeRating(it.title) == ageFilter.name }?.value?.toString()
                                 }
                             val excluded = filter.state
                                 .filter { it.state == STATE_EXCLUDE }
                                 .mapNotNull { ageFilter ->
-                                    ageRatingsListMeta.find { it.title == ageFilter.name }?.value?.toString()
+                                    ageRatingsListMeta.find { it.title == ageFilter.name || translateAgeRating(it.title) == ageFilter.name }?.value?.toString()
                                 }
 
                             if (included.isNotEmpty()) {
@@ -728,12 +728,12 @@ class Kavita(private val suffix: String = "") : ConfigurableSource, UnmeteredSou
                             val included = filter.state
                                 .filter { it.state == STATE_INCLUDE }
                                 .mapNotNull { languageFilter ->
-                                    languagesListMeta.find { it.title == languageFilter.name }?.isoCode
+                                    languagesListMeta.find { it.title == languageFilter.name || translateLanguage(it.title) == languageFilter.name }?.isoCode
                                 }
                             val excluded = filter.state
                                 .filter { it.state == STATE_EXCLUDE }
                                 .mapNotNull { languageFilter ->
-                                    languagesListMeta.find { it.title == languageFilter.name }?.isoCode
+                                    languagesListMeta.find { it.title == languageFilter.name || translateLanguage(it.title) == languageFilter.name }?.isoCode
                                 }
 
                             if (included.isNotEmpty()) {
@@ -784,7 +784,7 @@ class Kavita(private val suffix: String = "") : ConfigurableSource, UnmeteredSou
                         is PubStatusFilterGroup -> {
                             filter.state.forEach { pubStatusFilter ->
                                 if ((pubStatusFilter as Filter.CheckBox).state) {
-                                    val statusValue = when (pubStatusFilter.name) {
+                                    val statusValue = when (normalizePublicationStatus(pubStatusFilter.name)) {
                                         "Ongoing" -> 0
                                         "Hiatus" -> 1
                                         "Completed" -> 2
@@ -2078,8 +2078,8 @@ class Kavita(private val suffix: String = "") : ConfigurableSource, UnmeteredSou
             // Release year filter
             ReleaseYearRangeGroup(
                 listOf(
-                    ReleaseYearRange("Min"),
-                    ReleaseYearRange("Max"),
+                    ReleaseYearRange("최소"),
+                    ReleaseYearRange("최대"),
                 ),
             ),
 
@@ -2087,21 +2087,64 @@ class Kavita(private val suffix: String = "") : ConfigurableSource, UnmeteredSou
             TagFilterGroup(tags.map { TagFilter(it) }),
             CollectionFilterGroup(collections.map { CollectionFilter(it) }),
             LibrariesFilterGroup(libraries.map { LibraryFilter(it) }),
-            LanguageFilterGroup(languages.map { LanguageFilter(it) }),
-            PubStatusFilterGroup(pubStatus.map { PubStatusFilter(it) }),
-            AgeRatingFilterGroup(ageRatings.map { AgeRatingFilter(it) }),
+            LanguageFilterGroup(languages.map { LanguageFilter(translateLanguage(it)) }),
+            PubStatusFilterGroup(pubStatus.map { PubStatusFilter(translatePublicationStatus(it)) }),
+            AgeRatingFilterGroup(ageRatings.map { AgeRatingFilter(translateAgeRating(it)) }),
 
             UserRating(),
             UserRatingSeparator(),
 
             // Special filters section
-            Filter.Header(intl["filters_special"]),
-            SpecialListFilter(intl["filters_special_list"]),
+            Filter.Header("특수 필터"),
+            SpecialListFilter("특수 목록"),
             SmartFiltersFilter(smartFilters),
 
         )
     }
 
+    private fun translatePublicationStatus(value: String): String =
+        when (value) {
+            "Ongoing" -> "연재중"
+            "Hiatus" -> "휴재"
+            "Completed" -> "완결"
+            "Cancelled" -> "취소됨"
+            "Ended" -> "종료됨"
+            else -> value
+        }
+
+    private fun normalizePublicationStatus(value: String): String =
+        when (value) {
+            "연재중" -> "Ongoing"
+            "휴재" -> "Hiatus"
+            "완결" -> "Completed"
+            "취소됨" -> "Cancelled"
+            "종료됨" -> "Ended"
+            else -> value
+        }
+
+    private fun translateAgeRating(value: String): String =
+        when (value) {
+            "Unknown" -> "알 수 없음"
+            "Everyone" -> "전체 이용가"
+            "Teen" -> "청소년"
+            "Mature" -> "성인"
+            "Explicit" -> "노골적"
+            else -> value
+        }
+
+    private fun translateLanguage(value: String): String =
+        when (value) {
+            "Unknown" -> "알 수 없음"
+            "English" -> "영어"
+            "Korean" -> "한국어"
+            "Japanese" -> "일본어"
+            "Chinese" -> "중국어"
+            "Spanish" -> "스페인어"
+            "French" -> "프랑스어"
+            "German" -> "독일어"
+            else -> value
+        }
+
     override fun getFilterList(): FilterList {
         return getFilterList(
             genres = genresListMeta.map { it.title },

src/all/kavita/src/eu/kanade/tachiyomi/extension/all/kavita/KavitaConstants.kt

@@ -9,7 +9,7 @@ object KavitaConstants {
     const val SPECIAL_NUMBER_OFFSET = 10000000000f
 
     const val customSourceNamePref = "customSourceName"
-    const val noSmartFilterSelected = "No smart filter loaded"
+    const val noSmartFilterSelected = "스마트 필터 없음"
 
     // Template formatting preferences
     const val CHAPTER_TITLE_FORMAT_DEFAULT = "\$CleanTitle"