UIVIV के केवल ऊपरी-बाएँ और ऊपरी-दाएँ कोने के लिए कार्नरियस को कैसे सेट करें?

Question

क्या cornerRadiusकेवल ऊपरी-बाएँ और दाएँ-बाएँ कोने के लिए सेट करने का कोई तरीका है UIView?

मैंने निम्नलिखित की कोशिश की, लेकिन यह अब दृश्य नहीं देख रहा है।

UIView *view = [[UIView alloc] initWithFrame:frame];

CALayer *layer = [CALayer layer];
UIBezierPath *shadowPath = [UIBezierPath bezierPathWithRoundedRect:frame byRoundingCorners:(UIRectCornerTopLeft|UIRectCornerTopRight) cornerRadii:CGSizeMake(3.0, 3.0)];
layer.shadowPath = shadowPath.CGPath;
view.layer.mask = layer;

Comments

आपके संपादन के बाद, तीन चीजें ठीक करने के लिए: (1) गोल पथ पर आधारित होना चाहिए view.bounds, नहीं frame, (2) परत एक होना चाहिए CAShapeLayer, नहीं CALayer; (3) लेयर सेट करें path, नहीं shadowPath।

— कर्ट रेविस

इस प्रश्न और उत्तर की संभावित डुप्लिकेट ।

— स्टुअर्ट

CGPath पर वक्र बनाने के लिए, बेज़ियर वक्र एल्गोरिथ्म का उपयोग करें। मुझे पूरा यकीन है कि यह कोरग्राफिक्स का हिस्सा है। यदि नहीं, तो en.wikipedia.org/wiki/Bézier_curve की कुछ बेहतरीन परिभाषाएँ और एनिमेशन हैं।

— नैट सीमर

iosdevcenters.blogspot.com/2018/02/…

— भद्रेश

मेरा जवाब यहाँ देखें: stackoverflow.com/a/50396485/6246128

— wcarhart

Answer 1

इस तथ्य पर ध्यान दें कि यदि आपके पास लेआउट की बाधाएं जुड़ी हुई हैं, तो आपको इसे अपने यूआईईवीवाई उपवर्ग में निम्नानुसार ताज़ा करना होगा:

override func layoutSubviews() {
    super.layoutSubviews()
    roundCorners(corners: [.topLeft, .topRight], radius: 3.0)
}

यदि आप ऐसा नहीं करते हैं तो यह दिखाई नहीं देगा।

---

और गोल कोनों के लिए, एक्सटेंशन का उपयोग करें:

extension UIView {
   func roundCorners(corners: UIRectCorner, radius: CGFloat) {
        let path = UIBezierPath(roundedRect: bounds, byRoundingCorners: corners, cornerRadii: CGSize(width: radius, height: radius))
        let mask = CAShapeLayer()
        mask.path = path.cgPath
        layer.mask = mask
    }
}

Comments

यह बिल्कुल जवाब नहीं है, लेखक पूछ रहा था कि विशेष कोनों को कैसे गोल किया जाए, न कि लेआउट के परिवर्तनों के साथ कोने के त्रिज्या को कैसे सिंक्रनाइज़ किया जाए।

— केलिन

यह जवाब है मतलब नहीं है।

— टियागो कोटो

उत्तर हाल ही में तय किया गया है .. @kelin

— माइकल

यह निश्चित रूप से कोने गोल है।

— एज़ेलाइट a

आपको यह दिखाई देने के बाद करना होगा

— जोनाथन।

Answer 2

मुझे यकीन नहीं है कि आपका समाधान क्यों नहीं हुआ लेकिन निम्न कोड मेरे लिए काम कर रहा है। एक बेज़ियर मास्क बनाएं और इसे अपने दृश्य में लागू करें। नीचे मेरे कोड में मैं _backgroundView3 पिक्सेल के त्रिज्या के साथ नीचे के कोनों को गोल कर रहा था । selfएक रिवाज है UITableViewCell:

UIBezierPath *maskPath = [UIBezierPath
    bezierPathWithRoundedRect:self.backgroundImageView.bounds
    byRoundingCorners:(UIRectCornerBottomLeft | UIRectCornerBottomRight)
    cornerRadii:CGSizeMake(20, 20)
];

