Ho una domanda su UIButton e la sua area di successo. Sto usando il pulsante Info scuro nel generatore di interfaccia, ma sto scoprendo che l'area colpita non è abbastanza grande per le dita di alcune persone.

C'è un modo per aumentare l'area colpita di un pulsante in modo programmatico o in Interface Builder senza modificare le dimensioni del grafico InfoButton?

Dal momento che sto usando un'immagine di sfondo, nessuna di queste soluzioni ha funzionato bene per me. Ecco una soluzione che fa un po 'di divertente magia con obiettivo-c e offre una soluzione drop con un codice minimo.

Innanzitutto, aggiungi una categoria UIButtonche sovrascrive il hit test e aggiunge anche una proprietà per espandere il frame del hit test.

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

Una volta aggiunta questa classe, tutto ciò che devi fare è impostare gli inserti dei bordi del tuo pulsante. Nota che ho scelto di aggiungere gli inserti, quindi se vuoi allargare l'area colpita, devi usare numeri negativi.

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

Nota: ricorda di importare la categoria ( #import "UIButton+Extensions.h") nelle tue classi.

Basta impostare i valori di inserimento del bordo dell'immagine nel generatore di interfaccia.

Ecco una soluzione elegante che utilizza Extensions in Swift. Fornisce a tutti gli UIButton un'area di successo di almeno 44x44 punti, secondo le Human Interface Guidelines di Apple ( https://developer.apple.com/ios/human-interface-guidelines/visual-design/layout/ )

Swift 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
    }
}

Swift 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
    }
}

Puoi anche eseguire UIButtonuna sottoclasse o un'abitudine UIViewe sovrascrivere point(inside:with:)con qualcosa del tipo:

Swift 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);
}

Ecco UIButton di Chase + Extensions in Swift 3.0.

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)
    }
}

Per usarlo, puoi:

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

Ti consiglio di posizionare un pulsante UIB con il tipo personalizzato centrato sul pulsante informazioni. Ridimensiona il pulsante personalizzato in base alla dimensione desiderata per l'area colpita. Da lì hai due opzioni:

1. Seleziona l'opzione "Mostra tocco in evidenza" del pulsante personalizzato. Il bagliore bianco apparirà sopra il pulsante informazioni, ma nella maggior parte dei casi il dito dell'utente lo coprirà e tutto ciò che vedranno sarà il bagliore attorno all'esterno.

2. Impostare un IBOutlet per il pulsante Info e due IBActions per il pulsante personalizzato uno per "Touch Down" e uno per "Touch Up Inside". Quindi in Xcode imposta l'evento touchdown impostando la proprietà evidenziata del pulsante info su YES e l'evento touchupinside imposta la proprietà evidenziata su NO.

Non impostare la backgroundImageproprietà con la tua immagine, imposta la imageViewproprietà. Inoltre, assicurati di aver imageView.contentModeimpostato su UIViewContentModeCenter.

La mia soluzione su Swift 3:

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)
    }
}

Non c'è nulla di sbagliato nelle risposte presentate; tuttavia volevo estendere la risposta di jlarjlar in quanto ha un potenziale straordinario che può aggiungere valore allo stesso problema con altri controlli (ad esempio SearchBar). Questo perché poiché pointInside è collegato a una UIView, è possibile sottoclassare qualsiasi controllo per migliorare l'area touch. Questa risposta mostra anche un esempio completo di come implementare la soluzione completa.

Crea una nuova sottoclasse per il tuo pulsante (o qualsiasi controllo)

#import <UIKit/UIKit.h>

@interface MNGButton : UIButton

@end

Successivamente sovrascrivere il metodo pointInside nell'implementazione della sottoclasse

@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

Sul tuo file storyboard / xib seleziona il controllo in questione e apri la finestra di ispezione identità e digita il nome della tua classe personalizzata.

Nella classe UIViewController per la scena contenente il pulsante, cambia il tipo di classe per il pulsante con il nome della sottoclasse.

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

Collega il tuo pulsante storyboard / xib alla proprietà IBOutlet e l'area touch verrà espansa per adattarsi all'area definita nella sottoclasse.

Oltre a sovrascrivere il metodo pointInside insieme ai metodi CGRectInset e CGRectContainsPoint , si dovrebbe impiegare del tempo per esaminare la CGGeometry per estendere l'area di tocco rettangolare di qualsiasi sottoclasse UIView. Su NSHipster puoi trovare anche alcuni suggerimenti utili sui casi d'uso di CGGeometry .

Ad esempio, si potrebbe rendere irregolare l'area di tocco usando i metodi sopra menzionati o semplicemente scegliere di rendere l'area di tocco di larghezza due volte più grande dell'area di tocco orizzontale:

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

NB: la sostituzione di qualsiasi controllo della classe UI dovrebbe produrre risultati simili sull'estensione dell'area touch per controlli diversi (o qualsiasi sottoclasse UIView, come UIImageView, ecc.).

Questo funziona per me:

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)];

Non modificare il comportamento di UIButton.

@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

Sto usando un approccio più generico sfrecciando -[UIView pointInside:withEvent:]. Questo mi permette di modificare il comportamento del hit test su qualsiasi UIView, non soloUIButton .

Spesso, un pulsante viene posizionato all'interno di una vista contenitore che limita anche il hit testing. Ad esempio, quando un pulsante si trova nella parte superiore della vista di un contenitore e si desidera estendere il target del tocco verso l'alto, è necessario estendere anche il target del tocco della vista del container.

@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

