Sentient thoughts about .NET : Word

Inserting Pictures using WordML

jonathangreensted — Tue, 11 Jan 2005 23:39:00 GMT

I've seen many, many requests on the Microsoft newsgroups asking how you can insert a picture into a Word document without saving it to the file system first.

This example application described in this blog illustrates both methods for inserting a picture firstly using the Word object model (InlineShapes.AddPicture) and secondly using Word's XML support (InsertXML).

The Word object model code is very straight forward:

private
					void
					buttonInsertNormal_Click(object
					sender, System.EventArgs e)
{
 
					object
					oMissing = Type.Missing;
 
					object
					oCollapseEnd = Word.WdCollapseDirection.wdCollapseEnd;
  _wordApp.ActiveDocument.Content.Collapse(ref
					oCollapseEnd);
 
 
					string
					filename = @"c:\temp\WordMLImage.bmp";
 
 
					try
  {
    pictureBox1.Image.Save(filename);
    
					_wordApp.ActiveWindow.Selection.Range.InlineShapes.AddPicture(filename,
				
     
					ref
					oMissing,
					ref
					oMissing,
					ref
					oMissing);
  }
 
					finally
  {
    File.Delete(filename);
  }
}

The only problem with this code is the requirement to write the image to the file system so Word can reload it. There are many circumstances where you would prefer to avoid touching the file system or maybe your application does not have write permission.

Fortunately there is an alternative approach using Word's XML support. This approach requires us to constructing a WordML document fragment representing the image to be inserted and then calling Word's InsertXML function to place the image in the document.

The code to do this is as follows:

  private
				void
				buttonInsertWordML_Click(object
				sender, System.EventArgs e)
{
 
					object
					oMissing = Type.Missing;
 
					object
					oCollapseEnd = Word.WdCollapseDirection.wdCollapseEnd;
  _wordApp.ActiveDocument.Content.Collapse(ref
					oCollapseEnd);
 
 
					try
  {
    PictWriter pw =
					new
					PictWriter(pictureBox1.Image, "Example Image", "Example Image");
    
					_wordApp.ActiveWindow.Selection.Range.InsertXML(pw.ToString(),
					ref
					oMissing);   
				
  }
 
					catch
					(Exception ex)
  {
   
					// do 
something sensible here.
  }
}

You will notice the use of a custom class called Sentient.WordML.PictWriter which handles the task of converting the image into the WordML document fragment.

The complete class source is included in the zip download at the end of the article however the core elements are the following two methods.

WriteDoc handles writing the WordML document wrapper. InsertXML expects a complete WordML document including full namespace references and style definitions if you are using styles (we are not).

WritePict handles writing the actual image data into the XML stream as Base64.

///<summary>
/// Write the whole WordML document
///</summary>
///<param 
name="wtr">The XmlTextWriter to write 
to</param>
protected
					void
					WriteDoc(XmlTextWriter wtr)
{
 
					// start <xml> 
tag
  wtr.WriteStartDocument();
 
 
					// add processing 
instructions
  wtr.WriteProcessingInstruction("mso-application", 
					"progid=\"Word.Document\"");
 
 
					// start 
<wordDocument> tag  
  wtr.WriteStartElement("w", "wordDocument", WordMLNS);
 
 
					// write 
namespaces  
 
					foreach(string
					prefix
					in
					_namespaces.AllKeys)
  {
    wtr.WriteAttributeString("xmlns", prefix,
					null, _namespaces[prefix]);
  }
 
 
					// start <body> 
tag  
  wtr.WriteStartElement("body", WordMLNS);
 
 
					// call WritePict to 
add our image to the Xml stream.
  WritePict(wtr);
				
 
 
					// end <body> 
tag  
  wtr.WriteEndElement();
				
 
 
					// end 
<wordDocument> tag  
  wtr.WriteEndElement();
				
 
 
					// end <xml> 
tag
  wtr.WriteEndDocument();
}
 
