Есть ли простой способ разрешить взаимодействие с кнопкой в ​​UIView, который находится под другим UIView - где нет реальных объектов из верхнего UIView поверх кнопки?

Например, на данный момент у меня есть UIView (A) с объектом вверху и объектом внизу экрана и ничего в середине. Он находится поверх другого UIView с кнопками посередине (B). Однако я не могу взаимодействовать с кнопками в середине B.

Я вижу кнопки в B - я установил фон A на clearColor - но кнопки в B, похоже, не получают касаний, несмотря на то, что на самом деле поверх этих кнопок нет объектов из A.

РЕДАКТИРОВАТЬ - я все еще хочу иметь возможность взаимодействовать с объектами в верхнем UIView

Конечно, есть простой способ сделать это?

Вы должны создать подкласс UIView для вашего вида сверху и переопределить следующий метод:

- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event {
    // UIView will be "transparent" for touch events if we return NO
    return (point.y < MIDDLE_Y1 || point.y > MIDDLE_Y2);
}

Вы также можете посмотреть метод hitTest: event:.

Хотя многие ответы здесь будут работать, я немного удивлен, увидев, что наиболее удобный, общий и надежный ответ здесь не был дан. @Ash подошел ближе всего, за исключением того, что с возвратом супервизора происходит что-то странное ... не делайте этого.

Этот ответ взят из ответа, который я дал на аналогичный вопрос здесь .

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
{
    UIView *hitView = [super hitTest:point withEvent:event];
    if (hitView == self) return nil;
    return hitView;
}

[super hitTest:point withEvent:event]вернет самое глубокое представление в иерархии этого представления, которое было затронуто. Если hitView == self(то есть, если под точкой касания нет подпредставления), вернитесь nil, указав, что это представление не должно получать касание. То, как работает цепочка респондентов, означает, что иерархия представлений выше этой точки будет продолжаться до тех пор, пока не будет найдено представление, которое будет реагировать на касание. Не возвращайте супервизор, так как это не зависит от того, должен ли супервизор принимать прикосновения или нет!

Это решение:

• удобно , потому что не требует ссылок на какие-либо другие представления / подпредставления / объекты;
• общий , потому что он применяется к любому представлению, которое действует исключительно как контейнер для осязаемых подпредставлений, а конфигурация подпредставлений не влияет на способ его работы (как это происходит, если вы переопределяете, pointInside:withEvent:чтобы вернуть конкретную осязаемую область).
• надежный , кода не так много ... и эту концепцию нетрудно понять.

Я использую это достаточно часто, чтобы абстрагировать его в подкласс, чтобы сохранить бессмысленные подклассы представления для одного переопределения. В качестве бонуса добавьте свойство, чтобы сделать его настраиваемым:

@interface ISView : UIView
@property(nonatomic, assign) BOOL onlyRespondToTouchesInSubviews;
@end

@implementation ISView
- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
{
    UIView *hitView = [super hitTest:point withEvent:event];
    if (hitView == self && onlyRespondToTouchesInSubviews) return nil;
    return hitView;
}
@end

Затем сделайте шаг вперед и используйте этот вид везде, где вы можете использовать равнину UIView. Настройка его так просто , как установка onlyRespondToTouchesInSubviewsв YES.

Есть несколько способов справиться с этим. Я предпочитаю переопределить hitTest: withEvent: в представлении, которое является общим супервизором (возможно, косвенно) для конфликтующих представлений (похоже, вы называете их A и B). Например, что-то вроде этого (здесь A и B - указатели UIView, где B - «скрытый», обычно игнорируемый):

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event {
    CGPoint pointInB = [B convertPoint:point fromView:self];

    if ([B pointInside:pointInB withEvent:event])
        return B;

    return [super hitTest:point withEvent:event];
}

Вы также можете изменить pointInside:withEvent:метод в соответствии с предложением gyim. Это позволяет вам достичь практически того же результата, эффективно «протыкая дыру» в A, по крайней мере, для касаний.

Другой подход - пересылка событий, что означает переопределение touchesBegan:withEvent:и аналогичные методы (например, и touchesMoved:withEvent:т. Д.) Для отправки некоторых штрихов к другому объекту, а не к тому месту, где они были сначала. Например, в A можно написать что-то вроде этого:

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
    if ([self shouldForwardTouches:touches]) {
        [B touchesBegan:touches withEvent:event];
    }
    else {
        // Do whatever A does with touches.
    }
}

Однако это не всегда будет работать так, как вы ожидаете! Главное, чтобы встроенные элементы управления, такие как UIButton, всегда игнорировали перенаправленные касания. Из-за этого первый подход более надежен.

Есть хороший пост в блоге, объясняющий все это более подробно, а также небольшой рабочий проект xcode для демонстрации идей, доступный здесь:

http://bynomial.com/blog/?p=74

Ставить надо upperView.userInteractionEnabled = NO;, иначе прикосновения перехватит вид сверху.