CAShapeLayer *maskLayer = [CAShapeLayer layer];

maskLayer.frame = self.bounds;
maskLayer.path = maskPath.CGPath;

self.backgroundImageView.layer.mask = maskLayer;

कुछ सुधार के साथ स्विफ्ट संस्करण:

let path = UIBezierPath(roundedRect:viewToRound.bounds, byRoundingCorners:[.TopRight, .BottomLeft], cornerRadii: CGSizeMake(20, 20))
let maskLayer = CAShapeLayer()

maskLayer.path = path.CGPath
viewToRound.layer.mask = maskLayer

स्विफ्ट 3.0 संस्करण:

let path = UIBezierPath(roundedRect:viewToRound.bounds,
                        byRoundingCorners:[.topRight, .bottomLeft],
                        cornerRadii: CGSize(width: 20, height:  20))

let maskLayer = CAShapeLayer()

maskLayer.path = path.cgPath
viewToRound.layer.mask = maskLayer

यहां स्विफ्ट का विस्तार

Comments

टेक्स्टफील्ड में प्रयास करें। बाएं में सफलता, दाएं में विफलता

— रेनर लियाओ

@ RainerLiao मैं एक ही मुद्दा था, मैं इस viewDidLoadपद्धति पर यह सब किया , इसे स्थानांतरित करने के लिए viewDidAppearऔर यह काम किया।

— लूचो सेप

मैं किसी भी डिवाइस के लिए कैसे काम कर सकता हूं। यह केवल simulatorस्टोरीबोर्ड के आकार के लिए ठीक काम करता है । ex: if the simulator size is 6s it works fine for 6s, but not of others.मैं इससे कैसे उबरूं।

— चनाका काल्डेरा

स्विफ्ट 3 संस्करण में थोड़ा सा वाक्यविन्यास त्रुटि: path.CGPathहोना चाहिएpath.cgPath

— रोब

@ RainerLiao यदि आप नहीं चाहते कि यह दृश्य के रूप में फ़्लिक करे, तो इसे viewWillAppearबदले। यह भी काम करता है।

— मैथ्यू निप्पेन

Answer 3

यहाँ @JohnnyRockex उत्तर का एक स्विफ्ट संस्करण है

extension UIView {

    func roundCorners(_ corners: UIRectCorner, radius: CGFloat) {
         let path = UIBezierPath(roundedRect: self.bounds, byRoundingCorners: corners, cornerRadii: CGSize(width: radius, height: radius))
         let mask = CAShapeLayer()
         mask.path = path.cgPath
         self.layer.mask = mask
    }

}

---

view.roundCorners([.topLeft, .bottomRight], radius: 10)

ध्यान दें

यदि आप ऑटो लेआउट का उपयोग कर रहे हैं , तो आपको अपने उप-वर्ग को देखने और इष्टतम प्रभाव के लिए UIViewकॉल करने की आवश्यकता होगी ।roundCornerslayoutSubviews

class View: UIView {
    override func layoutSubviews() {
        super.layoutSubviews()

        self.roundCorners([.topLeft, .bottomLeft], radius: 10)
    }
}

Comments

महान विस्तार। हालांकि: .TopRightऔर .BottomRightमेरे लिए काम करने के लिए प्रतीत नहीं होता है।

— ओनिचन

पर स्विफ्ट 2 :view.roundCorners([.TopLeft , .BottomLeft], radius: 10)

— fahrulazmi

यह सही पर काम नहीं कर रहा है, क्योंकि आपके दृश्य की सीमा अभी तक ऑटोलिएट के साथ अच्छी तरह से परिभाषित नहीं है ... मैं वर्तमान में एक ही मुद्दे का सामना कर रहा हूं।

— dosdos

@dosdos सबक्लास उस दृश्य और लेआउट में साक्षात्कार स्वयं के कोनों को गोल करते हैं।

— आर्बिटूर

यदि आप ऑटो लेआउट का उपयोग करते हैं, और उस दृश्य का संदर्भ नहीं है जिसे आप गोल करना चाहते हैं .layoutIfNeeded(), तो आप कॉल कर सकते हैं , फिर यह विधि।

