common/src/com/android/tv/common/ui/setup/animation/FadeAndShortSlide.java - platform/packages/apps/TV - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.android.tv.common.ui.setup.animation;

 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.AnimatorSet;
 import android.animation.TimeInterpolator;
 import android.transition.Fade;
 import android.transition.Transition;
 import android.transition.TransitionValues;
 import android.transition.Visibility;
 import android.view.Gravity;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewParent;
 import android.view.animation.AccelerateInterpolator;
 import android.view.animation.DecelerateInterpolator;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;

 /**
  * Execute horizontal slide of 1/4 width and fade (to workaround bug 23718734)
  */
 public class FadeAndShortSlide extends Visibility {
     private static final TimeInterpolator APPEAR_INTERPOLATOR = new DecelerateInterpolator();
     private static final TimeInterpolator DISAPPEAR_INTERPOLATOR = new AccelerateInterpolator();

     private static final String PROPNAME_SCREEN_POSITION =
             "android_fadeAndShortSlideTransition_screenPosition";
     private static final String PROPNAME_DELAY = "propname_delay";

     private static final int DEFAULT_DISTANCE = 200;

     private static abstract class CalculateSlide {
         /** Returns the translation value for view when it goes out of the scene */
         public abstract float getGoneX(ViewGroup sceneRoot, View view, int[] position,
                 int distance);
     }

     private static final CalculateSlide sCalculateStart = new CalculateSlide() {
         @Override
         public float getGoneX(ViewGroup sceneRoot, View view, int[] position, int distance) {
             final boolean isRtl = sceneRoot.getLayoutDirection() == View.LAYOUT_DIRECTION_RTL;
             final float x;
             if (isRtl) {
                 x = view.getTranslationX() + distance;
             } else {
                 x = view.getTranslationX() - distance;
             }
             return x;
         }
     };

     private static final CalculateSlide sCalculateEnd = new CalculateSlide() {
         @Override
         public float getGoneX(ViewGroup sceneRoot, View view, int[] position, int distance) {
             final boolean isRtl = sceneRoot.getLayoutDirection() == View.LAYOUT_DIRECTION_RTL;
             final float x;
             if (isRtl) {
                 x = view.getTranslationX() - distance;
             } else {
                 x = view.getTranslationX() + distance;
             }
             return x;
         }
     };

     private static final ViewPositionComparator sViewPositionComparator =
             new ViewPositionComparator();

     private int mSlideEdge;
     private CalculateSlide mSlideCalculator = sCalculateEnd;
     private Visibility mFade = new Fade();

     // TODO: Consider using TransitionPropagation.
     private int[] mParentIdsForDelay;
     private int mDistance = DEFAULT_DISTANCE;

     public FadeAndShortSlide() {
         this(Gravity.START);
     }

     public FadeAndShortSlide(int slideEdge) {
         this(slideEdge, null);
     }

     public FadeAndShortSlide(int slideEdge, int[] parentIdsForDelay) {
         setSlideEdge(slideEdge);
         mParentIdsForDelay = parentIdsForDelay;
     }

     @Override
     public void setEpicenterCallback(EpicenterCallback epicenterCallback) {
         super.setEpicenterCallback(epicenterCallback);
         mFade.setEpicenterCallback(epicenterCallback);
     }

     private void captureValues(TransitionValues transitionValues) {
         View view = transitionValues.view;
         int[] position = new int[2];
         view.getLocationOnScreen(position);
         transitionValues.values.put(PROPNAME_SCREEN_POSITION, position);
     }

     private int getDelayOrder(View view, boolean appear) {
         if (mParentIdsForDelay == null) {
             return -1;
         }
         final View parentForDelay = findParentForDelay(view);
         if (parentForDelay == null || !(parentForDelay instanceof ViewGroup)) {
             return -1;
         }
         List<View> transitionTargets = new ArrayList<>();
         getTransitionTargets((ViewGroup) parentForDelay, transitionTargets);
         sViewPositionComparator.mParentForDelay = parentForDelay;
         sViewPositionComparator.mIsLtr = view.getLayoutDirection() == View.LAYOUT_DIRECTION_LTR;
         sViewPositionComparator.mToLeft = sViewPositionComparator.mIsLtr
                 ? mSlideEdge == (appear ? Gravity.END : Gravity.START)
                 : mSlideEdge == (appear ? Gravity.START : Gravity.END);
         Collections.sort(transitionTargets, sViewPositionComparator);
         return transitionTargets.indexOf(view);
     }

     private View findParentForDelay(View view) {
         if (isParentForDelay(view.getId())) {
             return view;
         }
         View parent = view;
         while (parent.getParent() instanceof View) {
             parent = (View) parent.getParent();
             if (isParentForDelay(parent.getId())) {
                 return parent;
             }
         }
         return null;
     }

     private boolean isParentForDelay(int viewId) {
         for (int id : mParentIdsForDelay) {
             if (id == viewId) {
                 return true;
             }
         }
         return false;
     }

     private void getTransitionTargets(ViewGroup parent, List<View> transitionTargets) {
         int count = parent.getChildCount();
         for (int i = 0; i < count; ++i) {
             View child = parent.getChildAt(i);
             if (child instanceof ViewGroup && !((ViewGroup) child).isTransitionGroup()) {
                 getTransitionTargets((ViewGroup) child, transitionTargets);
             } else {
                 transitionTargets.add(child);
             }
         }
     }

     @Override
     public void captureStartValues(TransitionValues transitionValues) {
         super.captureStartValues(transitionValues);
         mFade.captureStartValues(transitionValues);
         captureValues(transitionValues);
         int delayIndex = getDelayOrder(transitionValues.view, false);
         if (delayIndex > 0) {
             transitionValues.values.put(PROPNAME_DELAY,
                     delayIndex * SetupAnimationHelper.DELAY_BETWEEN_SIBLINGS_MS);
         }
     }

     @Override
     public void captureEndValues(TransitionValues transitionValues) {
         super.captureEndValues(transitionValues);
         mFade.captureEndValues(transitionValues);
         captureValues(transitionValues);
         int delayIndex = getDelayOrder(transitionValues.view, true);
         if (delayIndex > 0) {
             transitionValues.values.put(PROPNAME_DELAY,
                     delayIndex * SetupAnimationHelper.DELAY_BETWEEN_SIBLINGS_MS);
         }
     }

     public void setSlideEdge(int slideEdge) {
         mSlideEdge = slideEdge;
         switch (slideEdge) {
             case Gravity.START:
                 mSlideCalculator = sCalculateStart;
                 break;
             case Gravity.END:
                 mSlideCalculator = sCalculateEnd;
                 break;
             default:
                 throw new IllegalArgumentException("Invalid slide direction");
         }
     }

     @Override
     public Animator onAppear(ViewGroup sceneRoot, View view, TransitionValues startValues,
             TransitionValues endValues) {
         if (endValues == null) {
             return null;
         }
         int[] position = (int[]) endValues.values.get(PROPNAME_SCREEN_POSITION);
         int left = position[0];
         float endX = view.getTranslationX();
         float startX = mSlideCalculator.getGoneX(sceneRoot, view, position, mDistance);
         final Animator slideAnimator = TranslationAnimationCreator.createAnimation(view, endValues,
                 left, startX, endX, APPEAR_INTERPOLATOR, this);
         if (slideAnimator == null) {
             return null;
         }
         mFade.setInterpolator(APPEAR_INTERPOLATOR);
         final AnimatorSet set = new AnimatorSet();
         set.play(slideAnimator).with(mFade.onAppear(sceneRoot, view, startValues, endValues));
         Long delay = (Long ) endValues.values.get(PROPNAME_DELAY);
         if (delay != null) {
             set.setStartDelay(delay);
         }
         return set;
     }

     @Override
     public Animator onDisappear(ViewGroup sceneRoot, final View view, TransitionValues startValues,
             TransitionValues endValues) {
         if (startValues == null) {
             return null;
         }
         int[] position = (int[]) startValues.values.get(PROPNAME_SCREEN_POSITION);
         int left = position[0];
         float startX = view.getTranslationX();
         float endX = mSlideCalculator.getGoneX(sceneRoot, view, position, mDistance);
         final Animator slideAnimator = TranslationAnimationCreator.createAnimation(view,
                 startValues, left, startX, endX, DISAPPEAR_INTERPOLATOR, this);
         if (slideAnimator == null) { // slideAnimator is null if startX == endX
             return null;
         }

         mFade.setInterpolator(DISAPPEAR_INTERPOLATOR);
         final Animator fadeAnimator = mFade.onDisappear(sceneRoot, view, startValues, endValues);
         if (fadeAnimator == null) {
             return null;
         }
         fadeAnimator.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animator) {
                 fadeAnimator.removeListener(this);
                 view.setAlpha(0.0f);
             }
         });

         final AnimatorSet set = new AnimatorSet();
         set.play(slideAnimator).with(fadeAnimator);
         Long delay = (Long) startValues.values.get(PROPNAME_DELAY);
         if (delay != null) {
             set.setStartDelay(delay);
         }
         return set;
     }

     @Override
     public Transition addListener(TransitionListener listener) {
         mFade.addListener(listener);
         return super.addListener(listener);
     }

     @Override
     public Transition removeListener(TransitionListener listener) {
         mFade.removeListener(listener);
         return super.removeListener(listener);
     }

     @Override
     public Transition clone() {
         FadeAndShortSlide clone = (FadeAndShortSlide) super.clone();
         clone.mFade = (Visibility) mFade.clone();
         return clone;
     }

     @Override
     public Transition setDuration(long duration) {
         long scaledDuration = SetupAnimationHelper.applyAnimationTimeScale(duration);
         mFade.setDuration(scaledDuration);
         return super.setDuration(scaledDuration);
     }

     /**
      * Sets the moving distance in pixel.
      */
     public void setDistance(int distance) {
         mDistance = distance;
     }

     private static class ViewPositionComparator implements Comparator<View> {
         View mParentForDelay;
         boolean mIsLtr;
         boolean mToLeft;

         @Override
         public int compare(View lhs, View rhs) {
             int start1;
             int start2;
             if (mIsLtr) {
                 start1 = getRelativeLeft(lhs, mParentForDelay);
                 start2 = getRelativeLeft(rhs, mParentForDelay);
             } else {
                 start1 = getRelativeRight(lhs, mParentForDelay);
                 start2 = getRelativeRight(rhs, mParentForDelay);
             }
             if (mToLeft) {
                 if (start1 > start2) {
                     return 1;
                 } else if (start1 < start2) {
                     return -1;
                 }
             } else {
                 if (start1 > start2) {
                     return -1;
                 } else if (start1 < start2) {
                     return 1;
                 }
             }
             int top1 = getRelativeTop(lhs, mParentForDelay);
             int top2 = getRelativeTop(rhs, mParentForDelay);
             return Integer.compare(top1, top2);
         }

         private int getRelativeLeft(View child, View ancestor) {
             ViewParent parent = child.getParent();
             int left = child.getLeft();
             while (parent instanceof View) {
                 if (parent == ancestor) {
                     break;
                 }
                 left += ((View) parent).getLeft();
                 parent = parent.getParent();
             }
             return left;
         }

         private int getRelativeRight(View child, View ancestor) {
             ViewParent parent = child.getParent();
             int right = child.getRight();
             while (parent instanceof View) {
                 if (parent == ancestor) {
                     break;
                 }
                 right += ((View) parent).getLeft();
                 parent = parent.getParent();
             }
             return right;
         }

         private int getRelativeTop(View child, View ancestor) {
             ViewParent parent = child.getParent();
             int top = child.getTop();
             while (parent instanceof View) {
                 if (parent == ancestor) {
                     break;
                 }
                 top += ((View) parent).getTop();
                 parent = parent.getParent();
             }
             return top;
         }
     }
 }
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.android.tv.common.ui.setup.animation;

	import android.animation.Animator;
	import android.animation.AnimatorListenerAdapter;
	import android.animation.AnimatorSet;
	import android.animation.TimeInterpolator;
	import android.transition.Fade;
	import android.transition.Transition;
	import android.transition.TransitionValues;
	import android.transition.Visibility;
	import android.view.Gravity;
	import android.view.View;
	import android.view.ViewGroup;
	import android.view.ViewParent;
	import android.view.animation.AccelerateInterpolator;
	import android.view.animation.DecelerateInterpolator;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.List;

	/**
	* Execute horizontal slide of 1/4 width and fade (to workaround bug 23718734)
	*/
	public class FadeAndShortSlide extends Visibility {
	private static final TimeInterpolator APPEAR_INTERPOLATOR = new DecelerateInterpolator();
	private static final TimeInterpolator DISAPPEAR_INTERPOLATOR = new AccelerateInterpolator();

	private static final String PROPNAME_SCREEN_POSITION =
	"android_fadeAndShortSlideTransition_screenPosition";
	private static final String PROPNAME_DELAY = "propname_delay";

	private static final int DEFAULT_DISTANCE = 200;

	private static abstract class CalculateSlide {
	/** Returns the translation value for view when it goes out of the scene */
	public abstract float getGoneX(ViewGroup sceneRoot, View view, int[] position,
	int distance);
	}

	private static final CalculateSlide sCalculateStart = new CalculateSlide() {
	@Override
	public float getGoneX(ViewGroup sceneRoot, View view, int[] position, int distance) {
	final boolean isRtl = sceneRoot.getLayoutDirection() == View.LAYOUT_DIRECTION_RTL;
	final float x;
	if (isRtl) {
	x = view.getTranslationX() + distance;
	} else {
	x = view.getTranslationX() - distance;
	}
	return x;
	}
	};

	private static final CalculateSlide sCalculateEnd = new CalculateSlide() {
	@Override
	public float getGoneX(ViewGroup sceneRoot, View view, int[] position, int distance) {
	final boolean isRtl = sceneRoot.getLayoutDirection() == View.LAYOUT_DIRECTION_RTL;
	final float x;
	if (isRtl) {
	x = view.getTranslationX() - distance;
	} else {
	x = view.getTranslationX() + distance;
	}
	return x;
	}
	};

	private static final ViewPositionComparator sViewPositionComparator =
	new ViewPositionComparator();

	private int mSlideEdge;
	private CalculateSlide mSlideCalculator = sCalculateEnd;
	private Visibility mFade = new Fade();

	// TODO: Consider using TransitionPropagation.
	private int[] mParentIdsForDelay;
	private int mDistance = DEFAULT_DISTANCE;

	public FadeAndShortSlide() {
	this(Gravity.START);
	}

	public FadeAndShortSlide(int slideEdge) {
	this(slideEdge, null);
	}

	public FadeAndShortSlide(int slideEdge, int[] parentIdsForDelay) {
	setSlideEdge(slideEdge);
	mParentIdsForDelay = parentIdsForDelay;
	}

	@Override
	public void setEpicenterCallback(EpicenterCallback epicenterCallback) {
	super.setEpicenterCallback(epicenterCallback);
	mFade.setEpicenterCallback(epicenterCallback);
	}

	private void captureValues(TransitionValues transitionValues) {
	View view = transitionValues.view;
	int[] position = new int[2];
	view.getLocationOnScreen(position);
	transitionValues.values.put(PROPNAME_SCREEN_POSITION, position);
	}

	private int getDelayOrder(View view, boolean appear) {
	if (mParentIdsForDelay == null) {
	return -1;
	}
	final View parentForDelay = findParentForDelay(view);
	if (parentForDelay == null \|\| !(parentForDelay instanceof ViewGroup)) {
	return -1;
	}
	List<View> transitionTargets = new ArrayList<>();
	getTransitionTargets((ViewGroup) parentForDelay, transitionTargets);
	sViewPositionComparator.mParentForDelay = parentForDelay;
	sViewPositionComparator.mIsLtr = view.getLayoutDirection() == View.LAYOUT_DIRECTION_LTR;
	sViewPositionComparator.mToLeft = sViewPositionComparator.mIsLtr
	? mSlideEdge == (appear ? Gravity.END : Gravity.START)
	: mSlideEdge == (appear ? Gravity.START : Gravity.END);
	Collections.sort(transitionTargets, sViewPositionComparator);
	return transitionTargets.indexOf(view);
	}

	private View findParentForDelay(View view) {
	if (isParentForDelay(view.getId())) {
	return view;
	}
	View parent = view;
	while (parent.getParent() instanceof View) {
	parent = (View) parent.getParent();
	if (isParentForDelay(parent.getId())) {
	return parent;
	}
	}
	return null;
	}

	private boolean isParentForDelay(int viewId) {
	for (int id : mParentIdsForDelay) {
	if (id == viewId) {
	return true;
	}
	}
	return false;
	}

	private void getTransitionTargets(ViewGroup parent, List<View> transitionTargets) {
	int count = parent.getChildCount();
	for (int i = 0; i < count; ++i) {
	View child = parent.getChildAt(i);
	if (child instanceof ViewGroup && !((ViewGroup) child).isTransitionGroup()) {
	getTransitionTargets((ViewGroup) child, transitionTargets);
	} else {
	transitionTargets.add(child);
	}
	}
	}

	@Override
	public void captureStartValues(TransitionValues transitionValues) {
	super.captureStartValues(transitionValues);
	mFade.captureStartValues(transitionValues);
	captureValues(transitionValues);
	int delayIndex = getDelayOrder(transitionValues.view, false);
	if (delayIndex > 0) {
	transitionValues.values.put(PROPNAME_DELAY,
	delayIndex * SetupAnimationHelper.DELAY_BETWEEN_SIBLINGS_MS);
	}
	}

	@Override
	public void captureEndValues(TransitionValues transitionValues) {
	super.captureEndValues(transitionValues);
	mFade.captureEndValues(transitionValues);
	captureValues(transitionValues);
	int delayIndex = getDelayOrder(transitionValues.view, true);
	if (delayIndex > 0) {
	transitionValues.values.put(PROPNAME_DELAY,
	delayIndex * SetupAnimationHelper.DELAY_BETWEEN_SIBLINGS_MS);
	}
	}

	public void setSlideEdge(int slideEdge) {
	mSlideEdge = slideEdge;
	switch (slideEdge) {
	case Gravity.START:
	mSlideCalculator = sCalculateStart;
	break;
	case Gravity.END:
	mSlideCalculator = sCalculateEnd;
	break;
	default:
	throw new IllegalArgumentException("Invalid slide direction");
	}
	}

	@Override
	public Animator onAppear(ViewGroup sceneRoot, View view, TransitionValues startValues,
	TransitionValues endValues) {
	if (endValues == null) {
	return null;
	}
	int[] position = (int[]) endValues.values.get(PROPNAME_SCREEN_POSITION);
	int left = position[0];
	float endX = view.getTranslationX();
	float startX = mSlideCalculator.getGoneX(sceneRoot, view, position, mDistance);
	final Animator slideAnimator = TranslationAnimationCreator.createAnimation(view, endValues,
	left, startX, endX, APPEAR_INTERPOLATOR, this);
	if (slideAnimator == null) {
	return null;
	}
	mFade.setInterpolator(APPEAR_INTERPOLATOR);
	final AnimatorSet set = new AnimatorSet();
	set.play(slideAnimator).with(mFade.onAppear(sceneRoot, view, startValues, endValues));
	Long delay = (Long ) endValues.values.get(PROPNAME_DELAY);
	if (delay != null) {
	set.setStartDelay(delay);
	}
	return set;
	}

	@Override
	public Animator onDisappear(ViewGroup sceneRoot, final View view, TransitionValues startValues,
	TransitionValues endValues) {
	if (startValues == null) {
	return null;
	}
	int[] position = (int[]) startValues.values.get(PROPNAME_SCREEN_POSITION);
	int left = position[0];
	float startX = view.getTranslationX();
	float endX = mSlideCalculator.getGoneX(sceneRoot, view, position, mDistance);
	final Animator slideAnimator = TranslationAnimationCreator.createAnimation(view,
	startValues, left, startX, endX, DISAPPEAR_INTERPOLATOR, this);
	if (slideAnimator == null) { // slideAnimator is null if startX == endX
	return null;
	}

	mFade.setInterpolator(DISAPPEAR_INTERPOLATOR);
	final Animator fadeAnimator = mFade.onDisappear(sceneRoot, view, startValues, endValues);
	if (fadeAnimator == null) {
	return null;
	}
	fadeAnimator.addListener(new AnimatorListenerAdapter() {
	@Override
	public void onAnimationEnd(Animator animator) {
	fadeAnimator.removeListener(this);
	view.setAlpha(0.0f);
	}
	});

	final AnimatorSet set = new AnimatorSet();
	set.play(slideAnimator).with(fadeAnimator);
	Long delay = (Long) startValues.values.get(PROPNAME_DELAY);
	if (delay != null) {
	set.setStartDelay(delay);
	}
	return set;
	}

	@Override
	public Transition addListener(TransitionListener listener) {
	mFade.addListener(listener);
	return super.addListener(listener);
	}

	@Override
	public Transition removeListener(TransitionListener listener) {
	mFade.removeListener(listener);
	return super.removeListener(listener);
	}

	@Override
	public Transition clone() {
	FadeAndShortSlide clone = (FadeAndShortSlide) super.clone();
	clone.mFade = (Visibility) mFade.clone();
	return clone;
	}

	@Override
	public Transition setDuration(long duration) {
	long scaledDuration = SetupAnimationHelper.applyAnimationTimeScale(duration);
	mFade.setDuration(scaledDuration);
	return super.setDuration(scaledDuration);
	}

	/**
	* Sets the moving distance in pixel.
	*/
	public void setDistance(int distance) {
	mDistance = distance;
	}

	private static class ViewPositionComparator implements Comparator<View> {
	View mParentForDelay;
	boolean mIsLtr;
	boolean mToLeft;

	@Override
	public int compare(View lhs, View rhs) {
	int start1;
	int start2;
	if (mIsLtr) {
	start1 = getRelativeLeft(lhs, mParentForDelay);
	start2 = getRelativeLeft(rhs, mParentForDelay);
	} else {
	start1 = getRelativeRight(lhs, mParentForDelay);
	start2 = getRelativeRight(rhs, mParentForDelay);
	}
	if (mToLeft) {
	if (start1 > start2) {
	return 1;
	} else if (start1 < start2) {
	return -1;
	}
	} else {
	if (start1 > start2) {
	return -1;
	} else if (start1 < start2) {
	return 1;
	}
	}
	int top1 = getRelativeTop(lhs, mParentForDelay);
	int top2 = getRelativeTop(rhs, mParentForDelay);
	return Integer.compare(top1, top2);
	}

	private int getRelativeLeft(View child, View ancestor) {
	ViewParent parent = child.getParent();
	int left = child.getLeft();
	while (parent instanceof View) {
	if (parent == ancestor) {
	break;
	}
	left += ((View) parent).getLeft();
	parent = parent.getParent();
	}
	return left;
	}

	private int getRelativeRight(View child, View ancestor) {
	ViewParent parent = child.getParent();
	int right = child.getRight();
	while (parent instanceof View) {
	if (parent == ancestor) {
	break;
	}
	right += ((View) parent).getLeft();
	parent = parent.getParent();
	}
	return right;
	}

	private int getRelativeTop(View child, View ancestor) {
	ViewParent parent = child.getParent();
	int top = child.getTop();
	while (parent instanceof View) {
	if (parent == ancestor) {
	break;
	}
	top += ((View) parent).getTop();
	parent = parent.getParent();
	}
	return top;
	}
	}
	}