Версия для Interface Builder - это флажок в нижней части панели «Атрибуты просмотра», который называется «Взаимодействие с пользователем включено». Снимите флажок, и все будет хорошо.

Пользовательская реализация pointInside: withEvent: действительно казалась подходящей, но работа с жестко заданными координатами казалась мне странной. В итоге я проверил, находится ли CGPoint внутри кнопки CGRect с помощью функции CGRectContainsPoint ():

- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event {
    return (CGRectContainsPoint(disclosureButton.frame, point));
}

Недавно я написал класс, который мне в этом поможет. Использование его в качестве настраиваемого класса для UIButtonили UIViewбудет передавать события касания, которые были выполнены на прозрачном пикселе.

Это решение несколько лучше, чем принятый ответ, потому что вы все равно можете щелкнуть значок, UIButtonкоторый находится под полупрозрачным, в UIViewто время как непрозрачная часть по- UIViewпрежнему будет реагировать на события касания.

Как вы можете видеть на GIF-изображении, кнопка Giraffe представляет собой простой прямоугольник, но события касания на прозрачных областях передаются желтому UIButtonцвету под ней.

Ссылка на класс

Думаю, я немного опоздал на эту вечеринку, но я добавлю следующее возможное решение:

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event {
    UIView *hitView = [super hitTest:point withEvent:event];
    if (hitView != self) return hitView;
    return [self superview];
}

Если вы используете этот код для переопределения стандартной функции hitTest пользовательского UIView, он будет игнорировать ТОЛЬКО само представление. Любые подпредставления этого представления будут возвращать свои обращения в обычном режиме, и любые обращения, которые были бы отправлены в само представление, передаются его суперпредставлению.

-Ash

Просто перебираю принятый ответ и помещаю его здесь для справки. Принятый ответ работает отлично. Вы можете расширить его следующим образом, чтобы позволить подпредставлениям вашего представления получать прикосновение ИЛИ передать его любым представлениям позади нас:

- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event {
    // If one of our subviews wants it, return YES
    for (UIView *subview in self.subviews) {
        CGPoint pointInSubview = [subview convertPoint:point fromView:self];
        if ([subview pointInside:pointInSubview withEvent:event]) {
            return YES;
        }
    }
    // otherwise return NO, as if userInteractionEnabled were NO
    return NO;
}

Примечание. Вам даже не нужно выполнять рекурсию в дереве вложенного представления, потому что каждый pointInside:withEvent:метод сделает это за вас.

Может помочь установка отключенного свойства userInteraction. Например:

UIView * topView = [[TOPView alloc] initWithFrame:[self bounds]];
[self addSubview:topView];
[topView setUserInteractionEnabled:NO];

(Примечание: в приведенном выше коде "self" относится к представлению)

Таким образом, вы можете отображать только в topView, но не получите вводимые пользователем данные. Все эти прикосновения пользователя будут проходить через это представление, и нижнее представление будет отвечать за них. Я бы использовал этот topView для отображения прозрачных изображений или их анимации.

Этот подход довольно чистый и позволяет прозрачным подпредставлениям также не реагировать на прикосновения. Просто создайте подкласс UIViewи добавьте к его реализации следующий метод:

@implementation PassThroughUIView

- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event {
    for (UIView *v in self.subviews) {
        CGPoint localPoint = [v convertPoint:point fromView:self];
        if (v.alpha > 0.01 && ![v isHidden] && v.userInteractionEnabled && [v pointInside:localPoint withEvent:event])
            return YES;
    }
    return NO;
}

@end

Мое решение здесь:

-(UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event {
    CGPoint pointInView = [self.toolkitController.toolbar convertPoint:point fromView:self];

    if ([self.toolkitController.toolbar pointInside:pointInView withEvent:event]) {
       self.userInteractionEnabled = YES;
    } else {
       self.userInteractionEnabled = NO;
    }

    return [super hitTest:point withEvent:event];
}

Надеюсь это поможет

Есть кое-что, что вы можете сделать, чтобы перехватить касание в обоих представлениях.

Вид сверху:

-(void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
   // Do code in the top view
   [bottomView touchesBegan:touches withEvent:event]; // And pass them on to bottomView
   // You have to implement the code for touchesBegan, touchesEnded, touchesCancelled in top/bottom view.
}

Но это идея.

Вот версия Swift:

override func pointInside(point: CGPoint, withEvent event: UIEvent?) -> Bool {
    return !CGRectContainsPoint(buttonView.frame, point)
}

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
}

Я никогда не создавал полный пользовательский интерфейс с использованием набора инструментов пользовательского интерфейса, поэтому у меня нет большого опыта работы с ним. Вот что, я думаю, должно работать.

Каждый UIView, а это UIWindow, имеет свойство subviews, которое представляет собой массив NSArray, содержащий все подвиды.

