Microsoft Excel पंक्ति हाइट्स के साथ कैसे काम करता है

कभी-कभी मैं ऊब जाता हूं और एक डिबगर से लैस होकर, मैं विभिन्न कार्यक्रमों में खुदाई करना शुरू कर देता हूं। इस बार, मेरी पसंद एक्सेल पर गिर गई और मैं यह पता लगाना चाहता था कि यह पंक्तियों की ऊंचाइयों को कैसे संभालता है, यह क्या संग्रहीत करता है, यह कोशिकाओं की सीमा की ऊंचाई कैसे मानता है, आदि। मैंने Excel 2010 (excel.exe, 32bit, संस्करण 14.0.4756.1000, SHA1 a805cf60a5542f21001b0ea5d142d1cd0ee00b28) को पार्स किया।

सिद्धांत से शुरू करते हैं

यदि आप Microsoft Office के लिए VBA दस्तावेज़ीकरण की ओर मुड़ते हैं, तो आप देख सकते हैं कि पंक्ति की ऊँचाई को दो गुणों के माध्यम से एक या दूसरे तरीके से प्राप्त किया जा सकता है:

• रोहाइट - रिटर्न या निर्दिष्ट सीमा में पहली पंक्ति की ऊंचाई निर्धारित करता है, अंक में मापा जाता है। डबल पढ़ें / लिखें;
• ऊँचाई - एक दोहरा मान लौटाता है जो ऊंचाई का, अंकों में, सीमा का प्रतिनिधित्व करता है। केवल पढ़ने के लिए।

और अगर आप यहां भी देखते हैं: एक्सेल विनिर्देशों और सीमाएं । आप पा सकते हैं कि अधिकतम पंक्ति ऊंचाई 409 अंक है। यह, दुर्भाग्य से, एकमात्र मामले से बहुत दूर है जब आधिकारिक Microsoft दस्तावेज़ थोड़े भ्रामक हैं। वास्तव में, एक्सेल कोड में, अधिकतम पंक्ति ऊंचाई 2047 पिक्सेल पर सेट की जाती है, जो अंकों में 1535.25 होगी। और अधिकतम फ़ॉन्ट आकार 409.55 अंक है। केवल VBA / Interop में इसे निर्दिष्ट करके इतनी बड़ी ऊंचाई की एक पंक्ति प्राप्त करना असंभव है, लेकिन आप एक पंक्ति ले सकते हैं, अपनी पहली सेल में कम्ब्रिया मठ फ़ॉन्ट सेट कर सकते हैं और फ़ॉन्ट आकार 409.55 अंक पर सेट कर सकते हैं। फिर अपने चालाक एल्गोरिथ्म के साथ एक्सेल सेल प्रारूप के आधार पर पंक्ति की ऊंचाई की गणना करेगा, 2047 पिक्सल (शब्द पर विश्वास) से अधिक में एक संख्या प्राप्त करेगा, और पंक्ति को अधिकतम संभव ऊंचाई पर सेट करेगा। यदि आप UI के माध्यम से इस श्रृंखला की ऊंचाई पूछते हैं, तो एक्सेल झूठ बोलेगा कि ऊंचाई 409.5 अंक है, लेकिन यदि आप VBA के माध्यम से श्रृंखला की ऊंचाई का अनुरोध करते हैं, तो आपको ईमानदार 1535.25 अंक मिलते हैं, जो 2047 पिक्सेल के बराबर होता है। सच है, दस्तावेज़ को बचाने के बाद, ऊंचाई अभी भी 409.5 अंक तक गिर जाएगी। इस हेरफेर को इस वीडियो में यहां देखा जा सकता है: http://recordit.co/ivnFEsELLI

मैंने एक कारण से पिछले पैराग्राफ में पिक्सल का उल्लेख किया है। एक्सेल वास्तव में पूर्णांकों में कोशिकाओं के आकार को संग्रहीत करता है और गणना करता है (यह आमतौर पर पूर्णांकों में जितना संभव हो उतना सब कुछ करता है)। ज्यादातर अक्सर ये किसी न किसी कारक से गुणा किए जाते हैं। दिलचस्प है, एक्सेल एक साधारण अंश के रूप में उपस्थिति के पैमाने को संग्रहीत करता है, उदाहरण के लिए, 75% के पैमाने को दो नंबर 3 और 4 के रूप में संग्रहीत किया जाएगा। और जब पंक्ति को प्रदर्शित करना आवश्यक होगा, तो एक्सेल पंक्ति को पिक्सेल के पूर्णांक संख्या के रूप में ले जाएगा, 3 से गुणा करें और विभाजित करें 4. 4. लेकिन वह इस ऑपरेशन को पहले ही अंजाम पर पहुंचा देगा। इससे यह प्रभाव पैदा होता है कि सब कुछ भिन्नात्मक संख्याओं में माना जाता है। इसे सत्यापित करने के लिए, VBA में निम्नलिखित कोड लिखें:

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