— zgjie

Answer 4

और अंत में ... iOS11 में CACornerMask है! इसके साथ CACornerMaskबहुत आसान किया जा सकता है:

let view = UIView()
view.clipsToBounds = true
view.layer.cornerRadius = 10
view.layer.maskedCorners = [.layerMaxXMinYCorner, .layerMinXMinYCorner] // Top right corner, Top left corner respectively

Comments

यह निश्चित रूप से सबसे अच्छा काम करता है। डायनेमिक रूप से आकार देने वाले टेबलव्यू सेल के किनारों को गोल करते समय हमारे पास हमेशा अन्य समाधानों के साथ समस्या होती थी।

— cornr

उस समाधान का उपयोग करने के लिए प्रोजेक्ट को iOS 11 का समर्थन करना चाहिए।

— एलियन

@ एलियन और ... मैंने उल्लेख किया है कि

— सेर्गेई बेलौस

डिवाइस को घुमाते समय अन्य उत्तर काम नहीं करते हैं, यह कोड रोटेशन के लिए काम करता है और आपको कुछ कोनों को गोल करने की अनुमति देता है, यह स्वीकृत उत्तर होना चाहिए।

— Cloud9999Strife

सरल सुंदर है

— eharo2

Answer 5

यहां स्विफ्ट कोड उदाहरण: https://stackoverflow.com/a/35621736/308315

---

प्रत्यक्ष नहीं। तुम्हे करना ही होगा:

1. बनाओ CAShapeLayer
2. इसके सेट pathहोने के लिए एक CGPathRefके आधार पर view.boundsलेकिन केवल दो गोल किनारों के साथ (शायद का उपयोग करके +[UIBezierPath bezierPathWithRoundedRect:byRoundingCorners:cornerRadii:])
3. अपने view.layer.maskहोने के लिए निर्धारित करेंCAShapeLayer

Comments

चेतावनी दी है कि यदि आप इसे केवल एक-दो से अधिक दृश्यों पर करते हैं, तो यह प्रदर्शन को प्रभावित करेगा ...

— jjxtra

@jjxtra तो सबसे अच्छा प्रदर्शन नुकसान के बिना इसे करने का सबसे अच्छा तरीका क्या है? मैं इसे UITableViewCell में दिखाना चाहता हूं।

— xi.lin

@ xi.lin जो मुझे लेयर सेट करने से याद है। asterहोल्डरास्टराइज़ == हाँ 5 या तो गति में सुधार करता है। लेकिन डॉक्स का कहना है कि यह केवल तभी काम करता है जब आप गैर-पारदर्शी कोशिकाओं के साथ काम करते हैं। इसे आजमा कर देखें।

— कोडरूट

Answer 6

यहाँ एक छोटी विधि इस प्रकार लागू की गई है:

- (void)viewDidLoad {
    [super viewDidLoad];
    UIButton *openInMaps = [UIButton new];
    [openInMaps setFrame:CGRectMake(15, 135, 114, 70)];
    openInMaps = (UIButton *)[self roundCornersOnView:openInMaps onTopLeft:NO topRight:NO bottomLeft:YES bottomRight:NO radius:5.0];
}

- (UIView *)roundCornersOnView:(UIView *)view onTopLeft:(BOOL)tl topRight:(BOOL)tr bottomLeft:(BOOL)bl bottomRight:(BOOL)br radius:(float)radius {

    if (tl || tr || bl || br) {
        UIRectCorner corner = 0;
        if (tl) {corner = corner | UIRectCornerTopLeft;}
        if (tr) {corner = corner | UIRectCornerTopRight;}
        if (bl) {corner = corner | UIRectCornerBottomLeft;}
        if (br) {corner = corner | UIRectCornerBottomRight;}

        UIView *roundedView = view;
        UIBezierPath *maskPath = [UIBezierPath bezierPathWithRoundedRect:roundedView.bounds byRoundingCorners:corner cornerRadii:CGSizeMake(radius, radius)];
        CAShapeLayer *maskLayer = [CAShapeLayer layer];
        maskLayer.frame = roundedView.bounds;
        maskLayer.path = maskPath.CGPath;
        roundedView.layer.mask = maskLayer;
        return roundedView;
    }
    return view;
}

