/// <summary>
/// </summary>
/// <param name="parser">CssParser</param>
/// <param name="fragment">CssFragment</param>
void GetAttributes(CssFragment fragment, CssParser parser)
{
// TODO: CssParserOptions.ReadAttributes
string sTags, sBlocks;
if (fragment.FragmentType == CssFragmentType.Definition)
{
sTags = fragment.Tag.ToString();
sBlocks = parser
.FindNextFragment(CssFragmentType.Block, (int)this.Position)
.section.Substring(parser.Text);
}
}
/// <summary>
/// Performs level-1 parsing providing a set of curly-block CssFragments.
/// </summary>
/// <exception cref="CssParserException">Throws an exception on inconsistent curly-blocks.</exception>
void ParseLevel1()
{
// Set up our initial TextRange
this.Defs.Root = new TextRange(0, this.textBuffer.Length);
// Set our initial Read Position to 0
int current = 0;
// This is our output List.
this.Defs.BlockLevels.Clear();
// List<CssFragment> list = new List<CssFragment>();
// The Stack.Count tells us what Block-Level were at.
// It increments up each time we enter a new Block, and
// increments down each time we exit a Block.
Stack <CssFragment> stack = new Stack <CssFragment>();
while ((current = this.Defs.Root.section.IndexOf(CssBlockElement, this.textBuffer, current, this.Defs.Root.section.Length32 - current, false)) > -1)
{
// This is used to store the largest possible hierarchical block level.
// such as 'GLOBAL { LEVEL-1 { LEVEL-2 { LEVEL-3 { ... } } } }'.
int stackRecursion = 0;
// Exit the loop if no more block elements have been found.
if (current == -1)
{
break;
}
// Look into our buffer to tell if we're entering or exiting from a Block.
char c = this.textBuffer[current];
// Create a new CssFragment for using later.
CssFragment temp = new CssFragment(new TextRange(current, 1))
{
FragmentType = CssFragmentType.Block
};
// if we're in a comment segment, we have no pending action.
#if DEBUG
if (this.IsInComment(temp)) /* skipping */ System {
/// <summary>A utility function to quickly get all Definition names for a range of definitions.
/// <para>A definition is what we term any declaration before the curly-block of attributes/values.</para>
/// EG: <tt>definition-term1 :selector { attribute: value; }</tt>
/// <para>Depends on (boolean) <see cref="CssParserOptions"/>.CleanDefinitionWhiteSpace value.</para>
/// </summary>
/// <returns></returns>
/// <param name="parser">CssParser provides the text-buffer.</param>
/// <exception cref="ArgumentException">Thrown if you try to get definitions from a tag that does not contain any.</exception>
public string GetDefinitions(CssParser parser)
{
System.Diagnostics.Debug.Print("Reading Definitions from element.");
if ((this.FragmentType != CssFragmentType.Definition) /* || (this.FragmentType != CssFragmentType.DefinitionFragment)*/)
{
throw new ArgumentException("Fragment MUST be CssFragmentType.Definition."); //
}
// obtain a reference to the next curly-block.
CssFragment nextBlock = parser.FindNextFragment(CssFragmentType.Block, (int)this.Position);
// TODO: report mal-formed CSS.
if (nextBlock == null)
{
System.Diagnostics.Debug.Print("Mal-Formed CSS @{0}", this.Position);
return(null);
}
// Find fragmented terms, and comments
IEnumerable <CssFragment> resultset = parser.Defs.Leveled.Where(
f =>
(f.Position < nextBlock.Position) &&
(f.Position > this.Position) &&
((f.FragmentType == CssFragmentType.Definition) || (f.FragmentType == CssFragmentType.CommentBlock))
);
// Get Text for the current element fro the buffer
string temp = this.section.Substring(parser.Text);
// clean up the text if need be
if (parser.ParserOptions.CleanDefinitionWhiteSpace)
{
temp = CleanupDefinition(temp);
}
// Get text for fragmented definitions and if need be, comments.
using (IEnumerator <CssFragment> rs = resultset.GetEnumerator())
{
while (rs.MoveNext())
{
System.Diagnostics.Debug.Print("Fragment: {0}", rs.Current.Position);
// CssFragmentType.DefinitionFragmentComment
if ((rs.Current.FragmentType == CssFragmentType.CommentBlock) && (!parser.ParserOptions.CleanDefinitionFragmentedComments))
{
System.Diagnostics.Debug.Print("Found Fragmented Comment at Position: {0}", rs.Current.Position);
rs.Current.FragmentType = CssFragmentType.DefinitionFragmentComment;
temp += parser.GetEOL() + rs.Current.section.Substring(parser.Text) + parser.GetEOL();
}
// CssFragmentType.DefinitionFragment
else if ((rs.Current.FragmentType == CssFragmentType.Definition))
{
System.Diagnostics.Debug.Print("Found Fragmented Definition at Position: {0}", rs.Current.Position);
rs.Current.FragmentType = CssFragmentType.DefinitionFragment;
temp += parser.ParserOptions.CleanDefinitionWhiteSpace ?
CleanupDefinition(rs.Current.section.Substring(parser.Text)) :
rs.Current.section.Substring(parser.Text);
}
// This is a bad idea.
this.section.Length += rs.Current.Length;
}
}
return(temp);
}
/// <summary>
/// The .NET v2.0 standard for sorting.
/// </summary>
/// <returns></returns>
/// <param name="a"></param>
/// <param name="b"></param>
static public int SortCompare(CssFragment a, CssFragment b)
{
return(a.section.Position.CompareTo(b.section.Position));
}
