Wpf работа с word

Довольно часто в разработке приложений для работы с документами возникает необходимость отобразить эти самые документы не переключаясь из приложения. В подавляющем большинстве этими документами являются текстовые документы MS Word и электронные таблицы MS Excel. К сожалению мне не удалось найти каких-либо достойных контролов для их отображения в свободном доступе, так что было решено встроить сам офис в приложение, благо он установлен практически на каждом компьютере. В этой и следующей статье посмотрим как это можно сделать.

Начнём с создания юзерконтрола, отображающего документы Word.

Задача следующая: открывать документ внутри нашего приложения только для чтения без возможности отредактировать или пересохранить документ, меню и панели ворда спрятать.

Структура контрола будет такая: WPF-UserControl => WindowsFormsHost => WindowsForms-UserControl => Panel => Word app

Для работы нам понадобится подключить две библиотеки:

Microsoft.Office.Interop.Word
Office

WindowsForms UserControl

Для работы понадобится несколько WinApi функций:

#region Изменить родителя окна
[DllImport("user32.dll")]
private static extern IntPtr SetParent(IntPtr hWndChild, IntPtr hWndNewParent);
#endregion
 
#region Перемещение окна
[DllImport("user32.dll", SetLastError = true)]
public static extern bool MoveWindow(IntPtr hWnd, int X, int Y, int nWidth, int nHeight, bool bRepaint);
#endregion
 
#region Развернуть окно на весь экран
private const int SW_SHOWMAXIMIZED = 3;
[DllImport("user32.dll")]
private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
#endregion
 
#region Спрятать заголовок окна
const int WS_BORDER = 8388608;
const int WS_DLGFRAME = 4194304;
const int WS_CAPTION = WS_BORDER | WS_DLGFRAME;
const int WS_SYSMENU = 524288;
const int WS_THICKFRAME = 262144;
const int WS_MINIMIZE = 536870912;
const int WS_MAXIMIZEBOX = 65536;
const int GWL_STYLE = -16;
const int GWL_EXSTYLE = -20;
const int WS_EX_DLGMODALFRAME = 0x00000001;
const int SWP_NOMOVE = 0x2;
const int SWP_NOSIZE = 0x1;
const int SWP_FRAMECHANGED = 0x20;
const uint MF_BYPOSITION = 0x400;
const uint MF_REMOVE = 0x1000;
 
[DllImport("user32.dll")]
public static extern int GetWindowLong(IntPtr hWnd, int nIndex);
 
[DllImport("user32.dll")]
public static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);
 
[DllImport("user32.dll")]
public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, int uFlags);
 
public void MakeExternalWindowBorderless(IntPtr MainWindowHandle)
{
    int Style = 0;
    Style = GetWindowLong(MainWindowHandle, GWL_STYLE);
    Style = Style & Not(WS_CAPTION);
    Style = Style & Not(WS_SYSMENU);
    Style = Style & Not(WS_THICKFRAME);
    Style = Style & Not(WS_MINIMIZE);
    Style = Style & Not(WS_MAXIMIZEBOX);
    SetWindowLong(MainWindowHandle, GWL_STYLE, Style);
    Style = GetWindowLong(MainWindowHandle, GWL_EXSTYLE);
    SetWindowLong(MainWindowHandle, GWL_EXSTYLE, Style | WS_EX_DLGMODALFRAME);
    //SetWindowPos(MainWindowHandle, new IntPtr(0), 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_FRAMECHANGED);
}
#endregion
 
#region Спрятать меню окна
[DllImport("user32.dll")]
private static extern IntPtr GetMenu(IntPtr hWnd);
 
[DllImport("user32.dll")]
private static extern int GetMenuItemCount(IntPtr hMenu);
 
[DllImport("user32.dll")]
private static extern bool DrawMenuBar(IntPtr hWnd);
 
[DllImport("user32.dll")]
private static extern bool RemoveMenu(IntPtr hMenu, uint uPosition, uint uFlags);
 