Comments

रंग सेट करने के बारे में क्या? maskLayer.borderWidth = 10; maskLayer.borderColor = [UIColor redColor] .CGColor; यह मेरे लिए काम नहीं कर रहा है सर।

— किरन

@ एक मुखौटा में रंग नहीं होता है, अगर आप बॉर्डर बनाना चाहते हैं तो आप एक दूसरा कैशलेयर जोड़ सकते हैं

— जॉनी रॉकएक्स

Answer 7

स्विफ्ट 4.1 और एक्सकोड 9.4.1 में

में आईओएस 11 इस एक लाइन के लिए पर्याप्त है:

detailsSubView.layer.maskedCorners = [.layerMinXMinYCorner, .layerMaxXMinYCorner]//Set your view here

पूरा कोड देखें:

//In viewDidLoad
if #available(iOS 11.0, *){
        detailsSubView.clipsToBounds = false
        detailsSubView.layer.cornerRadius = 10
        detailsSubView.layer.maskedCorners = [.layerMinXMinYCorner, .layerMaxXMinYCorner]
} else {
      //For lower versions
}

लेकिन कम संस्करणों के लिए

let rectShape = CAShapeLayer()
    rectShape.bounds = detailsSubView.frame
    rectShape.position = detailsSubView.center
    rectShape.path = UIBezierPath(roundedRect: detailsSubView.bounds,    byRoundingCorners: [.topLeft , .topRight], cornerRadii: CGSize(width: 20, height: 20)).cgPath
    detailsSubView.layer.mask = rectShape

पूरा कोड है

if #available(iOS 11.0, *){
    detailsSubView.clipsToBounds = false
    detailsSubView.layer.cornerRadius = 10
    detailsSubView.layer.maskedCorners = [.layerMinXMinYCorner, .layerMaxXMinYCorner]
}else{
    let rectShape = CAShapeLayer()
    rectShape.bounds = detailsSubView.frame
    rectShape.position = detailsSubView.center
    rectShape.path = UIBezierPath(roundedRect: detailsSubView.bounds,    byRoundingCorners: [.topLeft , .topRight], cornerRadii: CGSize(width: 20, height: 20)).cgPath
    detailsSubView.layer.mask = rectShape
}

यदि आप स्टोरीबोर्ड में AutoResizing का उपयोग कर रहे हैं, तो यह कोड viewDidLayoutSubviews () में लिखें ।

override func viewDidLayoutSubviews() {
    super.viewDidLayoutSubviews()

    if #available(iOS 11.0, *){
        detailsSubView.clipsToBounds = false
        detailsSubView.layer.cornerRadius = 10
        detailsSubView.layer.maskedCorners = [.layerMinXMinYCorner, .layerMaxXMinYCorner]
    }else{
        let rectShape = CAShapeLayer()
        rectShape.bounds = detailsSubView.frame
        rectShape.position = detailsSubView.center
        rectShape.path = UIBezierPath(roundedRect: detailsSubView.bounds,    byRoundingCorners: [.topLeft , .topRight], cornerRadii: CGSize(width: 20, height: 20)).cgPath
        detailsSubView.layer.mask = rectShape
    }
}

Comments

यह iOS 9 पर काम नहीं कर रहा है, लेकिन

— अली इहसन URAL

Ios 9 के लिए कोई समाधान?

— jey

@ संजय करे 20, ऊंचाई: 20))। CgPath detailsSubView.layer.mask = rectShape यह कोड iOS 9 के लिए काम कर सकता है

— iOS

@ संजय मुझे सूचित न करें

— iOS

Ios 9 के लिए काम नहीं कर रहा है। इसके कोने के हिस्से पर कोई बॉर्डर नहीं है।

— jey

Answer 8

iOS 11, स्विफ्ट 4
और आप इस कोड को आज़मा सकते हैं:

