Ios UIView阴影和界面生成器_Ios_Interface Builder_Core Graphics

Ios UIView阴影和界面生成器

ios

Ios UIView阴影和界面生成器,ios,interface-builder,core-graphics,Ios,Interface Builder,Core Graphics,我想使用CALayer向UI（图像）视图添加阴影。下面的代码通常运行良好 previewImage.layer.shadowColor = [[UIColor blackColor] CGColor]; previewImage.layer.shadowOffset = CGSizeMake(1.0f, 1.0f); previewImage.layer.shadowOpacity = 1.0f; previewImage.layer.shadowRadius = 8.0f; 但是，只有以编

我想使用CALayer向UI（图像）视图添加阴影。下面的代码通常运行良好

previewImage.layer.shadowColor = [[UIColor blackColor] CGColor];
previewImage.layer.shadowOffset = CGSizeMake(1.0f, 1.0f);
previewImage.layer.shadowOpacity = 1.0f;
previewImage.layer.shadowRadius = 8.0f;

但是，只有以编程方式创建该视图并将其作为子视图添加到主视图中时，这才有效。如果在InterfaceBuilder中设置该视图并将其定义为IBUIImageView，则该视图不起作用。没有阴影出现。

那么我在这里遗漏了什么呢？

我不确定问题出在哪里-请确保您的

UIImageView

的

clipstobunds

属性设置为

NO

。从nib文件加载后，您可以在

viewDidLoad

中通过引用IBOutlet来执行此操作。您不需要在另一个视图中包装它。

编辑

鉴于您需要使用纵横比填充来缩放图像，您可以使用

UIImageView

底层的

contentsRect

属性来“模拟”内容剪辑的效果

contentsRect

是图层内容（在本例中为图像）单位坐标空间中的矩形，定义了应绘制内容的子矩形

通过一点数学运算，我们可以通过比较图像视图大小和图像大小（考虑纵横比填充比例）来找到这个矩形：

执行此操作后，您可以将图像视图的

clipstobunds

设置为

NO

，但图像仍将显示为剪裁。如果需要更改图像视图的大小，可以方便地将此代码包装到一个方法中，该方法将

UIImageView

作为参数

我希望这能有所帮助。

我知道这个问题已经问了很久了，但最近我遇到了类似的情况，所以我决定把我的答案留给那些处于这种情况的人

我想通过界面生成器在

UIView

上设置

borderColor

和

shadowColor

，但是图层的

borderColor

属性的类型是

CGColor

（就像

shadowColor

）这不是用户定义的运行时属性功能中允许更改的类型之一

因此，我对

CALayer

进行了扩展，并添加了两个名为borderColorIB和shadowColorIB的UIColor类型属性：

RuntimeAttributes.h

@import QuartzCore;

@interface CALayer (IBConfiguration)

@property(nonatomic, assign) UIColor* borderColorIB;
@property(nonatomic, assign) UIColor* shadowColorIB;

@end

RuntimeAttributes.m

#import <UIKit/UIKit.h>
#import "RuntimeAttributes.h"

@implementation CALayer (IBConfiguration)

-(void)setBorderColorIB:(UIColor*)color
{
    self.borderColor = color.CGColor;
}

-(UIColor*)borderColorIB
{
    return [UIColor colorWithCGColor:self.borderColor];
}

-(void)setShadowColorIB:(UIColor*)color
{
    self.shadowColor = color.CGColor;
}

-(UIColor*)shadowColorIB
{
    return [UIColor colorWithCGColor:self.shadowColor];
}

@end

#导入
#导入“RuntimeAttributes.h”
@实现CALayer（IBConfiguration）
-（void）setBorderColorIB:（UIColor*）颜色
{
self.borderColor=color.CGColor；
}
-（UIColor*）边框颜色B
{
返回[UIColor colorWithCGColor:self.borderColor]；
}
-（void）setShadowColorIB:（UIColor*）颜色
{
self.shadowColor=color.CGColor；
}
-（UIColor*）shadowColorIB
{
返回[UIColor colorWithCGColor:self.shadowColor]；
}
@结束

现在我可以通过Interface Builder设置这两个属性，如下所示：

在“用户定义的运行时属性”部分（标识检查器）

确保选中UIView，并添加以下运行时属性：

图层。边框宽度，编号，1

layer.borderColorIB、Color、someColor

在项目中添加一个名为UIView.swift的文件（或将其粘贴到任何文件中）：
然后，对于“实用程序”面板>“属性检查器”中的每个视图，Interface Builder中都会提供此选项：

现在可以轻松设置阴影
注：

-阴影仅在运行时出现。