public void WindowsReStyle(IntPtr MainWindowHandle)
{
    int style = GetWindowLong(MainWindowHandle, GWL_STYLE);
    IntPtr HMENU = GetMenu(MainWindowHandle);
    int count = GetMenuItemCount(HMENU);
 
    if (count > 0)
    {
        for (int i = count; i >= 0; i += -1)
        {
            uint menuToRemove = Convert.ToUInt32(i);
 
            RemoveMenu(HMENU, menuToRemove, (MF_BYPOSITION | MF_REMOVE));
        }
 
        DrawMenuBar(MainWindowHandle);
    }
}
#endregion

Переменные контрола

private Process process;
private Word.Application word;
private Word.Document document;
private List<string> hiddenBars;
private int originalWordWindowWidth;
private int originalWordWindowHeight;
private int originalWordWindowLeft;
private int originalWordWindowTop;

Методы открытия/закрытия Word

/// <summary>
/// Запустить Word
/// </summary>
private void StartWord()
{
    this.word = new Word.Application();
    this.word.Application.Caption = "WORD VIEWER";
 
    this.originalWordWindowWidth = this.word.Width;
    this.originalWordWindowHeight = this.word.Height;
    this.originalWordWindowLeft = this.word.Left;
    this.originalWordWindowTop = this.word.Top;
 
    this.word.Width = 0;
    this.word.Height = 0;
    this.word.Left = -100;
    this.word.Top = -100;
 
    this.word.Visible = true;
    this.word.CommandBars.ActiveMenuBar.Enabled = false;
 
    foreach (Process proc in Process.GetProcessesByName("winword"))
        if (proc.MainWindowTitle == "WORD VIEWER")
            this.process = proc;
 
    SetParent(this.process.MainWindowHandle, this.wordContainer.Handle);
    ShowWindow(this.process.MainWindowHandle, SW_SHOWMAXIMIZED);
    MakeExternalWindowBorderless(this.process.MainWindowHandle);
    WindowsReStyle(this.process.MainWindowHandle);
    MoveWindow(this.process.MainWindowHandle, -3, -3, this.wordContainer.Width + 6, this.wordContainer.Height + 6, true);
}
 
/// <summary>
/// Закрыть Word
/// </summary>
private void CloseWord()
{
    if ((this.word != null))
    {
        if (this.word.Documents.Count > 0)
            this.document.Close(SaveChanges: false);
 
        this.word.CommandBars.ActiveMenuBar.Enabled = true;
 
        foreach (string cb in this.hiddenBars)
            this.word.CommandBars[cb].Visible = true;
 
        this.word.Width = this.originalWordWindowWidth;
        this.word.Height = this.originalWordWindowHeight;
        this.word.Left = this.originalWordWindowLeft;
        this.word.Top = this.originalWordWindowTop;
 
        this.word.Quit(SaveChanges: false);
 
        GC.Collect();
        GC.WaitForPendingFinalizers();
 
        Marshal.ReleaseComObject(this.document);
        Marshal.ReleaseComObject(this.word);
    }
}

Методы открытия/закрытия документа

/// <summary>
/// Открыть документ
/// </summary>
/// <param name="path">Путь к документу</param>
public void OpenWordDocument(string path)
{
    if (this.word == null)
        this.StartWord();
 
    foreach (Microsoft.Office.Core.CommandBar cb in this.word.CommandBars)
    {
        if (cb.Visible)
        {
            try
            {
                if (!this.hiddenBars.Contains(cb.Name))
                    this.hiddenBars.Add(cb.Name);
 
                cb.Visible = false;
            }
            catch { }
        }
    }
 
    if (this.word.Documents.Count > 0)
        this.document.Close(SaveChanges: false);
 
    this.document = this.word.Documents.Open(FileName: path, ReadOnly: true);
}
 
/// <summary>
/// Закрывает текущую таблицу
/// </summary>
public void CloseWordDocument()
{
    if (this.word != null && this.word.Documents.Count > 0)
        this.document.Close(SaveChanges: false);
}

Подцепимся к нескольким событиям для изменения размера word’а / корректного закрытия приложения

/// <summary>
/// При изменении размеров родительского контейнера
/// </summary>
void OnContainerResize(object sender, EventArgs e)
{
    Panel container = sender as Panel;
 
    if (container == null)
        return;
 
    if ((this.process != null))
    {
        MakeExternalWindowBorderless(this.process.MainWindowHandle);
        WindowsReStyle(this.process.MainWindowHandle);
        MoveWindow(this.process.MainWindowHandle, -3, -3, container.Width + 6, container.Height + 6, true);
    }
}
 