La cosa bella di questo approccio è che puoi usarlo anche negli Storyboard aggiungendo un attributo di runtime definito dall'utente. Purtroppo, UIEdgeInsetsnon è direttamente disponibile come un tipo lì, ma dal momento che CGRectsi compone anche di una struttura con quattro CGFloatfunziona perfettamente scegliendo "Rect" e compilando i valori di questo tipo: {{top, left}, {bottom, right}}.

Sto usando la seguente classe in Swift, per abilitare anche una proprietà Interface Builder per regolare il margine:

@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)
    }
}

Bene, puoi posizionare il tuo UIButton all'interno di un UIView trasparente e leggermente più grande, quindi catturare gli eventi touch sull'istanza di UIView come in UIButton. In questo modo, avrai ancora il tuo pulsante, ma con un'area touch più grande. Dovrai gestire manualmente gli stati selezionati ed evidenziati con il pulsante se l'utente tocca la vista anziché il pulsante.

Un'altra possibilità consiste nell'utilizzare un UIImage invece di un UIButton.

Sono stato in grado di aumentare l'area di hit del pulsante informazioni a livello di codice. Il grafico "i" non cambia scala e rimane centrato nella nuova cornice del pulsante.

La dimensione del pulsante info sembra essere fissata a 18x19 [*] in Interface Builder. Collegandolo a un IBOutlet, sono stato in grado di modificare le dimensioni del frame nel codice senza problemi.

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 );
}

[*]: Le versioni successive di iOS sembrano aver aumentato l'area colpita del pulsante informazioni.

Questa è la mia soluzione Swift 3 (basata su questo post sul blog: 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
    }
}

Il hit test personalizzato di Chase implementato come sottoclasse di UIButton. Scritto in Objective-C.

Sembra funzionare sia per inite buttonWithType:costruttori. Per le mie esigenze è perfetto, ma da sottoclasseUIButton può essere pelosa, sarei interessato a sapere se qualcuno ha un difetto.

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

Implementazione tramite override UIButton ereditato.

Swift 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

Non ignorare mai il metodo nella categoria. Pulsante e sottoclasse della sottoclasse - pointInside:withEvent:. Ad esempio, se il lato del pulsante è inferiore a 44 px (che è consigliato come area minima toccabile), utilizzare questo:

- (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));
}

Ho creato una biblioteca proprio per questo scopo.

Puoi scegliere di utilizzare una UIViewcategoria, non è richiesta alcuna sottoclasse :

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

Oppure puoi sottoclassare il tuo UIView o UIButton e impostare il minimumHitTestWidthe / ominimumHitTestHeight . L'area di hit-test del pulsante verrà quindi rappresentata da questi 2 valori.

Proprio come altre soluzioni, utilizza il - (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)eventmetodo. Il metodo viene chiamato quando iOS esegue hit test. Questo post sul blog ha una buona descrizione del funzionamento dei test di successo di iOS.

https://github.com/kgaidis/KGHitTestingViews

@interface KGHitTestingButton : UIButton <KGHitTesting>

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

@end

Puoi anche solo subclassare e utilizzare Interface Builder senza scrivere alcun codice:

Basandoci sulla risposta di giaset sopra (che ho trovato la soluzione più elegante), ecco la versione rapida 3:

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
    }
}

È così semplice:

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

Questo è tutto.

Sto usando questo trucco per il pulsante all'interno di tableviewcell.accessoryView per ingrandire la sua area touch

#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];
}

Ho appena eseguito il port della soluzione @Chase in swift 2.2

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)
    }
}

uno che puoi usare in questo modo

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

Per qualsiasi altro riferimento, consultare https://stackoverflow.com/a/13067285/1728552

La risposta di @ antoine formattata per Swift 4

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 );
    }
}

Ho seguito la risposta di Chase e funziona benissimo, un singolo problema quando si crea l'arrea troppo grande, più grande della zona in cui il pulsante viene deselezionato (se la zona non era più grande) non chiama il selettore per l'evento UIControlEventTouchUpInside .

Penso che la dimensione sia superiore a 200 in qualsiasi direzione o qualcosa del genere.

Sono così in ritardo in questo gioco, ma volevo valutare una tecnica semplice che potesse risolvere i tuoi problemi. Ecco un tipico frammento UIButton programmatico per me:

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];

Sto caricando un'immagine png trasparente per il mio pulsante e impostando l'immagine di sfondo. Sto impostando il frame in base al UIImage e ridimensionandolo del 50% per la retina. OK, forse sei d'accordo con quanto sopra o no, MA se vuoi rendere l'area colpita PIÙ GRANDE e risparmiarti un mal di testa:

Quello che faccio, apro l'immagine in Photoshop e semplicemente aumenta la dimensione della tela al 120% e risparmia. In effetti, hai appena ingrandito l'immagine con pixel trasparenti.

Solo un approccio.

La risposta di @jlajlar sopra mi è sembrata buona e semplice ma non corrisponde a Xamarin.iOS, quindi l'ho convertita in Xamarin. Se stai cercando una soluzione su un Xamarin iOS, ecco qui:

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);
}

Puoi aggiungere questo metodo alla classe in cui stai sovrascrivendo UIView o UIImageView. Questo ha funzionato bene :)

Nessuna delle risposte funziona perfettamente per me, perché uso l'immagine di sfondo e un titolo su quel pulsante. Inoltre, il pulsante si ridimensionerà quando cambiano le dimensioni dello schermo.

Invece, ingrandisco l'area del rubinetto allargando l'area trasparente del png.