public Transition(string name, long unid, bool showAnnotation, int priority, TransitionType transitionType, int delay)
     : base(name, unid, showAnnotation)
 {
     this.priority = priority;
     this.transitionType = transitionType;
     this.delay = delay;
 }

 public FloatingMessage(String text, TransitionType transition = TransitionType.FIXED, Actor attachedMonster = null)
 {
     this.text = text;
     this.attachedMonster = attachedMonster;
     this.dialogSprite = new SpriteBatch(UI.getInstance().graphics);
     this.transitionType = transition;
 }

 /// <summary>
 /// Constructs a new background screen.
 /// </summary>
 public BackgroundScreen(string filename, TransitionType trans)
 {
     TransitionOnTime = TimeSpan.FromSeconds(0.5);
     TransitionOffTime = TimeSpan.FromSeconds(0.5);
     this.filename = filename;
     transitionType = trans;
 }

    public static void ChangeScene(string sceneName, TransitionType type)
    {
        if(sceneName.Length == 0){
            Debug.Log("SceneName is Null");
            return;
        }
        if (_nextSceneName.Length > 0){
            Debug.Log("Current Loading some other scene");
            return;
        }
        //ロード中
        if (_asyncOpp != null && !_asyncOpp.isDone){
            return;
        }

        string curScene = Application.loadedLevelName;  //_nextSeqName;

        _lastSceneName = curScene;
        _nextSceneName = sceneName;

        if (type == TransitionType.None)
        {
            SceneManager.LoadNextLevelCore();
        }
        else
        {
            _transitionFlag = false;
            // Commence Transition Effects
        //			_loadingTransition.ShowTransition(type, () => {
        //				SceneManager.LoadNextLevel();
        //			});
        }
    }

 public PopUpGraphicScreen(Texture2D _graphic, Vector2 _positionOffset, TransitionType _ttype, TimeSpan _transitionTime)
 {
     graphic = _graphic;
     ttype = _ttype;
     TransitionOnTime = _transitionTime;
     TransitionOffTime = _transitionTime;
     positionOffset = _positionOffset;
     position = Camera.Origin - new Vector2(graphic.Width * 0.5f, graphic.Height * 0.5f) + positionOffset;
 }

        private void FillList(ListBox list, TransitionType selection)
        {
            for (int i = 0; i < (int)TransitionType.EaseOutInBounce; i++) {
                list.Items.Add((TransitionType)i);

                if ((TransitionType)i == selection) {
                    list.SelectedIndex = i;
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="first"></param>
        /// <param name="second"></param>
        /// <param name="type">Linear interpolation or cosine</param>
        /// <param name="frames">Number of frames until the picture completely changes to the second one, then goes back to the first one</param>
        public TransitioningImage(Texture first, Texture second, TransitionType type, int frames, bool animateFirstAlpha = true)
        {
            First = new TexturedRectangle(first);
            Second = new TexturedRectangle(second);
            Type = type;
            Frames = frames;
            AnimateFirstImageAlpha = animateFirstAlpha;

            AddChild(First);
            AddChild(Second);
        }

 public TransitionEffect(Vector2 center,TransitionType type)
 {
     this.scale = 1;
     if (type == TransitionType.Translate)
         this.translation = new Vector2(-500, 0);
     else
         translation = Vector2.Zero;
     this.center = center;
     this.type = type;
     alpha = 1;
 }

	public void StartTransition (Color fromColor, Color toColor, float duration, TransitionType type) {
		if (transitState == TransitionState.TransitedIn || transitState == TransitionState.TransitedOut) {
			// Change the state to transiting in/out (according to the previous state)
			transitState = transitState == TransitionState.TransitedIn ? TransitionState.TransitingOut : TransitionState.TransitingIn;

			// Enable the transiter's Image
			transiters[type].EnableImage ();

			// Call the transition animation according to the given TransitionType
			transiters[type].StartTransition (fromColor, toColor, duration);
		}
	}

 /// <summary>
 /// NavigationEntry
 /// </summary>
 /// <param name="completionTime">completionTime</param>
 /// <param name="displayUrl">displayUrl</param>
 /// <param name="httpStatusCode">httpStatusCode</param>
 /// <param name="originalUrl">originalUrl</param>
 /// <param name="title">title</param>
 /// <param name="transitionType">transitionType</param>
 /// <param name="url">url</param>
 /// <param name="hasPostData">hasPostData</param>
 /// <param name="isValid">isValid</param>
 /// <param name="isCurrent">is the current entry</param>
 public NavigationEntry(bool isCurrent, DateTime completionTime, string displayUrl, int httpStatusCode, string originalUrl, string title, TransitionType transitionType, string url, bool hasPostData, bool isValid)
 {
     this.isCurrent = isCurrent;
     this.completionTime = completionTime;
     this.displayUrl = displayUrl;
     this.httpStatusCode = httpStatusCode;
     this.originalUrl = originalUrl;
     this.title = title;
     this.transitionType = transitionType;
     this.url = url;
     this.hasPostData = hasPostData;
     this.isValid = isValid;
 }

 public StateMenu(LeGame g)
     : base(g)
 {
     Log("Creating state");
     background = new ScrollBackground(game, "menu/background");
     mouse = new MouseEntity(game);
     singleColor = multiColor = optionsColor = exitColor = TEXT_COLOR;
     isTransitioning = true;
     doChangeState = false;
     transitionCount = 0;
     targetState = StateManager.State.Single;
     currentTransition = TransitionType.FadeIn;
 }

        protected void Start(Control control, TransitionType transitionType, int duration, AnimationAction actionHandler, AnimationFinishedEvaluator evaluatorHandler)
        {
            this.targetControl = control;
            this.transitionType = transitionType;
            this.actionHandler = actionHandler;
            this.evaluatorHandler = evaluatorHandler;

            this.counter = 0;
            this.startTime = 0;
            this.targetTime = duration;

            timer = DelayedCall.Start(DoAnimation, duration);
        }

        /// <summary>
        /// Show view onto the screen
        /// </summary>
        /// <param name="view">View to activate</param>
        /// <param name="type">Type of a transition</param>
        public static void ActivateView(IView view, TransitionType type)
        {
            if (_masterForm.InvokeRequired)
            {
                _masterForm.Invoke(new Action<IView>(ActivateView), new object[] { view, type });
                return;
            }

            var from = _currentView != null ? _currentView : view;
            var to = view;

            AddViewToForm(to);

            ViewTransitionManager.Execute(from, to, type);
        }

        /// <summary>
        /// Starts the specified control.
        /// </summary>
        /// <param name="control">The control.</param>
        /// <param name="targetSize">Size of the target.</param>
        /// <param name="transitionType">Type of the transition.</param>
        /// <param name="duration">The duration.</param>
        public void Start(Control control, Size targetSize, TransitionType transitionType, int duration)
        {
            base.Start(control, transitionType, duration,
                delegate
                {
                    int width = DoExpandAnimation(control.Width, targetSize.Width);
                    int height = DoExpandAnimation(control.Height, targetSize.Height);

                    control.Size = new Size(width, height);
                },
                delegate
                {
                    return (control.Size.Equals(targetSize));
                });
        }

        public void Start(Control control, Point targetPoint, TransitionType transitionType, int duration)
        {
            base.Start(control, transitionType, duration,
                delegate
                {
                    int x = DoMoveAnimation(control.Location.X, targetPoint.X);
                    int y = DoMoveAnimation(control.Location.Y, targetPoint.Y);

                    control.Location = new Point(x, y);
                },
                delegate
                {
                    return (control.Location.Equals(targetPoint));
                });
        }

 public ExitableBackgroundScreen(string filename, TransitionType type)
     : base(filename, type)
 {
     exit = new InputAction(
         new Buttons[]
         {
             Buttons.A,
             Buttons.B,
             Buttons.Back
         },
         new Keys[]
         {
             Keys.Space,
             Keys.Escape
         },
         true);
 }

        public ListBoxVideoItem(int id, string timestart, string clipid, string display1, string display2, TimeSpan lengthofclip, TypeEnum type, WhatNextEnum whatnext, int inframes, int outframes, Image itemImage, VideoCatergoryEnum category, TransitionType segue, Int32 seglength, string clipfilename)
            : base(id, timestart)
        {
            this.clipID = clipid;
            this.display1 = display1;
            this.display2 = display2;
            this.lengthOfClip = lengthofclip;
            this.type = type;
            this._whatnext = whatnext;
            this.inFrames = inframes;
            this.outFrames = outframes;
            this.itemImage = itemImage;
            this.Catergory = category;
            this.Segue = segue;
            this.SegLength = seglength;

            this.ClipFilename = clipfilename;
        }

    public void StartTransition(TransitionType transition)
    {
        if (transitionActive) return;

        switch(transition)
        {
            case TransitionType.GameToGlobe:
                StartCoroutine(GameToGlobeTransition());
                break;
            case TransitionType.GlobeToGame:
                StartCoroutine(GlobeToGameTransition());
                break;
            case TransitionType.GlobeGameToCam:
                StartCoroutine(GlobeGameToCam());
                break;
            case TransitionType.GlobeCamToGame:
                StartCoroutine(GlobeCamToGame());
                break;
        }
    }

        internal static void Execute(IView from, IView to, TransitionType type)
        {
            _fromView = from;
            _toView = to;

            switch (type)
            {
                case TransitionType.Basic:
                    _currentTransition = _basicTransition;
                    break;

                case TransitionType.SlideLeft:
                    _slideTransition.SlideDirection = TransitionType.SlideLeft;
                    _currentTransition = _slideTransition;
                    break;

                case TransitionType.SlideRight:
                    _slideTransition.SlideDirection = TransitionType.SlideRight;
                    _currentTransition = _slideTransition;
                    break;

                case TransitionType.FlipLeft:
                    _flipTransition.FlipDirection = TransitionType.FlipLeft;
                    _currentTransition = _flipTransition;
                    break;

                case TransitionType.FlipRight:
                    _flipTransition.FlipDirection = TransitionType.FlipRight;
                    _currentTransition = _flipTransition;
                    break;
            }

            if (!_currentTransition.IsTransitionAvailable())
                _currentTransition = _basicTransition;

            _currentTransition.Execute();
        }

        private static void FillAnimation(DoubleAnimationUsingKeyFrames animation, TransitionType type, double from, double to, TimeSpan duration, double fps)
        {
            Equation equation = (Equation)Delegate.CreateDelegate(typeof(Equation), typeof(Equations).GetMethod(type.ToString()));

            double total = duration.TotalMilliseconds;
            double step = 1000D / (double)fps;

            // clear animation
            animation.KeyFrames.Clear();

            for (double i = 0; i < total; i += step) {
                LinearDoubleKeyFrame frame = new LinearDoubleKeyFrame();
                frame.KeyTime = KeyTime.FromTimeSpan(TimeSpan.FromMilliseconds(i));
                frame.Value = equation(i, from, to - from, total);

                animation.KeyFrames.Add(frame);
            }

            // always add exact final key frame
            LinearDoubleKeyFrame finalFrame = new LinearDoubleKeyFrame();
            finalFrame.KeyTime = KeyTime.FromTimeSpan(TimeSpan.FromMilliseconds(total));
            finalFrame.Value = to;
            animation.KeyFrames.Add(finalFrame);
        }