/// <summary>
/// При закрытии приложения
/// </summary>
void OnMainWindowClosing(object sender, System.ComponentModel.CancelEventArgs e)
{
    this.CloseWord();
}
 
/// <summary>
/// При краше приложения
/// </summary>
void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)
{
    this.CloseWord();
}

WPF UserControl

XAML контрола будет содержать лишь одну строку:

<WindowsFormsHost x:Name="wordHost" />

При загрузке WPF-контрола добавляем в WindowFormsHost WindowsForms-контрол

private WordWindowsForms control;
 
private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
    this.control = new WordWindowsForms();
 
    this.wordHost.Child = this.control;
}

Dependency Property чтоб можно было биндить путь к файлу

/// <summary>
/// Путь к файлу
/// </summary>
public string File
{
    get { return (string)this.GetValue(FileProperty); }
    set { this.SetValue(FileProperty, value); }
}
 
public static readonly DependencyProperty FileProperty = DependencyProperty.Register("File", typeof(string), typeof(Word), new PropertyMetadata(null, OnFilePropertyChanged));
 
public static void OnFilePropertyChanged(object sender, DependencyPropertyChangedEventArgs e)
{
    Word ech = sender as Word;
 
    if (ech == null || ech.control == null)
        return;
 
    if (string.IsNullOrWhiteSpace((string)e.NewValue))
        ech.control.CloseWordDocument();
    else
        ech.control.OpenWordDocument((string)e.NewValue);
}

This article is going to introduce how to create, write and save word document in WPF via Spire.Doc for WPF.

Spire.Doc for WPF enables users to do a large range of manipulations (such as create, write, open, edit, convert and save, etc.) on word with high performance and efficiency. In addition, as a powerful and independent library, it doesn’t require Microsoft Office or any other 3rd party tools to be installed on system.

Note: please download and install Spire.Doc correctly and add the dll file from the installation folder as reference.

First, let’s begin to create a word document in WPF.

Use namespace:

using System.Windows;
using Spire.Doc;
using Spire.Doc.Documents;

Step 1: Create a new word document instance, next add a section and a paragraph to it.

//Create New Word
Document doc = new Document();
//Add Section
Section section = doc.AddSection();
//Add Paragraph
Paragraph Para = section.AddParagraph();

Second, we’re going to write something into the document.

Step 2: Append some text to it.

//Append Text
Para.AppendText("Hello! "
+ "I was created by Spire.Doc for WPF, it's a professional .NET Word component "
+ "which enables developers to perform a large range of tasks on Word document (such as create, open, write, edit, save and convert "
+ "Word document) without installing Microsoft Office and any other third-party tools on system.");

Third, save the generated document.

Step 3: Save and launch the document.

//Save and launch
doc.SaveToFile("MyWord.docx", FileFormat.Docx);
System.Diagnostics.Process.Start("MyWord.docx");

Output:

Full codes:

using Spire.Doc;
using Spire.Doc.Documents;
using System.Windows;

namespace WpfApplication1
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
        private void button1_Click(object sender, RoutedEventArgs e)
        {
            //Create New Word
            Document doc = new Document();
            //Add Section
            Section section = doc.AddSection();
            //Add Paragraph
            Paragraph Para = section.AddParagraph();
            //Append Text
            Para.AppendText("Hello! "
            + "I was created by Spire.Doc for WPF, it's a professional .NET Word component "
            + "which enables developers to perform a large range of tasks on Word document (such as create, open, write, edit, save and convert "
            + "Word document) without installing Microsoft Office and any other third-party tools on system.");
            //Save and launch
            doc.SaveToFile("MyWord.docx", Spire.Doc.FileFormat.Docx);
            System.Diagnostics.Process.Start("MyWord.docx");
        }

    }
}

Introduction

​Microsoft Office Documents like Word , Excel, PowerPoint are very difficult to View in WPF. I have seen a lot of posts related to viewing office files in forums. So to be straight forward there is no direct method to view office
documents in WPF. Office files should be converted to a suitable format so that it could be viewed in WPF. Here are the steps to view an office Document in WPF

Steps

1.) Create a WPF 4.0 Application and Place a Document Viewer.

2.) Add the Following Com Components in your References

