package com.ikea.kompis.browse;

import android.animation.Animator;
import android.animation.Animator.AnimatorListener;
import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.support.annotation.Nullable;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup.LayoutParams;
import android.view.ViewPropertyAnimator;
import android.widget.FrameLayout;
import android.widget.LinearLayout;
import android.widget.TextView;
import com.ikea.kompis.ShoppingCartActivity;
import com.ikea.kompis.browse.event.CategorySelectedEvent;
import com.ikea.kompis.browse.event.SubCategorySelectedEvent;
import com.ikea.kompis.fragments.SecondLevelContentFragment;
import com.ikea.kompis.products.FilterFragment;
import com.ikea.kompis.products.event.CancelFilterFragmentEvent;
import com.ikea.kompis.products.event.FilterAppliedEvent;
import com.ikea.kompis.util.TempFilterCache;
import com.ikea.kompis.util.TempObjectCache;
import com.ikea.kompis.util.UiUtil;
import com.ikea.shared.AppError;
import com.ikea.shared.analytics.UsageTracker;
import com.ikea.shared.browse.model.CatalogElement;
import com.ikea.shared.browse.model.CatalogElementSubCatagoryTree;
import com.ikea.shared.browse.model.CatalogElementSubTree;
import com.ikea.shared.browse.model.CatalogElementTree;
import com.ikea.shared.browse.model.ProductListing;
import com.ikea.shared.browse.service.CatalogService;
import com.ikea.shared.filter.model.AppliedFilters;
import com.ikea.shared.filter.model.AvailableFilters;
import com.ikea.shared.filter.model.CategoryFilter;
import com.ikea.shared.filter.model.CategoryFilterList;
import com.ikea.shared.products.model.RetailItemCommunication;
import com.ikea.shared.sort.model.SortList;
import com.ikea.shared.util.L;
import com.ikea.shared.util.ServiceCallback;
import com.ikea.shared.util.Util;
import com.squareup.otto.Bus;
import com.squareup.otto.Subscribe;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public abstract class SubCategoryBaseFragment extends SecondLevelContentFragment
{
  protected static final String CATEGORY_ID = "CATEGORY_ID";
  protected static final String CATEGORY_NAME = "CATEGORY_NAME";
  protected static final String CATEGORY_TYPE = "CATEGORY_TYPE";
  protected static final String FILTER_FRAGMENT = "FILTER_FRAGMENT";
  private static final String FILTER_FRAGMENT_EMPTY = "FILTER_FRAGMENT_EMPTY";
  private static final String IS_FROM_FILTER = "FROM_FILTER";
  protected static final String IS_SEASONAL = "IS_SEASONAL";
  protected static final String KEY_GRID_STATE = "KEY_GRID_STATE";
  protected static final String KEY_LIST_STATE = "KEY_LIST_STATE";
  private static final String OPEN_FILTER_FRAGMENT = "OPEN_FILTER_FRAGMENT";
  private static final String PRODUCT_ITEM = "PRODUCT_ITEM";
  protected static final String SUB_CATAGORY = "SUB_CATAGORY";
  private static final float VIEW_FADED = 0.7F;
  private AppliedFilters appliedFilters;
  protected boolean isFilterFragmentEmpty = true;
  private boolean isFilterListOpen;
  protected boolean isFragmentEmpty = false;
  private boolean isLandscape;
  protected boolean isSeasonal;
  private boolean isTablet;
  private AvailableFilters mAvailablefilters;
  private CatalogElement mCatalogElement;
  protected CatalogElementTree mCatalogElementTree = null;
  private String mCategoryId;
  private String mCategoryName;
  private String mCategoryType;
  private float mDeviceHeight;
  private float mDeviceWidth;
  private EventHandler mEventHandler;
  protected View mFilterFadeView;
  public FilterFragment mFilterFragment;
  protected LinearLayout mFilterHeader;
  protected FrameLayout mFilterHolder;
  protected TextView mFilterText;
  protected boolean mFromFilter = false;
  private String mFunctionName = "functional";
  protected final View.OnClickListener mOnClickListener = new View.OnClickListener()
  {
    public void onClick(View paramAnonymousView)
    {
      switch (paramAnonymousView.getId())
      {
      default:
        return;
      case 2131624000:
        L.D("clickeddddd");
        SubCategoryBaseFragment.this.showFilter(true);
        return;
      case 2131624006:
      }
      SubCategoryBaseFragment.this.showFilter(true);
    }
  };
  private List<RetailItemCommunication> mRetailItemComm;
  private final ServiceCallback<ProductListing> mServiceCallback = new ServiceCallback()
  {
    public void done(ProductListing paramAnonymousProductListing, AppError paramAnonymousAppError, Exception paramAnonymousException)
    {
      L.I("SubCategoryBaseFragment mServiceCallbackNew done " + paramAnonymousProductListing);
      if (SubCategoryBaseFragment.this.getActivity() == null)
        return;
      if (paramAnonymousProductListing != null)
      {
        if ((paramAnonymousProductListing.isSuccessful()) && (paramAnonymousProductListing.getRetailItemComm() != null) && (!paramAnonymousProductListing.getRetailItemComm().isEmpty()))
        {
          SubCategoryBaseFragment.access$002(SubCategoryBaseFragment.this, paramAnonymousProductListing.getRetailItemComm());
          SubCategoryBaseFragment.access$102(SubCategoryBaseFragment.this, paramAnonymousProductListing.getmAvailablefilters());
          SubCategoryBaseFragment.this.addChapterFilterInCategoryFilter();
          SubCategoryBaseFragment.access$302(SubCategoryBaseFragment.this, paramAnonymousProductListing.getSortList());
          SubCategoryBaseFragment.this.tempFilterCache.setAvailableCachedFilter(SubCategoryBaseFragment.this.mAvailablefilters);
          SubCategoryBaseFragment.this.tempFilterCache.setAvailableCurrentCachedFilter(SubCategoryBaseFragment.this.mAvailablefilters);
          SubCategoryBaseFragment.this.tempFilterCache.setCachedSortList(SubCategoryBaseFragment.this.mSortList);
          if ((SubCategoryBaseFragment.this.mAvailablefilters != null) || (SubCategoryBaseFragment.this.mSortList != null))
            SubCategoryBaseFragment.this.setFilterVisibilty(true);
          while (true)
          {
            SubCategoryBaseFragment.this.tempFilterCache.cacheOrignalRetailItemComm(SubCategoryBaseFragment.this.mRetailItemComm);
            SubCategoryBaseFragment.this.tempFilterCache.cacheCurrentRetailItemComm(SubCategoryBaseFragment.this.mRetailItemComm);
            L.I("SubCategoryBaseFragment mServiceCallbackNew size " + SubCategoryBaseFragment.this.mRetailItemComm.size());
            SubCategoryBaseFragment.this.refreshUI(SubCategoryBaseFragment.this.mCatalogElementTree.getCatalogElementList(), SubCategoryBaseFragment.this.mRetailItemComm, null, null);
            return;
            SubCategoryBaseFragment.this.setFilterVisibilty(false);
          }
        }
        SubCategoryBaseFragment.this.refreshUI(SubCategoryBaseFragment.this.mCatalogElementTree.getCatalogElementList(), null, null);
        return;
      }
      SubCategoryBaseFragment.this.refreshUI(SubCategoryBaseFragment.this.mCatalogElementTree.getCatalogElementList(), null, null);
    }
  };
  private SortList mSortList;
  private boolean needToOpenFilterFragment;
  private TempFilterCache tempFilterCache;

  private void addChapterFilterInCategoryFilter()
  {
    if (this.mAvailablefilters == null)
      this.mAvailablefilters = new AvailableFilters();
    CategoryFilterList localCategoryFilterList = new CategoryFilterList();
    this.mAvailablefilters.setCategoryFilter(localCategoryFilterList);
    if (this.mAvailablefilters.getCategoryFilter().getCategoryFiltersList() == null)
    {
      ArrayList localArrayList = new ArrayList();
      this.mAvailablefilters.getCategoryFilter().setCategoryFiltersList(localArrayList);
    }
    if ((this.mCatalogElement != null) && (this.mCatalogElement.getmCatalogElementSubTree() != null) && (this.mCatalogElement.getmCatalogElementSubTree().getCatalogElementList() != null) && (this.mCatalogElement.getmCatalogElementSubTree().getCatalogElementList().size() > 0))
    {
      Iterator localIterator = this.mCatalogElement.getmCatalogElementSubTree().getCatalogElementList().iterator();
      while (localIterator.hasNext())
      {
        CatalogElement localCatalogElement = (CatalogElement)localIterator.next();
        if ((localCatalogElement.getType().equalsIgnoreCase("CHAPTER")) || (localCatalogElement.getType().equalsIgnoreCase("CATEGORY SYSTEM CHAPTER")))
        {
          CategoryFilter localCategoryFilter = new CategoryFilter(localCatalogElement.getName(), localCatalogElement.getID());
          this.mAvailablefilters.getCategoryFilter().getCategoryFiltersList().add(localCategoryFilter);
        }
      }
    }
  }

  private boolean hasCatagorySystemItems(CatalogElement paramCatalogElement)
  {
    CatalogElementSubCatagoryTree localCatalogElementSubCatagoryTree = paramCatalogElement.getCatalogElementSubCatagoryTree();
    boolean bool1 = false;
    if (localCatalogElementSubCatagoryTree != null)
    {
      CatalogElementTree localCatalogElementTree = paramCatalogElement.getCatalogElementSubCatagoryTree().getmCatalogElementree();
      bool1 = false;
      if (localCatalogElementTree != null)
      {
        List localList = paramCatalogElement.getCatalogElementSubCatagoryTree().getmCatalogElementree().getCatalogElementList();
        bool1 = false;
        if (localList != null)
        {
          boolean bool2 = paramCatalogElement.getCatalogElementSubCatagoryTree().getmCatalogElementree().getCatalogElementList().isEmpty();
          bool1 = false;
          if (!bool2)
            bool1 = true;
        }
      }
    }
    return bool1;
  }

  private void hideTitleIcons()
  {
    if (!UiUtil.isTablet(this.mParent))
    {
      this.mParent.hideSL();
      this.mParent.hideBackButton();
    }
  }

  public static SubCategoryBaseFragment newInstance(Context paramContext, String paramString1, String paramString2, String paramString3, CatalogElementTree paramCatalogElementTree, boolean paramBoolean)
  {
    Bundle localBundle = new Bundle();
    localBundle.putString("CATEGORY_ID", paramString2.trim());
    localBundle.putString("CATEGORY_NAME", paramString1);
    localBundle.putString("CATEGORY_TYPE", paramString3);
    localBundle.putSerializable("SUB_CATAGORY", paramCatalogElementTree);
    localBundle.putBoolean("IS_SEASONAL", paramBoolean);
    SubCategoryPhoneFragment localSubCategoryPhoneFragment = new SubCategoryPhoneFragment();
    localSubCategoryPhoneFragment.setArguments(localBundle);
    return localSubCategoryPhoneFragment;
  }

  private void setFilterVisibilty(boolean paramBoolean)
  {
    if (paramBoolean)
    {
      this.mFilterHeader.setVisibility(8);
      return;
    }
    this.mFilterHeader.setVisibility(8);
  }

  private void showTitleIcons()
  {
    if (!UiUtil.isTablet(this.mParent))
    {
      this.mParent.showShoppingList(true);
      this.mParent.showBackButton();
    }
  }

  protected CharSequence getTitle(Context paramContext)
  {
    return this.mCategoryName;
  }

  public boolean goBack()
  {
    if (this.isFilterListOpen)
    {
      showFilter(true);
      if (this.mFilterFragment != null)
      {
        this.mFilterFragment.mCanceRequest = true;
        this.mFilterFragment.showProgress(false);
      }
      return true;
    }
    TempFilterCache.i(this.mParent).resetFilterCache();
    return super.goBack();
  }

  protected void moveToNext(final CatalogElement paramCatalogElement, final boolean paramBoolean)
  {
    if (hasCatagorySystemItems(paramCatalogElement))
    {
      this.mCatalogElement = paramCatalogElement;
      this.mHandler.post(new Runnable()
      {
        public void run()
        {
          SubCategoryBaseFragment.this.mBus.post(new CategorySelectedEvent(paramCatalogElement.getName(), paramCatalogElement.getID(), paramCatalogElement.getType(), paramCatalogElement.getCatalogElementSubCatagoryTree().getmCatalogElementree(), paramBoolean));
        }
      });
      return;
    }
    this.isFilterFragmentEmpty = true;
    this.mRetailItemComm = this.tempFilterCache.getOrignalCachedProductListData();
    this.mAvailablefilters = this.tempFilterCache.getAvailableCachedFilter();
    this.appliedFilters = null;
    this.mSortList = this.tempFilterCache.getCachedSortList();
    TempFilterCache.i(this.mParent).resetFilterCache();
    this.mFromFilter = false;
    this.mHandler.post(new Runnable()
    {
      public void run()
      {
        SubCategoryBaseFragment.this.mBus.post(new SubCategorySelectedEvent(SubCategoryBaseFragment.this.mCategoryId, paramCatalogElement.getID(), paramCatalogElement.getName(), paramCatalogElement, paramBoolean));
      }
    });
  }

  public void onActivityCreated(@Nullable Bundle paramBundle)
  {
    super.onActivityCreated(paramBundle);
    if ((paramBundle != null) && (paramBundle.containsKey("PRODUCT_ITEM")))
      this.mRetailItemComm = TempObjectCache.i(this.mParent).getCachedProductListData();
    if ((paramBundle != null) && (paramBundle.containsKey("FILTER_FRAGMENT_EMPTY")))
      this.isFilterFragmentEmpty = paramBundle.getBoolean("FILTER_FRAGMENT_EMPTY");
    if ((paramBundle != null) && (paramBundle.containsKey("FROM_FILTER")))
      this.mFromFilter = paramBundle.getBoolean("FROM_FILTER");
    if ((paramBundle != null) && (paramBundle.containsKey("OPEN_FILTER_FRAGMENT")))
      this.needToOpenFilterFragment = true;
  }

  public void onAttach(Activity paramActivity)
  {
    super.onAttach(paramActivity);
    Bundle localBundle = getArguments();
    if (localBundle != null)
    {
      if (localBundle.containsKey("SUB_CATAGORY"))
        this.mCatalogElementTree = ((CatalogElementTree)localBundle.getSerializable("SUB_CATAGORY"));
      if (localBundle.containsKey("CATEGORY_NAME"))
        this.mCategoryName = localBundle.getString("CATEGORY_NAME");
      if (localBundle.containsKey("CATEGORY_ID"))
        this.mCategoryId = localBundle.getString("CATEGORY_ID");
      if (localBundle.containsKey("CATEGORY_TYPE"))
      {
        this.mCategoryType = localBundle.getString("CATEGORY_TYPE");
        L.I("mCategoryType : " + this.mCategoryType);
      }
      if (Util.isNWP(this.mParent))
        this.mFunctionName = "products";
      if (localBundle.containsKey("IS_SEASONAL"))
      {
        this.isSeasonal = localBundle.getBoolean("IS_SEASONAL");
        if (this.isSeasonal)
          this.mFunctionName = "seasonal";
      }
    }
  }

  public void onCreate(Bundle paramBundle)
  {
    super.onCreate(paramBundle);
    this.mEventHandler = new EventHandler(null);
    this.isTablet = UiUtil.isTablet(getActivity());
    this.isLandscape = UiUtil.isLandscape(getActivity());
    this.mDeviceWidth = UiUtil.screenWidth(getActivity());
    this.mDeviceHeight = UiUtil.screenHeight(getActivity());
    this.tempFilterCache = TempFilterCache.i(getActivity());
  }

  public void onPause()
  {
    super.onPause();
    try
    {
      this.mBus.unregister(this.mEventHandler);
      this.mServiceCallback.markInvalid();
      return;
    }
    catch (Exception localException)
    {
      while (true)
        L.W("No event handler to unregister");
    }
  }

  public void onResume()
  {
    super.onResume();
    this.mBus.register(this.mEventHandler);
    if ((this.mRetailItemComm != null) && (!this.mFromFilter))
    {
      refreshUI(this.mCatalogElementTree.getCatalogElementList(), this.mRetailItemComm, null, null);
      if (this.tempFilterCache.getOrignalCachedProductListData() == null)
        this.tempFilterCache.cacheOrignalRetailItemComm(this.mRetailItemComm);
      setFilterVisibilty(true);
      if (UsageTracker.i().isBackPressed())
      {
        UsageTracker.i().popCategoryNavigationInfo(getActivity(), this.mCategoryId);
        UsageTracker.i().viewSubCategory(getActivity());
      }
      if (!this.needToOpenFilterFragment)
        break label277;
      this.needToOpenFilterFragment = false;
      showFilter(false);
    }
    label277: 
    while (!this.isFilterListOpen)
    {
      return;
      if (this.mFromFilter)
      {
        this.mAvailablefilters = this.tempFilterCache.getAvailableCurrentCachedFilter();
        this.mSortList = this.tempFilterCache.getCachedSortList();
        refreshUI(this.mCatalogElementTree.getCatalogElementList(), this.mRetailItemComm, null, null);
        if ((this.mAvailablefilters != null) || (this.mSortList != null))
        {
          setFilterVisibilty(true);
          break;
        }
        setFilterVisibilty(false);
        break;
      }
      if ((!"SUB CATEGORY".equalsIgnoreCase(this.mCategoryType)) && (!"SUBCATEGORY CONTAINER".equalsIgnoreCase(this.mCategoryType)))
      {
        refreshUI(this.mCatalogElementTree.getCatalogElementList(), null, null);
        break;
      }
      this.mServiceCallback.markValid();
      CatalogService.i(getActivity()).getCatalogElementsNewAsync(this.mFunctionName, "", this.mCategoryId, null, this.mServiceCallback);
      break;
    }
    hideTitleIcons();
  }

  public void onSaveInstanceState(Bundle paramBundle)
  {
    super.onSaveInstanceState(paramBundle);
    if (this.mRetailItemComm != null)
    {
      paramBundle.putString("PRODUCT_ITEM", "PRODUCT_ITEM");
      TempObjectCache.i(this.mParent).cacheRetailItemComm(this.mRetailItemComm);
    }
    paramBundle.putBoolean("FROM_FILTER", this.mFromFilter);
    paramBundle.putBoolean("FILTER_FRAGMENT_EMPTY", this.isFilterFragmentEmpty);
    if (this.isFilterListOpen)
      paramBundle.putBoolean("OPEN_FILTER_FRAGMENT", this.isFilterListOpen);
  }

  public abstract void refreshUI(List<CatalogElement> paramList, AppError paramAppError, Exception paramException);

  public abstract void refreshUI(List<CatalogElement> paramList, List<RetailItemCommunication> paramList1, AppError paramAppError, Exception paramException);

  public void setFilterWidth()
  {
    ViewGroup.LayoutParams localLayoutParams = this.mFilterHolder.getLayoutParams();
    if (this.isTablet)
    {
      this.mFilterHolder.setTranslationX(this.mDeviceWidth);
      if (this.isLandscape)
        localLayoutParams.width = ((int)(this.mDeviceWidth / 3.0F));
    }
    while (true)
    {
      this.mFilterHolder.setLayoutParams(localLayoutParams);
      return;
      localLayoutParams.width = ((int)(this.mDeviceWidth / 2.0F));
      continue;
      localLayoutParams.width = ((int)this.mDeviceWidth);
      this.mFilterHolder.setTranslationY(this.mDeviceHeight);
      this.mFilterHolder.animate().translationY(this.mDeviceHeight).setListener(new Animator.AnimatorListener()
      {
        public void onAnimationCancel(Animator paramAnonymousAnimator)
        {
        }

        public void onAnimationEnd(Animator paramAnonymousAnimator)
        {
          if (!SubCategoryBaseFragment.this.isFilterListOpen)
            SubCategoryBaseFragment.this.mFilterHolder.setVisibility(4);
        }

        public void onAnimationRepeat(Animator paramAnonymousAnimator)
        {
        }

        public void onAnimationStart(Animator paramAnonymousAnimator)
        {
        }
      });
    }
  }

  public void showFilter(boolean paramBoolean)
  {
    if (this.isFilterFragmentEmpty)
    {
      if (this.tempFilterCache.getAvailableCachedFilter() == null)
        this.tempFilterCache.setAvailableCachedFilter(this.mAvailablefilters);
      if (this.tempFilterCache.getAppliedCurrentCachedFilters() == null)
        this.tempFilterCache.setAvailableCurrentCachedFilter(this.mAvailablefilters);
      if (this.tempFilterCache.getCachedSortList() == null)
        this.tempFilterCache.setCachedSortList(this.mSortList);
      FragmentTransaction localFragmentTransaction = getChildFragmentManager().beginTransaction();
      this.mFilterFragment = FilterFragment.newInstance(this.mFunctionName, "", this.mCategoryId);
      localFragmentTransaction.replace(this.mFilterHolder.getId(), this.mFilterFragment, "FILTER_FRAGMENT");
      localFragmentTransaction.commit();
      this.isFilterFragmentEmpty = false;
      this.mFilterFragment.mCanceRequest = false;
      if (this.isFilterListOpen)
        break label338;
      if (this.mFilterHolder != null)
      {
        this.isFilterListOpen = true;
        hideTitleIcons();
        if (!this.isTablet)
          break label317;
        if (!paramBoolean)
          break label266;
        if (!this.isLandscape)
          break label241;
        this.mFilterHolder.animate().translationX(this.mDeviceWidth - this.mDeviceWidth / 3.0F);
      }
    }
    while (true)
    {
      this.mFilterFadeView.setVisibility(0);
      this.mFilterFadeView.animate().alpha(0.7F);
      return;
      this.mFilterFragment = ((FilterFragment)getChildFragmentManager().findFragmentByTag("FILTER_FRAGMENT"));
      break;
      label241: this.mFilterHolder.animate().translationX(this.mDeviceWidth - this.mDeviceWidth / 2.0F);
      continue;
      label266: if (this.isLandscape)
        this.mFilterHolder.setTranslationX(this.mDeviceWidth - this.mDeviceWidth / 3.0F);
      else
        this.mFilterHolder.setTranslationX(this.mDeviceWidth - this.mDeviceWidth / 2.0F);
    }
    label317: this.mFilterHolder.setVisibility(0);
    this.mFilterHolder.animate().translationY(0.0F);
    return;
    label338: this.isFilterListOpen = false;
    showTitleIcons();
    if (this.isTablet)
    {
      if (paramBoolean)
        this.mFilterHolder.animate().translationX(this.mDeviceWidth);
      while (true)
      {
        this.mFilterFadeView.setVisibility(8);
        this.mFilterFadeView.animate().alpha(0.0F);
        return;
        this.mFilterHolder.setTranslationX(this.mDeviceWidth);
      }
    }
    this.mFilterHolder.animate().translationY(this.mDeviceHeight);
  }

  protected void slEvent(boolean paramBoolean)
  {
    if ((!paramBoolean) && (UsageTracker.i().isBackPressed()))
      UsageTracker.i().viewSubCategory(getActivity());
  }

  private class EventHandler
  {
    private EventHandler()
    {
    }

    @Subscribe
    public void dismissFilterFragment(CancelFilterFragmentEvent paramCancelFilterFragmentEvent)
    {
      SubCategoryBaseFragment.this.showFilter(true);
      SubCategoryBaseFragment.this.mFromFilter = true;
    }

    @Subscribe
    public void handleFilterEvent(FilterAppliedEvent paramFilterAppliedEvent)
    {
      SubCategoryBaseFragment.access$002(SubCategoryBaseFragment.this, SubCategoryBaseFragment.this.tempFilterCache.getCurrentCachedRetailItemComm());
      SubCategoryBaseFragment.access$102(SubCategoryBaseFragment.this, SubCategoryBaseFragment.this.tempFilterCache.getAvailableCurrentCachedFilter());
      SubCategoryBaseFragment.access$1102(SubCategoryBaseFragment.this, SubCategoryBaseFragment.this.tempFilterCache.getAppliedCurrentCachedFilters());
      SubCategoryBaseFragment.access$302(SubCategoryBaseFragment.this, SubCategoryBaseFragment.this.tempFilterCache.getCachedSortList());
      SubCategoryBaseFragment.this.mFromFilter = true;
      if (SubCategoryBaseFragment.this.tempFilterCache.isResetFilters())
      {
        SubCategoryBaseFragment.access$002(SubCategoryBaseFragment.this, SubCategoryBaseFragment.this.tempFilterCache.getOrignalCachedProductListData());
        SubCategoryBaseFragment.access$102(SubCategoryBaseFragment.this, SubCategoryBaseFragment.this.tempFilterCache.getAvailableCurrentCachedFilter());
        SubCategoryBaseFragment.access$1102(SubCategoryBaseFragment.this, null);
        SubCategoryBaseFragment.access$302(SubCategoryBaseFragment.this, SubCategoryBaseFragment.this.tempFilterCache.getCachedSortList());
        SubCategoryBaseFragment.this.tempFilterCache.setResetFilters(false);
      }
      SubCategoryBaseFragment.this.refreshUI(SubCategoryBaseFragment.this.mCatalogElementTree.getCatalogElementList(), SubCategoryBaseFragment.this.mRetailItemComm, null, null);
    }
  }
}

/* Location:           C:\Documents and Settings\Cesar Cabello Cea\Mis documentos\Downloads\apk-downloader\com.ikea.kompis-6_dex2jar.jar
 * Qualified Name:     com.ikea.kompis.browse.SubCategoryBaseFragment
 * JD-Core Version:    0.6.2
 */