if #available(iOS 11.0, *) {
   element.clipsToBounds = true
   element.layer.cornerRadius = CORNER_RADIUS
   element.layer.maskedCorners = [.layerMaxXMaxYCorner]
} else {
   // Fallback on earlier versions
}

और आप टेबल व्यू सेल में इसका उपयोग कर सकते हैं।

Comments

आज की कोडिंग के लिए यही सही उत्तर है। अलविदा अलविदा परत।

— एलन लिआंग

यह सबसे अच्छा जवाब होना चाहिए!

— fujianjin6471

Answer 9

यह सबसे सरल उत्तर होगा:

yourView.layer.cornerRadius = 8
yourView.layer.masksToBounds = true
yourView.layer.maskedCorners = [.layerMinXMinYCorner, .layerMaxXMinYCorner]

Comments

टैग कि यह IOS 11 या इसके बाद के संस्करण के लिए समाधान है

— अंकुर लाहिरी

Answer 10

इस कोड को आज़माएं,

UIBezierPath *maskPath = [UIBezierPath bezierPathWithRoundedRect:view.bounds byRoundingCorners:( UIRectCornerTopLeft | UIRectCornerTopRight) cornerRadii:CGSizeMake(5.0, 5.0)];

CAShapeLayer *maskLayer = [[CAShapeLayer alloc] init];
maskLayer.frame = self.view.bounds;
maskLayer.path  = maskPath.CGPath;

view.layer.mask = maskLayer;

Answer 11

एम्मा: .TopRightऔर .BottomRightशायद आपके लिए काम नहीं कर रहे हैं क्योंकि कॉल करने के view.roundCornersलिए पहले अंतिम रूप view boundsसे गणना की जाती है। ध्यान दें कि Bezier Pathदृश्य उस समय सीमा से निकलता है जिसे यह कहा जाता है। उदाहरण के लिए, यदि ऑटो लेआउट दृश्य को संकीर्ण करेगा, तो दाईं ओर के गोल कोने दृश्य के बाहर हो सकते हैं। इसे उस स्थान पर कॉल करने का प्रयास करें viewDidLayoutSubviews, जहां दृश्य की सीमा अंतिम है।

Comments

धन्यवाद। मेरे लिए, जो समस्या हल हो गई, वह कॉल को "Arbitur" द्वारा दिए गए कार्यान्वयन के लिए ले जा रही थी, viewDidLoad और viewWillAppear से viewDidAppear तक। मैं ऐसा कर सकता था क्योंकि मेरा नियंत्रण शुरू में छिपा हुआ है।

— मैटी

तुम सही हो। यह ऑटोलॉयट के साथ समस्या पैदा करेगा और आपने अच्छा काम किया है।

— आशीष कक्कड़

Answer 12

स्विफ्ट 4 स्विफ्ट 5 आसान तरीका 1 लाइन में

उपयोग:

//MARK:- Corner Radius of only two side of UIViews
self.roundCorners(view: yourview, corners: [.bottomLeft, .topRight], radius: 12.0)

समारोह:

//MARK:- Corner Radius of only two side of UIViews
func roundCorners(view :UIView, corners: UIRectCorner, radius: CGFloat){
        let path = UIBezierPath(roundedRect: view.bounds, byRoundingCorners: corners, cornerRadii: CGSize(width: radius, height: radius))
        let mask = CAShapeLayer()
        mask.path = path.cgPath
        view.layer.mask = mask
}

ऑब्जेक्टिव-सी में

उपयोग:

[self.verticalSeparatorView roundCorners:UIRectCornerTopLeft radius:10.0];

श्रेणी (केवल एक कोने) में उपयोग किया जाने वाला कार्य:

-(void)roundCorners: (UIRectCorner) corners radius:(CGFloat)radius {
        UIBezierPath *path = [UIBezierPath bezierPathWithRoundedRect:self.bounds byRoundingCorners:corners cornerRadii:CGSizeMake(radius, radius)];
        CAShapeLayer *mask = [[CAShapeLayer alloc] init];
        mask.path = path.CGPath;
        self.layer.mask = mask;
    }

Comments

