Fonctionnement de Microsoft Excel avec les hauteurs de ligne

Parfois je m'ennuie et, armé d'un débogueur, je commence à creuser dans différents programmes. Cette fois, mon choix s'est porté sur Excel et je voulais comprendre comment il gère les hauteurs des lignes, ce qu'il stocke, comment il considère la hauteur de la plage de cellules, etc. J'ai analysé Excel 2010 (excel.exe, 32 bits, version 14.0.4756.1000, SHA1 a805cf60a5542f21001b0ea5d142d1cd0ee00b28).

Commençons par la théorie

Si vous consultez la documentation VBA pour Microsoft Office, vous pouvez voir que la hauteur de ligne peut être obtenue d'une manière ou d'une autre via deux propriétés:

• RowHeight - Renvoie ou définit la hauteur de la première ligne dans la plage spécifiée, mesurée en points. Lecture / écriture Double;
• Hauteur - Renvoie une valeur Double qui représente la hauteur, en points, de la plage. Lecture seule.

Et si vous regardez aussi ici: spécifications et limites Excel . Vous pouvez constater que la hauteur de ligne maximale est de 409 points. Malheureusement, c'est loin d'être le seul cas où les documents officiels de Microsoft sont un peu rusés. En fait, dans le code Excel, la hauteur de ligne maximale est définie sur 2047 pixels, ce qui correspond à 1535,25 points. Et la taille de police maximale est de 409,55 points. Il est impossible d'obtenir une ligne d'une telle hauteur en l'affectant simplement dans VBA / Interop, mais vous pouvez prendre une ligne, définir la police Cambria Math dans sa première cellule et définir la taille de la police sur 409,55 points. Ensuite, Excel avec son algorithme rusé calculera la hauteur de ligne en fonction du format de cellule, obtiendra un nombre supérieur à 2047 pixels (croyez le mot) et définira la ligne à la hauteur maximale possible. Si vous demandez la hauteur de cette série via l'interface utilisateur, Excel mentira que la hauteur est de 409,5 points, mais si vous demandez la hauteur de la série via VBA, vous obtenez honnêtement 1535,25 points, ce qui équivaut à 2047 pixels. Certes, après avoir enregistré le document, la hauteur baissera toujours à 409,5 points. Cette manipulation peut être observée ici dans cette vidéo: http://recordit.co/ivnFEsELLI

J'ai mentionné les pixels dans le paragraphe précédent pour une raison. Excel stocke et calcule en fait la taille des cellules en nombres entiers (il fait généralement tout autant que possible en nombres entiers). Le plus souvent, ce sont des pixels multipliés par un facteur. Fait intéressant, Excel stocke l'échelle d'apparence sous la forme d'une fraction ordinaire, par exemple, une échelle de 75% sera stockée sous la forme de deux nombres 3 et 4. Et quand il est nécessaire d'afficher la ligne, Excel prendra la hauteur de la ligne comme un nombre entier de pixels, multipliez par 3 et divisez par 4. Mais il effectuera cette opération déjà à la toute fin, ce qui crée l'effet que tout est considéré en nombres fractionnaires. Pour vérifier cela, écrivez le code suivant dans VBA:

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

VBA donnera 75 parce que 75,375 pixels seront 100,5 pixels, et Excel ne peut pas se le permettre et déposera la partie fractionnaire jusqu'à 100 pixels. Lorsque VBA demande la hauteur de ligne en points, Excel traduit honnêtement 100 pixels en points et renvoie 75.

En principe, nous avons déjà commencé à écrire une classe en C # qui décrira des informations sur la hauteur de ligne:

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

Vous devrez prendre ma parole pour l'instant, mais dans Excel, la hauteur de ligne est stockée de cette façon. Autrement dit, s'il est spécifié que la hauteur de la ligne est de 75 points, elle sera de 100 en pixels, puis 400 sera stockée dans Value. Je n'ai pas entièrement compris ce que tous les bits dans Flags signifient (il est difficile et long de comprendre les valeurs des drapeaux), mais je sais avec certitude que 0x4000 est défini pour les lignes dont la hauteur est définie manuellement et 0x2000 - est défini pour les lignes masquées. En général, pour les lignes visibles avec une hauteur définie manuellement, les indicateurs sont le plus souvent égaux à 0x4005, et pour les lignes dans lesquelles la hauteur est calculée en fonction du formatage des indicateurs, il s'agit de 0xA ou 0x800E.

