/// <summary>
/// Returns the font in use at a particular index.
/// </summary>
/// <param name="index">The index.</param>
/// <returns>The font that's currently being applied at that
/// index or null if no font Is being applied or the
/// index Is out of range.</returns>
public short GetFontAtIndex(int index)
{
int size = str.FormatRunCount;
FormatRun currentRun = null;
for (int i = 0; i < size; i++)
{
FormatRun r = str.GetFormatRun(i);
if (r.CharacterPos > index)
{
break;
}
else
{
currentRun = r;
}
}
if (currentRun == null)
{
return(NO_FONT);
}
else
{
return(currentRun.FontIndex);
}
}
/**
* return a character representation of the fields of this record
*
*
* @return String of output for biffviewer etc.
*
*/
public String GetDebugInfo()
{
StringBuilder buffer = new StringBuilder();
buffer.Append("[UNICODESTRING]\n");
buffer.Append(" .charcount = ")
.Append(StringUtil.ToHexString(CharCount)).Append("\n");
buffer.Append(" .optionflags = ")
.Append(StringUtil.ToHexString(OptionFlags)).Append("\n");
buffer.Append(" .string = ").Append(String).Append("\n");
if (field_4_format_Runs != null)
{
for (int i = 0; i < field_4_format_Runs.Count; i++)
{
FormatRun r = field_4_format_Runs[(i)];
buffer.Append(" .format_Run" + i + " = ").Append(r.ToString()).Append("\n");
}
}
if (field_5_ext_rst != null)
{
buffer.Append(" .field_5_ext_rst = ").Append("\n");
buffer.Append(field_5_ext_rst.ToString()).Append("\n");
}
buffer.Append("[/UNICODESTRING]\n");
return(buffer.ToString());
}
public void RemoveFormatRun(FormatRun r)
{
field_4_format_Runs.Remove(r);
if (field_4_format_Runs.Count == 0)
{
field_4_format_Runs = null;
field_2_optionflags = richText.ClearByte(field_2_optionflags);
}
}
/// <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();
}
private int FindFormatRunAt(int characterPos)
{
int size = field_4_format_Runs.Count;
for (int i = 0; i < size; i++)
{
FormatRun r = field_4_format_Runs[(i)];
if (r._character == characterPos)
{
return(i);
}
else if (r._character > characterPos)
{
return(-1);
}
}
return(-1);
}
public AlRuns(IStreamReader reader, RecordType id, UInt16 length)
: base(reader, id, length)
{
// assert that the correct record type is instantiated
Debug.Assert(this.Id == ID);
// initialize class members from stream
cRuns = reader.ReadUInt16();
if (cRuns > 0)
{
rgRuns = new FormatRun[cRuns];
for (int i = 0; i < cRuns; i++)
{
rgRuns[i] = new FormatRun(reader);
}
}
// assert that the correct number of bytes has been read from the stream
Debug.Assert(this.Offset + this.Length == this.Reader.BaseStream.Position);
}
public void TestSmallStringSize()
{
//Test a basic string
UnicodeString s = MakeUnicodeString("Test");
ConfirmSize(7, s);
//Test a small string that is uncompressed
s = MakeUnicodeString(STR_16_BIT);
s.OptionFlags = ((byte)0x01);
ConfirmSize(11, s);
//Test a compressed small string that has rich text formatting
s.String = "Test";
s.OptionFlags = ((byte)0x8);
FormatRun r = new FormatRun((short)0, (short)1);
s.AddFormatRun(r);
FormatRun r2 = new FormatRun((short)2, (short)2);
s.AddFormatRun(r2);
ConfirmSize(17, s);
//Test a uncompressed small string that has rich text formatting
s.String = STR_16_BIT;
s.OptionFlags = ((byte)0x9);
ConfirmSize(21, s);
//Test a compressed small string that has rich text and extended text
s.String = "Test";
s.OptionFlags = ((byte)0xC);
s.SetExtendedRst(new byte[] { (byte)0x1, (byte)0x2, (byte)0x3, (byte)0x4, (byte)0x5 });
ConfirmSize(26, s);
//Test a uncompressed small string that has rich text and extended text
s.String = STR_16_BIT;
s.OptionFlags = ((byte)0xD);
ConfirmSize(30, s);
}
/** Adds a font run to the formatted string.
*
* If a font run exists at the current charcter location, then it is
* Replaced with the font run to be Added.
*/
public void AddFormatRun(FormatRun r)
{
if (field_4_format_Runs == null)
{
field_4_format_Runs = new List <FormatRun>();
}
int index = FindFormatRunAt(r._character);
if (index != -1)
{
field_4_format_Runs.RemoveAt(index);
}
field_4_format_Runs.Add(r);
//Need to sort the font Runs to ensure that the font Runs appear in
//character order
//collections.Sort(field_4_format_Runs);
field_4_format_Runs.Sort();
//Make sure that we now say that we are a rich string
field_2_optionflags = richText.SetByte(field_2_optionflags);
}
/**
* Serialises out the String. There are special rules
* about where we can and can't split onto
* Continue records.
*/
public void Serialize(ContinuableRecordOutput out1)
{
int numberOfRichTextRuns = 0;
int extendedDataSize = 0;
if (IsRichText && field_4_format_Runs != null)
{
numberOfRichTextRuns = field_4_format_Runs.Count;
}
if (IsExtendedText && field_5_ext_rst != null)
{
extendedDataSize = 4 + field_5_ext_rst.DataSize;
}
// Serialise the bulk of the String
// The WriteString handles tricky continue stuff for us
out1.WriteString(field_3_string, numberOfRichTextRuns, extendedDataSize);
if (numberOfRichTextRuns > 0)
{
//This will ensure that a run does not split a continue
for (int i = 0; i < numberOfRichTextRuns; i++)
{
if (out1.AvailableSpace < 4)
{
out1.WriteContinue();
}
FormatRun r = field_4_format_Runs[(i)];
r.Serialize(out1);
}
}
if (extendedDataSize > 0)
{
field_5_ext_rst.Serialize(out1);
}
}
public int CompareTo(UnicodeString str)
{
//int result = String.CompareTo(str.String);
int result = string.Compare(String, str.String, StringComparison.CurrentCulture);
//As per the Equals method lets do this in stages
if (result != 0)
{
return(result);
}
//OK string appears to be equal but now lets compare formatting Runs
if ((field_4_format_Runs == null) && (str.field_4_format_Runs == null))
{
//Strings are Equal, and there are no formatting Runs.
return(0);
}
if ((field_4_format_Runs == null) && (str.field_4_format_Runs != null))
{
//Strings are Equal, but one or the other has formatting Runs
return(1);
}
if ((field_4_format_Runs != null) && (str.field_4_format_Runs == null))
{
//Strings are Equal, but one or the other has formatting Runs
return(-1);
}
//Strings are Equal, so now compare formatting Runs.
int size = field_4_format_Runs.Count;
if (size != str.field_4_format_Runs.Count)
{
return(size - str.field_4_format_Runs.Count);
}
for (int i = 0; i < size; i++)
{
FormatRun Run1 = field_4_format_Runs[(i)];
FormatRun run2 = str.field_4_format_Runs[(i)];
result = Run1.CompareTo(run2);
if (result != 0)
{
return(result);
}
}
//Well the format Runs are equal as well!, better check the ExtRst data
if ((field_5_ext_rst == null) && (str.field_5_ext_rst == null))
{
return(0);
}
if ((field_5_ext_rst == null) && (str.field_5_ext_rst != null))
{
return(1);
}
if ((field_5_ext_rst != null) && (str.field_5_ext_rst == null))
{
return(-1);
}
result = field_5_ext_rst.CompareTo(str.field_5_ext_rst);
if (result != 0)
{
return(result);
}
//Phew!! After all of that we have finally worked out that the strings
//are identical.
return(0);
}
/**
* Our handling of Equals is inconsistent with CompareTo. The trouble is because we don't truely understand
* rich text fields yet it's difficult to make a sound comparison.
*
* @param o The object to Compare.
* @return true if the object is actually Equal.
*/
public override bool Equals(Object o)
{
if (!(o is UnicodeString))
{
return(false);
}
UnicodeString other = (UnicodeString)o;
//OK lets do this in stages to return a quickly, first check the actual string
bool eq = ((field_1_charCount == other.field_1_charCount) &&
(field_2_optionflags == other.field_2_optionflags) &&
field_3_string.Equals(other.field_3_string));
if (!eq)
{
return(false);
}
//OK string appears to be equal but now lets compare formatting Runs
if ((field_4_format_Runs == null) && (other.field_4_format_Runs == null))
{
//Strings are Equal, and there are not formatting Runs.
return(true);
}
if (((field_4_format_Runs == null) && (other.field_4_format_Runs != null)) ||
(field_4_format_Runs != null) && (other.field_4_format_Runs == null))
{
//Strings are Equal, but one or the other has formatting Runs
return(false);
}
//Strings are Equal, so now compare formatting Runs.
int size = field_4_format_Runs.Count;
if (size != other.field_4_format_Runs.Count)
{
return(false);
}
for (int i = 0; i < size; i++)
{
FormatRun Run1 = field_4_format_Runs[(i)];
FormatRun run2 = other.field_4_format_Runs[(i)];
if (!Run1.Equals(run2))
{
return(false);
}
}
// Well the format Runs are equal as well!, better check the ExtRst data
if (field_5_ext_rst == null && other.field_5_ext_rst == null)
{
// Good
}
else if (field_5_ext_rst != null && other.field_5_ext_rst != null)
{
int extCmp = field_5_ext_rst.CompareTo(other.field_5_ext_rst);
if (extCmp == 0)
{
// Good
}
else
{
return(false);
}
}
else
{
return(false);
}
//Phew!! After all of that we have finally worked out that the strings
//are identical.
return(true);
}
/// <summary>
/// Gets the font used in a particular formatting run.
/// </summary>
/// <param name="index">the index of the formatting run.</param>
/// <returns>the font number used.</returns>
public short GetFontOfFormattingRun(int index)
{
FormatRun r = str.GetFormatRun(index);
return(r.FontIndex);
}
/// <summary>
/// The index within the string to which the specified formatting run applies.
/// </summary>
/// <param name="index">the index of the formatting run</param>
/// <returns>the index within the string.</returns>
public int GetIndexOfFormattingRun(int index)
{
FormatRun r = str.GetFormatRun(index);
return(r.CharacterPos);
}