-clipstobunds
应为false（默认情况下为）
UIView shadow with corner radius+interface builder-swift4
    extension UIView {

        @IBInspectable
        var cornerRadius: CGFloat {
            get {
                return layer.cornerRadius
            }
            set {
                layer.cornerRadius = newValue
                if shadowOpacity > 0.0 {
                    layer.masksToBounds = false
                }
                else {
                    layer.masksToBounds = true
                }
            }
        }
      @IBInspectable
        var borderWidth: CGFloat {
            get {
                return layer.borderWidth
            }
            set {
                layer.borderWidth = newValue
            }
        }
    @IBInspectable
        var borderColor: UIColor? {
            get {
                if let color = layer.borderColor {
                    return UIColor(cgColor: color)
                }
                return nil
            }
            set {
                if let color = newValue {
                    layer.borderColor = color.cgColor
                } else {
                    layer.borderColor = nil
                }
            }
      @IBInspectable var shadowColor: UIColor? {
            set {
                layer.shadowColor = newValue!.cgColor
            }
            get {
                if let color = layer.shadowColor {
                    return UIColor(cgColor: color)
                }
                else {
                    return nil
                }
            }
        }
       @IBInspectable var shadowOpacity: Float {
            set {
                layer.shadowOpacity = newValue
            }
            get {
                return layer.shadowOpacity
            }
        }
     @IBInspectable var shadowOffset: CGPoint {
            set {
                layer.shadowOffset = CGSize(width: newValue.x, height: newValue.y)
            }
            get {
                return CGPoint(x: layer.shadowOffset.width, y:layer.shadowOffset.height)
            }
        }
     @IBInspectable var shadowRadius: CGFloat {
            set {
                layer.shadowRadius = newValue
            }
            get {
                return layer.shadowRadius
            }
        }
}

mauricioconde答案的Swift 5 Xcode 11.3.1版本。请注意，如果没有@IBInspectable，它将无法工作
import UIKit
import QuartzCore

extension CALayer {

    @IBInspectable
    var shadowUIColor: UIColor? {
        get { shadowColor != nil ? UIColor(cgColor: shadowColor!) : nil }
        set { shadowColor = newValue?.cgColor }
    }
}

非常随机，我刚刚发现实际的问题似乎不是InterfaceBuilder，而是我将InterfaceBuilder视图的clipsToBounds设置为YES。这里没有人可以。所以我想我必须在第二个视图中使用clipsToBound=NO和阴影来包装视图。还有其他方法吗？我也有同样的问题，但这是因为在Interface Builder中检查了视图的“剪辑子视图”。取消勾选使CALayer阴影可见。我同意。不需要包装。只是不要剪切边界-因为阴影在边界之外。我需要剪切边界的原因是，该图像太大，不适合视图，我需要使用“纵横比填充”使其看起来很好。当然，我可以通过绘制全新的图像，然后通过UIGraphicsGetImageFromCurrentImageContext（）获得合适的图像来裁剪图像本身。但这不是会有很大的开销吗？@Dennis:如果图像是静态的，并且只会在该尺寸下使用，那么我的第一个建议是先在图像编辑软件中重新创建图像，然后在项目的图像视图中使用它，而不需要改变其几何体。但是，如果这不是一个选项，请参见上面的“我的编辑”。shadowColor将与UILabel冲突shadowColor将与UILabel冲突
    extension UIView {

        @IBInspectable
        var cornerRadius: CGFloat {
            get {
                return layer.cornerRadius
            }
            set {
                layer.cornerRadius = newValue
                if shadowOpacity > 0.0 {
                    layer.masksToBounds = false
                }
                else {
                    layer.masksToBounds = true
                }
            }
        }
      @IBInspectable
        var borderWidth: CGFloat {
            get {
                return layer.borderWidth
            }
            set {
                layer.borderWidth = newValue
            }
        }
    @IBInspectable
        var borderColor: UIColor? {
            get {
                if let color = layer.borderColor {
                    return UIColor(cgColor: color)
                }
                return nil
            }
            set {
                if let color = newValue {
                    layer.borderColor = color.cgColor
                } else {
                    layer.borderColor = nil
                }
            }
      @IBInspectable var shadowColor: UIColor? {
            set {
                layer.shadowColor = newValue!.cgColor
            }
            get {
                if let color = layer.shadowColor {
                    return UIColor(cgColor: color)
                }
                else {
                    return nil
                }
            }
        }
       @IBInspectable var shadowOpacity: Float {
            set {
                layer.shadowOpacity = newValue
            }
            get {
                return layer.shadowOpacity
            }
        }
     @IBInspectable var shadowOffset: CGPoint {
            set {
                layer.shadowOffset = CGSize(width: newValue.x, height: newValue.y)
            }
            get {
                return CGPoint(x: layer.shadowOffset.width, y:layer.shadowOffset.height)
            }
        }
     @IBInspectable var shadowRadius: CGFloat {
            set {
                layer.shadowRadius = newValue
            }
            get {
                return layer.shadowRadius
            }
        }
}

import UIKit
import QuartzCore

extension CALayer {

    @IBInspectable
    var shadowUIColor: UIColor? {
        get { shadowColor != nil ? UIColor(cgColor: shadowColor!) : nil }
        set { shadowColor = newValue?.cgColor }
    }
}