Obsługa zdarzeń dla iOS - jak hitTest:withEvent: i pointInside:withEvent: są powiązane?

Myślę, że mylisz podklasowanie z hierarchią widoków. To, co mówi doktor, jest następujące. Powiedzmy, że masz taką hierarchię widoków. Według hierarchii nie mówię o hierarchii klas, ale o widokach w hierarchii widoków, w następujący sposób:

+----------------------------+
|A                           |
|+--------+   +------------+ |
||B       |   |C           | |
||        |   |+----------+| |
|+--------+   ||D         || |
|             |+----------+| |
|             +------------+ |
+----------------------------+

Powiedz, że włożysz palec do środka D. Oto co się stanie:

1. {[2] } jest wywoływany na A, najwyższym widoku hierarchii widoków.
2. pointInside:withEvent: jest wywoływana rekurencyjnie w każdym widoku.
   1. pointInside:withEvent: jest wywoływana A, oraz zwraca YES
   2. pointInside:withEvent: jest wywołane na B i zwraca NO
   3. pointInside:withEvent: jest wywołane na {[12] } i zwraca YES
   4. pointInside:withEvent: jest wywołane na {[1] } i zwraca YES
3. w widokach, które zwróciły YES, spojrzy w dół hierarchii, aby zobaczyć subview, w którym miało miejsce dotknięcie. W tym przypadku od A, C i D, będzie D.
4. D będzie Widok hit-test

Jest to bardzo pomocne w testowaniu trafień w systemie iOS.]}

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event {
    if (!self.isUserInteractionEnabled || self.isHidden || self.alpha <= 0.01) {
        return nil;
    }
    if ([self pointInside:point withEvent:event]) {
        for (UIView *subview in [self.subviews reverseObjectEnumerator]) {
            CGPoint convertedPoint = [subview convertPoint:point fromView:self];
            UIView *hitTestView = [subview hitTest:convertedPoint withEvent:event];
            if (hitTestView) {
                return hitTestView;
            }
        }
        return self;
    }
    return nil;
}

Edytuj Swift 4:

override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
    if self.point(inside: point, with: event) {
        return super.hitTest(point, with: event)
    }
    guard isUserInteractionEnabled, !isHidden, alpha > 0 else {
        return nil
    }

    for subview in subviews.reversed() {
        let convertedPoint = subview.convert(point, from: self)
        if let hitView = subview.hitTest(convertedPoint, with: event) {
            return hitView
        }
    }
    return nil
}

Dzięki za odpowiedzi, pomogli mi rozwiązać sytuację z" overlay " widoki.

+----------------------------+
|A +--------+                |
|  |B  +------------------+  |
|  |   |C            X    |  |
|  |   +------------------+  |
|  |        |                |
|  +--------+                | 
|                            |
+----------------------------+

Załóżmy X - dotyk użytkownika. pointInside:withEvent: on B zwraca NO, więc hitTest:withEvent: zwraca A. Napisałem kategorię na UIView, aby poradzić sobie z problemem, gdy musisz otrzymać dotyk na górze najbardziej widoczny widok.

- (UIView *)overlapHitTest:(CGPoint)point withEvent:(UIEvent *)event {
    // 1
    if (!self.userInteractionEnabled || [self isHidden] || self.alpha == 0)
        return nil;

    // 2
    UIView *hitView = self;
    if (![self pointInside:point withEvent:event]) {
        if (self.clipsToBounds) return nil;
        else hitView = nil;
    }

    // 3
    for (UIView *subview in [self.subviewsreverseObjectEnumerator]) {
        CGPoint insideSubview = [self convertPoint:point toView:subview];
        UIView *sview = [subview overlapHitTest:insideSubview withEvent:event];
        if (sview) return sview;
    }

    // 4
    return hitView;
}

Nie należy wysyłać zdarzeń dotykowych dla widoków ukrytych lub przezroczystych, ani widoków z userInteractionEnabled ustawionym na NO;
1. Jeśli dotyk jest w środku self, self będą rozpatrywane jako potencjalny wynik.
2. Sprawdź rekurencyjnie wszystkie podviews dla hit. Jeśli w ogóle, zwróć go.
3. Else zwraca self lub nil w zależności od wyniku z kroku 2.

Uwaga, [self.subviewsreverseObjectEnumerator] potrzebne do śledzenia hierarchii widoku od góry do dołu. I sprawdź clipsToBounds, aby upewnić się, że nie testuje zamaskowanych podviewów.

Użycie:

1. Importuj kategorię w podklasowanym widoku.
2. Zastąp {[7] } tym

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event {
    return [self overlapHitTest:point withEvent:event];
}

Oficjalny poradnik Apple ' a zawiera kilka dobre ilustracje też.

To pokazuje jak ten fragment!

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
{
    if (self.hidden || !self.userInteractionEnabled || self.alpha < 0.01)
    {
        return nil;
    }

    if (![self pointInside:point withEvent:event])
    {
        return nil;
    }

    __block UIView *hitView = self;

    [self.subViews enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {   

        CGPoint thePoint = [self convertPoint:point toView:obj];

        UIView *theSubHitView = [obj hitTest:thePoint withEvent:event];

        if (theSubHitView != nil)
        {
            hitView = theSubHitView;

            *stop = YES;
        }

    }];

    return hitView;
}

Fragment @ lion działa jak czar. Przeportowałem go do swift 2.1 i użyłem go jako rozszerzenia do UIView. Wrzucam to tutaj na wypadek, gdyby ktoś tego potrzebował.

extension UIView {
    func overlapHitTest(point: CGPoint, withEvent event: UIEvent?) -> UIView? {
        // 1
        if !self.userInteractionEnabled || self.hidden || self.alpha == 0 {
            return nil
        }
        //2
        var hitView: UIView? = self
        if !self.pointInside(point, withEvent: event) {
            if self.clipsToBounds {
                return nil
            } else {
                hitView = nil
            }
        }
        //3
        for subview in self.subviews.reverse() {
            let insideSubview = self.convertPoint(point, toView: subview)
            if let sview = subview.overlapHitTest(insideSubview, withEvent: event) {
                return sview
            }
        }
        return hitView
    }
}

Aby go użyć, wystarczy zastąpić hitTest: point: withEvent w interfejsie użytkownika w następujący sposób:

override func hitTest(point: CGPoint, withEvent event: UIEvent?) -> UIView? {
    let uiview = super.hitTest(point, withEvent: event)
    print("hittest",uiview)
    return overlapHitTest(point, withEvent: event)
}