return mAllImages;
    }

<<<<<<< HEAD
    private class CreateContextMenuListener implements
            View.OnCreateContextMenuListener {
        public void onCreateContextMenu(ContextMenu menu, View v,
                ContextMenu.ContextMenuInfo menuInfo) {
            if (mSelectedImageGetter.getCurrentImage() == null) {
                return;
            }

            boolean isImage = ImageManager.isImage(
                    mSelectedImageGetter.getCurrentImage());
            if (isImage) {
                menu.add(0, 0, 0, R.string.view).setOnMenuItemClickListener(
                        new MenuItem.OnMenuItemClickListener() {
                            public boolean onMenuItemClick(MenuItem item) {
                                mGvs.onSelect(mGvs.mCurrentSelection);
                                return true;
                            }
                        });
            }

            menu.setHeaderTitle(isImage
                    ? R.string.context_menu_header
                    : R.string.video_context_menu_header);
            if ((mInclusion & (ImageManager.INCLUDE_IMAGES
                    | ImageManager.INCLUDE_VIDEOS)) != 0) {
                MenuHelper.MenuItemsResult r = MenuHelper.addImageMenuItems(
                        menu,
                        MenuHelper.INCLUDE_ALL,
                        isImage,
                        ImageGallery2.this,
                        mHandler,
                        mDeletePhotoRunnable,
                        new MenuHelper.MenuInvoker() {
                            public void run(MenuHelper.MenuCallback cb) {
                                cb.run(mSelectedImageGetter
                                        .getCurrentImageUri(),
                                        mSelectedImageGetter.getCurrentImage());

                                mGvs.clearCache();
                                mGvs.invalidate();
                                mGvs.requestLayout();
                                mGvs.start();
                                mNoImagesView.setVisibility(
                                        mAllImages.getCount() > 0
                                        ? View.GONE
                                        : View.VISIBLE);
                }
        }
                            }
                        });
                if (r != null) {
                    r.gettingReadyToOpen(menu,
                            mSelectedImageGetter.getCurrentImage());
                }

                if (isImage) {
                    addSlideShowMenu(menu, 1000);
                }
            }
        }
    }
}


class GridViewSpecial extends View {
    private static final String TAG = "GridViewSpecial";
    ImageGallery2 mGallery;
    private Paint   mGridViewPaint = new Paint();

    ImageBlockManager mImageBlockManager;
    private Handler mHandler;

    LayoutSpec mCurrentSpec;
    boolean mShowSelection = false;
    int mCurrentSelection = -1;
    private boolean mCurrentSelectionPressed;

    private boolean mDirectionBiasDown = true;
    private static final boolean DUMP = false;

    long mVideoSizeLimit;

    class LayoutSpec {
        LayoutSpec(int cols, int w, int h, int leftEdgePadding,
                   int rightEdgePadding, int intercellSpacing) {
            mColumns = cols;
            mCellWidth = w;
            mCellHeight = h;
            mLeftEdgePadding = leftEdgePadding;
            mRightEdgePadding = rightEdgePadding;
            mCellSpacing = intercellSpacing;
        }
        int mColumns;
        int mCellWidth, mCellHeight;
        int mLeftEdgePadding, mRightEdgePadding;
        int mCellSpacing;
    }

    private LayoutSpec [] mCellSizeChoices = new LayoutSpec[] {
            new LayoutSpec(0, 67, 67, 14, 14, 8),
            new LayoutSpec(0, 92, 92, 14, 14, 8),
    };
    private int mSizeChoice = 1;

    // Use a number like 100 or 200 here to allow the user to
    // overshoot the start (top) or end (bottom) of the gallery.
    // After overshooting the gallery will animate back to the
    // appropriate location.
    private int mMaxOvershoot = 0; // 100;
    private int mMaxScrollY;
    private int mMinScrollY;

    private boolean mFling = true;
    private Scroller mScroller = null;

    private GestureDetector mGestureDetector;

