UIButton ve isabet alanıyla ilgili bir sorum var. Arayüz oluşturucuda Info Dark düğmesini kullanıyorum, ancak hit alanının bazı insanların parmakları için yeterince büyük olmadığını görüyorum.

InfoButton grafiğinin boyutunu değiştirmeden bir düğmenin vuruş alanını programlı olarak veya Arabirim Oluşturucu'da artırmanın bir yolu var mı?

Arka plan resmi kullandığım için, bu çözümlerin hiçbiri benim için iyi sonuç vermedi. İşte bazı eğlenceli objektif c sihir yapan ve minimum kod ile çözümde bir düşüş sunan bir çözüm.

İlk olarak, UIButtonisabet testini geçersiz kılan bir kategori ekleyin ve isabet testi çerçevesini genişletmek için bir özellik ekler.

UIButton + Extensions.h

@interface UIButton (Extensions)

@property(nonatomic, assign) UIEdgeInsets hitTestEdgeInsets;

@end

UIButton + Extensions.m

#import "UIButton+Extensions.h"
#import <objc/runtime.h>

@implementation UIButton (Extensions)

@dynamic hitTestEdgeInsets;

static const NSString *KEY_HIT_TEST_EDGE_INSETS = @"HitTestEdgeInsets";

-(void)setHitTestEdgeInsets:(UIEdgeInsets)hitTestEdgeInsets {
    NSValue *value = [NSValue value:&hitTestEdgeInsets withObjCType:@encode(UIEdgeInsets)];
    objc_setAssociatedObject(self, &KEY_HIT_TEST_EDGE_INSETS, value, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

-(UIEdgeInsets)hitTestEdgeInsets {
    NSValue *value = objc_getAssociatedObject(self, &KEY_HIT_TEST_EDGE_INSETS);
    if(value) {
        UIEdgeInsets edgeInsets; [value getValue:&edgeInsets]; return edgeInsets;
    }else {
        return UIEdgeInsetsZero;
    }
}

- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event {
    if(UIEdgeInsetsEqualToEdgeInsets(self.hitTestEdgeInsets, UIEdgeInsetsZero) || !self.enabled || self.hidden) {
        return [super pointInside:point withEvent:event];
    }

    CGRect relativeFrame = self.bounds;
    CGRect hitFrame = UIEdgeInsetsInsetRect(relativeFrame, self.hitTestEdgeInsets);

    return CGRectContainsPoint(hitFrame, point);
}

@end

Bu sınıf eklendiğinde, tek yapmanız gereken düğmenizin kenar iç metinlerini ayarlamaktır. Ekleri eklemeyi seçtiğime dikkat edin, böylece isabet alanını büyütmek istiyorsanız negatif sayılar kullanmalısınız.

[button setHitTestEdgeInsets:UIEdgeInsetsMake(-10, -10, -10, -10)];

Not: #import "UIButton+Extensions.h"Sınıflarınıza kategori ( ) aktarmayı unutmayın.

Arayüz oluşturucuda görüntü kenarı iç değerlerini ayarlamanız yeterlidir.

Swift'te Extensions kullanan zarif bir çözüm. Apple'ın İnsan Arayüz Kılavuzlarına göre tüm UIButton'lara en az 44x44 puanlık bir isabet alanı verir ( https://developer.apple.com/ios/human-interface-guidelines/visual-design/layout/ )

Hızlı 2:

private let minimumHitArea = CGSizeMake(44, 44)

extension UIButton {
    public override func hitTest(point: CGPoint, withEvent event: UIEvent?) -> UIView? {
        // if the button is hidden/disabled/transparent it can't be hit
        if self.hidden || !self.userInteractionEnabled || self.alpha < 0.01 { return nil }

        // increase the hit frame to be at least as big as `minimumHitArea`
        let buttonSize = self.bounds.size
        let widthToAdd = max(minimumHitArea.width - buttonSize.width, 0)
        let heightToAdd = max(minimumHitArea.height - buttonSize.height, 0)
        let largerFrame = CGRectInset(self.bounds, -widthToAdd / 2, -heightToAdd / 2)

        // perform hit test on larger frame
        return (CGRectContainsPoint(largerFrame, point)) ? self : nil
    }
}

Hızlı 3:

fileprivate let minimumHitArea = CGSize(width: 100, height: 100)

extension UIButton {
    open override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
        // if the button is hidden/disabled/transparent it can't be hit
        if self.isHidden || !self.isUserInteractionEnabled || self.alpha < 0.01 { return nil }

        // increase the hit frame to be at least as big as `minimumHitArea`
        let buttonSize = self.bounds.size
        let widthToAdd = max(minimumHitArea.width - buttonSize.width, 0)
        let heightToAdd = max(minimumHitArea.height - buttonSize.height, 0)
        let largerFrame = self.bounds.insetBy(dx: -widthToAdd / 2, dy: -heightToAdd / 2)

        // perform hit test on larger frame
        return (largerFrame.contains(point)) ? self : nil
    }
}

Ayrıca, alt sınıfı UIButtonveya özel bir öğeyi kullanabilir UIViewve aşağıdakilerle geçersiz kılabilirsiniz point(inside:with:):

Hızlı 3

override func point(inside point: CGPoint, with _: UIEvent?) -> Bool {
    let margin: CGFloat = 5
    let area = self.bounds.insetBy(dx: -margin, dy: -margin)
    return area.contains(point)
}

Objective-C

- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event {
    CGFloat margin = 5.0;
    CGRect area = CGRectInset(self.bounds, -margin, -margin);
    return CGRectContainsPoint(area, point);
}

İşte Swift 3.0'da Chase'in UIButton + Uzantıları.

import UIKit

private var pTouchAreaEdgeInsets: UIEdgeInsets = .zero

extension UIButton {

    var touchAreaEdgeInsets: UIEdgeInsets {
        get {
            if let value = objc_getAssociatedObject(self, &pTouchAreaEdgeInsets) as? NSValue {
                var edgeInsets: UIEdgeInsets = .zero
                value.getValue(&edgeInsets)
                return edgeInsets
            }
            else {
                return .zero
            }
        }
        set(newValue) {
            var newValueCopy = newValue
            let objCType = NSValue(uiEdgeInsets: .zero).objCType
            let value = NSValue(&newValueCopy, withObjCType: objCType)
            objc_setAssociatedObject(self, &pTouchAreaEdgeInsets, value, .OBJC_ASSOCIATION_RETAIN)
        }
    }

    open override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
        if UIEdgeInsetsEqualToEdgeInsets(self.touchAreaEdgeInsets, .zero) || !self.isEnabled || self.isHidden {
            return super.point(inside: point, with: event)
        }

        let relativeFrame = self.bounds
        let hitFrame = UIEdgeInsetsInsetRect(relativeFrame, self.touchAreaEdgeInsets)

        return hitFrame.contains(point)
    }
}

