A configuração de Altura da linha da célula personalizada no storyboard não está respondendo

Estou tentando ajustar a altura da célula para uma das células na minha exibição de tabela. Estou ajustando o tamanho da configuração "altura da linha" dentro do "inspetor de tamanho" da célula em questão. Quando executo o aplicativo no meu iPhone, a célula tem o tamanho padrão definido no "tamanho da linha" na exibição da tabela.

Se eu alterar o "tamanho da linha" da exibição da tabela, o tamanho de todas as células será alterado. Não quero fazer isso, pois quero um tamanho personalizado apenas para uma célula. Eu já vi muitas postagens com uma solução programática para o problema, mas eu preferiria fazê-lo através do storyboard, se isso for possível.

Nas células dinâmicas , o rowHeightconjunto no UITableView sempre substitui o rowHeight das células individuais.

Mas em células estáticas , o rowHeightconjunto de células individuais pode substituir os UITableView.

Não tem certeza se é um bug, a Apple pode estar fazendo isso intencionalmente?

Se você usar UITableViewController, implemente este método:

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath;

Na função de uma linha, você pode escolher Altura. Por exemplo,

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
    if (indexPath.row == 0) {
       return 100;
    } 
    else {
       return 60;
    }
}

Neste exemplo, a altura da primeira linha é de 100 pixels e as demais são de 60 pixels.

Espero que este possa ajudá-lo.

Para células dinâmicas, rowHeightdefinir UITableViewsempre substitui as células individuais rowHeight.

Esse comportamento é, na IMO, um bug. Sempre que você precisar gerenciar sua interface do usuário em dois lugares, ela estará sujeita a erros. Por exemplo, se você alterar o tamanho da sua célula no storyboard, lembre-se de alterá-los heightForRowAtIndexPath:também. Até a Apple corrigir o erro, a melhor solução atual é substituir heightForRowAtIndexPath:, mas use as células de protótipo reais do storyboard para determinar a altura em vez de usar números mágicos . Aqui está um exemplo:

- (CGFloat)tableView:(UITableView *)tableView 
           heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
    /* In this example, there is a different cell for
       the top, middle and bottom rows of the tableView.
       Each type of cell has a different height.
       self.model contains the data for the tableview 
    */
    static NSString *CellIdentifier;
    if (indexPath.row == 0) 
        CellIdentifier = @"CellTop";
    else if (indexPath.row + 1 == [self.model count] )
        CellIdentifier = @"CellBottom";
    else
        CellIdentifier = @"CellMiddle";

    UITableViewCell *cell = 
              [self.tableView dequeueReusableCellWithIdentifier:CellIdentifier];

    return cell.bounds.size.height;
}

Isso garantirá que quaisquer alterações nas alturas das células do seu protótipo sejam selecionadas automaticamente no tempo de execução e você só precisará gerenciar sua interface do usuário em um só lugar: o storyboard.

Eu construí o código com as várias respostas / comentários para que isso funcione para storyboards que usam células protótipo.

Este código:

• Não requer que a altura da célula seja definida em outro lugar que não seja o local óbvio no storyboard
• Caches a altura por motivos de desempenho
• Usa uma função comum para obter o identificador de célula para um caminho de índice para evitar lógica duplicada

Obrigado ao Answerbot, Brennan e lensovet.

- (NSString *)cellIdentifierForIndexPath:(NSIndexPath *)indexPath
{
    NSString *cellIdentifier = nil;

    switch (indexPath.section)
    {
        case 0:
            cellIdentifier = @"ArtworkCell";
            break;
         <... and so on ...>
    }

    return cellIdentifier;
}

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
    NSString *cellIdentifier = [self cellIdentifierForIndexPath:indexPath];
    static NSMutableDictionary *heightCache;
    if (!heightCache)
        heightCache = [[NSMutableDictionary alloc] init];
    NSNumber *cachedHeight = heightCache[cellIdentifier];
    if (cachedHeight)
        return cachedHeight.floatValue;

    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:cellIdentifier];
    CGFloat height = cell.bounds.size.height;
    heightCache[cellIdentifier] = @(height);
    return height;
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    NSString *cellIdentifier = [self cellIdentifierForIndexPath:indexPath];

    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:cellIdentifier forIndexPath:indexPath];

    <... configure cell as usual...>