    public void dump() {
        if (Config.LOGV){
            Log.v(TAG, "mSizeChoice is " + mCellSizeChoices[mSizeChoice]);
            Log.v(TAG, "mCurrentSpec.width / mCellHeight are "
                    + mCurrentSpec.mCellWidth + " / "
                    + mCurrentSpec.mCellHeight);
        }
        mImageBlockManager.dump();
    }

    private void init(Context context) {
        mGridViewPaint.setColor(0xFF000000);
        mGallery = (ImageGallery2) context;

        setVerticalScrollBarEnabled(true);
        initializeScrollbars(context.obtainStyledAttributes(
                android.R.styleable.View));

        mGestureDetector = new GestureDetector(context,
                new SimpleOnGestureListener() {
            @Override
            public boolean onDown(MotionEvent e) {
                if (mScroller != null && !mScroller.isFinished()) {
                    mScroller.forceFinished(true);
                    return false;
                }

                int pos = computeSelectedIndex(e);
                if (pos >= 0 && pos < mGallery.mAllImages.getCount()) {
                    select(pos, true);
                } else {
                    select(-1, false);
                if (mImageBlockManager != null) {
                    mImageBlockManager.repaintSelection(mCurrentSelection);
                }
                invalidate();
                return true;
            }

            @Override
            public boolean onFling(MotionEvent e1, MotionEvent e2,
                    float velocityX, float velocityY) {
                final float maxVelocity = 2500;
                if (velocityY > maxVelocity) {
                    velocityY = maxVelocity;
                } else if (velocityY < -maxVelocity) {
                    velocityY = -maxVelocity;
                }

                select(-1, false);
                if (mFling) {
                    mScroller = new Scroller(getContext());
                    mScroller.fling(0, mScrollY, 0, -(int) velocityY, 0, 0, 0,
                            mMaxScrollY);
                    computeScroll();
                }
                return true;
            }

            @Override
            public void onLongPress(MotionEvent e) {
                performLongClick();
            }

            @Override
            public boolean onScroll(MotionEvent e1, MotionEvent e2,
                                    float distanceX, float distanceY) {
                select(-1, false);
                scrollBy(0, (int) distanceY);
                invalidate();
                return true;
            }

            @Override
            public boolean onSingleTapUp(MotionEvent e) {
                select(mCurrentSelection, false);
                int index = computeSelectedIndex(e);
                if (index >= 0 && index < mGallery.mAllImages.getCount()) {
                    onSelect(index);
                    return true;
                }
                return false;
            }
        });
        // mGestureDetector.setIsLongpressEnabled(false);
    }

    public GridViewSpecial(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init(context);
    }

    public GridViewSpecial(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }

    public GridViewSpecial(Context context) {
        super(context);
        init(context);
    }

    @Override
    protected int computeVerticalScrollRange() {
        return mMaxScrollY + getHeight();
    }

    public void setSizeChoice(int choice, int scrollY) {
        mSizeChoice = choice;
        clearCache();
        scrollTo(0, scrollY);
        requestLayout();
        invalidate();
    }

    /**
     *
     * @param newSel -2 means use old selection, -1 means remove selection
     * @param newPressed
     */
    public void select(int newSel, boolean newPressed) {
        if (newSel == -2) {
            newSel = mCurrentSelection;
        }
        int oldSel = mCurrentSelection;
        if ((oldSel == newSel) && (mCurrentSelectionPressed == newPressed)) {
            return;
        }

        mShowSelection = (newSel != -1);
        mCurrentSelection = newSel;
        mCurrentSelectionPressed = newPressed;
        if (mImageBlockManager != null) {
            mImageBlockManager.repaintSelection(oldSel);
            mImageBlockManager.repaintSelection(newSel);

        if (newSel != -1) {
            ensureVisible(newSel);
        }
    }

    private void ensureVisible(int pos) {
        android.graphics.Rect r = getRectForPosition(pos);
        int top = getScrollY();
        int bot = top + getHeight();

        if (r.bottom > bot) {
            mScroller = new Scroller(getContext());
            mScroller.startScroll(mScrollX, mScrollY, 0,
                    r.bottom - getHeight() - mScrollY, 200);
            computeScroll();
        } else if (r.top < top) {
            mScroller = new Scroller(getContext());
            mScroller.startScroll(mScrollX, mScrollY, 0, r.top - mScrollY, 200);
            computeScroll();
        }
        invalidate();
    }

    public void start() {
        if (mGallery.mLayoutComplete) {
            if (mImageBlockManager == null) {
                mImageBlockManager = new ImageBlockManager();
                mImageBlockManager.moveDataWindow(true, true);
            }
        }
    }

    public void onPause() {
        mScroller = null;
        if (mImageBlockManager != null) {
            mImageBlockManager.onPause();
            mImageBlockManager = null;
        }
    }

    public void clearCache() {
        if (mImageBlockManager != null) {
            mImageBlockManager.onPause();
            mImageBlockManager = null;
        }
    }


    @Override
    public void onLayout(boolean changed, int left, int top,
                         int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);
        if (mGallery.isFinishing() || mGallery.mPausing) {
            return;
        }
        clearCache();
        mCurrentSpec = mCellSizeChoices[mSizeChoice];
        int oldColumnCount = mCurrentSpec.mColumns;

        int width = right - left;
        mCurrentSpec.mColumns = 1;
        width -= mCurrentSpec.mCellWidth;
        mCurrentSpec.mColumns += width
                / (mCurrentSpec.mCellWidth + mCurrentSpec.mCellSpacing);

        mCurrentSpec.mLeftEdgePadding = ((right - left)
                - ((mCurrentSpec.mColumns - 1) * mCurrentSpec.mCellSpacing)
                - (mCurrentSpec.mColumns * mCurrentSpec.mCellWidth)) / 2;
        mCurrentSpec.mRightEdgePadding = mCurrentSpec.mLeftEdgePadding;

        int rows = (mGallery.mAllImages.getCount() + mCurrentSpec.mColumns - 1)
                / mCurrentSpec.mColumns;
        mMaxScrollY = mCurrentSpec.mCellSpacing
                + (rows
                * (mCurrentSpec.mCellSpacing + mCurrentSpec.mCellHeight))
                - (bottom - top) + mMaxOvershoot;
        mMinScrollY = 0 - mMaxOvershoot;

        mGallery.mLayoutComplete = true;

        start();

        if (mGallery.mSortAscending && mGallery.mTargetScroll == 0) {
            scrollTo(0, mMaxScrollY - mMaxOvershoot);
        } else {
            if (oldColumnCount != 0) {
                int y = mGallery.mTargetScroll *
                        oldColumnCount / mCurrentSpec.mColumns;
                Log.v(TAG, "target was " + mGallery.mTargetScroll
                        + " now " + y);
                scrollTo(0, y);
            }
        }
    }

    Bitmap scaleTo(int width, int height, Bitmap b) {
        Matrix m = new Matrix();
        m.setScale(width / 64F, height / 64F);
        Bitmap b2 = Bitmap.createBitmap(b, 0, 0, b.getWidth(), b.getHeight(),
                m, false);
        if (b2 != b) {
            b.recycle();
        }
        return b2;
    }

    class ImageBlockManager {
        private ImageLoader mLoader;
        private int mBlockCacheFirstBlockNumber = 0;

        // mBlockCache is an array with a starting point which is not
        // necessarily zero.  The first element of the array is indicated by
        // mBlockCacheStartOffset.
        private int mBlockCacheStartOffset = 0;
        private ImageBlock [] mBlockCache;

        private static final int sRowsPerPage    = 6;   // should compute this

        private static final int sPagesPreCache  = 2;
        private static final int sPagesPostCache = 2;

        private int mWorkCounter = 0;
        private boolean mDone = false;

        private Thread mWorkerThread;
        private Bitmap mMissingImageThumbnailBitmap;
        private Bitmap mMissingVideoThumbnailBitmap;

        private Drawable mVideoOverlay;
        private Drawable mVideoMmsErrorOverlay;

        public void dump() {
            synchronized (ImageBlockManager.this) {
                StringBuilder line1 = new StringBuilder();
                StringBuilder line2 = new StringBuilder();
                if (Config.LOGV) {
                    Log.v(TAG, ">>> mBlockCacheFirstBlockNumber: "
                            + mBlockCacheFirstBlockNumber + " "
                            + mBlockCacheStartOffset);
                }
                for (int i = 0; i < mBlockCache.length; i++) {
                    int index = (mBlockCacheStartOffset + i)
                            % mBlockCache.length;
                    ImageBlock block = mBlockCache[index];
                    block.dump(line1, line2);
                }
                if (Config.LOGV){
                    Log.v(TAG, line1.toString());
                    Log.v(TAG, line2.toString());
                }
            }
        }

        ImageBlockManager() {
            mLoader = new ImageLoader(mHandler, 1);

            mBlockCache = new ImageBlock[sRowsPerPage
                    * (sPagesPreCache + sPagesPostCache + 1)];
            for (int i = 0; i < mBlockCache.length; i++) {
                mBlockCache[i] = new ImageBlock();
            }

            mWorkerThread = new Thread(new Runnable() {
                public void run() {
                    while (true) {
                        int workCounter;
                        synchronized (ImageBlockManager.this) {
                            workCounter = mWorkCounter;
                        }
                        if (mDone) {
                            if (Config.LOGV) {
                                Log.v(TAG, "stopping the loader here "
                                        + Thread.currentThread().getName());
                            }
                            if (mLoader != null) {
                                mLoader.stop();
                            }
                            if (mBlockCache != null) {
                                for (int i = 0; i < mBlockCache.length; i++) {
                                    ImageBlock block = mBlockCache[i];
                                    if (block != null) {
                                        block.recycleBitmaps();
                                        mBlockCache[i] = null;
                                    }
                                }
                            }
                            mBlockCache = null;
                            mBlockCacheStartOffset = 0;
                            mBlockCacheFirstBlockNumber = 0;

                            break;
                        }

                        loadNext();

                        synchronized (ImageBlockManager.this) {
                            if ((workCounter == mWorkCounter) && (!mDone)) {
                                try {
                                    ImageBlockManager.this.wait();
                                } catch (InterruptedException ex) {
                                }
                            }
                        }
                    } // while
                } // run
            });
            BitmapManager.instance().allowThreadDecoding(mWorkerThread);
            mWorkerThread.setName("image-block-manager");
            mWorkerThread.start();
        }

        // Create this bitmap lazily, and only once for all the ImageBlocks to
        // use
        public Bitmap getErrorBitmap(IImage image) {
            if (ImageManager.isImage(image)) {
                if (mMissingImageThumbnailBitmap == null) {
                    mMissingImageThumbnailBitmap =
                            BitmapFactory.decodeResource(
                            GridViewSpecial.this.getResources(),
                            R.drawable.ic_missing_thumbnail_picture);
                }
                return mMissingImageThumbnailBitmap;
            } else {
                if (mMissingVideoThumbnailBitmap == null) {
                    mMissingVideoThumbnailBitmap =
                            BitmapFactory.decodeResource(
                            GridViewSpecial.this.getResources(),
                            R.drawable.ic_missing_thumbnail_video);
                }
                return mMissingVideoThumbnailBitmap;
            }
        }

        private ImageBlock getBlockForPos(int pos) {
            synchronized (ImageBlockManager.this) {
                int blockNumber = pos / mCurrentSpec.mColumns;
                int delta = blockNumber - mBlockCacheFirstBlockNumber;
                if (delta >= 0 && delta < mBlockCache.length) {
                    int index = (mBlockCacheStartOffset + delta)
                            % mBlockCache.length;
                    ImageBlock b = mBlockCache[index];
                    return b;
                }
            }
            return null;
        }

        private void repaintSelection(int pos) {
            synchronized (ImageBlockManager.this) {
                ImageBlock b = getBlockForPos(pos);
                if (b != null) {
                    b.repaintSelection();
                }
            }
        }

        private void onPause() {
            synchronized (ImageBlockManager.this) {
                mDone = true;
                ImageBlockManager.this.notify();
            }
            if (mWorkerThread != null) {
                try {
                    BitmapManager.instance().cancelThreadDecoding(mWorkerThread);
                    mWorkerThread.join();
                    mWorkerThread = null;
                } catch (InterruptedException ex) {
                    //
                }
            }
            Log.v(TAG, "/ImageBlockManager.onPause");
        }

        void getVisibleRange(int [] range) {
            // try to work around a possible bug in the VM wherein this appears
            // to be null
            try {
                synchronized (ImageBlockManager.this) {
                    int blockLength = mBlockCache.length;
                    boolean lookingForStart = true;
                    ImageBlock prevBlock = null;
                    for (int i = 0; i < blockLength; i++) {
                        int index = (mBlockCacheStartOffset + i) % blockLength;
                        ImageBlock block = mBlockCache[index];
                        if (lookingForStart) {
                            if (block.mIsVisible) {
                                range[0] = block.mBlockNumber
                                        * mCurrentSpec.mColumns;
                                lookingForStart = false;
                            }
                        } else {
                            if (!block.mIsVisible || i == blockLength - 1) {
                                range[1] = (prevBlock.mBlockNumber
                                        * mCurrentSpec.mColumns)
                                        + mCurrentSpec.mColumns - 1;
                                break;
                            }
                        }
                        prevBlock = block;
                    }
                }
            } catch (NullPointerException ex) {
                Log.e(TAG, "this is somewhat null, what up?");
                range[0] = range[1] = 0;
            }
        }

        private void loadNext() {
            final int blockHeight = (mCurrentSpec.mCellSpacing
                    + mCurrentSpec.mCellHeight);

            final int firstVisBlock =
                    Math.max(0, (mScrollY - mCurrentSpec.mCellSpacing)
                    / blockHeight);
            final int lastVisBlock =
                    (mScrollY - mCurrentSpec.mCellSpacing + getHeight())
                    / blockHeight;

            synchronized (ImageBlockManager.this) {
                ImageBlock [] blocks = mBlockCache;
                int numBlocks = blocks.length;
                if (mDirectionBiasDown) {
                    int first = (mBlockCacheStartOffset
                            + (firstVisBlock - mBlockCacheFirstBlockNumber))
                            % blocks.length;
                    for (int i = 0; i < numBlocks; i++) {
                        int j = first + i;
                        if (j >= numBlocks) {
                            j -= numBlocks;
                        }
                        ImageBlock b = blocks[j];
                        if (b.startLoading() > 0) {
                            break;
                        }
                    }
                } else {
                    int first = (mBlockCacheStartOffset
                            + (lastVisBlock - mBlockCacheFirstBlockNumber))
                            % blocks.length;
                    for (int i = 0; i < numBlocks; i++) {
                        int j = first - i;
                        if (j < 0) {
                            j += numBlocks;
                        }
                        ImageBlock b = blocks[j];
                        if (b.startLoading() > 0) {
                            break;
                        }
                    }
                }
                if (DUMP) {
                    this.dump();
                }
            }
        }

        private void moveDataWindow(boolean directionBiasDown,
                boolean forceRefresh) {
            final int blockHeight = (mCurrentSpec.mCellSpacing
                    + mCurrentSpec.mCellHeight);

            final int firstVisBlock = (mScrollY - mCurrentSpec.mCellSpacing)
                    / blockHeight;
            final int lastVisBlock =
                    (mScrollY - mCurrentSpec.mCellSpacing + getHeight())
                    / blockHeight;

            final int preCache = sPagesPreCache;
            final int startBlock = Math.max(0,
                    firstVisBlock - (preCache * sRowsPerPage));

            synchronized (ImageBlockManager.this) {
                boolean any = false;
                ImageBlock [] blocks = mBlockCache;
                int numBlocks = blocks.length;

                int delta = startBlock - mBlockCacheFirstBlockNumber;

                mBlockCacheFirstBlockNumber = startBlock;
                if (Math.abs(delta) > numBlocks || forceRefresh) {
                    for (int i = 0; i < numBlocks; i++) {
                        int blockNum = startBlock + i;
                        blocks[i].setStart(blockNum);
                        any = true;
                    }
                    mBlockCacheStartOffset = 0;
                } else if (delta > 0) {
                    mBlockCacheStartOffset += delta;
                    if (mBlockCacheStartOffset >= numBlocks) {
                        mBlockCacheStartOffset -= numBlocks;
                    }

                    for (int i = delta; i > 0; i--) {
                        int index = (mBlockCacheStartOffset + numBlocks - i)
                                % numBlocks;
                        int blockNum = mBlockCacheFirstBlockNumber
                                + numBlocks - i;
                        blocks[index].setStart(blockNum);
                        any = true;
                    }
                } else if (delta < 0) {
                    mBlockCacheStartOffset += delta;
                    if (mBlockCacheStartOffset < 0) {
                        mBlockCacheStartOffset += numBlocks;
                    }

                    for (int i = 0; i < -delta; i++) {
                        int index = (mBlockCacheStartOffset + i) % numBlocks;
                        int blockNum = mBlockCacheFirstBlockNumber + i;
                        blocks[index].setStart(blockNum);
                        any = true;
                    }
                }

                for (int i = 0; i < numBlocks; i++) {
                    int index = (mBlockCacheStartOffset + i) % numBlocks;
                    ImageBlock block = blocks[index];
                    int blockNum = block.mBlockNumber;
                    boolean isVis = blockNum >= firstVisBlock
                            && blockNum <= lastVisBlock;
                    block.setVisibility(isVis);
                }

                if (DUMP) {
                    mImageBlockManager.dump();
                }

                if (any) {
                    ImageBlockManager.this.notify();
                    mWorkCounter += 1;
                }
=======
    public void onSelect(int index) {
        if (index >= 0 && index < mAllImages.getCount()) {
            IImage img = mAllImages.getImageAt(index);
            if (img == null) {
                return;
            }

            if (isPickIntent()) {
                launchCropperOrFinish(img);
            } else {
                Uri targetUri = img.fullSizeImageUri();
                Uri thisUri = getIntent().getData();
                if (thisUri != null) {
                    String bucket = thisUri.getQueryParameter("bucketId");
                    if (bucket != null) {
                        targetUri = targetUri.buildUpon()
                                .appendQueryParameter("bucketId", bucket)
                                .build();
                    }
                }
                Intent intent = new Intent(Intent.ACTION_VIEW, targetUri);

                if (img instanceof VideoObject) {
                    intent.putExtra(MediaStore.EXTRA_SCREEN_ORIENTATION,
                            ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
                }

                try {
                    startActivity(intent);
                } catch (Exception ex) {
                    // sdcard removal??
                }
            }
        }
    }

    private final class MyThumbCheckCallback implements IImageList.ThumbCheckCallback {
        private final TextView progressTextView;
        private final long startTime;
        private final String progressTextFormatString;
        boolean mDidSetProgress = false;

        private MyThumbCheckCallback(TextView progressTextView, long startTime,
                String progressTextFormatString) {
            this.progressTextView = progressTextView;
            this.startTime = startTime;
            this.progressTextFormatString = progressTextFormatString;
        }

        public boolean checking(final int count,
                final int maxCount) {
            if (mStopThumbnailChecking) {
                return false;
            }

            if (!mLayoutComplete) {
                return true;
>>>>>>> 5e5aa7e1e8bd03e9919d5f14b9f5df75cf68ff8f
            }
            if (DUMP) {
                dump();

        return mAllImages;
    }

    public void onSelect(int index) {
        if (index >= 0 && index < mAllImages.getCount()) {
            IImage img = mAllImages.getImageAt(index);
            if (img == null) {
                return;
            }

            if (isPickIntent()) {
                launchCropperOrFinish(img);
            } else {
                Uri targetUri = img.fullSizeImageUri();
                Uri thisUri = getIntent().getData();
                if (thisUri != null) {
                    String bucket = thisUri.getQueryParameter("bucketId");
                    if (bucket != null) {
                        targetUri = targetUri.buildUpon()
                                .appendQueryParameter("bucketId", bucket)
                                .build();
                    }
                }
                Intent intent = new Intent(Intent.ACTION_VIEW, targetUri);

                if (img instanceof VideoObject) {
                    intent.putExtra(MediaStore.EXTRA_SCREEN_ORIENTATION,
                            ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
                }

                try {
                    startActivity(intent);
                } catch (Exception ex) {
                    // sdcard removal??
                }
            }
        }
    }

    private final class MyThumbCheckCallback implements IImageList.ThumbCheckCallback {
        private final TextView progressTextView;
        private final long startTime;
        private final String progressTextFormatString;
        boolean mDidSetProgress = false;

        private MyThumbCheckCallback(TextView progressTextView, long startTime,
                String progressTextFormatString) {
            this.progressTextView = progressTextView;
            this.startTime = startTime;
            this.progressTextFormatString = progressTextFormatString;
        }

        public boolean checking(final int count,
                final int maxCount) {
            if (mStopThumbnailChecking) {
                return false;
            }

            if (!mLayoutComplete) {
                return true;
            }

            if (!mDidSetProgress) {
                mHandler.post(new Runnable() {
                        public void run() {
                            findViewById(
                            R.id.loading_indicator)
                            .setVisibility(View.VISIBLE);
                        }
                });
                mDidSetProgress = true;
            }
            mGvs.postInvalidate();

            // If there is a new image done and it has been
            // one second, update the progress text.
            if (System.currentTimeMillis()
                    - startTime > 1000) {
                mHandler.post(new Runnable() {
                    public void run() {
                        String s = String.format(
                                progressTextFormatString,
                                maxCount - count);
                        progressTextView.setText(s);
                    }
                });
            }

            return !mPausing;
        }
    }

    private class CreateContextMenuListener implements
            View.OnCreateContextMenuListener {
        public void onCreateContextMenu(ContextMenu menu, View v,
                ContextMenu.ContextMenuInfo menuInfo) {
            if (getCurrentImage() == null) {
                return;
            }

            boolean isImage = ImageManager.isImage(getCurrentImage());
            if (isImage) {
                menu.add(0, 0, 0, R.string.view).setOnMenuItemClickListener(
                        new MenuItem.OnMenuItemClickListener() {
                            public boolean onMenuItemClick(MenuItem item) {
                                onSelect(mGvs.mCurrentSelection);
                                return true;
                            }
                        });
            }

            menu.setHeaderTitle(isImage
                    ? R.string.context_menu_header
                    : R.string.video_context_menu_header);
            if ((mInclusion & (ImageManager.INCLUDE_IMAGES
                    | ImageManager.INCLUDE_VIDEOS)) != 0) {
                MenuHelper.MenuItemsResult r = MenuHelper.addImageMenuItems(
                        menu,
                        MenuHelper.INCLUDE_ALL,
                        isImage,
                        ImageGallery2.this,
                        mHandler,
                        mDeletePhotoRunnable,
                        new MenuHelper.MenuInvoker() {
                            public void run(MenuHelper.MenuCallback cb) {
                                cb.run(getCurrentImageUri(), getCurrentImage());

                                mGvs.clearCache();
                                mGvs.invalidate();
                                mGvs.requestLayout();
                                mGvs.start();
                                mNoImagesView.setVisibility(
                                        mAllImages.getCount() > 0
                                        ? View.GONE
                                        : View.VISIBLE);
                            }
                        });
                if (r != null) {
                    r.gettingReadyToOpen(menu, getCurrentImage());
                }

                if (isImage) {
                    addSlideShowMenu(menu, 1000);
                }
            }
        }
    }

    public void onLayout() {
        mLayoutComplete = true;
        if (mSortAscending && mTargetScroll == 0) {
            mGvs.scrollToImage(mAllImages.getCount() - 1);
        } else {
            mGvs.scrollToImage(mFirstVisibleIndex);
        }
    }

    public void onScroll(int index) {
        mFirstVisibleIndex = index;
    }

}