yenru0/EhViewer
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup unused res

Browse Source
This commit is contained in:
Lokesh Gidra authored and Vladimir Dostoyevskiy committed 2023-11-20 21:45:40 +08:00
1 parent 3551ed7c7a
commit 21bfd4dd2d
7 files changed
-445
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

app/src/main/kotlin/com/hippo/ehviewer/ui/legacy/AddDeleteDrawable.kt
-149
View File
@@ -1,149 +0,0 @@
/*
* Copyright (C) 2015 Hippo Seven
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.hippo.ehviewer.ui.legacy
import android.animation.ObjectAnimator
import android.content.Context
import android.graphics.Canvas
import android.graphics.ColorFilter
import android.graphics.Paint
import android.graphics.Path
import android.graphics.PixelFormat
import android.graphics.drawable.Drawable
import androidx.annotation.Keep
import com.google.android.material.math.MathUtils
import com.hippo.ehviewer.R
import kotlin.math.roundToInt
/**
* @param context used to get the configuration for the drawable from
*/
class AddDeleteDrawable(context: Context, color: Int) : Drawable() {
private val mPaint = Paint()
private val mPath = Path()
private val mSize: Int
private var mProgress = 0f
private var mAutoUpdateMirror = false
private var mVerticalMirror = false
init {
val resources = context.resources
mSize = resources.getDimensionPixelSize(R.dimen.add_size)
val barThickness = resources.getDimension(R.dimen.add_thickness).roundToInt().toFloat()
mPaint.color = color
mPaint.style = Paint.Style.STROKE
mPaint.strokeJoin = Paint.Join.MITER
mPaint.strokeCap = Paint.Cap.BUTT
mPaint.strokeWidth = barThickness
val halfSize = (mSize / 2).toFloat()
mPath.moveTo(0f, -halfSize)
mPath.lineTo(0f, halfSize)
mPath.moveTo(-halfSize, 0f)
mPath.lineTo(halfSize, 0f)
}
override fun draw(canvas: Canvas) {
val bounds = bounds
val canvasRotate = if (mVerticalMirror) {
MathUtils.lerp(270f, 135f, mProgress)
} else {
MathUtils.lerp(0f, 135f, mProgress)
}
canvas.save()
canvas.translate(bounds.centerX().toFloat(), bounds.centerY().toFloat())
canvas.rotate(canvasRotate)
canvas.drawPath(mPath, mPaint)
canvas.restore()
}
fun setColor(color: Int) {
mPaint.color = color
invalidateSelf()
}
override fun setAlpha(alpha: Int) {
mPaint.alpha = alpha
}
override fun setColorFilter(cf: ColorFilter?) {
mPaint.colorFilter = cf
}
override fun getIntrinsicHeight(): Int {
return mSize * 6 / 5
}
override fun getIntrinsicWidth(): Int {
return mSize * 6 / 5
}
/**
* If set, canvas is flipped when progress reached to end and going back to start.
*/
private fun setVerticalMirror(verticalMirror: Boolean) {
mVerticalMirror = verticalMirror
}
fun setAutoUpdateMirror(autoUpdateMirror: Boolean) {
mAutoUpdateMirror = autoUpdateMirror
}
@get:Keep
@set:Keep
var progress: Float
get() = mProgress
set(progress) {
if (mAutoUpdateMirror) {
if (progress == 1f) {
setVerticalMirror(true)
} else if (progress == 0f) {
setVerticalMirror(false)
}
}
mProgress = progress
invalidateSelf()
}
fun setAdd(duration: Long) {
setShape(false, duration)
}
fun setDelete(duration: Long) {
setShape(true, duration)
}
private fun setShape(delete: Boolean, duration: Long) {
if (!(!delete && mProgress == 0f || delete && mProgress == 1f)) {
val endProgress = if (delete) 1f else 0f
if (duration <= 0) {
progress = endProgress
} else {
val oa = ObjectAnimator.ofFloat(this, "progress", endProgress)
oa.duration = duration
oa.setAutoCancel(true)
oa.start()
}
}
}
@Deprecated(
"Deprecated in Java",
ReplaceWith("PixelFormat.TRANSLUCENT", "android.graphics.PixelFormat"),
)
override fun getOpacity(): Int {
return PixelFormat.TRANSLUCENT
}
}
app/src/main/kotlin/com/hippo/ehviewer/ui/legacy/LayoutManagerUtils.kt
-124
View File
@@ -15,139 +15,15 @@
*/
package com.hippo.ehviewer.ui.legacy
import android.content.Context
import android.graphics.PointF
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView.LayoutManager
import androidx.recyclerview.widget.StaggeredGridLayoutManager
import com.google.android.material.math.MathUtils
import com.hippo.ehviewer.util.SimpleHandler
import java.lang.reflect.InvocationTargetException
import java.lang.reflect.Method
import kotlin.math.abs
object LayoutManagerUtils {
private var sCsdfp: Method? = null
init {
try {
sCsdfp = StaggeredGridLayoutManager::class.java.getDeclaredMethod(
"calculateScrollDirectionForPosition",
Int::class.javaPrimitiveType,
).apply { isAccessible = true }
} catch (e: NoSuchMethodException) {
// Ignore
e.printStackTrace()
}
}
fun scrollToPositionWithOffset(
layoutManager: LayoutManager,
position: Int,
offset: Int,
) {
when (layoutManager) {
is LinearLayoutManager -> layoutManager.scrollToPositionWithOffset(position, offset)
is StaggeredGridLayoutManager ->
layoutManager.scrollToPositionWithOffset(position, offset)
else -> throw IllegalStateException("Can't do scrollToPositionWithOffset for " + layoutManager.javaClass.name)
}
}
fun smoothScrollToPosition(
layoutManager: LayoutManager,
context: Context,
position: Int,
millisecondsPerInch: Int = -1,
) {
val smoothScroller: SimpleSmoothScroller
when (layoutManager) {
is LinearLayoutManager -> {
smoothScroller =
object : SimpleSmoothScroller(context, millisecondsPerInch.toFloat()) {
override fun computeScrollVectorForPosition(targetPosition: Int): PointF? {
return layoutManager.computeScrollVectorForPosition(targetPosition)
}
}
}
is StaggeredGridLayoutManager -> {
smoothScroller =
object : SimpleSmoothScroller(context, millisecondsPerInch.toFloat()) {
override fun computeScrollVectorForPosition(targetPosition: Int): PointF? {
var direction = 0
try {
direction = sCsdfp!!.invoke(layoutManager, targetPosition) as Int
} catch (e: IllegalAccessException) {
e.printStackTrace()
} catch (e: InvocationTargetException) {
e.printStackTrace()
}
if (direction == 0) {
return null
}
return if (layoutManager.orientation == StaggeredGridLayoutManager.HORIZONTAL) {
PointF(direction.toFloat(), 0f)
} else {
PointF(0f, direction.toFloat())
}
}
}
}
else -> throw IllegalStateException("Can't do smoothScrollToPosition for " + layoutManager.javaClass.name)
}
smoothScroller.targetPosition = position
layoutManager.startSmoothScroll(smoothScroller)
}
fun scrollToPositionProperly(
layoutManager: LayoutManager,
context: Context,
position: Int,
listener: OnScrollToPositionListener?,
) {
SimpleHandler.postDelayed({
val first = layoutManager.firstVisibleItemPosition
val last = getLastVisibleItemPosition(layoutManager)
val offset = abs(position - first)
val max = last - first
if (offset < max && max > 0) {
smoothScrollToPosition(
layoutManager,
context,
position,
MathUtils.lerp(100F, 25F, (offset / max).toFloat()).toInt(),
)
} else {
scrollToPositionWithOffset(layoutManager, position, 0)
listener?.onScrollToPosition(position)
}
}, 200)
}
val LayoutManager.firstVisibleItemPosition: Int
get() = when (this) {
is LinearLayoutManager -> findFirstVisibleItemPosition()
is StaggeredGridLayoutManager -> findFirstVisibleItemPositions(null).min()
else -> error("Can't do getFirstVisibleItemPosition for " + javaClass.name)
}
fun getLastVisibleItemPosition(layoutManager: LayoutManager): Int {
return when (layoutManager) {
is LinearLayoutManager -> layoutManager.findLastVisibleItemPosition()
is StaggeredGridLayoutManager -> {
val positions = layoutManager.findLastVisibleItemPositions(null)
positions.max()
}
else -> throw IllegalStateException("Can't do getLastVisibleItemPosition for " + layoutManager.javaClass.name)
}
}
fun interface OnScrollToPositionListener {
fun onScrollToPosition(position: Int)
}
}
app/src/main/kotlin/com/hippo/ehviewer/ui/legacy/SimpleSmoothScroller.kt
-38
View File
@@ -1,38 +0,0 @@
/*
* Copyright (C) 2015 Hippo Seven
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.hippo.ehviewer.ui.legacy
import android.content.Context
import androidx.recyclerview.widget.LinearSmoothScroller
import kotlin.math.abs
import kotlin.math.ceil
abstract class SimpleSmoothScroller(context: Context, millisecondsPerInch: Float) :
LinearSmoothScroller(context) {
private val mMillisecondsPerPx: Float
init {
mMillisecondsPerPx = millisecondsPerInch / context.resources.displayMetrics.densityDpi
}
override fun calculateTimeForScrolling(dx: Int): Int {
return if (mMillisecondsPerPx <= 0) {
super.calculateTimeForScrolling(dx)
} else {
ceil((abs(dx) * mMillisecondsPerPx).toDouble()).toInt()
}
}
}
app/src/main/kotlin/com/hippo/ehviewer/ui/legacy/WindowInsetsAnimationHelper.kt
-95
View File
@@ -1,95 +0,0 @@
/*
* Copyright 2022 Tarsin Norbin
*
* This file is part of EhViewer
*
* EhViewer 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.
*
* EhViewer 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 EhViewer.
* If not, see <https://www.gnu.org/licenses/>.
*/
package com.hippo.ehviewer.ui.legacy
import android.view.View
import androidx.core.view.WindowInsetsAnimationCompat
import androidx.core.view.WindowInsetsAnimationCompat.BoundsCompat
import androidx.core.view.WindowInsetsCompat
import com.google.android.material.math.MathUtils
class WindowInsetsAnimationHelper(dispatchMode: Int, vararg views: View) :
WindowInsetsAnimationCompat.Callback(dispatchMode) {
private val views: Array<View>
private val startPaddings = HashMap<View, Int>()
private val endPaddings = HashMap<View, Int>()
var animation: WindowInsetsAnimationCompat? = null
init {
this.views = arrayOf(*views)
}
override fun onPrepare(animation: WindowInsetsAnimationCompat) {
super.onPrepare(animation)
this.animation = animation
for (view in views) {
startPaddings[view] = view.paddingBottom
}
}
override fun onStart(
animation: WindowInsetsAnimationCompat,
bounds: BoundsCompat,
): BoundsCompat {
this.animation = animation
for (view in views) {
endPaddings[view] = view.paddingBottom
val startPadding = if (startPaddings.containsKey(view)) startPaddings[view]!! else 0
view.translationY = -(startPadding - view.paddingBottom).toFloat()
}
return bounds
}
override fun onProgress(
insets: WindowInsetsCompat,
runningAnimations: List<WindowInsetsAnimationCompat>,
): WindowInsetsCompat {
if (animation == null) {
return insets
}
var imeAnimation: WindowInsetsAnimationCompat? = null
for (animation in runningAnimations) {
if (animation.typeMask and WindowInsetsCompat.Type.ime() != 0) {
imeAnimation = animation
break
}
}
if (imeAnimation != null) {
for (view in views) {
val startPadding = if (startPaddings.containsKey(view)) startPaddings[view]!! else 0
val endPadding = if (endPaddings.containsKey(view)) endPaddings[view]!! else 0
view.translationY = MathUtils.lerp(
(endPadding - startPadding).toFloat(),
0f,
animation!!.interpolatedFraction,
)
}
}
return insets
}
override fun onEnd(animation: WindowInsetsAnimationCompat) {
super.onEnd(animation)
startPaddings.clear()
endPaddings.clear()
this.animation = null
for (view in views) {
view.translationY = 0f
}
}
}
app/src/main/kotlin/com/hippo/ehviewer/util/AnimationUtils.kt
-2
View File
@@ -17,11 +17,9 @@ package com.hippo.ehviewer.util
import android.view.animation.Interpolator
import androidx.interpolator.view.animation.FastOutLinearInInterpolator
import androidx.interpolator.view.animation.FastOutSlowInInterpolator
import androidx.interpolator.view.animation.LinearOutSlowInInterpolator
object AnimationUtils {
val FAST_SLOW_INTERPOLATOR: Interpolator = LinearOutSlowInInterpolator()
val SLOW_FAST_INTERPOLATOR: Interpolator = FastOutLinearInInterpolator()
val SLOW_FAST_SLOW_INTERPOLATOR: Interpolator = FastOutSlowInInterpolator()
}
app/src/main/kotlin/com/hippo/ehviewer/util/WindowInsetsUtil.kt
-10
View File
@@ -1,14 +1,12 @@
package com.hippo.ehviewer.util
import android.graphics.Rect
import android.view.View
import androidx.compose.foundation.layout.WindowInsets
import androidx.compose.runtime.Composable
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.platform.LocalLayoutDirection
import androidx.core.graphics.Insets
import androidx.core.view.WindowInsetsCompat
import dev.chrisbanes.insetter.applyInsetter
import kotlin.contracts.InvocationKind
import kotlin.contracts.contract
@@ -47,11 +45,3 @@ fun WindowInsetsCompat.Builder.set(type: Int, insets: WindowInsets): WindowInset
),
)
}
fun View.applyNavigationBarsPadding() {
applyInsetter {
type(navigationBars = true) {
padding()
}
}
}
app/src/main/res/layout/scene_favorites.xml
-27
View File
@@ -1,27 +0,0 @@
<?xml version="1.0" encoding="utf-8"?><!--
~ Copyright 2016 Hippo Seven
~
~ Licensed under the Apache License, Version 2.0 (the "License");
~ you may not use this file except in compliance with the License.
~ You may obtain a copy of the License at
~
~ http://www.apache.org/licenses/LICENSE-2.0
~
~ Unless required by applicable law or agreed to in writing, software
~ distributed under the License is distributed on an "AS IS" BASIS,
~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
~ See the License for the specific language governing permissions and
~ limitations under the License.
-->
<merge xmlns:android="http://schemas.android.com/apk/res/android">
<include
android:id="@+id/content_layout"
layout="@layout/widget_content_layout" />
<com.hippo.ehviewer.ui.legacy.FabLayout
android:id="@+id/fab_layout"
android:layout_width="match_parent"
android:layout_height="match_parent" />
</merge>