केवल यह याद रखें कि आपके दृश्य के कोनों की गणना तब तक नहीं की जाती है, जब तक व्यूडायलेटआउट साक्षात्कार नहीं किए जाते हैं, इसलिए आपको इसके भीतर गोलकार फंक बुलाना चाहिए

— जिरसन टवेरा

क्या आप बता सकते हैं कि मैं इस दृश्य में छाया कैसे जोड़ सकता हूं?

— वडलापल्ली मस्तान

@ShakeelAhmed यदि आप दृश्य में छाया जोड़ना चाहते हैं तो यह काम नहीं करेगा।

— मोजतबा अल मौसवी

पहले ऐड कोने की त्रिज्या और फिर छाया जोड़ने

— शकील अहमद

Answer 13

UIView और UITextFiels के विशिष्ट कोनों को तेजी से गोल करने के लिए मेरा समाधान उपयोग करना है

.layer.cornerRadius

तथा

layer.maskedCorners

वास्तविक UIView या UITextFields की।

उदाहरण:

fileprivate func inputTextFieldStyle() {
        inputTextField.layer.masksToBounds = true
        inputTextField.layer.borderWidth = 1
        inputTextField.layer.cornerRadius = 25
        inputTextField.layer.maskedCorners = [.layerMaxXMaxYCorner,.layerMaxXMinYCorner]
        inputTextField.layer.borderColor = UIColor.white.cgColor
    }

और उपयोग करके

.layerMaxXMaxYCorner

तथा

.layerMaxXMinYCorner

, मैं UITextField के शीर्ष दाएं और निचले दाएं कोने को गोल करने के लिए निर्दिष्ट कर सकता हूं।

आप यहाँ परिणाम देख सकते हैं:

Comments

सीमा और विशिष्ट कोनों के संयोजन के लिए बिल्कुल सही।

— नोमन

Answer 14

स्विफ्ट 4

extension UIView {

    func roundTop(radius:CGFloat = 5){
        self.clipsToBounds = true
        self.layer.cornerRadius = radius
        if #available(iOS 11.0, *) {
            self.layer.maskedCorners = [.layerMaxXMinYCorner, .layerMinXMinYCorner]
        } else {
            // Fallback on earlier versions
        }
    }

    func roundBottom(radius:CGFloat = 5){
        self.clipsToBounds = true
        self.layer.cornerRadius = radius
        if #available(iOS 11.0, *) {
            self.layer.maskedCorners = [.layerMaxXMaxYCorner, .layerMinXMaxYCorner]
        } else {
            // Fallback on earlier versions
        }
    }
}

Comments

आपने अपना दिन बचाया मेरे मामले में मुझे विशेष कक्षों के लिए तालिका दृश्य गोल करना पड़ा

— शक्ति

मेरी आवश्यकता के अनुसार बिल्कुल सही ans। मैंने सभी उत्तर का उपयोग किया, मेरे लिए कुछ भी काम नहीं किया, लेकिन आपके उत्तर ने मेरी मदद की और मेरी समस्या हल कर दी।

— निकिता पाटिल

Answer 15

इस प्रोग्राम को करने का एक तरीका यह होगा कि गोल कोनों UIViewवाले शीर्ष भाग पर एक ओवर बनाया जाए UIView। या आप किसी चीज़ के नीचे शीर्ष छिपा सकते हैं।

Comments

इसका एक बहुत ही बदसूरत समाधान: पी

— आर्बिटूर

Answer 16

    // Create the path (with only the top-left corner rounded)
UIBezierPath *maskPath = [UIBezierPath bezierPathWithRoundedRect:view.bounds 
                           byRoundingCorners:(UIRectCornerBottomLeft | UIRectCornerBottomRight) 
                           cornerRadii:CGSizeMake(7.0, 7.0)];

// Create the shape layer and set its path
CAShapeLayer *maskLayer = [CAShapeLayer layer];
maskLayer.frame = cell.stripBlackImnageView.bounds;
maskLayer.path = maskPath.CGPath; 
// Set the newly created shapelayer as the mask for the image view's layer
view.layer.mask = maskLayer;

Answer 17

सबसे आसान तरीका एक गोल कोने की परत के साथ एक मुखौटा बनाना होगा।

