Come posso fare clic su un pulsante dietro una UIView trasparente?

Supponiamo di avere un controller di visualizzazione con una vista secondaria. la sottoview occupa il centro dello schermo con margini di 100 px su tutti i lati. Aggiungiamo quindi un mucchio di piccole cose su cui fare clic all'interno della sottoview. Stiamo solo usando la vista secondaria per sfruttare il nuovo frame (x = 0, y = 0 all'interno della vista secondaria è in realtà 100.100 nella vista padre).

Quindi, immagina di avere qualcosa dietro la sottoview, come un menu. Voglio che l'utente sia in grado di selezionare una qualsiasi delle "piccole cose" nella sottoview, ma se non c'è nulla lì, voglio che i tocchi passino attraverso di essa (dato che lo sfondo è comunque chiaro) ai pulsanti dietro di essa.

Come posso fare questo? Sembra che tocchi Began, ma i pulsanti non funzionano.

Crea una vista personalizzata per il tuo contenitore e sovrascrivi il puntoInside: messaggio per restituire falso quando il punto non rientra in una vista figlio idonea, in questo modo:

Swift:

class PassThroughView: UIView {
    override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
        for subview in subviews {
            if !subview.isHidden && subview.isUserInteractionEnabled && subview.point(inside: convert(point, to: subview), with: event) {
                return true
            }
        }
        return false
    }
}

Obiettivo C:

@interface PassthroughView : UIView
@end

