【无标题】

最新推荐文章于 2024-08-12 19:52:11 发布
最新推荐文章于 2024-08-12 19:52:11 发布
阅读量635 收藏
点赞数
文章标签： ios xcode objective-c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32593237/article/details/126837715
版权
这个博客介绍了如何通过Category扩展UIView，实现圆角、渐变色、边框等效果，并且支持在Interface Builder中直接配置。代码中包括了属性的声明和实现，如圆角、边框宽度和颜色、阴影效果等，并且使用了运行时方法交换来确保视图的相关属性在布局变化时得到更新。
摘要由CSDN通过智能技术生成

xib加圆角，渐变色，边框等

.h的文件

#import <UIKit/UIKit.h>
//IB_DESIGNABLE
@interface UIView (HJViewStyle)

typedef NS_ENUM(NSInteger, GradientStyle) {
GradientStyleLeftToRight = 1,//渐变左到右
GradientStyleTopToBottom = 2//渐变上到下
};

///头部圆角
@property (nonatomic, assign) IBInspectable BOOL roundTop;
///底部圆角
@property (nonatomic, assign) IBInspectable BOOL roundBottom;
///左边圆角
@property (nonatomic, assign) IBInspectable BOOL roundLeft;
///右边圆角
@property (nonatomic, assign) IBInspectable BOOL roundRight;

///圆
@property (nonatomic, assign) IBInspectable BOOL circle;
///圆角
@property (nonatomic, assign) IBInspectable CGFloat cornerRadius;
///边框宽度
@property (nonatomic, assign) IBInspectable CGFloat borderWidth;
///边框颜色
@property (nonatomic, strong) IBInspectable UIColor *borderColor;

///阴影颜色
@property (nonatomic, strong) IBInspectable UIColor *shadowColor;
///阴影半径 默认1
@property (nonatomic, assign) IBInspectable CGFloat shadowRadius;
///阴影透明度 默认1
@property (nonatomic, assign) IBInspectable CGFloat shadowOpacity;
///阴影偏移
@property (nonatomic, assign) IBInspectable CGSize shadowOffset;

///是否开启主题渐变风格 (很多APP渐变风格大多数都是一致了.为了更快设置颜色而添加的属性,具体用法实现UIView+Theme方法)
@property (nonatomic, assign) IBInspectable BOOL themeGradientEnable;
///渐变方向
@property(nonatomic, assign) GradientStyle gradientStyle;
///渐变方向 xib用
@property(nonatomic, assign) IBInspectable NSInteger gradientStyleEnum;
///渐变A颜色
@property (nonatomic, strong) IBInspectable UIColor *gradientAColor;
///渐变B颜色
@property (nonatomic, strong) IBInspectable UIColor *gradientBColor;

/// 阴影Layer
@property(nonatomic, strong) UIView *shadowView;
// 渐变Layer
@property(nonatomic, strong) CAGradientLayer *gradientLayer;
// 边圆角Layer
@property(nonatomic, strong) CAShapeLayer *maskLayer;

///上一次大小
@property (nonatomic, copy) NSString *lastSize;

@end

.m的文件

#import <objc/runtime.h>

@implementation UIView (HJViewStyle)
@dynamic roundTop, roundLeft, roundBottom, borderWidth, borderColor, cornerRadius, shadowColor, shadowRadius, shadowOffset, shadowOpacity, themeGradientEnable, gradientStyle, gradientStyleEnum, gradientAColor, gradientBColor, shadowView, gradientLayer;

+(void)load{
NSArray *arr = @[@“setHidden:” ,@“setAlpha:”, @“layoutSubviews”, @“removeFromSuperview”, @“setFrame:”];
for (NSString *str in arr) {
NSString *new_str = [@“hj_” stringByAppendingString:str];

    SEL orignsel  = NSSelectorFromString(str);
    SEL exchgesel = NSSelectorFromString(new_str);
    
    Method originalM  = class_getInstanceMethod([self class], orignsel);
    Method exchangeM  = class_getInstanceMethod([self class], exchgesel);
    
    BOOL didAddMethod = class_addMethod([self class], orignsel, method_getImplementation(exchangeM), method_getTypeEncoding(exchangeM));
    if (didAddMethod)
    {
        class_replaceMethod([self class], exchgesel, method_getImplementation(originalM), method_getTypeEncoding(originalM));
    }
    else
    {
        method_exchangeImplementations(originalM, exchangeM);
    }
}

}

