src/com/cooliris/media/DisplayItem.java - platform/packages/apps/Gallery3D - Git at Google

 /*
  * Copyright (C) 2009 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.cooliris.media;

 import java.util.Random;

 import android.content.Context;

 import com.cooliris.app.App;
 import com.cooliris.media.FloatUtils;

 /**
  * A simple structure for a MediaItem that can be rendered.
  */
 public final class DisplayItem {
     private static final float STACK_SPACING = 0.2f;
     private DirectLinkedList.Entry<DisplayItem> mAnimatablesEntry = new DirectLinkedList.Entry<DisplayItem>(this);
     private static final Random random = new Random();
     private Vector3f mStacktopPosition = new Vector3f(-1.0f, -1.0f, -1.0f);
     private Vector3f mJitteredPosition = new Vector3f();
     private boolean mHasFocus;
     private Vector3f mTargetPosition = new Vector3f();
     private float mTargetTheta;
     private float mImageTheta;
     private int mStackId;
     private MediaItemTexture mThumbnailImage = null;
     private Texture mScreennailImage = null;
     private UriTexture mHiResImage = null;
     private float mConvergenceSpeed = 1.0f;

     public final MediaItem mItemRef;
     public float mAnimatedTheta;
     public float mAnimatedImageTheta;
     public float mAnimatedPlaceholderFade = 0f;
     public boolean mAlive;
     public Vector3f mAnimatedPosition = new Vector3f();
     public int mCurrentSlotIndex;
     private boolean mPerformingScale;
     private float mSpan;
     private float mSpanDirection;
     private float mStartOffset;
     private float mSpanSpeed;
     private static final String TAG = "DisplayItem";

     public DisplayItem(MediaItem item) {
         mItemRef = item;
         mAnimatedImageTheta = item.mRotation;
         mImageTheta = item.mRotation;
         if (item == null)
             throw new UnsupportedOperationException("Cannot create a displayitem from a null MediaItem.");
         mCurrentSlotIndex = Shared.INVALID;
     }

     public DirectLinkedList.Entry<DisplayItem> getAnimatablesEntry() {
         return mAnimatablesEntry;
     }

     public final void rotateImageBy(float theta) {
         mImageTheta += theta;
     }

     public final void set(Vector3f position, int stackIndex, boolean performTransition) {
         mConvergenceSpeed = 1.0f;
         Vector3f animatedPosition = mAnimatedPosition;
         Vector3f targetPosition = mTargetPosition;
         int seed = stackIndex;
         int randomSeed = stackIndex;

         if (seed > 3) {
             seed = 3;
             randomSeed = 0;
         }

         if (!mAlive) {
             animatedPosition.set(position);
             animatedPosition.z = -3.0f + stackIndex * STACK_SPACING;
         }

         targetPosition.set(position);
         if (mStackId != stackIndex && stackIndex >= 0) {
             mStackId = stackIndex;
         }

         if (randomSeed == 0) {
             if (stackIndex == 0) {
                 mTargetTheta = 0.0f;
             } else if (mTargetTheta == 0.0f){
                 mTargetTheta = 30.0f * (0.5f - (float) Math.random());
             }
             mTargetPosition.z = seed * STACK_SPACING;
             mJitteredPosition.set(0, 0, seed * STACK_SPACING);
         } else {
             int sign = (seed % 2 == 0) ? 1 : -1;
             if (seed != 0 && !mStacktopPosition.equals(position) && mTargetTheta == 0) {
                 mTargetTheta = 30.0f * (0.5f - (float) Math.random());
                 mJitteredPosition.x = sign * 12.0f * seed + (0.5f - random.nextFloat()) * 4 * seed;
                 mJitteredPosition.y = sign * 4 + ((sign == 1) ? -8.0f : sign * (random.nextFloat()) * 16.0f);
                 mJitteredPosition.x *= App.PIXEL_DENSITY;
                 mJitteredPosition.y *= App.PIXEL_DENSITY;
                 mJitteredPosition.z = seed * STACK_SPACING;
             }
         }
         mTargetPosition.add(mJitteredPosition);
         mStacktopPosition.set(position);
         mStartOffset = 0.0f;
     }

     public int getStackIndex() {
         return mStackId;
     }

     public Texture getThumbnailImage(Context context, MediaItemTexture.Config config) {
         MediaItemTexture texture = mThumbnailImage;
         if (texture == null && config != null) {
             if (mItemRef.mId != Shared.INVALID) {
                 texture = new MediaItemTexture(context, config, mItemRef);
             }
             mThumbnailImage = texture;
         }
         return texture;
     }

     public Texture getScreennailImage(Context context) {
         Texture texture = mScreennailImage;
         if (texture == null || texture.mState == Texture.STATE_ERROR) {
             MediaSet parentMediaSet = mItemRef.mParentMediaSet;
             if (parentMediaSet != null && parentMediaSet.mDataSource.getThumbnailCache() == LocalDataSource.sThumbnailCache) {
                 if (mItemRef.mId != Shared.INVALID && mItemRef.mId != 0) {
                     texture = new MediaItemTexture(context, null, mItemRef);
                 } else if (mItemRef.mContentUri != null) {
                     texture = new UriTexture(mItemRef.mContentUri);
                 }
             } else {
                 texture = new UriTexture(mItemRef.mScreennailUri);
                 ((UriTexture) texture).setCacheId(Utils.Crc64Long(mItemRef.mFilePath));
             }
             mScreennailImage = texture;
         }
         return texture;
     }

     public void clearScreennailImage() {
         if (mScreennailImage != null) {
             mScreennailImage = null;
             mHiResImage = null;
         }
     }

     public void clearHiResImage() {
         mHiResImage = null;
     }

     public void clearThumbnail() {
         mThumbnailImage = null;
     }

     /**
      * Use this function to query the animation state of the display item
      *
      * @return true if the display item is animating
      */
     public boolean isAnimating() {
         return mAlive
                 && (mPerformingScale ||
                         !mAnimatedPosition.equals(mTargetPosition) || mAnimatedTheta != mTargetTheta
                         || mAnimatedImageTheta != mImageTheta || mAnimatedPlaceholderFade != 1f);
     }

     /**
      * This function should be called every time the frame needs to be updated.
      */
     public final void update(float timeElapsedInSec) {
         if (mAlive) {
             timeElapsedInSec *= 1.25f;
             Vector3f animatedPosition = mAnimatedPosition;
             Vector3f targetPosition = mTargetPosition;
             timeElapsedInSec *= mConvergenceSpeed;
             animatedPosition.x = FloatUtils.animate(animatedPosition.x, targetPosition.x, timeElapsedInSec);
             animatedPosition.y = FloatUtils.animate(animatedPosition.y, targetPosition.y, timeElapsedInSec);
             mAnimatedTheta = FloatUtils.animate(mAnimatedTheta, mTargetTheta, timeElapsedInSec);
             mAnimatedImageTheta = FloatUtils.animate(mAnimatedImageTheta, mImageTheta, timeElapsedInSec);
             mAnimatedPlaceholderFade = FloatUtils.animate(mAnimatedPlaceholderFade, 1f, timeElapsedInSec);
             animatedPosition.z = FloatUtils.animate(animatedPosition.z, targetPosition.z, timeElapsedInSec);
         }
     }

     /**
      * Commits all animations for the Display Item
      */
     public final void commit() {
         mAnimatedPosition.set(mTargetPosition);
         mAnimatedTheta = mTargetTheta;
         mAnimatedImageTheta = mImageTheta;
     }

     public final void setHasFocus(boolean hasFocus, boolean pushDown) {
         mConvergenceSpeed = 2.0f;
         mHasFocus = hasFocus;
         int seed = mStackId;
         if (seed > 3) {
             seed = 3;
         }
         if (hasFocus) {
             mTargetPosition.set(mStacktopPosition);
             mTargetPosition.add(mJitteredPosition);
             mTargetPosition.add(mJitteredPosition);
             mTargetPosition.z = seed * STACK_SPACING + (pushDown ? 1.0f : -0.5f);
         } else {
             mTargetPosition.set(mStacktopPosition);
             mTargetPosition.add(mJitteredPosition);
             mTargetPosition.z = seed * STACK_SPACING;
         }
     }

     public final void setSingleOffset(boolean useOffset, boolean pushAway, float x, float y, float z, float spreadValue) {
         int seed = mStackId;
         if (useOffset) {
             mTargetPosition.set(mStacktopPosition);
             if (spreadValue > 4.0f)
                 spreadValue = 4.0f + 0.1f * spreadValue;
             if (spreadValue < 1.0f) {
                 spreadValue = 1.0f / spreadValue;
                 pushAway = true;
             }
             if (!pushAway) {
                 if (seed == 0) {
                     mTargetPosition.add(0, -spreadValue * 14, 0);
                 }
                 if (seed == 1) {
                     mTargetPosition.add(-spreadValue * 32, 0, 0);
                 }
                 if (seed == 2) {
                     mTargetPosition.add(0, spreadValue * 14, 0);
                 }
                 if (seed == 3) {
                     mTargetPosition.add(spreadValue * 32, 0, 0);
                 }
                 mTargetPosition.z = -1.0f * spreadValue + seed * STACK_SPACING * spreadValue;
                 mTargetTheta = 0.0f;
             } else {
                 mTargetPosition.z = seed * STACK_SPACING + spreadValue * 0.5f;
             }
         } else {
             if (seed > 3) {
                 seed = 3;
             }
             mTargetPosition.set(mStacktopPosition);
             mTargetPosition.add(mJitteredPosition);
             mTargetPosition.z = seed * STACK_SPACING;
             if (seed != 0 && mTargetTheta == 0.0f) {
                 mTargetTheta = 30.0f * (0.5f - (float) Math.random());
             }
             mStartOffset = 0.0f;
         }
     }

     public final void setOffset(boolean useOffset, boolean pushDown, float span, float dx1, float dy1, float dx2, float dy2) {
         int seed = mStackId;
         if (useOffset) {
             mPerformingScale = true;
             float spanDelta = span - mSpan;
             float maxSlots = mItemRef.mParentMediaSet.getNumExpectedItems();
             maxSlots = FloatUtils.clamp(maxSlots, 0, GridLayer.MAX_ITEMS_PER_SLOT);
             if (Math.abs(spanDelta) < 10 * App.PIXEL_DENSITY) {
                 // almost the same span
                 mStartOffset += (mSpanDirection * mSpanSpeed);
                 mStartOffset = FloatUtils.clamp(mStartOffset, 0, maxSlots);
             } else {
                 mSpanSpeed = Math.abs(span / (600 * App.PIXEL_DENSITY));
                 if (mSpanSpeed > 2.0f) {
                     mSpanSpeed = 2.0f;
                 }
                 mSpanSpeed *= 0.1f;
                 mSpanDirection = Math.signum(spanDelta);
             }
             mSpan = span;
             mTargetPosition.set(mStacktopPosition);
             if (!pushDown) {
                 if (maxSlots < 2)
                     return;
                 // If it is the stacktop, we track the top finger, ie, x1, y1
                 // else
                 // we track bottom finger x2, y2
                 // Instead of using linear interpolation, we will also try to
                 // look at the spread value to decide how many move at a given
                 // point of time.
                 int maxSeedVal = (int)(span / (125 * App.PIXEL_DENSITY));
                 maxSeedVal = (int)FloatUtils.clamp(maxSeedVal, 2, maxSlots - 1);
                 float startOffset = FloatUtils.clamp(mStartOffset, 0, maxSlots - maxSeedVal - 1);
                 float offsetSeed = seed - startOffset;
                 float seedFactor = offsetSeed / maxSeedVal;
                 seedFactor = FloatUtils.clamp(seedFactor, 0.0f, 1.0f);
                 float dx = dx2 * seedFactor + (1.0f - seedFactor) * dx1;
                 float dy = dy2 * seedFactor + (1.0f - seedFactor) * dy1;
                 mTargetPosition.add(dx, dy, seed * 0.1f);
                 mTargetTheta = 0.0f;
             } else {
                 mStartOffset = 0.0f;
                 mTargetPosition.z = seed * STACK_SPACING + 3.0f;
             }
         } else {
             mPerformingScale = false;
             mStartOffset = 0.0f;
             if (seed > 3) {
                 seed = 3;
             }
             mTargetPosition.set(mStacktopPosition);
             mTargetPosition.add(mJitteredPosition);
             mTargetPosition.z = seed * STACK_SPACING;
             if (seed != 0 && mTargetTheta == 0.0f) {
                 mTargetTheta = 30.0f * (0.5f - (float) Math.random());
             }
         }
     }

     public final boolean getHasFocus() {
         return mHasFocus;
     }

     public final Texture getHiResImage(Context context) {
         UriTexture texture = mHiResImage;
         if (texture == null) {
             texture = new UriTexture(mItemRef.mContentUri);
             texture.setCacheId(Utils.Crc64Long(mItemRef.mFilePath));
             mHiResImage = texture;
         }
         return texture;
     }

     public boolean isAlive() {
         return mAlive;
     }

     public float getImageTheta() {
         return mImageTheta;
     }
 }
	/*
	* Copyright (C) 2009 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.cooliris.media;

	import java.util.Random;

	import android.content.Context;

	import com.cooliris.app.App;
	import com.cooliris.media.FloatUtils;

	/**
	* A simple structure for a MediaItem that can be rendered.
	*/
	public final class DisplayItem {
	private static final float STACK_SPACING = 0.2f;
	private DirectLinkedList.Entry<DisplayItem> mAnimatablesEntry = new DirectLinkedList.Entry<DisplayItem>(this);
	private static final Random random = new Random();
	private Vector3f mStacktopPosition = new Vector3f(-1.0f, -1.0f, -1.0f);
	private Vector3f mJitteredPosition = new Vector3f();
	private boolean mHasFocus;
	private Vector3f mTargetPosition = new Vector3f();
	private float mTargetTheta;
	private float mImageTheta;
	private int mStackId;
	private MediaItemTexture mThumbnailImage = null;
	private Texture mScreennailImage = null;
	private UriTexture mHiResImage = null;
	private float mConvergenceSpeed = 1.0f;

	public final MediaItem mItemRef;
	public float mAnimatedTheta;
	public float mAnimatedImageTheta;
	public float mAnimatedPlaceholderFade = 0f;
	public boolean mAlive;
	public Vector3f mAnimatedPosition = new Vector3f();
	public int mCurrentSlotIndex;
	private boolean mPerformingScale;
	private float mSpan;
	private float mSpanDirection;
	private float mStartOffset;
	private float mSpanSpeed;
	private static final String TAG = "DisplayItem";

	public DisplayItem(MediaItem item) {
	mItemRef = item;
	mAnimatedImageTheta = item.mRotation;
	mImageTheta = item.mRotation;
	if (item == null)
	throw new UnsupportedOperationException("Cannot create a displayitem from a null MediaItem.");
	mCurrentSlotIndex = Shared.INVALID;
	}

	public DirectLinkedList.Entry<DisplayItem> getAnimatablesEntry() {
	return mAnimatablesEntry;
	}

	public final void rotateImageBy(float theta) {
	mImageTheta += theta;
	}

	public final void set(Vector3f position, int stackIndex, boolean performTransition) {
	mConvergenceSpeed = 1.0f;
	Vector3f animatedPosition = mAnimatedPosition;
	Vector3f targetPosition = mTargetPosition;
	int seed = stackIndex;
	int randomSeed = stackIndex;

	if (seed > 3) {
	seed = 3;
	randomSeed = 0;
	}

	if (!mAlive) {
	animatedPosition.set(position);
	animatedPosition.z = -3.0f + stackIndex * STACK_SPACING;
	}

	targetPosition.set(position);
	if (mStackId != stackIndex && stackIndex >= 0) {
	mStackId = stackIndex;
	}

	if (randomSeed == 0) {
	if (stackIndex == 0) {
	mTargetTheta = 0.0f;
	} else if (mTargetTheta == 0.0f){
	mTargetTheta = 30.0f * (0.5f - (float) Math.random());
	}
	mTargetPosition.z = seed * STACK_SPACING;
	mJitteredPosition.set(0, 0, seed * STACK_SPACING);
	} else {
	int sign = (seed % 2 == 0) ? 1 : -1;
	if (seed != 0 && !mStacktopPosition.equals(position) && mTargetTheta == 0) {
	mTargetTheta = 30.0f * (0.5f - (float) Math.random());
	mJitteredPosition.x = sign * 12.0f * seed + (0.5f - random.nextFloat()) * 4 * seed;
	mJitteredPosition.y = sign * 4 + ((sign == 1) ? -8.0f : sign * (random.nextFloat()) * 16.0f);
	mJitteredPosition.x *= App.PIXEL_DENSITY;
	mJitteredPosition.y *= App.PIXEL_DENSITY;
	mJitteredPosition.z = seed * STACK_SPACING;
	}
	}
	mTargetPosition.add(mJitteredPosition);
	mStacktopPosition.set(position);
	mStartOffset = 0.0f;
	}

	public int getStackIndex() {
	return mStackId;
	}

	public Texture getThumbnailImage(Context context, MediaItemTexture.Config config) {
	MediaItemTexture texture = mThumbnailImage;
	if (texture == null && config != null) {
	if (mItemRef.mId != Shared.INVALID) {
	texture = new MediaItemTexture(context, config, mItemRef);
	}
	mThumbnailImage = texture;
	}
	return texture;
	}

	public Texture getScreennailImage(Context context) {
	Texture texture = mScreennailImage;
	if (texture == null \|\| texture.mState == Texture.STATE_ERROR) {
	MediaSet parentMediaSet = mItemRef.mParentMediaSet;
	if (parentMediaSet != null && parentMediaSet.mDataSource.getThumbnailCache() == LocalDataSource.sThumbnailCache) {
	if (mItemRef.mId != Shared.INVALID && mItemRef.mId != 0) {
	texture = new MediaItemTexture(context, null, mItemRef);
	} else if (mItemRef.mContentUri != null) {
	texture = new UriTexture(mItemRef.mContentUri);
	}
	} else {
	texture = new UriTexture(mItemRef.mScreennailUri);
	((UriTexture) texture).setCacheId(Utils.Crc64Long(mItemRef.mFilePath));
	}
	mScreennailImage = texture;
	}
	return texture;
	}

	public void clearScreennailImage() {
	if (mScreennailImage != null) {
	mScreennailImage = null;
	mHiResImage = null;
	}
	}

	public void clearHiResImage() {
	mHiResImage = null;
	}

	public void clearThumbnail() {
	mThumbnailImage = null;
	}

	/**
	* Use this function to query the animation state of the display item
	*
	* @return true if the display item is animating
	*/
	public boolean isAnimating() {
	return mAlive
	&& (mPerformingScale \|\|
	!mAnimatedPosition.equals(mTargetPosition) \|\| mAnimatedTheta != mTargetTheta
	\|\| mAnimatedImageTheta != mImageTheta \|\| mAnimatedPlaceholderFade != 1f);
	}

	/**
	* This function should be called every time the frame needs to be updated.
	*/
	public final void update(float timeElapsedInSec) {
	if (mAlive) {
	timeElapsedInSec *= 1.25f;
	Vector3f animatedPosition = mAnimatedPosition;
	Vector3f targetPosition = mTargetPosition;
	timeElapsedInSec *= mConvergenceSpeed;
	animatedPosition.x = FloatUtils.animate(animatedPosition.x, targetPosition.x, timeElapsedInSec);
	animatedPosition.y = FloatUtils.animate(animatedPosition.y, targetPosition.y, timeElapsedInSec);
	mAnimatedTheta = FloatUtils.animate(mAnimatedTheta, mTargetTheta, timeElapsedInSec);
	mAnimatedImageTheta = FloatUtils.animate(mAnimatedImageTheta, mImageTheta, timeElapsedInSec);
	mAnimatedPlaceholderFade = FloatUtils.animate(mAnimatedPlaceholderFade, 1f, timeElapsedInSec);
	animatedPosition.z = FloatUtils.animate(animatedPosition.z, targetPosition.z, timeElapsedInSec);
	}
	}

	/**
	* Commits all animations for the Display Item
	*/
	public final void commit() {
	mAnimatedPosition.set(mTargetPosition);
	mAnimatedTheta = mTargetTheta;
	mAnimatedImageTheta = mImageTheta;
	}

	public final void setHasFocus(boolean hasFocus, boolean pushDown) {
	mConvergenceSpeed = 2.0f;
	mHasFocus = hasFocus;
	int seed = mStackId;
	if (seed > 3) {
	seed = 3;
	}
	if (hasFocus) {
	mTargetPosition.set(mStacktopPosition);
	mTargetPosition.add(mJitteredPosition);
	mTargetPosition.add(mJitteredPosition);
	mTargetPosition.z = seed * STACK_SPACING + (pushDown ? 1.0f : -0.5f);
	} else {
	mTargetPosition.set(mStacktopPosition);
	mTargetPosition.add(mJitteredPosition);
	mTargetPosition.z = seed * STACK_SPACING;
	}
	}

	public final void setSingleOffset(boolean useOffset, boolean pushAway, float x, float y, float z, float spreadValue) {
	int seed = mStackId;
	if (useOffset) {
	mTargetPosition.set(mStacktopPosition);
	if (spreadValue > 4.0f)
	spreadValue = 4.0f + 0.1f * spreadValue;
	if (spreadValue < 1.0f) {
	spreadValue = 1.0f / spreadValue;
	pushAway = true;
	}
	if (!pushAway) {
	if (seed == 0) {
	mTargetPosition.add(0, -spreadValue * 14, 0);
	}
	if (seed == 1) {
	mTargetPosition.add(-spreadValue * 32, 0, 0);
	}
	if (seed == 2) {
	mTargetPosition.add(0, spreadValue * 14, 0);
	}
	if (seed == 3) {
	mTargetPosition.add(spreadValue * 32, 0, 0);
	}
	mTargetPosition.z = -1.0f * spreadValue + seed * STACK_SPACING * spreadValue;
	mTargetTheta = 0.0f;
	} else {
	mTargetPosition.z = seed * STACK_SPACING + spreadValue * 0.5f;
	}
	} else {
	if (seed > 3) {
	seed = 3;
	}
	mTargetPosition.set(mStacktopPosition);
	mTargetPosition.add(mJitteredPosition);
	mTargetPosition.z = seed * STACK_SPACING;
	if (seed != 0 && mTargetTheta == 0.0f) {
	mTargetTheta = 30.0f * (0.5f - (float) Math.random());
	}
	mStartOffset = 0.0f;
	}
	}

	public final void setOffset(boolean useOffset, boolean pushDown, float span, float dx1, float dy1, float dx2, float dy2) {
	int seed = mStackId;
	if (useOffset) {
	mPerformingScale = true;
	float spanDelta = span - mSpan;
	float maxSlots = mItemRef.mParentMediaSet.getNumExpectedItems();
	maxSlots = FloatUtils.clamp(maxSlots, 0, GridLayer.MAX_ITEMS_PER_SLOT);
	if (Math.abs(spanDelta) < 10 * App.PIXEL_DENSITY) {
	// almost the same span
	mStartOffset += (mSpanDirection * mSpanSpeed);
	mStartOffset = FloatUtils.clamp(mStartOffset, 0, maxSlots);
	} else {
	mSpanSpeed = Math.abs(span / (600 * App.PIXEL_DENSITY));
	if (mSpanSpeed > 2.0f) {
	mSpanSpeed = 2.0f;
	}
	mSpanSpeed *= 0.1f;
	mSpanDirection = Math.signum(spanDelta);
	}
	mSpan = span;
	mTargetPosition.set(mStacktopPosition);
	if (!pushDown) {
	if (maxSlots < 2)
	return;
	// If it is the stacktop, we track the top finger, ie, x1, y1
	// else
	// we track bottom finger x2, y2
	// Instead of using linear interpolation, we will also try to
	// look at the spread value to decide how many move at a given
	// point of time.
	int maxSeedVal = (int)(span / (125 * App.PIXEL_DENSITY));
	maxSeedVal = (int)FloatUtils.clamp(maxSeedVal, 2, maxSlots - 1);
	float startOffset = FloatUtils.clamp(mStartOffset, 0, maxSlots - maxSeedVal - 1);
	float offsetSeed = seed - startOffset;
	float seedFactor = offsetSeed / maxSeedVal;
	seedFactor = FloatUtils.clamp(seedFactor, 0.0f, 1.0f);
	float dx = dx2 * seedFactor + (1.0f - seedFactor) * dx1;
	float dy = dy2 * seedFactor + (1.0f - seedFactor) * dy1;
	mTargetPosition.add(dx, dy, seed * 0.1f);
	mTargetTheta = 0.0f;
	} else {
	mStartOffset = 0.0f;
	mTargetPosition.z = seed * STACK_SPACING + 3.0f;
	}
	} else {
	mPerformingScale = false;
	mStartOffset = 0.0f;
	if (seed > 3) {
	seed = 3;
	}
	mTargetPosition.set(mStacktopPosition);
	mTargetPosition.add(mJitteredPosition);
	mTargetPosition.z = seed * STACK_SPACING;
	if (seed != 0 && mTargetTheta == 0.0f) {
	mTargetTheta = 30.0f * (0.5f - (float) Math.random());
	}
	}
	}

	public final boolean getHasFocus() {
	return mHasFocus;
	}

	public final Texture getHiResImage(Context context) {
	UriTexture texture = mHiResImage;
	if (texture == null) {
	texture = new UriTexture(mItemRef.mContentUri);
	texture.setCacheId(Utils.Crc64Long(mItemRef.mFilePath));
	mHiResImage = texture;
	}
	return texture;
	}

	public boolean isAlive() {
	return mAlive;
	}

	public float getImageTheta() {
	return mImageTheta;
	}
	}