Use Voyager on Library tab (#8620)

2025-11-10 02:58:55 +01:00 · 2022-11-27 03:48:57 +07:00
parent fe579c4865
commit e14909fff4
15 changed files with 802 additions and 845 deletions
--- a/app/src/main/java/eu/kanade/presentation/library/LibraryScreen.kt
+++ b/app/src/main/java/eu/kanade/presentation/library/LibraryScreen.kt
@@ -1,130 +0,0 @@
-package eu.kanade.presentation.library
-
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.HelpOutline
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.platform.LocalHapticFeedback
-import androidx.compose.ui.platform.LocalUriHandler
-import androidx.compose.ui.util.fastAll
-import eu.kanade.domain.category.model.Category
-import eu.kanade.domain.library.model.LibraryManga
-import eu.kanade.domain.library.model.display
-import eu.kanade.domain.manga.model.isLocal
-import eu.kanade.presentation.components.EmptyScreen
-import eu.kanade.presentation.components.EmptyScreenAction
-import eu.kanade.presentation.components.LibraryBottomActionMenu
-import eu.kanade.presentation.components.LoadingScreen
-import eu.kanade.presentation.components.Scaffold
-import eu.kanade.presentation.library.components.LibraryContent
-import eu.kanade.presentation.library.components.LibraryToolbar
-import eu.kanade.presentation.manga.DownloadAction
-import eu.kanade.tachiyomi.R
-import eu.kanade.tachiyomi.ui.library.LibraryPresenter
-import eu.kanade.tachiyomi.widget.TachiyomiBottomNavigationView
-
-@Composable
-fun LibraryScreen(
-    presenter: LibraryPresenter,
-    onMangaClicked: (Long) -> Unit,
-    onContinueReadingClicked: (LibraryManga) -> Unit,
-    onGlobalSearchClicked: () -> Unit,
-    onChangeCategoryClicked: () -> Unit,
-    onMarkAsReadClicked: () -> Unit,
-    onMarkAsUnreadClicked: () -> Unit,
-    onDownloadClicked: (DownloadAction) -> Unit,
-    onDeleteClicked: () -> Unit,
-    onClickUnselectAll: () -> Unit,
-    onClickSelectAll: () -> Unit,
-    onClickInvertSelection: () -> Unit,
-    onClickFilter: () -> Unit,
-    onClickRefresh: (Category?) -> Boolean,
-    onClickOpenRandomManga: () -> Unit,
-) {
-    val haptic = LocalHapticFeedback.current
-
-    Scaffold(
-        topBar = { scrollBehavior ->
-            val title by presenter.getToolbarTitle()
-            val tabVisible = presenter.tabVisibility && presenter.categories.size > 1
-            LibraryToolbar(
-                state = presenter,
-                title = title,
-                incognitoMode = !tabVisible && presenter.isIncognitoMode,
-                downloadedOnlyMode = !tabVisible && presenter.isDownloadOnly,
-                onClickUnselectAll = onClickUnselectAll,
-                onClickSelectAll = onClickSelectAll,
-                onClickInvertSelection = onClickInvertSelection,
-                onClickFilter = onClickFilter,
-                onClickRefresh = { onClickRefresh(null) },
-                onClickOpenRandomManga = onClickOpenRandomManga,
-                scrollBehavior = scrollBehavior.takeIf { !tabVisible }, // For scroll overlay when no tab
-            )
-        },
-        bottomBar = {
-            LibraryBottomActionMenu(
-                visible = presenter.selectionMode,
-                onChangeCategoryClicked = onChangeCategoryClicked,
-                onMarkAsReadClicked = onMarkAsReadClicked,
-                onMarkAsUnreadClicked = onMarkAsUnreadClicked,
-                onDownloadClicked = onDownloadClicked.takeIf { presenter.selection.fastAll { !it.manga.isLocal() } },
-                onDeleteClicked = onDeleteClicked,
-            )
-        },
-    ) { paddingValues ->
-        if (presenter.isLoading) {
-            LoadingScreen()
-            return@Scaffold
-        }
-
-        val contentPadding = TachiyomiBottomNavigationView.withBottomNavPadding(paddingValues)
-        if (presenter.searchQuery.isNullOrEmpty() && presenter.isLibraryEmpty) {
-            val handler = LocalUriHandler.current
-            EmptyScreen(
-                textResource = R.string.information_empty_library,
-                modifier = Modifier.padding(contentPadding),
-                actions = listOf(
-                    EmptyScreenAction(
-                        stringResId = R.string.getting_started_guide,
-                        icon = Icons.Outlined.HelpOutline,
-                        onClick = { handler.openUri("https://tachiyomi.org/help/guides/getting-started") },
-                    ),
-                ),
-            )
-            return@Scaffold
-        }
-
-        LibraryContent(
-            state = presenter,
-            contentPadding = contentPadding,
-            currentPage = { presenter.activeCategory },
-            isLibraryEmpty = presenter.isLibraryEmpty,
-            showPageTabs = presenter.tabVisibility,
-            showMangaCount = presenter.mangaCountVisibility,
-            onChangeCurrentPage = { presenter.activeCategory = it },
-            onMangaClicked = onMangaClicked,
-            onContinueReadingClicked = onContinueReadingClicked,
-            onToggleSelection = { presenter.toggleSelection(it) },
-            onToggleRangeSelection = {
-                presenter.toggleRangeSelection(it)
-                haptic.performHapticFeedback(HapticFeedbackType.LongPress)
-            },
-            onRefresh = onClickRefresh,
-            onGlobalSearchClicked = onGlobalSearchClicked,
-            getNumberOfMangaForCategory = { presenter.getMangaCountForCategory(it) },
-            getDisplayModeForPage = { presenter.categories[it].display },
-            getColumnsForOrientation = { presenter.getColumnsPreferenceForCurrentOrientation(it) },
-            getLibraryForPage = { presenter.getMangaForCategory(page = it) },
-            showDownloadBadges = presenter.showDownloadBadges,
-            showUnreadBadges = presenter.showUnreadBadges,
-            showLocalBadges = presenter.showLocalBadges,
-            showLanguageBadges = presenter.showLanguageBadges,
-            showContinueReadingButton = presenter.showContinueReadingButton,
-            isIncognitoMode = presenter.isIncognitoMode,
-            isDownloadOnly = presenter.isDownloadOnly,
-        )
-    }
-}
--- a/app/src/main/java/eu/kanade/presentation/library/LibraryState.kt
+++ b/app/src/main/java/eu/kanade/presentation/library/LibraryState.kt
@@ -1,35 +0,0 @@
-package eu.kanade.presentation.library
-
-import androidx.compose.runtime.Stable
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
-import eu.kanade.domain.category.model.Category
-import eu.kanade.domain.library.model.LibraryManga
-import eu.kanade.tachiyomi.ui.library.LibraryPresenter
-
-@Stable
-interface LibraryState {
-    val isLoading: Boolean
-    val categories: List<Category>
-    var searchQuery: String?
-    val selection: List<LibraryManga>
-    val selectionMode: Boolean
-    var hasActiveFilters: Boolean
-    var dialog: LibraryPresenter.Dialog?
-}
-
-fun LibraryState(): LibraryState {
-    return LibraryStateImpl()
-}
-
-class LibraryStateImpl : LibraryState {
-    override var isLoading: Boolean by mutableStateOf(true)
-    override var categories: List<Category> by mutableStateOf(emptyList())
-    override var searchQuery: String? by mutableStateOf(null)
-    override var selection: List<LibraryManga> by mutableStateOf(emptyList())
-    override val selectionMode: Boolean by derivedStateOf { selection.isNotEmpty() }
-    override var hasActiveFilters: Boolean by mutableStateOf(false)
-    override var dialog: LibraryPresenter.Dialog? by mutableStateOf(null)
-}
--- a/app/src/main/java/eu/kanade/presentation/library/components/LibraryBadges.kt
+++ b/app/src/main/java/eu/kanade/presentation/library/components/LibraryBadges.kt
@@ -5,16 +5,12 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.stringResource
 import eu.kanade.presentation.components.Badge
 import eu.kanade.tachiyomi.R
-import eu.kanade.tachiyomi.ui.library.LibraryItem

@Composable
-fun DownloadsBadge(
-    enabled: Boolean,
-    item: LibraryItem,
-) {
-    if (enabled && item.downloadCount > 0) {
+fun DownloadsBadge(count: Int) {
+    if (count > 0) {
        Badge(
-            text = "${item.downloadCount}",
+            text = "$count",
            color = MaterialTheme.colorScheme.tertiary,
            textColor = MaterialTheme.colorScheme.onTertiary,
        )
@@ -22,30 +18,26 @@ fun DownloadsBadge(
 }

@Composable
-fun UnreadBadge(
-    enabled: Boolean,
-    item: LibraryItem,
-) {
-    if (enabled && item.unreadCount > 0) {
-        Badge(text = "${item.unreadCount}")
+fun UnreadBadge(count: Int) {
+    if (count > 0) {
+        Badge(text = "$count")
    }
 }

@Composable
 fun LanguageBadge(
-    showLanguage: Boolean,
-    showLocal: Boolean,
-    item: LibraryItem,
+    isLocal: Boolean,
+    sourceLanguage: String,
 ) {
-    if (showLocal && item.isLocal) {
+    if (isLocal) {
        Badge(
            text = stringResource(R.string.local_source_badge),
            color = MaterialTheme.colorScheme.tertiary,
            textColor = MaterialTheme.colorScheme.onTertiary,
        )
-    } else if (showLanguage && item.sourceLanguage.isNotEmpty()) {
+    } else if (sourceLanguage.isNotEmpty()) {
        Badge(
-            text = item.sourceLanguage.uppercase(),
+            text = sourceLanguage.uppercase(),
            color = MaterialTheme.colorScheme.tertiary,
            textColor = MaterialTheme.colorScheme.onTertiary,
        )
--- a/app/src/main/java/eu/kanade/presentation/library/components/LibraryComfortableGrid.kt
+++ b/app/src/main/java/eu/kanade/presentation/library/components/LibraryComfortableGrid.kt
@@ -14,17 +14,12 @@ import eu.kanade.tachiyomi.ui.library.LibraryItem
@Composable
 fun LibraryComfortableGrid(
    items: List<LibraryItem>,
-    showDownloadBadges: Boolean,
-    showUnreadBadges: Boolean,
-    showLocalBadges: Boolean,
-    showLanguageBadges: Boolean,
-    showContinueReadingButton: Boolean,
    columns: Int,
    contentPadding: PaddingValues,
    selection: List<LibraryManga>,
    onClick: (LibraryManga) -> Unit,
    onLongClick: (LibraryManga) -> Unit,
-    onClickContinueReading: (LibraryManga) -> Unit,
+    onClickContinueReading: ((LibraryManga) -> Unit)?,
    searchQuery: String?,
    onGlobalSearchClicked: () -> Unit,
 ) {
@@ -51,26 +46,22 @@ fun LibraryComfortableGrid(
                    lastModified = manga.coverLastModified,
                ),
                coverBadgeStart = {
-                    DownloadsBadge(
-                        enabled = showDownloadBadges,
-                        item = libraryItem,
-                    )
-                    UnreadBadge(
-                        enabled = showUnreadBadges,
-                        item = libraryItem,
-                    )
+                    DownloadsBadge(count = libraryItem.downloadCount.toInt())
+                    UnreadBadge(count = libraryItem.unreadCount.toInt())
                },
                coverBadgeEnd = {
                    LanguageBadge(
-                        showLanguage = showLanguageBadges,
-                        showLocal = showLocalBadges,
-                        item = libraryItem,
+                        isLocal = libraryItem.isLocal,
+                        sourceLanguage = libraryItem.sourceLanguage,
                    )
                },
-                showContinueReadingButton = showContinueReadingButton,
                onLongClick = { onLongClick(libraryItem.libraryManga) },
                onClick = { onClick(libraryItem.libraryManga) },
-                onClickContinueReading = { onClickContinueReading(libraryItem.libraryManga) },
+                onClickContinueReading = if (onClickContinueReading != null) {
+                    { onClickContinueReading(libraryItem.libraryManga) }
+                } else {
+                    null
+                },
            )
        }
    }
--- a/app/src/main/java/eu/kanade/presentation/library/components/LibraryCompactGrid.kt
+++ b/app/src/main/java/eu/kanade/presentation/library/components/LibraryCompactGrid.kt
@@ -15,17 +15,12 @@ import eu.kanade.tachiyomi.ui.library.LibraryItem
 fun LibraryCompactGrid(
    items: List<LibraryItem>,
    showTitle: Boolean,
-    showDownloadBadges: Boolean,
-    showUnreadBadges: Boolean,
-    showLocalBadges: Boolean,
-    showLanguageBadges: Boolean,
-    showContinueReadingButton: Boolean,
    columns: Int,
    contentPadding: PaddingValues,
    selection: List<LibraryManga>,
    onClick: (LibraryManga) -> Unit,
    onLongClick: (LibraryManga) -> Unit,
-    onClickContinueReading: (LibraryManga) -> Unit,
+    onClickContinueReading: ((LibraryManga) -> Unit)?,
    searchQuery: String?,
    onGlobalSearchClicked: () -> Unit,
 ) {
@@ -52,26 +47,22 @@ fun LibraryCompactGrid(
                    lastModified = manga.coverLastModified,
                ),
                coverBadgeStart = {
-                    DownloadsBadge(
-                        enabled = showDownloadBadges,
-                        item = libraryItem,
-                    )
-                    UnreadBadge(
-                        enabled = showUnreadBadges,
-                        item = libraryItem,
-                    )
+                    DownloadsBadge(count = libraryItem.downloadCount.toInt())
+                    UnreadBadge(count = libraryItem.unreadCount.toInt())
                },
                coverBadgeEnd = {
                    LanguageBadge(
-                        showLanguage = showLanguageBadges,
-                        showLocal = showLocalBadges,
-                        item = libraryItem,
+                        isLocal = libraryItem.isLocal,
+                        sourceLanguage = libraryItem.sourceLanguage,
                    )
                },
-                showContinueReadingButton = showContinueReadingButton,
                onLongClick = { onLongClick(libraryItem.libraryManga) },
                onClick = { onClick(libraryItem.libraryManga) },
-                onClickContinueReading = { onClickContinueReading(libraryItem.libraryManga) },
+                onClickContinueReading = if (onClickContinueReading != null) {
+                    { onClickContinueReading(libraryItem.libraryManga) }
+                } else {
+                    null
+                },
            )
        }
    }
--- a/app/src/main/java/eu/kanade/presentation/library/components/LibraryContent.kt
+++ b/app/src/main/java/eu/kanade/presentation/library/components/LibraryContent.kt
@@ -7,7 +7,6 @@ import androidx.compose.foundation.layout.calculateStartPadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.State
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -21,7 +20,6 @@ import eu.kanade.domain.library.model.LibraryDisplayMode
 import eu.kanade.domain.library.model.LibraryManga
 import eu.kanade.presentation.components.SwipeRefresh
 import eu.kanade.presentation.components.rememberPagerState
-import eu.kanade.presentation.library.LibraryState
 import eu.kanade.tachiyomi.ui.library.LibraryItem
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
@@ -29,28 +27,24 @@ import kotlin.time.Duration.Companion.seconds

@Composable
 fun LibraryContent(
-    state: LibraryState,
+    categories: List<Category>,
+    searchQuery: String?,
+    selection: List<LibraryManga>,
    contentPadding: PaddingValues,
    currentPage: () -> Int,
    isLibraryEmpty: Boolean,
    showPageTabs: Boolean,
-    showMangaCount: Boolean,
    onChangeCurrentPage: (Int) -> Unit,
    onMangaClicked: (Long) -> Unit,
-    onContinueReadingClicked: (LibraryManga) -> Unit,
+    onContinueReadingClicked: ((LibraryManga) -> Unit)?,
    onToggleSelection: (LibraryManga) -> Unit,
    onToggleRangeSelection: (LibraryManga) -> Unit,
    onRefresh: (Category?) -> Boolean,
    onGlobalSearchClicked: () -> Unit,
-    getNumberOfMangaForCategory: @Composable (Long) -> State<Int?>,
+    getNumberOfMangaForCategory: (Category) -> Int?,
    getDisplayModeForPage: @Composable (Int) -> LibraryDisplayMode,
    getColumnsForOrientation: (Boolean) -> PreferenceMutableState<Int>,
-    getLibraryForPage: @Composable (Int) -> List<LibraryItem>,
-    showDownloadBadges: Boolean,
-    showUnreadBadges: Boolean,
-    showLocalBadges: Boolean,
-    showLanguageBadges: Boolean,
-    showContinueReadingButton: Boolean,
+    getLibraryForPage: (Int) -> List<LibraryItem>,
    isDownloadOnly: Boolean,
    isIncognitoMode: Boolean,
 ) {
@@ -61,38 +55,30 @@ fun LibraryContent(
            end = contentPadding.calculateEndPadding(LocalLayoutDirection.current),
        ),
    ) {
-        val categories = state.categories
        val coercedCurrentPage = remember { currentPage().coerceAtMost(categories.lastIndex) }
        val pagerState = rememberPagerState(coercedCurrentPage)

        val scope = rememberCoroutineScope()
        var isRefreshing by remember(pagerState.currentPage) { mutableStateOf(false) }

-        if (isLibraryEmpty.not() && showPageTabs && categories.size > 1) {
+        if (!isLibraryEmpty && showPageTabs && categories.size > 1) {
            LibraryTabs(
                categories = categories,
                currentPageIndex = pagerState.currentPage,
-                showMangaCount = showMangaCount,
-                getNumberOfMangaForCategory = getNumberOfMangaForCategory,
                isDownloadOnly = isDownloadOnly,
                isIncognitoMode = isIncognitoMode,
-                onTabItemClick = { scope.launch { pagerState.animateScrollToPage(it) } },
-            )
+                getNumberOfMangaForCategory = getNumberOfMangaForCategory,
+            ) { scope.launch { pagerState.animateScrollToPage(it) } }
        }

+        val notSelectionMode = selection.isEmpty()
        val onClickManga = { manga: LibraryManga ->
-            if (state.selectionMode.not()) {
+            if (notSelectionMode) {
                onMangaClicked(manga.manga.id)
            } else {
                onToggleSelection(manga)
            }
        }
-        val onLongClickManga = { manga: LibraryManga ->
-            onToggleRangeSelection(manga)
-        }
-        val onClickContinueReading = { manga: LibraryManga ->
-            onContinueReadingClicked(manga)
-        }

        SwipeRefresh(
            refreshing = isRefreshing,
@@ -106,26 +92,21 @@ fun LibraryContent(
                    isRefreshing = false
                }
            },
-            enabled = state.selectionMode.not(),
+            enabled = notSelectionMode,
        ) {
            LibraryPager(
                state = pagerState,
                contentPadding = PaddingValues(bottom = contentPadding.calculateBottomPadding()),
                pageCount = categories.size,
-                selectedManga = state.selection,
+                selectedManga = selection,
+                searchQuery = searchQuery,
+                onGlobalSearchClicked = onGlobalSearchClicked,
                getDisplayModeForPage = getDisplayModeForPage,
                getColumnsForOrientation = getColumnsForOrientation,
                getLibraryForPage = getLibraryForPage,
-                showDownloadBadges = showDownloadBadges,
-                showUnreadBadges = showUnreadBadges,
-                showLocalBadges = showLocalBadges,
-                showLanguageBadges = showLanguageBadges,
-                showContinueReadingButton = showContinueReadingButton,
                onClickManga = onClickManga,
-                onLongClickManga = onLongClickManga,
-                onClickContinueReading = onClickContinueReading,
-                onGlobalSearchClicked = onGlobalSearchClicked,
-                searchQuery = state.searchQuery,
+                onLongClickManga = onToggleRangeSelection,
+                onClickContinueReading = onContinueReadingClicked,
            )
        }

--- a/app/src/main/java/eu/kanade/presentation/library/components/LibraryList.kt
+++ b/app/src/main/java/eu/kanade/presentation/library/components/LibraryList.kt
@@ -23,16 +23,11 @@ import eu.kanade.tachiyomi.ui.library.LibraryItem
@Composable
 fun LibraryList(
    items: List<LibraryItem>,
-    showDownloadBadges: Boolean,
-    showUnreadBadges: Boolean,
-    showLocalBadges: Boolean,
-    showLanguageBadges: Boolean,
-    showContinueReadingButton: Boolean,
    contentPadding: PaddingValues,
    selection: List<LibraryManga>,
    onClick: (LibraryManga) -> Unit,
    onLongClick: (LibraryManga) -> Unit,
-    onClickContinueReading: (LibraryManga) -> Unit,
+    onClickContinueReading: ((LibraryManga) -> Unit)?,
    searchQuery: String?,
    onGlobalSearchClicked: () -> Unit,
 ) {
@@ -41,13 +36,13 @@ fun LibraryList(
        contentPadding = contentPadding + PaddingValues(vertical = 8.dp),
    ) {
        item {
-            if (searchQuery.isNullOrEmpty().not()) {
+            if (!searchQuery.isNullOrEmpty()) {
                TextButton(
                    modifier = Modifier.fillMaxWidth(),
                    onClick = onGlobalSearchClicked,
                ) {
                    Text(
-                        text = stringResource(R.string.action_global_search_query, searchQuery!!),
+                        text = stringResource(R.string.action_global_search_query, searchQuery),
                        modifier = Modifier.zIndex(99f),
                    )
                }
@@ -70,14 +65,20 @@ fun LibraryList(
                    lastModified = manga.coverLastModified,
                ),
                badge = {
-                    DownloadsBadge(enabled = showDownloadBadges, item = libraryItem)
-                    UnreadBadge(enabled = showUnreadBadges, item = libraryItem)
-                    LanguageBadge(showLanguage = showLanguageBadges, showLocal = showLocalBadges, item = libraryItem)
+                    DownloadsBadge(count = libraryItem.downloadCount.toInt())
+                    UnreadBadge(count = libraryItem.unreadCount.toInt())
+                    LanguageBadge(
+                        isLocal = libraryItem.isLocal,
+                        sourceLanguage = libraryItem.sourceLanguage,
+                    )
                },
-                showContinueReadingButton = showContinueReadingButton,
                onLongClick = { onLongClick(libraryItem.libraryManga) },
                onClick = { onClick(libraryItem.libraryManga) },
-                onClickContinueReading = { onClickContinueReading(libraryItem.libraryManga) },
+                onClickContinueReading = if (onClickContinueReading != null) {
+                    { onClickContinueReading(libraryItem.libraryManga) }
+                } else {
+                    null
+                },
            )
        }
    }
--- a/app/src/main/java/eu/kanade/presentation/library/components/LibraryPager.kt
+++ b/app/src/main/java/eu/kanade/presentation/library/components/LibraryPager.kt
@@ -27,15 +27,10 @@ fun LibraryPager(
    onGlobalSearchClicked: () -> Unit,
    getDisplayModeForPage: @Composable (Int) -> LibraryDisplayMode,
    getColumnsForOrientation: (Boolean) -> PreferenceMutableState<Int>,
-    getLibraryForPage: @Composable (Int) -> List<LibraryItem>,
-    showDownloadBadges: Boolean,
-    showUnreadBadges: Boolean,
-    showLocalBadges: Boolean,
-    showLanguageBadges: Boolean,
-    showContinueReadingButton: Boolean,
+    getLibraryForPage: (Int) -> List<LibraryItem>,
    onClickManga: (LibraryManga) -> Unit,
    onLongClickManga: (LibraryManga) -> Unit,
-    onClickContinueReading: (LibraryManga) -> Unit,
+    onClickContinueReading: ((LibraryManga) -> Unit)?,
 ) {
    HorizontalPager(
        count = pageCount,
@@ -62,11 +57,6 @@ fun LibraryPager(
            LibraryDisplayMode.List -> {
                LibraryList(
                    items = library,
-                    showDownloadBadges = showDownloadBadges,
-                    showUnreadBadges = showUnreadBadges,
-                    showLocalBadges = showLocalBadges,
-                    showLanguageBadges = showLanguageBadges,
-                    showContinueReadingButton = showContinueReadingButton,
                    contentPadding = contentPadding,
                    selection = selectedManga,
                    onClick = onClickManga,
@@ -80,11 +70,6 @@ fun LibraryPager(
                LibraryCompactGrid(
                    items = library,
                    showTitle = displayMode is LibraryDisplayMode.CompactGrid,
-                    showDownloadBadges = showDownloadBadges,
-                    showUnreadBadges = showUnreadBadges,
-                    showLocalBadges = showLocalBadges,
-                    showLanguageBadges = showLanguageBadges,
-                    showContinueReadingButton = showContinueReadingButton,
                    columns = columns,
                    contentPadding = contentPadding,
                    selection = selectedManga,
@@ -98,17 +83,12 @@ fun LibraryPager(
            LibraryDisplayMode.ComfortableGrid -> {
                LibraryComfortableGrid(
                    items = library,
-                    showDownloadBadges = showDownloadBadges,
-                    showUnreadBadges = showUnreadBadges,
-                    showLocalBadges = showLocalBadges,
-                    showLanguageBadges = showLanguageBadges,
-                    showContinueReadingButton = showContinueReadingButton,
                    columns = columns,
                    contentPadding = contentPadding,
                    selection = selectedManga,
                    onClick = onClickManga,
-                    onClickContinueReading = onClickContinueReading,
                    onLongClick = onLongClickManga,
+                    onClickContinueReading = onClickContinueReading,
                    searchQuery = searchQuery,
                    onGlobalSearchClicked = onGlobalSearchClicked,
                )
--- a/app/src/main/java/eu/kanade/presentation/library/components/LibraryTabs.kt
+++ b/app/src/main/java/eu/kanade/presentation/library/components/LibraryTabs.kt
@@ -5,8 +5,6 @@ import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.ScrollableTabRow
 import androidx.compose.material3.Tab
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.State
-import androidx.compose.runtime.getValue
 import androidx.compose.ui.unit.dp
 import eu.kanade.domain.category.model.Category
 import eu.kanade.presentation.category.visualName
@@ -19,10 +17,9 @@ import eu.kanade.presentation.components.TabText
 fun LibraryTabs(
    categories: List<Category>,
    currentPageIndex: Int,
-    showMangaCount: Boolean,
    isDownloadOnly: Boolean,
    isIncognitoMode: Boolean,
-    getNumberOfMangaForCategory: @Composable (Long) -> State<Int?>,
+    getNumberOfMangaForCategory: (Category) -> Int?,
    onTabItemClick: (Int) -> Unit,
 ) {
    Column {
@@ -41,11 +38,7 @@ fun LibraryTabs(
                    text = {
                        TabText(
                            text = category.visualName,
-                            badgeCount = if (showMangaCount) {
-                                getNumberOfMangaForCategory(category.id)
-                            } else {
-                                null
-                            }?.value,
+                            badgeCount = getNumberOfMangaForCategory(category),
                        )
                    },
                    unselectedContentColor = MaterialTheme.colorScheme.onSurface,
--- a/app/src/main/java/eu/kanade/presentation/library/components/LibraryToolbar.kt
+++ b/app/src/main/java/eu/kanade/presentation/library/components/LibraryToolbar.kt
@@ -14,6 +14,7 @@ import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBarScrollBehavior
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
@@ -23,13 +24,13 @@ import eu.kanade.presentation.components.AppBar
 import eu.kanade.presentation.components.OverflowMenu
 import eu.kanade.presentation.components.Pill
 import eu.kanade.presentation.components.SearchToolbar
-import eu.kanade.presentation.library.LibraryState
 import eu.kanade.presentation.theme.active
 import eu.kanade.tachiyomi.R

@Composable
 fun LibraryToolbar(
-    state: LibraryState,
+    hasActiveFilters: Boolean,
+    selectedCount: Int,
    title: LibraryToolbarTitle,
    incognitoMode: Boolean,
    downloadedOnlyMode: Boolean,
@@ -39,10 +40,12 @@ fun LibraryToolbar(
    onClickFilter: () -> Unit,
    onClickRefresh: () -> Unit,
    onClickOpenRandomManga: () -> Unit,
+    searchQuery: String?,
+    onSearchQueryChange: (String?) -> Unit,
    scrollBehavior: TopAppBarScrollBehavior?,
 ) = when {
-    state.selectionMode -> LibrarySelectionToolbar(
-        state = state,
+    selectedCount > 0 -> LibrarySelectionToolbar(
+        selectedCount = selectedCount,
        incognitoMode = incognitoMode,
        downloadedOnlyMode = downloadedOnlyMode,
        onClickUnselectAll = onClickUnselectAll,
@@ -51,11 +54,11 @@ fun LibraryToolbar(
    )
    else -> LibraryRegularToolbar(
        title = title,
-        hasFilters = state.hasActiveFilters,
+        hasFilters = hasActiveFilters,
        incognitoMode = incognitoMode,
        downloadedOnlyMode = downloadedOnlyMode,
-        searchQuery = state.searchQuery,
-        onChangeSearchQuery = { state.searchQuery = it },
+        searchQuery = searchQuery,
+        onSearchQueryChange = onSearchQueryChange,
        onClickFilter = onClickFilter,
        onClickRefresh = onClickRefresh,
        onClickOpenRandomManga = onClickOpenRandomManga,
@@ -70,7 +73,7 @@ fun LibraryRegularToolbar(
    incognitoMode: Boolean,
    downloadedOnlyMode: Boolean,
    searchQuery: String?,
-    onChangeSearchQuery: (String?) -> Unit,
+    onSearchQueryChange: (String?) -> Unit,
    onClickFilter: () -> Unit,
    onClickRefresh: () -> Unit,
    onClickOpenRandomManga: () -> Unit,
@@ -96,7 +99,7 @@ fun LibraryRegularToolbar(
            }
        },
        searchQuery = searchQuery,
-        onChangeSearchQuery = onChangeSearchQuery,
+        onChangeSearchQuery = onSearchQueryChange,
        actions = {
            val filterTint = if (hasFilters) MaterialTheme.colorScheme.active else LocalContentColor.current
            IconButton(onClick = onClickFilter) {
@@ -128,7 +131,7 @@ fun LibraryRegularToolbar(

@Composable
 fun LibrarySelectionToolbar(
-    state: LibraryState,
+    selectedCount: Int,
    incognitoMode: Boolean,
    downloadedOnlyMode: Boolean,
    onClickUnselectAll: () -> Unit,
@@ -136,7 +139,7 @@ fun LibrarySelectionToolbar(
    onClickInvertSelection: () -> Unit,
 ) {
    AppBar(
-        titleContent = { Text(text = "${state.selection.size}") },
+        titleContent = { Text(text = "$selectedCount") },
        actions = {
            IconButton(onClick = onClickSelectAll) {
                Icon(Icons.Outlined.SelectAll, contentDescription = stringResource(R.string.action_select_all))
@@ -152,6 +155,7 @@ fun LibrarySelectionToolbar(
    )
 }

+@Immutable
 data class LibraryToolbarTitle(
    val text: String,
    val numberOfManga: Int? = null,