Como o Microsoft Excel funciona com alturas de linha

Às vezes fico entediado e, armado com um depurador, começo a pesquisar em diferentes programas. Dessa vez, minha escolha foi no Excel e havia um desejo de descobrir como ele lida com as alturas das linhas, o que as armazena, como considera a altura de um intervalo de células etc. Analisei o Excel 2010 (excel.exe, 32 bits, versão 14.0.4756.1000, SHA1 a805cf60a5542f21001b0ea5d142d1cd0ee00b28).

Vamos começar com a teoria

Se você recorrer à documentação do VBA para Microsoft Office, poderá ver que a altura da linha pode ser obtida de uma maneira ou de outra através de duas propriedades:

• RowHeight - Retorna ou define a altura da primeira linha no intervalo especificado, medido em pontos. Leitura / gravação dupla;
• Altura - Retorna um valor Duplo que representa a altura, em pontos, do intervalo. Somente leitura.

E se você também procurar aqui: Especificações e limites do Excel . Você pode descobrir que a altura máxima da linha é 409 pontos. Infelizmente, isso está longe de ser o único caso em que os documentos oficiais da Microsoft são um pouco enganadores. De fato, no código do Excel, a altura máxima da linha é definida como 2047 pixels, que será 1535,25 em pontos. E o tamanho máximo da fonte é 409,55 pontos. É impossível obter uma linha com uma altura tão grande atribuindo-a simplesmente no VBA / Interop, mas você pode fazer uma linha, definir a fonte Cambria Math em sua primeira célula e definir o tamanho da fonte para 409,55 pontos. Em seguida, o Excel, com seu algoritmo de astúcia, calculará a altura da linha com base no formato da célula, obterá um número superior a 2047 pixels (acredite na palavra) e definirá a linha para a altura máxima possível. Se você perguntar a altura desta série por meio da interface do usuário, o Excel indicará que a altura é 409,5 pontos, mas se você solicitar a altura da série por meio do VBA, obterá 1535,25 pontos honestos, o que equivale a 2047 pixels. É verdade que, depois de salvar o documento, a altura ainda cairá para 409,5 pontos. Essa manipulação pode ser observada aqui neste vídeo: http://recordit.co/ivnFEsELLI

Mencionei os pixels no parágrafo anterior por um motivo. Na verdade, o Excel armazena e calcula o tamanho das células em números inteiros (geralmente faz tudo o máximo possível em números inteiros). Na maioria das vezes, esses pixels são multiplicados por algum fator. Curiosamente, o Excel armazena a escala de aparência na forma de uma fração comum, por exemplo, uma escala de 75% será armazenada como dois números 3 e 4. E quando for necessário exibir a linha, o Excel assumirá a altura da linha como um número inteiro de pixels, multiplique por 3 e divida por 4. Mas ele executará essa operação já no final, a partir disso, cria-se o efeito de que tudo seja considerado em números fracionários. Para verificar isso, escreva o seguinte código no VBA:

w.Rows(1).RowHeight = 75.375 Debug.Print w.Rows(1).Height 

VBA vai dar 75 porque 75.375 pixels serão 100,5 pixels, e o Excel não pode pagar e reduzirá a parte fracionária em até 100 pixels. Quando o VBA solicita a altura da linha em pontos, o Excel honestamente converte 100 pixels em pontos e retorna 75.