@implementation PassthroughView
-(BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event {
    for (UIView *view in self.subviews) {
        if (!view.hidden && view.userInteractionEnabled && [view pointInside:[self convertPoint:point toView:view] withEvent:event])
            return YES;
    }
    return NO;
}
@end

L'uso di questa vista come contenitore consentirà a tutti i suoi figli di ricevere tocchi ma la vista stessa sarà trasparente agli eventi.

Anche io uso

myView.userInteractionEnabled = NO;

Non è necessario effettuare la sottoclasse. Funziona bene.

Da Apple:

L'inoltro di eventi è una tecnica utilizzata da alcune applicazioni. Inoltri gli eventi tocco invocando i metodi di gestione degli eventi di un altro oggetto responder. Sebbene questa possa essere una tecnica efficace, dovresti usarla con cautela. Le classi del framework UIKit non sono progettate per ricevere tocchi che non sono associati a loro .... Se si desidera inoltrare in modo condizionale tocchi ad altri responder nella propria applicazione, tutti questi risponditori dovrebbero essere istanze delle proprie sottoclassi di UIView.

Best practice sulle mele :

Non inviare esplicitamente eventi nella catena del risponditore (tramite nextResponder); invoca invece l'implementazione della superclasse e lascia che UIKit gestisca l'attraversamento della catena di risposta.

invece puoi sovrascrivere:

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

nella sottoclasse UIView e restituisci NO se desideri che quel tocco venga inviato nella catena del risponditore (IE per le visualizzazioni dietro la tua vista che non contiene nulla).

Un modo molto più semplice è quello di "Un-Check" Interazione utente abilitata nel builder di interfacce. "Se stai usando uno storyboard"

Sulla base di ciò che John ha pubblicato, ecco un esempio che consentirà agli eventi touch di passare attraverso tutte le visualizzazioni secondarie di una vista ad eccezione dei pulsanti:

-(BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event
{
    // Allow buttons to receive press events.  All other views will get ignored
    for( id foundView in self.subviews )
    {
        if( [foundView isKindOfClass:[UIButton class]] )
        {
            UIButton *foundButton = foundView;

            if( foundButton.isEnabled  &&  !foundButton.hidden &&  [foundButton pointInside:[self convertPoint:point toView:foundButton] withEvent:event] )
                return YES;
        }        
    }
    return NO;
}

Ultimamente ho scritto un corso che mi aiuterà in questo. Usandolo come una classe personalizzata per un UIButtono UIViewpasserà eventi touch che sono stati eseguiti su un pixel trasparente.

Questa soluzione è in qualche modo migliore della risposta accettata perché è ancora possibile fare clic su una UIButtonsotto semitrasparente UIViewmentre la parte non trasparente UIViewrisponderà comunque agli eventi di tocco.

Come puoi vedere nella GIF, il pulsante Giraffe è un semplice rettangolo ma gli eventi di tocco su aree trasparenti vengono passati al giallo UIButtonsotto.

Link alla lezione

La soluzione più votata non funzionava completamente per me, suppongo che fosse perché avevo un TabBarController nella gerarchia (come sottolinea uno dei commenti) stava infatti passando tocchi ad alcune parti dell'interfaccia utente ma stava facendo casino con il mio La capacità di tableView di intercettare gli eventi di tocco, quello che alla fine ha fatto è stato scavalcare hitTest nella vista Voglio ignorare i tocchi e lasciare che le subview di quella vista li gestiscano

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event{
    UIView *view = [super hitTest:point withEvent:event];
    if (view == self) {
        return nil; //avoid delivering touch events to the container view (self)
    }
    else{
        return view; //the subviews will still receive touch events
    }
}

Swift 3

override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
    for subview in subviews {
        if subview.frame.contains(point) {
            return true
        }
    }
    return false
}

Secondo la "Guida alla programmazione delle applicazioni iPhone":

Disattivazione della consegna di eventi touch. Per impostazione predefinita, una vista riceve eventi touch, ma è possibile impostare la proprietà userInteractionEnabled su NO per disattivare la consegna degli eventi. Una vista inoltre non riceve eventi se è nascosta o se è trasparente .

http://developer.apple.com/iphone/library/documentation/iPhone/Conceptual/iPhoneOSProgrammingGuide/EventHandling/EventHandling.html

Aggiornato : esempio rimosso - rileggi la domanda ...

Hai qualche elaborazione gestuale nelle viste che potrebbe elaborare i tocchi prima che il pulsante lo ottenga? Il pulsante funziona quando non hai la vista trasparente su di esso?

Qualche esempio di codice di codice non funzionante?

Per quanto ne so, dovresti essere in grado di farlo ignorando il metodo hitTest : . L'ho provato ma non sono riuscito a farlo funzionare correttamente.

Alla fine ho creato una serie di viste trasparenti attorno all'oggetto toccabile in modo che non lo coprissero. Un po 'di hack per il mio problema ha funzionato bene.

Prendendo suggerimenti dalle altre risposte e leggendo la documentazione di Apple, ho creato questa semplice libreria per risolvere il tuo problema:
https://github.com/natrosoft/NATouchThroughView
Rende facile disegnare viste in Interface Builder che dovrebbero passare i tocchi attraverso una visione di base.

Penso che il metodo di swizzling sia eccessivo e molto pericoloso da fare nel codice di produzione perché stai scherzando direttamente con l'implementazione di base di Apple e stai apportando una modifica a livello di applicazione che potrebbe causare conseguenze indesiderate.

C'è un progetto dimostrativo e speriamo che il README faccia un buon lavoro spiegando cosa fare. Per indirizzare l'OP, è necessario modificare l'UIView chiaro che contiene i pulsanti nella classe NATouchThroughView in Interface Builder. Quindi trova UIView chiaro che si sovrappone al menu che desideri abilitare al tocco. Cambia l'UIView nella classe NARootTouchThroughView in Interface Builder. Può persino essere l'UIView principale del controller della vista se si desidera che quei tocchi passino al controller della vista sottostante. Dai un'occhiata al progetto demo per vedere come funziona. È davvero abbastanza semplice, sicuro e non invasivo

Ho creato una categoria per farlo.

un piccolo metodo sfrigolante e la vista è d'oro.

L'intestazione

//UIView+PassthroughParent.h
@interface UIView (PassthroughParent)

- (BOOL) passthroughParent;
- (void) setPassthroughParent:(BOOL) passthroughParent;

@end

Il file di implementazione

#import "UIView+PassthroughParent.h"

@implementation UIView (PassthroughParent)

+ (void)load{
    Swizz([UIView class], @selector(pointInside:withEvent:), @selector(passthroughPointInside:withEvent:));
}

- (BOOL)passthroughParent{
    NSNumber *passthrough = [self propertyValueForKey:@"passthroughParent"];
    if (passthrough) return passthrough.boolValue;
    return NO;
}
- (void)setPassthroughParent:(BOOL)passthroughParent{
    [self setPropertyValue:[NSNumber numberWithBool:passthroughParent] forKey:@"passthroughParent"];
}

- (BOOL)passthroughPointInside:(CGPoint)point withEvent:(UIEvent *)event{
    // Allow buttons to receive press events.  All other views will get ignored
    if (self.passthroughParent){
        if (self.alpha != 0 && !self.isHidden){
            for( id foundView in self.subviews )
            {
                if ([foundView alpha] != 0 && ![foundView isHidden] && [foundView pointInside:[self convertPoint:point toView:foundView] withEvent:event])
                    return YES;
            }
        }
        return NO;
    }
    else {
        return [self passthroughPointInside:point withEvent:event];// Swizzled
    }
}

@end

Dovrai aggiungere i miei Swizz.h e Swizz.m

situato qui

Successivamente, devi solo importare UIView + PassthroughParent.h nel tuo file {Project} -Prefix.pch e ogni vista avrà questa capacità.

ogni vista prenderà punti, ma nessuno spazio vuoto lo farà.

Consiglio anche di usare uno sfondo chiaro.

myView.passthroughParent = YES;
myView.backgroundColor = [UIColor clearColor];

MODIFICARE

Ho creato la mia borsa di proprietà, che non era inclusa in precedenza.

File di intestazione

// NSObject+PropertyBag.h

#import <Foundation/Foundation.h>

@interface NSObject (PropertyBag)

- (id) propertyValueForKey:(NSString*) key;
- (void) setPropertyValue:(id) value forKey:(NSString*) key;

@end

File di implementazione

// NSObject+PropertyBag.m

#import "NSObject+PropertyBag.h"



@implementation NSObject (PropertyBag)

+ (void) load{
    [self loadPropertyBag];
}

+ (void) loadPropertyBag{
    @autoreleasepool {
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            Swizz([NSObject class], NSSelectorFromString(@"dealloc"), @selector(propertyBagDealloc));
        });
    }
}