Kullanmak için şunları yapabilirsiniz:

button.touchAreaEdgeInsets = UIEdgeInsets(top: -10, left: -10, bottom: -10, right: -10)

Bilgi düğmenizin üzerinde ortalanmış Özel türüne sahip bir UIButton yerleştirmenizi öneririz. Özel düğmeyi, isabet alanının olmasını istediğiniz boyuta getirin. Oradan iki seçeneğiniz var:

1. Özel düğmenin 'Vurguda dokunmayı göster' seçeneğini işaretleyin. Beyaz ışıltı bilgi düğmesinin üzerinde görünecektir, ancak çoğu durumda kullanıcıların parmağı bunu kapsayacaktır ve görecekleri tek şey dışarıdaki ışıltıdır.

2. Bilgi düğmesi için bir IBOutlet ve biri 'Aşağıya Dokunuş' için özel düğme için ve diğeri 'İçeride Rötuş' için iki IBActions ayarlayın. Daha sonra Xcode'da, touchdown olayını bilgi düğmesinin vurgulanan özelliğini EVET olarak ve touchupinside olayı vurgulanan özelliği NO olarak ayarlayın.

Belirlemeyin backgroundImagegörüntü ile mülkiyet, set imageViewözelliği. Ayrıca, imageView.contentModeadresinde ayarladığınızdan emin olun UIViewContentModeCenter.

Swift 3'teki çözümüm:

class MyButton: UIButton {

    override open func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
        let relativeFrame = self.bounds
        let hitTestEdgeInsets = UIEdgeInsetsMake(-25, -25, -25, -25)
        let hitFrame = UIEdgeInsetsInsetRect(relativeFrame, hitTestEdgeInsets)
        return hitFrame.contains(point)
    }
}

