Bir UIView'de başka bir UIView altında bulunan bir düğmeyle etkileşime izin vermenin basit bir yolu var mı?

Örneğin, şu anda ekranın üstünde bir nesne ve ekranın altında bir nesne olan ve ortasında hiçbir şey olmayan bir UIView (A) var. Bu, ortasında (B) düğmeleri olan başka bir UIView'ın üstüne oturur. Ancak, B.'nin ortasındaki düğmelerle etkileşim kuramıyorum.

B'de düğmeleri görebiliyorum - A'nın arka planını clearColor olarak ayarladım - ancak B'deki düğmeler, aslında bu düğmelerin üstünde A'dan herhangi bir nesne olmamasına rağmen dokunuş almıyor gibi görünüyor.

DÜZENLE - Yine de üst UIV görünümündeki nesnelerle etkileşimde bulunabilmek istiyorum

Elbette bunu yapmanın basit bir yolu var mı?

Üstten görünümünüz için bir UIView alt sınıfı oluşturmalı ve aşağıdaki yöntemi geçersiz kılmalısınız:

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

Ayrıca hitTest: event: method'a da bakabilirsiniz.

Buradaki cevapların çoğu işe yarayacak olsa da, en uygun, genel ve kusursuz cevabın burada verilmediğini görünce biraz şaşırdım. @ Ash en yakın geldi, ancak süpervizyona dönerken garip bir şeyler oluyor ... bunu yapma.

Bu cevap, burada benzer bir soruya verdiğim cevaptan alınmıştır .

- (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]dokunulan o görünümün hiyerarşisindeki en derin görünümü döndürür. Eğer hitView == self(yani temas noktasının altında alt nilgörünüm yoksa ), bu görünümün dokunmayı almaması gerektiğini belirterek geri dönün . Yanıtlayıcı zincirinin çalışma şekli, bu noktanın üzerindeki görünüm hiyerarşisinin, dokunmaya yanıt verecek bir görünüm bulunana kadar geçilmeye devam edeceği anlamına gelir.Etmeyin onun Superview dokunuşlar veya olmasın kabul edip, etmemeye Bu görüşe kadar olmadığı için, Superview dönüş!

Bu çözüm:

• uygun , çünkü diğer görünümlere / alt görünümlere / nesnelere referans gerektirmez;
• genel , çünkü yalnızca dokunulabilir alt görünümler için bir kapsayıcı görevi gören herhangi bir görünüm için geçerlidir ve alt görünümlerin yapılandırması, çalışma şeklini etkilemez ( pointInside:withEvent:belirli bir dokunulabilir alanı geri döndürmek için geçersiz kılmanız durumunda olduğu gibi ).
• kusursuz , çok fazla kod yok ... ve kavramın kafanızı karıştırması zor değil.

Bunu, bir geçersiz kılma için anlamsız görünüm alt sınıflarını kaydetmek için bir alt sınıfa soyutlayacak kadar sık ​​kullanıyorum. Bonus olarak, yapılandırılabilir hale getirmek için bir mülk ekleyin:

@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

O zaman vahşileşin ve bu manzarayı ovayı kullandığınız her yerde kullanın UIView. Bunu yapılandırılması ayarlama gibi basit gibidir onlyRespondToTouchesInSubviewsiçin YES.

Bununla başa çıkmanın birkaç yolu var. Benim favorim hitTest: withEvent'i geçersiz kılmaktır: çelişen görünümlere (belki de dolaylı olarak) ortak bir denetim görünümü olan bir görünümde (bunlara A ve B dediğiniz gibi geliyor). Örneğin, şuna benzer bir şey (burada A ve B, UIView işaretçileridir; burada B, normalde göz ardı edilen "gizli" dir):

