public UIPageViewControllerSpineLocation GetSpineLocation (UIPageViewController pageViewController, UIInterfaceOrientation orientation) { if (orientation == UIInterfaceOrientation.Portrait || UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Phone) { UIViewController currentViewController = pageViewController.ViewControllers [0]; pageViewController.SetViewControllers ( new [] { currentViewController }, UIPageViewControllerNavigationDirection.Forward, true, null ); pageViewController.DoubleSided = false; return UIPageViewControllerSpineLocation.Min; } var dataViewController = (DataViewController)pageViewController.ViewControllers [0]; var indexOfCurrentViewController = modelController.IndexOfViewController (dataViewController); UIViewController[] viewControllers = null; if (indexOfCurrentViewController == 0 || indexOfCurrentViewController % 2 == 0) { UIViewController nextViewController = modelController.GetNextViewController (pageViewController, dataViewController); viewControllers = new [] { dataViewController, nextViewController }; } else { UIViewController previousViewController = modelController.GetPreviousViewController (pageViewController, dataViewController); viewControllers = new[] { dataViewController, previousViewController }; } pageViewController.SetViewControllers (viewControllers, UIPageViewControllerNavigationDirection.Forward, true, null); return UIPageViewControllerSpineLocation.Mid; }
public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { base.DidRotate (fromInterfaceOrientation); foreach (var x in TableView.VisibleCells) { ((ContactListScreenCell)x).Rotate (); } }
/// <summary> /// A helper method to position the controls appropriately, based on the /// orientation /// </summary> protected void PositionControls (UIInterfaceOrientation toInterfaceOrientation) { // depending one what orientation we start in, we want to position our controls // appropriately switch (toInterfaceOrientation) { // if we're switching to landscape case UIInterfaceOrientation.LandscapeLeft: case UIInterfaceOrientation.LandscapeRight: // reposition the buttons button1.Frame = new System.Drawing.RectangleF (10, 10, 100, 33); button2.Frame = new System.Drawing.RectangleF (10, 200, 100, 33); // reposition the image image.Frame = new System.Drawing.RectangleF (240, 25, image.Frame.Width, image.Frame.Height); break; // we're switching back to portrait case UIInterfaceOrientation.Portrait: case UIInterfaceOrientation.PortraitUpsideDown: // reposition the buttons button1.Frame = new System.Drawing.RectangleF (10, 10, 100, 33); button2.Frame = new System.Drawing.RectangleF (200, 10, 100, 33); // reposition the image image.Frame = new System.Drawing.RectangleF (20, 150, this.image.Frame.Width, this.image.Frame.Height); break; } }
public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { base.DidRotate (fromInterfaceOrientation); scrollView.Frame = new RectangleF(0,0,baseView.Bounds.Width,baseView.Bounds.Height-36); pageControl.Frame = new RectangleF(0,baseView.Bounds.Height-36,baseView.Bounds.Width,36); int count = pageControl.Pages; RectangleF scrollFrame = scrollView.Frame; scrollFrame.Width = scrollFrame.Width * count; scrollView.ContentSize = scrollFrame.Size; for (int i=0; i<count; i++) { RectangleF frame = scrollView.Frame; PointF location = new PointF(); location.X = frame.Width * i; frame.Location = location; scrollView.Subviews[i].Frame = frame; } float pageOffset = scrollView.Frame.Width*pageControl.CurrentPage; PointF p = new PointF(pageOffset, 0); scrollView.SetContentOffset(p,true); }
public override bool ShouldHideViewController(UISplitViewController svc, UIViewController viewController, UIInterfaceOrientation inOrientation) { //return true; // always hide //return true; // never hide return inOrientation == UIInterfaceOrientation.Portrait || inOrientation == UIInterfaceOrientation.PortraitUpsideDown; }
/// <summary> /// is called when the OS is going to rotate the application. It handles rotating the status bar /// if it's present, as well as it's controls like the navigation controller and tab bar, but you /// must handle the rotation of your view and associated subviews. This call is wrapped in an /// animation block in the underlying implementation, so it will automatically animate your control /// repositioning. /// </summary> public override void WillAnimateRotation (UIInterfaceOrientation toInterfaceOrientation, double duration) { base.WillAnimateRotation (toInterfaceOrientation, duration); // call our helper method to position the controls PositionControls (toInterfaceOrientation); }
/// <summary> /// Only allow iPad application to rotate, iPhone is always portrait /// </summary> public override bool ShouldAutorotateToInterfaceOrientation(UIInterfaceOrientation toInterfaceOrientation) { if (AppDelegate.IsPad) return true; else return toInterfaceOrientation == UIInterfaceOrientation.Portrait; }
public ExEnEmTouchScaler(UIInterfaceOrientation orientation, Point renderbufferSize, Point deviceSize) { this.orientation = orientation; this.renderbufferSize = renderbufferSize; this.deviceSize = deviceSize; Recalculate(); }
public override void DidRotate(UIInterfaceOrientation orientation) { base.DidRotate(orientation); View.SetNeedsDisplay(); Console.WriteLine("Hypnosis View did rotate - frame" + View.Frame.ToString()); Console.WriteLine("Hypnosis View did rotate - bounds" + View.Frame.ToString()); }
public void UpdatePreviewRotation(UIInterfaceOrientation orientation) { //Re-size camera feed based on orientation if (previewLayer == null) return; previewLayer.Connection.VideoOrientation = configDicByRotationChanged[orientation]; previewLayer.Frame = rootView.Bounds; }
public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { if (ViewModel is BaseViewModel) { ((BaseViewModel)ViewModel).WaitForReady(() => InvokeOnMainThread(ViewModelReady)); } }
public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { base.DidRotate (fromInterfaceOrientation); WebView.Frame = new RectangleF (0f * Device.screenWidthP, 0f * Device.screenHeightP, 100f * Device.screenWidthP, 100f * Device.screenHeightP); WebView.Reload (); }
public override void DidRotate (UIInterfaceOrientation fromInterfaceOrientation) { base.DidRotate (fromInterfaceOrientation); // update the camera orientation stillCamera.OutputImageOrientation = InterfaceOrientation; }
public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { base.DidRotate (fromInterfaceOrientation); if (aboutScreenView != null) { aboutScreenView.Rotate (); } }
public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { CheckOrientation (); Console.WriteLine("Rotate From {0} to {1} with frame {2}",fromInterfaceOrientation, InterfaceOrientation, this.View.Frame); base.DidRotate (fromInterfaceOrientation); }
public override bool ShouldAutorotateToInterfaceOrientation(UIInterfaceOrientation toInterfaceOrientation) { var f = this.View.Frame; _player.View.Frame = new Rectangle(0,0,(int)f.Height,(int)f.Width); return true; }
public override void WillRotate(UIInterfaceOrientation toInterfaceOrientation, double duration) { base.WillRotate (toInterfaceOrientation, duration); if (googleAdView != null) googleAdView.AdSize = ForOrientation (toInterfaceOrientation); }
void UpdateInterfaceOrientation(UIInterfaceOrientation interfaceOrientation) { _scannerSession.InterfaceOrientation = interfaceOrientation; var captureLayer = _scannerSession.CaptureLayer; captureLayer.Frame = View.Bounds; switch (interfaceOrientation) { case UIInterfaceOrientation.Portrait: captureLayer.Connection.VideoOrientation = AVCaptureVideoOrientation.Portrait; break; case UIInterfaceOrientation.PortraitUpsideDown: captureLayer.Connection.VideoOrientation = AVCaptureVideoOrientation.PortraitUpsideDown; break; case UIInterfaceOrientation.LandscapeLeft: captureLayer.Connection.VideoOrientation = AVCaptureVideoOrientation.LandscapeLeft; break; case UIInterfaceOrientation.LandscapeRight: captureLayer.Connection.VideoOrientation = AVCaptureVideoOrientation.LandscapeRight; break; default: break; } }
public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { base.DidRotate(fromInterfaceOrientation); TableView.BeginUpdates(); TableView.TableHeaderView = HeaderView; TableView.EndUpdates(); }
public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { base.DidRotate(fromInterfaceOrientation); foreach(var v in ScrollView.Subviews) v.RemoveFromSuperview(); CreateMenu(); }
public override bool ShouldAutorotateToInterfaceOrientation (UIInterfaceOrientation toInterfaceOrientation) { // Return true for supported orientations _moviePlayer.View.Frame = this.View.Frame; return (toInterfaceOrientation != UIInterfaceOrientation.PortraitUpsideDown); }
public override System.Drawing.SizeF SizeForItemsInInterfaceOrientation(GMGridView.GMGridView gridView, UIInterfaceOrientation orientation) { SizeF size; //Console.WriteLine("SizeForItemsInInterfaceOrientation"); if (MainViewController.UserInterfaceIdiomIsPhone) { if (orientation == UIInterfaceOrientation.LandscapeLeft || orientation == UIInterfaceOrientation.LandscapeRight) { size = new SizeF(170.0f, 135.0f); } else { size = new SizeF(140f, 110f); } } else { if (orientation == UIInterfaceOrientation.LandscapeLeft || orientation == UIInterfaceOrientation.LandscapeRight) { size = new SizeF(285.0f, 205.0f); } else { size = new SizeF(230.0f, 175.0f); } } Console.WriteLine("Size: {0}; {1}", size.Width, size.Height); return size; }
public UIPageViewControllerSpineLocation GetSpineLocation(UIPageViewController pageViewController, UIInterfaceOrientation orientation) { UIViewController currentViewController; UIViewController[] viewControllers; if (orientation == UIInterfaceOrientation.Portrait || orientation == UIInterfaceOrientation.PortraitUpsideDown || UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Phone) { // In portrait orientation or on iPhone: Set the spine position to "min" and the page view controller's view controllers array to contain just one view controller. // Setting the spine position to 'UIPageViewControllerSpineLocation.Mid' in landscape orientation sets the doubleSided property to true, so set it to false here. currentViewController = pageViewController.ViewControllers [0]; viewControllers = new [] { currentViewController }; pageViewController.SetViewControllers (viewControllers, UIPageViewControllerNavigationDirection.Forward, true, null); pageViewController.DoubleSided = false; return UIPageViewControllerSpineLocation.Min; } // In landscape orientation: Set set the spine location to "mid" and the page view controller's view controllers array to contain two view controllers. // If the current page is even, set it to contain the current and next view controllers; if it is odd, set the array to contain the previous and current view controllers. currentViewController = pageViewController.ViewControllers [0]; int index = ModelController.IndexOf ((DataViewController)currentViewController); if (index == 0 || index % 2 == 0) { var nextViewController = ModelController.GetNextViewController (pageViewController, currentViewController); viewControllers = new [] { currentViewController, nextViewController }; } else { var previousViewController = ModelController.GetPreviousViewController (pageViewController, currentViewController); viewControllers = new [] { previousViewController, currentViewController }; } pageViewController.SetViewControllers (viewControllers, UIPageViewControllerNavigationDirection.Forward, true, null); return UIPageViewControllerSpineLocation.Mid; }
public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { base.DidRotate(fromInterfaceOrientation); UpdateGUI(); UpdateTableView(); }
public override bool ShouldAutorotateToInterfaceOrientation (UIInterfaceOrientation toInterfaceOrientation) { if (UserInterfaceIdiomIsPhone) return (toInterfaceOrientation != UIInterfaceOrientation.PortraitUpsideDown); return true; }
public override bool ShouldAutorotateToInterfaceOrientation (UIInterfaceOrientation toInterfaceOrientation) { if (toInterfaceOrientation == UIInterfaceOrientation.LandscapeLeft) return true; else if (toInterfaceOrientation == UIInterfaceOrientation.LandscapeRight) return true; return false; }
public override void WillRotate(UIInterfaceOrientation toInterfaceOrientation, double duration) { base.WillRotate(toInterfaceOrientation, duration); UIView.BeginAnimations( "Position" ); UIView.SetAnimationDuration(duration); LayoutViews(Helper.ScreenBoundsDependOnOrientation(toInterfaceOrientation)); UIView.CommitAnimations(); }
public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { // Refresh Chart rotating the device chart.RemoveFromSuperview(); chart.Frame = View.Frame; View.AddSubview(chart); chart.DoInvalidate(); }
public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { base.DidRotate (fromInterfaceOrientation); if (centerButton != null){ this.View.BringSubviewToFront(centerButton); } }
public override bool ShouldAutorotateToInterfaceOrientation(UIInterfaceOrientation toInterfaceOrientation) { if (UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Pad) { return (toInterfaceOrientation != UIInterfaceOrientation.PortraitUpsideDown); } else { return (toInterfaceOrientation == UIInterfaceOrientation.Portrait); } }
public override bool ShouldHideViewController(UISplitViewController svc, UIViewController viewController, UIInterfaceOrientation inOrientation) { bool willHideViewController; switch (_flyoutPresentedDefaultState) { case FlyoutLayoutBehavior.Split: willHideViewController = false; break; case FlyoutLayoutBehavior.Popover: willHideViewController = true; break; case FlyoutLayoutBehavior.SplitOnPortrait: willHideViewController = !(inOrientation == UIInterfaceOrientation.Portrait || inOrientation == UIInterfaceOrientation.PortraitUpsideDown); break; default: willHideViewController = inOrientation == UIInterfaceOrientation.Portrait || inOrientation == UIInterfaceOrientation.PortraitUpsideDown; break; } return(willHideViewController); }
bool ShouldShowMaster(UIInterfaceOrientation orientation) { // Returns true if master view should be shown directly embedded in the splitview, instead of hidden in a popover. return(IsLandscape() ? _showsMasterInLandscape : _showsMasterInPortrait); }
public void DidRotate(UIInterfaceOrientation orientation) { ResizePreview(orientation); LayoutSubviews(); }
void LayoutSubviews(UIInterfaceOrientation theOrientation, bool animate) { // this is mostly for video playback. if a video is playing, we need // to make sure that it remains on the top when a rotation occurs UIView topView = null; if (View.Subviews.Count() > 0) { topView = View.Subviews.Last(); } if (_reconfigurePopup) { ReconfigureForMasterInPopover(!ShouldShowMaster(theOrientation)); } // Layout the master, detail and divider views appropriately, adding/removing subviews as needed. // First obtain relevant geometry. SizeF fullSize = SplitViewSizeForOrientation(theOrientation); float width = fullSize.Width; float height = fullSize.Height; // Layout the master, divider and detail views. RectangleF newFrame = new RectangleF(0, 0, width, height); UIView view; bool shouldShowMaster = ShouldShowMaster(theOrientation); bool masterFirst = MasterBeforeDetail; RectangleF masterRect, dividerRect, detailRect; if (Vertical) { if (masterFirst) { if (!ShouldShowMaster()) { // Move off-screen. newFrame.X -= (SplitPosition + SplitWidth); } newFrame.Width = SplitPosition; masterRect = newFrame; newFrame.X += newFrame.Width; newFrame.Width = SplitWidth; dividerRect = newFrame; newFrame.X += newFrame.Width; newFrame.Width = width - newFrame.X; detailRect = newFrame; } else { if (!ShouldShowMaster()) { // Move off-screen. newFrame.Width += (SplitPosition + SplitWidth); } newFrame.Width -= (SplitPosition + SplitWidth); detailRect = newFrame; newFrame.X += newFrame.Width; newFrame.Width = SplitWidth; dividerRect = newFrame; newFrame.X += newFrame.Width; newFrame.Width = SplitPosition; masterRect = newFrame; } // Position master. view = _masterViewController.View; if (view != null) { view.Frame = masterRect; if (view.Superview == null) { _masterViewController.ViewWillAppear(false); View.AddSubview(view); _masterViewController.ViewDidAppear(false); } } // Position divider. view = DividerView; view.Frame = dividerRect; if (view.Superview == null) { View.AddSubview(view); } // Position detail. view = _detailViewController.View; if (view != null) { view.Frame = detailRect; if (view.Superview == null) { View.InsertSubviewAbove(view, _masterViewController.View); } else { View.BringSubviewToFront(view); } } } else { if (masterFirst) { if (!ShouldShowMaster()) { // Move off-screen. newFrame.Y -= (SplitPosition + SplitWidth); } newFrame.Height = SplitPosition; masterRect = newFrame; newFrame.Y += newFrame.Height; newFrame.Height = SplitWidth; dividerRect = newFrame; newFrame.Y += newFrame.Height; newFrame.Height = height - newFrame.Y; detailRect = newFrame; } else { if (!ShouldShowMaster()) { // Move off-screen. newFrame.Height += (SplitPosition + SplitWidth); } newFrame.Height -= (SplitPosition + SplitWidth); detailRect = newFrame; newFrame.Y += newFrame.Height; newFrame.Height = SplitWidth; dividerRect = newFrame; newFrame.Y += newFrame.Height; newFrame.Height = SplitPosition; masterRect = newFrame; } // Position master. view = _masterViewController.View; if (view != null) { view.Frame = masterRect; if (view.Superview == null) { _masterViewController.ViewWillAppear(false); View.AddSubview(view); _masterViewController.ViewDidAppear(false); } } // Position divider. view = DividerView; view.Frame = dividerRect; if (view.Superview == null) { View.AddSubview(view); } // Position detail. view = _detailViewController.View; if (view == null) { view.Frame = detailRect; if (view.Superview == null) { View.InsertSubviewAbove(view, _masterViewController.View); } else { View.BringSubviewToFront(view); } } } // Create corner views if necessary. MGSplitCornersView leadingCorners; // top/left of screen in Vertical/horizontal split. MGSplitCornersView trailingCorners; // bottom/right of screen in Vertical/horizontal split. if (_cornerViews == null) { leadingCorners = new MGSplitCornersView(); leadingCorners.SetSplitViewController(this); leadingCorners.CornerBackgroundColor = _defaultCornerColor; leadingCorners.CornerRadius = _defaultCornerRadius; trailingCorners = new MGSplitCornersView(); trailingCorners.SetSplitViewController(this); trailingCorners.CornerBackgroundColor = _defaultCornerColor; trailingCorners.CornerRadius = _defaultCornerRadius; _cornerViews = new MGSplitCornersView[2] { leadingCorners, trailingCorners }; } else { leadingCorners = _cornerViews[0]; trailingCorners = _cornerViews[1]; } // Configure and layout the corner-views. leadingCorners.CornersPosition = (Vertical) ? MGCornersPosition.LeadingVertical : MGCornersPosition.LeadingHorizontal; trailingCorners.CornersPosition = (Vertical) ? MGCornersPosition.TrailingVertical : MGCornersPosition.TrailingHorizontal; leadingCorners.AutoresizingMask = (Vertical) ? UIViewAutoresizing.FlexibleBottomMargin : UIViewAutoresizing.FlexibleRightMargin; trailingCorners.AutoresizingMask = (Vertical) ? UIViewAutoresizing.FlexibleTopMargin : UIViewAutoresizing.FlexibleLeftMargin; float x, y, cornersWidth, cornersHeight; RectangleF leadingRect, trailingRect; float radius = leadingCorners.CornerRadius; if (Vertical) // left/right split { cornersWidth = (radius * 2.0f) + SplitWidth; cornersHeight = radius; x = ((shouldShowMaster) ? ((masterFirst) ? SplitPosition : width - (SplitPosition + SplitWidth)) : (0 - SplitWidth)) - radius; y = 0; leadingRect = new RectangleF(x, y, cornersWidth, cornersHeight); // top corners trailingRect = new RectangleF(x, (height - cornersHeight), cornersWidth, cornersHeight); // bottom corners } else // top/bottom split { x = 0; y = ((shouldShowMaster) ? ((masterFirst) ? SplitPosition : height - (SplitPosition + SplitWidth)) : (0 - SplitWidth)) - radius; cornersWidth = radius; cornersHeight = (radius * 2.0f) + SplitWidth; leadingRect = new RectangleF(x, y, cornersWidth, cornersHeight); // left corners trailingRect = new RectangleF((width - cornersWidth), y, cornersWidth, cornersHeight); // right corners } leadingCorners.Frame = leadingRect; trailingCorners.Frame = trailingRect; // Ensure corners are visible and frontmost. if (leadingCorners.Superview == null) { View.InsertSubviewAbove(leadingCorners, _detailViewController.View); View.InsertSubviewAbove(trailingCorners, _detailViewController.View); } else { View.BringSubviewToFront(leadingCorners); View.BringSubviewToFront(trailingCorners); } if (topView != null) { topView.Superview.BringSubviewToFront(topView); } // if (IsLandscape()) // View.Frame = new RectangleF(0, 20, View.Frame.Width, View.Frame.Height); // else // View.Frame = new RectangleF(0, 20, View.Frame.Width, View.Frame.Height); }
/// <summary> /// Handles device orientation changes. /// </summary> /// <param name="fromInterfaceOrientation">The previous interface orientation.</param> public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { base.DidRotate(fromInterfaceOrientation); this.plotView.InvalidatePlot(false); }
public bool IsPortrait(UIInterfaceOrientation orientation) { return(orientation == UIInterfaceOrientation.Portrait || orientation == UIInterfaceOrientation.PortraitUpsideDown); }
public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { _ignoreNativeScrolling = false; View.SetNeedsLayout(); }
public UIPageViewControllerSpineLocation GetSpineLocation(UIPageViewController pageViewController, UIInterfaceOrientation orientation) { UIViewController currentViewController; UIViewController[] viewControllers; if (orientation == UIInterfaceOrientation.Portrait || orientation == UIInterfaceOrientation.PortraitUpsideDown || UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Phone) { // In portrait orientation or on iPhone: Set the spine position to "min" and the page view controller's view controllers array to contain just one view controller. // Setting the spine position to 'UIPageViewControllerSpineLocation.Mid' in landscape orientation sets the doubleSided property to true, so set it to false here. currentViewController = pageViewController.ViewControllers[0]; viewControllers = new[] { currentViewController }; pageViewController.SetViewControllers(viewControllers, UIPageViewControllerNavigationDirection.Forward, true, null); pageViewController.DoubleSided = false; return(UIPageViewControllerSpineLocation.Min); } // In landscape orientation: Set set the spine location to "mid" and the page view controller's view controllers array to contain two view controllers. // If the current page is even, set it to contain the current and next view controllers; if it is odd, set the array to contain the previous and current view controllers. currentViewController = pageViewController.ViewControllers[0]; int index = ModelController.IndexOf((DataViewController)currentViewController); if (index == 0 || index % 2 == 0) { var nextViewController = ModelController.GetNextViewController(pageViewController, currentViewController); viewControllers = new[] { currentViewController, nextViewController }; } else { var previousViewController = ModelController.GetPreviousViewController(pageViewController, currentViewController); viewControllers = new[] { previousViewController, currentViewController }; } pageViewController.SetViewControllers(viewControllers, UIPageViewControllerNavigationDirection.Forward, true, null); return(UIPageViewControllerSpineLocation.Mid); }
public override bool ShouldHideViewController(UISplitViewController svc, UIViewController viewController, UIInterfaceOrientation inOrientation) { return(false); }
public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { base.DidRotate(fromInterfaceOrientation); View.SetNeedsLayout(); }
private static UICollectionViewFlowLayout CollectionViewFlowLayoutForOrientation(UIInterfaceOrientation orientation, GMImagePickerController picker) { nfloat screenWidth; nfloat screenHeight; //Ipad popover is not affected by rotation! if (UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Pad) { screenWidth = picker.View.Bounds.Width; screenHeight = picker.View.Bounds.Height; } else { var insets = UIEdgeInsets.Zero; if (picker.View.RespondsToSelector(new ObjCRuntime.Selector("safeAreaInsets"))) { insets = picker.View.SafeAreaInsets; } var horizontalInsets = insets.Right + insets.Left; var verticalInsets = insets.Bottom + insets.Top; if (UIApplication.SharedApplication.StatusBarOrientation == UIInterfaceOrientation.LandscapeLeft || UIApplication.SharedApplication.StatusBarOrientation == UIInterfaceOrientation.LandscapeRight) { screenHeight = picker.View.Bounds.Width - horizontalInsets; screenWidth = picker.View.Bounds.Height - verticalInsets; } else { screenWidth = picker.View.Bounds.Width - horizontalInsets; screenHeight = picker.View.Bounds.Height - verticalInsets; } } if ((UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Pad) || (UIApplication.SharedApplication.StatusBarOrientation == UIInterfaceOrientation.Portrait || UIApplication.SharedApplication.StatusBarOrientation == UIInterfaceOrientation.PortraitUpsideDown)) { if (_portraitLayout == null) { var cellTotalUsableWidth = screenWidth - (picker.ColsInPortrait - 1) * picker.MinimumInteritemSpacing; var itemSize = new CGSize(cellTotalUsableWidth / picker.ColsInPortrait, cellTotalUsableWidth / picker.ColsInPortrait); var cellTotalUsedWidth = (double)itemSize.Width * picker.ColsInPortrait; var spaceTotalWidth = screenWidth - cellTotalUsedWidth; var spaceWidth = spaceTotalWidth / (picker.ColsInPortrait - 1); _portraitLayout = new UICollectionViewFlowLayout { MinimumInteritemSpacing = picker.MinimumInteritemSpacing, ItemSize = itemSize, MinimumLineSpacing = (nfloat)spaceWidth }; if (_portraitLayout.RespondsToSelector(new ObjCRuntime.Selector("sectionInsetReference"))) { _portraitLayout.SectionInsetReference = UICollectionViewFlowLayoutSectionInsetReference.SafeArea; } } return(_portraitLayout); } else { if (_landscapeLayout == null) { var cellTotalUsableWidth = screenHeight - (picker.ColsInLandscape - 1) * picker.MinimumInteritemSpacing; var itemSize = new CGSize(cellTotalUsableWidth / picker.ColsInLandscape, cellTotalUsableWidth / picker.ColsInLandscape); var cellTotalUsedWidth = (double)itemSize.Width * picker.ColsInLandscape; var spaceTotalWidth = screenHeight - cellTotalUsedWidth; var spaceWidth = spaceTotalWidth / (picker.ColsInLandscape - 1); _landscapeLayout = new UICollectionViewFlowLayout { MinimumInteritemSpacing = picker.MinimumInteritemSpacing, ItemSize = itemSize, MinimumLineSpacing = (nfloat)spaceWidth }; if (_landscapeLayout.RespondsToSelector(new ObjCRuntime.Selector("sectionInsetReference"))) { _landscapeLayout.SectionInsetReference = UICollectionViewFlowLayoutSectionInsetReference.SafeArea; } } return(_landscapeLayout); } }
public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { //if( }
//------------------------------------------------------------------------------------------------------------------------------------------------------------------ public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { base.DidRotate(fromInterfaceOrientation); UpdateView(); }
public bool IsLandscape(UIInterfaceOrientation orientation) { return(orientation == UIInterfaceOrientation.LandscapeLeft || orientation == UIInterfaceOrientation.LandscapeRight); }
public override bool ShouldAutorotateToInterfaceOrientation(UIInterfaceOrientation toInterfaceOrientation) { // Return true for supported orientations return(true); }
void PositionHUD(NSNotification notification) { float keyboardHeight = 0; double animationDuration = 0; UIInterfaceOrientation orientation = UIApplication.SharedApplication.StatusBarOrientation; if (notification != null) { RectangleF keyboardFrame = UIKeyboard.FrameEndFromNotification(notification); animationDuration = UIKeyboard.AnimationDurationFromNotification(notification); if (notification.Name == UIKeyboard.WillShowNotification || notification.Name == UIKeyboard.DidShowNotification) { if (IsPortrait(orientation)) { keyboardHeight = keyboardFrame.Size.Height; } else { keyboardHeight = keyboardFrame.Size.Width; } } else { keyboardHeight = 0; } } else { keyboardHeight = VisibleKeyboardHeight; } RectangleF orientationFrame = UIScreen.MainScreen.Bounds; RectangleF statusBarFrame = UIApplication.SharedApplication.StatusBarFrame; if (IsLandscape(orientation)) { orientationFrame.Size = new SizeF(orientationFrame.Size.Height, orientationFrame.Size.Width); statusBarFrame.Size = new SizeF(statusBarFrame.Size.Height, statusBarFrame.Size.Width); } float activeHeight = orientationFrame.Size.Height; if (keyboardHeight > 0) { activeHeight += statusBarFrame.Size.Height * 2; } activeHeight -= keyboardHeight; float posY = (float)Math.Floor(activeHeight * 0.45); float posX = orientationFrame.Size.Width / 2; if (!showToastCentered) { posY = activeHeight - 40; } PointF newCenter; float rotateAngle; switch (orientation) { case UIInterfaceOrientation.PortraitUpsideDown: rotateAngle = (float)Math.PI; newCenter = new PointF(posX, orientationFrame.Size.Height - posY); break; case UIInterfaceOrientation.LandscapeLeft: rotateAngle = (float)(-Math.PI / 2.0f); newCenter = new PointF(posY, posX); break; case UIInterfaceOrientation.LandscapeRight: rotateAngle = (float)(Math.PI / 2.0f); newCenter = new PointF(orientationFrame.Size.Height - posY, posX); break; default: // as UIInterfaceOrientationPortrait rotateAngle = 0.0f; newCenter = new PointF(posX, posY); break; } if (notification != null) { UIView.Animate(animationDuration, 0, UIViewAnimationOptions.AllowUserInteraction, delegate { MoveToPoint(newCenter, rotateAngle); }, null); } else { MoveToPoint(newCenter, rotateAngle); } }
public override void WillAnimateRotation(UIInterfaceOrientation toInterfaceOrientation, double duration) { base.WillAnimateRotation(toInterfaceOrientation, duration); }
public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { base.DidRotate(fromInterfaceOrientation); Web.Frame = View.Bounds; }
public override void WillAnimateSecondHalfOfRotation(UIInterfaceOrientation fromInterfaceOrientation, double duration) { _masterViewController.WillAnimateSecondHalfOfRotation(fromInterfaceOrientation, duration); _detailViewController.WillAnimateSecondHalfOfRotation(fromInterfaceOrientation, duration); }
public override bool ShouldAutorotateToInterfaceOrientation(UIInterfaceOrientation toInterfaceOrientation) { return(!UserInterfaceIdiomIsPhone || toInterfaceOrientation != UIInterfaceOrientation.PortraitUpsideDown); }
public override void DidAnimateFirstHalfOfRotation(UIInterfaceOrientation toInterfaceOrientation) { _masterViewController.DidAnimateFirstHalfOfRotation(toInterfaceOrientation); _detailViewController.DidAnimateFirstHalfOfRotation(toInterfaceOrientation); }
/// <summary> /// Called after the view rotated /// This override forwards the DidRotate callback on to each of the panel containers /// </summary> /// <param name="fromInterfaceOrientation">From interface orientation.</param> public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation) { base.DidRotate(fromInterfaceOrientation); _panelContainers.ForEach(c => c.DidRotate(fromInterfaceOrientation)); }
public override void WillAnimateFirstHalfOfRotation(UIInterfaceOrientation toInterfaceOrientation, double duration) { _masterViewController.WillAnimateFirstHalfOfRotation(toInterfaceOrientation, duration); _detailViewController.WillAnimateFirstHalfOfRotation(toInterfaceOrientation, duration); }
/// <summary> /// Called when the view will rotate. /// This override forwards the WillRotate callback on to each of the panel containers /// </summary> /// <param name="toInterfaceOrientation">To interface orientation.</param> /// <param name="duration">Duration.</param> public override void WillRotate(UIInterfaceOrientation toInterfaceOrientation, double duration) { base.WillRotate(toInterfaceOrientation, duration); _panelContainers.ForEach(c => c.WillRotate(toInterfaceOrientation, duration)); }
public override bool ShouldAutorotateToInterfaceOrientation(UIInterfaceOrientation toInterfaceOrientation) { // Return YES for supported orientations return(toInterfaceOrientation == UIInterfaceOrientation.Portrait); }
public override bool ShouldAutorotateToInterfaceOrientation(UIInterfaceOrientation toInterfaceOrientation) { return(AppDelegate.IsPad); }
public override bool ShouldAutorotateToInterfaceOrientation(UIInterfaceOrientation toInterfaceOrientation) { return(true); }
public override void WillRotate(UIInterfaceOrientation toInterfaceOrientation, double duration) { _ignoreNativeScrolling = true; }
public override bool ShouldAutorotateToInterfaceOrientation(UIInterfaceOrientation toInterfaceOrientation) { // Return true for supported orientations return(toInterfaceOrientation != UIInterfaceOrientation.PortraitUpsideDown); }
// [Obsolete] public override bool ShouldAutorotateToInterfaceOrientation(UIInterfaceOrientation toInterfaceOrientation) { // Return true for supported orientations return(true); // (toInterfaceOrientation == UIInterfaceOrientation.LandscapeLeft || toInterfaceOrientation == UIInterfaceOrientation.LandscapeRight); }