Home | History | Annotate | Download | only in category
      1 /*
      2  * Copyright (C) 2013 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.gallery3d.filtershow.category;
     18 
     19 import android.os.Bundle;
     20 import android.support.v4.app.Fragment;
     21 import android.support.v4.app.FragmentTransaction;
     22 import android.view.LayoutInflater;
     23 import android.view.View;
     24 import android.view.ViewGroup;
     25 import android.widget.ImageButton;
     26 import android.widget.LinearLayout;
     27 
     28 import com.android.gallery3d.R;
     29 import com.android.gallery3d.filtershow.FilterShowActivity;
     30 import com.android.gallery3d.filtershow.state.StatePanel;
     31 
     32 public class MainPanel extends Fragment {
     33 
     34     private static final String LOGTAG = "MainPanel";
     35 
     36     private LinearLayout mMainView;
     37     private ImageButton looksButton;
     38     private ImageButton bordersButton;
     39     private ImageButton geometryButton;
     40     private ImageButton filtersButton;
     41 
     42     public static final String FRAGMENT_TAG = "MainPanel";
     43     public static final int LOOKS = 0;
     44     public static final int BORDERS = 1;
     45     public static final int GEOMETRY = 2;
     46     public static final int FILTERS = 3;
     47     public static final int VERSIONS = 4;
     48 
     49     private int mCurrentSelected = -1;
     50     private int mPreviousToggleVersions = -1;
     51 
     52     private void selection(int position, boolean value) {
     53         if (value) {
     54             FilterShowActivity activity = (FilterShowActivity) getActivity();
     55             activity.setCurrentPanel(position);
     56         }
     57         switch (position) {
     58             case LOOKS: {
     59                 looksButton.setSelected(value);
     60                 break;
     61             }
     62             case BORDERS: {
     63                 bordersButton.setSelected(value);
     64                 break;
     65             }
     66             case GEOMETRY: {
     67                 geometryButton.setSelected(value);
     68                 break;
     69             }
     70             case FILTERS: {
     71                 filtersButton.setSelected(value);
     72                 break;
     73             }
     74         }
     75     }
     76 
     77     @Override
     78     public void onDestroyView() {
     79         super.onDestroyView();
     80         if (mMainView != null) {
     81             if (mMainView.getParent() != null) {
     82                 ViewGroup parent = (ViewGroup) mMainView.getParent();
     83                 parent.removeView(mMainView);
     84             }
     85         }
     86     }
     87 
     88     @Override
     89     public View onCreateView(LayoutInflater inflater, ViewGroup container,
     90                              Bundle savedInstanceState) {
     91 
     92         mMainView = (LinearLayout) inflater.inflate(
     93                 R.layout.filtershow_main_panel, null, false);
     94 
     95         looksButton = (ImageButton) mMainView.findViewById(R.id.fxButton);
     96         bordersButton = (ImageButton) mMainView.findViewById(R.id.borderButton);
     97         geometryButton = (ImageButton) mMainView.findViewById(R.id.geometryButton);
     98         filtersButton = (ImageButton) mMainView.findViewById(R.id.colorsButton);
     99 
    100         looksButton.setOnClickListener(new View.OnClickListener() {
    101             @Override
    102             public void onClick(View v) {
    103                 showPanel(LOOKS);
    104             }
    105         });
    106         bordersButton.setOnClickListener(new View.OnClickListener() {
    107             @Override
    108             public void onClick(View v) {
    109                 showPanel(BORDERS);
    110             }
    111         });
    112         geometryButton.setOnClickListener(new View.OnClickListener() {
    113             @Override
    114             public void onClick(View v) {
    115                 showPanel(GEOMETRY);
    116             }
    117         });
    118         filtersButton.setOnClickListener(new View.OnClickListener() {
    119             @Override
    120             public void onClick(View v) {
    121                 showPanel(FILTERS);
    122             }
    123         });
    124 
    125         FilterShowActivity activity = (FilterShowActivity) getActivity();
    126         showImageStatePanel(activity.isShowingImageStatePanel());
    127         showPanel(activity.getCurrentPanel());
    128         return mMainView;
    129     }
    130 
    131     private boolean isRightAnimation(int newPos) {
    132         if (newPos < mCurrentSelected) {
    133             return false;
    134         }
    135         return true;
    136     }
    137 
    138     private void setCategoryFragment(CategoryPanel category, boolean fromRight) {
    139         FragmentTransaction transaction = getChildFragmentManager().beginTransaction();
    140         if (fromRight) {
    141             transaction.setCustomAnimations(R.anim.slide_in_right, R.anim.slide_out_right);
    142         } else {
    143             transaction.setCustomAnimations(R.anim.slide_in_left, R.anim.slide_out_left);
    144         }
    145         transaction.replace(R.id.category_panel_container, category, CategoryPanel.FRAGMENT_TAG);
    146         transaction.commitAllowingStateLoss();
    147     }
    148 
    149     public void loadCategoryLookPanel(boolean force) {
    150         if (!force && mCurrentSelected == LOOKS) {
    151             return;
    152         }
    153         boolean fromRight = isRightAnimation(LOOKS);
    154         selection(mCurrentSelected, false);
    155         CategoryPanel categoryPanel = new CategoryPanel();
    156         categoryPanel.setAdapter(LOOKS);
    157         setCategoryFragment(categoryPanel, fromRight);
    158         mCurrentSelected = LOOKS;
    159         selection(mCurrentSelected, true);
    160     }
    161 
    162     public void loadCategoryBorderPanel() {
    163         if (mCurrentSelected == BORDERS) {
    164             return;
    165         }
    166         boolean fromRight = isRightAnimation(BORDERS);
    167         selection(mCurrentSelected, false);
    168         CategoryPanel categoryPanel = new CategoryPanel();
    169         categoryPanel.setAdapter(BORDERS);
    170         setCategoryFragment(categoryPanel, fromRight);
    171         mCurrentSelected = BORDERS;
    172         selection(mCurrentSelected, true);
    173     }
    174 
    175     public void loadCategoryGeometryPanel() {
    176         if (mCurrentSelected == GEOMETRY) {
    177             return;
    178         }
    179         boolean fromRight = isRightAnimation(GEOMETRY);
    180         selection(mCurrentSelected, false);
    181         CategoryPanel categoryPanel = new CategoryPanel();
    182         categoryPanel.setAdapter(GEOMETRY);
    183         setCategoryFragment(categoryPanel, fromRight);
    184         mCurrentSelected = GEOMETRY;
    185         selection(mCurrentSelected, true);
    186     }
    187 
    188     public void loadCategoryFiltersPanel() {
    189         if (mCurrentSelected == FILTERS) {
    190             return;
    191         }
    192         boolean fromRight = isRightAnimation(FILTERS);
    193         selection(mCurrentSelected, false);
    194         CategoryPanel categoryPanel = new CategoryPanel();
    195         categoryPanel.setAdapter(FILTERS);
    196         setCategoryFragment(categoryPanel, fromRight);
    197         mCurrentSelected = FILTERS;
    198         selection(mCurrentSelected, true);
    199     }
    200 
    201     public void loadCategoryVersionsPanel() {
    202         if (mCurrentSelected == VERSIONS) {
    203             return;
    204         }
    205         FilterShowActivity activity = (FilterShowActivity) getActivity();
    206         activity.updateVersions();
    207         boolean fromRight = isRightAnimation(VERSIONS);
    208         selection(mCurrentSelected, false);
    209         CategoryPanel categoryPanel = new CategoryPanel();
    210         categoryPanel.setAdapter(VERSIONS);
    211         setCategoryFragment(categoryPanel, fromRight);
    212         mCurrentSelected = VERSIONS;
    213         selection(mCurrentSelected, true);
    214     }
    215 
    216     public void showPanel(int currentPanel) {
    217         switch (currentPanel) {
    218             case LOOKS: {
    219                 loadCategoryLookPanel(false);
    220                 break;
    221             }
    222             case BORDERS: {
    223                 loadCategoryBorderPanel();
    224                 break;
    225             }
    226             case GEOMETRY: {
    227                 loadCategoryGeometryPanel();
    228                 break;
    229             }
    230             case FILTERS: {
    231                 loadCategoryFiltersPanel();
    232                 break;
    233             }
    234             case VERSIONS: {
    235                 loadCategoryVersionsPanel();
    236                 break;
    237             }
    238         }
    239     }
    240 
    241     public void setToggleVersionsPanelButton(ImageButton button) {
    242         if (button == null) {
    243             return;
    244         }
    245         button.setOnClickListener(new View.OnClickListener() {
    246             @Override
    247             public void onClick(View v) {
    248                 if (mCurrentSelected == VERSIONS) {
    249                     showPanel(mPreviousToggleVersions);
    250                 } else {
    251                     mPreviousToggleVersions = mCurrentSelected;
    252                     showPanel(VERSIONS);
    253                 }
    254             }
    255         });
    256     }
    257 
    258     public void showImageStatePanel(boolean show) {
    259         View container = mMainView.findViewById(R.id.state_panel_container);
    260         FragmentTransaction transaction = null;
    261         if (container == null) {
    262             FilterShowActivity activity = (FilterShowActivity) getActivity();
    263             container = activity.getMainStatePanelContainer(R.id.state_panel_container);
    264         } else {
    265             transaction = getChildFragmentManager().beginTransaction();
    266         }
    267         if (container == null) {
    268             return;
    269         } else {
    270             transaction = getFragmentManager().beginTransaction();
    271         }
    272         int currentPanel = mCurrentSelected;
    273         if (show) {
    274             container.setVisibility(View.VISIBLE);
    275             StatePanel statePanel = new StatePanel();
    276             statePanel.setMainPanel(this);
    277             FilterShowActivity activity = (FilterShowActivity) getActivity();
    278             activity.updateVersions();
    279             transaction.replace(R.id.state_panel_container, statePanel, StatePanel.FRAGMENT_TAG);
    280         } else {
    281             container.setVisibility(View.GONE);
    282             Fragment statePanel = getChildFragmentManager().findFragmentByTag(StatePanel.FRAGMENT_TAG);
    283             if (statePanel != null) {
    284                 transaction.remove(statePanel);
    285             }
    286             if (currentPanel == VERSIONS) {
    287                 currentPanel = LOOKS;
    288             }
    289         }
    290         mCurrentSelected = -1;
    291         showPanel(currentPanel);
    292         transaction.commit();
    293     }
    294 }
    295