Como obter UITableView de UITableViewCell?

Tenho um UITableViewCellque está vinculado a um objeto e preciso saber se a célula está visível. A partir da pesquisa que fiz, isso significa que preciso acessar de alguma forma o UITableViewque o contém (a partir daí, existem várias maneiras de verificar se ele está visível). Então, eu gostaria de saber se UITableViewCelltem um ponteiro para o UITableView, ou se havia alguma outra maneira de obter um ponteiro da célula?

Para evitar a verificação da versão do iOS, percorra iterativamente as visualizações da célula até que um UITableView seja encontrado:

id view = [tableViewCellInstance superview];

while (view && [view isKindOfClass:[UITableView class]] == NO) {
    view = [view superview]; 
}

UITableView *tableView = (UITableView *)view;

No iOS7 beta 5 UITableViewWrapperViewé a visão geral de a UITableViewCell. Também UITableViewé superview de a UITableViewWrapperView.

Portanto, para iOS 7, a solução é

UITableView *tableView = (UITableView *)cell.superview.superview;

Portanto, para iOSes até iOS 6, a solução é

UITableView *tableView = (UITableView *)cell.superview;

Extensão Swift 5

Recursivamente

extension UIView {
    func parentView<T: UIView>(of type: T.Type) -> T? {
        guard let view = superview else {
            return nil
        } 
        return (view as? T) ?? view.parentView(of: T.self)
    }
}

extension UITableViewCell {
    var tableView: UITableView? {
        return parentView(of: UITableView.self)
    }
}

Usando loop

extension UITableViewCell {
    var tableView: UITableView? {
        var view = superview
        while let v = view, v.isKind(of: UITableView.self) == false {
            view = v.superview
        }
        return view as? UITableView
    }
}

Antes do iOS7, a visão geral da célula era o UITableViewque o continha. A partir do iOS7 GM (provavelmente também estará no lançamento público), a supervisão da célula é uma, UITableViewWrapperViewcom sua supervisão sendo o UITableView. Existem duas soluções para o problema.

Solução nº 1: crie uma UITableViewCellcategoria

@implementation UITableViewCell (RelatedTable)

- (UITableView *)relatedTable
{
    if ([self.superview isKindOfClass:[UITableView class]])
        return (UITableView *)self.superview;
    else if ([self.superview.superview isKindOfClass:[UITableView class]])
        return (UITableView *)self.superview.superview;
    else
    {
        NSAssert(NO, @"UITableView shall always be found.");
        return nil;
    }

}
@end

Este é um bom substituto imediato para usar cell.superview, torna mais fácil refatorar seu código existente - apenas pesquise e substitua [cell relatedTable], e coloque uma declaração para garantir que, se a hierarquia de visualização mudar ou reverter no futuro, ela aparecerá imediatamente em seus testes.

Solução # 2: Adicionar uma UITableViewreferência fraca aUITableViewCell

@interface SOUITableViewCell

   @property (weak, nonatomic) UITableView *tableView;

@end

Este é um design muito melhor, embora exija um pouco mais de refatoração de código para usar em projetos existentes. Em seu tableView:cellForRowAtIndexPathuso SOUITableViewCell como sua classe de célula ou certifique-se de que sua classe de célula personalizada é uma subclasse de SOUITableViewCelle atribua tableView à propriedade tableView da célula. Dentro da célula, você pode então referir-se ao tableview que o contém usando self.tableView.

Se estiver visível, tem uma visão geral. E ... surpresa ... o superview é um objeto UITableView.

No entanto, ter uma supervisualização não é garantia de estar na tela. Mas UITableView fornece métodos para determinar quais células são visíveis.

E não, não há nenhuma referência dedicada de uma célula a uma tabela. Mas quando você subclasse UITableViewCell você pode introduzir um e configurá-lo na criação. (Eu mesmo fiz muito isso antes de pensar na hierarquia de subvisualização.)

Atualização para iOS7: a Apple mudou a hierarquia de subvisualização aqui. Como de costume, ao trabalhar com coisas que não são documentadas detalhadamente, há sempre o risco de que as coisas mudem. É muito mais seguro "rastrear" a hierarquia de visualizações até que um objeto UITableView seja finalmente encontrado.

Solução Swift 2.2.

Uma extensão para UIView que procura recursivamente por uma visualização com um tipo específico.

import UIKit

extension UIView {
    func lookForSuperviewOfType<T: UIView>(type: T.Type) -> T? {
        guard let view = self.superview as? T else {
            return self.superview?.lookForSuperviewOfType(type)
        }
        return view
    }
}

ou mais compacto (graças ao kabiroberai):

import UIKit

extension UIView {
    func lookForSuperviewOfType<T: UIView>(type: T.Type) -> T? {
        return superview as? T ?? superview?.superviewOfType(type)
    }
}

No seu celular você apenas chama:

let tableView = self.lookForSuperviewOfType(UITableView)
// Here we go

Lembre-se de que UITableViewCell é adicionado ao UITableView somente após a execução de cellForRowAtIndexPath.

O que quer que você consiga fazer ao chamar super view ou por meio da cadeia de resposta será muito frágil. A melhor maneira de fazer isso, se as células querem saber algo, é passar um objeto para a célula que responde a algum método que responda à pergunta que a célula quer fazer e fazer com que o controlador implemente a lógica de determinar o que responder (pela sua pergunta, acho que a célula quer saber se algo está visível ou não).

Crie um protocolo de delegado na célula, defina o delegado da célula como tableViewController e mova toda a lógica de "controle" da interface do usuário no tableViewCotroller.

As células da visualização da tabela devem ser uma visualização que exibirá apenas informações.

