Refactor. Rename AlbumView to AlbumSlotRenderer.

Change-Id: I7d8d3586a910dac35975e4effa0d02528e2ccf98

1 files changed, 211 insertions, 0 deletions

diff --git a/src/com/android/gallery3d/ui/AlbumSetSlotRenderer.java b/src/com/android/gallery3d/ui/AlbumSetSlotRenderer.java
new file mode 100644
index 000000000..d20c387ae
--- /dev/null
+++ b/src/com/android/gallery3d/ui/AlbumSetSlotRenderer.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright (C) 2010 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.android.gallery3d.ui;
+
+import android.content.Context;
+
+import com.android.gallery3d.app.AlbumSetDataLoader;
+import com.android.gallery3d.app.GalleryActivity;
+import com.android.gallery3d.data.MediaObject;
+import com.android.gallery3d.data.Path;
+import com.android.gallery3d.ui.AlbumSetSlidingWindow.AlbumSetEntry;
+
+public class AlbumSetSlotRenderer extends AbstractSlotRenderer {
+    @SuppressWarnings("unused")
+    private static final String TAG = "AlbumSetView";
+    private static final int CACHE_SIZE = 96;
+    private static final int PLACEHOLDER_COLOR = 0xFF222222;
+
+    private final ColorTexture mWaitLoadingTexture;
+    private final GalleryActivity mActivity;
+    private final SelectionManager mSelectionManager;
+    protected final LabelSpec mLabelSpec;
+
+    protected AlbumSetSlidingWindow mDataWindow;
+    private SlotView mSlotView;
+
+    private int mPressedIndex = -1;
+    private Path mHighlightItemPath = null;
+    private boolean mInSelectionMode;
+
+    public static class LabelSpec {
+        public int labelBackgroundHeight;
+        public int titleOffset;
+        public int countOffset;
+        public int titleFontSize;
+        public int countFontSize;
+        public int leftMargin;
+        public int iconSize;
+    }
+
+    public AlbumSetSlotRenderer(GalleryActivity activity, SelectionManager selectionManager,
+            SlotView slotView, LabelSpec labelSpec) {
+        super ((Context) activity);
+        mActivity = activity;
+        mSelectionManager = selectionManager;
+        mSlotView = slotView;
+        mLabelSpec = labelSpec;
+
+        mWaitLoadingTexture = new ColorTexture(PLACEHOLDER_COLOR);
+        mWaitLoadingTexture.setSize(1, 1);
+
+        Context context = activity.getAndroidContext();
+    }
+
+    public void setPressedIndex(int index) {
+        if (mPressedIndex == index) return;
+        mPressedIndex = index;
+        mSlotView.invalidate();
+    }
+
+    public void setHighlightItemPath(Path path) {
+        if (mHighlightItemPath == path) return;
+        mHighlightItemPath = path;
+        mSlotView.invalidate();
+    }
+
+    public void setModel(AlbumSetDataLoader model) {
+        if (mDataWindow != null) {
+            mDataWindow.setListener(null);
+            mDataWindow = null;
+            mSlotView.setSlotCount(0);
+        }
+        if (model != null) {
+            mDataWindow = new AlbumSetSlidingWindow(
+                    mActivity, model, mLabelSpec, CACHE_SIZE);
+            mDataWindow.setListener(new MyCacheListener());
+            mSlotView.setSlotCount(mDataWindow.size());
+        }
+    }
+
+    private static Texture checkTexture(GLCanvas canvas, Texture texture) {
+        return ((texture == null) || ((texture instanceof UploadedTexture)
+                && !((UploadedTexture) texture).isContentValid(canvas)))
+                ? null
+                : texture;
+    }
+
+    @Override
+    public int renderSlot(GLCanvas canvas, int index, int pass, int width, int height) {
+        AlbumSetEntry entry = mDataWindow.get(index);
+        int renderRequestFlags = 0;
+        renderRequestFlags |= renderContent(canvas, entry, width, height);
+        renderRequestFlags |= renderLabel(canvas, entry, width, height);
+        renderRequestFlags |= renderOverlay(canvas, index, entry, width, height);
+        return renderRequestFlags;
+    }
+
+    protected int renderOverlay(
+            GLCanvas canvas, int index, AlbumSetEntry entry, int width, int height) {
+        Path path = entry.setPath;
+        if (mPressedIndex == index) {
+            drawPressedFrame(canvas, width, height);
+        } else if ((path != null) && (mHighlightItemPath == path)) {
+            drawSelectedFrame(canvas, width, height);
+        } else if (mInSelectionMode && mSelectionManager.isItemSelected(path)) {
+            drawSelectedFrame(canvas, width, height);
+        }
+        return 0;
+    }
+
+    protected int renderContent(
+            GLCanvas canvas, AlbumSetEntry entry, int width, int height) {
+        int renderRequestFlags = 0;
+
+        Texture content = checkTexture(canvas, entry.content);
+        if (content == null) {
+            content = mWaitLoadingTexture;
+            entry.isWaitLoadingDisplayed = true;
+        } else if (entry.isWaitLoadingDisplayed) {
+            entry.isWaitLoadingDisplayed = false;
+            entry.content = new FadeInTexture(
+                    PLACEHOLDER_COLOR, (BitmapTexture) entry.content);
+            content = entry.content;
+        }
+        drawContent(canvas, content, width, height, entry.rotation);
+        if ((content instanceof FadeInTexture) &&
+                ((FadeInTexture) content).isAnimating()) {
+            renderRequestFlags |= SlotView.RENDER_MORE_FRAME;
+        }
+
+        if (entry.mediaType == MediaObject.MEDIA_TYPE_VIDEO) {
+            drawVideoOverlay(canvas, width, height);
+        }
+
+        if (entry.isPanorama) {
+            drawPanoramaBorder(canvas, width, height);
+        }
+
+        return renderRequestFlags;
+    }
+
+    protected int renderLabel(
+            GLCanvas canvas, AlbumSetEntry entry, int width, int height) {
+        // We show the loading message only when the album is still loading
+        // (Not when we are still preparing the label)
+        Texture content = checkTexture(canvas, entry.label);
+        if (entry.album == null) {
+            content = mDataWindow.getLoadingTexture();
+        }
+        if (content != null) {
+            int b = AlbumLabelMaker.getBorderSize();
+            int h = content.getHeight();
+            content.draw(canvas, -b, height - h + b, width + b + b, h);
+        }
+        return 0;
+    }
+
+    @Override
+    public void prepareDrawing() {
+        mInSelectionMode = mSelectionManager.inSelectionMode();
+    }
+
+    private class MyCacheListener implements AlbumSetSlidingWindow.Listener {
+
+        @Override
+        public void onSizeChanged(int size) {
+            mSlotView.setSlotCount(size);
+        }
+
+        @Override
+        public void onContentChanged() {
+            mSlotView.invalidate();
+        }
+    }
+
+    public void pause() {
+        mDataWindow.pause();
+    }
+
+    public void resume() {
+        mDataWindow.resume();
+    }
+
+    @Override
+    public void onVisibleRangeChanged(int visibleStart, int visibleEnd) {
+        if (mDataWindow != null) {
+            mDataWindow.setActiveWindow(visibleStart, visibleEnd);
+        }
+    }
+
+    @Override
+    public void onSlotSizeChanged(int width, int height) {
+        if (mDataWindow != null) {
+            mDataWindow.onSlotSizeChanged(width, height);
+        }
+    }
+}