Nous demandons la hauteur de ligne

Maintenant, en principe, vous pouvez jeter un œil à la méthode de excel.exe, qui retourne la hauteur de la ligne par son index (merci à HexRays pour le beau code):

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

Qu'est-ce que dword1A0, je n'ai toujours pas compris. n'a pas pu trouver un endroit où ce drapeau est défini :(
Ce qui est defaultRowDelta2 pour moi aussi, reste toujours un mystère. Lorsque Excel calcule la hauteur de ligne en fonction du format, il la représente comme la somme de deux nombres. defaultRowDelta2 est le deuxième nombre de cette somme pour la hauteur de ligne standard. La valeur du paramètre flag est également mystérieuse, car partout où j'ai vu un appel à cette méthode dans flag passé faux.
La classe SheetLayoutInfo apparaît également dans cette méthode. Je l'ai nommé ainsi, car il stocke beaucoup de toutes sortes d'informations sur l'apparence de la feuille. Dans SheetLayoutInfo, il existe des champs tels que:

• DefaultFullRowHeightMul4 - hauteur de ligne standard;
• MinRowIndexNonDefault - l'indice de la première ligne, à laquelle la hauteur diffère de la norme;
• MaxRowIndexNonDefault - indice de la série suivant la dernière, à laquelle la hauteur diffère de la norme;
• DefaultRowDelta2 est la même partie de la somme de la hauteur de ligne standard.
• GroupIndexDelta - plus à ce sujet plus tard

En principe, la logique de cette méthode est compréhensible:

1. Si l'indice de la série est inférieur au premier avec une hauteur non standard, renvoyez le standard;
2. Si l'indice de la série est supérieur au dernier avec une hauteur non standard, renvoyez le standard;
3. Sinon, nous obtenons l'objet rowHeightInfo pour la série à partir de la méthode GetRowHeightCore;
4. Si rowHeightInfo == null renvoie la hauteur de ligne standard;
5. Il y a de la magie avec les drapeaux, mais en général, nous renvoyons ce qui est dans rowHeightInfo.Value et définissons le 16e bit dans la réponse si la hauteur de la ligne n'a pas été définie manuellement.

Si vous réécrivez ce code en C #, vous obtenez quelque chose comme ceci:

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

Vous pouvez maintenant voir ce qui se passe à l'intérieur de 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. Encore une fois, au début, Excel vérifie si l'index de la série se trouve parmi les lignes avec une hauteur modifiée, et sinon, il renvoie null.
2. Recherche le groupe de lignes souhaité; s'il n'y en a pas, il renvoie null.
3. Obtient l'index de la série dans le groupe.
4. De plus, par l'index de la série, il trouve l'objet souhaité de la classe RowHeightInfo. wordBA, wordBC, wordB8 - quelques constantes. Ils ne changent qu'avec l'histoire. En principe, ils n'affectent pas la compréhension de l'algorithme.

Ici, il vaut la peine de s'écarter du sujet et d'en dire plus sur RowsGroupInfo. Excel stocke RowHeightInfo dans des groupes de 16 pièces, où le i-ème groupe, représenté par la classe RowsGroupInfo, stockera des informations sur les lignes de i × 16 à i × 16 + 15 inclus.

Mais les informations de hauteur de ligne dans RowsGroupInfo sont stockées d'une manière quelque peu inhabituelle. Très probablement en raison de la nécessité de conserver l'historique dans Excel.

Il y a trois champs importants dans RowsGroupInfo: Indices, HeightInfos et RowsCount, le second n'est pas visible dans le code ci-dessus (il devrait être dans cette ligne: (rowsGroupInfo + 8 × (...)), car rowInfoIndex peut prendre des valeurs très différentes , J'en ai vu encore plus de 1000 et je ne sais pas comment définir une telle structure dans l'IDA.Le champ RowsCount n'apparaît pas dans le code ci-dessus, mais c'est le nombre de lignes vraiment non standard stockées dans le groupe.
De plus, dans SheetLayoutInfo, il y a GroupIndexDelta - la différence entre l'index réel du groupe et l'index du premier groupe avec une hauteur de ligne modifiée.

Le champ Indices stocke les décalages RowHeightInfo pour chaque index de la série dans le groupe. Ils y sont stockés dans l'ordre, mais dans HeightInfos RowHeightInfo sont déjà stockés dans l'ordre de modification.