Criei uma categoria em UITableViewCell para obter seu tableView pai:

@implementation UITableViewCell (ParentTableView)


- (UITableView *)parentTableView {
    UITableView *tableView = nil;
    UIView *view = self;
    while(view != nil) {
        if([view isKindOfClass:[UITableView class]]) {
            tableView = (UITableView *)view;
            break;
        }
        view = [view superview];
    }
    return tableView;
}


@end

melhor,

Aqui está a versão do Swift com base nas respostas acima. Eu generalizei ExtendedCellpara uso posterior.

import Foundation
import UIKit

class ExtendedCell: UITableViewCell {

    weak var _tableView: UITableView!

    func rowIndex() -> Int {
        if _tableView == nil {
            _tableView = tableView()
        }

        return _tableView.indexPathForSelectedRow!.row
    }

    func tableView() -> UITableView! {
        if _tableView != nil {
            return _tableView
        }

        var view = self.superview
        while view != nil && !(view?.isKindOfClass(UITableView))! {
            view = view?.superview
        }

        self._tableView = view as! UITableView
        return _tableView
    }
}

Espero que esta ajuda :)

Eu baseei essa solução na sugestão de Gabe de que o UITableViewWrapperViewobjeto é a supervisão do UITableViewCellobjeto no iOS7 beta5.

Subclasse UITableviewCell:

- (UITableView *)superTableView
{
    return (UITableView *)[self findTableView:self];
}

- (UIView *)findTableView:(UIView *)view
{
    if (view.superview && [view.superview isKindOfClass:[UITableView class]]) {
        return view.superview;
    }
    return [self findTableView:view.superview];
}

Eu peguei emprestado e modifiquei um pouco da resposta acima e cheguei ao seguinte trecho.

- (id)recursivelyFindSuperViewWithClass:(Class)clazz fromView:(id)containedView {
    id containingView = [containedView superview];
    while (containingView && ![containingView isKindOfClass:[clazz class]]) {
        containingView = [containingView superview];
    }
    return containingView;
}

A passagem em classe oferece a flexibilidade para percorrer e obter visualizações diferentes de UITableView em algumas outras ocasiões.

Minha solução para esse problema é um pouco semelhante a outras soluções, mas usa um elegante for-loop e é curto. Também deve ser à prova de futuro:

- (UITableView *)tableView
{
    UIView *view;
    for (view = self.superview; ![view isKindOfClass:UITableView.class]; view = view.superview);
    return (UITableView *)view;
}

UITableView *tv = (UITableView *) self.superview.superview;
BuyListController *vc = (BuyListController *) tv.dataSource;

Em vez de superview, tente usar ["UItableViewvariable" visibleCells].

Usei isso em loops foreach para percorrer as células que o aplicativo viu e funcionou.

for (UITableView *v in [orderItemTableView visibleCells])//visibleCell is the fix.
{
  @try{
    [orderItemTableView reloadData];
    if ([v isKindOfClass:[UIView class]]) {
        ReviewOrderTableViewCell *cell = (ReviewOrderTableViewCell *)v;
        if (([[cell deleteRecord] intValue] == 1) || ([[[cell editQuantityText] text] intValue] == 0))
            //code here 
    }
  }
}

Funciona como um encanto.

Testado minimamente, mas este exemplo não genérico de Swift 3 parece funcionar:

extension UITableViewCell {
    func tableView() -> UITableView? {
        var currentView: UIView = self
        while let superView = currentView.superview {
            if superView is UITableView {
                return (superView as! UITableView)
            }
            currentView = superView
        }
        return nil
    }
}

este código `UITableView *tblView=[cell superview];lhe dará uma instância da UItableview que contém a célula de visualização da guia

Eu sugiro que você atravesse a hierarquia de visualizações desta maneira para encontrar o UITableView pai:

- (UITableView *) findParentTableView:(UITableViewCell *) cell
{
    UIView *view = cell;
    while ( view && ![view isKindOfClass:[UITableView class]] )
    {
#ifdef DEBUG
        NSLog( @"%@", [[view  class ] description] );
#endif
        view = [view superview];
    }

    return ( (UITableView *) view );
}

Caso contrário, seu código será interrompido quando a Apple alterar a hierarquia de visualização novamente .

Outra resposta que também atravessa a hierarquia é recursiva.

UITableViewCell Internal View Hierarchy Change in iOS 7

Using iOS 6.1 SDK

    <UITableViewCell>
       | <UITableViewCellContentView>
       |    | <UILabel>

Using iOS 7 SDK

    <UITableViewCell>
       | <UITableViewCellScrollView>
       |    | <UIButton>
       |    |    | <UIImageView>
       |    | <UITableViewCellContentView>
       |    |    | <UILabel>


The new private UITableViewCellScrollView class is a subclass of UIScrollView and is what allows this interaction:


![enter image description here][1]


  [1]: http://i.stack.imgur.com/C2uJa.gif

http://www.curiousfind.com/blog/646 Obrigado

Você pode obtê-lo com uma linha de código.

UITableView *tableView = (UITableView *)[[cell superview] superview];

extension UIView {
    func parentTableView() -> UITableView? {
        var viewOrNil: UIView? = self
        while let view = viewOrNil {
            if let tableView = view as? UITableView {
                return tableView
            }
            viewOrNil = view.superview
        }
        return nil
    }
}

da resposta de @idris escrevi uma expansão para UITableViewCell em Swift

extension UITableViewCell {
func relatedTableView() -> UITableView? {
    var view = self.superview
    while view != nil && !(view is UITableView) {
        view = view?.superview
    }

    guard let tableView = view as? UITableView else { return nil }
    return tableView
}