Niestandardowe ustawienie wysokości wiersza komórki w serii ujęć nie odpowiada

Próbuję dostosować wysokość komórki dla jednej z komórek w moim widoku tabeli. Dostosowuję rozmiar z ustawienia „wysokości wiersza” w „inspektorze wielkości” danej komórki. Po uruchomieniu aplikacji na iPhonie komórka ma domyślny rozmiar ustawiony na podstawie „rozmiaru wiersza” w widoku tabeli.

Jeśli zmienię „rozmiar wiersza” widoku tabeli, wówczas zmieni się rozmiar wszystkich komórek. Nie chcę tego robić, ponieważ chcę niestandardowy rozmiar tylko dla jednej komórki. Widziałem wiele postów, które mają programowe rozwiązanie problemu, ale wolałbym to zrobić za pomocą scenorysu, jeśli to możliwe.

W komórkach dynamicznychrowHeight ustawione w UITableView zawsze nadpisuje wartość rowHeight poszczególnych komórek.

Ale na statycznych komórkach, rowHeightustawione na poszczególnych komórkach mogą zastąpić UITableView.

Nie jesteś pewien, czy to błąd, Apple może celowo to robić?

Jeśli używasz UITableViewController, zaimplementuj tę metodę:

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

W funkcji wiersza możesz wybrać Wysokość. Na przykład,

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

W tym przykładzie wysokość pierwszego rzędu wynosi 100 pikseli, a pozostałe 60 pikseli.

Mam nadzieję, że ten może ci pomóc.

W przypadku komórek dynamicznych rowHeightustawienie UITableViewzawsze zastępuje poszczególne komórki rowHeight.

Takie zachowanie jest, IMO, błędem. Za każdym razem, gdy musisz zarządzać interfejsem użytkownika w dwóch miejscach, jest on podatny na błędy. Na przykład, jeśli zmienisz rozmiar komórki w serii ujęć, musisz pamiętać, aby również je zmienić heightForRowAtIndexPath:. Dopóki Apple nie naprawi błędu, obecnie najlepszym obejściem jest przesłonięcie heightForRowAtIndexPath:, ale użyj rzeczywistych prototypowych komórek z serii ujęć, aby określić wysokość, zamiast używać liczb magicznych . Oto przykład:

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

Zapewni to, że wszelkie zmiany wysokości prototypowych komórek zostaną automatycznie wykryte w czasie wykonywania, a użytkownik będzie musiał zarządzać interfejsem użytkownika tylko w jednym miejscu: w scenariuszu.

Zbudowałem kod, na który wskazują różne odpowiedzi / komentarze, aby działało to w przypadku scenorysów wykorzystujących komórki prototypowe.

Ten kod:

• Nie wymaga ustawiania wysokości komórki w innym miejscu niż oczywiste miejsce w serii ujęć
• Buforuje wysokość ze względu na wydajność
• Używa wspólnej funkcji, aby uzyskać identyfikator komórki dla ścieżki indeksu, aby uniknąć powielonej logiki

Dzięki Answerbot, Brennan i 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...>

W rzeczywistości są dwa miejsca, w których musisz zmienić wysokość wiersza, najpierw komórka (już to zmieniłeś), a teraz wybierz Widok tabeli i sprawdź Inspektor rozmiaru

Myślę, że to błąd.

Spróbuj wyregulować wysokość nie za pomocą Inspektora narzędzi, ale przeciągając myszą bezpośrednio na scenorysie.

Rozwiązałem ten problem za pomocą tej metody.

Jeśli używasz szybkiego, użyj tego w ten sposób. Nie używaj scenorysu, aby wybrać wysokość wiersza. Programowo ustawiaj wysokość wiersza tabeli w ten sposób,

 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
    }

}

Możesz uzyskać wysokość UITableviewCell (w UITableviewController - komórki statyczne) z serii ujęć za pomocą następujących wierszy.

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

    return height;
}

Otwórz scenorys w widoku XML i spróbuj edytować rowHeightatrybut pożądanego elementu.

Działa to dla mnie, gdy próbowałem ustawić niestandardową wysokość wiersza dla mojego prototypowanego wiersza. Nie działa przez inspektora, ale działa przez XML.

Możesz użyć prototypu cellsz niestandardowym height, a następnie wywołać cellForRowAtIndexPath:i zwrócić jego frame.height.:.

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