CALayer *maskLayer = [CALayer layer];
maskLayer.frame = CGRectMake(0,0,maskWidth ,maskHeight);
maskLayer.contents = (__bridge id)[[UIImage imageNamed:@"maskImageWithRoundedCorners.png"] CGImage];

aUIView.layer.mask = maskLayer;

और यह मत भूलना:

#import <QuartzCore/QuartzCore.h>

Answer 18

पहले से दिए गए सभी उत्तर वास्तव में अच्छे और वैध हैं (विशेषकर maskसंपत्ति का उपयोग करने का यूनुस विचार )।

हालाँकि मुझे कुछ अधिक जटिल की आवश्यकता थी क्योंकि मेरी परत अक्सर आकार बदल सकती थी जिसका मतलब है कि मुझे हर बार उस मास्किंग लॉजिक को कॉल करने की आवश्यकता थी और यह थोड़ा कष्टप्रद था।

मैंने extensionsएक वास्तविक cornerRadiiसंपत्ति बनाने के लिए स्विफ्ट और कम्प्यूटेड गुणों का उपयोग किया, जो कि लेयर के बाहर होने पर मास्क को अपडेट करने वाले ऑटो की देखभाल करता है।

यह स्विज़लिंग के लिए पीटर स्टीनबर्ग महान एस्पेक्ट्स लाइब्रेरी का उपयोग करके हासिल किया गया था ।

पूरा कोड यहाँ है:

extension CALayer {
  // This will hold the keys for the runtime property associations
  private struct AssociationKey {
    static var CornerRect:Int8 = 1    // for the UIRectCorner argument
    static var CornerRadius:Int8 = 2  // for the radius argument
  }

  // new computed property on CALayer
  // You send the corners you want to round (ex. [.TopLeft, .BottomLeft])
  // and the radius at which you want the corners to be round
  var cornerRadii:(corners: UIRectCorner, radius:CGFloat) {
    get {
      let number = objc_getAssociatedObject(self, &AssociationKey.CornerRect)  as? NSNumber ?? 0
      let radius = objc_getAssociatedObject(self, &AssociationKey.CornerRadius)  as? NSNumber ?? 0
      return (corners: UIRectCorner(rawValue: number.unsignedLongValue), radius: CGFloat(radius.floatValue))
    }
    set (v) {
      let radius = v.radius
      let closure:((Void)->Void) = {
        let path = UIBezierPath(roundedRect: self.bounds, byRoundingCorners: v.corners, cornerRadii: CGSize(width: radius, height: radius))
        let mask = CAShapeLayer()
        mask.path = path.CGPath
        self.mask = mask
      }
      let block: @convention(block) Void -> Void = closure
      let objectBlock = unsafeBitCast(block, AnyObject.self)
      objc_setAssociatedObject(self, &AssociationKey.CornerRect, NSNumber(unsignedLong: v.corners.rawValue), .OBJC_ASSOCIATION_RETAIN)
      objc_setAssociatedObject(self, &AssociationKey.CornerRadius, NSNumber(float: Float(v.radius)), .OBJC_ASSOCIATION_RETAIN)
      do { try aspect_hookSelector("layoutSublayers", withOptions: .PositionAfter, usingBlock: objectBlock) }
      catch _ { }
    }
  }
}

मैंने यह बताते हुए एक साधारण ब्लॉग पोस्ट लिखी ।

Answer 19

यदि आप एक इंटरफ़ेस बिल्डर की तलाश कर रहे हैं तो केवल समाधान iOS 11 और उच्चतर के लिए एक है । मेरा उत्तर यहाँ देखें: https://stackoverflow.com/a/58626264

Answer 20

यह है कि आप C # में Xamarin के साथ बटन के प्रत्येक कोने के लिए एक कोने त्रिज्या कैसे सेट कर सकते हैं :

var maskPath = UIBezierPath.FromRoundedRect(MyButton.Bounds, UIRectCorner.BottomLeft | UIRectCorner.BottomRight,
    new CGSize(10.0, 10.0));