Na verdade, existem dois lugares em que você precisa alterar a altura da linha, primeiro a célula (você já a alterou) e agora selecione a Visualização da tabela e verifique o Inspetor de tamanho

Eu acho que é um bug.

Tente ajustar a altura não pelo inspetor do Utility, mas pelo mouse diretamente no storyboard.

Eu resolvi esse problema com esse método.

Se você estiver usando rápido, use assim. Não use o storyboard para selecionar a altura da linha. Defina programaticamente a altura da linha da tabela assim,

 func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
    if indexPath.row == 0 || indexPath.row == 1{
        let cell = self.tableView.dequeueReusableCellWithIdentifier("section1", forIndexPath: indexPath) as! Section1TableViewCell
        self.tableView.rowHeight = 150
        cell.label1.text = "hiiiiii"
        cell.label2.text = "Huiiilllllll"
        return cell

    } else {

        let cell = self.tableView.dequeueReusableCellWithIdentifier("section2", forIndexPath: indexPath) as! Section2TableViewCell
        self.tableView.rowHeight = 60
        cell.label3.text = "llll"
        return cell
    }

}

Você pode obter a altura do UITableviewCell (no UITableviewController - células estáticas) no storyboard com a ajuda das seguintes linhas.

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
   CGFloat height = [super tableView:tableView heightForRowAtIndexPath:indexPath];

    return height;
}

Abra o storyboard na visualização XML e tente editar o rowHeightatributo do elemento desejado.

Funcionou para mim quando tentei definir rowHeight personalizado para minha linha com protótipo. Não está funcionando via inspetor, mas via XML funciona.

Você pode usar o protótipo cellscom um costume heighte, em seguida, chamar cellForRowAtIndexPath:e retornar seu frame.height.:.

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
    UITableViewCell *cell = [self tableView:tableView
                    cellForRowAtIndexPath:indexPath];
    return cell.frame.size.height;
}

Se você deseja definir uma altura de linha estática, pode fazer algo assim:

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
    return 120;
}

Eu tenho lutado recentemente com isso. Meu problema foi que as soluções postadas acima usando o heightForRowAtIndexPath:método funcionariam para o iOS 7.1 no Simulador, mas depois estragaram completamente os resultados simplesmente mudando para o iOS 8.1.

Comecei a ler mais sobre células de auto-dimensionamento (introduzidas no iOS 8, leia aqui ). Era evidente que o uso de UITableViewAutomaticDimensionajudaria no iOS 8. Tentei usar essa técnica e excluí o uso de heightForRowAtIndexPath:e voila, estava funcionando perfeitamente no iOS 8 agora. Mas o iOS 7 não estava. O que eu devo fazer? Eu precisava heightForRowAtIndexPath:do iOS 7 e não do iOS 8.

Aqui está a minha solução (aparada por uma questão de brevidade) que empresta da resposta @ JosephphH postada acima:

- (void)viewDidLoad {
    [super viewDidLoad];

    self.tableView.estimatedRowHeight = 50.;
    self.tableView.rowHeight = UITableViewAutomaticDimension;

    // ...
}

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
    if (SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(@"8.0")) {
        return UITableViewAutomaticDimension;

    } else {
        NSString *cellIdentifier = [self reuseIdentifierForCellAtIndexPath:indexPath];
        static NSMutableDictionary *heightCache;
        if (!heightCache)
            heightCache = [[NSMutableDictionary alloc] init];
        NSNumber *cachedHeight = heightCache[cellIdentifier];
        if (cachedHeight)
            return cachedHeight.floatValue;

    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:cellIdentifier];
    CGFloat height = cell.bounds.size.height;
    heightCache[cellIdentifier] = @(height);
    return height;
    }
}

- (NSString *)reuseIdentifierForCellAtIndexPath:(NSIndexPath *)indexPath {
    NSString * reuseIdentifier;
    switch (indexPath.row) {
        case 0:
            reuseIdentifier = EventTitleCellIdentifier;
            break;
        case 2:
            reuseIdentifier = EventDateTimeCellIdentifier;
            break;
        case 4:
            reuseIdentifier = EventContactsCellIdentifier;
            break;
        case 6:
            reuseIdentifier = EventLocationCellIdentifier;
            break;
        case 8:
            reuseIdentifier = NotesCellIdentifier;
            break;
        default:
            reuseIdentifier = SeparatorCellIdentifier;
            break;
    }

    return reuseIdentifier;
}

SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO (@ "8.0") é realmente de um conjunto de definições de macro que estou usando e que encontrei em algum lugar (muito útil). Eles são definidos como:

#define SYSTEM_VERSION_EQUAL_TO(v)                  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedSame)
#define SYSTEM_VERSION_GREATER_THAN(v)              ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedDescending)
#define SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(v)  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedAscending)
#define SYSTEM_VERSION_LESS_THAN(v)                 ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedAscending)
#define SYSTEM_VERSION_LESS_THAN_OR_EQUAL_TO(v)     ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedDescending)

O mesmo problema ocorreu ao trabalhar no XCode 9 usando o Swift 4 .

Adicione AutoLayout para os elementos da interface do usuário dentro da célula e a altura da linha da célula personalizada funcionará adequadamente, conforme especificado.

Para células dinâmicas, o rowHeight definido no UITableView sempre substitui o rowHeight das células individuais. Apenas calcule a altura dinâmica se o conteúdo estiver dentro da linha.

A única solução real que pude encontrar é esta

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
    UITableViewCell *cell = ...; // Instantiate with a "common" method you'll use again in cellForRowAtIndexPath:
    return cell.frame.size.height;
}

Isso funciona e permite não ter uma opção horrível / se duplicar a lógica já no StoryBoard. Não tenho certeza sobre o desempenho, mas acho que ao chegar na cellForRow:célula já sendo inicializado, é tão rápido. É claro que provavelmente há danos colaterais aqui, mas parece que funciona bem para mim aqui.

Também publiquei isso aqui: https://devforums.apple.com/message/772464

Edição: Ortwin Gentz me lembrou que heightForRowAtIndexPath:será chamado para todas as células do TableView, não apenas as visíveis. Parece lógico, já que o iOS precisa saber a altura total para poder mostrar as barras de rolagem corretas. Isso significa que provavelmente está bem em TableViews pequenos (como 20 células), mas esqueça isso em um TableView de 1000 células.

Além disso, o truque anterior com XML: O mesmo que o primeiro comentário para mim. O valor correto já estava lá.

Adicionado como comentário, mas postando como resposta para visibilidade:

Parece haver também um problema se você configurar inicialmente uma exibição de tabela como "células estáticas" e alterá-la para "protótipos dinâmicos". Eu tive um problema em que até o método delegado heightForRowAtIndexPathestava sendo ignorado. Eu o resolvi editando diretamente o XML do storyboard, e finalmente reconstruí a cena do storyboard do zero, usando protótipos dinâmicos desde o início.

Como não encontrei nenhuma solução para esse problema através do Interface Builder, decidi postar uma solução programática para o problema no Swift usando duas células dinâmicas , mesmo que a pergunta inicial pedisse uma solução através do Interface Builder. Independentemente, acho que poderia ser útil para a comunidade Stack Overflow:

    import UIKit

    enum SignInUpMenuTableViewControllerCellIdentifier: String {
       case BigButtonCell = "BigButtonCell"
       case LabelCell = "LabelCell"
    }

    class SignInUpMenuTableViewController: UITableViewController {
            let heightCache = [SignInUpMenuTableViewControllerCellIdentifier.BigButtonCell : CGFloat(50),
                              SignInUpMenuTableViewControllerCellIdentifier.LabelCell : CGFloat(115)]

    private func cellIdentifierForIndexPath(indexPath: NSIndexPath) -> SignInUpMenuTableViewControllerCellIdentifier {
        if indexPath.row == 2 {
            return SignInUpMenuTableViewControllerCellIdentifier.LabelCell
        } else {
            return SignInUpMenuTableViewControllerCellIdentifier.BigButtonCell
        }
    }

   override func tableView(tableView: UITableView, heightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
       return self.heightCache[self.cellIdentifierForIndexPath(indexPath)]!
   }

   ...

  }

Outra coisa que você pode fazer é acessar o Esboço do documento, selecionar a visualização da tabela em que a célula do seu protótipo está aninhada. Em seguida, no Inspetor de tamanhos, altere a altura da linha da visualização da tabela para o valor desejado e desmarque a caixa Automático.