Jeśli chcesz ustawić statyczną wysokość wiersza, możesz zrobić coś takiego:

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

Ostatnio walczyłem z tym. Mój problem polegał na tym, że powyższe rozwiązania wykorzystujące tę heightForRowAtIndexPath:metodę działałyby na iOS 7.1 w Symulatorze, ale potem całkowicie spieprzyły wyniki, po prostu przechodząc na iOS 8.1.

Zacząłem czytać więcej o samorozmierzających się komórkach (wprowadzonych w iOS 8, czytaj tutaj ). Było oczywiste, że użycie UITableViewAutomaticDimensionpomoże w iOS 8. Próbowałem użyć tej techniki i usunąłem użycie heightForRowAtIndexPath:i voila, teraz działało idealnie w iOS 8. Ale potem iOS 7 nie był. Co miałam zrobić? Potrzebowałem heightForRowAtIndexPath:na iOS 7, a nie na iOS 8.

Oto moje rozwiązanie (przygotowane dla zwięzłości), które pożyczyłem od odpowiedzi @JosephH zamieszczonej powyżej:

- (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”) jest właściwie z zestawu definicji makr, których używam, które gdzieś znalazłem (bardzo pomocne). Są one zdefiniowane jako:

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

Ten sam problem wystąpił podczas pracy na XCode 9 za pomocą Swift 4 .

Dodaj opcję AutoLayout dla elementów interfejsu użytkownika w komórce, a niestandardowa wysokość wiersza komórki będzie działać odpowiednio, jak określono.

W przypadku komórek dynamicznych wartość rowHeight ustawiona w UITableView zawsze zastępuje wartość rowHeight poszczególnych komórek. Wystarczy obliczyć wysokość dynamiczną, jeśli zawartość wewnątrz wiersza.

Jedynym prawdziwym rozwiązaniem, jakie mogłem znaleźć, jest to

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

To działa i pozwala nie mieć okropnego przełącznika / jeśli powiela logikę już na StoryBoard. Nie jestem pewien co do wydajności, ale myślę, że po przybyciu cellForRow:do już zainicjowanej komórki jest tak szybko. Oczywiście są tu prawdopodobnie szkody dodatkowe, ale wygląda na to, że działa mi to dobrze.

Opublikowałem to również tutaj: https://devforums.apple.com/message/772464

EDYCJA: Ortwin Gentz przypomniał mi, że heightForRowAtIndexPath:będą wywoływane dla wszystkich komórek TableView, nie tylko widocznych. Brzmi logicznie, ponieważ iOS musi znać całkowitą wysokość, aby móc wyświetlić odpowiednie paski przewijania. Oznacza to, że prawdopodobnie jest w porządku na małych TableViews (jak 20 komórek), ale zapomnij o tym na 1000 TableView.

Również poprzednia sztuczka z XML: tak samo jak pierwszy komentarz dla mnie. Prawidłowa wartość już tam była.

Dodano jako komentarz, ale opublikowanie jako odpowiedź na widoczność:

Wydaje się również występować problem, jeśli początkowo skonfigurujesz widok tabeli jako „komórki statyczne”, a następnie zmienisz go na „dynamiczne prototypy”. Miałem problem polegający na heightForRowAtIndexPathtym, że nawet metoda delegowania była ignorowana. Najpierw rozwiązałem go, edytując bezpośrednio scenariuszowy kod XML, a na koniec po prostu przebudowałem scenę od podstaw, używając dynamicznych prototypów od samego początku.

Biorąc pod uwagę, że nie znalazłem żadnego rozwiązania tego problemu za pomocą Konstruktora interfejsów, postanowiłem opublikować programowe rozwiązanie problemu w Swift przy użyciu dwóch dynamicznych komórek , mimo że początkowe pytanie dotyczyło rozwiązania za pomocą Konstruktora interfejsów. Niezależnie od tego uważam, że może to być pomocne dla społeczności 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)]!
   }

   ...

  }

Inną rzeczą, którą możesz zrobić, to przejść do Zarysu dokumentu, wybrać widok tabeli, w którym zagnieżdżona jest komórka prototypowa. Następnie w Inspektorze rozmiarów zmień widok tabeli Wysokość wiersza na żądaną wartość i odznacz pole Automatyczne.