static void AppendHtmlText (StringBuilder htmlText, TextDocument doc, ITextEditorOptions options, int start, int end)
		{
			for (int i = start; i < end; i++) {
				char ch = doc.GetCharAt (i);
				switch (ch) {
				case ' ':
					htmlText.Append ("&nbsp;");
					break;
				case '\t':
					for (int i2 = 0; i2 < options.TabSize; i2++)
						htmlText.Append ("&nbsp;");
					break;
				case '<':
					htmlText.Append ("&lt;");
					break;
				case '>':
					htmlText.Append ("&gt;");
					break;
				case '&':
					htmlText.Append ("&amp;");
					break;
				case '"':
					htmlText.Append ("&quot;");
					break;
				default:
					htmlText.Append (ch);
					break;
				}
			}
		}

        public void RawlyIndentLine(int tabsToInsert, TextDocument document, DocumentLine line)
        {
            if (!_doBeginUpdateManually)
                document.BeginUpdate();
            /*
             * 1) Remove old indentation
             * 2) Insert new one
             */

            // 1)
            int prevInd = 0;
            int curOff = line.Offset;
            if (curOff < document.TextLength)
            {
                char curChar = '\0';
                while (curOff < document.TextLength && ((curChar = document.GetCharAt(curOff)) == ' ' || curChar == '\t'))
                {
                    prevInd++;
                    curOff++;
                }

                document.Remove(line.Offset, prevInd);
            }

            // 2)
            string indentString = "";
            for (int i = 0; i < tabsToInsert; i++)
                indentString += dEditor.Editor.Options.IndentationString;

            document.Insert(line.Offset, indentString);
            if (!_doBeginUpdateManually)
                document.EndUpdate();
        }

		static void AppendRtfText (StringBuilder rtfText, TextDocument doc, int start, int end, ref bool appendSpace)
		{
			for (int i = start; i < end; i++) {
				char ch = doc.GetCharAt (i);
				switch (ch) {
				case '\\':
					rtfText.Append (@"\\");
					break;
				case '{':
					rtfText.Append (@"\{");
					break;
				case '}':
					rtfText.Append (@"\}");
					break;
				case '\t':
					rtfText.Append (@"\tab");
					appendSpace = true;
					break;
				default:
					if (appendSpace) {
						rtfText.Append (' ');
						appendSpace = false;
					}
					rtfText.Append (ch);
					break;
				}
			}
		}

        /// <summary>
        /// Reformat all comments between the specified start and end point. Comments that start
        /// within the range, even if they overlap the end are included.
        /// </summary>
        /// <param name="textDocument">The text document.</param>
        /// <param name="start">The start point.</param>
        /// <param name="end">The end point.</param>
        public bool FormatComments(TextDocument textDocument, EditPoint start, EditPoint end)
        {
            var options = new CodeCommentOptions(Settings.Default, _package, textDocument);

            bool foundComments = false;

            while (start.Line <= end.Line)
            {
                if (CodeCommentHelper.IsCommentLine(start))
                {
                    var comment = new CodeComment(start);
                    if (comment.IsValid)
                    {
                        comment.Format(options);
                        foundComments = true;
                    }

                    if (comment.EndPoint != null)
                    {
                        start = comment.EndPoint.CreateEditPoint();
                    }
                }

                if (start.Line == textDocument.EndPoint.Line)
                {
                    break;
                }

                start.LineDown();
                start.StartOfLine();
            }

            return foundComments;
        }

    void Example6()
    {
        //Create a new text document
        TextDocument document = new TextDocument();
        document.New();
        //Create a table for a text document using the TableBuilder
        Table table = TableBuilder.CreateTextDocumentTable(
            document,
            "table1",
            "table1",
            3,
            3,
            16.99,
            false,
            false);

        //Fill the cells
        foreach (Row row in table.RowCollection)
        {
            foreach (Cell cell in row.CellCollection)
            {
                //Create a standard paragraph
                Paragraph paragraph = ParagraphBuilder.CreateStandardTextParagraph(document);
                //Add some simple text
                paragraph.TextContent.Add(new SimpleText(document, "Cell text"));
                cell.Content.Add(paragraph);
            }
        }
        //Merge some cells. Notice this is only available in text documents!
        table.RowCollection[1].MergeCells(document, 1, 2, true);
        //Add table to the document
        document.Content.Add(table);
        //Save the document
        document.SaveTo("example6_simpleTableWithMergedCells.odt");
    }

 public void Howto_special_charInch()
 {
     TextDocument document		= new TextDocument();
     document.Load(@"F:\odtFiles\Howto_special_char.odt");
     document.SaveTo(@"F:\odtFiles\Howto_special_char.html");
     document.Dispose();
 }

 void Example3()
 {
     string imagePath = @"Assets\ODFSample\Examples\example3.png";
     TextDocument document = new TextDocument();
     document.New();
     //Create standard paragraph
     Paragraph paragraphOuter = ParagraphBuilder.CreateStandardTextParagraph(document);
     //Create the frame with graphic
     Frame frame = new Frame(document, "frame1", "graphic1", imagePath);
     //Create a Draw Area Rectangle
     DrawAreaRectangle drawAreaRec = new DrawAreaRectangle(
         document, "0cm", "0cm", "1.5cm", "2.5cm", null);
     drawAreaRec.Href = "http://OpenDocument4all.com";
     //Create a Draw Area Circle
     DrawAreaCircle drawAreaCircle = new DrawAreaCircle(
         document, "4cm", "4cm", "1.5cm", null);
     drawAreaCircle.Href = "http://AODL.OpenDocument4all.com";
     DrawArea[] drawArea = new DrawArea[2] { drawAreaRec, drawAreaCircle };
     //Create a Image Map
     ImageMap imageMap = new ImageMap(document, drawArea);
     //Add Image Map to the frame
     frame.Content.Add(imageMap);
     //Add frame to paragraph
     paragraphOuter.Content.Add(frame);
     //Add paragraph to document
     document.Content.Add(paragraphOuter);
     //Save the document
     document.SaveTo(@"example3_simpleImageMap.odt");
 }

		public void ParagraphAddRemoveTest()
		{
			TextDocument td = new TextDocument();
			td.New();
			Paragraph p = new Paragraph(td, "P1");
			Assert.IsNotNull(p.Style, "Style object must exist!");
			Assert.AreEqual(p.Style.GetType().Name, "ParagraphStyle", "IStyle object must be type of ParagraphStyle");
			Assert.IsNotNull(((ParagraphStyle)p.Style).Properties, "Properties object must exist!");
			//add text
			p.TextContent.Add(new SimpleText(p, "Hello"));
			IText itext		= p.TextContent[0];
			p.TextContent.Remove(itext);
			//Console.Write(p.Node.Value);
			Assert.IsTrue(p.Node.InnerXml.IndexOf("Hello") == -1, "Must be removed!");
			//Add the Paragraph
			td.Content.Add((IContent)p);
			//Blank para
			td.Content.Add(new Paragraph(td, ParentStyles.Standard.ToString()));
			// new para
			p = new Paragraph(td, "P2");
			p.TextContent.Add(new SimpleText(p, "Hello i'm still here"));
			td.Content.Add(p);
			td.SaveTo("pararemoved.odt");
			//Console.WriteLine("Document: {0}", td.XmlDoc.OuterXml);
		}

 public void Howto_special_char()
 {
     TextDocument document		= new TextDocument();
     document.Load("Howto_special_char.odt");
     document.SaveTo("Howto_special_char.html");
     document.Dispose();
 }

		public void NewTextDocument()
		{
			TextDocument td = new TextDocument();
			td.New();
			Assert.IsNotNull(td.XmlDoc, "Must exist!");
			//Console.WriteLine("Doc: {0}", td.XmlDoc.OuterXml);
		}

    void Example10()
    {
        //some text e.g read from a TextBox
        string someText = "Max Mustermann\nMustermann Str. 300\n22222 Hamburg\n\n\n\n"
                                + "Heinz Willi\nDorfstr. 1\n22225 Hamburg\n\n\n\n"
                                + "Offer for 200 Intel Pentium 4 CPU's\n\n\n\n"
                                + "Dear Mr. Willi,\n\n\n\n"
                                + "thank you for your request. \tWe can "
                                + "offer you the 200 Intel Pentium IV 3 Ghz CPU's for a price of "
                                + "79,80 € per unit."
                                + "This special offer is valid to 31.10.2005. If you accept, we "
                                + "can deliver within 24 hours.\n\n\n\n"
                                + "Best regards \nMax Mustermann";

        //Create new TextDocument
        TextDocument document = new TextDocument();
        document.New();
        //Use the ParagraphBuilder to split the string into ParagraphCollection
        ParagraphCollection pCollection = ParagraphBuilder.CreateParagraphCollection(
                                             document,
                                             someText,
                                             true,
                                             ParagraphBuilder.ParagraphSeperator);
        //Add the paragraph collection
        foreach (Paragraph paragraph in pCollection)
            document.Content.Add(paragraph);
        //save
        document.SaveTo("example10_Letter.odt");
    }

 void Example4()
 {
     string imagePath = @"Assets\ODFSample\Examples\example3.png";
     TextDocument textdocument = new TextDocument();
     textdocument.New();
     Paragraph pOuter = ParagraphBuilder.CreateStandardTextParagraph(textdocument);
     DrawTextBox drawTextBox = new DrawTextBox(textdocument);
     Frame frameTextBox = new Frame(textdocument, "fr_txt_box");
     frameTextBox.DrawName = "fr_txt_box";
     frameTextBox.ZIndex = "0";
     Paragraph p = ParagraphBuilder.CreateStandardTextParagraph(textdocument);
     p.StyleName = "Illustration";
     Frame frame = new Frame(textdocument, "frame1", "graphic1", imagePath);
     frame.ZIndex = "1";
     p.Content.Add(frame);
     p.TextContent.Add(new SimpleText(textdocument, "Illustration"));
     drawTextBox.Content.Add(p);
     frameTextBox.SvgWidth = frame.SvgWidth;
     drawTextBox.MinWidth = frame.SvgWidth;
     drawTextBox.MinHeight = frame.SvgHeight;
     frameTextBox.Content.Add(drawTextBox);
     pOuter.Content.Add(frameTextBox);
     textdocument.Content.Add(pOuter);
     textdocument.SaveTo("example4_drawTextbox.odt");
 }

        public void CellParagraphTest()
        {
            TextDocument doc		= new TextDocument();
            doc.New();

            Table table				= new Table(doc, "table1");
            table.Init(5, 3, 16.99);

            foreach(Row r in table.Rows)
                foreach(Cell c in r.Cells)
                    c.InsertText("Hello");

            Paragraph p				= new Paragraph(doc, "P1");

            FormatedText ft			= new FormatedText(p, "T1", "Hello World");

            ((TextStyle)ft.Style).Properties.Italic = "italic";

            p.TextContent.Add(ft);

            table.Rows[0].Cells[0].Content.Add(p);

            doc.Content.Add(table);

            doc.SaveTo("tablewithstyles.odt");
        }

        public void CellSpanTest()
        {
            TextDocument doc		= new TextDocument();
            doc.New();

            Table table				= new Table(doc, "table1");
            table.Init(5, 2, 16.99);

            //Create a new row within this table and
            //set the cellspan to 2
            Row row					= new Row(table, "");
            //Create a real cell
            Cell cell				= new Cell(row, "table1.ZZ1");
            //Set cell span
            cell.ColumnRepeating	= "2";
            //Set the border
            ((CellStyle)cell.Style).CellProperties.Border	= Border.NormalSolid;
            //add some content to this cell
            cell.Content.Add(new Paragraph(doc,
                ParentStyles.Standard,
                "Hello I'm merged over two cells!"));
            //add cell to the row
            row.Cells.Add(cell);
            //we have to add one CellSpan object, because the
            //table has original 2 columns
            row.CellSpans.Add(new CellSpan(row));
            //at least at this row the table
            table.Rows.Add(row);
            //add the table to the document
            doc.Content.Add(table);
            //save it to the disk
            doc.SaveTo("tablecellspan.odt");
        }

 private static void ExtractRemainingSelection(TextDocument ActiveDoc, SourceRange SelectRange)
 {
     // Extract Remaining Selection
     CodeRush.Selection.SelectRange(SelectRange);
     ExecuteRefactoring("Extract Method");
     ActiveDoc.ParseIfTextChanged();
 }

        private async void UploadDocumentTextToHastebin(TextDocument document)
        {
            var textToUpload = textSelector.GetDocumentSelection(document);

            var textWithExcessTabsRemoved = ExcessTabRemover.RemoveExcessTabs(textToUpload, document.TabSize);

            var urlExtension = new LanguageUrlExtensionProvider(document).Extension;

            using (var request = new HasteRequest(url))
            {
                try
                {
                    var response = await request.PostAsync(textWithExcessTabsRemoved);

                    var fullUrl = response.GetUrl(url, urlExtension);

                    ClipboardCommunicator.AddToClipboard(fullUrl);

                    SetStatusBarText($"Code URL copied to clipboard: {fullUrl}");
                }
                catch (HttpRequestException)
                {
                    SetStatusBarText("An error occurred trying to post to hastebin");
                }
            }
        }

        /// <summary>
        /// Run the visual studio built-in remove unused using statements command.
        /// </summary>
        /// <param name="textDocument">The text document to update.</param>
        public void RemoveUnusedUsingStatements(TextDocument textDocument)
        {
            if (!Settings.Default.Cleaning_RunVisualStudioRemoveUnusedUsingStatements) return;
            if (_package.IsAutoSaveContext && Settings.Default.Cleaning_SkipRemoveUnusedUsingStatementsDuringAutoCleanupOnSave) return;

            // Capture all existing using statements that should be re-inserted if removed.
            const string patternFormat = @"^[ \t]*{0}[ \t]*\r?\n";

            var points = (from usingStatement in _usingStatementsToReinsertWhenRemoved.Value
                          from editPoint in TextDocumentHelper.FindMatches(textDocument, string.Format(patternFormat, usingStatement))
                          select new { editPoint, text = editPoint.GetLine() }).Reverse().ToList();

            // Shift every captured point one character to the right so they will auto-advance
            // during new insertions at the start of the line.
            foreach (var point in points)
            {
                point.editPoint.CharRight();
            }

            _package.IDE.ExecuteCommand("Edit.RemoveUnusedUsings", string.Empty);

            // Check each using statement point and re-insert it if removed.
            foreach (var point in points)
            {
                string text = point.editPoint.GetLine();
                if (text != point.text)
                {
                    point.editPoint.StartOfLine();
                    point.editPoint.Insert(point.text);
                    point.editPoint.Insert(Environment.NewLine);
                }
            }
        }

        /// <summary>
        /// Run the visual studio built-in remove unused using statements command.
        /// </summary>
        /// <param name="textDocument">The text document to update.</param>
        /// <param name="isAutoSave">A flag indicating if occurring due to auto-save.</param>
        public void RemoveUnusedUsingStatements(TextDocument textDocument, bool isAutoSave)
        {
            if (!Settings.Default.Cleaning_RunVisualStudioRemoveUnusedUsingStatements) return;
            if (isAutoSave && Settings.Default.Cleaning_SkipRemoveUnusedUsingStatementsDuringAutoCleanupOnSave) return;

            // Capture all existing using statements that should be re-inserted if removed.
            string patternFormat = _package.UsePOSIXRegEx
                                       ? @"^:b*{0}:b*\n"
                                       : @"^[ \t]*{0}[ \t]*\r?\n";

            var points = (from usingStatement in _usingStatementsToReinsertWhenRemoved.Value
                          from editPoint in TextDocumentHelper.FindMatches(textDocument, string.Format(patternFormat, usingStatement))
                          select new { editPoint, text = editPoint.GetLine() }).Reverse().ToList();

            _package.IDE.ExecuteCommand("Edit.RemoveUnusedUsings", String.Empty);

            // Check each using statement point and re-insert it if removed.
            foreach (var point in points)
            {
                string text = point.editPoint.GetLine();
                if (text != point.text)
                {
                    point.editPoint.StartOfLine();
                    point.editPoint.Insert(point.text);
                    point.editPoint.Insert(Environment.NewLine);
                }
            }
        }

		/// <summary>
		/// Breaks the lines into words in the form of a list of <see cref="TextSegment">TextSegments</see>. A 'word' is defined as an identifier (a series of letters, digits or underscores)
		/// or a single non-identifier character (including white space characters)
		/// </summary>
		/// <returns>
		/// The list of segments representing the 'words' in the lines
		/// </returns>
		/// <param name='document'>
		/// The document to get the words from
		/// </param>
		/// <param name='startLine'>
		/// The first line in the documents to get the words from
		/// </param>
		/// <param name='lineCount'>
		/// The number of lines to get words from
		/// </param>
		public static List<TextSegment> BreakLinesIntoWords (TextDocument document, int startLine, int lineCount, bool includeDelimiter = true)
		{
			var result = new List<TextSegment> ();
			for (int line = startLine; line < startLine + lineCount; line++) {
				var lineSegment = document.GetLine (line);
				int offset = lineSegment.Offset;
				bool wasIdentifierPart = false;
				int lastWordEnd = 0;
				for (int i = 0; i < lineSegment.Length; i++) {
					char ch = document.GetCharAt (offset + i);
					bool isIdentifierPart = char.IsLetterOrDigit (ch) || ch == '_';
					if (!isIdentifierPart) {
						if (wasIdentifierPart) {
							result.Add (new TextSegment (offset + lastWordEnd, i - lastWordEnd));
						}
						result.Add (new TextSegment (offset + i, 1));
						lastWordEnd = i + 1;
					}
					wasIdentifierPart = isIdentifierPart;
				}
				
				if (lastWordEnd != lineSegment.Length) {
					result.Add (new TextSegment (offset + lastWordEnd, lineSegment.Length - lastWordEnd));
				}
				if (includeDelimiter && lineSegment.DelimiterLength > 0)
					result.Add (new TextSegment (lineSegment.Offset + lineSegment.Length, lineSegment.DelimiterLength));
			}
			
			return result;
		}

        /// <summary>
        /// Removes blank lines from the top of the specified text document.
        /// </summary>
        /// <param name="textDocument">The text document to cleanup.</param>
        internal void RemoveBlankLinesAtTop(TextDocument textDocument)
        {
            if (!Settings.Default.Cleaning_RemoveBlankLinesAtTop) return;

            EditPoint cursor = textDocument.StartPoint.CreateEditPoint();
            cursor.DeleteWhitespace(vsWhitespaceOptions.vsWhitespaceOptionsVertical);
        }