1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
/*
* Copyright (C) 2012 The Android Open Source Project 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.cyanogenmod.eleven.widgets;
import android.content.Context;
import android.view.View;
import android.widget.FrameLayout;
/**
* A View that other Views can use to create a touch-interceptor layer above
* their other sub-views. This layer can be enabled and disabled; when enabled,
* clicks are intercepted and passed to a listener. Also supports an alpha layer
* to dim the content underneath. By default, the alpha layer is the same View
* as the touch-interceptor layer. However, for some use-cases, you want a few
* Views to not be dimmed, but still have touches intercepted. In this case, you
* can specify the View to use as the alpha layer via setAlphaLayer(); in this
* case you are responsible for managing the z-order of the alpha-layer with
* respect to your other sub-views. Typically, you would not use this class
* directly, but rather use another class that uses it, for example
* {@link FrameLayoutWithOverlay}.
*/
public class AlphaTouchInterceptorOverlay extends FrameLayout {
private final View mInterceptorLayer;
private float mAlpha = 0.0f;
private View mAlphaLayer;
/**
* @param context The {@link Context} to use.
*/
public AlphaTouchInterceptorOverlay(final Context context) {
super(context);
mInterceptorLayer = new View(context);
mInterceptorLayer.setBackgroundColor(0);
addView(mInterceptorLayer);
mAlphaLayer = this;
}
/**
* Set the View that the overlay will use as its alpha-layer. If none is set
* it will use itself. Only necessary to set this if some child views need
* to appear above the alpha-layer but below the touch-interceptor.
*/
public void setAlphaLayer(final View alphaLayer) {
if (mAlphaLayer == alphaLayer) {
return;
}
/* We're no longer the alpha-layer, so make ourself invisible. */
if (mAlphaLayer == this) {
setAlphaOnViewBackground(this, 0.0f);
}
mAlphaLayer = alphaLayer == null ? this : alphaLayer;
setAlphaLayerValue(mAlpha);
}
/** Sets the alpha value on the alpha layer. */
public void setAlphaLayerValue(final float alpha) {
mAlpha = alpha;
if (mAlphaLayer != null) {
setAlphaOnViewBackground(mAlphaLayer, mAlpha);
}
}
/** Delegate to interceptor-layer. */
public void setOverlayOnClickListener(final OnClickListener listener) {
mInterceptorLayer.setOnClickListener(listener);
}
/** Delegate to interceptor-layer. */
public void setOverlayClickable(final boolean clickable) {
mInterceptorLayer.setClickable(clickable);
}
/**
* Sets an alpha value on the view.
*/
public static void setAlphaOnViewBackground(final View view, final float alpha) {
if (view != null) {
view.setBackgroundColor((int)(clamp(alpha, 0.0f, 1.0f) * 255) << 24);
}
}
/**
* If the input value lies outside of the specified range, return the nearer
* bound. Otherwise, return the input value, unchanged.
*/
public static float clamp(final float input, final float lowerBound, final float upperBound) {
if (input < lowerBound) {
return lowerBound;
} else if (input > upperBound) {
return upperBound;
}
return input;
}
}
|