Sunulan cevaplarda yanlış bir şey yok; Ancak jlarjlar'ın cevabını , diğer kontrollerle (örneğin SearchBar) aynı soruna değer katabilecek inanılmaz bir potansiyele sahip olarak genişletmek istedim . Bunun nedeni, pointInside bir UIView'a bağlı olduğu için, dokunma alanını geliştirmek için herhangi bir kontrolü alt sınıflandırabilmesidir . Bu cevap aynı zamanda komple çözümün nasıl uygulanacağının tam bir örneğini gösterir.

Düğmeniz (veya herhangi bir denetiminiz) için yeni bir alt sınıf oluşturun

#import <UIKit/UIKit.h>

@interface MNGButton : UIButton

@end

Ardından, alt sınıf uygulamanızdaki pointInside yöntemini geçersiz kılın

@implementation MNGButton


-(BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event
{
    //increase touch area for control in all directions by 20
    CGFloat margin = 20.0;
    CGRect area = CGRectInset(self.bounds, -margin, -margin);
    return CGRectContainsPoint(area, point);
}


@end

Film şeridi / xib dosyanızda söz konusu kontrolü seçin ve kimlik denetçisini açın ve özel sınıfınızın adını yazın.

Düğmeyi içeren sahne için UIViewController sınıfınızda, düğmenin sınıf türünü alt sınıfınızın adıyla değiştirin.

@property (weak, nonatomic) IBOutlet MNGButton *helpButton;

Film şeridi / xib düğmenizi IBOutlet özelliğine bağlayın; dokunma alanınız alt sınıfta tanımlanan alana uyacak şekilde genişletilir.

PointInside yöntemini CGRectInset ve CGRectContainsPoint yöntemleriyle birlikte geçersiz kılmanın yanı sıra , herhangi bir UIView alt sınıfının dikdörtgen dokunma alanını genişletmek için CGGeometry'nin incelenmesi zaman almalıdır . Ayrıca at CGGeometry kullanım senaryoları üzerinde bazı güzel ipuçları bulabilirsiniz NSHipster .

Örneğin, yukarıda belirtilen yöntemleri kullanarak dokunma alanını düzensiz hale getirebilir veya genişlik dokunma alanını yatay dokunma alanının iki katı kadar büyük yapmayı seçebiliriz:

CGRect area = CGRectInset(self.bounds, -(2*margin), -margin);

Not: Herhangi bir UI Sınıf kontrolünün değiştirilmesi, farklı kontroller (veya UIImageView, vb. Gibi herhangi bir UIView alt sınıfı) için dokunmatik alanın genişletilmesinde benzer sonuçlar üretmelidir.

Bu benim için çalışıyor:

UIButton *button = [UIButton buttonWithType: UIButtonTypeCustom];
// set the image (here with a size of 32 x 32)
[button setImage: [UIImage imageNamed: @"myimage.png"] forState: UIControlStateNormal];
// just set the frame of the button (here 64 x 64)
[button setFrame: CGRectMake(xPositionOfMyButton, yPositionOfMyButton, 64, 64)];

UIButton'un davranışını değiştirmeyin.

@interface ExtendedHitButton: UIButton

+ (instancetype) extendedHitButton;

- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event;

@end

@implementation ExtendedHitButton

+ (instancetype) extendedHitButton {
    return (ExtendedHitButton *) [ExtendedHitButton buttonWithType:UIButtonTypeCustom];
}

- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event {
    CGRect relativeFrame = self.bounds;
    UIEdgeInsets hitTestEdgeInsets = UIEdgeInsetsMake(-44, -44, -44, -44);
    CGRect hitFrame = UIEdgeInsetsInsetRect(relativeFrame, hitTestEdgeInsets);
    return CGRectContainsPoint(hitFrame, point);
}

@end

Ben swizzling tarafından daha genel bir yaklaşım kullanıyorum -[UIView pointInside:withEvent:]. Bu, isabet testi davranışını UIViewyalnızcaUIButton .

Çoğu zaman, bir konteyner görünümünün içine, isabet testini de sınırlayan bir düğme yerleştirilir. Örneğin, bir düğme kapsayıcı görünümünün üstündeyken ve dokunma hedefini yukarı doğru genişletmek istediğinizde, kapsayıcı görünümünün dokunma hedefini de uzatmanız gerekir.

@interface UIView(Additions)
@property(nonatomic) UIEdgeInsets hitTestEdgeInsets;
@end

@implementation UIView(Additions)

+ (void)load {
    Swizzle(self, @selector(pointInside:withEvent:), @selector(myPointInside:withEvent:));
}

- (BOOL)myPointInside:(CGPoint)point withEvent:(UIEvent *)event {

    if(UIEdgeInsetsEqualToEdgeInsets(self.hitTestEdgeInsets, UIEdgeInsetsZero) || self.hidden ||
       ([self isKindOfClass:UIControl.class] && !((UIControl*)self).enabled))
    {
        return [self myPointInside:point withEvent:event]; // original implementation
    }
    CGRect hitFrame = UIEdgeInsetsInsetRect(self.bounds, self.hitTestEdgeInsets);
    hitFrame.size.width = MAX(hitFrame.size.width, 0); // don't allow negative sizes
    hitFrame.size.height = MAX(hitFrame.size.height, 0);
    return CGRectContainsPoint(hitFrame, point);
}

static char hitTestEdgeInsetsKey;
- (void)setHitTestEdgeInsets:(UIEdgeInsets)hitTestEdgeInsets {
    objc_setAssociatedObject(self, &hitTestEdgeInsetsKey, [NSValue valueWithUIEdgeInsets:hitTestEdgeInsets], OBJC_ASSOCIATION_RETAIN);
}

- (UIEdgeInsets)hitTestEdgeInsets {
    return [objc_getAssociatedObject(self, &hitTestEdgeInsetsKey) UIEdgeInsetsValue];
}

void Swizzle(Class c, SEL orig, SEL new) {

    Method origMethod = class_getInstanceMethod(c, orig);
    Method newMethod = class_getInstanceMethod(c, new);

    if(class_addMethod(c, orig, method_getImplementation(newMethod), method_getTypeEncoding(newMethod)))
        class_replaceMethod(c, new, method_getImplementation(origMethod), method_getTypeEncoding(origMethod));
    else
        method_exchangeImplementations(origMethod, newMethod);
}
@end

Bu yaklaşımın güzel yanı, bunu Kullanıcı Tanımlı Çalışma Zamanı Özelliği ekleyerek Storyboard'larda bile kullanabilmenizdir. Ne yazık ki, UIEdgeInsetsorada bir türü olarak doğrudan kullanılamaz ancak o zamandan beri CGRectde dört ile bir yapı oluşur CGFloato "Rect" seçme ve bunun gibi değerlerle doldurarak kusursuz çalışır: {{top, left}, {bottom, right}}.

Ayrıca, bir arayüz oluşturucu özelliği kenar boşluğunu ayarlamak için etkinleştirmek için Swift, aşağıdaki sınıfı kullanıyorum:

@IBDesignable
class ALExtendedButton: UIButton {

    @IBInspectable var touchMargin:CGFloat = 20.0

    override func pointInside(point: CGPoint, withEvent event: UIEvent?) -> Bool {
        var extendedArea = CGRectInset(self.bounds, -touchMargin, -touchMargin)
        return CGRectContainsPoint(extendedArea, point)
    }
}

UIButton'unuzu şeffaf ve biraz daha büyük bir UIView içine yerleştirebilir ve ardından UIView örneğinde olduğu gibi UIView örneğinde dokunma olaylarını yakalayabilirsiniz. Bu şekilde, düğmeniz yine de olacak, ancak daha geniş bir dokunmatik alana sahip olacaksınız. Kullanıcı düğme yerine görünüme dokunursa, düğme ile seçilen ve vurgulanan durumlarla ilgilenmeniz gerekir.

Diğer olasılık, bir UIButton yerine bir UIImage kullanılmasını içerir.

Bilgi düğmesinin vuruş alanını programlı olarak artırabildim. "İ" grafiği ölçeği değiştirmez ve yeni düğme çerçevesinde ortalanmış olarak kalır.

Bilgi düğmesinin boyutu, Arayüz Oluşturucu'da 18x19 [*] olarak sabit gibi görünüyor. Bir IBOutlet'e bağlayarak, koddaki çerçeve boyutunu herhangi bir sorun olmadan değiştirebildim.

static void _resizeButton( UIButton *button )
{
    const CGRect oldFrame = infoButton.frame;
    const CGFloat desiredWidth = 44.f;
    const CGFloat margin = 
        ( desiredWidth - CGRectGetWidth( oldFrame ) ) / 2.f;
    infoButton.frame = CGRectInset( oldFrame, -margin, -margin );
}

[*]: İOS'un sonraki sürümlerinde bilgi düğmesinin isabet alanını artırdığı görülüyor.

Bu benim Swift 3 Çözümüm (bu blog yazısına dayanarak: http://bdunagan.com/2010/03/01/iphone-tip-larger-hit-area-for-uibutton/ )

class ExtendedHitAreaButton: UIButton {

    @IBInspectable var hitAreaExtensionSize: CGSize = CGSize(width: -10, height: -10)

    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {

        let extendedFrame: CGRect = bounds.insetBy(dx: hitAreaExtensionSize.width, dy: hitAreaExtensionSize.height)

        return extendedFrame.contains(point) ? self : nil
    }
}

Chase'in UIButton alt sınıfı olarak uygulanan özel isabet testi. Amaç-C ile yazılmıştır.

Hem iş gibi görünüyor initve buttonWithType:kurucular. Benim ihtiyaçlarım için mükemmel, ama alt sınıftan beriUIButton kıllı olabileceğinden, kimsenin onunla bir hatası olup olmadığını bilmek isterim.

CustomeHitAreaButton.h

#import <UIKit/UIKit.h>

@interface CustomHitAreaButton : UIButton

- (void)setHitTestEdgeInsets:(UIEdgeInsets)hitTestEdgeInsets;

@end

CustomHitAreaButton.m

#import "CustomHitAreaButton.h"

@interface CustomHitAreaButton()

@property (nonatomic, assign) UIEdgeInsets hitTestEdgeInsets;

@end

@implementation CustomHitAreaButton

- (instancetype)initWithFrame:(CGRect)frame {
    if(self = [super initWithFrame:frame]) {
        self.hitTestEdgeInsets = UIEdgeInsetsZero;
    }
    return self;
}

-(void)setHitTestEdgeInsets:(UIEdgeInsets)hitTestEdgeInsets {
    self->_hitTestEdgeInsets = hitTestEdgeInsets;
}

- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event {
    if(UIEdgeInsetsEqualToEdgeInsets(self.hitTestEdgeInsets, UIEdgeInsetsZero) || !self.enabled || self.hidden) {
        return [super pointInside:point withEvent:event];
    }
    CGRect relativeFrame = self.bounds;
    CGRect hitFrame = UIEdgeInsetsInsetRect(relativeFrame, self.hitTestEdgeInsets);
    return CGRectContainsPoint(hitFrame, point);
}

@end

Geçersiz kılınan UIButton aracılığıyla uygulama.

Hızlı 2.2 :

// don't forget that negative values are for outset
_button.hitOffset = UIEdgeInsets(top: -10, left: -10, bottom: -10, right: -10)
...
class UICustomButton: UIButton {
    var hitOffset = UIEdgeInsets()

    override func pointInside(point: CGPoint, withEvent event: UIEvent?) -> Bool {
        guard hitOffset != UIEdgeInsetsZero && enabled && !hidden else {
            return super.pointInside(point, withEvent: event)
        }
        return UIEdgeInsetsInsetRect(bounds, hitOffset).contains(point)
    }
}

WJBackgroundInsetButton.h

#import <UIKit/UIKit.h>

@interface WJBackgroundInsetButton : UIButton {
    UIEdgeInsets backgroundEdgeInsets_;
}

@property (nonatomic) UIEdgeInsets backgroundEdgeInsets;

@end

WJBackgroundInsetButton.m

#import "WJBackgroundInsetButton.h"

@implementation WJBackgroundInsetButton

@synthesize backgroundEdgeInsets = backgroundEdgeInsets_;

-(CGRect) backgroundRectForBounds:(CGRect)bounds {
    CGRect sup = [super backgroundRectForBounds:bounds];
    UIEdgeInsets insets = self.backgroundEdgeInsets;
    CGRect r = UIEdgeInsetsInsetRect(sup, insets);
    return r;
}

@end

Kategorideki yöntemi asla geçersiz kılmayın. Alt sınıf düğmesi ve geçersiz kılma - pointInside:withEvent:. Örneğin, düğmenizin tarafı 44 pikselden küçükse (minimum dokunma alanı olarak önerilir) bunu kullanın:

- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event
{
    return (ABS(point.x - CGRectGetMidX(self.bounds)) <= MAX(CGRectGetMidX(self.bounds), 22)) && (ABS(point.y - CGRectGetMidY(self.bounds)) <= MAX(CGRectGetMidY(self.bounds), 22));
}

Bunun için bir kütüphane yaptım .

Bir UIViewkategori kullanmayı seçebilirsiniz , alt sınıflama gerekmez :

@interface UIView (KGHitTesting)
- (void)setMinimumHitTestWidth:(CGFloat)width height:(CGFloat)height;
@end

Veya UIView veya UIButton'unuzu alt sınıflara ayırabilir ve minimumHitTestWidthve / veya ayarlayabilirsiniz minimumHitTestHeight. Düğme vuruş testi alanınız bu 2 değerle temsil edilir.

Diğer çözümler gibi, - (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)eventyöntemi kullanır . Yöntem, isabet testi gerçekleştirdiğinde çağrılır. Bu blog gönderisinde iOS hit testinin nasıl çalıştığı hakkında iyi bir açıklama var.

https://github.com/kgaidis/KGHitTestingViews

@interface KGHitTestingButton : UIButton <KGHitTesting>

@property (nonatomic) CGFloat minimumHitTestHeight; 
@property (nonatomic) CGFloat minimumHitTestWidth;

@end

Ayrıca, herhangi bir kod yazmadan sadece Ara Sınıf Oluşturucu'yu kullanabilir ve kullanabilirsiniz:

Giaset'in cevabına (en zarif çözümü bulduğum) dayanarak, işte hızlı 3 versiyonu:

import UIKit

fileprivate let minimumHitArea = CGSize(width: 44, height: 44)

extension UIButton {
    open override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
        // if the button is hidden/disabled/transparent it can't be hit
        if isHidden || !isUserInteractionEnabled || alpha < 0.01 { return nil }

        // increase the hit frame to be at least as big as `minimumHitArea`
        let buttonSize = bounds.size
        let widthToAdd = max(minimumHitArea.width - buttonSize.width, 0)
        let heightToAdd = max(minimumHitArea.height - buttonSize.height, 0)
        let largerFrame = bounds.insetBy(dx: -widthToAdd / 2, dy: -heightToAdd / 2)

        // perform hit test on larger frame
        return (largerFrame.contains(point)) ? self : nil
    }
}

Sadece bu kadar basit:

class ChubbyButton: UIButton {
    override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
        return bounds.insetBy(dx: -20, dy: -20).contains(point)
    }
}