Первое вложенное представление, которое вы добавляете к представлению, получит индекс 0, следующее - 1 и так далее. Вы также можете заменить addSubview:на insertSubview: atIndex:или insertSubview:aboveSubview:и такие методы, которые могут определять положение вашего подпредставления в иерархии.

Поэтому проверьте свой код, чтобы увидеть, какое представление вы добавляете первым в свой UIWindow. Это будет 0, другое - 1.
Теперь из одного из ваших вложенных представлений, чтобы перейти к другому, вы должны сделать следующее:

UIView * theOtherView = [[[self superview] subviews] objectAtIndex: 0];
// or using the properties syntax
UIView * theOtherView = [self.superview.subviews objectAtIndex:0];

Сообщите мне, работает ли это в вашем случае!

(под этим маркером мой предыдущий ответ):

Если представлениям необходимо взаимодействовать друг с другом, они должны делать это через контроллер (то есть с использованием популярной модели MVC ).

Когда вы создаете новое представление, вы можете убедиться, что оно регистрируется в контроллере.

Таким образом, методика состоит в том, чтобы убедиться, что ваши представления регистрируются с помощью контроллера (который может хранить их по имени или как угодно в словаре или массиве). Либо вы можете заставить контроллер отправлять вам сообщение, либо вы можете получить ссылку на представление и напрямую общаться с ним.

Если в вашем представлении нет ссылки на контроллер (что может иметь место), вы можете использовать синглтоны и / или методы класса, чтобы получить ссылку на ваш контроллер.

Я думаю, что правильный способ - использовать цепочку представлений, встроенную в иерархию представлений. Для ваших вложенных представлений, которые помещаются в основное представление, не используйте общий UIView, а вместо этого подкласс UIView (или один из его вариантов, например UIImageView), чтобы сделать MYView: UIView (или любой другой супертип, который вы хотите, например UIImageView). В реализации YourView реализуйте метод touchesBegan. Затем этот метод будет вызван при касании этого представления. Все, что вам нужно в этой реализации, - это метод экземпляра:

- (void) touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event ;
{   // cannot handle this event. pass off to super
    [self.superview touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event]; }

this touchesBegan - это api респондента, поэтому вам не нужно объявлять его в публичном или частном интерфейсе; это одно из тех волшебных API, о которых вам просто нужно знать. Этот self.superview в конечном итоге передаст запрос к viewController. Затем в viewController реализуйте touchBegan для обработки прикосновения.

Обратите внимание, что место касания (CGPoint) автоматически настраивается относительно окружающего представления для вас, поскольку оно перемещается вверх по цепочке иерархии представлений.

Просто хочу опубликовать это, потому что у меня была несколько похожая проблема, я потратил значительное количество времени, пытаясь реализовать здесь ответы, но безуспешно. Что я в итоге сделал:

 for(UIGestureRecognizer *recognizer in topView.gestureRecognizers)
 {
     recognizer.delegate=self;
     [bottomView addGestureRecognizer:recognizer];   
 }
 topView.abView.userInteractionEnabled=NO; 

и реализуя UIGestureRecognizerDelegate:

- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
{
    return YES;
}

Вид снизу представлял собой навигационный контроллер с несколькими сегментами, и у меня была своего рода дверь наверху, которая могла закрываться с помощью жеста панорамирования. Все это было встроено в еще одну ВК. Работал как шарм. Надеюсь это поможет.

Внедрение Swift 4 для решения на основе HitTest

let hitView = super.hitTest(point, with: event)
if hitView == self { return nil }
return hitView

Полученный из превосходного и в основном надежного ответа Стюарта и полезной реализации Сегева, вот пакет Swift 4, который вы можете добавить в любой проект:

extension UIColor {
    static func colorOfPoint(point:CGPoint, in view: UIView) -> UIColor {

        var pixel: [CUnsignedChar] = [0, 0, 0, 0]

        let colorSpace = CGColorSpaceCreateDeviceRGB()
        let bitmapInfo = CGBitmapInfo(rawValue: CGImageAlphaInfo.premultipliedLast.rawValue)

        let context = CGContext(data: &pixel, width: 1, height: 1, bitsPerComponent: 8, bytesPerRow: 4, space: colorSpace, bitmapInfo: bitmapInfo.rawValue)

        context!.translateBy(x: -point.x, y: -point.y)

        view.layer.render(in: context!)

        let red: CGFloat   = CGFloat(pixel[0]) / 255.0
        let green: CGFloat = CGFloat(pixel[1]) / 255.0
        let blue: CGFloat  = CGFloat(pixel[2]) / 255.0
        let alpha: CGFloat = CGFloat(pixel[3]) / 255.0

        let color = UIColor(red:red, green: green, blue:blue, alpha:alpha)

        return color
    }
}

А затем с помощью hitTest:

override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
    guard UIColor.colorOfPoint(point: point, in: self).cgColor.alpha > 0 else { return nil }
    return super.hitTest(point, with: event)
}