Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.WazaBe.HoloEverywhere;
  
  
 
 
 public class ProgressBar extends View {
 	private class AccessibilityEventSender implements Runnable {
 		public void run() {
 		}
 	}
 
 	private static class RefreshData implements Poolable<RefreshData> {
 		private static final int POOL_MAX = 24;
 		private static final Pool<RefreshDatasPool = Pools
 							public RefreshData newInstance() {
 								return new RefreshData();
 							}
 
 							public void onAcquired(RefreshData element) {
 							}
 
 							public void onReleased(RefreshData element) {
 							}
 						}, ));
 
 		public static RefreshData obtain(int idint progressboolean fromUser) {
 			rd.id = id;
 			rd.progress = progress;
 			rd.fromUser = fromUser;
 			return rd;
 		}
 
 		public boolean fromUser;
 		public int id;
 		private boolean mIsPooled;
 		private RefreshData mNext;
 
 		public int progress;
 
 			return ;
 		}
 
 		public boolean isPooled() {
 			return ;
 		}
 
 		public void recycle() {
 			.release(this);
 		}
		public void setNextPoolable(RefreshData element) {
			 = element;
		}
		public void setPooled(boolean isPooled) {
			 = isPooled;
		}
	}
	private class RefreshProgressRunnable implements Runnable {
		public void run() {
			synchronized (ProgressBar.this) {
				final int count = .size();
				for (int i = 0; i < counti++) {
					final RefreshData rd = .get(i);
					doRefreshProgress(rd.idrd.progressrd.fromUsertrue);
					rd.recycle();
				}
			}
		}
	}
	protected static class SavedState extends BaseSavedState {
		public static final Parcelable.Creator<SavedStateCREATOR = new Parcelable.Creator<SavedState>() {
				return new SavedState(in);
			}
			public SavedState[] newArray(int size) {
				return new SavedState[size];
			}
		};
		protected SavedState(Parcel in) {
			super(in);
			 = in.readInt();
		}
		protected SavedState(Parcelable superState) {
			super(superState);
		}
		public void writeToParcel(Parcel outint flags) {
			super.writeToParcel(outflags);
		}
	}
	private static final int MAX_LEVEL = 10000;
	private static final int TIMEOUT_SEND_ACCESSIBILITY_EVENT = 200;
	private boolean mAttached;
	private int mBehavior;
	private int mDuration;
	private boolean mHasAnimation;
	private boolean mIndeterminate;
	private boolean mInDrawing;
	private int mMax;
	private boolean mNoInvalidate;
	private boolean mOnlyIndeterminate;
	private int mProgress;
	private boolean mRefreshIsPosted;
	private int mSecondaryProgress;
	private long mUiThreadId;
	public ProgressBar(Context context) {
		this(contextnull);
	}
	public ProgressBar(Context contextAttributeSet attrs) {
		this(contextattrs...);
	}
	public ProgressBar(Context contextAttributeSet attrsint defStyle) {
		this(contextattrsdefStyle, 0);
	}
	public ProgressBar(Context contextAttributeSet attrsint defStyle,
			int styleRes) {
		super(contextattrsdefStyle);
		TypedArray a = context.obtainStyledAttributes(attrs,
				..defStylestyleRes);
		 = true;
		Drawable drawable = getDrawable(a,
		if (drawable != null) {
			drawable = tileify(drawablefalse);
		}
		final int resID = a.getResourceId(
		if (resID > 0) {
			setInterpolator(contextresID);
		}
		drawable = getDrawable(a,
		if (drawable != null) {
			drawable = tileifyIndeterminate(drawable);
		}
		 = false;
	}
	private synchronized void doRefreshProgress(int idint progress,
			boolean fromUserboolean callBackToApp) {
		float scale =  > 0 ? (floatprogress / (float : 0;
		if (d != null) {
			Drawable progressDrawable = null;
			if (d instanceof LayerDrawable) {
				progressDrawable = ((LayerDrawabled)
			}
			final int level = (int) (scale * );
			(progressDrawable != null ? progressDrawable : d).setLevel(level);
else {
		}
		if (callBackToApp && id == ..) {
			onProgressRefresh(scalefromUser);
		}
	}
	protected void drawableStateChanged() {
	}
	}
	private Drawable getDrawable(TypedArray aint attr) {
		Drawable d = a.getDrawable(attr);
		try {
			int id = a.getResourceId(attr, 0);
				LayerDrawable layers = (LayerDrawabled;
						truetrue, 0.5f, 0.5f, 720f, 0f);
			}
catch (Exception e) {
		}
		return d;
	}
	private Shape getDrawableShape() {
		final float[] roundedCorners = new float[] { 5, 5, 5, 5, 5, 5, 5, 5 };
		return new RoundRectShape(roundedCornersnullnull);
	}
	}
	}
	@ViewDebug.ExportedProperty(category = "progress")
	public synchronized int getMax() {
		return ;
	}
	@ViewDebug.ExportedProperty(category = "progress")
	public synchronized int getProgress() {
		return  ? 0 : ;
	}
	}
		return who ==  || who ==  ? ReflectHelper
				.invoke(this"getResolvedLayoutDirection"int.class)
				: ReflectHelper.invoke(this"getResolvedLayoutDirection",
						int.classtruenew Object[] { who });
	}
	@ViewDebug.ExportedProperty(category = "progress")
	public synchronized int getSecondaryProgress() {
	}
	public synchronized final void incrementProgressBy(int diff) {
	}
	public synchronized final void incrementSecondaryProgressBy(int diff) {
	}
	private void initProgressBar() {
		 = 100;
		 = 0;
		 = false;
		 = 4000;
		 = 24;
		 = 48;
		 = 24;
		 = 48;
	}
	public void invalidateDrawable(Drawable dr) {
		if (!) {
			if (verifyDrawable(dr)) {
				final Rect dirty = dr.getBounds();
				final int scrollX = getScrollX() + getPaddingLeft();
				final int scrollY = getScrollY() + getPaddingTop();
				invalidate(dirty.left + scrollXdirty.top + scrollY,
						dirty.right + scrollXdirty.bottom + scrollY);
else {
			}
		}
	}
	@ViewDebug.ExportedProperty(category = "progress")
	public synchronized boolean isIndeterminate() {
	}
	@SuppressLint("NewApi")
	public void jumpDrawablesToCurrentState() {
		if ( != null) {
		}
		if ( != null) {
		}
	}
	protected void onAttachedToWindow() {
		}
		if ( != null) {
			synchronized (this) {
				final int count = .size();
				for (int i = 0; i < counti++) {
					final RefreshData rd = .get(i);
					doRefreshProgress(rd.idrd.progressrd.fromUsertrue);
					rd.recycle();
				}
			}
		}
		 = true;
	}
	protected void onDetachedFromWindow() {
		}
		if ( != null) {
		}
		}
		if ( != null) {
		}
		 = false;
	}
	protected synchronized void onDraw(Canvas canvas) {
		super.onDraw(canvas);
		if (d != null) {
			canvas.save();
			long time = getDrawingTime();
				float scale = .getAlpha();
				try {
					 = true;
					d.setLevel((int) (scale * ));
finally {
					 = false;
				}
			}
			d.draw(canvas);
			canvas.restore();
			if ( && d instanceof Animatable) {
				((Animatabled).start();
			}
		}
	}
	@SuppressLint("NewApi")
	}
	@SuppressLint("NewApi")
	}
	protected synchronized void onMeasure(int widthMeasureSpec,
			int heightMeasureSpec) {
		int dw = 0;
		int dh = 0;
		if (d != null) {
			dw = Math
			dh = Math.max(,
		}
		setMeasuredDimension(resolveSizeAndState(dwwidthMeasureSpec, 0),
				resolveSizeAndState(dhheightMeasureSpec, 0));
	}
	protected void onProgressRefresh(float scaleboolean fromUser) {
		try {
					"getInstance"Context.class).invoke(nullgetContext()))
					.isEnabled()) {
			}