///<summary>
/// Write the Pict WordML element
///</summary>
///<param 
name="wtr">The XmlTextWriter to write 
to</param>
protected
					void
					WritePict(XmlTextWriter wtr)
{
 
					if(_data==null)
  {
   
					return;
  }
 
 
					// start <pict> 
tag
  wtr.WriteStartElement("pict", WordMLNS);
 
 
					// start 
<binData> tag
  wtr.WriteStartElement("binData", WordMLNS);
  wtr.WriteAttributeString("name", WordMLNS,
					string.Format("wordml://{0}{1}", _name, 
					_extension));
 
 
					// write the image as 
Base64
  wtr.WriteBase64(_data, 0, _data.Length);
 
 
					// end 
<binData> tag
  wtr.WriteEndElement();
 
 
					// start 
<shape> tag which describes the shape containing the image
  wtr.WriteStartElement("shape", VMLNS);
  wtr.WriteAttributeString("id", "_x0000_" + _name);
  wtr.WriteAttributeString("style",
					string.Format("width:{0}px;height:{1}px", 
					_width, _height));
 
 
					// start 
<imagedata> tag which links to the <binData> above.
  wtr.WriteStartElement("imagedata", VMLNS);
  wtr.WriteAttributeString("src",
					string.Format("wordml://{0}{1}", _name, 
					_extension));
  wtr.WriteAttributeString("title", OfficeNS, _title);
 
 
					// end 
<imagedata> tag
  wtr.WriteEndElement();
 
 
					// end <shape> 
tag
  wtr.WriteEndElement();
 
 
					// end <pict> 
tag
  wtr.WriteEndElement();
}

As you can see the InsertXML approach requires a little more code however does achieve our objective of not touching the file system.

The only drawback I've found with the InsertXML approach is you dont get the image autosizing functionality which means if you want the image to be reduced or enlarged in size you'll have to do this yourself in code either by resizing the image before inserting it or using the Word object model to manipulate the InlineShape properties after it has been inserted.

A major bonus is that using InsertXML is considerably faster than writing the image to the file system and then calling InlineShape.Add so you get a considerable performance improvement especially if you are working with large images.

The source for this experimentation can be downloaded from the following page on the Sentient website:

http://www.sentient.co.uk/WordMLInsertPicture.aspx

If you know of a better way to do this please add a comment to this blog.

Finding word styles fast

jonathangreensted — Tue, 07 Dec 2004 15:13:00 GMT

In a recent project we had a scenario where we had to find all the paragraphs in a particular style eg. Heading 1, Heading 2, etc. to build a custom table of contents.

My initial thought was to iterate over the document paragraphs looking for the particular style we were interested in.

The code looked like this:

					 
private
					void
					FindStyleUsingParagraphIteration(Word.Document doc,
					string
					style)
{
   
					foreach
					(Word.Paragraph p
					in
					doc.Paragraphs)
    {
 
        Word.Style s = 
					(Word.Style)p.Range.get_Style();
 
       
					if
					(s.NameLocal == style)
        {
           
					string
					text = p.Range.Text;
 
           
					int
					page = (int) 
					p.Range.get_Information(Word.WdInformation.wdActiveEndPageNumber);
            
					Single vert = (Single) 
					p.Range.get_Information(Word.WdInformation.wdVerticalPositionRelativeToPage);
 
        
    Message +=   
					 
					string.Format("    
					    Style: {0}, text: {1}, page: {2}, vert: {3}",
            
					    s.NameLocal, p.Range.Text, page, vert.ToString());
        }
    }
}
 

This worked perfectly however it was a little slow so I looked for a better approach.

My second attempt was to use Word's built in Find functionality to find paragraphs in a particular style.