__strong NSMutableDictionary *_propertyBagHolder; // Properties for every class will go in this property bag
- (id) propertyValueForKey:(NSString*) key{
    return [[self propertyBag] valueForKey:key];
}
- (void) setPropertyValue:(id) value forKey:(NSString*) key{
    [[self propertyBag] setValue:value forKey:key];
}
- (NSMutableDictionary*) propertyBag{
    if (_propertyBagHolder == nil) _propertyBagHolder = [[NSMutableDictionary alloc] initWithCapacity:100];
    NSMutableDictionary *propBag = [_propertyBagHolder valueForKey:[[NSString alloc] initWithFormat:@"%p",self]];
    if (propBag == nil){
        propBag = [NSMutableDictionary dictionary];
        [self setPropertyBag:propBag];
    }
    return propBag;
}
- (void) setPropertyBag:(NSDictionary*) propertyBag{
    if (_propertyBagHolder == nil) _propertyBagHolder = [[NSMutableDictionary alloc] initWithCapacity:100];
    [_propertyBagHolder setValue:propertyBag forKey:[[NSString alloc] initWithFormat:@"%p",self]];
}

- (void)propertyBagDealloc{
    [self setPropertyBag:nil];
    [self propertyBagDealloc];//Swizzled
}

@end

Se non ti preoccupi di usare una UIView di categoria o sottoclasse, puoi anche portare avanti il ​​pulsante in modo che sia davanti alla vista trasparente. Questo non sarà sempre possibile a seconda dell'applicazione, ma ha funzionato per me. Puoi sempre riportare nuovamente il pulsante o nasconderlo.

Prova questo

class PassthroughToWindowView: UIView {
        override func test(_ point: CGPoint, with event: UIEvent?) -> UIView? {
            var view = super.hitTest(point, with: event)
            if view != self {
                return view
            }

            while !(view is PassthroughWindow) {
                view = view?.superview
            }
            return view
        }
    } 

Prova a impostare un backgroundColortuo transparentViewas UIColor(white:0.000, alpha:0.020). Quindi è possibile ottenere eventi tocco in touchesBegan/ touchesMovedmetodi. Posiziona il codice in basso da qualche parte in cui viene visualizzata la tua vista:

self.alpha = 1
self.backgroundColor = UIColor(white: 0.0, alpha: 0.02)
self.isMultipleTouchEnabled = true
self.isUserInteractionEnabled = true

Lo uso al posto del metodo override point (dentro: CGPoint, con: UIEvent)

  override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
        guard self.point(inside: point, with: event) else { return nil }
        return self
    }