出栈入栈动画demo

项目做了一个切换界面动画的功能,用到了出栈入栈的,写了一个demo

package com.myron.stackview;

import java.util.Stack;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.animation.Animation;
import android.view.animation.LinearInterpolator;
import android.view.animation.TranslateAnimation;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.LinearLayout;

public class StackViewActivity extends Activity {
    private Stack<View> mViewStack = new Stack<View>();
    private View mCurrentView;
    private LinearLayout parent2;
 // 动画
	 private TranslateAnimation mAnimLeftOut;
	 private TranslateAnimation mAnimRightIn;
	 private TranslateAnimation mAnimRightOut;
	 private TranslateAnimation mAnimLeftIn;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        initAnim();
        //第一个界面
        LinearLayout parent = new LinearLayout(this);
        parent.setOrientation(LinearLayout.VERTICAL);
        ImageView imageView = new ImageView(this);
        imageView.setBackgroundResource(R.drawable.icon);
        parent.addView(imageView, -2, -2);
        Button btnPush = new Button(this);
        btnPush.setId(1);
        btnPush.setText("push");
        parent.addView(btnPush, -2, -2);
        pushView2Stack(parent);
        btnPush.setOnClickListener(listener);

        //第二个界面
        parent2 = new LinearLayout(this);
        parent2.setOrientation(LinearLayout.VERTICAL);
        ImageView imageView2 = new ImageView(this);
        imageView2.setBackgroundResource(R.drawable.icon);
        parent2.addView(imageView2, -2, -2);
        Button btnPop = new Button(this);
        btnPop.setId(2);
        btnPop.setText("pop");
        parent2.addView(btnPop, -2, -2);
        btnPop.setOnClickListener(listener);
    }

    private OnClickListener listener = new OnClickListener() {

		@Override
		public void onClick(View v) {
			int id = v.getId();
			switch (id) {
			case 1:
				pushView2Stack(parent2);
				break;
			case 2:
				popViewFromStack();
				break;

			default:
				break;
			}
		}
	};

	/**
	 * 进栈
	 * @param newView
	 */
    public void pushView2Stack(View newView) {
		if (mViewStack.size() > 0) {
			View peek = mViewStack.peek();
			peek.clearFocus();
			peek.startAnimation(mAnimLeftOut);
		}
		mViewStack.push(newView);
		mCurrentView = newView;
		setContentView(newView);
		newView.requestFocus();
		if (mViewStack.size() > 1) {
			// 启动动画
			newView.startAnimation(mAnimRightIn);
		}
	}

    public View popViewFromStack() {
		if (mViewStack.size() > 1) {
			// 弹出旧ui
			View pop = mViewStack.pop();
			pop.clearFocus();
			// 动画
			pop.startAnimation(mAnimRightOut);

			// 新ui
			mCurrentView = mViewStack.peek();
			setContentView(mCurrentView);
			mCurrentView.requestFocus();
			mCurrentView.startAnimation(mAnimLeftIn);
			return mCurrentView;
		} else {
			finish();
			return null;
		}
	}

    private void initAnim() {
   	 // 左出
   	 mAnimLeftOut = new TranslateAnimation(Animation.RELATIVE_TO_SELF, 0,
   	 Animation.RELATIVE_TO_SELF, -1, Animation.RELATIVE_TO_SELF, 0,
   	 Animation.RELATIVE_TO_SELF, 0);
   	 mAnimLeftOut.setDuration(400);
   	 mAnimLeftOut.setFillAfter(true);
   	 mAnimLeftOut.setInterpolator(new LinearInterpolator());

   	 // 右进
   	 mAnimRightIn = new TranslateAnimation(Animation.RELATIVE_TO_SELF, 1,
   	 Animation.RELATIVE_TO_SELF, 0, Animation.RELATIVE_TO_SELF, 0,
   	 Animation.RELATIVE_TO_SELF, 0);
   	 mAnimRightIn.setDuration(400);
   	 mAnimRightIn.setFillAfter(true);
   	 mAnimRightIn.setInterpolator(new LinearInterpolator());

   	 // 右出
   	 mAnimRightOut = new TranslateAnimation(Animation.RELATIVE_TO_SELF, 0,
   	 Animation.RELATIVE_TO_SELF, 1, Animation.RELATIVE_TO_SELF, 0,
   	 Animation.RELATIVE_TO_SELF, 0);
   	 mAnimRightOut.setDuration(400);
   	 mAnimRightOut.setFillAfter(true);
   	 mAnimRightOut.setInterpolator(new LinearInterpolator());

   	 // 左进
   	 mAnimLeftIn = new TranslateAnimation(Animation.RELATIVE_TO_SELF, -1,
   	 Animation.RELATIVE_TO_SELF, 0, Animation.RELATIVE_TO_SELF, 0,
   	 Animation.RELATIVE_TO_SELF, 0);
   	 mAnimLeftIn.setDuration(400);
   	 mAnimLeftIn.setFillAfter(true);
   	 mAnimLeftIn.setInterpolator(new LinearInterpolator());
   	 }
}

  

