gt:                 if (child.canScrollHorizontally(-1)) {
context: package org.telegram.ui.Components;
  
  import android.animation.Animator;
  import android.animation.AnimatorListenerAdapter;
  import android.animation.AnimatorSet;
  import android.animation.ObjectAnimator;
  import android.animation.ValueAnimator;
  import android.annotation.SuppressLint;
  import android.content.Context;
  import android.graphics.Bitmap;
  import android.graphics.Canvas;
  import android.graphics.Paint;
  import android.graphics.Rect;
  import android.graphics.RectF;
  import android.graphics.drawable.Drawable;
  import android.graphics.drawable.GradientDrawable;
  import android.os.SystemClock;
  import android.text.Layout;
  import android.text.StaticLayout;
  import android.text.TextPaint;
  import android.text.TextUtils;
  import android.util.SparseArray;
  import android.util.SparseIntArray;
  import android.view.MotionEvent;
  import android.view.VelocityTracker;
  import android.view.View;
  import android.view.ViewConfiguration;
  import android.view.ViewGroup;
  import android.view.accessibility.AccessibilityNodeInfo;
  import android.view.animation.Interpolator;
  import android.widget.FrameLayout;
  import android.widget.TextView;
  
  import androidx.annotation.NonNull;
  import androidx.core.graphics.ColorUtils;
  import androidx.core.view.accessibility.AccessibilityNodeInfoCompat;
  import androidx.recyclerview.widget.DefaultItemAnimator;
  import androidx.recyclerview.widget.LinearLayoutManager;
  import androidx.recyclerview.widget.LinearSmoothScroller;
  import androidx.recyclerview.widget.RecyclerView;
  
  import org.telegram.messenger.AndroidUtilities;
  import org.telegram.messenger.Emoji;
  import org.telegram.messenger.MessagesController;
  import org.telegram.messenger.MessagesStorage;
  import org.telegram.messenger.UserConfig;
  import org.telegram.tgnet.ConnectionsManager;
  import org.telegram.tgnet.TLRPC;
  import org.telegram.ui.ActionBar.Theme;
  
  import java.util.ArrayList;
  
  public class ViewPagerFixed extends FrameLayout {
  
      int currentPosition;
      int nextPosition;
      private View[] viewPages;
      private int[] viewTypes;
  
      protected SparseArray<View> viewsByType = new SparseArray<>();
  
      private int startedTrackingPointerId;
      private int startedTrackingX;
      private int startedTrackingY;
      private VelocityTracker velocityTracker;
  
      private AnimatorSet tabsAnimation;
      private boolean tabsAnimationInProgress;
      private boolean animatingForward;
      private float additionalOffset;
      private boolean backAnimation;
      private int maximumVelocity;
      private boolean startedTracking;
      private boolean maybeStartTracking;
      private static final Interpolator interpolator = t -> {
          --t;
          return t * t * t * t * t + 1.0F;
      };
  
      private final float touchSlop;
  
      private Adapter adapter;
      TabsView tabsView;
  
      ValueAnimator.AnimatorUpdateListener updateTabProgress = new ValueAnimator.AnimatorUpdateListener() {
          @Override
          public void onAnimationUpdate(ValueAnimator valueAnimator) {
              if (tabsAnimationInProgress) {
                  float scrollProgress = Math.abs(viewPages[0].getTranslationX()) / (float) viewPages[0].getMeasuredWidth();
                  if (tabsView != null) {
                      tabsView.selectTab(nextPosition, currentPosition, 1f - scrollProgress);
                  }
              }
          }
      };
      private Rect rect = new Rect();
  
      public ViewPagerFixed(@NonNull Context context) {
          super(context);
  
          touchSlop = AndroidUtilities.getPixelsInCM(0.3f, true);
          maximumVelocity = ViewConfiguration.get(context).getScaledMaximumFlingVelocity();
  
          viewTypes = new int[2];
          viewPages = new View[2];
          setClipChildren(true);
      }
  
      public void setAdapter(Adapter adapter) {
          this.adapter = adapter;
          viewTypes[0] = adapter.getItemViewType(currentPosition);
          viewPages[0] = adapter.createView(viewTypes[0]);
          adapter.bindView(viewPages[0], currentPosition, viewTypes[0]);
          addView(viewPages[0]);
          viewPages[0].setVisibility(View.VISIBLE);
          fillTabs();
      }
  
      public TabsView createTabsView() {
          tabsView = new TabsView(getContext());
          tabsView.setDelegate(new TabsView.TabsViewDelegate() {
              @Override
              public void onPageSelected(int page, boolean forward) {
                  animatingForward = forward;
                  nextPosition = page;
                  updateViewForIndex(1);
  
                  if (forward) {
                      viewPages[1].setTranslationX(viewPages[0].getMeasuredWidth());
                  } else {
                      viewPages[1].setTranslationX(-viewPages[0].getMeasuredWidth());
                  }
              }
  
              @Override
              public void onPageScrolled(float progress) {
                  if (progress == 1f) {
                      if (viewPages[1] != null) {
                          swapViews();
                          viewsByType.put(viewTypes[1], viewPages[1]);
                          removeView(viewPages[1]);
                          viewPages[0].setTranslationX(0);
                          viewPages[1] = null;
                      }
                      return;
                  }
                  if (viewPages[1] == null) {
                      return;
                  }
                  if (animatingForward) {
                      viewPages[1].setTranslationX(viewPages[0].getMeasuredWidth() * (1f - progress));
                      viewPages[0].setTranslationX(-viewPages[0].getMeasuredWidth() * progress);
                  } else {
                      viewPages[1].setTranslationX(-viewPages[0].getMeasuredWidth() * (1f - progress));
                      viewPages[0].setTranslationX(viewPages[0].getMeasuredWidth() * progress);
                  }
              }
  
              @Override
              public void onSamePageSelected() {
  
              }
  
              @Override
              public boolean canPerformActions() {
                  return !tabsAnimationInProgress && !startedTracking;
              }
          });
          fillTabs();
          return tabsView;
      }
  
      private void updateViewForIndex(int index) {
          int adapterPosition = index == 0 ? currentPosition : nextPosition;
          if (viewPages[index] == null) {
              viewTypes[index] = adapter.getItemViewType(adapterPosition);
              View v = viewsByType.get(viewTypes[index]);
              if (v == null) {
                  v = adapter.createView(viewTypes[index]);
              } else {
                  viewsByType.remove(viewTypes[index]);
              }
              if (v.getParent() != null) {
                  ViewGroup parent = (ViewGroup) v.getParent();
                  parent.removeView(v);
              }
              addView(v);
              viewPages[index] = v;
              adapter.bindView(viewPages[index], adapterPosition, viewTypes[index]);
              viewPages[index].setVisibility(View.VISIBLE);
          } else {
              if (viewTypes[index] == adapter.getItemViewType(adapterPosition)) {
                  adapter.bindView(viewPages[index], adapterPosition, viewTypes[index]);
                  viewPages[index].setVisibility(View.VISIBLE);
              } else {
                  viewsByType.put(viewTypes[index], viewPages[index]);
                  viewPages[index].setVisibility(View.GONE);
                  removeView(viewPages[index]);
                  viewTypes[index] = adapter.getItemViewType(adapterPosition);
                  View v = viewsByType.get(viewTypes[index]);
                  if (v == null) {
                      v = adapter.createView(viewTypes[index]);
                  } else {
                      viewsByType.remove(viewTypes[index]);
                  }
                  addView(v);
                  viewPages[index] = v;
                  viewPages[index].setVisibility(View.VISIBLE);
                  adapter.bindView(viewPages[index], adapterPosition, adapter.getItemViewType(adapterPosition));
              }
          }
      }
  
      private void fillTabs() {
          if (adapter != null && tabsView != null) {
              tabsView.removeTabs();
              for (int i = 0; i < adapter.getItemCount(); i++) {
                  tabsView.addTab(adapter.getItemId(i), adapter.getItemTitle(i));
              }
          }
      }
  
      private boolean prepareForMoving(MotionEvent ev, boolean forward) {
          if ((!forward && currentPosition == 0) || (forward && currentPosition == adapter.getItemCount() - 1)) {
              return false;
          }
  
          getParent().requestDisallowInterceptTouchEvent(true);
          maybeStartTracking = false;
          startedTracking = true;
          startedTrackingX = (int) (ev.getX() + additionalOffset);
          if (tabsView != null) {
              tabsView.setEnabled(false);
          }
  
          animatingForward = forward;
          nextPosition = currentPosition + (forward ? 1 : -1);
          updateViewForIndex(1);
          if (forward) {
              viewPages[1].setTranslationX(viewPages[0].getMeasuredWidth());
          } else {
              viewPages[1].setTranslationX(-viewPages[0].getMeasuredWidth());
          }
          return true;
      }
  
      public boolean onInterceptTouchEvent(MotionEvent ev) {
          if (tabsView != null && tabsView.isAnimatingIndicator()) {
              return false;
          }
          if (checkTabsAnimationInProgress()) {
              return true;
          }
          onTouchEvent(ev);
          return startedTracking;
      }
  
      @Override
      public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
          if (maybeStartTracking && !startedTracking) {
              onTouchEvent(null);
          }
          super.requestDisallowInterceptTouchEvent(disallowIntercept);
      }
  
      @Override
      public boolean onTouchEvent(MotionEvent ev) {
          if (tabsView != null && tabsView.animatingIndicator) {
              return false;
          }
          if (ev != null) {
              if (velocityTracker == null) {
                  velocityTracker = VelocityTracker.obtain();
              }
              velocityTracker.addMovement(ev);
          }
          if (ev != null && ev.getAction() == MotionEvent.ACTION_DOWN && checkTabsAnimationInProgress()) {
              startedTracking = true;
              startedTrackingPointerId = ev.getPointerId(0);
              startedTrackingX = (int) ev.getX();
              if (animatingForward) {
                  if (startedTrackingX < viewPages[0].getMeasuredWidth() + viewPages[0].getTranslationX()) {
                      additionalOffset = viewPages[0].getTranslationX();
                  } else {
                      swapViews();
                      animatingForward = false;
                      additionalOffset = viewPages[0].getTranslationX();
                  }
              } else {
                  if (startedTrackingX < viewPages[1].getMeasuredWidth() + viewPages[1].getTranslationX()) {
                      swapViews();
                      animatingForward = true;
                      additionalOffset = viewPages[0].getTranslationX();
                  } else {
                      additionalOffset = viewPages[0].getTranslationX();
                  }
              }
              tabsAnimation.removeAllListeners();
              tabsAnimation.cancel();
              tabsAnimationInProgress = false;
          } else if (ev != null && ev.getAction() == MotionEvent.ACTION_DOWN) {
              additionalOffset = 0;
          }
  
          if (!startedTracking && ev != null) {
              View child = findScrollingChild(this, ev.getX(), ev.getY());
              if (child != null && (child.canScrollHorizontally(1) || child.canScrollHorizontally(-1))) {
                  return false;
              }
          }
          if (ev != null && ev.getAction() == MotionEvent.ACTION_DOWN && !startedTracking && !maybeStartTracking) {
              startedTrackingPointerId = ev.getPointerId(0);
              maybeStartTracking = true;
              startedTrackingX = (int) ev.getX();
              startedTrackingY = (int) ev.getY();
          } else if (ev != null && ev.getAction() == MotionEvent.ACTION_MOVE && ev.getPointerId(0) == startedTrackingPointerId) {
              int dx = (int) (ev.getX() - startedTrackingX + additionalOffset);
              int dy = Math.abs((int) ev.getY() - startedTrackingY);
              if (startedTracking && (animatingForward && dx > 0 || !animatingForward && dx < 0)) {
                  if (!prepareForMoving(ev, dx < 0)) {
                      maybeStartTracking = true;
                      startedTracking = false;
                      viewPages[0].setTranslationX(0);
                      viewPages[1].setTranslationX(animatingForward ? viewPages[0].getMeasuredWidth() : -viewPages[0].getMeasuredWidth());
                      if (tabsView != null) {
                          tabsView.selectTab(currentPosition, 0, 0);
                      }
                  }
              }
              if (maybeStartTracking && !startedTracking) {
                  int dxLocal = (int) (ev.getX() - startedTrackingX);
                  if (Math.abs(dxLocal) >= touchSlop && Math.abs(dxLocal) > dy) {
                      prepareForMoving(ev, dx < 0);
                  }
              } else if (startedTracking) {
                  viewPages[0].setTranslationX(dx);
                  if (animatingForward) {
                      viewPages[1].setTranslationX(viewPages[0].getMeasuredWidth() + dx);
                  } else {
                      viewPages[1].setTranslationX(dx - viewPages[0].getMeasuredWidth());
                  }
                  float scrollProgress = Math.abs(dx) / (float) viewPages[0].getMeasuredWidth();
                  if (tabsView != null) {
                      tabsView.selectTab(nextPosition, currentPosition, 1f - scrollProgress);
                  }
              }
          } else if (ev == null || ev.getPointerId(0) == startedTrackingPointerId && (ev.getAction() == MotionEvent.ACTION_CANCEL || ev.getAction() == MotionEvent.ACTION_UP || ev.getAction() == MotionEvent.ACTION_POINTER_UP)) {
              velocityTracker.computeCurrentVelocity(1000, maximumVelocity);
              float velX;
              float velY;
              if (ev != null && ev.getAction() != MotionEvent.ACTION_CANCEL) {
                  velX = velocityTracker.getXVelocity();
                  velY = velocityTracker.getYVelocity();
                  if (!startedTracking) {
                      if (Math.abs(velX) >= 3000 && Math.abs(velX) > Math.abs(velY)) {
                          prepareForMoving(ev, velX < 0);
                      }
                  }
              } else {
                  velX = 0;
                  velY = 0;
              }
              if (startedTracking) {
                  float x = viewPages[0].getX();
                  tabsAnimation = new AnimatorSet();
                  if (additionalOffset != 0) {
                      if (Math.abs(velX) > 1500) {
                          backAnimation = animatingForward ? velX > 0 : velX < 0;
                      } else {
                          if (animatingForward) {
                              backAnimation = (viewPages[1].getX() > (viewPages[0].getMeasuredWidth() >> 1));
                          } else {
                              backAnimation = (viewPages[0].getX() < (viewPages[0].getMeasuredWidth() >> 1));
                          }
                      }
                  } else {
                      backAnimation = Math.abs(x) < viewPages[0].getMeasuredWidth() / 3.0f && (Math.abs(velX) < 3500 || Math.abs(velX) < Math.abs(velY));
                  }
                  float distToMove;
                  float dx;
                  if (backAnimation) {
                      dx = Math.abs(x);
                      if (animatingForward) {
                          tabsAnimation.playTogether(
                                  ObjectAnimator.ofFloat(viewPages[0], View.TRANSLATION_X, 0),
                                  ObjectAnimator.ofFloat(viewPages[1], View.TRANSLATION_X, viewPages[1].getMeasuredWidth())
                          );
                      } else {
                          tabsAnimation.playTogether(
                                  ObjectAnimator.ofFloat(viewPages[0], View.TRANSLATION_X, 0),
                                  ObjectAnimator.ofFloat(viewPages[1], View.TRANSLATION_X, -viewPages[1].getMeasuredWidth())
                          );
                      }
                  } else {
                      dx = viewPages[0].getMeasuredWidth() - Math.abs(x);
                      if (animatingForward) {
                          tabsAnimation.playTogether(
                                  ObjectAnimator.ofFloat(viewPages[0], View.TRANSLATION_X, -viewPages[0].getMeasuredWidth()),
                                  ObjectAnimator.ofFloat(viewPages[1], View.TRANSLATION_X, 0)
                          );
                      } else {
                          tabsAnimation.playTogether(
                                  ObjectAnimator.ofFloat(viewPages[0], View.TRANSLATION_X, viewPages[0].getMeasuredWidth()),
                                  ObjectAnimator.ofFloat(viewPages[1], View.TRANSLATION_X, 0)
                          );
                      }
                  }
                  ValueAnimator animator = ValueAnimator.ofFloat(0,1f);
                  animator.addUpdateListener(updateTabProgress);
                  tabsAnimation.playTogether(animator);
                  tabsAnimation.setInterpolator(interpolator);
  
                  int width = getMeasuredWidth();
                  int halfWidth = width / 2;
                  float distanceRatio = Math.min(1.0f, 1.0f * dx / (float) width);
                  float distance = (float) halfWidth + (float) halfWidth * distanceInfluenceForSnapDuration(distanceRatio);
                  velX = Math.abs(velX);
                  int duration;
                  if (velX > 0) {
                      duration = 4 * Math.round(1000.0f * Math.abs(distance / velX));
                  } else {
                      float pageDelta = dx / getMeasuredWidth();
                      duration = (int) ((pageDelta + 1.0f) * 100.0f);
                  }
                  duration = Math.max(150, Math.min(duration, 600));
  
                  tabsAnimation.setDuration(duration);
                  tabsAnimation.addListener(new AnimatorListenerAdapter() {
                      @Override
                      public void onAnimationEnd(Animator animator) {
                          tabsAnimation = null;
                          if (viewPages[1] != null) {
                              if (!backAnimation) {
                                  swapViews();
                              }
  
                              viewsByType.put(viewTypes[1], viewPages[1]);
                              removeView(viewPages[1]);
                              viewPages[1].setVisibility(View.GONE);
                              viewPages[1] = null;
                          }
                          tabsAnimationInProgress = false;
                          maybeStartTracking = false;
                          if (tabsView != null) {
                              tabsView.setEnabled(true);
                          }
                      }
                  });
                  tabsAnimation.start();
                  tabsAnimationInProgress = true;
                  startedTracking = false;
              } else {
                  maybeStartTracking = false;
                  if (tabsView != null) {
                      tabsView.setEnabled(true);
                  }
              }
              if (velocityTracker != null) {
                  velocityTracker.recycle();
                  velocityTracker = null;
              }
          }
          return startedTracking || maybeStartTracking;
      }
  
      private void swapViews() {
          View page = viewPages[0];
          viewPages[0] = viewPages[1];
          viewPages[1] = page;
          int p = currentPosition;
          currentPosition = nextPosition;
          nextPosition = p;
          p = viewTypes[0];
          viewTypes[0] = viewTypes[1];
          viewTypes[1] = p;
  
          onItemSelected(viewPages[0], viewPages[1], currentPosition, nextPosition);
      }
  
  
      public boolean checkTabsAnimationInProgress() {
          if (tabsAnimationInProgress) {
              boolean cancel = false;
              if (backAnimation) {
                  if (Math.abs(viewPages[0].getTranslationX()) < 1) {
                      viewPages[0].setTranslationX(0);
                      viewPages[1].setTranslationX(viewPages[0].getMeasuredWidth() * (animatingForward ? 1 : -1));
                      cancel = true;
                  }
              } else if (Math.abs(viewPages[1].getTranslationX()) < 1) {
                  viewPages[0].setTranslationX(viewPages[0].getMeasuredWidth() * (animatingForward ? -1 : 1));
                  viewPages[1].setTranslationX(0);
                  cancel = true;
              }
              if (cancel) {
                  //showScrollbars(true);
                  if (tabsAnimation != null) {
                      tabsAnimation.cancel();
                      tabsAnimation = null;
                  }
                  tabsAnimationInProgress = false;
              }
              return tabsAnimationInProgress;
          }
          return false;
      }
  
      public static float distanceInfluenceForSnapDuration(float f) {
          f -= 0.5F;
          f *= 0.47123894F;
          return (float) Math.sin(f);
      }
  
      public void setPosition(int position) {
          if (tabsAnimation != null) {
              tabsAnimation.cancel();
          }
          if (viewPages[1] != null) {
              viewsByType.put(viewTypes[1], viewPages[1]);
              removeView(viewPages[1]);
              viewPages[1] = null;
          }
          if (currentPosition != position) {
              int oldPosition = currentPosition;
              currentPosition = position;
              View oldView = viewPages[0];
              updateViewForIndex(0);
              onItemSelected(viewPages[0], oldView, currentPosition, oldPosition);
              viewPages[0].setTranslationX(0);
              if (tabsView != null) {
                  tabsView.selectTab(position, 0, 1f);
              }
          }
      }
  
      protected void onItemSelected(View currentPage, View oldPage, int position, int oldPosition) {
  
      }
  
      public abstract static class Adapter {
          public abstract int getItemCount();
          public abstract View createView(int viewType);
          public abstract void bindView(View view, int position, int viewType);
  
          public int getItemId(int position) {
              return position;
          }
  
          public String getItemTitle(int position) {
              return "";
          }
  
          public int getItemViewType(int position) {
              return 0;
          }
      }
  
      @Override
      public boolean canScrollHorizontally(int direction) {
          if (direction == 0) {
              return false;
          }
          if (tabsAnimationInProgress || startedTracking) {
              return true;
          }
          boolean forward = direction > 0;
          if ((!forward && currentPosition == 0) || (forward && currentPosition == adapter.getItemCount() - 1)) {
              return false;
          }
          return true;
      }
  
      public View getCurrentView() {
          return viewPages[0];
      }
  
      public int getCurrentPosition() {
          return currentPosition;
      }
  
      public static class TabsView extends FrameLayout {
  
          public interface TabsViewDelegate {
              void onPageSelected(int page, boolean forward);
              void onPageScrolled(float progress);
              void onSamePageSelected();
              boolean canPerformActions();
          }
  
          private static class Tab {
              public int id;
              public String title;
              public int titleWidth;
              public int counter;
  
              public Tab(int i, String t) {
                  id = i;
                  title = t;
              }
  
              public int getWidth(boolean store, TextPaint textPaint) {
                  int width = titleWidth = (int) Math.ceil(textPaint.measureText(title));
                  return Math.max(AndroidUtilities.dp(40), width);
              }
  
              public boolean setTitle(String newTitle) {
                  if (TextUtils.equals(title, newTitle)) {
                      return false;
                  }
                  title = newTitle;
                  return true;
              }
          }
  
          public class TabView extends View {
  
              private Tab currentTab;
              private int textHeight;
              private int tabWidth;
              private int currentPosition;
              private RectF rect = new RectF();
              private String currentText;
              private StaticLayout textLayout;
              private int textOffsetX;
  
              public TabView(Context context) {
                  super(context);
              }
  
              public void setTab(Tab tab, int position) {
                  currentTab = tab;
                  currentPosition = position;
                  setContentDescription(tab.title);
                  requestLayout();
              }
  
              public int getId() {
                  return currentTab.id;
              }
  
              @Override
              protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                  int w = currentTab.getWidth(false, textPaint) + AndroidUtilities.dp(32) + additionalTabWidth;
                  setMeasuredDimension(w, MeasureSpec.getSize(heightMeasureSpec));
              }
  
              @SuppressLint("DrawAllocation")
              @Override
              protected void onDraw(Canvas canvas) {
                  if (currentTab.id != Integer.MAX_VALUE && editingAnimationProgress != 0) {
                      canvas.save();
                      float p = editingAnimationProgress * (currentPosition % 2 == 0 ? 1.0f : -1.0f);
                      canvas.translate(AndroidUtilities.dp(0.66f) * p, 0);
                      canvas.rotate(p, getMeasuredWidth() / 2, getMeasuredHeight() / 2);
                  }
                  String key;
                  String animateToKey;
                  String otherKey;
                  String animateToOtherKey;
                  String unreadKey;
                  String unreadOtherKey;
                  int id1;
                  int id2;
                  if (manualScrollingToId != -1) {
                      id1 = manualScrollingToId;
                      id2 = selectedTabId;
                  } else {
                      id1 = selectedTabId;
                      id2 = previousId;
                  }
                  if (currentTab.id == id1) {
                      key = activeTextColorKey;
                      otherKey = unactiveTextColorKey;
                      unreadKey = Theme.key_chats_tabUnreadActiveBackground;
                      unreadOtherKey = Theme.key_chats_tabUnreadUnactiveBackground;
                  } else {
                      key = unactiveTextColorKey;
                      otherKey = activeTextColorKey;
                      unreadKey = Theme.key_chats_tabUnreadUnactiveBackground;
                      unreadOtherKey = Theme.key_chats_tabUnreadActiveBackground;
                  }
  
                  if ((animatingIndicator || manualScrollingToId != -1) && (currentTab.id == id1 || currentTab.id == id2)) {
                      textPaint.setColor(ColorUtils.blendARGB(Theme.getColor(otherKey), Theme.getColor(key), animatingIndicatorProgress));
                  } else {
                      textPaint.setColor(Theme.getColor(key));
                  }
  
  
                  int counterWidth;
                  int countWidth;
                  String counterText;
                  if (currentTab.counter > 0) {
                      counterText = String.format("%d", currentTab.counter);
                      counterWidth = (int) Math.ceil(textCounterPaint.measureText(counterText));
                      countWidth = Math.max(AndroidUtilities.dp(10), counterWidth) + AndroidUtilities.dp(10);
                  } else {
                      counterText = null;
                      counterWidth = 0;
                      countWidth = 0;
                  }
  
                  if (currentTab.id != Integer.MAX_VALUE && (isEditing || editingStartAnimationProgress != 0)) {
                      countWidth = (int) (countWidth + (AndroidUtilities.dp(20) - countWidth) * editingStartAnimationProgress);
                  }
  
                  tabWidth = currentTab.titleWidth + (countWidth != 0 ? countWidth + AndroidUtilities.dp(6 * (counterText != null ? 1.0f : editingStartAnimationProgress)) : 0);
                  int textX = (getMeasuredWidth() - tabWidth) / 2;
                  if (!TextUtils.equals(currentTab.title, currentText)) {
                      currentText = currentTab.title;
                      CharSequence text = Emoji.replaceEmoji(currentText, textPaint.getFontMetricsInt(), AndroidUtilities.dp(15), false);
                      textLayout = new StaticLayout(text, textPaint, AndroidUtilities.dp(400), Layout.Alignment.ALIGN_NORMAL, 1.0f, 0, false);
                      textHeight = textLayout.getHeight();
                      textOffsetX = (int) -textLayout.getLineLeft(0);
                  }
                  if (textLayout != null) {
                      canvas.save();
                      canvas.translate(textX + textOffsetX, (getMeasuredHeight() - textHeight) / 2 + 1);
                      textLayout.draw(canvas);
                      canvas.restore();
                  }
  
                  if (counterText != null || currentTab.id != Integer.MAX_VALUE && (isEditing || editingStartAnimationProgress != 0)) {
                      textCounterPaint.setColor(Theme.getColor(backgroundColorKey));
                      if (Theme.hasThemeKey(unreadKey) && Theme.hasThemeKey(unreadOtherKey)) {
                          int color1 = Theme.getColor(unreadKey);
                          if ((animatingIndicator || manualScrollingToPosition != -1) && (currentTab.id == id1 || currentTab.id == id2)) {
                              int color3 = Theme.getColor(unreadOtherKey);
                              counterPaint.setColor(ColorUtils.blendARGB(color3, color1, animatingIndicatorProgress));
                          } else {
                              counterPaint.setColor(color1);
                          }
                      } else {
                          counterPaint.setColor(textPaint.getColor());
                      }
  
                      int x = textX + currentTab.titleWidth + AndroidUtilities.dp(6);
                      int countTop = (getMeasuredHeight() - AndroidUtilities.dp(20)) / 2;
  
                      if (currentTab.id != Integer.MAX_VALUE && (isEditing || editingStartAnimationProgress != 0) && counterText == null) {
                          counterPaint.setAlpha((int) (editingStartAnimationProgress * 255));
                      } else {
                          counterPaint.setAlpha(255);
                      }
  
                      rect.set(x, countTop, x + countWidth, countTop + AndroidUtilities.dp(20));
                      canvas.drawRoundRect(rect, 11.5f * AndroidUtilities.density, 11.5f * AndroidUtilities.density, counterPaint);
  
                      if (counterText != null) {
                          if (currentTab.id != Integer.MAX_VALUE) {
                              textCounterPaint.setAlpha((int) (255 * (1.0f - editingStartAnimationProgress)));
                          }
                          canvas.drawText(counterText, rect.left + (rect.width() - counterWidth) / 2, countTop + AndroidUtilities.dp(14.5f), textCounterPaint);
                      }
                      if (currentTab.id != Integer.MAX_VALUE && (isEditing || editingStartAnimationProgress != 0)) {
                          deletePaint.setColor(textCounterPaint.getColor());
                          deletePaint.setAlpha((int) (255 * editingStartAnimationProgress));
                          int side = AndroidUtilities.dp(3);
                          canvas.drawLine(rect.centerX() - side, rect.centerY() - side, rect.centerX() + side, rect.centerY() + side, deletePaint);
                          canvas.drawLine(rect.centerX() - side, rect.centerY() + side, rect.centerX() + side, rect.centerY() - side, deletePaint);
                      }
                  }
                  if (currentTab.id != Integer.MAX_VALUE && editingAnimationProgress != 0) {
                      canvas.restore();
                  }
              }
  
              @Override
              public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
                  super.onInitializeAccessibilityNodeInfo(info);
                  info.setSelected(currentTab != null && selectedTabId != -1 && currentTab.id == selectedTabId);
              }
          }
  
          private TextPaint textPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
          private TextPaint textCounterPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
          private Paint deletePaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
          private Paint counterPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
  
          private ArrayList<Tab> tabs = new ArrayList<>();
  
          private Bitmap crossfadeBitmap;
          private Paint crossfadePaint = new Paint();
          private float crossfadeAlpha;
          private boolean commitCrossfade;
  
          private boolean isEditing;
          private long lastEditingAnimationTime;
          private boolean editingForwardAnimation;
          private float editingAnimationProgress;
          private float editingStartAnimationProgress;
  
          private boolean orderChanged;
  
          private boolean ignoreLayout;
  
          private RecyclerListView listView;
          private LinearLayoutManager layoutManager;
          private ListAdapter adapter;
  
          private TabsViewDelegate delegate;
  
          private int currentPosition;
          private int selectedTabId = -1;
          private int allTabsWidth;
  
          private int additionalTabWidth;
  
          private boolean animatingIndicator;
          private float animatingIndicatorProgress;
          private int manualScrollingToPosition = -1;
          private int manualScrollingToId = -1;
  
          private int scrollingToChild = -1;
          private GradientDrawable selectorDrawable;
  
          private String tabLineColorKey = Theme.key_profile_tabSelectedLine;
          private String activeTextColorKey = Theme.key_profile_tabSelectedText;
          private String unactiveTextColorKey = Theme.key_profile_tabText;
          private String selectorColorKey = Theme.key_profile_tabSelector;
          private String backgroundColorKey = Theme.key_actionBarDefault;
  
          private int prevLayoutWidth;
  
          private boolean invalidated;
  
          private boolean isInHiddenMode;
          private float hideProgress;
  
          private CubicBezierInterpolator interpolator = CubicBezierInterpolator.EASE_OUT_QUINT;
  
          private SparseIntArray positionToId = new SparseIntArray(5);
          private SparseIntArray idToPosition = new SparseIntArray(5);
          private SparseIntArray positionToWidth = new SparseIntArray(5);
          private SparseIntArray positionToX = new SparseIntArray(5);
  
          private boolean animationRunning;
          private long lastAnimationTime;
          private float animationTime;
          private int previousPosition;
          private int previousId;
          private Runnable animationRunnable = new Runnable() {
              @Override
              public void run() {
                  if (!animatingIndicator) {
                      return;
                  }
                  long newTime = SystemClock.elapsedRealtime();
                  long dt = (newTime - lastAnimationTime);
                  if (dt > 17) {
                      dt = 17;
                  }
                  animationTime += dt / 200.0f;
                  setAnimationIdicatorProgress(interpolator.getInterpolation(animationTime));
                  if (animationTime > 1.0f) {
                      animationTime = 1.0f;
                  }
                  if (animationTime < 1.0f) {
                      AndroidUtilities.runOnUIThread(animationRunnable);
                  } else {
                      animatingIndicator = false;
                      setEnabled(true);
                      if (delegate != null) {
                          delegate.onPageScrolled(1.0f);
                      }
                  }
              }
          };
          ValueAnimator tabsAnimator;
          private float animationValue;
  
          public TabsView(Context context) {
              super(context);
              textCounterPaint.setTextSize(AndroidUtilities.dp(13));
              textCounterPaint.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
              textPaint.setTextSize(AndroidUtilities.dp(15));
              textPaint.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
              deletePaint.setStyle(Paint.Style.STROKE);
              deletePaint.setStrokeCap(Paint.Cap.ROUND);
              deletePaint.setStrokeWidth(AndroidUtilities.dp(1.5f));
  
              selectorDrawable = new GradientDrawable(GradientDrawable.Orientation.LEFT_RIGHT, null);
              float rad = AndroidUtilities.dpf2(3);
              selectorDrawable.setCornerRadii(new float[]{rad, rad, rad, rad, 0, 0, 0, 0});
              selectorDrawable.setColor(Theme.getColor(tabLineColorKey));
  
              setHorizontalScrollBarEnabled(false);
              listView = new RecyclerListView(context) {
  
                  @Override
                  public void addView(View child, int index, ViewGroup.LayoutParams params) {
                      super.addView(child, index, params);
                      if (isInHiddenMode) {
                          child.setScaleX(0.3f);
                          child.setScaleY(0.3f);
                          child.setAlpha(0);
                      } else {
                          child.setScaleX(1f);
                          child.setScaleY(1f);
                          child.setAlpha(1f);
                      }
                  }
  
                  @Override
                  public void setAlpha(float alpha) {
                      super.setAlpha(alpha);
                      TabsView.this.invalidate();
                  }
  
                  @Override
                  protected boolean canHighlightChildAt(View child, float x, float y) {
                      if (isEditing) {
                          TabView tabView = (TabView) child;
                          int side = AndroidUtilities.dp(6);
                          if (tabView.rect.left - side < x && tabView.rect.right + side > x) {
                              return false;
                          }
                      }
                      return super.canHighlightChildAt(child, x, y);
                  }
              };
              ((DefaultItemAnimator) listView.getItemAnimator()).setDelayAnimations(false);
              listView.setSelectorType(7);
              listView.setSelectorDrawableColor(Theme.getColor(selectorColorKey));
              listView.setLayoutManager(layoutManager = new LinearLayoutManager(context, LinearLayoutManager.HORIZONTAL, false) {
                  @Override
                  public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state, int position) {
                      LinearSmoothScroller linearSmoothScroller = new LinearSmoothScroller(recyclerView.getContext()) {
                          @Override
                          protected void onTargetFound(View targetView, RecyclerView.State state, Action action) {
                              int dx = calculateDxToMakeVisible(targetView, getHorizontalSnapPreference());
                              if (dx > 0 || dx == 0 && targetView.getLeft() - AndroidUtilities.dp(21) < 0) {
                                  dx += AndroidUtilities.dp(60);
                              } else if (dx < 0 || dx == 0 && targetView.getRight() + AndroidUtilities.dp(21) > getMeasuredWidth()) {
                                  dx -= AndroidUtilities.dp(60);
                              }
  
                              final int dy = calculateDyToMakeVisible(targetView, getVerticalSnapPreference());
                              final int distance = (int) Math.sqrt(dx * dx + dy * dy);
                              final int time = Math.max(180, calculateTimeForDeceleration(distance));
                              if (time > 0) {
                                  action.update(-dx, -dy, time, mDecelerateInterpolator);
                              }
                          }
                      };
                      linearSmoothScroller.setTargetPosition(position);
                      startSmoothScroll(linearSmoothScroller);
                  }
  
                  @Override
                  public void onInitializeAccessibilityNodeInfo(@NonNull RecyclerView.Recycler recycler, @NonNull RecyclerView.State state, @NonNull AccessibilityNodeInfoCompat info) {
                      super.onInitializeAccessibilityNodeInfo(recycler, state, info);
                      if (isInHiddenMode) {
                          info.setVisibleToUser(false);
                      }
                  }
              });
              listView.setPadding(AndroidUtilities.dp(7), 0, AndroidUtilities.dp(7), 0);
              listView.setClipToPadding(false);
              listView.setDrawSelectorBehind(true);
              listView.setAdapter(adapter = new ListAdapter(context));
              listView.setOnItemClickListener((view, position, x, y) -> {
                  if (!delegate.canPerformActions()) {
                      return;
                  }
                  TabView tabView = (TabView) view;
                  if (position == currentPosition && delegate != null) {
                      delegate.onSamePageSelected();
                      return;
                  }
                  scrollToTab(tabView.currentTab.id, position);
              });
              listView.setOnScrollListener(new RecyclerView.OnScrollListener() {
                  @Override
                  public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
                      invalidate();
                  }
              });
              addView(listView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
          }
  
          public void setDelegate(TabsViewDelegate filterTabsViewDelegate) {
              delegate = filterTabsViewDelegate;
          }
  
          public boolean isAnimatingIndicator() {
              return animatingIndicator;
          }
  
          public void scrollToTab(int id, int position) {
              boolean scrollingForward = currentPosition < position;
              scrollingToChild = -1;
              previousPosition = currentPosition;
              previousId = selectedTabId;
              currentPosition = position;
              selectedTabId = id;
  
              if (tabsAnimator != null) {
                  tabsAnimator.cancel();
              }
              if (animatingIndicator) {
                  animatingIndicator = false;
              }
  
              animationTime = 0;
              animatingIndicatorProgress = 0;
              animatingIndicator = true;
              setEnabled(false);
  
  
              if (delegate != null) {
                  delegate.onPageSelected(id, scrollingForward);
              }
              scrollToChild(position);
              tabsAnimator = ValueAnimator.ofFloat(0,1f);
              tabsAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                  @Override
                  public void onAnimationUpdate(ValueAnimator valueAnimator) {
                      float progress = (float) valueAnimator.getAnimatedValue();
                      setAnimationIdicatorProgress(progress);
                      if (delegate != null) {
                          delegate.onPageScrolled(progress);
                      }
                  }
              });
              tabsAnimator.setDuration(250);
              tabsAnimator.setInterpolator(CubicBezierInterpolator.DEFAULT);
              tabsAnimator.addListener(new AnimatorListenerAdapter() {
                  @Override
                  public void onAnimationEnd(Animator animation) {
                      animatingIndicator = false;
                      setEnabled(true);
                      if (delegate != null) {
                          delegate.onPageScrolled(1.0f);
                      }
                      invalidate();
                  }
              });
              tabsAnimator.start();
          }
  
          public void setAnimationIdicatorProgress(float value) {
              animatingIndicatorProgress = value;
              listView.invalidateViews();
              invalidate();
              if (delegate != null) {
                  delegate.onPageScrolled(value);
              }
          }
  
          public Drawable getSelectorDrawable() {
              return selectorDrawable;
          }
  
          public RecyclerListView getTabsContainer() {
              return listView;
          }
  
          public int getNextPageId(boolean forward) {
              return positionToId.get(currentPosition + (forward ? 1 : -1), -1);
          }
  
          public void addTab(int id, String text) {
              int position = tabs.size();
              if (position == 0 && selectedTabId == -1) {
                  selectedTabId = id;
              }
              positionToId.put(position, id);
              idToPosition.put(id, position);
              if (selectedTabId != -1 && selectedTabId == id) {
                  currentPosition = position;
              }
              Tab tab = new Tab(id, text);
              allTabsWidth += tab.getWidth(true, textPaint) + AndroidUtilities.dp(32);
              tabs.add(tab);
          }
  
          public void removeTabs() {
              tabs.clear();
              positionToId.clear();
              idToPosition.clear();
              positionToWidth.clear();
              positionToX.clear();
              allTabsWidth = 0;
          }
  
          public void finishAddingTabs() {
              adapter.notifyDataSetChanged();
          }
  
          public int getCurrentTabId() {
              return selectedTabId;
          }
  
          public int getFirstTabId() {
              return positionToId.get(0, 0);
          }
  
          private void updateTabsWidths() {
              positionToX.clear();
              positionToWidth.clear();
              int xOffset = AndroidUtilities.dp(7);
              for (int a = 0, N = tabs.size(); a < N; a++) {
                  int tabWidth = tabs.get(a).getWidth(false, textPaint);
                  positionToWidth.put(a, tabWidth);
                  positionToX.put(a, xOffset + additionalTabWidth / 2);
                  xOffset += tabWidth + AndroidUtilities.dp(32) + additionalTabWidth;
              }
          }
  
          @Override
          protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
              boolean result = super.drawChild(canvas, child, drawingTime);
              if (child == listView) {
                  final int height = getMeasuredHeight();
                  boolean invalidate = false;
                  if (isInHiddenMode && hideProgress != 1f) {
                      hideProgress += 0.1f;
                      if (hideProgress > 1f) {
                          hideProgress = 1f;
                      }
                      invalidate();
                  } else if (!isInHiddenMode && hideProgress != 0) {
                      hideProgress -= 0.12f;
                      if (hideProgress < 0) {
                          hideProgress = 0;
                      }
                      invalidate();
                  }
                  selectorDrawable.setAlpha((int) (255 * listView.getAlpha()));
                  int indicatorX = 0;
                  int indicatorWidth = 0;
                  if (animatingIndicator || manualScrollingToPosition != -1) {
                      int position = layoutManager.findFirstVisibleItemPosition();
                      if (position != RecyclerListView.NO_POSITION) {
                          RecyclerListView.ViewHolder holder = listView.findViewHolderForAdapterPosition(position);
                          if (holder != null) {
                              int idx1;
                              int idx2;
                              if (animatingIndicator) {
                                  idx1 = previousPosition;
                                  idx2 = currentPosition;
                              } else {
                                  idx1 = currentPosition;
                                  idx2 = manualScrollingToPosition;
                              }
                              int prevX = positionToX.get(idx1);
                              int newX = positionToX.get(idx2);
                              int prevW = positionToWidth.get(idx1);
                              int newW = positionToWidth.get(idx2);
                              if (additionalTabWidth != 0) {
                                  indicatorX = (int) (prevX + (newX - prevX) * animatingIndicatorProgress) + AndroidUtilities.dp(16);
                              } else {
                                  int x = positionToX.get(position);
                                  indicatorX = (int) (prevX + (newX - prevX) * animatingIndicatorProgress) - (x - holder.itemView.getLeft()) + AndroidUtilities.dp(16);
                              }
                              indicatorWidth = (int) (prevW + (newW - prevW) * animatingIndicatorProgress);
                          }
                      }
                  } else {
                      RecyclerListView.ViewHolder holder = listView.findViewHolderForAdapterPosition(currentPosition);
                      if (holder != null) {
                          TabView tabView = (TabView) holder.itemView;
                          indicatorWidth = Math.max(AndroidUtilities.dp(40), tabView.tabWidth);
                          indicatorX = (int) (tabView.getX() + (tabView.getMeasuredWidth() - indicatorWidth) / 2);
                      }
                  }
                  if (indicatorWidth != 0) {
                      selectorDrawable.setBounds(indicatorX, (int) (height - AndroidUtilities.dpr(4) + hideProgress * AndroidUtilities.dpr(4)), indicatorX + indicatorWidth, (int) (height + hideProgress * AndroidUtilities.dpr(4)));
                      selectorDrawable.draw(canvas);
                  }
                  if (crossfadeBitmap != null) {
                      crossfadePaint.setAlpha((int) (crossfadeAlpha * 255));
                      canvas.drawBitmap(crossfadeBitmap, 0, 0, crossfadePaint);
                  }
              }
  
              return result;
          }
  
          @Override
          protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
              if (!tabs.isEmpty()) {
                  int width = MeasureSpec.getSize(widthMeasureSpec) - AndroidUtilities.dp(7) - AndroidUtilities.dp(7);
                  int prevWidth = additionalTabWidth;
                  additionalTabWidth = allTabsWidth < width ? (width - allTabsWidth) / tabs.size() : 0;
                  if (prevWidth != additionalTabWidth) {
                      ignoreLayout = true;
                      adapter.notifyDataSetChanged();
                      ignoreLayout = false;
                  }
                  updateTabsWidths();
                  invalidated = false;
              }
              super.onMeasure(widthMeasureSpec, heightMeasureSpec);
          }
  
          public void updateColors() {
              selectorDrawable.setColor(Theme.getColor(tabLineColorKey));
              listView.invalidateViews();
              listView.invalidate();
              invalidate();
          }
  
          @Override
          public void requestLayout() {
              if (ignoreLayout) {
                  return;
              }
              super.requestLayout();
          }
  
          private void scrollToChild(int position) {
              if (tabs.isEmpty() || scrollingToChild == position || position < 0 || position >= tabs.size()) {
                  return;
              }
              scrollingToChild = position;
              listView.smoothScrollToPosition(position);
          }
  
          @Override
          protected void onLayout(boolean changed, int l, int t, int r, int b) {
              super.onLayout(changed, l, t, r, b);
  
              if (prevLayoutWidth != r - l) {
                  prevLayoutWidth = r - l;
                  scrollingToChild = -1;
                  if (animatingIndicator) {
                      AndroidUtilities.cancelRunOnUIThread(animationRunnable);
                      animatingIndicator = false;
                      setEnabled(true);
                      if (delegate != null) {
                          delegate.onPageScrolled(1.0f);
                      }
                  }
              }
          }
          public void selectTab(int currentPosition, int nextPosition, float progress) {
              if (progress < 0) {
                  progress = 0;
              } else if (progress > 1.0f) {
                  progress = 1.0f;
              }
  
              this.currentPosition = currentPosition;
              selectedTabId = positionToId.get(currentPosition);
  
              if (progress > 0) {
                  manualScrollingToPosition = nextPosition;
                  manualScrollingToId = positionToId.get(nextPosition);
              } else {
                  manualScrollingToPosition = -1;
                  manualScrollingToId = -1;
              }
              animatingIndicatorProgress = progress;
              listView.invalidateViews();
              invalidate();
              scrollToChild(currentPosition);
  
              if (progress >= 1.0f) {
                  manualScrollingToPosition = -1;
                  manualScrollingToId = -1;
                  this.currentPosition = nextPosition;
                  selectedTabId = positionToId.get(nextPosition);
              }
          }
  
          public void selectTabWithId(int id, float progress) {
              int position = idToPosition.get(id, -1);
              if (position < 0) {
                  return;
              }
              if (progress < 0) {
                  progress = 0;
              } else if (progress > 1.0f) {
                  progress = 1.0f;
              }
  
              if (progress > 0) {
                  manualScrollingToPosition = position;
                  manualScrollingToId = id;
              } else {
                  manualScrollingToPosition = -1;
                  manualScrollingToId = -1;
              }
              animatingIndicatorProgress = progress;
              listView.invalidateViews();
              invalidate();
              scrollToChild(position);
  
              if (progress >= 1.0f) {
                  manualScrollingToPosition = -1;
                  manualScrollingToId = -1;
                  currentPosition = position;
                  selectedTabId = id;
              }
          }
  
          private int getChildWidth(TextView child) {
              Layout layout = child.getLayout();
              if (layout != null) {
                  int w = (int) Math.ceil(layout.getLineWidth(0)) + AndroidUtilities.dp(2);
                  if (child.getCompoundDrawables()[2] != null) {
                      w += child.getCompoundDrawables()[2].getIntrinsicWidth() + AndroidUtilities.dp(6);
                  }
                  return w;
              } else {
                  return child.getMeasuredWidth();
              }
          }
  
          public void onPageScrolled(int position, int first) {
              if (currentPosition == position) {
                  return;
              }
              currentPosition = position;
              if (position >= tabs.size()) {
                  return;
              }
              if (first == position && position > 1) {
                  scrollToChild(position - 1);
              } else {
                  scrollToChild(position);
              }
              invalidate();
          }
  
          public boolean isEditing() {
              return isEditing;
          }
  
          public void setIsEditing(boolean value) {
              isEditing = value;
              editingForwardAnimation = true;
              listView.invalidateViews();
              invalidate();
              if (!isEditing && orderChanged) {
                  MessagesStorage.getInstance(UserConfig.selectedAccount).saveDialogFiltersOrder();
                  TLRPC.TL_messages_updateDialogFiltersOrder req = new TLRPC.TL_messages_updateDialogFiltersOrder();
                  ArrayList<MessagesController.DialogFilter> filters = MessagesController.getInstance(UserConfig.selectedAccount).dialogFilters;
                  for (int a = 0, N = filters.size(); a < N; a++) {
                      MessagesController.DialogFilter filter = filters.get(a);
                      req.order.add(filters.get(a).id);
                  }
                  ConnectionsManager.getInstance(UserConfig.selectedAccount).sendRequest(req, (response, error) -> {
  
                  });
                  orderChanged = false;
              }
          }
  
          private class ListAdapter extends RecyclerListView.SelectionAdapter {
  
              private Context mContext;
  
              public ListAdapter(Context context) {
                  mContext = context;
              }
  
              @Override
              public int getItemCount() {
                  return tabs.size();
              }
  
              @Override
              public long getItemId(int i) {
                  return i;
              }
  
              @Override
              public boolean isEnabled(RecyclerView.ViewHolder holder) {
                  return true;
              }
  
              @Override
              public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
                  return new RecyclerListView.Holder(new TabView(mContext));
              }
  
              @Override
              public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
                  TabView tabView = (TabView) holder.itemView;
                  tabView.setTab(tabs.get(position), position);
              }
  
              @Override
              public int getItemViewType(int i) {
                  return 0;
              }
  
          }
  
          public void hide(boolean hide, boolean animated) {
              isInHiddenMode = hide;
  
              if (animated) {
                  for (int i = 0; i < listView.getChildCount(); i++) {
                      listView.getChildAt(i).animate().alpha(hide ? 0 : 1f).scaleX(hide ? 0 : 1f).scaleY(hide ? 0 : 1f).setInterpolator(CubicBezierInterpolator.DEFAULT).setDuration(220).start();
                  }
              } else {
                  for (int i = 0; i < listView.getChildCount(); i++) {
                      View v = listView.getChildAt(i);
                      v.setScaleX(hide ? 0 : 1f);
                      v.setScaleY(hide ? 0 : 1f);
                      v.setAlpha(hide ? 0 : 1f);
                  }
                  hideProgress = hide ? 1 : 0;
              }
              invalidate();
          }
      }
  
      private View findScrollingChild(ViewGroup parent, float x, float y) {
          int n = parent.getChildCount();
          for (int i = 0; i < n; i++) {
              View child = parent.getChildAt(i);
              if (child.getVisibility() != View.VISIBLE) {
                  continue;
              }
              child.getHitRect(rect);
              if (rect.contains((int) x, (int) y)) {
  