The code looked like this:

				 
private
				void
				FindStyleUsingFind(Word.Document doc,
				string
				style)
{
   
				object
				oMissing = Type.Missing;
   
				object oTrue =
				 
				true;
   
				object
				oStyle = style;
 
    Word.Range r = doc.Content;
 
   
				bool found =
				 
				true;
   
				while
				(found)
    {
       
				try
        {
            
				r.Find.ClearFormatting();
            
				r.Find.set_Style(ref
				oStyle);
            
				found = r.Find.Execute(ref
				oMissing,
				ref
				oMissing,
				ref
				oMissing,
				ref
				oMissing,
				ref
				oMissing,
				ref
				oMissing,
				ref
				oMissing,ref
				oMissing,
			
            
				   
				ref
				oTrue,
				ref
				oMissing,
				ref
				oMissing,
				ref
				oMissing,
				ref
				oMissing,
				ref
				oMissing,
				ref
				oMissing);
        }
       
				catch
        {
        
    found =   
				 
				false;
        }
       
				if
				(found)
        {
           
				string
				text = r.Text;
 
           
				int
				page = (int) 
				r.get_Information(Word.WdInformation.wdActiveEndPageNumber);
            
				Single vert = (Single) 
				r.get_Information(Word.WdInformation.wdVerticalPositionRelativeToPage);
 
        
    Message +=   
				 
				string.Format("    
				    Style: {0}, text: {1}, page: {2}, vert: {3}",
            
				    oStyle.ToString(), r.Text, page, vert.ToString());
        }
    }
			
}

The performance of this approach was much better however it resulted in the Word status bar flickering as it performed the Finds so I started looking for a third option.

My third attempt was to use Word's built in XML support and write an xpath against the WordML schema.

The code looks like this:

private void FindStyleUsingXPath(Word.Document doc, string style)
{
    try
    {
        string schema = 
"xmlns:w=\"http://schemas.microsoft.com/office/word/2003/wordml\"";
        string xPath = string.Format("//w:p[descendant::w:pStyle[@w:val='{0}']]/w:r/w:t", 
style);
        Word.XMLNodes nodes 
= doc.SelectNodes(xPath,schema,false);
 
        if (nodes != null)
        {
            
foreach (Word.XMLNode node in nodes)
            
{
            
    int page = (int) 
node.Range.get_Information(Word.WdInformation.wdActiveEndPageNumber);
            
    Single vPos = (Single) 
node.Range.get_Information(Word.WdInformation.wdVerticalPositionRelativeToPage);
            
    string text = 
node.Text;
 
            
    Message += string.Format("    
    Page (0), vert (1), (2)\n", page, vPos, text);
            
}
        }
    }
    catch(Exception ex)
    {
        Message += 
ex.Message;
    }
}

Sadly this is where it all went wrong. The code ran fine (without any exceptions being thrown) however it returned no results!

The first thing I noted was that it took longer to return no results than my Find attempt took to do the job properly so this isn't a good approach in terms of performance anyway however it was strange that it didn't return any results. After some investigate I found that the wordml namespace was not registered in the doc.XMLSchemaReferences collection so I thought that maybe I should add it manually using the following code:

object oNamespaceURI 
= "http://schemas.microsoft.com/office/word/2003/wordml";
object oAlias = 
"w";
object oFileLocation 
= @"C:\Program Files\Microsoft Office 2003 Developer Resources\Microsoft Office 
2003 XML Reference Schemas\WordprocessingML Schemas\w10.xsd";
 
string schema = string.Format("xmlns:{0}=\"{1}\"",oNamespaceURI, 
oAlias);
 
doc.XMLSchemaReferences.Add(ref oNamespaceURI, ref oAlias, ref oFileLocation, false);

Unfortunately this code generates the following exception "This schema cannot be used because it attempts to declare a namespace reserved by Word." so that isn't the answer.

Finally in frustration I emailed a buddy of mine on the Office team who confirmed definatively that SelectNodes(...) would only work custom schemas and not WordML. So there you have it, don't waste your time like me trying to do this until at least the next version. (I have submitted a feature request).

For those of you who are interested in the relative performance here are the stats for my test document:

      Using Paragraph iteration: 10.1445872 seconds
      Using Find: 1.9928656 seconds
      Using XPath: 4.9771568 seconds (failed)

My conclusion was to use the Find.Execute method and put up with the status bar flickering!

The source for this experimentation can be downloaded from the following page on the Sentient website:

http://www.sentient.co.uk/wordFindStyle.aspx

If you know of a better way to do this please add a comment to this blog.