var maskLayer = new CAShapeLayer
{
    Frame = MyButton.Bounds,
    Path = maskPath.CGPath
};
MyButton.Layer.Mask = maskLayer;

Answer 21

यूनुस नेदिम मेहेल समाधान का पुन: उपयोग करने के लिए एक सुंदर विस्तार

स्विफ्ट 2.3

extension UIView {
func roundCornersWithLayerMask(cornerRadii: CGFloat, corners: UIRectCorner) {
    let path = UIBezierPath(roundedRect: bounds,
                            byRoundingCorners: corners,
                            cornerRadii: CGSize(width: cornerRadii, height: cornerRadii))
    let maskLayer = CAShapeLayer()
    maskLayer.path = path.CGPath
    layer.mask = maskLayer
} }

प्रयोग

let view = UIView()
view.roundCornersWithLayerMask(10,[.TopLeft,.TopRight])

Comments

अच्छा साफ समाधान

— अग्रेंजी

Answer 22

कोड बदलने के बाद @apinho स्विफ्ट 4.3 में ठीक काम कर रहा है

extension UIView {
func roundCornersWithLayerMask(cornerRadii: CGFloat, corners: UIRectCorner) {
    let path = UIBezierPath(roundedRect: bounds,
                            byRoundingCorners: corners,
                            cornerRadii: CGSize(width: cornerRadii, height: cornerRadii))
    let maskLayer = CAShapeLayer()
    maskLayer.path = path.cgPath
    layer.mask = maskLayer
  }
}

आपके देखने के लिए इस फ़ंक्शन का उपयोग करने के लिए

YourViewName. roundCornersWithLayerMask(cornerRadii: 20,corners: [.topLeft,.topRight])

Answer 23

स्टीफन के जवाब का एक और संस्करण ।

import UIKit

    class RoundCornerView: UIView {
    var corners : UIRectCorner = [.topLeft,.topRight,.bottomLeft,.bottomRight]
        var roundCornerRadius : CGFloat = 0.0
        override func layoutSubviews() {
            super.layoutSubviews()
            if corners.rawValue > 0 && roundCornerRadius > 0.0 {
                self.roundCorners(corners: corners, radius: roundCornerRadius)
            }
        }
        private func roundCorners(corners: UIRectCorner, radius: CGFloat) {
            let path = UIBezierPath(roundedRect: bounds, byRoundingCorners: corners, cornerRadii: CGSize(width: radius, height: radius))
            let mask = CAShapeLayer()
            mask.path = path.cgPath
            layer.mask = mask
        }

    }

Answer 24

स्विफ्ट 4.2 में, इसे @IBDesignableइस तरह बनाएं :

@IBDesignable

class DesignableViewCustomCorner: UIView {

    @IBInspectable var cornerRadious: CGFloat = 0 {
        didSet {
            let path = UIBezierPath(roundedRect: self.bounds, byRoundingCorners: [.topLeft, .topRight], cornerRadii: CGSize(width: cornerRadious, height: cornerRadious))
            let mask = CAShapeLayer()
            mask.path = path.cgPath
            self.layer.mask = mask
        }
    }

}

Answer 25

सरल विस्तार

extension UIView {
    func roundCorners(corners: UIRectCorner, radius: CGFloat) {
        if #available(iOS 11, *) {
            self.clipsToBounds = true
            self.layer.cornerRadius = radius
            var masked = CACornerMask()
            if corners.contains(.topLeft) { masked.insert(.layerMinXMinYCorner) }
            if corners.contains(.topRight) { masked.insert(.layerMaxXMinYCorner) }
            if corners.contains(.bottomLeft) { masked.insert(.layerMinXMaxYCorner) }
            if corners.contains(.bottomRight) { masked.insert(.layerMaxXMaxYCorner) }
            self.layer.maskedCorners = masked
        }
        else {
            let path = UIBezierPath(roundedRect: bounds, byRoundingCorners: corners, cornerRadii: CGSize(width: radius, height: radius))
            let mask = CAShapeLayer()
            mask.path = path.cgPath
            layer.mask = mask
        }
    }
}

उपयोग:

view.roundCorners(corners: [.bottomLeft, .bottomRight], radius: 12)