Qual è il modo migliore per aggiungere un'ombra esterna al mio UIView

Sto cercando di aggiungere un'ombra discendente alle viste che sono sovrapposte l'una sull'altra, le viste collassano consentendo di vedere il contenuto in altre viste, in questo senso voglio rimanere view.clipsToBoundsATTIVO in modo che quando le viste collassano il loro contenuto venga ritagliato.

Questo sembra aver reso difficile per me aggiungere un'ombra esterna ai livelli poiché quando accendo anche clipsToBoundsle ombre vengono tagliate.

Ho provato a manipolare view.framee view.boundsper aggiungere un'ombra esterna al fotogramma ma consentire ai bordi di essere abbastanza grandi da racchiuderlo, tuttavia non ho avuto fortuna con questo.

Ecco il codice che sto usando per aggiungere un'ombra (funziona solo con clipsToBoundsOFF come mostrato)

view.clipsToBounds = NO;
view.layer.shadowColor = [[UIColor blackColor] CGColor];
view.layer.shadowOffset = CGSizeMake(0,5);
view.layer.shadowOpacity = 0.5;

Ecco uno screenshot dell'ombra applicata allo strato grigio più chiaro in alto. Spero che questo dia un'idea di come il mio contenuto si sovrapporrà se clipsToBoundsè OFF.

Come posso aggiungere un'ombra al mio UIViewe mantenere il mio contenuto ritagliato?

Modifica: Volevo solo aggiungere che ho anche giocato con l'utilizzo di immagini di sfondo con le ombre, il che funziona bene, tuttavia mi piacerebbe comunque conoscere la migliore soluzione codificata per questo.

Prova questo:

UIBezierPath *shadowPath = [UIBezierPath bezierPathWithRect:view.bounds];
view.layer.masksToBounds = NO;
view.layer.shadowColor = [UIColor blackColor].CGColor;
view.layer.shadowOffset = CGSizeMake(0.0f, 5.0f);
view.layer.shadowOpacity = 0.5f;
view.layer.shadowPath = shadowPath.CGPath;

Prima di tutto : l' UIBezierPathusato come shadowPathè fondamentale. Se non lo usi, potresti non notare una differenza all'inizio, ma l'occhio attento osserverà un certo ritardo che si verifica durante eventi come la rotazione del dispositivo e / o simili. È un'importante modifica delle prestazioni.

Per quanto riguarda il tuo problema in particolare : la linea importante è view.layer.masksToBounds = NO. Disabilita il ritaglio dei sottolivelli della vista che si estendono oltre i limiti della vista.

Per coloro che si chiedono quale sia la differenza tra masksToBounds(sul livello) e la proprietà della vista clipToBounds: non ce n'è davvero. La commutazione di uno avrà un effetto sull'altro. Solo un diverso livello di astrazione.

Swift 2.2:

override func layoutSubviews()
{
    super.layoutSubviews()

    let shadowPath = UIBezierPath(rect: bounds)
    layer.masksToBounds = false
    layer.shadowColor = UIColor.blackColor().CGColor
    layer.shadowOffset = CGSizeMake(0.0, 5.0)
    layer.shadowOpacity = 0.5
    layer.shadowPath = shadowPath.CGPath
}

Swift 3:

override func layoutSubviews()
{
    super.layoutSubviews()

    let shadowPath = UIBezierPath(rect: bounds)
    layer.masksToBounds = false
    layer.shadowColor = UIColor.black.cgColor
    layer.shadowOffset = CGSize(width: 0.0, height: 5.0)
    layer.shadowOpacity = 0.5
    layer.shadowPath = shadowPath.cgPath
}

La risposta di Wasabii in Swift 2.3:

let shadowPath = UIBezierPath(rect: view.bounds)
view.layer.masksToBounds = false
view.layer.shadowColor = UIColor.blackColor().CGColor
view.layer.shadowOffset = CGSize(width: 0, height: 0.5)
view.layer.shadowOpacity = 0.2
view.layer.shadowPath = shadowPath.CGPath

E in Swift 3/4/5:

let shadowPath = UIBezierPath(rect: view.bounds)
view.layer.masksToBounds = false
view.layer.shadowColor = UIColor.black.cgColor
view.layer.shadowOffset = CGSize(width: 0, height: 0.5)
view.layer.shadowOpacity = 0.2
view.layer.shadowPath = shadowPath.cgPath

Inserisci questo codice in layoutSubviews () se stai usando AutoLayout.

In SwiftUI, tutto questo è molto più semplice:

Color.yellow  // or whatever your view
    .shadow(radius: 3)
    .frame(width: 200, height: 100)

Il trucco è definire masksToBoundscorrettamente la proprietà del livello della vista:

view.layer.masksToBounds = NO;

e dovrebbe funzionare.

( Fonte )

È possibile creare un'estensione per UIView per accedere a questi valori nell'editor di progettazione

extension UIView{

    @IBInspectable var shadowOffset: CGSize{
        get{
            return self.layer.shadowOffset
        }
        set{
            self.layer.shadowOffset = newValue
        }
    }

    @IBInspectable var shadowColor: UIColor{
        get{
            return UIColor(cgColor: self.layer.shadowColor!)
        }
        set{
            self.layer.shadowColor = newValue.cgColor
        }
    }

    @IBInspectable var shadowRadius: CGFloat{
        get{
            return self.layer.shadowRadius
        }
        set{
            self.layer.shadowRadius = newValue
        }
    }

    @IBInspectable var shadowOpacity: Float{
        get{
            return self.layer.shadowOpacity
        }
        set{
            self.layer.shadowOpacity = newValue
        }
    }
}

Puoi anche impostare l'ombra sulla tua vista dallo storyboard

In mostra WillLayoutSubviews:

override func viewWillLayoutSubviews() {
    sampleView.layer.masksToBounds =  false
    sampleView.layer.shadowColor = UIColor.darkGrayColor().CGColor;
    sampleView.layer.shadowOffset = CGSizeMake(2.0, 2.0)
    sampleView.layer.shadowOpacity = 1.0
}

Utilizzo dell'estensione di UIView:

extension UIView {

    func addDropShadowToView(targetView:UIView? ){
        targetView!.layer.masksToBounds =  false
        targetView!.layer.shadowColor = UIColor.darkGrayColor().CGColor;
        targetView!.layer.shadowOffset = CGSizeMake(2.0, 2.0)
        targetView!.layer.shadowOpacity = 1.0
    }
}

Uso:

sampleView.addDropShadowToView(sampleView)

Quindi sì, dovresti preferire la proprietà shadowPath per le prestazioni, ma anche: Dal file di intestazione di CALayer.shadowPath

Specificare il percorso in modo esplicito utilizzando questa proprietà di solito * migliorerà le prestazioni di rendering, così come la condivisione dello stesso riferimento * del percorso su più livelli

Un trucco meno noto è condividere lo stesso riferimento su più livelli. Ovviamente devono usare la stessa forma, ma questo è comune con le celle della vista tabella / raccolta.

Non so perché diventi più veloce se condividi istanze, immagino che memorizzi nella cache il rendering dell'ombra e possa riutilizzarlo per altre istanze nella vista. Mi chiedo se questo sia ancora più veloce con