VBA 75 देगा क्योंकि 75.375 पिक्सेल 100.5 पिक्सेल होंगे, और एक्सेल इसे बर्दाश्त नहीं कर सकता है और 100 पिक्सेल तक का आंशिक भाग गिरा देगा। जब वीबीए अंकों में पंक्ति की ऊंचाई पूछता है, तो एक्सेल ईमानदारी से अंकों में 100 पिक्सल का अनुवाद करता है और 75 रिटर्न करता है।

सिद्धांत रूप में, हम पहले से ही C # में एक वर्ग लिखने के लिए तैयार हो गए हैं जो पंक्ति ऊंचाई के बारे में जानकारी का वर्णन करेगा:

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

आपको मेरा शब्द अभी लेना होगा, लेकिन एक्सेल में, पंक्ति की ऊंचाई को इस तरह से संग्रहीत किया जाता है। यही है, अगर यह निर्दिष्ट किया जाता है कि पंक्ति की ऊँचाई 75 अंक है, तो यह पिक्सेल में 100 होगी, फिर 400 को मूल्य में संग्रहीत किया जाएगा। मुझे पूरी तरह से पता नहीं है कि झंडे में सभी बिट्स का क्या मतलब है (झंडे के मूल्यों का पता लगाना मुश्किल और लंबा है), लेकिन मुझे यकीन है कि पता है। वह 0x4000 पंक्तियों के लिए सेट है जिसकी ऊँचाई मैन्युअल रूप से सेट की गई है, और 0x2000 - छिपी हुई पंक्तियों के लिए सेट है। सामान्य तौर पर, मैन्युअल रूप से सेट की गई ऊँचाई वाली दृश्यमान पंक्तियों के लिए, फ़्लैगस अक्सर 0x4005 के बराबर होता है, और उन पंक्तियों के लिए जिसमें फ़्लैग स्वरूपण के आधार पर ऊँचाई की गणना की जाती है, यह या तो 0xA या 0x800E है।

हम पंक्ति की ऊंचाई पूछते हैं

अब, सिद्धांत रूप में, आप excel.exe से विधि पर एक नज़र डाल सकते हैं, जो अपने सूचकांक द्वारा पंक्ति की ऊंचाई लौटाता है (सुंदर कोड के लिए HexRays के लिए धन्यवाद):

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

Dword1A0 क्या है, मैं अभी भी समझ नहीं पाया हूं। एक जगह नहीं मिली जहाँ यह झंडा लगा हो :(
मेरे लिए defaultRowDelta2 क्या है, अभी भी एक रहस्य बना हुआ है। जब एक्सेल प्रारूप के आधार पर पंक्ति की ऊंचाई की गणना करता है, तो यह इसे दो संख्याओं के योग के रूप में दर्शाता है। defaultRowDelta2 मानक पंक्ति ऊंचाई के लिए इस राशि से दूसरा नंबर है। ध्वज पैरामीटर का मान भी रहस्यमय है, क्योंकि जहाँ भी मैंने झंडे में इस पद्धति के लिए कॉल को देखा वह गलत था।
इस विधि में SheetLayoutInfo वर्ग भी दिखाई देता है। मैंने इसे इस तरह नामित किया, क्योंकि यह शीट की उपस्थिति के बारे में सभी प्रकार की बहुत सारी जानकारी संग्रहीत करता है। SheetLayoutInfo में ऐसे क्षेत्र हैं:

• DefaultFullRowHeightMul4 - मानक पंक्ति ऊंचाई;
• MinRowIndexNonDefault - पहली पंक्ति का सूचकांक, जिस पर ऊंचाई मानक से भिन्न होती है;
• MaxRowIndexNonDefault - पिछले एक के बाद श्रृंखला का सूचकांक, जिस पर ऊंचाई मानक से भिन्न होती है;
• DefaultRowDelta2 मानक पंक्ति ऊंचाई के योग का एक ही हिस्सा है।
• GroupIndexDelta - इस पर बाद में

सिद्धांत रूप में, इस विधि का तर्क समझ में आता है:

1. यदि श्रृंखला का सूचकांक गैर-मानक ऊंचाई के साथ पहले से कम है, तो मानक वापस करें;
2. यदि श्रृंखला का सूचकांक गैर-मानक ऊंचाई के साथ पिछले से अधिक है, तो मानक वापस करें;
3. अन्यथा, हम GetRowHeightCore विधि से श्रृंखला के लिए rowHeightInfo ऑब्जेक्ट प्राप्त करते हैं;
4. यदि rowHeightInfo == अशक्त मानक पंक्ति की ऊंचाई वापस आती है;
5. झंडे के साथ जादू है, लेकिन सामान्य तौर पर, हम पंक्तिहाइटइन्फोइन्फो.वैल्यू में जो है उसे वापस करते हैं और प्रतिक्रिया में 16 वीं बिट सेट करते हैं यदि पंक्ति की ऊंचाई मैन्युअल रूप से सेट नहीं की गई थी।

यदि आप C # में इस कोड को फिर से लिखते हैं, तो आपको निम्न जैसा कुछ मिलेगा:

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

अब आप देख सकते हैं कि 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. फिर से, शुरुआत में, एक्सेल यह देखने के लिए जांचता है कि क्या श्रृंखला का सूचकांक एक बदली हुई ऊँचाई वाली पंक्तियों में से है, और यदि नहीं, तो यह सुस्त हो जाती है।
2. पंक्तियों के वांछित समूह को ढूँढता है; यदि ऐसा कोई समूह नहीं है, तो यह अशक्त हो जाता है।
3. समूह में श्रृंखला का सूचकांक प्राप्त करता है।
4. इसके अलावा, श्रृंखला के सूचकांक के अनुसार, यह रोहाइटइन्फो वर्ग की वांछित वस्तु पाता है। wordBA, wordBC, wordB8 - कुछ स्थिरांक। वे इतिहास के साथ ही बदलते हैं। सिद्धांत रूप में, वे एल्गोरिथ्म की समझ को प्रभावित नहीं करते हैं।

यहाँ यह विषय से भटकने और RowsGroupInfo के बारे में अधिक बताने के लायक है। Excel 16 टुकड़ों के समूह में रोहाइटइनइन्फो को संग्रहीत करता है, जहाँ I-th समूह, जो RowsGroupInfo वर्ग द्वारा दर्शाया जाता है, i × 16 से i × 16 + 15 समावेशी पंक्तियों के बारे में जानकारी संग्रहीत करेगा।

लेकिन RowsGroupInfo में पंक्ति ऊंचाई की जानकारी कुछ हद तक असामान्य तरीके से संग्रहीत की जाती है। एक्सेल में इतिहास बनाए रखने की आवश्यकता के कारण सबसे अधिक संभावना है।

RowsGroupInfo में तीन महत्वपूर्ण फ़ील्ड हैं: Indices, HeightInfos, और RowsCount, दूसरा ऊपर दिए गए कोड में दिखाई नहीं देता है (यह इस पंक्ति में होना चाहिए: (rowGroupInfo + 8 × (...)), क्योंकि rowInfoIndex बहुत भिन्न मान ले सकता है , मैंने 1000 से अधिक बार भी देखा है और मुझे यह पता नहीं है कि आईडीए में ऐसी संरचना कैसे सेट की जाती है। RowsCount फ़ील्ड उपरोक्त कोड में नहीं दिखाई देती है, लेकिन यह है कि समूह में वास्तव में गैर-मानक पंक्तियां संग्रहीत हैं।
इसके अलावा, SheetLayoutInfo में GroupIndexDelta है - समूह के वास्तविक सूचकांक और संशोधित पंक्ति ऊंचाई के साथ पहले समूह के सूचकांक के बीच अंतर।

इंडिसेस फ़ील्ड समूह के भीतर श्रृंखला के प्रत्येक सूचकांक के लिए RowHeightInfo ऑफ़सेट को संग्रहीत करता है। वे क्रम में वहाँ संग्रहीत हैं, लेकिन HeightInfos RowHeightInfo में पहले से ही परिवर्तन के क्रम में संग्रहीत हैं।

मान लीजिए कि हमारे पास एक नई खाली शीट है और किसी तरह हमने पंक्ति संख्या 23 की ऊंचाई बदल दी। यह पंक्ति 16 पंक्तियों के दूसरे समूह में निहित है, फिर:

1. एक्सेल इस श्रृंखला के लिए समूह सूचकांक का निर्धारण करेगा। वर्तमान स्थिति में, इंडेक्स 1 होगा और GroupIndexDelta = -1 को बदल देगा।
2. पंक्तियों की एक श्रृंखला के लिए RowsGroupInfo वर्ग की एक वस्तु बनाता है और इसे sheetLayoutInfo-> RowsGroups में 0 इंडेक्स के तहत बनाता है (sheetLayoutInfo-> GroupIndexDelta + 1);
3. RowsGroupInfo में एक्सेल 16 4-बाइट इंडिसेस के लिए मेमोरी आवंटित करेगा, RowsCount, wordBA, wordBC और wordB8, आदि के लिए;
4. तब एक्सेल बिटवाइंड और ऑपरेशन के माध्यम से समूह में श्रृंखला के सूचकांक की गणना करता है (यह विभाजन के शेष भाग लेने की तुलना में बहुत तेज है): rowIndex & 0xF। समूह में वांछित सूचकांक होगा: 23 & 0xF = 7;
5. उसके बाद, एक्सेल को इंडेक्स 7: ऑफसेट = इंडिस [7] के लिए ऑफसेट मिलता है। यदि ऑफसेट = 0, तो RowsGroupInto के अंत में Excel 8 बाइट्स आवंटित करता है, एक एक करके RowsCount बढ़ाता है, और Indices [7] पर नई ऑफसेट लिखता है। किसी भी मामले में, अंत में, एक्सेल RowsGroupInfo में ऑफसेट पर नई पंक्ति ऊंचाई और झंडे के बारे में जानकारी लिखता है।

C # में RowsGroupInfo वर्ग इस तरह दिखेगा:

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

GetRowHeightCore विधि इस तरह दिखाई देगी:

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

और यह वही है जो SetRowHeight की तरह दिखेगा (मैंने 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; } 

थोड़ा सा अभ्यास

ऊपर दिए गए उदाहरण के बाद, पंक्ति 23 की ऊंचाई में परिवर्तन के साथ, एक्सेल कुछ इस तरह दिखाई देगा (मैंने पंक्ति 23 को 75 अंक की ऊंचाई पर सेट किया है):

आप देख सकते हैं कि यदि मानक नहीं है तो Excel हमेशा पंक्ति की ऊँचाई को संग्रहीत करता है। भले ही ऊंचाई स्पष्ट रूप से सेट नहीं है, लेकिन कोशिकाओं या प्रारूप की सामग्री के आधार पर गणना की जाती है, एक्सेल अभी भी एक बार इसकी गणना करेगा और परिणाम को उचित समूह में डाल देगा।

हम पंक्तियों के सम्मिलन / विलोपन से निपटते हैं

पंक्तियों को सम्मिलित / हटाते समय क्या होता है, यह पार्स करना दिलचस्प होगा। Excel.exe में संबंधित कोड को ढूंढना मुश्किल नहीं है, लेकिन इसे अलग करने की कोई इच्छा नहीं थी, आप इसके एक हिस्से पर एक नज़र डाल सकते हैं:

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

इसके अलावा, उपस्थिति में, आप मोटे तौर पर समझ सकते हैं कि वहां क्या हो रहा है, और बाकी अप्रत्यक्ष संकेतों द्वारा समाप्त करना है।
हम इन अप्रत्यक्ष सुविधाओं की पहचान करने की कोशिश करते हैं। सबसे पहले, यादृच्छिक क्रम में 16 से 64 समावेशी पंक्तियों के लिए ऊंचाई निर्धारित करें। फिर, सूचकांक 39 के तहत पंक्ति के सामने, एक नई पंक्ति डालें। नई पंक्ति पंक्ति 38 की ऊंचाई की नकल करेगी।
आइए श्रृंखला को जोड़ने से पहले और बाद में श्रृंखला के समूहों में जानकारी देखें, मैंने बोल्ड अंतर पर प्रकाश डाला:

यह वही था जो अपेक्षित था: एक्सेल दूसरे समूह में अनुक्रमणिका 7 (39 और 0xF) के साथ एक नई पंक्ति सम्मिलित करता है, जिसका ऑफसेट 0x05 है, पंक्ति की ऊँचाई को सूचकांक 6 पर कॉपी करता है, जबकि अंतिम पंक्ति, जो ऑफसेट 05 थी, को अगले पर धकेल दिया जाता है समूह, और वहाँ से अंतिम पंक्ति को चौथे में धकेल दिया जाता है, आदि।

अब देखते हैं कि 29 वीं पंक्ति को हटाने पर क्या होता है।

सिद्धांत रूप में, जब कोई पंक्ति हटा दी जाती है, तो रिवर्स ऑपरेशन होते हैं। इस स्थिति में, चौथे समूह का अस्तित्व बना रहता है और पंक्ति की ऊँचाई के मान को इसी झंडे के साथ मानक ऊँचाई से भरा जाता है - 0208005।

यह डेटा इस एल्गोरिथ्म को 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); } } 

आप उपरोक्त सभी कोड GitHub पर पा सकते हैं

निष्कर्ष

यह पहली बार नहीं है जब एक्सेल कोड दिलचस्प ट्रिक्स से हैरान हो गया है। इस बार मुझे पता चला कि वह कैसे पंक्तियों की ऊंचाइयों के बारे में जानकारी संग्रहीत करता है। यदि समुदाय में दिलचस्पी है, तो अगले लेख में मैं दिखाऊंगा कि कैसे एक्सेल कोशिकाओं की सीमा की ऊंचाई पर विचार करता है (स्पॉइलर: एसक्यूआरटी अपघटन के समान कुछ है, लेकिन कुछ कारणों के बिना रकम को रोकना), आप वहां देख सकते हैं कि यह पूर्णांकों में स्केलिंग कैसे लागू करता है ।