- (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:Yöntemi gyim'in önerdiği şekilde de değiştirebilirsiniz . Bu, en azından dokunuşlar için, A'da etkili bir şekilde "bir delik açarak" esasen aynı sonucu elde etmenizi sağlar.

Diğer bir yaklaşım olay iletmedir, bu da bazı dokunuşları ilk gittikleri yerden farklı bir nesneye göndermek için geçersiz kılma touchesBegan:withEvent:ve benzer yöntemler ( touchesMoved:withEvent:vb.) Anlamına gelir . Örneğin, A'da şöyle bir şey yazabilirsiniz:

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

Ancak, bu her zaman beklediğiniz gibi çalışmayacaktır ! Önemli olan, UIButton gibi yerleşik kontrollerin her zaman iletilen dokunuşları göz ardı etmesidir. Bu nedenle ilk yaklaşım daha güvenilirdir.

Tüm bunları daha ayrıntılı olarak açıklayan iyi bir blog yazısı ve fikirleri tanıtmak için çalışan küçük bir xcode projesi var, burada mevcut:

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

Ayarlamalısınız upperView.userInteractionEnabled = NO;, aksi takdirde üst görünüm dokunuşları keser.

Bunun Arayüz Oluşturucu sürümü, Nitelikleri Görüntüle panelinin altında "Kullanıcı Etkileşimi Etkin" adlı bir onay kutusudur. İşaretini kaldırın ve gitmeniz iyi olur.

PointInside: withEvent'in özel uygulaması gerçekten de gidilecek yol gibi görünüyordu, ancak sabit kodlanmış koordinatlarla uğraşmak bana tuhaf geldi. Bu yüzden, CGRectContainsPoint () işlevini kullanarak CGPoint'in CGRect düğmesinin içinde olup olmadığını kontrol ettim:

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

Son zamanlarda bana yardımcı olacak bir ders yazdım. Bunu bir için özel bir sınıf olarak kullanmak UIButtonveya UIViewsaydam bir piksel üzerinde yürütülen dokunma olaylarını geçecektir.

Bu çözüm, kabul edilen yanıttan biraz daha iyidir, çünkü UIButtonyarı saydam altındaki a'yı hala tıklayabilirken , şeffaf UIViewolmayan kısmı UIViewdokunma olaylarına yanıt verecektir.

GIF'te de görebileceğiniz gibi, Zürafa düğmesi basit bir dikdörtgendir ancak şeffaf alanlardaki dokunma olayları alttaki sarıya aktarılır UIButton.

Sınıfa bağla

Sanırım bu partiye biraz geç kaldım, ancak bu olası çözümü ekleyeceğim:

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

Özel bir UIView standart hitTest işlevini geçersiz kılmak için bu kodu kullanırsanız, YALNIZCA görünümün kendisini yok sayar. Bu görünümün tüm alt görünümleri, isabetlerini normal şekilde döndürür ve görünümün kendisine gidecek tüm isabetler, gözetim görünümüne geçer.

-Kül

Sadece Kabul Edilen Cevabı kısaltmak ve bunu referansım için buraya koymak. Kabul Edilen Cevap mükemmel çalışıyor. Görünümünüzün alt görünümlerinin dokunuşu almasına veya arkamızdaki herhangi bir görüntüye aktarmasına izin vermek için bunu şu şekilde genişletebilirsiniz:

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

Not: Alt görünüm ağacında özyineleme yapmak zorunda bile değilsiniz, çünkü her pointInside:withEvent:yöntem bunu sizin için halledecektir.

UserInteraction özelliğini devre dışı bırakmak yardımcı olabilir. Örneğin:

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

(Not: Yukarıdaki kodda, 'kendi' bir görünümü ifade eder)

Bu şekilde, yalnızca topView'da görüntüleyebilirsiniz, ancak kullanıcı girdilerini alamazsınız. Tüm bu kullanıcı dokunuşları bu görünümden geçecek ve alt görünüm onlara yanıt verecektir. Bu topView'ı saydam resimleri görüntülemek veya onları canlandırmak için kullanırdım.

Bu yaklaşım oldukça temiz ve şeffaf alt görünümlerin de dokunuşlara tepki vermemesini sağlıyor . Sadece alt sınıflara ayırın UIViewve uygulamasına aşağıdaki yöntemi ekleyin:

@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

Buradaki çözümüm:

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

Bu yardımcı olur umarım

Her iki görünümde de dokunuşu kesmek için yapabileceğiniz bir şey var.

Üstten görünüm:

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

Ama fikir bu.

İşte bir Swift versiyonu:

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

Hızlı 3

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

UI araç setini kullanarak hiçbir zaman eksiksiz bir kullanıcı arayüzü oluşturmadım, bu yüzden bu konuda fazla deneyimim yok. İşte yine de çalışması gerektiğini düşündüğüm şey.

Her UIView ve bu UIWindow, subviewstüm alt görünümleri içeren bir NSArray olan bir özelliğe sahiptir .

Bir görünüme eklediğiniz ilk alt görünüm, 0 dizinini ve sonraki dizin 1'i vb. Alacaktır. Ayrıca değiştirebilir addSubview:ile insertSubview: atIndex:veyainsertSubview:aboveSubview: hiyerarşisinde subview konumunu belirleyebilir gibi yöntemlere ve.

Bu nedenle, UIWindow'unuza ilk olarak hangi görünümü eklediğinizi görmek için kodunuzu kontrol edin. Bu 0, diğeri 1 olacak.
Şimdi, alt görünümlerinizden birinden diğerine ulaşmak için aşağıdakileri yaparsınız:

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

Bunun sizin durumunuz için işe yarayıp yaramadığını bana bildirin!

(bu işaretin altında önceki cevabım var):

Görünümlerin birbirleriyle iletişim kurması gerekiyorsa, bunu bir denetleyici aracılığıyla (yani popüler MVC modelini kullanarak ) yapmaları gerekir .

Yeni bir görünüm oluşturduğunuzda, kendisini bir denetleyiciye kaydettirdiğinden emin olabilirsiniz.

Dolayısıyla teknik, görünümlerinizin bir denetleyiciye kaydedildiğinden emin olmaktır (bu, onları ada göre veya bir Sözlük veya Dizide tercih ettiğiniz her şeyi saklayabilir). Ya kontrolörün sizin için bir mesaj göndermesini sağlayabilirsiniz ya da görünüme bir referans alıp doğrudan onunla iletişim kurabilirsiniz.

Görünümünüzde denetleyiciye bir bağlantı yoksa (durum böyle olabilir) , denetleyicinize bir referans almak için tekli ve / veya sınıf yöntemlerinden yararlanabilirsiniz.

Bence doğru yol, görünüm hiyerarşisine yerleştirilmiş görünüm zincirini kullanmaktır. Ana görünüme gönderilen alt görünümleriniz için genel UIView kullanmayın, bunun yerine MYView: UIView (veya UIImageView gibi istediğiniz süper türü) yapmak için UIView (veya UIImageView gibi varyantlarından birini) alt sınıfını kullanın. YourView uygulamasında touchesBegan yöntemini uygulayın. Daha sonra bu görünüme dokunulduğunda bu yöntem çağrılacaktır. Bu uygulamada sahip olmanız gereken tek şey bir örnek yöntemidir:

- (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 bir yanıtlayıcı api'sidir, bu nedenle bunu genel veya özel arayüzünüzde bildirmenize gerek yoktur; Bilmen gereken şu sihirli api'lerden biri. Bu self.superview, isteği sonunda viewController'a gönderecektir. ViewController'da, dokunmayı işlemek için bu touchesBegan'ı uygulayın.

Dokunma konumunun (CGPoint), görünüm hiyerarşi zincirinde yukarı çıkarken sizin için çevreleyen görünüme göre otomatik olarak ayarlandığını unutmayın.

Sadece bunu göndermek istiyorum, çünkü biraz benzer bir problemim vardı, burada cevapları burada şanssız uygulamaya çalışmak için önemli miktarda zaman harcadım. Ne yaptım:

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

ve uygulama UIGestureRecognizerDelegate:

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

Alttan görünüm, çok sayıda segmenti olan bir gezinme denetleyicisiydi ve üzerinde pan hareketiyle kapanabilen bir tür kapı vardı. Her şey başka bir VC'ye gömüldü. Bir cazibe gibi çalıştı. Bu yardımcı olur umarım.

HitTest tabanlı çözüm için Swift 4 Uygulaması

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

Stuart'ın mükemmel ve çoğunlukla kusursuz cevabından ve Segev'in yararlı uygulamasından türetilen işte, herhangi bir projeye dahil edebileceğiniz bir Swift 4 paketi:

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

Ve sonra hitTest ile:

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