///设置角圆角

  • (void)setRound:(CACornerMask)maskedCorners
    {
    self.clipsToBounds = true;

    if (@available(iOS 11.0, *)) {
    self.layer.maskedCorners = maskedCorners;
    self.shadowView.layer.maskedCorners = maskedCorners;
    self.gradientLayer.maskedCorners = maskedCorners;
    } else {
    [self refreshRoundingCorners];
    }
    }

//头部圆角

  • (BOOL)roundTop {
    return [objc_getAssociatedObject(self, @selector(roundTop)) boolValue];
    }
  • (void)setRoundTop:(BOOL)roundTop {
    objc_setAssociatedObject(self, @selector(roundTop), @(roundTop), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    if(roundTop) {
    [self setRound:kCALayerMinXMinYCorner | kCALayerMaxXMinYCorner];
    }
    }

//底部圆角

  • (BOOL)roundBottom {
    return [objc_getAssociatedObject(self, @selector(roundBottom)) boolValue];
    }
  • (void)setRoundBottom:(BOOL)roundBottom {
    objc_setAssociatedObject(self, @selector(roundBottom), @(roundBottom), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    if(roundBottom) {
    [self setRound:kCALayerMinXMaxYCorner | kCALayerMaxXMaxYCorner];
    }
    }

//左边圆角

  • (BOOL)roundLeft {
    return [objc_getAssociatedObject(self, @selector(roundLeft)) boolValue];
    }
  • (void)setRoundLeft:(BOOL)roundLeft {
    objc_setAssociatedObject(self, @selector(roundLeft), @(roundLeft), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    if(roundLeft) {
    [self setRound:kCALayerMinXMinYCorner | kCALayerMinXMaxYCorner];
    }
    }

//右边圆角

  • (BOOL)roundRight {
    return [objc_getAssociatedObject(self, @selector(roundRight)) boolValue];
    }
  • (void)setRoundRight:(BOOL)roundRight {
    objc_setAssociatedObject(self, @selector(roundRight), @(roundRight), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    if(roundRight) {
    [self setRound:kCALayerMaxXMinYCorner | kCALayerMaxXMaxYCorner];
    }
    }

// 渐变空视图，只在有圆角的时候使用

  • (CAShapeLayer *)maskLayer{
    return objc_getAssociatedObject(self, @selector(maskLayer));
    }

  • (void)setMaskLayer:(CAShapeLayer *)maskLayer{
    objc_setAssociatedObject(self, @selector(maskLayer), maskLayer, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    }

///上一次大小

  • (NSString *)lastSize{
    return objc_getAssociatedObject(self, @selector(lastSize));
    }

  • (void)setLastSize:(NSString *)lastSize{
    objc_setAssociatedObject(self, @selector(lastSize), lastSize, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    }

//刷新圆角边框

  • (void)refreshRoundingCorners{
    if (@available(iOS 11.0, *)) {
    }else{
    if (self.roundTop || self.roundBottom) {
    CGFloat radius = self.cornerRadius; // 圆角大小
    UIRectCorner corner = UIRectCornerAllCorners; // 圆角位置，全部位置
    if (self.roundTop) {
    corner = UIRectCornerTopLeft | UIRectCornerTopRight;
    }else if (self.roundBottom) {
    corner = UIRectCornerBottomLeft | UIRectCornerBottomRight;
    }else if (self.roundLeft) {
    corner = UIRectCornerTopLeft | UIRectCornerBottomLeft;
    }else if (self.roundRight) {
    corner = UIRectCornerTopRight | UIRectCornerBottomRight;
    }

          [self setLayerCornerRadius:0];
      self.getStyleLayer.borderWidth = 0;
      self.getStyleLayer.borderColor = [UIColor clearColor].CGColor;
      [self setBorderWithCornerRadius:radius borderWidth:self.borderWidth borderColor:self.borderColor type:corner];
      
  }

    }
    }

  • (void)setBorderWithCornerRadius:(CGFloat)cornerRadius
    borderWidth:(CGFloat)borderWidth
    borderColor:(UIColor *)borderColor
    type:(UIRectCorner)corners {

    // UIRectCorner type = UIRectCornerTopRight | UIRectCornerBottomRight | UIRectCornerBottomLeft;

    //1. 加一个layer 显示形状
    CGRect rect = CGRectMake(borderWidth/2.0, borderWidth/2.0,
    CGRectGetWidth(self.frame)-borderWidth, CGRectGetHeight(self.frame)-borderWidth);
    CGSize radii = CGSizeMake(cornerRadius, borderWidth);

    //create path
    UIBezierPath *path = [UIBezierPath bezierPathWithRoundedRect:rect byRoundingCorners:corners cornerRadii:radii];

    //create shape layer
    if (!self.maskLayer) {
    self.maskLayer = [[CAShapeLayer alloc] init];
    }

    self.maskLayer.strokeColor = borderColor.CGColor;
    self.maskLayer.fillColor = [UIColor clearColor].CGColor;

    self.maskLayer.lineWidth = borderWidth;
    self.maskLayer.lineJoin = kCALineJoinRound;
    self.maskLayer.lineCap = kCALineCapRound;
    self.maskLayer.path = path.CGPath;
    [self.layer addSublayer:self.maskLayer];

    CAShapeLayer *clipLayer = [CAShapeLayer layer];
    clipLayer.path = path.CGPath;
    self.layer.mask = clipLayer;

    self.gradientLayer.mask = clipLayer;
    self.shadowView.layer.mask = clipLayer;
    }

//圆形

  • (BOOL)circle {
    return [objc_getAssociatedObject(self, @selector(circle)) boolValue];
    }

  • (void)setCircle:(BOOL)circle {
    objc_setAssociatedObject(self, @selector(circle), @(circle), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    [self setLayerCcircleRadius];
    }

  • (void)setLayerCcircleRadius
    {
    if (self.circle) {
    CGFloat width = self.bounds.size.width;
    CGFloat height = self.bounds.size.height;
    CGFloat radius = (width > height ? height : width) / 2;
    [self setCornerRadius:radius];
    } else if (!self.circle && self.cornerRadius > 0) {
    [self setCornerRadius:self.cornerRadius];
    }
    }

///圆角

  • (CGFloat)cornerRadius {
    return [objc_getAssociatedObject(self, @selector(cornerRadius)) floatValue];
    }

  • (void)setCornerRadius:(CGFloat)cornerRadius {
    objc_setAssociatedObject(self, @selector(cornerRadius), @(cornerRadius), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    [self setLayerCornerRadius:cornerRadius];

    if (!CGSizeEqualToSize(CGSizeFromString(self.lastSize), self.frame.size)) {
    [self refreshRoundingCorners];
    }
    }

///设置圆角

  • (void)setLayerCornerRadius:(CGFloat)cornerRadius
    {
    self.clipsToBounds = true;

    self.layer.cornerRadius = cornerRadius;
    self.getStyleLayer.cornerRadius = cornerRadius;
    self.gradientLayer.cornerRadius = cornerRadius;
    }

///边框宽度

  • (CGFloat)borderWidth {
    return [objc_getAssociatedObject(self, @selector(borderWidth)) floatValue];
    }
  • (void)setBorderWidth:(CGFloat)borderWidth {
    objc_setAssociatedObject(self, @selector(borderWidth), @(borderWidth), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    self.layer.borderWidth = borderWidth;
    [self refreshRoundingCorners];
    }

///边框颜色

  • (UIColor *)borderColor {
    return objc_getAssociatedObject(self, @selector(borderColor));
    }
  • (void)setBorderColor:(UIColor *)borderColor {
    objc_setAssociatedObject(self, @selector(borderColor), borderColor, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    self.layer.borderColor = borderColor.CGColor;
    [self refreshRoundingCorners];
    }

///阴影颜色

  • (UIColor *)shadowColor {
    return objc_getAssociatedObject(self, @selector(shadowColor));
    }
  • (void)setShadowColor:(UIColor *)shadowColor
    {
    objc_setAssociatedObject(self, @selector(shadowColor), shadowColor, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    self.getStyleLayer.shadowColor = shadowColor.CGColor;
    self.getStyleLayer.shadowOpacity = 1;
    }

///阴影半径

  • (void)setShadowRadius:(CGFloat)shadowRadius
    {
    self.getStyleLayer.shadowRadius = shadowRadius;;
    }

///阴影偏移

  • (void)setShadowOffset:(CGSize)shadowOffset
    {
    self.getStyleLayer.shadowOffset = shadowOffset;;
    }

///阴影透明度

  • (void)setShadowOpacity:(CGFloat)shadowOpacity
    {
    self.getStyleLayer.shadowOpacity = shadowOpacity;;
    }

//阴影layer

  • (CALayer *)getStyleLayer{
    if (self.shadowColor && ([self isKindOfClass:[UIImageView class]] || self.clipsToBounds)) {
    if (!self.shadowView) {
    self.shadowView = [[UIView alloc] init];
    self.shadowView.backgroundColor = self.backgroundColor;

          self.shadowView.layer.shadowOpacity = self.layer.shadowOpacity?:1;
      self.shadowView.layer.shadowRadius = self.layer.shadowRadius?:1;
      self.shadowView.layer.shadowColor = self.shadowColor.CGColor;
      self.shadowView.layer.cornerRadius = self.cornerRadius;
      if (CGSizeEqualToSize(self.layer.shadowOffset, self.shadowView.layer.shadowOffset)) {
          self.shadowView.layer.shadowOffset = CGSizeZero;
      }
  }
  // 禁止将 AutoresizingMask 转换为 Constraints
  self.shadowView.translatesAutoresizingMaskIntoConstraints = NO;
  [self.superview insertSubview:self.shadowView belowSubview:self];
  // 添加 right 约束
  NSLayoutConstraint *rightConstraint = [NSLayoutConstraint constraintWithItem:self attribute:NSLayoutAttributeRight relatedBy:NSLayoutRelationEqual toItem:self.shadowView attribute:NSLayoutAttributeRight multiplier:1.0 constant:0];
  [self.superview addConstraint:rightConstraint];
  
  // 添加 left 约束
  NSLayoutConstraint *leftConstraint = [NSLayoutConstraint constraintWithItem:self.shadowView attribute:NSLayoutAttributeLeft relatedBy:NSLayoutRelationEqual toItem:self attribute:NSLayoutAttributeLeft multiplier:1.0 constant:0];
  [self.superview addConstraint:leftConstraint];
  // 添加 top 约束
  NSLayoutConstraint *topConstraint = [NSLayoutConstraint constraintWithItem:self.shadowView attribute:NSLayoutAttributeTop relatedBy:NSLayoutRelationEqual toItem:self attribute:NSLayoutAttributeTop multiplier:1.0 constant:0];
  [self.superview addConstraint:topConstraint];
  // 添加 bottom 约束
  NSLayoutConstraint *bottomConstraint = [NSLayoutConstraint constraintWithItem:self.shadowView attribute:NSLayoutAttributeBottom relatedBy:NSLayoutRelationEqual toItem:self attribute:NSLayoutAttributeBottom multiplier:1.0 constant:0];
  [self.superview addConstraint:bottomConstraint];
  
  [self.superview insertSubview:self.shadowView belowSubview:self];
  
  return self.shadowView.layer;

    }else{
    return self.layer;
    }
    }

// 阴影空视图，只在有圆角的时候使用

  • (UIView *)shadowView{
    return objc_getAssociatedObject(self, @selector(shadowView));
    }

  • (void)setShadowView:(UIView *)shadowView{
    objc_setAssociatedObject(self, @selector(shadowView), shadowView, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    }

///渐变A颜色

  • (void)setGradientAColor:(UIColor *)gradientAColor
    {
    objc_setAssociatedObject(self, @selector(gradientAColor), gradientAColor, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    [self drawingGradientLayer];
    }

  • (UIColor *)gradientAColor {
    return objc_getAssociatedObject(self, @selector(gradientAColor));
    }

///渐变B颜色

  • (void)setGradientBColor:(UIColor *)gradientBColor
    {
    objc_setAssociatedObject(self, @selector(gradientBColor), gradientBColor, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    [self drawingGradientLayer];
    }
  • (UIColor *)gradientBColor {
    return objc_getAssociatedObject(self, @selector(gradientBColor));
    }

///渐变风格xib用

  • (NSInteger)gradientStyleEnum
    {
    return [objc_getAssociatedObject(self, @selector(gradientStyleEnum)) integerValue];
    }
  • (void)setGradientStyleEnum:(NSInteger)gradientStyleEnum
    {
    objc_setAssociatedObject(self, @selector(gradientStyleEnum), @(gradientStyleEnum), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    self.gradientStyle = gradientStyleEnum;
    }

///渐变风格

  • (GradientStyle)gradientStyle
    {
    return [objc_getAssociatedObject(self, @selector(gradientStyle)) integerValue];
    }
  • (void)setGradientStyle:(GradientStyle)gradientStyle{
    objc_setAssociatedObject(self, @selector(gradientStyle), @(gradientStyle), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    if (self.gradientStyle) [self drawingGradientLayer];
    }

///是否开启主题渐变风格

  • (BOOL)themeGradientEnable
    {
    return [objc_getAssociatedObject(self, @selector(themeGradientEnable)) boolValue];
    }

  • (void)setThemeGradientEnable:(BOOL)themeGradientEnable{
    objc_setAssociatedObject(self, @selector(themeGradientEnable), @(themeGradientEnable), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    [self drawingGradientLayer];
    }

//渐变layer

  • (void)drawingGradientLayer{

    UIColor *colorA = self.gradientAColor;
    UIColor *colorB = self.gradientBColor;
    GradientStyle gradientStyle = self.gradientStyle;

    if (!colorA && [self respondsToSelector:@selector(themeGradientAColor)]) {
    colorA = [self valueForKey:@“themeGradientAColor”];
    }
    if (!colorB && [self respondsToSelector:@selector(themeGradientBColor)]) {
    colorB = [self valueForKey:@“themeGradientBColor”];
    }
    if (!gradientStyle && [self respondsToSelector:@selector(themeGradientStyle)]) {
    gradientStyle = [[self valueForKey:@“themeGradientStyle”] integerValue];
    }

    if (colorA && colorB) {
    if (!self.gradientLayer) {
    self.gradientLayer = [CAGradientLayer layer];
    [self.layer insertSublayer:self.gradientLayer below:self.layer];
    }
    self.gradientLayer.frame = self.bounds;

      self.gradientLayer.colors = @[(__bridge id)colorA.CGColor, (__bridge id)colorB.CGColor];
  //            self.gradientLayer.locations = @[@0.5, @0.5];
  if (gradientStyle == GradientStyleLeftToRight) {
      self.gradientLayer.startPoint = CGPointMake(0, 0);
      self.gradientLayer.endPoint = CGPointMake(1.0, 0);
  }else{
      self.gradientLayer.startPoint = CGPointMake(0, 0);
      self.gradientLayer.endPoint = CGPointMake(0, 1.0);
  }
  self.gradientLayer.cornerRadius = self.cornerRadius;
  if (@available(iOS 11.0, *)) {
      self.gradientLayer.maskedCorners = self.getStyleLayer.maskedCorners;
  } else {
      [self refreshRoundingCorners];
  }
  self.backgroundColor = [UIColor clearColor];

    }
    }

  • (UIColor *)themeGradientAColor{
    return [UIColor redColor];
    }

  • (UIColor *)themeGradientBColor{
    return [UIColor blueColor];
    }

  • (NSInteger)themeGradientStyle
    {
    return 1;
    }

// 渐变空视图，只在有圆角的时候使用

  • (CAGradientLayer *)gradientLayer{
    return objc_getAssociatedObject(self, @selector(gradientLayer));
    }

  • (void)setGradientLayer:(CAGradientLayer *)gradientLayer{
    objc_setAssociatedObject(self, @selector(gradientLayer), gradientLayer, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    }

  • (void)hj_setFrame:(CGRect)frame
    {
    [self hj_setFrame:frame];
    [self refreshLayout];
    }

  • (void)hj_layoutSubviews
    {
    [self hj_layoutSubviews];
    [self refreshLayout];
    }

  • (void)refreshLayout
    {
    if (self.shadowView.layer) {
    self.shadowView.frame = self.frame;
    }
    if (self.gradientLayer) {
    self.gradientLayer.frame = self.bounds;
    }

    if (self.shadowView.layer && !self.roundTop && !self.roundBottom && !self.roundLeft && !self.roundRight) {
    //设置阴影路径
    [self.shadowView layer].shadowPath =[UIBezierPath bezierPathWithRect:self.shadowView.bounds].CGPath;
    [self layer].shadowPath =[UIBezierPath bezierPathWithRect:self.bounds].CGPath;
    }
    [self setLayerCcircleRadius];
    self.lastSize = NSStringFromCGSize(self.frame.size);

}

  • (void)hj_removeFromSuperview
    {
    if (self.shadowView) {
    [self.shadowView removeFromSuperview];
    }
    if (self.gradientLayer) {
    [self.gradientLayer removeFromSuperlayer];
    }
    [self hj_removeFromSuperview];
    }

  • (void)hj_setAlpha:(CGFloat)alpha{
    [self hj_setAlpha:alpha];

    if (self.shadowView) {
    self.shadowView.alpha = alpha;
    }
    if (self.gradientLayer) {
    self.gradientLayer.opacity = alpha;
    }
    }

  • (void)hj_setHidden:(BOOL)hidden
    {
    [self hj_setHidden:hidden];
    if (self.shadowView) {
    self.shadowView.hidden = hidden;
    }
    if (self.gradientLayer) {
    self.gradientLayer.hidden = hidden;
    }
    }

@end

qq_32593237
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
iOS中为控件设置颜色渐变和透明度渐变
03-17 1万+
代码为控件设置颜色渐变和透明度渐变
ios-HJViewStyle-xib零代码和代码快速设置View各种样式,实现阴影圆角并存,渐变色背景等功能.zip
07-11
GitHub地址: https://github.com/JohnnyHooo/HJViewStyle 特点: xib零代码和代码快速设置View各种样式 阴影和圆角并存 渐变色背景 根据主题色快速设置渐变背景色 pod 'HJViewStyle'
iOS设置渐变色
Kevin_love_Chrissy的博客
05-07 1193
设置各个控件的背景渐变色 ///设置View的背景渐变色view可以说label，button等，size控件的size，startPoint与endPoint分别为渐变的起始方向与结束方向，它是以矩形的四个角为基础的，（0，0）为左上角、（1，0）为右上角、（0，1）为左下角、（1，1）为右下角，默认是值是（0.5，0）和（0.5，1） +(void)setLayerColorWit...
iOS代码设置渐变背景色
CaryaLiu的专栏
10-20 6488
欢迎到个人博客: liumh.com查看本文。本文为原创，未经允许勿转载项目会遇到给各种UI控件添加渐变背景色的需求，如果只是上下渐变或者左右渐变，可以使用Xcode xcassets的Slicing功能或者 api- resizableImageWithCapInsets:完成功能，但是如果是从左上角到右下角的渐变，或者是右上角到左下角渐变，使用截图恐怕不能完成。下面介绍一种生成渐变颜色UIIma
iOS实现渐变背景色的三种方法
热门推荐
子虚
08-03 3万+
In some particular circumstances, we want to use a gradient background view. As far as my knowledge can reach, there are three different ways to implement a gradient background: CAGradientLayer, CGGra
iOS实现渐变颜色的三种方法
ZHFDBK的博客
04-23 5258
一、CAGradientLayer实现渐变 CAGradientLayer是CALayer的一个特殊子类，用于生成颜色渐变的图层，使用较为方便 下面介绍下它的相关属性： colors 渐变的颜色 locations 渐变颜色的分割点 startPoint&amp;endPoint 颜色渐变的方向，范围在(0,0)与(1.0,1.0)之间，如(0,0)(...
Qt无标题窗口
05-21
在本文中，我们将深入探讨如何使用Qt框架创建一个无标题窗口，这在界面设计和自定义标题栏美化中非常有用。我们将关注`framelesswidget.cpp`、`main.cpp`、`framelesswidget.h`等核心文件，理解它们在实现无标题窗口...
VC去掉'无标题'字样的方法.zip
11-21
在使用Visual C++进行编程时，我们经常会在创建新的窗口或者对话框时默认看到标题栏显示为“无标题”。这可能会对用户界面的美观性和专业性造成一定的影响。本资料包提供了一种方法来帮助开发者去掉这个“无标题”...
visual c++取掉对话框窗口的 -无标题 字样的方法
08-04
在Visual C++编程环境中，创建窗口应用程序时，默认情况下，窗口标题栏可能会显示“-无标题”字样，这通常是由于没有正确设置窗口类或没有自定义窗口标题所导致的。要解决这个问题，我们需要深入理解Windows API中的...
c#实现无标题栏窗口的拖动
09-05
本篇文章将详细讲解如何在C#中实现这种无标题栏窗口的拖动以及其他基本操作。 首先，为了实现无标题栏窗口的拖动，我们需要处理窗体的鼠标事件。窗体的`FormBorderStyle`属性应设置为`None`，这会去除窗体的边框和...
iOS 渐变色 CAGrantLayer
05-08
渐变色 IOS CAGrantLayer
delphi 无标题调整大小
11-26
在Delphi编程环境中，"无标题调整大小"通常是指创建没有标准标题栏的窗口，并允许用户通过拖动边界来调整其大小。这种设计通常用于自定义界面或创建无边框的对话框。以下是对这个主题的详细解释： 一、创建无标题...
iOS CAGradientLayer 渐变图层
LOLITA0164的博客
07-11 3万+
CAGradientLayer 是 CALayer 的子类，用来制作渐变效果的图层。
iOS UIView添加渐变色
冰凉的枷锁的博客
05-06 2881
#import <UIKit/UIKit.h> @interface UIView (TransitionColor) //添加渐变色 - (void)addDefaultTransitionColor; //- (void)addTransitionColor:(NSArray<UIColor *> *)colors; - (void)addTransitionCol...
UIView 实现渐变色 CAGradientLayer
xuejunrong的博客
03-14 1680
- (UIView *)sendView {     if (_sendView == nil) {         _sendView = [[UILabel alloc]init];         _sendView.frame = CGRectMake(0, 0, KScreenWidth-40, kH(30));                  /**          *
iOS 统一修改xib中控件颜色（亲测真实有效）
年轻就做四件事：挣钱存钱、见世面、交朋友、学本事。
03-21 5525
原理：使用mac终端进行批量文件内容替换！步骤一：找到自己需要替换的颜色，和自己想要替换成什么颜色。如下图根据RGB计算出大致的R值为：42/255约等于0.164705. 步骤二：选中xib文件，右键“Open with External Editor”,将xib以文档格式打开。步骤三：将我们之前计算的0.164705使用 Command+F 进行搜索如下图所示，将其中颜色部分复制下来。步骤四：...
iOS 渐变色
观星的专栏
07-20 2711
想给UIImageView加上渐变颜色作为背景，第一个想到的是使用CAGradientLayer来实现。 但仔细想想这并不可以。CAGradientLayer
[Swift]绘制渐变色
Gamin
08-05 1379
demo:https://download.csdn.net/download/u012881779/20721788 示意图: import Foundation import UIKit class GradientVC: UIViewController { @IBOutlet weak var butOne: GradientCustomButton! @IBOutlet weak var viewTwo: UIView! ..
iOS Swift开发 navigation模式自定义pop和push动画
最新发布
JOJO_
08-12 221
Swift navigation pop push 自定义动画
设置无标题 android
05-02
在Android应用中，设置无标题是一种简洁和美观的设计方式，可以为用户提供更流畅的使用体验。以下是一些实现设置无标题的方法： 1. 在Android的Manifest文件中，找到对应Activity的标签，并添加”android:theme="@android:style/Theme.NoTitleBar"“属性。这样可以通过Android自带的主题去掉标题栏。 2. 使用自定义的主题，可以在样式表中添加以下代码： <style name="AppTheme" parent="Theme.AppCompat.NoActionBar"> <!-- ...其他样式... --> </style> 这种方式可以通过设置主题去除ActionBar和标题栏，同时保留其他布局元素。 3. 去掉代码中的setTitle()方法，这是一种最简单的方法，通过不设置Activity的标题来实现无标题。 以上就是三种常见的实现Android无标题的方式，开发者可以根据实际需求进行选择。值得注意的是，去除标题栏可能会影响用户的导航体验，因此在设计上需要考虑周全。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值