• Microsoft Word 14.0 Object Library
• Microsoft Excel 14.0 Object Library
• Microsoft PowerPoint 14.0 Object Library

Ensure that you are having version 12.0 or Above. Which means Microsoft word 2007 or higher versions.

3.) The next step is to convert the Office Documents into a suitable format which are XPS Documents. Before that add the following dll to your Reference

• ReachFramework.dll 

4.) To convert the Office Documents to XPS Documents. Attach the OfficetoXps.cs class file to your project. You can download the class files and the whole project from my skydrive.

5.) Next step is to invoke the class and convert the office files to XPS and View in the Document Viewer. Using the code Below.

Download the Project from My Skydrive:
https://skydrive.live.com/?cid=841ACEE3077E04E5&id=841ACEE3077E04E5%21138

• Download source code — 213.2 KB

Table of Contents

• Introduction
• DOCX Overview
• Implementation
  • DocxReader
  • DocxToFlowDocumentConverter
• Using the Code
• Conclusion

Introduction

Word 2007 documents are Office Open XML Documents, a combination of XML architecture and ZIP compression used to store an XML and non-XML files together within a single ZIP archive. These documents usually have DOCX extension, but there are exceptions for macro enabled documents, templates etc.

This article will show how you can read and view a DOCX file in WPF with the use of only .NET Framework 3.0 (without using any 3^rd party code).

DOCX Overview

A DOCX file is actually a zipped group of files and folders, called a package. Package consists of package parts (files that contain any type of data like text, images, binary, etc.) and relationships files. Package parts have a unique URI name and relationships XML files contain these URIs.

When you open the DOCX file with a zipping application, you can see the document structure and its package’s parts.

DOCX main content is stored in the package part document.xml, which is often located in word directory, but it does not have to be. To find out URI (location) of document.xml, we should read a relationships XML file inside the _rels directory and look for a relationship type http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument.

Document.xml file contains XML elements defined primarily in WordprocessingML XML namespace of Office Open XML specification. The basic structure of document.xml consists of a document (<document>) element which contains a body (<body>) element. Body element consists of one or more block level elements such as paragraph (<p>) elements. A paragraph contains one or more inline level elements such as run (<r>) elements. A run element contains one or more document’s text content elements such as text (<t>), page break (<br>) and tab (<tab>) elements.

Implementation

In short, to retrieve and display a DOCX text content, application will use two classes: DocxReader and its subclass DocxToFlowDocumentConverter.

DocxReader will unzip the file with the help of System.IO.Packaging namespace, find the document.xml file through the relationship and read it with XmlReader.

DocxToFlowDocumentConverter will convert the XML elements from XmlReader into a corresponding WPF’s FlowDocument elements.

DocxReader

DocxReader constructor first opens (unzips) the package from the DOCX file stream and retrieves the mainDocumentPart (document.xml) with the help of its PackageRelationship.

protected const string MainDocumentRelationshipType = 
   "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
private readonly Package package;
private readonly PackagePart mainDocumentPart;
 
public DocxReader(Stream stream)
{
    if (stream == null)
        throw new ArgumentNullException("stream");
 
    this.package = Package.Open(stream, FileMode.Open, FileAccess.Read);
 
    foreach (var relationship in 
       this.package.GetRelationshipsByType(MainDocumentRelationshipType))
    {
        this.mainDocumentPart = 
          package.GetPart(PackUriHelper.CreatePartUri(relationship.TargetUri));
        break;
    }
}

After retrieving the document.xml PackagePart, we can read it with .NET’s XmlReader class, a fast forward-only XML reader which has the same path trajectory as depth-first traversal algorithm in tree data structure.

First path, 1 to 4, shows the simplest path in retrieving a text from the paragraph element. The second path, 5 — …, shows a more complex paragraph content. In this path, we will also read paragraph properties (<pPr>) and run properties (<rPr>) which contain various formatting options.

We create a series of reading methods for every element we wish to support in this path trajectory.

protected virtual void ReadDocument(XmlReader reader)
{
    while (reader.Read())
        if (reader.NodeType == XmlNodeType.Element && reader.NamespaceURI == 
          WordprocessingMLNamespace && reader.LocalName == BodyElement)
        {
            ReadXmlSubtree(reader, this.ReadBody);
            break;
        }
}
 