catch (Exception e) {
		}
	}
	public void onRestoreInstanceState(Parcelable state) {
		SavedState ss = (SavedStatestate;
		setProgress(ss.progress);
		setSecondaryProgress(ss.secondaryProgress);
	}
		Parcelable superState = super.onSaveInstanceState();
		SavedState ss = new SavedState(superState);
		ss.progress = ;
		ss.secondaryProgress = ;
		return ss;
	}
	protected void onSizeChanged(int wint hint oldwint oldh) {
	}
	public void onVisibilityChanged(View changedViewint visibility) {
		super.onVisibilityChanged(changedViewvisibility);
			if (visibility ==  || visibility == ) {
else {
			}
		}
	}
	public void postInvalidate() {
		if (!) {
		}
	}
	private synchronized void refreshProgress(int idint progress,
			boolean fromUser) {
		if ( == Thread.currentThread().getId()) {
			doRefreshProgress(idprogressfromUsertrue);
else {
			if ( == null) {
			}
			final RefreshData rd = RefreshData.obtain(idprogressfromUser);
			}
		}
	}
		if ( == null) {
else {
		}
	}
	public synchronized void setIndeterminate(boolean indeterminate) {
				&& indeterminate != ) {
			 = indeterminate;
			if (indeterminate) {
				// swap between indeterminate and regular backgrounds
else {
			}
		}
	}
		if (d != null) {
			d.setCallback(this);
		}
		}
	}
	public void setInterpolator(Context contextint resID) {
		setInterpolator(AnimationUtils.loadInterpolator(contextresID));
	}
	public void setInterpolator(Interpolator interpolator) {
		 = interpolator;
	}
	public synchronized void setMax(int max) {
		if (max < 0) {
			max = 0;
		}
		if (max != ) {
			 = max;
			if ( > max) {
				 = max;
			}
		}
	}
	public synchronized void setProgress(int progress) {
		setProgress(progressfalse);
	}
	synchronized void setProgress(int progressboolean fromUser) {
			return;
		}
		if (progress < 0) {
			progress = 0;
		}
		if (progress > ) {
			progress = ;
		}
		if (progress != ) {
			 = progress;
		}
	}
	public void setProgressDrawable(Drawable d) {
		boolean needUpdate;
		if ( != null && d != ) {
			needUpdate = true;
else {
			needUpdate = false;
		}
		if (d != null) {
			d.setCallback(this);
			int drawableHeight = d.getMinimumHeight();
			if ( < drawableHeight) {
				 = drawableHeight;
			}
		}
		}
		if (needUpdate) {
					falsefalse);
		}
	}
	public synchronized void setSecondaryProgress(int secondaryProgress) {
			return;
		}
		if (secondaryProgress < 0) {
			secondaryProgress = 0;
		}
		if (secondaryProgress > ) {
			secondaryProgress = ;
		}
		if (secondaryProgress != ) {
			 = secondaryProgress;
		}
	}
	public void setVisibility(int v) {
		if (getVisibility() != v) {
			super.setVisibility(v);
				if (v ==  || v == ) {
else {
				}
			}
		}
	}
	void startAnimation() {
		if (getVisibility() != ) {
			return;
		}
		if ( instanceof Animatable) {
			 = false;
else {
			 = true;
			if ( == null) {
			}
			if ( == null) {
else {
			}
			if ( == null) {
				 = new AlphaAnimation(0.0f, 1.0f);
else {
			}
		}
	}
	void stopAnimation() {
		 = false;
		if ( instanceof Animatable) {
		}
	}
	private Drawable tileify(Drawable drawableboolean clip) {
		if (drawable instanceof LayerDrawable) {
			LayerDrawable background = (LayerDrawabledrawable;
			final int N = background.getNumberOfLayers();
			Drawable[] outDrawables = new Drawable[N];
			for (int i = 0; i < Ni++) {
				int id = background.getId(i);
				outDrawables[i] = tileify(background.getDrawable(i),
						id == .. || id == ..);
			}
			LayerDrawable newBg = new LayerDrawable(outDrawables);
			for (int i = 0; i < Ni++) {
				newBg.setId(ibackground.getId(i));
			}
			return newBg;
else if (drawable instanceof StateListDrawable) {
			int numStates = ReflectHelper
					.invoke(in"getStateCount"int.class);
			for (int i = 0; i < numStatesi++) {
						ReflectHelper.invoke(in"getStateSet"int[].classi),
						tileify(ReflectHelper.invoke(in"getStateDrawable",
								Drawable.classi), clip));
			}
			return out;
else if (drawable instanceof BitmapDrawable) {
			final Bitmap tileBitmap = ((BitmapDrawabledrawable).getBitmap();
			if ( == null) {
				 = tileBitmap;
			}
			final ShapeDrawable shapeDrawable = new ShapeDrawable(
			final BitmapShader bitmapShader = new BitmapShader(tileBitmap,
			shapeDrawable.getPaint().setShader(bitmapShader);
			return clip ? new ClipDrawable(shapeDrawable.,
					.) : shapeDrawable;
		}
		return drawable;
	}
	private Drawable tileifyIndeterminate(Drawable drawable) {
		if (drawable instanceof AnimationDrawable) {
			AnimationDrawable background = (AnimationDrawabledrawable;
			final int N = background.getNumberOfFrames();
			newBg.setOneShot(background.isOneShot());
			for (int i = 0; i < Ni++) {
				Drawable frame = tileify(background.getFrame(i), true);
				frame.setLevel(10000);
				newBg.addFrame(framebackground.getDuration(i));
			}
			newBg.setLevel(10000);
			drawable = newBg;
		}
		return drawable;
	}
	private void updateDrawableBounds(int wint h) {
		int right = w - getPaddingRight() - getPaddingLeft();
		int bottom = h - getPaddingBottom() - getPaddingTop();
		int top = 0;
		int left = 0;
		if ( != null) {
				final int intrinsicWidth = 
				final int intrinsicHeight = 
				final float intrinsicAspect = (floatintrinsicWidth
intrinsicHeight;
				final float boundAspect = (floatw / h;
				if (intrinsicAspect != boundAspect) {
					if (boundAspect > intrinsicAspect) {
						final int width = (int) (h * intrinsicAspect);
						left = (w - width) / 2;
						right = left + width;
else {
						final int height = (int) (w * (1 / intrinsicAspect));
						top = (h - height) / 2;
						bottom = top + height;
					}
				}
			}
			.setBounds(lefttoprightbottom);
		}
		if ( != null) {
			.setBounds(0, 0, rightbottom);
		}
	}
	private void updateDrawableState() {
		int[] state = getDrawableState();
		}
		}
	}
	protected boolean verifyDrawable(Drawable who) {
		return who ==  || who == 
				|| super.verifyDrawable(who);
	}