Em princípio, já começamos a escrever uma classe em C # que descreverá informações sobre a altura da linha:

 class RowHeightInfo { public ushort Value { get; set; } //    ,   4. public ushort Flags { get; set; } //  } 

Você terá que aceitar minha palavra por enquanto, mas no Excel, a altura da linha é armazenada dessa maneira. Ou seja, se for especificado que a altura da linha é 75 pontos, será 100 em pixels e 400 serão armazenados em Valor. Ainda não entendi o que todos os bits em Flags significam (é difícil e longo descobrir os valores dos sinalizadores), mas tenho certeza 0x4000 é definido para linhas cuja altura é definida manualmente e 0x2000 - é definido para linhas ocultas. Em geral, para linhas visíveis com uma altura definida manualmente, Flags geralmente é igual a 0x4005 e para linhas nas quais a altura é calculada com base na formatação de Flags, é 0xA ou 0x800E.

Pedimos a altura da linha

Agora, em princípio, você pode dar uma olhada no método em excel.exe, que retorna a altura da linha por seu índice (graças a HexRays pelo código bonito):

 int __userpurge GetRowHeight@<eax>(signed int rowIndex@<edx>, SheetLayoutInfo *sheetLayoutInfo@<esi>, bool flag) { RowHeightInfo *rowHeightInfo; // eax int result; // ecx if ( sheetLayoutInfo->dword1A0 ) return sheetLayoutInfo->defaultFullRowHeightMul4 | (~(sheetLayoutInfo->defaultRowDelta2 >> 14 << 15) & 0x8000); if ( rowIndex < sheetLayoutInfo->MinRowIndexNonDefault ) return sheetLayoutInfo->defaultFullRowHeightMul4 | (~(sheetLayoutInfo->defaultRowDelta2 >> 14 << 15) & 0x8000); if ( rowIndex >= sheetLayoutInfo->MaxRowIndexNonDefault ) return sheetLayoutInfo->defaultFullRowHeightMul4 | (~(sheetLayoutInfo->defaultRowDelta2 >> 14 << 15) & 0x8000); rowHeightInfo = GetRowHeightCore(sheetLayoutInfo, rowIndex); if ( !rowHeightInfo ) return sheetLayoutInfo->defaultFullRowHeightMul4 | (~(sheetLayoutInfo->defaultRowDelta2 >> 14 << 15) & 0x8000); result = 0; if ( flag || !(rowHeightInfo->Flags & 0x2000) ) result = rowHeightInfo->Value; if ( !(rowHeightInfo->Flags & 0x4000) ) result |= 0x8000u; return result; } 

O que é dword1A0, ainda não descobri. não foi possível encontrar um local em que esse sinalizador está definido :(
O que é defaultRowDelta2 para mim também continua sendo um mistério. Quando o Excel calcula a altura da linha com base no formato, ele representa a soma de dois números. defaultRowDelta2 é o segundo número dessa soma para a altura da linha padrão. O valor do parâmetro flag também é misterioso, pois onde quer que eu vi uma chamada para esse método na flag passou false.
A classe SheetLayoutInfo também aparece nesse método. Eu o nomeei assim, porque ele armazena muitas informações sobre a aparência da planilha. No SheetLayoutInfo, existem campos como:

• DefaultFullRowHeightMul4 - altura da linha padrão;
• MinRowIndexNonDefault - o índice da primeira linha na qual a altura difere do padrão;
• MaxRowIndexNonDefault - índice da série após a última, na qual a altura difere da padrão;
• DefaultRowDelta2 é a mesma parte da soma da altura da linha padrão.
• GroupIndexDelta - mais sobre isso mais tarde

Em princípio, a lógica deste método é compreensível:

1. Se o índice da série for menor que o primeiro com uma altura não padrão, retorne o padrão;
2. Se o índice da série for maior que o último com uma altura não padrão, retorne o padrão;
3. Caso contrário, obteremos o objeto rowHeightInfo da série do método GetRowHeightCore;
4. Se rowHeightInfo == null retorne a altura da linha padrão;
5. Existe mágica com sinalizadores, mas, em geral, retornamos o que está em rowHeightInfo.Value e configuramos o 16º bit na resposta se a altura da linha não foi definida manualmente.

Se você reescrever esse código em C #, obterá algo como o seguinte:

 const ulong HiddenRowMask = 0x2000; const ulong CustomHeightMask = 0x4000; const ushort DefaultHeightMask = 0x8000; public static ushort GetRowHeight(int rowIndex, SheetLayoutInfo sheetLayoutInfo) { ushort defaultHeight = (ushort) (sheetLayoutInfo.DefaultFullRowHeightMul4 | (~(sheetLayoutInfo.DefaultRowDelta2 >> 14 << 15) & DefaultHeightMask)); if (rowIndex < sheetLayoutInfo.MinRowIndexNonDefault) return defaultHeight; if (rowIndex >= sheetLayoutInfo.MaxRowIndexNonDefault) return defaultHeight; RowHeightInfo rowHeightInfo = GetRowHeightCore(sheetLayoutInfo, rowIndex); if (rowHeightInfo == null) return defaultHeight; ushort result = 0; if ((rowHeightInfo.Flags & HiddenRowMask) == 0) result = rowHeightInfo.Value; if ((rowHeightInfo.Flags & CustomHeightMask) == 0) result |= DefaultHeightMask; return result; } 

Agora você pode dar uma olhada no que está acontecendo no GetRowHeightCore:

 RowHeightInfo *__fastcall GetRowHeightCore(SheetLayoutInfo *sheetLayoutInfo, signed int rowIndex) { RowHeightInfo *result; // eax RowsGroupInfo *rowsGroupInfo; // ecx int rowInfoIndex; // edx result = 0; if ( rowIndex < sheetLayoutInfo->MinRowIndexNonDefault || rowIndex >= sheetLayoutInfo->MaxRowIndexNonDefault ) return result; rowsGroupInfo = sheetLayoutInfo->RowsGroups[sheetLayoutInfo-GroupIndexDelta + (rowIndex >> 4)]; result = 0; if ( !rowsGroupInfo ) return result; rowInfoIndex = rowsGroupInfo->Indices[rowIndex & 0xF]; if ( rowInfoIndex ) result = (rowsGroupInfo + 8 * (rowInfoIndex + rowsGroupInfo->wordBA + rowsGroupInfo->wordBC - rowsGroupInfo->wordB8)); return result; } 

1. Novamente, no início, o Excel verifica se o índice da série está entre as linhas com uma altura alterada e, se não, retorna nulo.
2. Localiza o grupo de linhas desejado; se não houver um grupo, ele retornará nulo.
3. Obtém o índice da série no grupo.
4. Além disso, pelo índice da série, ele encontra o objeto desejado da classe RowHeightInfo. wordBA, wordBC, wordB8 - algumas constantes. Eles mudam apenas com a história. Em princípio, eles não afetam o entendimento do algoritmo.

Aqui vale a pena desviar do tópico e contar mais sobre o RowsGroupInfo. O Excel armazena RowHeightInfo em grupos de 16 partes, onde o i-ésimo grupo, representado pela classe RowsGroupInfo, armazenará informações sobre linhas de i × 16 a i × 16 + 15, inclusive.

Mas as informações de altura da linha no RowsGroupInfo são armazenadas de uma maneira um tanto incomum. Provavelmente devido à necessidade de manter o histórico no Excel.

Existem três campos importantes no RowsGroupInfo: Indices, HeightInfos e RowsCount, o segundo não é visível no código acima (ele deve estar nesta linha: (linesGroupInfo + 8 × (...)), porque rowInfoIndex pode assumir valores muito diferentes , Já vi mais de 1000 e não tenho ideia de como definir essa estrutura na IDA.O campo RowsCount não aparece no código acima, mas é quantas linhas realmente não padrão são armazenadas no grupo.
Além disso, em SheetLayoutInfo, há GroupIndexDelta - a diferença entre o índice real do grupo e o índice do primeiro grupo com uma altura de linha modificada.

O campo Índices armazena as compensações de RowHeightInfo para cada índice da série dentro do grupo. Eles são armazenados lá em ordem, mas em HeightInfos RowHeightInfo já estão armazenados na ordem de alteração.

Suponha que tenhamos uma nova planilha em branco e, de alguma forma, alteramos a altura do número da linha 23. Essa linha está no segundo grupo de 16 linhas;

1. O Excel determinará o índice do grupo para esta série. No caso atual, o índice será 1 e mudará GroupIndexDelta = -1.
2. Cria um objeto da classe RowsGroupInfo para uma série de linhas e o coloca em sheetLayoutInfo-> RowsGroups sob o índice 0 (sheetLayoutInfo-> GroupIndexDelta + 1);
3. No RowsGroupInfo, o Excel alocará memória para 16 índices de 4 bytes, para RowsCount, wordBA, wordBA, wordBC e wordB8, etc.;
4. Em seguida, o Excel calcula o índice da série no grupo através da operação AND bit a bit (isso é muito mais rápido do que o restante da divisão): rowIndex & 0xF. O índice desejado no grupo será: 23 ​​& 0xF = 7;
5. Depois disso, o Excel obtém o deslocamento para o índice 7: deslocamento = índices [7]. Se deslocamento = 0, o Excel aloca 8 bytes no final de RowsGroupInto, aumenta o RowsCount em um e grava o novo deslocamento nos Índices [7]. De qualquer forma, no final, o Excel grava informações sobre a nova altura da linha e sinalizadores no deslocamento no RowsGroupInfo.

A classe RowsGroupInfo no próprio C # ficaria assim:

 class RowsGroupInfo { public int[] Indices { get; } public List<RowHeightInfo> HeightInfos { get; } public RowsGroupInfo() { Indices = new int[SheetLayoutInfo.MaxRowsCountInGroup]; HeightInfos = new List<RowHeightInfo>(); for (int i = 0; i < SheetLayoutInfo.MaxRowsCountInGroup; i++) { Indices[i] = -1; } } } 

O método GetRowHeightCore ficaria assim:

 static RowHeightInfo GetRowHeightCore(SheetLayoutInfo sheetLayoutInfo, int rowIndex) { if (rowIndex < sheetLayoutInfo.MinRowIndexNonDefault || rowIndex >= sheetLayoutInfo.MaxRowIndexNonDefault) return null; RowsGroupInfo rowsGroupInfo = sheetLayoutInfo.RowsGroups[sheetLayoutInfo.GroupIndexDelta + (rowIndex >> 4)]; if (rowsGroupInfo == null) return null; int rowInfoIndex = rowsGroupInfo.Indices[rowIndex & 0xF]; return rowInfoIndex != -1 ? rowsGroupInfo.HeightInfos[rowInfoIndex] : null; } 

E é assim que o SetRowHeight se pareceria (eu não listei seu código no excel.exe):

 public static void SetRowHeight(int rowIndex, ushort newRowHeight, ushort flags, SheetLayoutInfo sheetLayoutInfo) { sheetLayoutInfo.MaxRowIndexNonDefault = Math.Max(sheetLayoutInfo.MaxRowIndexNonDefault, rowIndex + 1); sheetLayoutInfo.MinRowIndexNonDefault = Math.Min(sheetLayoutInfo.MinRowIndexNonDefault, rowIndex); int realGroupIndex = rowIndex >> 4; if (sheetLayoutInfo.RowsGroups.Count == 0) { sheetLayoutInfo.RowsGroups.Add(null); sheetLayoutInfo.GroupIndexDelta = -realGroupIndex; } else if (sheetLayoutInfo.GroupIndexDelta + realGroupIndex < 0) { int bucketSize = -(sheetLayoutInfo.GroupIndexDelta + realGroupIndex); sheetLayoutInfo.RowsGroups.InsertRange(0, new RowsGroupInfo[bucketSize]); sheetLayoutInfo.GroupIndexDelta = -realGroupIndex; } else if (sheetLayoutInfo.GroupIndexDelta + realGroupIndex >= sheetLayoutInfo.RowsGroups.Count) { int bucketSize = sheetLayoutInfo.GroupIndexDelta + realGroupIndex - sheetLayoutInfo.RowsGroups.Count + 1; sheetLayoutInfo.RowsGroups.AddRange(new RowsGroupInfo[bucketSize]); } RowsGroupInfo rowsGroupInfo = sheetLayoutInfo.RowsGroups[sheetLayoutInfo.GroupIndexDelta + realGroupIndex]; if (rowsGroupInfo == null) { rowsGroupInfo = new RowsGroupInfo(); sheetLayoutInfo.RowsGroups[sheetLayoutInfo.GroupIndexDelta + realGroupIndex] = rowsGroupInfo; } int rowInfoIndex = rowsGroupInfo.Indices[rowIndex & 0xF]; RowHeightInfo rowHeightInfo; if (rowInfoIndex == -1) { rowHeightInfo = new RowHeightInfo(); rowsGroupInfo.HeightInfos.Add(rowHeightInfo); rowsGroupInfo.Indices[rowIndex & 0xF] = rowsGroupInfo.HeightInfos.Count - 1; } else { rowHeightInfo = rowsGroupInfo.HeightInfos[rowInfoIndex]; } rowHeightInfo.Value = newRowHeight; rowHeightInfo.Flags = flags; } 

Um pouco de prática

Após o exemplo acima, com uma alteração na altura da linha 23, o Excel se parecerá com isso (eu defino a linha 23 com 75 pontos de altura):

Você pode perceber que o Excel sempre armazena a altura da linha, se não for padrão. Mesmo que a altura não seja definida explicitamente, mas seja calculada com base no conteúdo das células ou formato, o Excel ainda a calculará uma vez e colocará o resultado no grupo apropriado.

Lidamos com a inserção / exclusão de linhas

Seria interessante analisar o que acontece ao inserir / excluir linhas. O código correspondente no excel.exe não é difícil de encontrar, mas não havia o desejo de desmontá-lo; você pode dar uma olhada em uma parte dele:

 int __userpurge sub_305EC930@<eax>(int a1@<eax>, int a2@<edx>, int a3@<ecx>, int a4, int a5, int a6) { int v6; // esi int v7; // ebx int v8; // edi int v9; // edx int v10; // ecx size_t v11; // eax _WORD *v12; // ebp size_t v13; // eax size_t v14; // eax int v15; // eax unsigned __int16 *v16; // ecx _WORD *v17; // eax _WORD *v18; // ecx int v19; // edx __int16 v20; // bx int v21; // eax _WORD *v22; // ecx int v24; // edx int v25; // eax int v26; // esi int v27; // ebx size_t v28; // eax int v29; // ebp size_t v30; // eax int v31; // esi size_t v32; // eax int v33; // eax unsigned __int16 *v34; // ecx int v35; // eax _WORD *v36; // edx _WORD *v37; // ecx int v38; // eax __int16 v39; // bx int v40; // eax _WORD *v41; // ecx int v42; // [esp+10h] [ebp-48h] int v43; // [esp+10h] [ebp-48h] int v44; // [esp+14h] [ebp-44h] char v45; // [esp+14h] [ebp-44h] int Dst[16]; // [esp+18h] [ebp-40h] int v47; // [esp+5Ch] [ebp+4h] int v48; // [esp+60h] [ebp+8h] v6 = a1; v7 = a1 & 0xF; v8 = a2; if ( !a5 ) { v24 = a4 - a1; v25 = a1 - a3; v43 = a4 - v6; if ( v7 >= v25 ) v7 = v25; v47 = a4 - v7; v26 = v6 - v7; v27 = v7 + 1; v48 = v27; if ( !v8 ) return v27; v28 = 4 * v24; if ( (4 * v24) > 0x40 ) v28 = 64; v45 = v27 + v26; v29 = (v27 + v26) & 0xF; memmove(Dst, (v8 + 4 * v29), v28); v30 = 4 * v27; if ( (4 * v27) > 0x40 ) v30 = 64; v31 = v26 & 0xF; memmove((v8 + 4 * (v47 & 0xF)), (v8 + 4 * v31), v30); v32 = 4 * v43; if ( (4 * v43) > 0x40 ) v32 = 64; memmove((v8 + 4 * v31), Dst, v32); if ( !a6 ) return v48; v33 = v29; if ( v29 < v29 + v43 ) { v34 = (v8 + 4 * v29 + 214); do { Dst[v33++] = *v34 >> 15; v34 += 2; } while ( v33 < v29 + v43 ); } v35 = (v45 - 1) & 0xF; if ( v35 >= v31 ) { v36 = (v8 + 4 * ((v27 + v47 - 1) & 0xF) + 214); v37 = (v8 + 4 * ((v45 - 1) & 0xF) + 214); v38 = v35 - v31 + 1; do { v39 = *v37 ^ (*v37 ^ *v36) & 0x7FFF; v37 -= 2; *v36 = v39; v36 -= 2; --v38; } while ( v38 ); v27 = v48; } v40 = v31; if ( v31 >= v31 + v43 ) return v27; v41 = (v8 + 4 * v31 + 214); do { *v41 = *v41 & 0x7FFF | (LOWORD(Dst[v40++]) << 15); v41 += 2; } while ( v40 < v31 + v43 ); return v27; } v9 = a1 - a4; v10 = a3 - a1; v42 = a1 - a4; v48 = 16 - v7; if ( 16 - v7 >= v10 ) v48 = v10; if ( !v8 ) return v48; v11 = 4 * v9; if ( (4 * v9) > 0x40 ) v11 = 64; v12 = (v8 + 4 * (a4 & 0xF)); v44 = a4 & 0xF; memmove(Dst, v12, v11); v13 = 4 * v48; if ( (4 * v48) > 0x40 ) v13 = 64; memmove(v12, (v8 + 4 * v7), v13); v14 = 4 * v42; if ( (4 * v42) > 0x40 ) v14 = 64; memmove((v8 + 4 * ((a4 + v48) & 0xF)), Dst, v14); if ( !a6 ) return v48; v15 = a4 & 0xF; if ( v44 < v44 + v42 ) { v16 = (v8 + 4 * v44 + 214); do { Dst[v15++] = *v16 >> 15; v16 += 2; } while ( v15 < v44 + v42 ); } if ( v7 < v48 + v7 ) { v17 = (v8 + 4 * v7 + 214); v18 = v12 + 107; v19 = v48; do { v20 = *v17 ^ (*v17 ^ *v18) & 0x7FFF; v17 += 2; *v18 = v20; v18 += 2; --v19; } while ( v19 ); } v21 = a4 & 0xF; if ( v44 >= v44 + v42 ) return v48; v22 = (v8 + 4 * (v44 + v48) + 214); do { *v22 = *v22 & 0x7FFF | (LOWORD(Dst[v21++]) << 15); v22 += 2; } while ( v21 < v44 + v42 ); return v48; } 

Além disso, na aparência, você pode entender aproximadamente o que está acontecendo lá e o restante para terminar com sinais indiretos.
Tentamos identificar esses recursos indiretos. Primeiro, defina a altura das linhas 16 a 64, inclusive em ordem aleatória. Em seguida, na frente da linha no índice 39, insira uma nova linha. A nova linha copiará a altura da linha 38.
Vejamos as informações nos grupos de séries antes e depois de adicionar uma série, destaquei as diferenças arrojadas:

Era o que era esperado: o Excel insere no segundo grupo uma nova linha com o índice 7 (39 & 0xF), cujo deslocamento é 0x05, copia a altura da linha no índice 6, enquanto a última linha, que foi deslocada 05, é empurrada para a próxima grupo, e a partir daí a última linha é empurrada para a quarta, etc.

Agora vamos ver o que acontece se você excluir a 29ª linha.

Em princípio, quando uma linha é excluída, ocorrem operações reversas. Nesse caso, o quarto grupo continua a existir e o valor da altura da linha é preenchido com a altura padrão com o sinalizador correspondente - 0x8005.

Esses dados são suficientes para reproduzir esse algoritmo em C #:

 public static void InsertRow(SheetLayoutInfo sheetLayoutInfo, int rowIndex) { if (rowIndex >= sheetLayoutInfo.MaxRowIndexNonDefault) return; RowHeightInfo etalonRowHeightInfo = GetRowHeightCore(sheetLayoutInfo, rowIndex); RowHeightInfo newRowHeightInfo = etalonRowHeightInfo != null ? etalonRowHeightInfo.Clone() : CreateDefaultRowHeight(sheetLayoutInfo); int realGroupIndex = (rowIndex + 1) >> 4; int newRowInGroupIndex = (rowIndex + 1) & 0xF; int groupIndex; for (groupIndex = realGroupIndex + sheetLayoutInfo.GroupIndexDelta; groupIndex < sheetLayoutInfo.RowsGroups.Count; groupIndex++, newRowInGroupIndex = 0) { if (groupIndex < 0) continue; if (groupIndex == SheetLayoutInfo.MaxGroupsCount) break; RowsGroupInfo rowsGroupInfo = sheetLayoutInfo.RowsGroups[groupIndex]; if (rowsGroupInfo == null) { if ((newRowHeightInfo.Flags & CustomHeightMask) == 0) continue; rowsGroupInfo = new RowsGroupInfo(); sheetLayoutInfo.RowsGroups[groupIndex] = rowsGroupInfo; } int rowInfoIndex = rowsGroupInfo.Indices[newRowInGroupIndex]; RowHeightInfo lastRowHeightInGroup; if (rowInfoIndex == -1 || rowsGroupInfo.HeightInfos.Count < SheetLayoutInfo.MaxRowsCountInGroup) { lastRowHeightInGroup = GetRowHeightCore(sheetLayoutInfo, ((groupIndex - sheetLayoutInfo.GroupIndexDelta) << 4) + SheetLayoutInfo.MaxRowsCountInGroup - 1); Array.Copy(rowsGroupInfo.Indices, newRowInGroupIndex, rowsGroupInfo.Indices, newRowInGroupIndex + 1, SheetLayoutInfo.MaxRowsCountInGroup - 1 - newRowInGroupIndex); rowsGroupInfo.HeightInfos.Add(newRowHeightInfo); rowsGroupInfo.Indices[newRowInGroupIndex] = rowsGroupInfo.HeightInfos.Count - 1; } else { int lastIndex = rowsGroupInfo.Indices[SheetLayoutInfo.MaxRowsCountInGroup - 1]; lastRowHeightInGroup = rowsGroupInfo.HeightInfos[lastIndex]; Array.Copy(rowsGroupInfo.Indices, newRowInGroupIndex, rowsGroupInfo.Indices, newRowInGroupIndex + 1, SheetLayoutInfo.MaxRowsCountInGroup - 1 - newRowInGroupIndex); rowsGroupInfo.HeightInfos[lastIndex] = newRowHeightInfo; rowsGroupInfo.Indices[newRowInGroupIndex] = lastIndex; } newRowHeightInfo = lastRowHeightInGroup ?? CreateDefaultRowHeight(sheetLayoutInfo); } if ((newRowHeightInfo.Flags & CustomHeightMask) != 0 && groupIndex != SheetLayoutInfo.MaxGroupsCount) { SetRowHeight(((groupIndex - sheetLayoutInfo.GroupIndexDelta) << 4) + newRowInGroupIndex, newRowHeightInfo.Value, newRowHeightInfo.Flags, sheetLayoutInfo); } else { sheetLayoutInfo.MaxRowIndexNonDefault = Math.Min(sheetLayoutInfo.MaxRowIndexNonDefault + 1, SheetLayoutInfo.MaxRowsCount); } } 

 public static void RemoveRow(SheetLayoutInfo sheetLayoutInfo, int rowIndex) { if (rowIndex >= sheetLayoutInfo.MaxRowIndexNonDefault) return; int realGroupIndex = rowIndex >> 4; int newRowInGroupIndex = rowIndex & 0xF; int groupIndex; for (groupIndex = realGroupIndex + sheetLayoutInfo.GroupIndexDelta; groupIndex < sheetLayoutInfo.RowsGroups.Count; groupIndex++, newRowInGroupIndex = 0) { if (groupIndex < -1) continue; if (groupIndex == -1) { sheetLayoutInfo.RowsGroups.Insert(0, null); sheetLayoutInfo.GroupIndexDelta++; groupIndex = 0; } if (groupIndex == SheetLayoutInfo.MaxGroupsCount) break; var newRowHeightInfo = groupIndex == SheetLayoutInfo.MaxGroupsCount - 1 ? null : GetRowHeightCore(sheetLayoutInfo, (groupIndex - sheetLayoutInfo.GroupIndexDelta + 1) << 4); RowsGroupInfo rowsGroupInfo = sheetLayoutInfo.RowsGroups[groupIndex]; if (rowsGroupInfo == null) { if (newRowHeightInfo == null || (newRowHeightInfo.Flags & CustomHeightMask) == 0) continue; rowsGroupInfo = new RowsGroupInfo(); sheetLayoutInfo.RowsGroups[groupIndex] = rowsGroupInfo; } if (newRowHeightInfo == null) { newRowHeightInfo = CreateDefaultRowHeight(sheetLayoutInfo); } int rowInfoIndex = rowsGroupInfo.Indices[newRowInGroupIndex]; if (rowInfoIndex == -1) { for (int i = newRowInGroupIndex; i < SheetLayoutInfo.MaxRowsCountInGroup - 1; i++) { rowsGroupInfo.Indices[i] = rowsGroupInfo.Indices[i + 1]; } rowsGroupInfo.HeightInfos.Add(newRowHeightInfo); rowsGroupInfo.Indices[SheetLayoutInfo.MaxRowsCountInGroup - 1] = rowsGroupInfo.HeightInfos.Count - 1; } else { for(int i = newRowInGroupIndex; i < rowsGroupInfo.HeightInfos.Count - 1; i++) { rowsGroupInfo.Indices[i] = rowsGroupInfo.Indices[i + 1]; } rowsGroupInfo.Indices[rowsGroupInfo.HeightInfos.Count - 1] = rowInfoIndex; rowsGroupInfo.HeightInfos[rowInfoIndex] = newRowHeightInfo; } } if(rowIndex <= sheetLayoutInfo.MinRowIndexNonDefault) { sheetLayoutInfo.MinRowIndexNonDefault = Math.Max(sheetLayoutInfo.MinRowIndexNonDefault - 1, 0); } } 

Você pode encontrar todo o código acima no GitHub

Conclusões

Esta não é a primeira vez que o código do Excel é surpreendido por truques interessantes. Dessa vez, descobri como ele armazena informações sobre as alturas das linhas. Se a comunidade estiver interessada, no próximo artigo, mostrarei como o Excel considera a altura do intervalo de células (spoiler: existe algo semelhante à decomposição do SQRT, mas por algum motivo sem cache de soma), é possível ver como ele aplica o dimensionamento em números inteiros .