protected override void AcceptExpression(
        ITextControl textControl, ISolution solution, TextRange resultRange, ICSharpExpression expression)
            {
                // set selection for introduce field
                textControl.Selection.SetRanges(new[] {TextControlPosRange.FromDocRange(textControl, resultRange)});

                const string name = "IntroFieldAction";
                var rules = DataRules
                  .AddRule(name, ProjectModel.DataContext.DataConstants.SOLUTION, solution)
                  .AddRule(name, DataConstants.DOCUMENT, textControl.Document)
                  .AddRule(name, TextControl.DataContext.DataConstants.TEXT_CONTROL, textControl)
                  .AddRule(name, Psi.Services.DataConstants.SELECTED_EXPRESSION, expression);

                Lifetimes.Using(lifetime =>
                  WorkflowExecuter.ExecuteBatch(
                Shell.Instance.GetComponent<DataContexts>().CreateWithDataRules(lifetime, rules),
                new IntroFieldWorkflow(solution, null)));

                // todo: rename hotspots

                var ranges = textControl.Selection.Ranges.Value;
                if (ranges.Count == 1) // reset selection
                {
                  var endPos = ranges[0].End;
                  textControl.Selection.SetRanges(new[] {new TextControlPosRange(endPos, endPos)});
                }
            }

        public PostfixTemplateAcceptanceContext(
      [NotNull] IReferenceExpression referenceExpression,
      [NotNull] ICSharpExpression expression,
      TextRange replaceRange, TextRange expressionRange,
      bool canBeStatement, bool looseChecks)
        {
            ReferenceExpression = referenceExpression;
              Expression = expression;
              ExpressionType = expression.Type();
              ReplaceRange = replaceRange;
              ExpressionRange = expressionRange;
              CanBeStatement = canBeStatement;
              LooseChecks = looseChecks;

              ContainingFunction = Expression.GetContainingNode<ICSharpFunctionDeclaration>();

              var expressionReference = expression as IReferenceExpression;
              if (expressionReference != null)
              {
            ExpressionReferencedElement = expressionReference.Reference.Resolve().DeclaredElement;
              }
              else
              {
            var typeExpression = expression as IPredefinedTypeExpression;
            if (typeExpression != null)
            {
              var typeName = typeExpression.PredefinedTypeName;
              if (typeName != null)
            ExpressionReferencedElement = typeName.Reference.Resolve().DeclaredElement;
            }
              }
        }

        /// <summary>
        /// Locate value of attribute position for specified html tag
        /// </summary>
        public static TextRange GetTagAttributeValuePos(ref string pageHtml, string tagName, string attributeName, int start)
        {
            int tagStart, tagEnd;
            int attrStart;
            int valueStart;

            // Allocate result with default values
            TextRange result = new TextRange(-1, -1);

            // Incorrect input
            if (start >= pageHtml.Length)
                return result;

            // Correct tag name
            if (tagName[0] != '<')
                tagName = '<' + tagName;

            //=============================================================//

            // Find tag first position
            tagStart = StringCompare.IndexOfIgnoreCase(ref pageHtml, tagName, start);
            if (tagStart == -1)
                return result;

            // Locate end of tag
            tagEnd = StringCompare.IndexOfMatchCase(ref pageHtml, ">", tagStart);

            // Wrong html code
            if (tagEnd == -1)
                return result;

            // Find the Attribute position
            attrStart = StringCompare.IndexOfIgnoreCase(ref pageHtml, attributeName, tagStart);

            // There is no attribute, so go away!
            if (attrStart == -1 || attrStart >= tagEnd)
            {
                // Set found start position to result
                result.Start = tagStart;
                result.End = -1;
                return result;
            }

            // Find value start position
            valueStart = StringCompare.IndexOfMatchCase(ref pageHtml, '=', attrStart);

            // There is no value, so go away!
            if (valueStart == -1 || valueStart >= tagEnd)
            {
                // Set found start position to result
                result.Start = attrStart;
                result.End = -1;
                return result;
            }

            // Locate value of attribute position
            result = FindAttributeValuePosition(ref pageHtml, tagEnd, valueStart);

            return result;
        }

 public static void divideToLines(Slides slides, Slide slide, TextRange textRange)
 {
     var slideNumber = slide.SlideIndex;
     float slideDuration = slide.SlideShowTransition.AdvanceTime;
     int divisionNumber = textRange.Lines().Count;
     float duration = durationAfterDivisions(slideDuration, divisionNumber / 2);
     string textFrmLines = "";
     foreach (TextRange line in textRange.Lines())
     {
         if (textFrmLines.Length > 0)
         {
             textFrmLines += line.Text;
             SlidesManipulation.createNewSlide(slides, ++slideNumber, textFrmLines.Trim(), duration);
             SlidesManipulation.createNewSlide(slides, ++slideNumber, "", 0.01F);
             textFrmLines = "";
         }
         else
         {
             textFrmLines += line.Text;
         }
     }
     //add the rest of textFrmLines
     if (textFrmLines.Length > 0)
     {
         SlidesManipulation.createNewSlide(slides, ++slideNumber, textFrmLines, duration);
         SlidesManipulation.createNewSlide(slides, ++slideNumber, "", 0.1F);
     }
         //delete slides
         slide.Delete();
         slides[slideNumber].Delete();
 }

        public TypefaceListItem(Typeface typeface)
        {
            _displayName = GetDisplayName(typeface);
            _simulated = typeface.IsBoldSimulated || typeface.IsObliqueSimulated;

            this.FontFamily = typeface.FontFamily;
            this.FontWeight = typeface.Weight;
            this.FontStyle = typeface.Style;
            this.FontStretch = typeface.Stretch;

            string itemLabel = _displayName;

            if (_simulated)
            {
                string formatString = Properties.FontDialogResources.ResourceManager.GetString(
                    "simulated", 
                    CultureInfo.CurrentUICulture
                    );
                itemLabel = string.Format(formatString, itemLabel);
            }

            Text = itemLabel;
            ToolTip = itemLabel;

            // In the case of symbol font, apply the default message font to the text so it can be read.
            if (FontFamilyListItem.IsSymbolFont(typeface.FontFamily))
            {
                var range = new TextRange(ContentStart, ContentEnd);
                range.ApplyPropertyValue(TextBlock.FontFamilyProperty, SystemFonts.MessageFontFamily);
            }
        }

 public Assign(string name, Element value, bool isMaybe, TextRange range)
     : base(isMaybe, range)
 {
     Contract.Requires<ArgumentNullException>(name != null);
     this.Name = name;
     this.Value = value;
 }

        protected JasmineElement(KarmaServiceProvider provider, string name,
			ProjectModelElementEnvoy projectFileEnvoy,
			TextRange textRange, IList<string> referencedFiles)
            : base(provider, name, projectFileEnvoy, textRange)
        {
            _referencedFiles = referencedFiles ?? new List<string>().AsReadOnly();
        }

        public static UnitTestElementDisposition BuildDisposition(UnitTestElement element, ScenarioLocation location, IProjectFile  projectFile)
        {
            var contents = File.ReadAllText(location.Path);
            var range = new TextRange(LineToOffset(contents, location.FromLine), LineToOffset(contents, location.ToLine));

            return new UnitTestElementDisposition(element, projectFile, range, new TextRange(0));
        }

 /// <summary>
 /// Selects the element.
 /// </summary>
 public override IEnumerable<TextRange> SelectElement(TextRange textRange)
 {
     return base.SelectElement(textRange).Where(line => {
         var text = TextRangeExtensions.GetText(line);
         return IsEmptyLineIncluded || !String.IsNullOrWhiteSpace(text);
     });
 }

        public CsvCompilationUnit CompilationUnit(TextRange textRange, IEnumerable<RowDeclarationSyntax> rows)
        {
            Assume.NotNull(textRange, nameof(textRange));
            Assume.NotNull(rows, nameof(rows));

            return new CsvCompilationUnit(textRange, rows);
        }

		/// <summary>
		/// Locates @import rule value
		/// </summary>
		/// <param name="cssCodes"></param>
		/// <param name="startindex"></param>
		/// <param name="onlyWithoutUrlOption">Specifies that operator should not catch rule with URL attribute.</param>
		/// <param name="captureExactInUrl">Specifies that operator should strip the URL attribute if there is any</param>
		/// <returns></returns>
		public static TextRange FindImportRuleUrlPosition(ref string cssCodes, int startindex, bool onlyWithoutUrlOption, bool captureExactlyInUrl)
		{
			int valueStart, valueEnd;
			TextRange result = new TextRange(-1, -1);
			const string strCSSImportRule = "@import";
			const string strCSSUrlValue = "url(";

			//==============================
			if (startindex >= cssCodes.Length)
				return result;


			// Find first position
			valueStart = StringCompare.IndexOfIgnoreCase(ref cssCodes, strCSSImportRule, startindex);
			if (valueStart == -1)
				return result;

			valueStart += strCSSImportRule.Length;

			// 
			if (cssCodes.Substring(valueStart, 1).Trim().Length > 0)
				return result;
			else
				valueStart++;

			valueEnd = StringCompare.IndexOfMatchCase(ref cssCodes, ";", valueStart);

			if (valueEnd == -1)
				return result;
			else
			{
				int urlPos = StringCompare.IndexOfIgnoreCase(ref cssCodes, strCSSUrlValue, valueStart);
				if (urlPos != -1 && urlPos < valueEnd)
				{
					if (onlyWithoutUrlOption)
					{
						result.Start = valueEnd;
						result.End = -1;
						return result;
					}

					if (captureExactlyInUrl)
					{
						valueStart = urlPos + strCSSUrlValue.Length;

						urlPos = StringCompare.IndexOfMatchCase(ref cssCodes, ")", valueStart);
						if (urlPos != -1 && urlPos < valueEnd)
						{
							valueEnd = urlPos;
						}
					}
				}
			}

			result.Start = valueStart;
			result.End = valueEnd;
			return result;

		}

        public override UnitTestElementDisposition GetDisposition()
        {
            var projectFile = GetProjectFile(Scenario.Location.Path);
            var contents = File.ReadAllText(Scenario.Location.Path);
            var range = new TextRange(LineToOffset(contents, Scenario.Location.FromLine), LineToOffset(contents, Scenario.Location.ToLine));

            return new UnitTestElementDisposition(this, projectFile, range, new TextRange(0));
        }

 /// <summary>
 /// Creates row node and appends it to actual document node
 /// </summary>
 public ICsvTreeFactory CreateRow(TextRange textRange)
 {
     Assume.NotNull(textRange, nameof(textRange));
     checkIsDocumentDefined();
     _actualRowDeclaration = new RowDeclarationSyntax(textRange);
     _csvCompilationUnits.Peek().AppendChild(_actualRowDeclaration);
     return this;
 }

 protected Element(KarmaServiceProvider serviceProvider, string name, ProjectModelElementEnvoy projectFileEnvoy, TextRange textRange)
 {
     ServiceProvider = serviceProvider;
     ShortName = name;
     ProjectFileEnvoy = projectFileEnvoy;
     TextRange = textRange;
     State = UnitTestElementState.Valid;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="CsvCompilationUnit"/> class.
        /// </summary>
        public CsvCompilationUnit(TextRange textRange, IEnumerable<RowDeclarationSyntax> rows)
            : base(textRange)
        {
            Assume.NotNull(rows, nameof(rows));

            Rows = rows;
            this.AttachChildren(rows);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="TextDocument"/> class.
        /// </summary>
        public TextDocument(String text)
        {
            Assume.NotNull("text", text);

            Text = text;
            TextRange = CreateOrGetTextRange(0, text.Length);
            _root = TextRange;
        }

			public DeclaredElementInfo([NotNull] IDeclaredElement declaredElement, [NotNull] ISubstitution substitution, [NotNull] IFile file,
				TextRange sourceRange, [CanBeNull] IReference reference) {
				DeclaredElement = declaredElement;
				Substitution = substitution;
				File = file;
				SourceRange = sourceRange;
				Reference = reference;
			}

        /// <summary>
        /// Removes the text.
        /// </summary>
        /// <param name="textRange">The text range.</param>
        /// <returns></returns>
        public TextDocument RemoveText(TextRange textRange)
        {
            Assume.NotNull(textRange, "textRange");

            ChangeText(textRange, String.Empty);
            removeTextRange(textRange);

            return this;
        }

        /// <summary>
        /// Creates the document node 
        /// </summary>
        public ICsvTreeFactory CreateDocument(TextRange textRange)
        {
            Assume.NotNull(textRange, nameof(textRange));
            var csvCompilationUnit = new CsvCompilationUnit(textRange);

            _csvCompilationUnits.Push(csvCompilationUnit);

            return this;
        }

        public RowDeclarationSyntax Row(TextRange textRange, IEnumerable<CommaToken> commas, IEnumerable<FieldDeclarationSyntax> fields)
        {
            Assume.NotNull(commas, nameof(commas));
            Assume.NotNull(fields, nameof(fields));

            return new RowDeclarationSyntax(textRange) {
                Commas = commas,
                Fields = fields
            };
        }