Пример #1
0
        /// <summary>
        /// Adjusts the container views based on how far along X they should move.
        /// Also updates the fade out view so it darkens or lightens as needed.
        /// </summary>
        /// <param name="xPos">X position.</param>
        void PanContainerViews(float xPos)
        {
            // there's a small chance of an exception being thrown
            // due to one of the below not being valid. Repro'ing this is not easy,
            // so the safer route is to just guard against all of them, and
            // worst case we'll skip a frame of animation

            if (DropShadowView != null &&
                View != null &&
                ActiveTaskFrame != null &&
                NavToolbar != null &&
                NavToolbar.ButtonLayout != null &&
                FadeOutFrame != null)
            {
                DropShadowView.SetX(xPos - DropShadowXOffset);
                View.SetX(xPos);
                ActiveTaskFrame.SetX(xPos);
                NavToolbar.ButtonLayout.SetX(xPos);
                FadeOutFrame.SetX(xPos);

                // now determine the alpha
                float maxSlide = Springboard.GetSpringboardDisplayWidth( );
                FadeOutFrame.Alpha = Math.Min(xPos / maxSlide, PrivatePrimaryContainerConfig.SlideDarkenAmount);
            }
        }
Пример #2
0
        public void ToggleFullscreen(bool fullscreenEnabled)
        {
            // useful for when a video wants to be fullscreen
            if (fullscreenEnabled == true)
            {
                Navbar.Visibility = ViewStates.Gone;
                NavToolbar.ButtonLayout.Visibility = ViewStates.Gone;

                // if we're in landscape wide, ensure the springboard is closed while in fullscreen.
                if (MainActivity.IsLandscapeWide( ) == true)
                {
                    PanContainerViews(0);

                    Point displaySize = new Point();
                    Activity.WindowManager.DefaultDisplay.GetSize(displaySize);
                    float displayWidth = displaySize.X;
                    SetContainerWidth((int)displayWidth);
                }
            }
            else
            {
                Navbar.Visibility = ViewStates.Visible;
                NavToolbar.ButtonLayout.Visibility = ViewStates.Visible;

                // if we're in landscape wide, ensure the springboard is closed while in fullscreen.
                if (MainActivity.IsLandscapeWide( ) == true)
                {
                    PanContainerViews(Springboard.GetSpringboardDisplayWidth( ));
                    SetContainerWidth(GetCurrentContainerDisplayWidth( ));
                }
            }
        }
Пример #3
0
        public void OnScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)
        {
            // sanity check, as the events could be null.
            if (e1 != null && e2 != null)
            {
                // only allow it if we're NOT animating, the task is ok with us panning, and we're in portrait mode.
                if (Animating == false &&
                    ActiveTask.CanContainerPan( ) &&
                    Activity.Resources.Configuration.Orientation == Android.Content.Res.Orientation.Portrait)
                {
                    switch (Panning)
                    {
                    case PanState.Monitoring:
                    {
                        TotalPanY += Math.Abs(e2.RawY - e1.RawY);
                        TotalPanX += Math.Abs(e2.RawX - e1.RawX);

                        FrameCount++;

                        if (FrameCount > sNumPanTrackingFrames)
                        {
                            // decide how to proceed
                            Panning = PanState.None;

                            // put simply, if their total X was more than their total Y, well then,
                            // lets pan.
                            if (TotalPanX > TotalPanY)
                            {
                                Panning = PanState.Panning;

                                // mark where the panning began, so we can move the field appropriately
                                PanStartX = e2.RawX;

                                PanelOriginX = View.GetX( );
                            }
                            else
                            {
                                // Y was greater than X, so they probably intended to scroll, not pan.
                                Panning = PanState.None;
                            }
                        }
                        break;
                    }

                    case PanState.Panning:
                    {
                        distanceX = e2.RawX - PanStartX;

                        float xPos         = PanelOriginX + distanceX;
                        float revealAmount = Springboard.GetSpringboardDisplayWidth( );
                        xPos = Math.Max(0, Math.Min(xPos, revealAmount));

                        PanContainerViews(xPos);
                        break;
                    }
                    }
                }
            }
        }
Пример #4
0
        public void LayoutChanged( )
        {
            // if we just entered landscape wide mode
            if (MainActivity.IsLandscapeWide( ) == true)
            {
                // turn off the springboard button
                SpringboardRevealButton.Enabled = false;
                SpringboardRevealed             = true;

                // move the container over so the springboard is revealed
                PanContainerViews(Springboard.GetSpringboardDisplayWidth( ));

                // turn off the shadow
                FadeOutFrame.Alpha      = 0.0f;
                FadeOutFrame.Visibility = ViewStates.Invisible;

                // resize the containers to use the remaining width
                int containerWidth = GetCurrentContainerDisplayWidth( );

                SetContainerWidth(containerWidth);

                ToggleInputViewChecker(false);
            }
            // we're going back to portrait (or normal landscape)
            else
            {
                // enable the springboard reveal button
                SpringboardRevealed = false;

                // close the springboard
                PanContainerViews(0);
                FadeOutFrame.Visibility = ViewStates.Visible;

                // resize the containers to use the full device width
                Point displaySize = new Point( );
                Activity.WindowManager.DefaultDisplay.GetSize(displaySize);
                float displayWidth = displaySize.X;

                SetContainerWidth((int)displayWidth);

                // only allow the reveal button if the device is in portrait.
                if (MainActivity.IsPortrait( ))
                {
                    SpringboardRevealButton.Enabled = true;
                }
                else
                {
                    SpringboardRevealButton.Enabled = false;
                }
            }
        }
Пример #5
0
        public void OnUp(MotionEvent e)
        {
            // if we were panning
            if (Panning == PanState.Panning)
            {
                float revealAmount = Springboard.GetSpringboardDisplayWidth( );
                if (SpringboardRevealed == false)
                {
                    // since the springboard wasn't revealed, require that they moved
                    // at least 1/5th the amount before opening it
                    if (View.GetX( ) > revealAmount * .20f)
                    {
                        RevealSpringboard(true);
                    }
                    else
                    {
                        RevealSpringboard(false);
                    }
                }
                else
                {
                    if (View.GetX( ) < revealAmount * .85f)
                    {
                        RevealSpringboard(false);
                    }
                    else
                    {
                        RevealSpringboard(true);
                    }
                }
            }
            else
            {
                // if the task should allowe input, reveal the nav bar
                if (ShouldTaskAllowInput( ) == true)
                {
                    // let the active task know that the user released input
                    ActiveTask.OnUp(e);
                }
                else if (ShouldSpringboardAllowInput( ) == true)
                {
                    // else close the springboard
                    RevealSpringboard(false);
                }
            }

            // no matter what, we're done panning
            Panning = PanState.None;
        }
Пример #6
0
        public void RevealSpringboard(bool wantReveal)
        {
            if (!Animating)
            {
                Animating = true;

                int xOffset = wantReveal ? (int)Springboard.GetSpringboardDisplayWidth( ) : 0;

                // setup an animation from our current mask scale to the new one.
                XPosAnimator = ValueAnimator.OfInt((int)View.GetX( ), xOffset);

                XPosAnimator.AddUpdateListener(this);
                XPosAnimator.AddListener(new NavbarAnimationListener( )
                {
                    NavbarFragment = this
                });
                XPosAnimator.SetDuration((int)(PrivatePrimaryContainerConfig.SlideRate * 1000.0f));
                XPosAnimator.Start();
            }
        }