Différentes dispositions en mode portrait et paysage
Supposons que j'ai cette conception de mise en page sur un portrait iPad.
Mais j'aimerais qu'il en soit ainsi lorsque l'iPad est en paysage: 
Est-il possible de le faire avec la mise en page automatique? Ou avec une petite quantité de code?
Remarque - les réponses ici sont bonnes et résolvent le problème, mais sur les anciennes versions d'iOS.
Pour iOS11 (Xcode 9), vous devriez considérer les dispositions adaptatives comme référencé ici: https://www.raywenderlich.com/162311/adaptive -layout-tutorial-ios-11-getting-started
Vous pouvez y parvenir grâce au code Tout d'abord, vous devez faire IBoutlet de vos contraintes dynamiques
Contrainte constante: // ces contraintes resteront les mêmes dans les deux orientations
1- RedView top Space to Superview
2- RedView Trailing Space à Superview
3- BlueView mène l'espace à Superview
4- Espace inférieur BlueView vers SuperView
Contrainte dynamique
Contrainte Portrait:
1- Hauteur RedView
2- Espace vertical RedView vers BlueView
3- RedView mène l'espace à Superview
4- BlueView Trailing Space à Superview
Contrainte LandScape:
1- Largeur RedView
2- RedView Horizontal Space à BlueView
3- RedView bottom Space to Superview
4- BlueView Top Space à Superview
Maintenant, vous devez remplacer la méthode qui est appelée lors d'un changement d'orientation
override func viewWillTransitionToSize(size: CGSize, withTransitionCoordinator coordinator: UIViewControllerTransitionCoordinator) {
coordinator.animateAlongsideTransition({ (UIViewControllerTransitionCoordinatorContext) -> Void in
let orient = UIApplication.sharedApplication().statusBarOrientation
switch orient {
case .Portrait:
print("Portrait")
self.ApplyportraitConstraint()
break
// Do something
default:
print("LandScape")
// Do something else
self.applyLandScapeConstraint()
break
}
}, completion: { (UIViewControllerTransitionCoordinatorContext) -> Void in
print("rotation completed")
})
super.viewWillTransitionToSize(size, withTransitionCoordinator: coordinator)
}
Et appelez ces 2 fonctions
Fonction d'orientation portrait
func ApplyportraitConstraint(){
self.view.addConstraint(self.RedViewHeight)
self.view.addConstraint(self.RedView_VerticalSpace_To_BlueView)
self.view.addConstraint(self.RedView_LeadingSpace_To_SuperView)
self.view.addConstraint(self.BlueView_TrailingSpace_To_SuperView)
self.view.removeConstraint(self.RedViewWidth)
self.view.removeConstraint(self.RedView_HorizontalSpace_To_BlueView)
self.view.removeConstraint(self.RedView_BottomSpace_To_SuperView)
self.view.removeConstraint(self.BlueView_TopSpace_To_SuperView)
}
Fonction d'orientation LandScape
func applyLandScapeConstraint(){
self.view.removeConstraint(self.RedViewHeight)
self.view.removeConstraint(self.RedView_VerticalSpace_To_BlueView)
self.view.removeConstraint(self.RedView_LeadingSpace_To_SuperView)
self.view.removeConstraint(self.BlueView_TrailingSpace_To_SuperView)
self.view.addConstraint(self.RedViewWidth)
self.view.addConstraint(self.RedView_HorizontalSpace_To_BlueView)
self.view.addConstraint(self.RedView_BottomSpace_To_SuperView)
self.view.addConstraint(self.BlueView_TopSpace_To_SuperView)
}
Portrait d'écran:
Capture d'écran LandScape:
J'espère que cela vous aidera à le comprendre grâce à la gestion de la mise en page grâce au codage. Si vous ne parvenez toujours pas à comprendre, veuillez vérifier mon code sur
Si vous avez des avertissements, définissez simplement la priorité des contraintes de hauteur et de largeur sur 999.
iPAD n'a pas la classe de taille pour le mode paysage. Je pense que la raison en est que ce n'est pas nécessaire dans la plupart des cas. Cependant, on peut activer et désactiver les contraintes lorsque l'orientation de l'appareil change comme la réponse acceptée.
Les informations suivantes peuvent être utiles aux utilisateurs d'iPhone.
Oui, cela est possible dans le constructeur d'interface avec la mise en page automatique et les classes de taille. Vous n'aurez pas besoin de coder.
Vous sélectionnez d'abord la classe de taille wAny hAny
Ici est de savoir comment sélectionner la classe de taille.
Ajoutez deux vues dans votre contrôleur de vue. Vue rouge en haut et vue bleue en dessous. Tout comme votre première image.
Les contraintes sur la vue rouge sont:
- Espace supérieur pour une vue superbe
- Espace leader pour une vue superbe
- Espace de fuite pour une vue superbe
- hauteur = 50
Les contraintes sur la vue bleue sont:
- espace vertical à vue rouge
- menant l'espace à la super vue
- espace de fuite pour une vue superbe
- espace inférieur pour une vue superbe
Tout est réglé pour le mode Potrait.
Maintenant, vous changez les classes de taille en wAny hCompact (Les deux premières colonnes de la première ligne). cette classe est pour le paysage iPhone.
Maintenant, vous devez utiliser installer et désinstaller le concept.
Contraintes qui changeront pour la vue rouge:
- Désinstallez sa constante de hauteur pour la classe de taille (wAny hCompact) en tant que:
- De même, désinstallez sa contrainte Leading. Ajoutez deux nouvelles contraintes à cette vue rouge dans cette classe:
- Espace inférieur à superview
- Contrainte de largeur = 50
Cela rendra la vue rouge sur le côté droit avec une largeur de 50.
Maintenant, changement de contrainte pour la vue bleue:
- Désinstaller son espacement vertical, espace de fuite.
Ajoutez deux nouvelles contraintes:
- Espace vertical pour une vue superbe
- Espace de fin en rouge Voir
Cela attachera la vue rouge à gauche de la vue bleue.
J'espère que cela fonctionnera pour vous.
Est-il possible de le faire avec la mise en page automatique? Ou avec une petite quantité de code?
Vous aurez besoin des deux pour faire ces dispositions pour un iPad.
- Définissez vos contraintes de disposition pour chaque vue, ne définissez pas les contraintes de largeur ou de hauteur pour ces vues.
- Câblez IBOutlets pour chaque contrainte sur les vues un et deux.
Implémentez protocole UIContentContainer dans votre contrôleur de vue.
viewWillTransitionToSize(_ size: CGSize,withTransitionCoordinator coordinator: UIViewControllerTransitionCoordinator)
Discussion UIKit appelle cette méthode avant de modifier la taille de la vue d'un contrôleur de vue présenté. Vous pouvez remplacer cette méthode dans vos propres objets et l'utiliser pour effectuer des tâches supplémentaires liées au changement de taille. Par exemple, un contrôleur de vue de conteneur peut utiliser cette méthode pour remplacer les traits de ses contrôleurs de vue enfant intégrés. Utilisez l'objet coordinateur fourni pour animer toutes les modifications que vous apportez.
Si vous remplacez cette méthode dans vos contrôleurs de vue personnalisés, appelez toujours super à un moment donné de votre implémentation afin qu'UIKit puisse transférer le message de changement de taille de manière appropriée. Les contrôleurs de vue transmettent le message de changement de taille à leurs vues et aux contrôleurs de vue enfant. Les contrôleurs de présentation transmettent le changement de taille à leur contrôleur de vue présenté.
Est la méthode que vous devez implémenter. À l'intérieur de cette méthode, vous devrez inspecter la largeur et la hauteur des propriétés de la taille pour déterminer comment votre mise en page doit changer - c'est-à-dire la mise en page paysage ou portrait. Notez que cette méthode indique qu'elle [~ # ~] [~ # ~] changera en taille transmise.
- Ajustez vos contraintes en fonction de la rotation de l'appareil en mode portrait ou paysage.
J'ai implémenté cela avec Obj-C et publié sur mon github La solution implique un peu de code, et la plupart du travail est concentré sur AutoLayout et les conventions de dénomination ... Le README explique comment je l'ai fait. Le code que j'ai utilisé sur le ViewController est essentiellement cette méthode:
- (void)setUpViewConstraintsForInterfaceOrientation:(InterfaceOrientation)interfaceOrientation {
self.lastOrientation = interfaceOrientation;
if (interfaceOrientation == Landscape) {
[NSLayoutConstraint deactivateConstraints:self.portraitConstraintsCollection];
[NSLayoutConstraint activateConstraints:self.landscapeConstraintsCollection];
} else if(interfaceOrientation == Portrait){
[NSLayoutConstraint deactivateConstraints:self.landscapeConstraintsCollection];
[NSLayoutConstraint activateConstraints:self.portraitConstraintsCollection];
}
[self.view layoutIfNeeded];
}
portraitConstraintsCollection et landscapeConstraintsCollection sont des propriétés IBOutletCollection pour gérer les contraintes spécifiques de l'orientation.
Et la solution de mise en page automatique ne fonctionne qu'avec l'installation et la désinstallation de contraintes (activer et désactiver), pas besoin d'ajouter ou de supprimer des contraintes.
Ma tâche était similaire en général. J'avais besoin de contraintes de portrait et de paysage pour iPhone et iPad. De plus, l'emplacement des vues jaunes et grises doit être le même en général, mais la largeur de la vue jaune doit être différente dans le paysage iPhone et dans le paysage iPad (40% de l'écran sur iPhone et 60% de l'écran sur iPad): - 
Contraintes pour les orientations de l'iPhone que j'ai définies en utilisant des collections de traits et en définissant pour chaque contrainte quelle collection il doit être installé. Pour l'iPhone, il existe wChR (portrait) et wChC (paysage). Ou wC avec hAny:
Mais pour les orientations paysage et portrait sur iPad, les collections de traits uniques sont utilisées (wRhR), par conséquent, la méthode utilisée pour iPhone n'est pas appropriée. Pour changer les contraintes de ces cas, je prévois deux ensembles de contraintes (le premier pour iPad en paysage et le second pour iPad en portrait):
@property (strong, nonatomic) IBOutletCollection(NSLayoutConstraint) NSArray *ipadLandscapeConstraints;
@property (strong, nonatomic) IBOutletCollection(NSLayoutConstraint) NSArray *ipadPortraitConstraints;
Remarque: 1. Pour ce faire, sélectionnez plusieurs contraintes requises dans le storyboard et connectez-les à votre fichier .m. Pour voir quelles contraintes ont été ajoutées au tableau, cliquez sur le bouton ‘+’ à gauche pour la propriété dans le fichier .m: 
2. J'ai utilisé la priorité des contraintes pour résoudre les conflits de contraintes pour iPad
Enfin, j'ai implémenté la méthode configConstraints pour changer les ensembles de contraintes en fonction de l'orientation de l'iPad et j'ai remplacé la méthode viewWillTransitionToSize:
- (void)viewWillTransitionToSize:(CGSize)size withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator {
[super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];
[self configConstraints];
}
- (void)configConstraints {
if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
// iPad landscape orientation
if (UIDeviceOrientationIsLandscape([UIDevice currentDevice].orientation)) {
[NSLayoutConstraint deactivateConstraints:self.ipadPortraitConstraints];
[NSLayoutConstraint activateConstraints:self.ipadLandscapeConstraints];
}
// iPad portrait orientation
else {
[NSLayoutConstraint deactivateConstraints:self.ipadLandscapeConstraints];
[NSLayoutConstraint activateConstraints:self.ipadPortraitConstraints];
}
[self.view layoutIfNeeded];
}
}
Il se peut qu'il soit nécessaire d'appeler la méthode configConstraints dans d'autres endroits où la vue se charge ou apparaît, mais l'idée de base est décrite ci-dessus.
il est beaucoup plus facile de placer ces deux vues dans une vue de pile et de changer l'orientation de l'axe pour la vue de pile.
- créer une référence IBOulet à la stackview
- implémenter viewWillTransitionToSize
- changer l'axe pour chaque orientation en faisant self.stackView.axis = .vertical ou .horizontal
La seule façon d'y parvenir facilement, donc cela fonctionne sur les iPads et les iPhones, c'est de le faire par programmation. Cela se fait avec Swift 5.0 dans Xcode 10.2.
Dans votre ViewController, définissez les deux vues que vous souhaitez modifier en fonction de l'orientation:
@IBOutlet weak var raceInfoView: UIStackView!
@IBOutlet weak var raceListView: UITableView!
Définissez ensuite les contraintes qui resteront toujours les mêmes dans votre storyboard et définissez celles qui changeront dans votre ViewController.
private var portraitRaceInfoViewTrailing: NSLayoutConstraint!
private var portraitRaceInfoViewBottom: NSLayoutConstraint!
private var portraitRaceListViewLeading: NSLayoutConstraint!
private var landscapeRaceInfoViewTrailing: NSLayoutConstraint!
private var landscapeRaceInfoViewBottom: NSLayoutConstraint!
private var landscapeRaceListViewTop: NSLayoutConstraint!
Ensuite, initialisez les contraintes, je l'ai mis dans viewDidLoad mais il peut probablement être mis ailleurs.
override func viewDidLoad() {
super.viewDidLoad()
portraitRaceInfoViewTrailing = NSLayoutConstraint(
item: racesView as Any, attribute: NSLayoutConstraint.Attribute.trailing,
relatedBy: NSLayoutConstraint.Relation.equal,
toItem: raceInfoView, attribute: NSLayoutConstraint.Attribute.trailing,
multiplier: 1, constant: 0)
portraitRaceInfoViewBottom = NSLayoutConstraint(
item: raceListView as Any, attribute: NSLayoutConstraint.Attribute.top,
relatedBy: NSLayoutConstraint.Relation.equal,
toItem: raceInfoView, attribute: NSLayoutConstraint.Attribute.bottom,
multiplier: 1, constant: 0)
portraitRaceListViewLeading = NSLayoutConstraint(
item: raceListView as Any, attribute: NSLayoutConstraint.Attribute.leading,
relatedBy: NSLayoutConstraint.Relation.equal,
toItem: racesView, attribute: NSLayoutConstraint.Attribute.leading,
multiplier: 1, constant: 0)
landscapeRaceInfoViewTrailing = NSLayoutConstraint(
item: raceListView as Any, attribute: NSLayoutConstraint.Attribute.leading,
relatedBy: NSLayoutConstraint.Relation.equal,
toItem: raceInfoView, attribute: NSLayoutConstraint.Attribute.trailing,
multiplier: 1, constant: 0)
landscapeRaceInfoViewBottom = NSLayoutConstraint(
item: raceInfoView as Any, attribute: NSLayoutConstraint.Attribute.bottom,
relatedBy: NSLayoutConstraint.Relation.equal,
toItem: racesView, attribute: NSLayoutConstraint.Attribute.bottom,
multiplier: 1, constant: 0)
landscapeRaceListViewTop = NSLayoutConstraint(
item: raceListView as Any, attribute: NSLayoutConstraint.Attribute.top,
relatedBy: NSLayoutConstraint.Relation.equal,
toItem: racesView, attribute: NSLayoutConstraint.Attribute.top,
multiplier: 1, constant: 0)
applyOrientationConstraints()
}
Déclarer des contraintes par programme semble un peu effrayant, mais c'est en fait assez facile. Vous pouvez créer la contrainte dans votre storyboard et afficher toutes les valeurs et copier les bonnes au bon endroit dans le code.
Et enfin dans viewDidLoad, appliquez les contraintes avec applyOrientationConstraints().
func applyOrientationConstraints() {
let orient = UIApplication.shared.statusBarOrientation
switch orient {
case .portrait:
NSLayoutConstraint.activate([portraitRaceInfoViewTrailing, portraitRaceInfoViewBottom, portraitRaceListViewLeading])
NSLayoutConstraint.deactivate([landscapeRaceInfoViewTrailing, landscapeRaceInfoViewBottom, landscapeRaceListViewTop])
break
default:
NSLayoutConstraint.deactivate([portraitRaceInfoViewTrailing, portraitRaceInfoViewBottom, portraitRaceListViewLeading])
NSLayoutConstraint.activate([landscapeRaceInfoViewTrailing, landscapeRaceInfoViewBottom, landscapeRaceListViewTop])
break
}
}
Et enfin, remplacez viewWillTransition pour appliquer les contraintes lorsque l'orientation change.
override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
coordinator.animate(alongsideTransition: { (UIViewControllerTransitionCoordinatorContext) -> Void in
self.applyOrientationConstraints()
}, completion: { (UIViewControllerTransitionCoordinatorContext) -> Void in
print("rotation completed")
})
super.viewWillTransition(to: size, with: coordinator)
}
mes deux cents .. Swift 5:
(pls connecter la sortie ..)
//
// ViewController.Swift
// AutoLayoutSampleOnRotation
//
// Created by ing.conti on 13/09/2019.
// Copyright © 2019 ing.conti. All rights reserved.
//
import UIKit
class ViewController: UIViewController {
@IBOutlet weak var redView: UIView!
@IBOutlet weak var yellowView: UIView!
private var red_TopPortrait : NSLayoutConstraint?
private var red_TopLandscape : NSLayoutConstraint?
private var red_LeftPortrait : NSLayoutConstraint?
private var red_LeftLandscape : NSLayoutConstraint?
private var red_RightPortrait : NSLayoutConstraint?
private var red_RightLandscape : NSLayoutConstraint?
private var red_BottomPortrait : NSLayoutConstraint?
private var red_BottomLandscape : NSLayoutConstraint?
private var red_HeightPortrait : NSLayoutConstraint?
private var red_WidthLandscape : NSLayoutConstraint?
///
private var yellow_TopPortrait : NSLayoutConstraint?
private var yellow_TopLandscape : NSLayoutConstraint?
private var yellow_LeftPortrait : NSLayoutConstraint?
private var yellow_LeftLandscape : NSLayoutConstraint?
private var yellow_RightPortrait : NSLayoutConstraint?
private var yellow_RightLandscape : NSLayoutConstraint?
private var yellow_BottomPortrait : NSLayoutConstraint?
private var yellow_BottomLandscape : NSLayoutConstraint?
private let H_SpaceBetween = CGFloat(20)
private let V_SpaceBetween = CGFloat(50)
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view.
redView.translatesAutoresizingMaskIntoConstraints = false
yellowView.translatesAutoresizingMaskIntoConstraints = false
buildConstraintsForRed()
buildConstraintsForYellow()
applyConstraints()
}
final private func buildConstraintsForRed(){
let portraitTopMargin = CGFloat(70)
let portraitLeftMargin = CGFloat(70)
let portraitRightMargin = CGFloat(70)
let landscapeTopMargin = CGFloat(70)
let landscapeLeftMargin = CGFloat(70)
let landscapeBottomMargin = CGFloat(70)
// TOP P
red_TopPortrait = NSLayoutConstraint(item: redView as Any,
attribute: .top,
relatedBy: .equal,
toItem: self.view,
attribute: .top,
multiplier: 1,
constant: portraitTopMargin)
red_TopPortrait!.identifier = "red_TopPortrait"
// LEFT-Heading P
red_LeftPortrait = NSLayoutConstraint(item: redView as Any,
attribute: .leading,
relatedBy: .equal,
toItem: self.view,
attribute: .leading,
multiplier: 1,
constant: portraitLeftMargin)
red_LeftPortrait!.identifier = "red_LeftPortrait"
// RIGHT - trailing P
red_RightPortrait = NSLayoutConstraint(item: redView as Any,
attribute: .trailing,
relatedBy: .equal,
toItem: self.view,
attribute: .trailing,
multiplier: 1,
constant: -portraitRightMargin)
red_RightPortrait!.identifier = "red_RightPortrait"
// BOTTOM: P
red_BottomPortrait = NSLayoutConstraint(item: redView as Any,
attribute: .bottom,
relatedBy: .equal,
toItem: yellowView,
attribute: .top,
multiplier: 1,
constant: -V_SpaceBetween)
red_BottomPortrait!.identifier = "red_BottomPortrait"
// HEIGHT: P
red_HeightPortrait = NSLayoutConstraint(item: redView as Any,
attribute: .height,
relatedBy: .equal,
toItem: self.view,
attribute: .height,
multiplier: 0.3,
constant: 0)
red_HeightPortrait?.identifier = "red_HeightPortrait"
//LANDSCAPE
// TOP L
red_TopLandscape = NSLayoutConstraint(item: redView as Any,
attribute: .top,
relatedBy: .equal,
toItem: self.view,
attribute: .top,
multiplier: 1,
constant: landscapeTopMargin)
red_TopLandscape!.identifier = "red_TopLandscape"
// LEFT-Heading L
red_LeftLandscape = NSLayoutConstraint(item: redView as Any,
attribute: .leading,
relatedBy: .equal,
toItem: self.view,
attribute: .leading,
multiplier: 1,
constant: landscapeLeftMargin)
red_LeftLandscape!.identifier = "red_LeftLandscape"
// RIGHT - trailing L
red_RightLandscape = NSLayoutConstraint(item: redView as Any,
attribute: .trailing,
relatedBy: .equal,
toItem: yellowView,
attribute: .leading,
multiplier: 1,
constant: -H_SpaceBetween)
red_RightLandscape!.identifier = "red_RightLandscape"
// BOTTOM: L
red_BottomLandscape = NSLayoutConstraint(item: redView as Any,
attribute: .bottom,
relatedBy: .equal,
toItem: self.view,
attribute: .bottom,
multiplier: 1,
constant: -landscapeBottomMargin)
red_BottomLandscape?.identifier = "red_BottomLandscape"
// Width L:
red_WidthLandscape = NSLayoutConstraint(item: redView as Any,
attribute: .width,
relatedBy: .equal,
toItem: self.view,
attribute: .width,
multiplier: 0.3,
constant: 0)
red_WidthLandscape!.identifier = "red_WidthLandscape"
}
final private func buildConstraintsForYellow(){
let portraitLeftMargin = CGFloat(20)
let portraitRightMargin = CGFloat(20)
//let portraitHorizMargin = CGFloat(100)
let portraitBottomMargin = CGFloat(20)
let landscaspeTopMargin = CGFloat(20)
let landscaspeRightMargin = CGFloat(20)
let landscapeBottomMargin = CGFloat(20)
// TOP P
yellow_TopPortrait = NSLayoutConstraint(item: yellowView as Any,
attribute: .top,
relatedBy: .equal,
toItem: redView,
attribute: .bottom,
multiplier: 1,
constant: V_SpaceBetween)
yellow_TopPortrait!.identifier = "yellow_TopPortrait"
// LEFT-Heading P
yellow_LeftPortrait = NSLayoutConstraint(item: yellowView as Any,
attribute: .leading,
relatedBy: .equal,
toItem: self.view,
attribute: .leading,
multiplier: 1,
constant: portraitLeftMargin)
yellow_LeftPortrait!.identifier = "yellow_LeftPortrait"
// RIGHT - trailing P
yellow_RightPortrait = NSLayoutConstraint(item: yellowView as Any,
attribute: .trailing,
relatedBy: .equal,
toItem: self.view,
attribute: .trailing,
multiplier: 1,
constant: -portraitRightMargin)
yellow_RightPortrait!.identifier = "yellow_RightPortrait"
// BOTTOM: P
yellow_BottomPortrait = NSLayoutConstraint(item: yellowView as Any,
attribute: .bottom,
relatedBy: .equal,
toItem: self.view,
attribute: .bottom,
multiplier: 1,
constant: -portraitBottomMargin)
yellow_BottomPortrait!.identifier = "yellow_BottomPortrait"
//LANDSSCAPE
// TOP L
yellow_TopLandscape = NSLayoutConstraint(item: yellowView as Any,
attribute: .top,
relatedBy: .equal,
toItem: self.view,
attribute: .top,
multiplier: 1,
constant: landscaspeTopMargin)
yellow_TopLandscape!.identifier = "yellow_TopLandscape"
// LEFT-Heading L
yellow_LeftLandscape = NSLayoutConstraint(item: yellowView as Any,
attribute: .leading,
relatedBy: .equal,
toItem: self.redView,
attribute: .trailing,
multiplier: 1,
constant: H_SpaceBetween)
yellow_LeftLandscape!.identifier = "yellow_LeftLandscape"
// RIGHT - trailing L
yellow_RightLandscape = NSLayoutConstraint(item: yellowView as Any,
attribute: .trailing,
relatedBy: .equal,
toItem: self.view,
attribute: .trailing,
multiplier: 1,
constant: -landscaspeRightMargin)
yellow_RightLandscape!.identifier = "yellow_RightLandscape"
// BOTTOM: L
yellow_BottomLandscape = NSLayoutConstraint(item: yellowView as Any,
attribute: .bottom,
relatedBy: .equal,
toItem: self.view,
attribute: .bottom,
multiplier: 1,
constant: -landscapeBottomMargin)
yellow_BottomLandscape!.identifier = "yellow_BottomLandscape"
}
final private func removeRedConstraints() {
if let c = red_LeftPortrait {self.view.removeConstraint(c)}
if let c = red_LeftLandscape {self.view.removeConstraint(c)}
if let c = red_RightPortrait {self.view.removeConstraint(c)}
if let c = red_RightLandscape {self.view.removeConstraint(c)}
if let c = red_TopPortrait {self.view.removeConstraint(c)}
if let c = red_TopLandscape {self.view.removeConstraint(c)}
if let c = red_BottomPortrait {self.view.removeConstraint(c)}
if let c = red_BottomLandscape {self.view.removeConstraint(c)}
if let c = red_HeightPortrait {self.view.removeConstraint(c)}
if let c = red_WidthLandscape {self.view.removeConstraint(c)}
}
final private func removeYellowConstraints() {
if let c = yellow_LeftPortrait {self.view.removeConstraint(c)}
if let c = yellow_LeftLandscape {self.view.removeConstraint(c)}
if let c = yellow_RightPortrait {self.view.removeConstraint(c)}
if let c = yellow_RightLandscape {self.view.removeConstraint(c)}
if let c = yellow_TopPortrait {self.view.removeConstraint(c)}
if let c = yellow_TopLandscape {self.view.removeConstraint(c)}
if let c = yellow_BottomPortrait {self.view.removeConstraint(c)}
if let c = yellow_BottomLandscape {self.view.removeConstraint(c)}
}
final private func applyPortraitConstraint(){
removeRedConstraints()
removeYellowConstraints()
self.view.addConstraint(self.red_LeftPortrait!)
self.view.addConstraint(self.red_RightPortrait!)
self.view.addConstraint(self.red_TopPortrait!)
self.view.addConstraint(self.red_BottomPortrait!)
self.view.addConstraint(self.red_HeightPortrait!)
self.view.addConstraint(self.yellow_LeftPortrait!)
self.view.addConstraint(self.yellow_RightPortrait!)
self.view.addConstraint(self.yellow_TopPortrait!)
self.view.addConstraint(self.yellow_BottomPortrait!)
}
final private func applyLandscapeConstraint(){
removeRedConstraints()
removeYellowConstraints()
self.view.addConstraint(self.red_LeftLandscape!)
self.view.addConstraint(self.red_RightLandscape!)
self.view.addConstraint(self.red_TopLandscape!)
self.view.addConstraint(self.red_BottomLandscape!)
self.view.addConstraint(self.red_WidthLandscape!)
self.view.addConstraint(self.yellow_LeftLandscape!)
self.view.addConstraint(self.yellow_RightLandscape!)
self.view.addConstraint(self.yellow_TopLandscape!)
self.view.addConstraint(self.yellow_BottomLandscape!)
}
final private func applyConstraints(){
let orient = UIApplication.shared.statusBarOrientation
switch orient {
case .portrait:
print("Portrait")
self.applyPortraitConstraint()
break
// Do something
default:
print("LandScape")
// Do something else
self.applyLandscapeConstraint()
break
}
}
override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
coordinator.animate(alongsideTransition: { (UIViewControllerTransitionCoordinatorContext) -> Void in
self.applyConstraints()
}, completion: { (UIViewControllerTransitionCoordinatorContext) -> Void in
print("rotation completed")
})
super.viewWillTransition(to: size, with: coordinator)
}
}