Her şey bu.

Touchview alanını genişletmek için tableviewcell.accessoryView içindeki düğmeyi kullanıyorum

#pragma mark - Touches

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
    UITouch *touch                  = [touches anyObject];
    CGPoint location                = [touch locationInView:self];
    CGRect  accessoryViewTouchRect  = CGRectInset(self.accessoryView.frame, -15, -15);

    if(!CGRectContainsPoint(accessoryViewTouchRect, location))
        [super touchesBegan:touches withEvent:event];
}

- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event
{
    UITouch *touch                  = [touches anyObject];
    CGPoint location                = [touch locationInView:self];
    CGRect  accessoryViewTouchRect  = CGRectInset(self.accessoryView.frame, -15, -15);

    if(CGRectContainsPoint(accessoryViewTouchRect, location) && [self.accessoryView isKindOfClass:[UIButton class]])
    {
        [(UIButton *)self.accessoryView sendActionsForControlEvents:UIControlEventTouchUpInside];
    }
    else
        [super touchesEnded:touches withEvent:event];
}

@Chase çözümünün portunu hızlı 2.2'de yaptım

import Foundation
import ObjectiveC

private var hitTestEdgeInsetsKey: UIEdgeInsets = UIEdgeInsetsZero

extension UIButton {
    var hitTestEdgeInsets:UIEdgeInsets {
        get {
            let inset = objc_getAssociatedObject(self, &hitTestEdgeInsetsKey) as? NSValue ?? NSValue(UIEdgeInsets: UIEdgeInsetsZero)
            return inset.UIEdgeInsetsValue()
        }
        set {
            let inset = NSValue(UIEdgeInsets: newValue)
            objc_setAssociatedObject(self, &hitTestEdgeInsetsKey, inset, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }

    public override func pointInside(point: CGPoint, withEvent event: UIEvent?) -> Bool {
        guard !UIEdgeInsetsEqualToEdgeInsets(hitTestEdgeInsets, UIEdgeInsetsZero) && self.enabled == true && self.hidden == false else {
            return super.pointInside(point, withEvent: event)
        }
        let relativeFrame = self.bounds
        let hitFrame = UIEdgeInsetsInsetRect(relativeFrame, hitTestEdgeInsets)
        return CGRectContainsPoint(hitFrame, point)
    }
}

böyle kullanabilirsiniz

button.hitTestEdgeInsets = UIEdgeInsetsMake(-10, -10, -10, -10)

Başka referanslar için bkz. Https://stackoverflow.com/a/13067285/1728552

@ antoine cevabı Swift 4 için biçimlendirildi

class ExtendedHitButton: UIButton
{
    override func point( inside point: CGPoint, with event: UIEvent? ) -> Bool
    {
        let relativeFrame = self.bounds
        let hitTestEdgeInsets = UIEdgeInsetsMake( -44, -44, -44, -44 ) // Apple recommended hit target
        let hitFrame = UIEdgeInsetsInsetRect( relativeFrame, hitTestEdgeInsets )
        return hitFrame.contains( point );
    }
}

Chase'in yanıtını izledim ve harika çalışıyor, arrea'yı çok büyük, düğmenin seçiminin kaldırıldığı bölgeden daha büyük oluşturduğunuzda (bölge daha büyük değilse) UIControlEventTouchUpInside olayı için seçici çağırmıyor .

Bence boyutu herhangi bir yön ya da bunun gibi bir şey 200 üzerinde.

Bu oyuna çok geç kaldım, ancak sorunlarınızı çözebilecek basit bir tekniğe ağırlık vermek istedim. İşte benim için tipik bir programlı UIButton snippet'i:

UIImage *arrowImage = [UIImage imageNamed:@"leftarrow"];
arrowButton = [[UIButton alloc] initWithFrame:CGRectMake(15.0, self.frame.size.height-35.0, arrowImage.size.width/2, arrowImage.size.height/2)];
[arrowButton setBackgroundImage:arrowImage forState:UIControlStateNormal];
[arrowButton addTarget:self action:@selector(onTouchUp:) forControlEvents:UIControlEventTouchUpOutside];
[arrowButton addTarget:self action:@selector(onTouchDown:) forControlEvents:UIControlEventTouchDown];
[arrowButton addTarget:self action:@selector(onTap:) forControlEvents:UIControlEventTouchUpInside];
[arrowButton addTarget:self action:@selector(onTouchUp:) forControlEvents:UIControlEventTouchDragExit];
[arrowButton setUserInteractionEnabled:TRUE];
[arrowButton setAdjustsImageWhenHighlighted:NO];
[arrowButton setTag:1];
[self addSubview:arrowButton];

Düğmem için şeffaf bir png resmi yüklüyorum ve arka plan resmini ayarlıyorum. Çerçeveyi UIImage'a göre ayarlıyorum ve retina için% 50 ölçeklendiriyorum. Tamam, belki yukarıdakileri kabul edersiniz ya da etmezsiniz, ancak hit alanı BÜYÜK yapmak ve kendinizi baş ağrısından kurtarmak istiyorsanız:

Yaptığım şey, görüntüyü photoshop'ta açın ve tuval boyutunu% 120'ye artırın ve kaydedin. Etkili saydam piksellerle görüntüyü daha büyük hale getirdiniz.

Sadece bir yaklaşım.

@jlajlar'ın yukarıdaki cevabı iyi ve anlaşılır görünüyordu, ancak Xamarin.iOS ile eşleşmiyor, bu yüzden Xamarin'e dönüştürdüm. Bir Xamarin iOS'ta bir çözüm arıyorsanız, işte burada:

public override bool PointInside (CoreGraphics.CGPoint point, UIEvent uievent)
{
    var margin = -10f;
    var area = this.Bounds;
    var expandedArea = area.Inset(margin, margin);
    return expandedArea.Contains(point);
}

Bu yöntemi, UIView veya UIImageView'ı geçersiz kıldığınız sınıfa ekleyebilirsiniz. Bu güzel çalıştı :)

Cevapların hiçbiri benim için mükemmel değil, çünkü o düğme üzerinde arka plan resmi ve başlık kullanıyorum. Ayrıca, ekran boyutu değiştikçe düğme yeniden boyutlandırılır.

Bunun yerine, png saydam alanını daha büyük hale getirerek musluk alanını genişletiyorum.