package android.support.v4.widget;

import android.content.Context;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.drawable.ColorDrawable;
import android.graphics.drawable.Drawable;
import android.os.Build.VERSION;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.Parcelable.Creator;
import android.os.SystemClock;
import android.support.annotation.ColorInt;
import android.support.annotation.DrawableRes;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.content.ContextCompat;
import android.support.v4.graphics.drawable.DrawableCompat;
import android.support.v4.os.ParcelableCompat;
import android.support.v4.os.ParcelableCompatCreatorCallbacks;
import android.support.v4.view.AbsSavedState;
import android.support.v4.view.AccessibilityDelegateCompat;
import android.support.v4.view.GravityCompat;
import android.support.v4.view.MotionEventCompat;
import android.support.v4.view.ViewCompat;
import android.support.v4.view.ViewGroupCompat;
import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat;
import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat.AccessibilityActionCompat;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.MeasureSpec;
import android.view.ViewGroup;
import android.view.ViewGroup.LayoutParams;
import android.view.ViewGroup.MarginLayoutParams;
import android.view.accessibility.AccessibilityEvent;
import ew;
import ex;
import java.util.ArrayList;
import java.util.List;

public class DrawerLayout
  extends ViewGroup
  implements ex
{
  public static final int LOCK_MODE_LOCKED_CLOSED = 1;
  public static final int LOCK_MODE_LOCKED_OPEN = 2;
  public static final int LOCK_MODE_UNDEFINED = 3;
  public static final int LOCK_MODE_UNLOCKED = 0;
  public static final int STATE_DRAGGING = 1;
  public static final int STATE_IDLE = 0;
  public static final int STATE_SETTLING = 2;
  static final int[] a;
  static final boolean b;
  static final c d;
  private static final boolean e;
  private float A;
  private Drawable B;
  private Drawable C;
  private Drawable D;
  private CharSequence E;
  private CharSequence F;
  private Object G;
  private boolean H;
  private Drawable I = null;
  private Drawable J = null;
  private Drawable K = null;
  private Drawable L = null;
  private final ArrayList<View> M;
  boolean c;
  private final b f = new b();
  private float g;
  private int h;
  private int i = -1728053248;
  private float j;
  private Paint k = new Paint();
  private final ViewDragHelper l;
  private final ViewDragHelper m;
  private final f n;
  private final f o;
  private int p;
  private boolean q;
  private boolean r = true;
  private int s = 3;
  private int t = 3;
  private int u = 3;
  private int v = 3;
  private boolean w;
  @Nullable
  private DrawerListener x;
  private List<DrawerListener> y;
  private float z;
  
  static
  {
    boolean bool2 = true;
    a = new int[] { 16842931 };
    if (Build.VERSION.SDK_INT >= 19)
    {
      bool1 = true;
      b = bool1;
      if (Build.VERSION.SDK_INT < 21) {
        break label65;
      }
    }
    label65:
    for (boolean bool1 = bool2;; bool1 = false)
    {
      e = bool1;
      if (Build.VERSION.SDK_INT < 21) {
        break label70;
      }
      d = new d();
      return;
      bool1 = false;
      break;
    }
    label70:
    d = new e();
  }
  
  public DrawerLayout(Context paramContext)
  {
    this(paramContext, null);
  }
  
  public DrawerLayout(Context paramContext, AttributeSet paramAttributeSet)
  {
    this(paramContext, paramAttributeSet, 0);
  }
  
  public DrawerLayout(Context paramContext, AttributeSet paramAttributeSet, int paramInt)
  {
    super(paramContext, paramAttributeSet, paramInt);
    setDescendantFocusability(262144);
    float f1 = getResources().getDisplayMetrics().density;
    this.h = ((int)(64.0F * f1 + 0.5F));
    float f2 = 400.0F * f1;
    this.n = new f(3);
    this.o = new f(5);
    this.l = ViewDragHelper.create(this, 1.0F, this.n);
    this.l.setEdgeTrackingEnabled(1);
    this.l.setMinVelocity(f2);
    this.n.b = this.l;
    this.m = ViewDragHelper.create(this, 1.0F, this.o);
    this.m.setEdgeTrackingEnabled(2);
    this.m.setMinVelocity(f2);
    this.o.b = this.m;
    setFocusableInTouchMode(true);
    ViewCompat.setImportantForAccessibility(this, 1);
    ViewCompat.setAccessibilityDelegate(this, new a());
    ViewGroupCompat.setMotionEventSplittingEnabled(this, false);
    if (ViewCompat.getFitsSystemWindows(this))
    {
      d.a(this);
      this.B = d.a(paramContext);
    }
    this.g = (f1 * 10.0F);
    this.M = new ArrayList();
  }
  
  static float a(View paramView)
  {
    return ((LayoutParams)paramView.getLayoutParams()).a;
  }
  
  private void a(View paramView, boolean paramBoolean)
  {
    int i2 = getChildCount();
    int i1 = 0;
    if (i1 < i2)
    {
      View localView = getChildAt(i1);
      if (((!paramBoolean) && (!c(localView))) || ((paramBoolean) && (localView == paramView))) {
        ViewCompat.setImportantForAccessibility(localView, 1);
      }
      for (;;)
      {
        i1 += 1;
        break;
        ViewCompat.setImportantForAccessibility(localView, 4);
      }
    }
  }
  
  private void a(boolean paramBoolean)
  {
    int i4 = getChildCount();
    int i2 = 0;
    int i1 = 0;
    if (i2 < i4)
    {
      View localView = getChildAt(i2);
      LayoutParams localLayoutParams = (LayoutParams)localView.getLayoutParams();
      boolean bool = i1;
      int i3;
      if (c(localView)) {
        if (paramBoolean)
        {
          bool = i1;
          if (!localLayoutParams.b) {}
        }
        else
        {
          i3 = localView.getWidth();
          if (!a(localView, 3)) {
            break label115;
          }
          i1 |= this.l.smoothSlideViewTo(localView, -i3, localView.getTop());
        }
      }
      for (;;)
      {
        localLayoutParams.b = false;
        i3 = i1;
        i2 += 1;
        i1 = i3;
        break;
        label115:
        i1 |= this.m.smoothSlideViewTo(localView, getWidth(), localView.getTop());
      }
    }
    this.n.a();
    this.o.a();
    if (i1 != 0) {
      invalidate();
    }
  }
  
  private static boolean a(Drawable paramDrawable, int paramInt)
  {
    if ((paramDrawable == null) || (!DrawableCompat.isAutoMirrored(paramDrawable))) {
      return false;
    }
    DrawableCompat.setLayoutDirection(paramDrawable, paramInt);
    return true;
  }
  
  private View b()
  {
    int i2 = getChildCount();
    int i1 = 0;
    while (i1 < i2)
    {
      View localView = getChildAt(i1);
      if ((((LayoutParams)localView.getLayoutParams()).c & 0x1) == 1) {
        return localView;
      }
      i1 += 1;
    }
    return null;
  }
  
  private static String b(int paramInt)
  {
    if ((paramInt & 0x3) == 3) {
      return "LEFT";
    }
    if ((paramInt & 0x5) == 5) {
      return "RIGHT";
    }
    return Integer.toHexString(paramInt);
  }
  
  private void b(View paramView, float paramFloat)
  {
    float f1 = a(paramView);
    int i1 = paramView.getWidth();
    int i2 = (int)(f1 * i1);
    i1 = (int)(i1 * paramFloat) - i2;
    if (a(paramView, 3)) {}
    for (;;)
    {
      paramView.offsetLeftAndRight(i1);
      a(paramView, paramFloat);
      return;
      i1 = -i1;
    }
  }
  
  private void c()
  {
    if (e) {
      return;
    }
    int i1 = ViewCompat.getLayoutDirection(this);
    Drawable localDrawable;
    if (i1 == 0)
    {
      if (this.I == null) {
        break label102;
      }
      a(this.I, i1);
      localDrawable = this.I;
      this.C = localDrawable;
      i1 = ViewCompat.getLayoutDirection(this);
      if (i1 != 0) {
        break label110;
      }
      if (this.J == null) {
        break label134;
      }
      a(this.J, i1);
      localDrawable = this.J;
    }
    for (;;)
    {
      this.D = localDrawable;
      return;
      if (this.J != null)
      {
        a(this.J, i1);
        localDrawable = this.J;
        break;
      }
      label102:
      localDrawable = this.K;
      break;
      label110:
      if (this.I != null)
      {
        a(this.I, i1);
        localDrawable = this.I;
      }
      else
      {
        label134:
        localDrawable = this.L;
      }
    }
  }
  
  static boolean c(View paramView)
  {
    int i1 = GravityCompat.getAbsoluteGravity(((LayoutParams)paramView.getLayoutParams()).gravity, ViewCompat.getLayoutDirection(paramView));
    if ((i1 & 0x3) != 0) {
      return true;
    }
    return (i1 & 0x5) != 0;
  }
  
  static boolean d(View paramView)
  {
    return (ViewCompat.getImportantForAccessibility(paramView) != 4) && (ViewCompat.getImportantForAccessibility(paramView) != 2);
  }
  
  private static boolean e(View paramView)
  {
    return ((LayoutParams)paramView.getLayoutParams()).gravity == 0;
  }
  
  final View a()
  {
    int i2 = getChildCount();
    int i1 = 0;
    while (i1 < i2)
    {
      View localView = getChildAt(i1);
      if ((c(localView)) && (isDrawerVisible(localView))) {
        return localView;
      }
      i1 += 1;
    }
    return null;
  }
  
  final View a(int paramInt)
  {
    int i1 = GravityCompat.getAbsoluteGravity(paramInt, ViewCompat.getLayoutDirection(this));
    int i2 = getChildCount();
    paramInt = 0;
    while (paramInt < i2)
    {
      View localView = getChildAt(paramInt);
      if ((b(localView) & 0x7) == (i1 & 0x7)) {
        return localView;
      }
      paramInt += 1;
    }
    return null;
  }
  
  final void a(int paramInt, View paramView)
  {
    int i1 = this.l.getViewDragState();
    int i2 = this.m.getViewDragState();
    if ((i1 == 1) || (i2 == 1)) {
      i1 = 1;
    }
    LayoutParams localLayoutParams;
    while ((paramView != null) && (paramInt == 0))
    {
      localLayoutParams = (LayoutParams)paramView.getLayoutParams();
      if (localLayoutParams.a != 0.0F) {
        break label243;
      }
      localLayoutParams = (LayoutParams)paramView.getLayoutParams();
      if ((localLayoutParams.c & 0x1) == 1)
      {
        localLayoutParams.c = 0;
        if (this.y != null)
        {
          paramInt = this.y.size() - 1;
          for (;;)
          {
            if (paramInt >= 0)
            {
              ((DrawerListener)this.y.get(paramInt)).onDrawerClosed(paramView);
              paramInt -= 1;
              continue;
              if ((i1 == 2) || (i2 == 2))
              {
                i1 = 2;
                break;
              }
              i1 = 0;
              break;
            }
          }
        }
        a(paramView, false);
        if (hasWindowFocus())
        {
          paramView = getRootView();
          if (paramView != null) {
            paramView.sendAccessibilityEvent(32);
          }
        }
      }
    }
    while (i1 != this.p)
    {
      this.p = i1;
      if (this.y == null) {
        break;
      }
      paramInt = this.y.size() - 1;
      while (paramInt >= 0)
      {
        ((DrawerListener)this.y.get(paramInt)).onDrawerStateChanged(i1);
        paramInt -= 1;
      }
      label243:
      if (localLayoutParams.a == 1.0F)
      {
        localLayoutParams = (LayoutParams)paramView.getLayoutParams();
        if ((localLayoutParams.c & 0x1) == 0)
        {
          localLayoutParams.c = 1;
          if (this.y != null)
          {
            paramInt = this.y.size() - 1;
            while (paramInt >= 0)
            {
              ((DrawerListener)this.y.get(paramInt)).onDrawerOpened(paramView);
              paramInt -= 1;
            }
          }
          a(paramView, true);
          if (hasWindowFocus()) {
            sendAccessibilityEvent(32);
          }
        }
      }
    }
  }
  
  final void a(View paramView, float paramFloat)
  {
    LayoutParams localLayoutParams = (LayoutParams)paramView.getLayoutParams();
    if (paramFloat == localLayoutParams.a) {}
    for (;;)
    {
      return;
      localLayoutParams.a = paramFloat;
      if (this.y != null)
      {
        int i1 = this.y.size() - 1;
        while (i1 >= 0)
        {
          ((DrawerListener)this.y.get(i1)).onDrawerSlide(paramView, paramFloat);
          i1 -= 1;
        }
      }
    }
  }
  
  final boolean a(View paramView, int paramInt)
  {
    return (b(paramView) & paramInt) == paramInt;
  }
  
  public void addDrawerListener(@NonNull DrawerListener paramDrawerListener)
  {
    if (paramDrawerListener == null) {
      return;
    }
    if (this.y == null) {
      this.y = new ArrayList();
    }
    this.y.add(paramDrawerListener);
  }
  
  public void addFocusables(ArrayList<View> paramArrayList, int paramInt1, int paramInt2)
  {
    int i3 = 0;
    if (getDescendantFocusability() == 393216) {
      return;
    }
    int i4 = getChildCount();
    int i1 = 0;
    int i2 = 0;
    View localView;
    if (i1 < i4)
    {
      localView = getChildAt(i1);
      if (c(localView)) {
        if (isDrawerOpen(localView))
        {
          i2 = 1;
          localView.addFocusables(paramArrayList, paramInt1, paramInt2);
        }
      }
      for (;;)
      {
        i1 += 1;
        break;
        this.M.add(localView);
      }
    }
    if (i2 == 0)
    {
      i2 = this.M.size();
      i1 = i3;
      while (i1 < i2)
      {
        localView = (View)this.M.get(i1);
        if (localView.getVisibility() == 0) {
          localView.addFocusables(paramArrayList, paramInt1, paramInt2);
        }
        i1 += 1;
      }
    }
    this.M.clear();
  }
  
  public void addView(View paramView, int paramInt, ViewGroup.LayoutParams paramLayoutParams)
  {
    super.addView(paramView, paramInt, paramLayoutParams);
    if ((b() != null) || (c(paramView))) {
      ViewCompat.setImportantForAccessibility(paramView, 4);
    }
    for (;;)
    {
      if (!b) {
        ViewCompat.setAccessibilityDelegate(paramView, this.f);
      }
      return;
      ViewCompat.setImportantForAccessibility(paramView, 1);
    }
  }
  
  final int b(View paramView)
  {
    return GravityCompat.getAbsoluteGravity(((LayoutParams)paramView.getLayoutParams()).gravity, ViewCompat.getLayoutDirection(this));
  }
  
  protected boolean checkLayoutParams(ViewGroup.LayoutParams paramLayoutParams)
  {
    return ((paramLayoutParams instanceof LayoutParams)) && (super.checkLayoutParams(paramLayoutParams));
  }
  
  public void closeDrawer(int paramInt)
  {
    closeDrawer(paramInt, true);
  }
  
  public void closeDrawer(int paramInt, boolean paramBoolean)
  {
    View localView = a(paramInt);
    if (localView == null) {
      throw new IllegalArgumentException("No drawer view found with gravity " + b(paramInt));
    }
    closeDrawer(localView, paramBoolean);
  }
  
  public void closeDrawer(View paramView)
  {
    closeDrawer(paramView, true);
  }
  
  public void closeDrawer(View paramView, boolean paramBoolean)
  {
    if (!c(paramView)) {
      throw new IllegalArgumentException("View " + paramView + " is not a sliding drawer");
    }
    LayoutParams localLayoutParams = (LayoutParams)paramView.getLayoutParams();
    if (this.r)
    {
      localLayoutParams.a = 0.0F;
      localLayoutParams.c = 0;
    }
    for (;;)
    {
      invalidate();
      return;
      if (paramBoolean)
      {
        localLayoutParams.c |= 0x4;
        if (a(paramView, 3)) {
          this.l.smoothSlideViewTo(paramView, -paramView.getWidth(), paramView.getTop());
        } else {
          this.m.smoothSlideViewTo(paramView, getWidth(), paramView.getTop());
        }
      }
      else
      {
        b(paramView, 0.0F);
        a(0, paramView);
        paramView.setVisibility(4);
      }
    }
  }
  
  public void closeDrawers()
  {
    a(false);
  }
  
  public void computeScroll()
  {
    int i2 = getChildCount();
    float f1 = 0.0F;
    int i1 = 0;
    while (i1 < i2)
    {
      f1 = Math.max(f1, ((LayoutParams)getChildAt(i1).getLayoutParams()).a);
      i1 += 1;
    }
    this.j = f1;
    if ((this.l.continueSettling(true) | this.m.continueSettling(true))) {
      ViewCompat.postInvalidateOnAnimation(this);
    }
  }
  
  protected boolean drawChild(Canvas paramCanvas, View paramView, long paramLong)
  {
    int i7 = getHeight();
    boolean bool1 = e(paramView);
    int i2 = 0;
    int i5 = 0;
    int i1 = getWidth();
    int i8 = paramCanvas.save();
    int i3 = i1;
    int i4;
    View localView;
    if (bool1)
    {
      int i9 = getChildCount();
      i4 = 0;
      i2 = i5;
      if (i4 < i9)
      {
        localView = getChildAt(i4);
        if ((localView != paramView) && (localView.getVisibility() == 0))
        {
          Drawable localDrawable = localView.getBackground();
          if (localDrawable != null) {
            if (localDrawable.getOpacity() == -1)
            {
              i3 = 1;
              label105:
              if ((i3 == 0) || (!c(localView)) || (localView.getHeight() < i7)) {
                break label215;
              }
              if (!a(localView, 3)) {
                break label193;
              }
              i3 = localView.getRight();
              if (i3 <= i2) {
                break label558;
              }
              i2 = i3;
            }
          }
        }
      }
    }
    label193:
    label215:
    label558:
    for (;;)
    {
      i5 = i2;
      i3 = i1;
      for (;;)
      {
        i4 += 1;
        i1 = i3;
        i2 = i5;
        break;
        i3 = 0;
        break label105;
        i3 = 0;
        break label105;
        int i6 = localView.getLeft();
        i3 = i6;
        i5 = i2;
        if (i6 >= i1)
        {
          i3 = i1;
          i5 = i2;
        }
      }
      paramCanvas.clipRect(i2, 0, i1, getHeight());
      i3 = i1;
      boolean bool2 = super.drawChild(paramCanvas, paramView, paramLong);
      paramCanvas.restoreToCount(i8);
      if ((this.j > 0.0F) && (bool1))
      {
        i1 = (int)(((this.i & 0xFF000000) >>> 24) * this.j);
        i4 = this.i;
        this.k.setColor(i1 << 24 | i4 & 0xFFFFFF);
        paramCanvas.drawRect(i2, 0.0F, i3, getHeight(), this.k);
      }
      do
      {
        return bool2;
        if ((this.C != null) && (a(paramView, 3)))
        {
          i1 = this.C.getIntrinsicWidth();
          i2 = paramView.getRight();
          i3 = this.l.getEdgeSize();
          f1 = Math.max(0.0F, Math.min(i2 / i3, 1.0F));
          this.C.setBounds(i2, paramView.getTop(), i1 + i2, paramView.getBottom());
          this.C.setAlpha((int)(255.0F * f1));
          this.C.draw(paramCanvas);
          return bool2;
        }
      } while ((this.D == null) || (!a(paramView, 5)));
      i1 = this.D.getIntrinsicWidth();
      i2 = paramView.getLeft();
      i3 = getWidth();
      i4 = this.m.getEdgeSize();
      float f1 = Math.max(0.0F, Math.min((i3 - i2) / i4, 1.0F));
      this.D.setBounds(i2 - i1, paramView.getTop(), i2, paramView.getBottom());
      this.D.setAlpha((int)(255.0F * f1));
      this.D.draw(paramCanvas);
      return bool2;
    }
  }
  
  protected ViewGroup.LayoutParams generateDefaultLayoutParams()
  {
    return new LayoutParams(-1, -1);
  }
  
  public ViewGroup.LayoutParams generateLayoutParams(AttributeSet paramAttributeSet)
  {
    return new LayoutParams(getContext(), paramAttributeSet);
  }
  
  protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams paramLayoutParams)
  {
    if ((paramLayoutParams instanceof LayoutParams)) {
      return new LayoutParams((LayoutParams)paramLayoutParams);
    }
    if ((paramLayoutParams instanceof ViewGroup.MarginLayoutParams)) {
      return new LayoutParams((ViewGroup.MarginLayoutParams)paramLayoutParams);
    }
    return new LayoutParams(paramLayoutParams);
  }
  
  public float getDrawerElevation()
  {
    if (e) {
      return this.g;
    }
    return 0.0F;
  }
  
  public int getDrawerLockMode(int paramInt)
  {
    int i1 = ViewCompat.getLayoutDirection(this);
    switch (paramInt)
    {
    }
    for (;;)
    {
      return 0;
      if (this.s != 3) {
        return this.s;
      }
      if (i1 == 0) {}
      for (paramInt = this.u; paramInt != 3; paramInt = this.v) {
        return paramInt;
      }
      if (this.t != 3) {
        return this.t;
      }
      if (i1 == 0) {}
      for (paramInt = this.v; paramInt != 3; paramInt = this.u) {
        return paramInt;
      }
      if (this.u != 3) {
        return this.u;
      }
      if (i1 == 0) {}
      for (paramInt = this.s; paramInt != 3; paramInt = this.t) {
        return paramInt;
      }
      if (this.v != 3) {
        return this.v;
      }
      if (i1 == 0) {}
      for (paramInt = this.t; paramInt != 3; paramInt = this.s) {
        return paramInt;
      }
    }
  }
  
  public int getDrawerLockMode(View paramView)
  {
    if (!c(paramView)) {
      throw new IllegalArgumentException("View " + paramView + " is not a drawer");
    }
    return getDrawerLockMode(((LayoutParams)paramView.getLayoutParams()).gravity);
  }
  
  @Nullable
  public CharSequence getDrawerTitle(int paramInt)
  {
    paramInt = GravityCompat.getAbsoluteGravity(paramInt, ViewCompat.getLayoutDirection(this));
    if (paramInt == 3) {
      return this.E;
    }
    if (paramInt == 5) {
      return this.F;
    }
    return null;
  }
  
  public Drawable getStatusBarBackgroundDrawable()
  {
    return this.B;
  }
  
  public boolean isDrawerOpen(int paramInt)
  {
    View localView = a(paramInt);
    if (localView != null) {
      return isDrawerOpen(localView);
    }
    return false;
  }
  
  public boolean isDrawerOpen(View paramView)
  {
    if (!c(paramView)) {
      throw new IllegalArgumentException("View " + paramView + " is not a drawer");
    }
    return (((LayoutParams)paramView.getLayoutParams()).c & 0x1) == 1;
  }
  
  public boolean isDrawerVisible(int paramInt)
  {
    View localView = a(paramInt);
    if (localView != null) {
      return isDrawerVisible(localView);
    }
    return false;
  }
  
  public boolean isDrawerVisible(View paramView)
  {
    if (!c(paramView)) {
      throw new IllegalArgumentException("View " + paramView + " is not a drawer");
    }
    return ((LayoutParams)paramView.getLayoutParams()).a > 0.0F;
  }
  
  protected void onAttachedToWindow()
  {
    super.onAttachedToWindow();
    this.r = true;
  }
  
  protected void onDetachedFromWindow()
  {
    super.onDetachedFromWindow();
    this.r = true;
  }
  
  public void onDraw(Canvas paramCanvas)
  {
    super.onDraw(paramCanvas);
    if ((this.H) && (this.B != null))
    {
      int i1 = d.a(this.G);
      if (i1 > 0)
      {
        this.B.setBounds(0, 0, getWidth(), i1);
        this.B.draw(paramCanvas);
      }
    }
  }
  
  public boolean onInterceptTouchEvent(MotionEvent paramMotionEvent)
  {
    boolean bool1 = false;
    int i1 = MotionEventCompat.getActionMasked(paramMotionEvent);
    boolean bool2 = this.l.shouldInterceptTouchEvent(paramMotionEvent);
    boolean bool3 = this.m.shouldInterceptTouchEvent(paramMotionEvent);
    switch (i1)
    {
    default: 
      i1 = 0;
      if ((!(bool2 | bool3)) && (i1 == 0))
      {
        int i2 = getChildCount();
        i1 = 0;
        if (i1 >= i2) {
          break label257;
        }
        if (!((LayoutParams)getChildAt(i1).getLayoutParams()).b) {
          break;
        }
        i1 = 1;
        if ((i1 == 0) && (!this.c)) {}
      }
      else
      {
        bool1 = true;
      }
      return bool1;
    case 0: 
      label63:
      label85:
      label113:
      float f1 = paramMotionEvent.getX();
      float f2 = paramMotionEvent.getY();
      this.z = f1;
      this.A = f2;
      if (this.j > 0.0F)
      {
        paramMotionEvent = this.l.findTopChildUnder((int)f1, (int)f2);
        if ((paramMotionEvent == null) || (!e(paramMotionEvent))) {}
      }
      break;
    }
    for (i1 = 1;; i1 = 0)
    {
      this.w = false;
      this.c = false;
      break label63;
      if (!this.l.checkTouchSlop(3)) {
        break;
      }
      this.n.a();
      this.o.a();
      i1 = 0;
      break label63;
      a(true);
      this.w = false;
      this.c = false;
      break;
      i1 += 1;
      break label85;
      label257:
      i1 = 0;
      break label113;
    }
  }
  
  public boolean onKeyDown(int paramInt, KeyEvent paramKeyEvent)
  {
    if (paramInt == 4)
    {
      if (a() != null) {}
      for (int i1 = 1; i1 != 0; i1 = 0)
      {
        paramKeyEvent.startTracking();
        return true;
      }
    }
    return super.onKeyDown(paramInt, paramKeyEvent);
  }
  
  public boolean onKeyUp(int paramInt, KeyEvent paramKeyEvent)
  {
    if (paramInt == 4)
    {
      paramKeyEvent = a();
      if ((paramKeyEvent != null) && (getDrawerLockMode(paramKeyEvent) == 0)) {
        closeDrawers();
      }
      return paramKeyEvent != null;
    }
    return super.onKeyUp(paramInt, paramKeyEvent);
  }
  
  protected void onLayout(boolean paramBoolean, int paramInt1, int paramInt2, int paramInt3, int paramInt4)
  {
    this.q = true;
    int i4 = paramInt3 - paramInt1;
    int i5 = getChildCount();
    paramInt3 = 0;
    while (paramInt3 < i5)
    {
      View localView = getChildAt(paramInt3);
      LayoutParams localLayoutParams;
      if (localView.getVisibility() != 8)
      {
        localLayoutParams = (LayoutParams)localView.getLayoutParams();
        if (e(localView)) {
          localView.layout(localLayoutParams.leftMargin, localLayoutParams.topMargin, localLayoutParams.leftMargin + localView.getMeasuredWidth(), localLayoutParams.topMargin + localView.getMeasuredHeight());
        }
      }
      else
      {
        paramInt3 += 1;
        continue;
      }
      int i6 = localView.getMeasuredWidth();
      int i7 = localView.getMeasuredHeight();
      int i1;
      float f1;
      label163:
      int i2;
      if (a(localView, 3))
      {
        paramInt1 = -i6;
        i1 = (int)(i6 * localLayoutParams.a) + paramInt1;
        f1 = (i6 + i1) / i6;
        if (f1 == localLayoutParams.a) {
          break label310;
        }
        i2 = 1;
        label177:
        switch (localLayoutParams.gravity & 0x70)
        {
        default: 
          localView.layout(i1, localLayoutParams.topMargin, i6 + i1, i7 + localLayoutParams.topMargin);
          label237:
          if (i2 != 0) {
            a(localView, f1);
          }
          if (localLayoutParams.a <= 0.0F) {
            break;
          }
        }
      }
      for (paramInt1 = 0; localView.getVisibility() != paramInt1; paramInt1 = 4)
      {
        localView.setVisibility(paramInt1);
        break;
        i1 = i4 - (int)(i6 * localLayoutParams.a);
        f1 = (i4 - i1) / i6;
        break label163;
        label310:
        i2 = 0;
        break label177;
        paramInt1 = paramInt4 - paramInt2;
        localView.layout(i1, paramInt1 - localLayoutParams.bottomMargin - localView.getMeasuredHeight(), i6 + i1, paramInt1 - localLayoutParams.bottomMargin);
        break label237;
        int i8 = paramInt4 - paramInt2;
        int i3 = (i8 - i7) / 2;
        if (i3 < localLayoutParams.topMargin) {
          paramInt1 = localLayoutParams.topMargin;
        }
        for (;;)
        {
          localView.layout(i1, paramInt1, i6 + i1, i7 + paramInt1);
          break;
          paramInt1 = i3;
          if (i3 + i7 > i8 - localLayoutParams.bottomMargin) {
            paramInt1 = i8 - localLayoutParams.bottomMargin - i7;
          }
        }
      }
    }
    this.q = false;
    this.r = false;
  }
  
  protected void onMeasure(int paramInt1, int paramInt2)
  {
    int i6 = View.MeasureSpec.getMode(paramInt1);
    int i5 = View.MeasureSpec.getMode(paramInt2);
    int i3 = View.MeasureSpec.getSize(paramInt1);
    int i4 = View.MeasureSpec.getSize(paramInt2);
    int i2;
    int i1;
    if (i6 == 1073741824)
    {
      i2 = i3;
      if (i5 == 1073741824) {}
    }
    else if (isInEditMode())
    {
      i1 = i3;
      if (i6 != Integer.MIN_VALUE)
      {
        i1 = i3;
        if (i6 == 0) {
          i1 = 300;
        }
      }
      i2 = i1;
      if (i5 == Integer.MIN_VALUE) {
        break label574;
      }
      i2 = i1;
      if (i5 != 0) {
        break label574;
      }
      i3 = 300;
    }
    for (i4 = i1;; i4 = i2)
    {
      setMeasuredDimension(i4, i3);
      label146:
      View localView;
      int i7;
      int i8;
      LayoutParams localLayoutParams;
      if ((this.G != null) && (ViewCompat.getFitsSystemWindows(this)))
      {
        i5 = 1;
        int i9 = ViewCompat.getLayoutDirection(this);
        i1 = 0;
        i2 = 0;
        int i10 = getChildCount();
        i6 = 0;
        if (i6 >= i10) {
          break label573;
        }
        localView = getChildAt(i6);
        i7 = i2;
        i8 = i1;
        if (localView.getVisibility() != 8)
        {
          localLayoutParams = (LayoutParams)localView.getLayoutParams();
          if (i5 != 0)
          {
            i7 = GravityCompat.getAbsoluteGravity(localLayoutParams.gravity, i9);
            if (!ViewCompat.getFitsSystemWindows(localView)) {
              break label322;
            }
            d.a(localView, this.G, i7);
          }
        }
      }
      for (;;)
      {
        if (!e(localView)) {
          break label341;
        }
        localView.measure(View.MeasureSpec.makeMeasureSpec(i4 - localLayoutParams.leftMargin - localLayoutParams.rightMargin, 1073741824), View.MeasureSpec.makeMeasureSpec(i3 - localLayoutParams.topMargin - localLayoutParams.bottomMargin, 1073741824));
        i8 = i1;
        i7 = i2;
        i6 += 1;
        i2 = i7;
        i1 = i8;
        break label146;
        throw new IllegalArgumentException("DrawerLayout must be measured with MeasureSpec.EXACTLY.");
        i5 = 0;
        break;
        label322:
        d.a(localLayoutParams, this.G, i7);
      }
      label341:
      if (c(localView))
      {
        if ((e) && (ViewCompat.getElevation(localView) != this.g)) {
          ViewCompat.setElevation(localView, this.g);
        }
        i8 = b(localView) & 0x7;
        if (i8 == 3) {}
        for (i7 = 1; ((i7 != 0) && (i1 != 0)) || ((i7 == 0) && (i2 != 0)); i7 = 0) {
          throw new IllegalStateException("Child drawer has absolute gravity " + b(i8) + " but this DrawerLayout already has a drawer view along that edge");
        }
        if (i7 != 0) {
          i1 = 1;
        }
        for (;;)
        {
          localView.measure(getChildMeasureSpec(paramInt1, this.h + localLayoutParams.leftMargin + localLayoutParams.rightMargin, localLayoutParams.width), getChildMeasureSpec(paramInt2, localLayoutParams.topMargin + localLayoutParams.bottomMargin, localLayoutParams.height));
          i7 = i2;
          i8 = i1;
          break;
          i2 = 1;
        }
      }
      throw new IllegalStateException("Child " + localView + " at index " + i6 + " does not have a valid layout_gravity - must be Gravity.LEFT, Gravity.RIGHT or Gravity.NO_GRAVITY");
      label573:
      return;
      label574:
      i3 = i4;
    }
  }
  
  protected void onRestoreInstanceState(Parcelable paramParcelable)
  {
    if (!(paramParcelable instanceof SavedState)) {
      super.onRestoreInstanceState(paramParcelable);
    }
    do
    {
      return;
      paramParcelable = (SavedState)paramParcelable;
      super.onRestoreInstanceState(paramParcelable.getSuperState());
      if (paramParcelable.a != 0)
      {
        View localView = a(paramParcelable.a);
        if (localView != null) {
          openDrawer(localView);
        }
      }
      if (paramParcelable.b != 3) {
        setDrawerLockMode(paramParcelable.b, 3);
      }
      if (paramParcelable.c != 3) {
        setDrawerLockMode(paramParcelable.c, 5);
      }
      if (paramParcelable.d != 3) {
        setDrawerLockMode(paramParcelable.d, 8388611);
      }
    } while (paramParcelable.e == 3);
    setDrawerLockMode(paramParcelable.e, 8388613);
  }
  
  public void onRtlPropertiesChanged(int paramInt)
  {
    c();
  }
  
  protected Parcelable onSaveInstanceState()
  {
    SavedState localSavedState = new SavedState(super.onSaveInstanceState());
    int i4 = getChildCount();
    int i1 = 0;
    for (;;)
    {
      LayoutParams localLayoutParams;
      int i2;
      if (i1 < i4)
      {
        localLayoutParams = (LayoutParams)getChildAt(i1).getLayoutParams();
        if (localLayoutParams.c != 1) {
          break label119;
        }
        i2 = 1;
        if (localLayoutParams.c != 2) {
          break label124;
        }
      }
      label119:
      label124:
      for (int i3 = 1;; i3 = 0)
      {
        if ((i2 == 0) && (i3 == 0)) {
          break label129;
        }
        localSavedState.a = localLayoutParams.gravity;
        localSavedState.b = this.s;
        localSavedState.c = this.t;
        localSavedState.d = this.u;
        localSavedState.e = this.v;
        return localSavedState;
        i2 = 0;
        break;
      }
      label129:
      i1 += 1;
    }
  }
  
  public boolean onTouchEvent(MotionEvent paramMotionEvent)
  {
    this.l.processTouchEvent(paramMotionEvent);
    this.m.processTouchEvent(paramMotionEvent);
    float f1;
    float f2;
    boolean bool;
    switch (paramMotionEvent.getAction() & 0xFF)
    {
    case 2: 
    default: 
      return true;
    case 0: 
      f1 = paramMotionEvent.getX();
      f2 = paramMotionEvent.getY();
      this.z = f1;
      this.A = f2;
      this.w = false;
      this.c = false;
      return true;
    case 1: 
      f2 = paramMotionEvent.getX();
      f1 = paramMotionEvent.getY();
      paramMotionEvent = this.l.findTopChildUnder((int)f2, (int)f1);
      if ((paramMotionEvent != null) && (e(paramMotionEvent)))
      {
        f2 -= this.z;
        f1 -= this.A;
        int i1 = this.l.getTouchSlop();
        if (f2 * f2 + f1 * f1 < i1 * i1)
        {
          paramMotionEvent = b();
          if (paramMotionEvent != null) {
            if (getDrawerLockMode(paramMotionEvent) == 2) {
              bool = true;
            }
          }
        }
      }
      break;
    }
    for (;;)
    {
      a(bool);
      this.w = false;
      return true;
      bool = false;
      continue;
      a(true);
      this.w = false;
      this.c = false;
      return true;
      bool = true;
    }
  }
  
  public void openDrawer(int paramInt)
  {
    openDrawer(paramInt, true);
  }
  
  public void openDrawer(int paramInt, boolean paramBoolean)
  {
    View localView = a(paramInt);
    if (localView == null) {
      throw new IllegalArgumentException("No drawer view found with gravity " + b(paramInt));
    }
    openDrawer(localView, paramBoolean);
  }
  
  public void openDrawer(View paramView)
  {
    openDrawer(paramView, true);
  }
  
  public void openDrawer(View paramView, boolean paramBoolean)
  {
    if (!c(paramView)) {
      throw new IllegalArgumentException("View " + paramView + " is not a sliding drawer");
    }
    LayoutParams localLayoutParams = (LayoutParams)paramView.getLayoutParams();
    if (this.r)
    {
      localLayoutParams.a = 1.0F;
      localLayoutParams.c = 1;
      a(paramView, true);
    }
    for (;;)
    {
      invalidate();
      return;
      if (paramBoolean)
      {
        localLayoutParams.c |= 0x2;
        if (a(paramView, 3)) {
          this.l.smoothSlideViewTo(paramView, 0, paramView.getTop());
        } else {
          this.m.smoothSlideViewTo(paramView, getWidth() - paramView.getWidth(), paramView.getTop());
        }
      }
      else
      {
        b(paramView, 1.0F);
        a(0, paramView);
        paramView.setVisibility(0);
      }
    }
  }
  
  public void removeDrawerListener(@NonNull DrawerListener paramDrawerListener)
  {
    if (paramDrawerListener == null) {}
    while (this.y == null) {
      return;
    }
    this.y.remove(paramDrawerListener);
  }
  
  public void requestDisallowInterceptTouchEvent(boolean paramBoolean)
  {
    super.requestDisallowInterceptTouchEvent(paramBoolean);
    this.w = paramBoolean;
    if (paramBoolean) {
      a(true);
    }
  }
  
  public void requestLayout()
  {
    if (!this.q) {
      super.requestLayout();
    }
  }
  
  public void setChildInsets(Object paramObject, boolean paramBoolean)
  {
    this.G = paramObject;
    this.H = paramBoolean;
    if ((!paramBoolean) && (getBackground() == null)) {}
    for (paramBoolean = true;; paramBoolean = false)
    {
      setWillNotDraw(paramBoolean);
      requestLayout();
      return;
    }
  }
  
  public void setDrawerElevation(float paramFloat)
  {
    this.g = paramFloat;
    int i1 = 0;
    while (i1 < getChildCount())
    {
      View localView = getChildAt(i1);
      if (c(localView)) {
        ViewCompat.setElevation(localView, this.g);
      }
      i1 += 1;
    }
  }
  
  @Deprecated
  public void setDrawerListener(DrawerListener paramDrawerListener)
  {
    if (this.x != null) {
      removeDrawerListener(this.x);
    }
    if (paramDrawerListener != null) {
      addDrawerListener(paramDrawerListener);
    }
    this.x = paramDrawerListener;
  }
  
  public void setDrawerLockMode(int paramInt)
  {
    setDrawerLockMode(paramInt, 3);
    setDrawerLockMode(paramInt, 5);
  }
  
  public void setDrawerLockMode(int paramInt1, int paramInt2)
  {
    int i1 = GravityCompat.getAbsoluteGravity(paramInt2, ViewCompat.getLayoutDirection(this));
    Object localObject;
    switch (paramInt2)
    {
    default: 
      if (paramInt1 != 0)
      {
        if (i1 == 3)
        {
          localObject = this.l;
          label67:
          ((ViewDragHelper)localObject).cancel();
        }
      }
      else {
        switch (paramInt1)
        {
        }
      }
      break;
    }
    do
    {
      do
      {
        return;
        this.s = paramInt1;
        break;
        this.t = paramInt1;
        break;
        this.u = paramInt1;
        break;
        this.v = paramInt1;
        break;
        localObject = this.m;
        break label67;
        localObject = a(i1);
      } while (localObject == null);
      openDrawer((View)localObject);
      return;
      localObject = a(i1);
    } while (localObject == null);
    closeDrawer((View)localObject);
  }
  
  public void setDrawerLockMode(int paramInt, View paramView)
  {
    if (!c(paramView)) {
      throw new IllegalArgumentException("View " + paramView + " is not a drawer with appropriate layout_gravity");
    }
    setDrawerLockMode(paramInt, ((LayoutParams)paramView.getLayoutParams()).gravity);
  }
  
  public void setDrawerShadow(@DrawableRes int paramInt1, int paramInt2)
  {
    setDrawerShadow(ContextCompat.getDrawable(getContext(), paramInt1), paramInt2);
  }
  
  public void setDrawerShadow(Drawable paramDrawable, int paramInt)
  {
    if (e) {
      return;
    }
    if ((paramInt & 0x800003) == 8388611) {
      this.I = paramDrawable;
    }
    for (;;)
    {
      c();
      invalidate();
      return;
      if ((paramInt & 0x800005) == 8388613)
      {
        this.J = paramDrawable;
      }
      else if ((paramInt & 0x3) == 3)
      {
        this.K = paramDrawable;
      }
      else
      {
        if ((paramInt & 0x5) != 5) {
          break;
        }
        this.L = paramDrawable;
      }
    }
  }
  
  public void setDrawerTitle(int paramInt, CharSequence paramCharSequence)
  {
    paramInt = GravityCompat.getAbsoluteGravity(paramInt, ViewCompat.getLayoutDirection(this));
    if (paramInt == 3) {
      this.E = paramCharSequence;
    }
    while (paramInt != 5) {
      return;
    }
    this.F = paramCharSequence;
  }
  
  public void setScrimColor(@ColorInt int paramInt)
  {
    this.i = paramInt;
    invalidate();
  }
  
  public void setStatusBarBackground(int paramInt)
  {
    if (paramInt != 0) {}
    for (Drawable localDrawable = ContextCompat.getDrawable(getContext(), paramInt);; localDrawable = null)
    {
      this.B = localDrawable;
      invalidate();
      return;
    }
  }
  
  public void setStatusBarBackground(Drawable paramDrawable)
  {
    this.B = paramDrawable;
    invalidate();
  }
  
  public void setStatusBarBackgroundColor(@ColorInt int paramInt)
  {
    this.B = new ColorDrawable(paramInt);
    invalidate();
  }
  
  public static abstract interface DrawerListener
  {
    public abstract void onDrawerClosed(View paramView);
    
    public abstract void onDrawerOpened(View paramView);
    
    public abstract void onDrawerSlide(View paramView, float paramFloat);
    
    public abstract void onDrawerStateChanged(int paramInt);
  }
  
  public static class LayoutParams
    extends ViewGroup.MarginLayoutParams
  {
    float a;
    boolean b;
    int c;
    public int gravity = 0;
    
    public LayoutParams(int paramInt1, int paramInt2)
    {
      super(paramInt2);
    }
    
    public LayoutParams(int paramInt1, int paramInt2, int paramInt3)
    {
      this(paramInt1, paramInt2);
    }
    
    public LayoutParams(Context paramContext, AttributeSet paramAttributeSet)
    {
      super(paramAttributeSet);
      paramContext = paramContext.obtainStyledAttributes(paramAttributeSet, DrawerLayout.a);
      this.gravity = paramContext.getInt(0, 0);
      paramContext.recycle();
    }
    
    public LayoutParams(LayoutParams paramLayoutParams)
    {
      super();
      this.gravity = paramLayoutParams.gravity;
    }
    
    public LayoutParams(ViewGroup.LayoutParams paramLayoutParams)
    {
      super();
    }
    
    public LayoutParams(ViewGroup.MarginLayoutParams paramMarginLayoutParams)
    {
      super();
    }
  }
  
  public static class SavedState
    extends AbsSavedState
  {
    public static final Parcelable.Creator<SavedState> CREATOR = ParcelableCompat.newCreator(new ParcelableCompatCreatorCallbacks() {});
    int a = 0;
    int b;
    int c;
    int d;
    int e;
    
    public SavedState(Parcel paramParcel, ClassLoader paramClassLoader)
    {
      super(paramClassLoader);
      this.a = paramParcel.readInt();
      this.b = paramParcel.readInt();
      this.c = paramParcel.readInt();
      this.d = paramParcel.readInt();
      this.e = paramParcel.readInt();
    }
    
    public SavedState(Parcelable paramParcelable)
    {
      super();
    }
    
    public void writeToParcel(Parcel paramParcel, int paramInt)
    {
      super.writeToParcel(paramParcel, paramInt);
      paramParcel.writeInt(this.a);
      paramParcel.writeInt(this.b);
      paramParcel.writeInt(this.c);
      paramParcel.writeInt(this.d);
      paramParcel.writeInt(this.e);
    }
  }
  
  public static abstract class SimpleDrawerListener
    implements DrawerLayout.DrawerListener
  {
    public void onDrawerClosed(View paramView) {}
    
    public void onDrawerOpened(View paramView) {}
    
    public void onDrawerSlide(View paramView, float paramFloat) {}
    
    public void onDrawerStateChanged(int paramInt) {}
  }
  
  final class a
    extends AccessibilityDelegateCompat
  {
    private final Rect c = new Rect();
    
    a() {}
    
    public final boolean dispatchPopulateAccessibilityEvent(View paramView, AccessibilityEvent paramAccessibilityEvent)
    {
      if (paramAccessibilityEvent.getEventType() == 32)
      {
        paramView = paramAccessibilityEvent.getText();
        paramAccessibilityEvent = DrawerLayout.this.a();
        if (paramAccessibilityEvent != null)
        {
          int i = DrawerLayout.this.b(paramAccessibilityEvent);
          paramAccessibilityEvent = DrawerLayout.this.getDrawerTitle(i);
          if (paramAccessibilityEvent != null) {
            paramView.add(paramAccessibilityEvent);
          }
        }
        return true;
      }
      return super.dispatchPopulateAccessibilityEvent(paramView, paramAccessibilityEvent);
    }
    
    public final void onInitializeAccessibilityEvent(View paramView, AccessibilityEvent paramAccessibilityEvent)
    {
      super.onInitializeAccessibilityEvent(paramView, paramAccessibilityEvent);
      paramAccessibilityEvent.setClassName(DrawerLayout.class.getName());
    }
    
    public final void onInitializeAccessibilityNodeInfo(View paramView, AccessibilityNodeInfoCompat paramAccessibilityNodeInfoCompat)
    {
      if (DrawerLayout.b) {
        super.onInitializeAccessibilityNodeInfo(paramView, paramAccessibilityNodeInfoCompat);
      }
      for (;;)
      {
        paramAccessibilityNodeInfoCompat.setClassName(DrawerLayout.class.getName());
        paramAccessibilityNodeInfoCompat.setFocusable(false);
        paramAccessibilityNodeInfoCompat.setFocused(false);
        paramAccessibilityNodeInfoCompat.removeAction(AccessibilityNodeInfoCompat.AccessibilityActionCompat.ACTION_FOCUS);
        paramAccessibilityNodeInfoCompat.removeAction(AccessibilityNodeInfoCompat.AccessibilityActionCompat.ACTION_CLEAR_FOCUS);
        return;
        Object localObject1 = AccessibilityNodeInfoCompat.obtain(paramAccessibilityNodeInfoCompat);
        super.onInitializeAccessibilityNodeInfo(paramView, (AccessibilityNodeInfoCompat)localObject1);
        paramAccessibilityNodeInfoCompat.setSource(paramView);
        Object localObject2 = ViewCompat.getParentForAccessibility(paramView);
        if ((localObject2 instanceof View)) {
          paramAccessibilityNodeInfoCompat.setParent((View)localObject2);
        }
        localObject2 = this.c;
        ((AccessibilityNodeInfoCompat)localObject1).getBoundsInParent((Rect)localObject2);
        paramAccessibilityNodeInfoCompat.setBoundsInParent((Rect)localObject2);
        ((AccessibilityNodeInfoCompat)localObject1).getBoundsInScreen((Rect)localObject2);
        paramAccessibilityNodeInfoCompat.setBoundsInScreen((Rect)localObject2);
        paramAccessibilityNodeInfoCompat.setVisibleToUser(((AccessibilityNodeInfoCompat)localObject1).isVisibleToUser());
        paramAccessibilityNodeInfoCompat.setPackageName(((AccessibilityNodeInfoCompat)localObject1).getPackageName());
        paramAccessibilityNodeInfoCompat.setClassName(((AccessibilityNodeInfoCompat)localObject1).getClassName());
        paramAccessibilityNodeInfoCompat.setContentDescription(((AccessibilityNodeInfoCompat)localObject1).getContentDescription());
        paramAccessibilityNodeInfoCompat.setEnabled(((AccessibilityNodeInfoCompat)localObject1).isEnabled());
        paramAccessibilityNodeInfoCompat.setClickable(((AccessibilityNodeInfoCompat)localObject1).isClickable());
        paramAccessibilityNodeInfoCompat.setFocusable(((AccessibilityNodeInfoCompat)localObject1).isFocusable());
        paramAccessibilityNodeInfoCompat.setFocused(((AccessibilityNodeInfoCompat)localObject1).isFocused());
        paramAccessibilityNodeInfoCompat.setAccessibilityFocused(((AccessibilityNodeInfoCompat)localObject1).isAccessibilityFocused());
        paramAccessibilityNodeInfoCompat.setSelected(((AccessibilityNodeInfoCompat)localObject1).isSelected());
        paramAccessibilityNodeInfoCompat.setLongClickable(((AccessibilityNodeInfoCompat)localObject1).isLongClickable());
        paramAccessibilityNodeInfoCompat.addAction(((AccessibilityNodeInfoCompat)localObject1).getActions());
        ((AccessibilityNodeInfoCompat)localObject1).recycle();
        paramView = (ViewGroup)paramView;
        int j = paramView.getChildCount();
        int i = 0;
        while (i < j)
        {
          localObject1 = paramView.getChildAt(i);
          if (DrawerLayout.d((View)localObject1)) {
            paramAccessibilityNodeInfoCompat.addChild((View)localObject1);
          }
          i += 1;
        }
      }
    }
    
    public final boolean onRequestSendAccessibilityEvent(ViewGroup paramViewGroup, View paramView, AccessibilityEvent paramAccessibilityEvent)
    {
      if ((DrawerLayout.b) || (DrawerLayout.d(paramView))) {
        return super.onRequestSendAccessibilityEvent(paramViewGroup, paramView, paramAccessibilityEvent);
      }
      return false;
    }
  }
  
  final class b
    extends AccessibilityDelegateCompat
  {
    b() {}
    
    public final void onInitializeAccessibilityNodeInfo(View paramView, AccessibilityNodeInfoCompat paramAccessibilityNodeInfoCompat)
    {
      super.onInitializeAccessibilityNodeInfo(paramView, paramAccessibilityNodeInfoCompat);
      if (!DrawerLayout.d(paramView)) {
        paramAccessibilityNodeInfoCompat.setParent(null);
      }
    }
  }
  
  static abstract interface c
  {
    public abstract int a(Object paramObject);
    
    public abstract Drawable a(Context paramContext);
    
    public abstract void a(View paramView);
    
    public abstract void a(View paramView, Object paramObject, int paramInt);
    
    public abstract void a(ViewGroup.MarginLayoutParams paramMarginLayoutParams, Object paramObject, int paramInt);
  }
  
  static final class d
    implements DrawerLayout.c
  {
    public final int a(Object paramObject)
    {
      return ew.a(paramObject);
    }
    
    public final Drawable a(Context paramContext)
    {
      return ew.a(paramContext);
    }
    
    public final void a(View paramView)
    {
      ew.a(paramView);
    }
    
    public final void a(View paramView, Object paramObject, int paramInt)
    {
      ew.a(paramView, paramObject, paramInt);
    }
    
    public final void a(ViewGroup.MarginLayoutParams paramMarginLayoutParams, Object paramObject, int paramInt)
    {
      ew.a(paramMarginLayoutParams, paramObject, paramInt);
    }
  }
  
  static final class e
    implements DrawerLayout.c
  {
    public final int a(Object paramObject)
    {
      return 0;
    }
    
    public final Drawable a(Context paramContext)
    {
      return null;
    }
    
    public final void a(View paramView) {}
    
    public final void a(View paramView, Object paramObject, int paramInt) {}
    
    public final void a(ViewGroup.MarginLayoutParams paramMarginLayoutParams, Object paramObject, int paramInt) {}
  }
  
  final class f
    extends ViewDragHelper.Callback
  {
    final int a;
    ViewDragHelper b;
    private final Runnable d = new Runnable()
    {
      public final void run()
      {
        int k = 0;
        Object localObject2 = DrawerLayout.f.this;
        int m = ((DrawerLayout.f)localObject2).b.getEdgeSize();
        int i;
        Object localObject1;
        int j;
        if (((DrawerLayout.f)localObject2).a == 3)
        {
          i = 1;
          if (i == 0) {
            break label226;
          }
          localObject1 = ((DrawerLayout.f)localObject2).c.a(3);
          if (localObject1 == null) {
            break label221;
          }
          j = -((View)localObject1).getWidth();
          label56:
          j += m;
        }
        for (;;)
        {
          label61:
          if ((localObject1 != null) && (((i != 0) && (((View)localObject1).getLeft() < j)) || ((i == 0) && (((View)localObject1).getLeft() > j) && (((DrawerLayout.f)localObject2).c.getDrawerLockMode((View)localObject1) == 0))))
          {
            DrawerLayout.LayoutParams localLayoutParams = (DrawerLayout.LayoutParams)((View)localObject1).getLayoutParams();
            ((DrawerLayout.f)localObject2).b.smoothSlideViewTo((View)localObject1, j, ((View)localObject1).getTop());
            localLayoutParams.b = true;
            ((DrawerLayout.f)localObject2).c.invalidate();
            ((DrawerLayout.f)localObject2).b();
            localObject1 = ((DrawerLayout.f)localObject2).c;
            if (!((DrawerLayout)localObject1).c)
            {
              long l = SystemClock.uptimeMillis();
              localObject2 = MotionEvent.obtain(l, l, 3, 0.0F, 0.0F, 0);
              j = ((DrawerLayout)localObject1).getChildCount();
              i = k;
              for (;;)
              {
                if (i < j)
                {
                  ((DrawerLayout)localObject1).getChildAt(i).dispatchTouchEvent((MotionEvent)localObject2);
                  i += 1;
                  continue;
                  i = 0;
                  break;
                  label221:
                  j = 0;
                  break label56;
                  label226:
                  localObject1 = ((DrawerLayout.f)localObject2).c.a(5);
                  j = ((DrawerLayout.f)localObject2).c.getWidth();
                  j -= m;
                  break label61;
                }
              }
              ((MotionEvent)localObject2).recycle();
              ((DrawerLayout)localObject1).c = true;
            }
          }
        }
      }
    };
    
    f(int paramInt)
    {
      this.a = paramInt;
    }
    
    public final void a()
    {
      DrawerLayout.this.removeCallbacks(this.d);
    }
    
    final void b()
    {
      int i = 3;
      if (this.a == 3) {
        i = 5;
      }
      View localView = DrawerLayout.this.a(i);
      if (localView != null) {
        DrawerLayout.this.closeDrawer(localView);
      }
    }
    
    public final int clampViewPositionHorizontal(View paramView, int paramInt1, int paramInt2)
    {
      if (DrawerLayout.this.a(paramView, 3)) {
        return Math.max(-paramView.getWidth(), Math.min(paramInt1, 0));
      }
      paramInt2 = DrawerLayout.this.getWidth();
      return Math.max(paramInt2 - paramView.getWidth(), Math.min(paramInt1, paramInt2));
    }
    
    public final int clampViewPositionVertical(View paramView, int paramInt1, int paramInt2)
    {
      return paramView.getTop();
    }
    
    public final int getViewHorizontalDragRange(View paramView)
    {
      if (DrawerLayout.c(paramView)) {
        return paramView.getWidth();
      }
      return 0;
    }
    
    public final void onEdgeDragStarted(int paramInt1, int paramInt2)
    {
      if ((paramInt1 & 0x1) == 1) {}
      for (View localView = DrawerLayout.this.a(3);; localView = DrawerLayout.this.a(5))
      {
        if ((localView != null) && (DrawerLayout.this.getDrawerLockMode(localView) == 0)) {
          this.b.captureChildView(localView, paramInt2);
        }
        return;
      }
    }
    
    public final boolean onEdgeLock(int paramInt)
    {
      return false;
    }
    
    public final void onEdgeTouched(int paramInt1, int paramInt2)
    {
      DrawerLayout.this.postDelayed(this.d, 160L);
    }
    
    public final void onViewCaptured(View paramView, int paramInt)
    {
      ((DrawerLayout.LayoutParams)paramView.getLayoutParams()).b = false;
      b();
    }
    
    public final void onViewDragStateChanged(int paramInt)
    {
      DrawerLayout.this.a(paramInt, this.b.getCapturedView());
    }
    
    public final void onViewPositionChanged(View paramView, int paramInt1, int paramInt2, int paramInt3, int paramInt4)
    {
      paramInt2 = paramView.getWidth();
      float f;
      if (DrawerLayout.this.a(paramView, 3))
      {
        f = (paramInt2 + paramInt1) / paramInt2;
        DrawerLayout.this.a(paramView, f);
        if (f != 0.0F) {
          break label76;
        }
      }
      label76:
      for (paramInt1 = 4;; paramInt1 = 0)
      {
        paramView.setVisibility(paramInt1);
        DrawerLayout.this.invalidate();
        return;
        f = (DrawerLayout.this.getWidth() - paramInt1) / paramInt2;
        break;
      }
    }
    
    public final void onViewReleased(View paramView, float paramFloat1, float paramFloat2)
    {
      paramFloat2 = DrawerLayout.a(paramView);
      int k = paramView.getWidth();
      int i;
      if (DrawerLayout.this.a(paramView, 3)) {
        if ((paramFloat1 > 0.0F) || ((paramFloat1 == 0.0F) && (paramFloat2 > 0.5F))) {
          i = 0;
        }
      }
      for (;;)
      {
        this.b.settleCapturedViewAt(i, paramView.getTop());
        DrawerLayout.this.invalidate();
        return;
        i = -k;
        continue;
        int j = DrawerLayout.this.getWidth();
        if (paramFloat1 >= 0.0F)
        {
          i = j;
          if (paramFloat1 == 0.0F)
          {
            i = j;
            if (paramFloat2 <= 0.5F) {}
          }
        }
        else
        {
          i = j - k;
        }
      }
    }
    
    public final boolean tryCaptureView(View paramView, int paramInt)
    {
      return (DrawerLayout.c(paramView)) && (DrawerLayout.this.a(paramView, this.a)) && (DrawerLayout.this.getDrawerLockMode(paramView) == 0);
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/v4/widget/DrawerLayout.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */