public SupBookRecord(UnicodeString url, UnicodeString[] sheetNames) { field_1_number_of_sheets = (short)sheetNames.Length; field_2_encoded_url = url; field_3_sheet_names = sheetNames; _isAddInFunctions = false; }
private SupBookRecord(bool IsAddInFuncs, short numberOfSheets) { // else not 'External References' field_1_number_of_sheets = numberOfSheets; field_2_encoded_url = null; field_3_sheet_names = null; _isAddInFunctions = IsAddInFuncs; }
/** * This Is the starting point where strings are constructed. Note that * strings may span across multiple continuations. Read the SST record * carefully before beginning to hack. */ public void ManufactureStrings(int stringCount, RecordInputStream in1) { for (int i = 0; i < stringCount; i++) { //Extract exactly the count of strings from the SST record. UnicodeString str = new UnicodeString(in1); AddToStringTable(strings, str); } }
/** * Note - a value of zero for <tt>amountUsedInCurrentRecord</tt> would only ever occur just * After a {@link ContinueRecord} had been started. In the Initial {@link SSTRecord} this * value starts at 8 (for the first {@link UnicodeString} written). In general, it can be * any value between 0 and {@link #MAX_DATA_SIZE} */ private static void ConfirmSize(int expectedSize, UnicodeString s, int amountUsedInCurrentRecord) { ContinuableRecordOutput out1 = ContinuableRecordOutput.CreateForCountingOnly(); out1.WriteContinue(); for(int i=amountUsedInCurrentRecord; i>0; i--) { out1.WriteByte(0); } int size0 = out1.TotalSize; s.Serialize(out1); int size1 = out1.TotalSize; int actualSize = size1-size0; Assert.AreEqual(expectedSize, actualSize); }
/** * This Is the starting point where strings are constructed. Note that * strings may span across multiple continuations. Read the SST record * carefully before beginning to hack. */ public void ManufactureStrings(int stringCount, RecordInputStream in1) { for (int i = 0; i < stringCount; i++) { // Extract exactly the count of strings from the SST record. UnicodeString str; if (in1.Available() == 0 && !in1.HasNextRecord) { System.Console.WriteLine("Ran out of data before creating all the strings! String at index " + i + ""); str = new UnicodeString(""); } else { str = new UnicodeString(in1); } AddToStringTable(strings, str); } }
private static String ResolveTitleString(UnicodeString us) { if (us == null || us.Equals(NULL_TEXT_STRING)) { return null; } return us.String; }
private static void SerializeUnicodeString(UnicodeString us, ILittleEndianOutput out1) { StringUtil.WriteUnicodeString(out1, us.String); }
private static int GetUnicodeStringSize(UnicodeString str) { return 3 + str.String.Length; }
/** * Constructs a DV record and Sets its fields appropriately. * * @param in the RecordInputstream to Read the record from */ public DVRecord(RecordInputStream in1) { _option_flags = in1.ReadInt(); _promptTitle = ReadUnicodeString(in1); _errorTitle = ReadUnicodeString(in1); _promptText = ReadUnicodeString(in1); _errorText = ReadUnicodeString(in1); int field_size_first_formula = in1.ReadUShort(); _not_used_1 = in1.ReadShort(); //read first formula data condition _formula1 = NPOI.SS.Formula.Formula.Read(field_size_first_formula, in1); int field_size_sec_formula = in1.ReadUShort(); _not_used_2 = in1.ReadShort(); //read sec formula data condition _formula2 = NPOI.SS.Formula.Formula.Read(field_size_sec_formula, in1); //read cell range address list with all affected ranges _regions = new CellRangeAddressList(in1); }
/// <summary> /// Applies a font to the specified Chars of a string. /// </summary> /// <param name="startIndex">The start index to apply the font to (inclusive).</param> /// <param name="endIndex">The end index to apply the font to (exclusive).</param> /// <param name="fontIndex">The font to use.</param> public void ApplyFont(int startIndex, int endIndex, short fontIndex) { if (startIndex > endIndex) throw new ArgumentException("Start index must be less than end index."); if (startIndex < 0 || endIndex > Length) throw new ArgumentException("Start and end index not in range."); if (startIndex == endIndex) return; //Need to Check what the font Is currently, so we can reapply it after //the range Is completed short currentFont = NO_FONT; if (endIndex != Length) { currentFont = this.GetFontAtIndex(startIndex); } //Need to clear the current formatting between the startIndex and endIndex str = CloneStringIfRequired(); System.Collections.Generic.List<FormatRun> formatting = str.FormatIterator(); ArrayList deletedFR = new ArrayList(); if (formatting != null) { IEnumerator formats = formatting.GetEnumerator(); while (formats.MoveNext()) { FormatRun r = (FormatRun)formats.Current; if ((r.CharacterPos >= startIndex) && (r.CharacterPos < endIndex)) { deletedFR.Add(r); } } } foreach(FormatRun fr in deletedFR) { str.RemoveFormatRun(fr); } str.AddFormatRun(new FormatRun((short)startIndex, fontIndex)); if (endIndex != Length) str.AddFormatRun(new FormatRun((short)endIndex, currentFont)); AddToSSTIfRequired(); }
/// <summary> /// Adds to SST if required. /// </summary> private void AddToSSTIfRequired() { if (book != null) { int index = book.AddSSTString(str); record.SSTIndex = (index); //The act of Adding the string to the SST record may have meant that //a extsing string was returned for the index, so update our local version str = book.GetSSTString(index); } }
private static UnicodeString MakeUnicodeString(String s) { UnicodeString st = new UnicodeString(s); st.OptionFlags = (/*setter*/(byte)0); return st; }
public Object Clone() { UnicodeString str = new UnicodeString(); str.field_1_charCount = field_1_charCount; str.field_2_optionflags = field_2_optionflags; str.field_3_string = field_3_string; if (field_4_format_runs != null) { str.field_4_format_runs = new ArrayList(); int size = field_4_format_runs.Count; for (int i = 0; i < size; i++) { FormatRun r = (FormatRun)field_4_format_runs[i]; str.field_4_format_runs.Add(new FormatRun(r.Char, r.FontIndex)); } } if (field_5_ext_rst != null) { str.field_5_ext_rst = new byte[field_5_ext_rst.Length]; Array.Copy(field_5_ext_rst, 0, str.field_5_ext_rst, 0, field_5_ext_rst.Length); } return str; }
public bool IsString16bit(int id) { UnicodeString unicodeString = ((UnicodeString)field_3_strings[id]); return((unicodeString.OptionFlags & 0x01) == 1); }
public UnicodeStringTreeNode(UnicodeString record) { this.Record = record; this.Text = record.GetType().Name; this.ImageKey = "Binary"; }
private static int GetSheetIndex(UnicodeString[] sheetNames, String sheetName) { for (int i = 0; i < sheetNames.Length; i++) { if (sheetNames[i].String.Equals(sheetName)) { return i; } } throw new InvalidOperationException("External workbook does not contain sheet '" + sheetName + "'"); }
/** * Constructs a Extern Sheet record and Sets its fields appropriately. * * @param id id must be 0x16 or an exception will be throw upon validation * @param size the size of the data area of the record * @param data data of the record (should not contain sid/len) */ public SupBookRecord(RecordInputStream in1) { field_1_number_of_sheets = in1.ReadShort(); if (in1.CurrentLength > SMALL_RECORD_SIZE) { // 5.38.1 External References _isAddInFunctions = false; field_2_encoded_url = in1.ReadUnicodeString(); UnicodeString[] sheetNames = new UnicodeString[field_1_number_of_sheets]; for (int i = 0; i < sheetNames.Length; i++) { sheetNames[i] = in1.ReadUnicodeString(); } field_3_sheet_names = sheetNames; return; } // else not 'External References' field_2_encoded_url = null; field_3_sheet_names = null; short nextShort = in1.ReadShort(); if (nextShort == TAG_INTERNAL_REFERENCES) { // 5.38.2 'Internal References' _isAddInFunctions = false; } else if (nextShort == TAG_Add_IN_FUNCTIONS) { // 5.38.3 'Add-In Functions' _isAddInFunctions = true; if (field_1_number_of_sheets != 1) { throw new Exception("Expected 0x0001 for number of sheets field in 'Add-In Functions' but got (" + field_1_number_of_sheets + ")"); } } else { throw new Exception("invalid EXTERNALBOOK code (" + StringUtil.ToHexString(nextShort) + ")"); } }
private static int SerializeUnicodeString(UnicodeString us, int offset, byte[] data) { UnicodeRecordStats urs = new UnicodeRecordStats(); us.Serialize(urs, offset, data); return urs.recordSize; }
private static int GetUnicodeStringSize(UnicodeString us) { String str = us.String; return 3 + str.Length * (StringUtil.HasMultibyte(str) ? 2 : 1); }
private static void ConfirmSize(int expectedSize, UnicodeString s) { ConfirmSize(expectedSize, s, 0); }
public DVRecord(int validationType, int operator1, int errorStyle, bool emptyCellAllowed, bool suppressDropDownArrow, bool isExplicitList, bool showPromptBox, String promptTitle, String promptText, bool showErrorBox, String errorTitle, String errorText, Ptg[] formula1, Ptg[] formula2, CellRangeAddressList regions) { int flags = 0; flags = opt_data_type.SetValue(flags, validationType); flags = opt_condition_operator.SetValue(flags, operator1); flags = opt_error_style.SetValue(flags, errorStyle); flags = opt_empty_cell_allowed.SetBoolean(flags, emptyCellAllowed); flags = opt_suppress_dropdown_arrow.SetBoolean(flags, suppressDropDownArrow); flags = opt_string_list_formula.SetBoolean(flags, isExplicitList); flags = opt_show_prompt_on_cell_selected.SetBoolean(flags, showPromptBox); flags = opt_show_error_on_invalid_value.SetBoolean(flags, showErrorBox); _option_flags = flags; _promptTitle = ResolveTitleText(promptTitle); _promptText = ResolveTitleText(promptText); _errorTitle = ResolveTitleText(errorTitle); _errorText = ResolveTitleText(errorText); _formula1 = NPOI.SS.Formula.Formula.Create(formula1); _formula2 = NPOI.SS.Formula.Formula.Create(formula2); _regions = regions; }
/// <summary> /// Initializes a new instance of the <see cref="HSSFRichTextString"/> class. /// </summary> /// <param name="book">The workbook.</param> /// <param name="record">The record.</param> public HSSFRichTextString(InternalWorkbook book, LabelSSTRecord record) { SetWorkbookReferences(book, record); this.str = book.GetSSTString(record.SSTIndex); }
/** * Add a string. * * @param string string to be Added * * @return the index of that string in the table */ public int AddString(UnicodeString str) { field_1_num_strings++; UnicodeString ucs = (str == null) ? EMPTY_STRING : str; int rval; int index = field_3_strings.GetIndex(ucs); if (index != -1) { rval = index; } else { // This is a new string -- we didn't see it among the // strings we've already collected rval = field_3_strings.Size; field_2_num_unique_strings++; SSTDeserializer.AddToStringTable(field_3_strings, ucs); } return rval; }
public void TestHugeStrings() { SSTRecord record = new SSTRecord(); byte[][] bstrings = { new byte[9000], new byte[7433], new byte[9002], new byte[16998] }; UnicodeString[] strings = new UnicodeString[bstrings.Length]; int total_length = 0; for (int k = 0; k < bstrings.Length; k++) { Arrays.Fill(bstrings[k], (byte)('a' + k)); strings[k] = new UnicodeString(new String(ConvertByteToChar(bstrings[k]))); record.AddString(strings[k]); total_length += 3 + bstrings[k].Length; } // add overhead of SST record total_length += 8; // add overhead of broken strings total_length += 4; // add overhead of six records total_length += (6 * 4); byte[] content = new byte[record.RecordSize]; record.Serialize(0, content); Assert.AreEqual(total_length, content.Length); //Deserialize the record. RecordInputStream recStream = new RecordInputStream(new MemoryStream(content)); recStream.NextRecord(); record = new SSTRecord(recStream); Assert.AreEqual(strings.Length, record.NumStrings); Assert.AreEqual(strings.Length, record.NumUniqueStrings); Assert.AreEqual(strings.Length, record.CountStrings); for (int k = 0; k < strings.Length; k++) { Assert.AreEqual(strings[k], record.GetString(k)); } record = new SSTRecord(); bstrings[1] = new byte[bstrings[1].Length - 1]; for (int k = 0; k < bstrings.Length; k++) { if ((bstrings[k].Length % 2) == 1) { Arrays.Fill(bstrings[k], (byte)('a' + k)); strings[k] = new UnicodeString(new String(ConvertByteToChar(bstrings[k]))); } else { char[] data = new char[bstrings[k].Length / 2]; Arrays.Fill(data, (char)('\u2122' + k)); strings[k] = new UnicodeString(new String(data)); } record.AddString(strings[k]); } content = new byte[record.RecordSize]; record.Serialize(0, content); total_length--; Assert.AreEqual(total_length, content.Length); recStream = new RecordInputStream(new MemoryStream(content)); recStream.NextRecord(); record = new SSTRecord(recStream); Assert.AreEqual(strings.Length, record.NumStrings); Assert.AreEqual(strings.Length, record.NumUniqueStrings); Assert.AreEqual(strings.Length, record.CountStrings); for (int k = 0; k < strings.Length; k++) { Assert.AreEqual(strings[k], record.GetString(k)); } }
/// <summary> /// Removes any formatting that may have been applied to the string. /// </summary> public void ClearFormatting() { str = CloneStringIfRequired(); str.ClearFormatting(); AddToSSTIfRequired(); }
private static int GetUnicodeStringSize(UnicodeString us) { String str = us.String; return(3 + str.Length * (StringUtil.HasMultibyte(str) ? 2 : 1)); }
/// <summary> /// Initializes a new instance of the <see cref="HSSFRichTextString"/> class. /// </summary> /// <param name="str">The string.</param> public HSSFRichTextString(String str) { if (str == null) str = ""; this.str = new UnicodeString(str); }
public static SupBookRecord CreateExternalReferences(UnicodeString url, UnicodeString[] sheetNames) { return new SupBookRecord(url, sheetNames); }
/** * Adds a string to the SST table and returns its index (if its a duplicate * just returns its index and update the counts) ASSUMES compressed Unicode * (meaning 8bit) * * @param string the string to be Added to the SSTRecord * * @return index of the string within the SSTRecord */ public int AddSSTString(UnicodeString str) { //if (log.Check(POILogger.DEBUG)) // log.Log(DEBUG, "Insert to sst string='", str); if (sst == null) { InsertSST(); } return sst.AddString(str); }
static public void AddToStringTable(IntMapper<UnicodeString> strings, UnicodeString str) { strings.Add(str); }
public void TestSimpleAddString() { SSTRecord record = new SSTRecord(); UnicodeString s1 = new UnicodeString("Hello world"); // \u2122 is the encoding of the trademark symbol ... UnicodeString s2 = new UnicodeString("Hello world\u2122"); Assert.AreEqual(0, record.AddString(s1)); Assert.AreEqual(s1, record.GetString(0)); Assert.AreEqual(1, record.CountStrings); Assert.AreEqual(1, record.NumStrings); Assert.AreEqual(1, record.NumUniqueStrings); Assert.AreEqual(0, record.AddString(s1)); Assert.AreEqual(s1, record.GetString(0)); Assert.AreEqual(1, record.CountStrings); Assert.AreEqual(2, record.NumStrings); Assert.AreEqual(1, record.NumUniqueStrings); Assert.AreEqual(1, record.AddString(s2)); Assert.AreEqual(s2, record.GetString(1)); Assert.AreEqual(2, record.CountStrings); Assert.AreEqual(3, record.NumStrings); Assert.AreEqual(2, record.NumUniqueStrings); IEnumerator iter = record.GetStrings(); while (iter.MoveNext()) { UnicodeString ucs = (UnicodeString)iter.Current; if (ucs.Equals(s1)) { Assert.AreEqual((byte)0, ucs.OptionFlags); } else if (ucs.Equals(s2)) { Assert.AreEqual((byte)1, ucs.OptionFlags); } else { Assert.Fail("cannot match string: " + ucs.String); } } }