Supposons que nous ayons une nouvelle feuille vierge et que nous ayons en quelque sorte changé la hauteur de la ligne numéro 23. Cette ligne se trouve dans le deuxième groupe de 16 lignes, puis:

1. Excel déterminera l'index de groupe pour cette série. Dans le cas actuel, l'index sera 1 et changera GroupIndexDelta = -1.
2. Crée un objet de la classe RowsGroupInfo pour une série de lignes et le place dans sheetLayoutInfo-> RowsGroups sous l'index 0 (sheetLayoutInfo-> GroupIndexDelta + 1);
3. Dans RowsGroupInfo, Excel allouera de la mémoire pour 16 indices à 4 octets, pour RowsCount, wordBA, wordBC et wordB8, etc.;
4. Excel calcule ensuite l'index de la série dans le groupe via l'opération ET au niveau du bit (c'est beaucoup plus rapide que de prendre le reste de la division): rowIndex & 0xF. L'index souhaité dans le groupe sera: 23 & 0xF = 7;
5. Après cela, Excel obtient le décalage pour l'index 7: offset = Indices [7]. Si offset = 0, Excel alloue 8 octets à la fin de RowsGroupInto, augmente le RowsCount de un et écrit le nouveau décalage dans Indices [7]. Dans tous les cas, à la fin, Excel écrit des informations sur la nouvelle hauteur de ligne et les indicateurs au décalage dans RowsGroupInfo.

La classe RowsGroupInfo en C # lui-même ressemblerait à ceci:

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

La méthode GetRowHeightCore ressemblerait à ceci:

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

Et voici à quoi ressemblerait SetRowHeight (je n'ai pas répertorié son code depuis 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; } 

Un peu de pratique

Après l'exemple ci-dessus, avec un changement dans la hauteur de la ligne 23, Excel ressemblera à ceci (j'ai défini la ligne 23 à une hauteur de 75 points):

Vous pouvez remarquer qu'Excel stocke toujours la hauteur de ligne si elle n'est pas standard. Même si la hauteur n'est pas définie explicitement, mais est calculée en fonction du contenu des cellules ou du format, Excel la calculera toujours une fois et mettra le résultat dans le groupe approprié.

Nous nous occupons de l'insertion / suppression de lignes

Il serait intéressant d'analyser ce qui se passe lors de l'insertion / suppression de lignes. Le code correspondant dans excel.exe n'est pas difficile à trouver, mais il n'y avait aucune envie de le démonter, vous pouvez en voir une partie:

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

De plus, en apparence, vous pouvez à peu près comprendre ce qui s'y passe, et le reste pour finir par des signes indirects.
Nous essayons d'identifier ces caractéristiques indirectes. Tout d'abord, définissez la hauteur des lignes 16 à 64 inclusivement dans un ordre aléatoire. Ensuite, devant la ligne sous l'index 39, insérez une nouvelle ligne. La nouvelle ligne copiera la hauteur de la ligne 38.
Regardons les informations dans les groupes de séries avant et après avoir ajouté une série, j'ai souligné les différences audacieuses:

C'est ce qui était attendu: Excel insère dans le deuxième groupe une nouvelle ligne avec l'index 7 (39 & 0xF), dont le décalage est 0x05, copie la hauteur de ligne à l'index 6, tandis que la dernière ligne, qui était décalée 05, est poussée à la suivante groupe, et à partir de là, la dernière ligne est poussée dans le quatrième, etc.

Voyons maintenant ce qui se passe si vous supprimez la 29e ligne.

En principe, lorsqu'une ligne est supprimée, des opérations inverses se produisent. Dans ce cas, le quatrième groupe continue d'exister et la valeur de la hauteur de ligne y est remplie avec la hauteur standard avec l'indicateur correspondant - 0x8005.

Ces données sont suffisantes pour reproduire cet algorithme en 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); } } 

Vous pouvez trouver tout le code ci-dessus sur GitHub

Conclusions

Ce n'est pas la première fois que le code Excel est surpris par des astuces intéressantes. Cette fois, j'ai découvert comment il stocke des informations sur les hauteurs des rangées. Si la communauté est intéressée, dans le prochain article, je montrerai comment Excel considère la hauteur de la plage de cellules (spoiler: il y a quelque chose de similaire à la décomposition SQRT, mais pour une raison quelconque sans mettre en cache les sommes), vous pouvez voir comment il applique la mise à l'échelle en nombres entiers .