时间: 2024-10-11 06:53:37

出栈入栈动画demo的相关文章

C++中栈的出栈,入栈规则:A,B,C,D,E

考题: 栈底至栈顶一次存放元素 ABCD 在第五个元素E入栈之前  栈中元素可以出栈,则出栈序列可能是_____a d___________. a.  ABCED b.  DBCEA   c.  CDABE   d.  DCBEA 分析: 1.假定进栈序列是从小到大排练的(即A<B<C<D<E),则出栈序列中不可能有  “大小中”这种序列,因为在“大数”出栈后,在栈中“中数”是在“小数”上面的,所以只能是先出“中数”再出“小数”2.出栈序列中如包含下列序列则是错误的:CAB,DAB

xtu 1035 与xtu 1036 两道出栈入栈题目,蛮有趣的

Description John是个小列车站的站长,每次列车在这里重新编组时他就很烦恼.因为站上只有一个人字形的编组轨道(如图),所有的列车车厢都是从人字轨的右边依次进去,从左边出来.但有一些编组顺序John总编不出来,John怀疑有些编组顺序是不可能完成的,可John又找不出那些是顺序是可以编组出,那些不可以.请你写一个程序帮助John辨别哪些编组可以完成,哪些不能完成. 输入: 第一行是一个整数K,表示有多少个测试用例,以后每行一个测试用例,每行为n+1个整数,第一个整数为n 表示有多少节车

职责链 评价:挺好玩的 稍微复杂版 类似出栈入栈 (原理职责链调用一个之后跳转到第二个执行在跳转第三个执行 接下来因为每次调用完后都会返回被调用的位置)

using System;using System.Collections.Generic;using System.Linq;using System.Text; namespace ConsoleApplication20{    public class Response    {        public string ResponseStr { get; set; }                     } public class Request    {        pub

C语言数据结构链栈(创建、入栈、出栈、取栈顶元素、遍历链栈中的元素)

/**创建链栈*创建一个top指针代表head指针*采用链式存储结构*采用头插法创建链表*操作 创建 出栈 入栈 取栈顶元素*创建数据域的结构体*创建数据域的名称指针*使用随机函数对数据域的编号进行赋值*/ #include<stdio.h>#include<stdlib.h>#include<string.h>#include<time.h>#define OK 1#define ERROR 0#define NAMESIZE 255//字符串的最大长度

栈的链式存储结构和入栈出栈操作

参考<大话数据结构>P98~99——栈的链式存储结构. 进栈: 出栈: 举个简单的例子: 代码和解释如下(VS2012测试通过): 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 typedef string status;//用书上推荐的status返回是否成功,C++中的模板类string比字符数组char[]更方便 6 7 //栈的结点 8 //包含data,和指向下一个结点

实现一个栈,要求实现Push(入栈)、Pop(出栈)、Min(返回最小值的操作)的时间复杂度为O(1)

具体实现如下: #include<iostream> #include<stack> #include<string> #include<assert.h> using namespace std; template<class T> class Stack { public: void Push(const T& x); void Pop(); T& Min(); void PrintS(); private: stack<

两栈共享空间的存储结构和入栈出栈操作

参考<大话数据结构>P95~96——两栈共享存储空间. 当两个栈的需求空间有相反关系时,也就是一个栈增长时,另一个栈在缩短,可以采用两栈共享空间结构.这是针对两个具有相同数据类型的栈的一个设计技巧. 举个简单的例子: 代码和解释如下(VS2012测试通过): 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 #define MAXSIZE 6 //本例中栈满共6个元素 6 typed

N个数依次入栈,出栈顺序有多少种?

对于每一个数来说,必须进栈一次.出栈一次.我们把进栈设为状态‘1’,出栈设为状态‘0’.n个数的所有状态对应n个1和n个0组成的2n位二进制数.由于等待入栈的操作数按照1‥n的顺序排列.入栈的操作数b大于等于出栈的操作数a(a≤b),因此输出序列的总数目=由左而右扫描由n个1和n个0组成的2n位二进制数,1的累计数不小于0的累计数的方案种数. 在2n位二进制数中填入n个1的方案数为C(2n,n),不填1的其余n位自动填0.从中减去不符合要求(由左而右扫描,0的累计数大于1的累计数)的方案数即为所

栈初始化,入栈,出栈功能的实现

1 ////////////////////////////////////////////////////////// 2 // stack.cpp 3 // 4 // author:Leetao 5 ////////////////////////////////////////////////////////// 6 // 简介: 7 // 线性表的实现 8 ////////////////////////////////////////////////////////// 9 /** 1