private void ReadBody(XmlReader reader) {...}
private void ReadBlockLevelElement(XmlReader reader) {...}
protected virtual void ReadParagraph(XmlReader reader) {...}
private void ReadInlineLevelElement(XmlReader reader) {...}
protected virtual void ReadRun(XmlReader reader) {...}
private void ReadRunContentElement(XmlReader reader) {...}
protected virtual void ReadText(XmlReader reader) {...} 

To point out a few things you will notice in DocxReader reading methods:

• We use XmlNameTable to store XML namespace, element and attribute names. This provides us with a better looking code but we also get better performance because now we can do an object (reference) comparisons on these strings rather than a more expensive string (value) comparison since XmlReader will use atomized strings from XmlNameTable for its LocalName and NamespaceURI properties and because .NET uses string interning and cleverly implements string equality by first doing reference equality and then value equality.
• We use XmlReader.ReadSubtree method while passing the XmlReader into a specific DocxReader reading method to create a boundary around that XML element. DocxReader reading methods will now have access to only that specific XML element, rather than to the entire document.xml. Using this method has some performance penalty which we traded for more secure and intuitive code.

private static void ReadXmlSubtree(XmlReader reader, Action<XmlReader> action)
{
    using (var subtreeReader = reader.ReadSubtree())
    {
        
        subtreeReader.Read();

        if (action != null)
           action(subtreeReader);
    }
}  

DocxToFlowDocumentConverter

This class inherits from the DocxReader and it overrides some of the reading methods of DocxReader to create a corresponding WPF’s FlowDocument element.

So, for example, while reading document element, we will create a new FlowDocument, while reading paragraph element we will create a new Paragraph element and while reading run element we will create a new Span element.

protected override void ReadDocument(XmlReader reader)
{
    this.document = new FlowDocument();
    this.document.BeginInit();
    base.ReadDocument(reader);
    this.document.EndInit();
}
 
protected override void ReadParagraph(XmlReader reader)
{
    using (this.SetCurrent(new Paragraph()))
        base.ReadParagraph(reader);
}
 
protected override void ReadRun(XmlReader reader)
{
    using (this.SetCurrent(new Span()))
        base.ReadRun(reader);
}

Also, this class implements setting some Paragraph and Span properties which are read from paragraph property element <pPr> and run property element <rPr>. While XmlReader is reading these property elements we have already created a new Paragraph or Span element and now we need to set their properties.

Because we are moving from the parent element (Paragraph) to child elements (Spans) and back to a parent, we will have to track our current element in the FlowDocument with a variable of type TextElement (an abstract base class for Paragraph and Span).

This is accomplished with a help of CurrentHandle and C# using statement syntactic sugar for try-finally construct. With a SetCurrent method we set a current TextElement and with a Dispose method will retrieve our previous TextElement and set it as the current TextElement.

private struct CurrentHandle : IDisposable
{
    private readonly DocxToFlowDocumentConverter converter;
    private readonly TextElement previous;
 
    public CurrentHandle(DocxToFlowDocumentConverter converter, TextElement current)
    {
        this.converter = converter;
        this.converter.AddChild(current);
        this.previous = this.converter.current;
        this.converter.current = current;
    }
 
    public void Dispose()
    {
        this.converter.current = this.previous;
    }
}

private IDisposable SetCurrent(TextElement current)
{
    return new CurrentHandle(this, current);
}

Using the Code

To get a FlowDocument all we need is to create a new DocxToFlowDocumentConverter instance from a DOCX file stream and call Read method on that instance.

After that, we can display the flow document content in WPF application using the FlowDocumentReader control.

using (var stream = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
    var flowDocumentConverter = new DocxToFlowDocumentConverter(stream);
    flowDocumentConverter.Read();
    this.flowDocumentReader.Document = flowDocumentConverter.Document;
    this.Title = Path.GetFileName(path);
}

Conclusion

DOCX Reader is not a complete solution and is intended to be used for simple scenarios (without tables, lists, pictures, headers/footers, styles, etc.). This application can be enhanced to read more DOCX features, but to get a full DOCX support with all advanced features would require a lot more time and knowledge of DOCX file format. Hopefully, this article and accompanying application has shown you some insights into DOCX file format and might provide a basis for doing more complex DOCX related applications.