Visual Studio Office Developer (VSOD) Support Team

How to loop through the app-domains in the current process

2009-11-30T20:38:53Z

Consider a scenario where we have a VSTO add-in and an automation add-in for Excel and we want to share some objects from the VSTO addin to the Automation add-in. Because the VSTO add-in is loaded in its own separate appdomain and the automation add-in is loaded in the different(default) appdomain, sharing objects is not that easy. One way to share objects could be to use "RequestCOMAutomationService" method as described in the following blog article:

http://blogs.msdn.com/andreww/archive/2008/08/11/why-your-comaddin-object-should-derive-from-standardolemarshalobject.aspx

However, by using the above mentioned method, the object would be shared "ByVal". What if we want to share the objects "ByRef"

One of the solution to share objects "ByRef" is to use appdomain's "CreateInstanceAndUnwrap" method to create objects and to get the proxy objects. However to use "CreateInstanceAndUnwrap" method we need reference to the appdomain in which the actual objects will be created.

In our scenario we need to have reference to the VSTO appdomain so that we can create objects in it and can obtain proxy objects in the automation appdomain.

Since VSTO appdomain is automatically created by VSTO runtime, we do not have reference to it. We need a way to loop through the appdomain present in the current process (Excel) and get a reference to the VSTO appdomain.

To find the VSTO Appdomain (in a collection of appdomains), we will use its name. To find the VSTO appdomain's name, in the VSTO add-in code, we can use following code:

AppDomain ad = System.Threading.Thread.GetDomain();
String VSTO_AppDomain_Name = ad.FriendlyName.ToString();

This VSTO appdomain name can be shared with the Automation add-in using the RequestCOMAutomationService technique mentioned above or by using any other way.

Although there is no managed API which enables us to loop through the appdomains, there is a way to loop through the app-domains in a process. The following code can be used to loop through the appdomains and to get reference to the VSTO appdomain:

using System.Runtime.InteropServices; 
using mscoree; 
AppDomain VSTOAppDomain = null; 

private void FindVSTOAppDomain(string VSTOAppDomainName) 
{ 
    IntPtr enumHandle = IntPtr.Zero; 
    CorRuntimeHostClass host = new mscoree.CorRuntimeHostClass(); 
    try 
    { 
        host.EnumDomains(out enumHandle); 
        object domain = null; 
        while (true) 
        { 
            host.NextDomain(enumHandle, out domain); 
            if (domain == null) break; 
            AppDomain ad = (AppDomain)domain; 
            if (ad.FriendlyName.Equals(VSTOAppDomainName)) 
            { 
                VSTOAppDomain = ad; 
            } 
        } 
    } 
    catch (Exception ex) 
    { 

    } 
}

To use above code we need to add COM reference to the mscoree.tlb to the project. mscoree.tlb can be located at:
"C:\WINDOWS\Microsoft.NET\Framework\vXXXXXX\mscoree.tlb".

For more information, please refer to: http://blogs.msdn.com/jackg/archive/2007/06/11/enumerating-appdomains.aspx

Excel: How do you use RefEdit/range selection control to select a cell range using .Net

2009-10-02T20:33:00Z

In Excel VBA, we could use RefEdit control on a user form for allowing users to select a cell range on worksheets. This control allows users to select a range easily just by dragging on Excel cells and it can be passed as an input (as range object) to the program. It is very beneficial for users while doing Excel programming using VBA, as user does not require typing the address of a range manually.

However, we cannot use this control in other than VBA userforms, because RefEdit is not really a true ActiveX control, it is a special in-process to Excel only control that directly integrates with VBA. As per the following article, the RefEdit Control is designed to work only when placed on a form in an Excel VBA project.

RefEdit control does not work on form in a Com Add-In in Excel

http://support.microsoft.com/?id=281542

As a workaround, some people develop their own user control to achieve this functionality in Excel. However, if we want to use an Excel out of box option to implement such functionality in our .Net applications or any external Excel automation applications, here is what we need to do,

We could make use of Application.Inputbox method that Excel Object Model exposes with the Type argument (which is last argument) set as 8. This allows us to select a cell range, as if we select while using RefEdit control/Function Arguments dialog box, which we get when we insert Excel functions

I have implemented this using the C# code snippet below,

            Excel.Application xlApp = "<Refer to an Excel application instance>";
            //Declares range object
            Microsoft.Office.Interop.Excel.Range rng;

            //Implements InputBox method with last argument value is set as 8
            rng = (Microsoft.Office.Interop.Excel.Range)xlApp.InputBox("Select Range", System.Type.Missing, System.Type.Missing, System.Type.Missing, System.Type.Missing, System.Type.Missing, System.Type.Missing, 8);

            //Display the range address that we just received as an input using InputBox method
            MessageBox.Show(rng.get_Address(System.Type.Missing, System.Type.Missing, Microsoft.Office.Interop.Excel.XlReferenceStyle.xlA1, System.Type.Missing, System.Type.Missing));

Excel: How do you implement Application_Quit event in Excel/how do you intercept Excel application Quit

2009-10-02T20:27:00Z

We know Word Object model provides an event handler called Application_Quit, which will be triggered when the application quits, but we don’t have any such events for Excel (even for PowerPoint and some other Office applications). In order to workaround this issue, first thing that will come in our mind is to use an Office COM add-in and implement OnBeginShutdown method (which “IDTExtensibility2” interface exposes). Moreover, this can be implemented for any/multiple Office applications as well. Otherwise, we can even use ThisAddIn_Shutdown method that VSTO Application level add-in provides.

However, all these methods can run some code when the application is being shut down and they do not allow us to control the quitting of the application. Let us assume a scenario, what if we need to intercept the application quit and need to decide whether to quit the application or not based on certain criteria/business rules.

Here I come with an option to use the old style of processing Windows messages that Office applications receive. I have described the steps below to implement this thought for Excel using VB.Net COM Add-in in much simpler way.

Here are the steps:

Create an Excel COM Add-in using VB.Net
In order to process the windows messages that an Office application receives, we need to inherit the Connect class (Connect.vb) of the COM add-in from, System.Windows.Forms.NativeWindow class. This class provides an overridable method called, WndProc(), that passes Windows message as an argument. We can make use of these messages to implement, as we want. To inherit the NativeWindow class in our Connect class, please make sure that you have added reference for System.Windows.Forms

Then, add the following Using statements in the Connect.cs module,

Imports Extensibility
Imports System.Runtime.InteropServices
Imports System.Windows.Forms
Imports Excel = Microsoft.Office.Interop.Excel

Declare the following constant. It is the value for “Window Close” message, which will be passed by Excel when user clicks close button
```
Const WM_CLOSE As Integer = 16
```

Add the following code in the OnConnection method of the Connect class. The main purpose of using this method is to pass the Excel application’s handle to NativeWindow class so that it can process the messages that the application receives through the WndProc method

Public Sub OnConnection(ByVal application As Object, ByVal connectMode As Extensibility.ext_ConnectMode, ByVal addInInst As Object, ByRef custom As System.Array) Implements Extensibility.IDTExtensibility2.OnConnection

'Type cast the application object to Excel application class
xlApp = DirectCast(application, Excel.Application)

'Pass the Excel application handle to NativeWindow class in order to process messages that Excel receives
MyBase.AssignHandle(xlApp.Hwnd)

'To display a message box
MessageBox.Show("Excel quit detection add-in started!")

End Sub

Copy the following WndProc method implementation to trap the close action in Excel

Protected Overrides Sub WndProc(ByRef m As System.Windows.Forms.Message)

        'Check if the Window handle passed by this procedure is for Excel application and the message is to indicate closing Excel application
      
  If m.HWnd = xlApp.Hwnd And m.Msg = WM_CLOSE Then

Dim wb As Excel.Workbook

            'Prompt Message box to close Excel or not
Dim res As DialogResult = MessageBox.Show("You are quitting Excel. Do you want to save changes for the workbooks opened?", "Excel Quit", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1)

'If the user response is "Yes" for the message box, then loop through all the workbooks, save and close it
If res = DialogResult.Yes Then
For Each wb In xlApp.Workbooks
wb.Close(True)
Next

MyBase.WndProc(m) 'process message as default

ElseIf res = DialogResult.No Then 'If no, Loop through all the workbooks and close it, but don't save

For Each wb In xlApp.Workbooks
  wb.Close(False)
Next

MyBase.WndProc(m) 'process message as default

End If

'If none of the above criteria is not satisfied, Excel will not quit
Else

            MyBase.WndProc(m) 'process message as default

End If

End Sub

Build the add-in and run it. Now, Excel will prompt with a message box, when user attempts to close Excel application by either clicking “X” button or by going to File menu-->Exit or by pressing Alt+F4.

Excel: How to run C# code behind with a click of a button on a Worksheet, without VBA code

2009-10-02T19:59:00Z

OLE object controls such as Command button, Checkbox, etc., allow us to call VBA code behind using OnAction property. However, when a situation arises that we have to call .Net code behind, we cannot use OnAction property, because this property requires a VBA macro to be assigned. In such situations, the option that we can immediately think of is to have VBA macro to call the .Net code, which is possible.

There are scenarios such as one where you want to upgrade your VBA add-in (XLA) to .Net COM/Automation add-in (with no VBA layer in between), which does not allow us to use OnAction property, then this blog post can help you. Because this option does not require us to have VBA layer in between and we can call C#.Net code directly.

I have illustrated this idea using an Excel COM add-in that inserts an OLE command button control on Application start up and I will use it to call its button click event written in C# code behind. To know how to build an Office COM add-in by using Visual C# .NET, please refer to the article, http://support.microsoft.com/kb/302901

Here are the steps:

Create an Excel COM Add-in using C#

Add the following Using statements in the Connect.cs class,

using System;
using Extensibility;
using System.Runtime.InteropServices;
using Excel = Microsoft.Office.Interop.Excel;
using Office = Microsoft.Office.Core;
using MSForms = Microsoft.Vbe.Interop.Forms;
using Microsoft.VisualBasic.CompilerServices;

Add the following code in the OnConnection method of the Connect class. This code will insert a command button onto the Active Worksheet and wire up the Click event for the button, which is written in the C# code behind

public void OnConnection(object application, Extensibility.ext_ConnectMode connectMode, object addInInst, ref System.Array custom)
      {
            try
            {
                
                xlApp = (Excel.Application)application;
                wbs = xlApp.Workbooks; //Get the Workbooks collection
                wbs.Add(Type.Missing); //Add a new workbook
                wb = xlApp.ActiveWorkbook; 
                wsht = (Excel.Worksheet)wb.ActiveSheet;
                //To insert an OLE Object which of type "CommandButton". We need to use the ProgID for the command button, which is "Forms.CommandButton.1"
                cmdButton = (Excel.Shape)wsht.Shapes.AddOLEObject("Forms.CommandButton.1", Type.Missing, false, false, Type.Missing, Type.Missing, Type.Missing, 200, 100, 100, 100);
                //We name the command button, we will use it later
                cmdButton.Name = "btnClick";
                //In order to access the Command button object, we are using NewLateBinding class as below
                CmdBtn = (MSForms.CommandButton)NewLateBinding.LateGet((Excel.Worksheet)xlApp.ActiveSheet, null, "btnClick", new object[0], null, null, null);
                
                //Set the required properties for the command button
                CmdBtn.FontSize = 10;
                CmdBtn.FontBold = true; 
                CmdBtn.Caption = "Click Me";
                //Wiring up the Click event
                CmdBtn.Click += new Microsoft.Vbe.Interop.Forms.CommandButtonEvents_ClickEventHandler(CmdBtn_Click);
                
                }
            catch (Exception ex)
            {

                System.Windows.Forms.MessageBox.Show(ex.Message);
            }
       }

Now, we will need to implement the Button Click event handler. Here is the sample code snippet that just displays a message box and writes value to some cells

void CmdBtn_Click()
{
            //Adding the event code
            System.Windows.Forms.MessageBox.Show("I am called from C# COM add-in");
            wsht.get_Range("A1", "A10").Value2 = "I am called from C# Add-in";  
}

Compile and Build the project, which will add some registry entries to notify Office to load the add-in.
(Note: on machines with Vista or later, you will need to launch Visual Studio in Administrator mode (To do that, right click Visual Studio Icon-->Run as Administrator), as Vista or later would not allow a program to modify registry entries, when UAC is turned on)
Now, the add-in will add a button and upon button click, it will call code from the C# code behind

Word: How to do “Drag and Drop” of Content controls from Task Pane to the document

2009-10-02T18:44:00Z

Create a Word VSTO application level project for Word using Visual Studio 2008/2005 (For VS 2005, you need to install VSTO SE). To do that, go to File Menu in VS -->New-->Project-->Expand Office hive-->Select Word 2007 Add-in
Add a user control item (Name it as CTP.cs) to the project and insert a List box (Name it as, lstItems). To add a user control to the project, go to Project Menu-->Add User Control-->Name it as CTP.cs

Add the code snippet below in the ThisAddIn_Startup event (You will see this when you view the code for ThisAddin.cs). This will add our custom task pane while loading Word

        Microsoft.Office.Tools.CustomTaskPane WCTP;

        private void ThisAddIn_Startup(object sender, System.EventArgs e)

           //To add our CTP to the Custom Task panes collection of Word. We need to set the Visible property to true, otherwise, by

           //default it is false

WCTP = (Microsoft.Office.Tools.CustomTaskPane)this.CustomTaskPanes.Add(new CTP(), "Do Drag Drop");

            WCTP.Visible = true;

The code snippet that we need to have in the user control class is as below,

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Drawing;

using System.Data;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using Word = Microsoft.Office.Interop.Word;

namespace DragDrop_ContentControls

    public partial class CTP : UserControl

        public CTP()

            InitializeComponent();

        object missing = System.Type.Missing;

        private Rectangle dragBoxFromMouseDown;

        private void lstItems_MouseDown(object sender, MouseEventArgs e)

                // Remember the point where the mouse down occurred. The DragSize indicates

                // the size that the mouse can move before a drag event should be started.

                Size dragSize = SystemInformation.DragSize;

                // Create a rectangle using the DragSize, with the mouse position being

                // at the center of the rectangle.

                dragBoxFromMouseDown = new Rectangle(new Point(e.X - (dragSize.Width / 2),

                                                               e.Y - (dragSize.Height / 2)), dragSize);

        private void lstItems_MouseMove(object sender, MouseEventArgs e)

                                                                //To check if the Mouse left button is clicked

if ((e.Button & MouseButtons.Left) == MouseButtons.Left)

                // If the mouse moves outside the rectangle, start the drag.

                if (dragBoxFromMouseDown != Rectangle.Empty &&

                    !dragBoxFromMouseDown.Contains(e.X, e.Y))

                            //Start Drag Drop

                            DoDragDrop("", DragDropEffects.All);

                            Word.ContentControl cntCtrl;

                            //Insert Content Control at the selected range

                            cntCtrl = Globals.ThisAddIn.Application.Selection.Range.ContentControls.Add(Microsoft.Office.Interop.Word.WdContentControlType.wdContentControlText, ref missing);

                            cntCtrl.Range.Text = lstItems.Text; //This is how we set the value to be to populated in the content controls

                            //To set the XPath for custom XML binding for content controls. This is optional

                            string xPath = @"Root\" + lstItems.Text.Replace(" ", "_");

                            cntCtrl.XMLMapping.SetMapping(xPath, "", null); //This is required when you want to bind to a custom XML part

        private void lstItems_MouseUp(object sender, MouseEventArgs e)

            // Reset the drag rectangle when the mouse button is raised.

            dragBoxFromMouseDown = Rectangle.Empty;

Build the application and Run it to launch Word
When you drag an item from List box in the Task Pane onto the document surface, you will see a content control being added with the caption of the list item name

Issue: Change in behavior from Office 2007 RTM to SP2 when Sheet.Unprotect is called

2009-09-11T23:11:00Z

Let’s say you have a password protected Excel workbook, and you are calling following function through VBA in it:

  Sheet.Unprotect Password:=""

If you run this macro in Office 2007 RTM or SP1 version, it will result in a VBA Error; provided the actual password is not an empty string. However, in SP2 it will result in a password input dialog box.

This change of behavior is the result of a design change for SP2 release.

In case you have a code/logic which depends on the handling of VBA Error received in Office 2007 RTM/SP1 for wrong password specified for the above call, you can get the same behavior in SP2 release by passing a dummy password instead of an empty string.

For example:

  Sheet.Unprotect Password:="dummy"

If the specified string is the correct password then the Sheet will be unprotected without any error or showing the Password input dialog box.

Issue: Formatting individual characters of Data Labels of Charts programmatically in Excel 2007 SP2

2009-09-11T19:21:00Z

If you are working with Charts programmatically in Excel 2007 Service Pack 2, and are trying to set the formatting of individual characters of Data Labels of charts programmatically, you will notice that the formatting gets applied to the whole of Data Label instead of the specific character/range.

Here is a snippet which one would typically be used to set formatting of specific characters:

Sub Test()
    Dim ch As Chart
    Dim series As series
    Dim points As points
    Dim label As DataLabel
    Dim chars As Characters
    Dim font As font
    
    Set ch = ActiveSheet.Shapes(1).Chart
    
    Set series = ch.SeriesCollection(1)
    Set points = series.points
    Set label = points(1).DataLabel
    
    label.Text = label.Text & vbCrLf & "a"
    
    Set chars = label.Characters(3, 1)
    
    Set font = chars.font
    
    font.Size = 24
End Sub

The above code will work as desired (format individual characters) on Excel 2003 and Excel 2007 Service Pack 1 releases.

This behavior is a known bug with Excel 2007 Service Pack 2 release, and the Excel development team is looking into it. Unfortunately, there is no known programmatic workaround possible for this requirement. Character level formatting of Data labels can only be set manually as of now.

WORD 2003/EXCEL 2003: VSTO Customization added using ServerDocument.AddCustomization method does not add customization if your document contained an embedded VSTO customized Document/WorkBook

2009-06-30T14:23:30Z

PROBLEM DESCRIPTION

Consider this scenario. You are adding VSTO customizations dynamically to Word 2003/Excel 2003 documents using ServerDocument.AddCustomization method. The ServerDocument.AddCustomization method succeeds. But when you try to open this customized document, the customization does not load. If you have the “VSTO_SUPPRESSDISPLAYALERTS” environment variable set to “0” you will get the following error: “The customization assembly could not be found or could not be loaded.”

This is a known issue with Word 2003 and Excel 2003 VSTO customizations, containing embedded customized documents. It doesn’t occur with Word 2007 (or Excel 2007) VSTO customization.

How to avoid this?

To workaround this issue, you can add the customization to the outer document using VSTO related document properties.

_AssemblyName: This property contains an asterisk (*). This indicates to the Microsoft Office application that the document has a Visual Studio Tools for Office customization.
_AssemblyLocation: This property contains a string that provides details about the deployment manifest for the customization.

For more details on document properties, please visit Custom Document Properties Overview

The _AssemblyLocation custom document property needs to point to the deployment manfiest location. In order to generate the deployment manifest, follow these steps:

Open the Solution that you would like to publish using Visual Studio
Click on the View, Select Solution Explorer (This will display Solution explorer window)
Right-click the project node in Solution Explorer.
Click Publish on the shortcut menu.
The Publish Wizard appears.
In the Specify the location to publish this application box, type the path to the folder where you want to deploy the solution. Optionally, you can click Browse and navigate to the folder using the dialog box that appears.
Verify that the path is correct, and then click Finish.

The document, assemblies, and manifests are copied to the publish location, with the assemblies and application manifest (<filename>.dll.mainfest) in a subdirectory under the document and deployment manifest (<filename>.application)

For more details please refer to: How to: Deploy Solution Files Using the Publish Wizard (2003 System)

You can add these custom document properties using either of the two approaches:-

Use IPropertyStorage APIs to add the custom properties.
Add the custom properties using Word/Excel Object Model (Please see KB 257757 if you intend to do this task from un-attended environments).

Approach 1: Adding Custom Document Properties programmatically using IPropertyStorage

The other approach that you can use is to add the properties using IPropertyStorage interface. You can use the concepts demonstrated in DSOFile sample, to add the custom document properties. This sample can be downloaded using the link http://support.microsoft.com/kb/224351.

Information about DSOFile:
The Dsofile.dll sample file demonstrates how to use the OLE32 IPropertyStorage interface to access the extended properties of OLE structured storage files. The component converts the data to Automation friendly data types for easier use by high level programming languages such as Visual Basic 6.0, Visual Basic .NET, and C#. The Dsofile.dll sample file is given with full source code and includes sample clients written in Visual Basic 6.0 and Visual Basic .NET 2003 (7.1).Warning The Dsofile.dll, the source code, and the associated samples are provided "as is" without warranty of any kind, either expressed or implied, including but not limited to the implied warranties of merchantability and/or fitness for a particular purpose. Use at your own risk.

Let’s see how to use DSOFile sample to attach custom properties to the document, but before that we need to ensure that DSOFile.dll is registered on the development machine. The self-extracting setup installs and registers the DsoFile.dll component in a location that you want. But, if you move the DLL to another location or to another computer, you have to re-register the DLL before you can use it again. To do this, type regsvr32 [filepath]\dsofile.dll in the Run dialog box on the Start menu (or from elevated rights command prompt in case of Vista).

Let’s start by creating a new windows application project which references DSOFile.dll and adds these properties.

Launch Visual Studio
On the File menu, point to New, and then click Project.
In the Project Types pane, expand Visual C# or Visual Basic, and then Click on Windows.
In the templates pane, select “Windows Form Application”
In the Name box, type AddPropertiesSample
Click OK. (This will open Visual Studio and by default one Window form Form1 will be added to the project)
Click on the View, Select Solution Explorer (This will display Solution explorer window)
Right click on the References and Select “Add References…” from the drop down menu.
The “Add Reference” dialog will be displayed, Click on the COM tab in the dialog.
Locate “DSO OLE Document Properties Reader 2.1” in the Component Name and Click on OK.
Click on the View, Select ToolBox (This will display ToolBox)
Expand “All Windows Forms” in the ToolBox
Drag and Drop button control on the Form1, a new control named Button1 will be added to the form.

Double click on the button1 to add button1_Click event, paste the following code

   1:  string fileName = @"C:\temp\Sample.doc";

   2:  object vstoDocumentLocation = @"C:\Temp\WordDocument.application";

3:

   4:  DSOFile.OleDocumentPropertiesClass doc = new DSOFile.OleDocumentPropertiesClass();

   5:  doc.Open(fileName, false, DSOFile.dsoFileOpenOptions.dsoOptionDefault);

   6:  object assemblyName = "*";

   7:  DSOFile.CustomProperties customProperties = doc.CustomProperties;

   8:  //Check if _AssemblyName property already exists

   9:  try

  10:    {

  11:       DSOFile.CustomProperty nameProp = customProperties["_AssemblyName"];

  12:       nameProp.set_Value(ref assemblyName);

  13:    }

  14:  catch (Exception)

  15:    {

  16:       customProperties.Add("_AssemblyName", ref assemblyName);

  17:    }

  18:  //Check if _AssemblyLocation property already exists

  19:  try

  20:    {

  21:        DSOFile.CustomProperty loc = customProperties["_AssemblyLocation"];

  22:        loc.set_Value(ref assemblyLocation);

  23:    }

  24:  catch (Exception ex)

  25:    {

  26:        customProperties.Add("_AssemblyLocation", ref vstoDocumentLocation);

  27:    }

28:

  29:  doc.Save();

  30:  doc.Close(false);

Approach 2: Add the properties using Word/Excel Object Model:

One more approach that you can use is to add the properties using Excel/Word object model.

Let’s start by creating a new windows application project which references Excel/Word libraries and adds these properties using CustomDocumentProperties Object.

Create an Automation Client for Microsoft Word

Start Visual Studio .NET.
On the File menu, click New, and then click Project. Select Windows Application from the Visual C# Project types. Form1 is created by default.
Add a reference to Microsoft Word Object Library. To do this, follow these steps:
1. On the Project menu, click Add Reference.
2. On the COM tab, locate Microsoft Word Object Library, and then click Select.
Click OK in the Add References dialog box to accept your selections. On the View menu, select Toolbox to display the Toolbox, and then add a button to Form1.
Double-click Button1. The code window for the form appears.

In the code window, replace the following code

   1:  private void button1_Click(object sender, EventArgs e)

   2:  {

   3:  }

4:

   5:  With:-

6:

   7:  private void button1_Click(object sender, EventArgs e)

   8:  {

   9:  Word.Application oWord;

  10:  Word._Document oDoc;

  11:  object oMissing = Missing.Value;

  12:  object oDocBuiltInProps;

  13:  object oDocCustomProps;

  14:  object fileName = @"C:\test.doc";

15:

  16:  //Create an instance of Microsoft Word and make it visible.

  17:  oWord = new Word.Application();

  18:  oWord.Visible = true;

19:

  20:  //Create a new Document and get the BuiltInDocumentProperties collection.

  21:  oDoc = oWord.Documents.Open(ref fileName,ref oMissing,ref oMissing,

  22:                              ref oMissing,ref oMissing,ref oMissing,

  23:                              ref oMissing,ref oMissing,ref oMissing,

  24:                              ref oMissing,ref oMissing,ref oMissing,

  25:                              ref oMissing,ref oMissing,ref oMissing,

  26:                              ref oMissing);

  27:  oDocBuiltInProps = oDoc.BuiltInDocumentProperties;

  28:  Type typeDocBuiltInProps = oDocBuiltInProps.GetType();

29:

  30:  //Get the Author property and display it.

  31:  string strName;

  32:  string strValue;

33:

  34:  //Add a property/value pair to the CustomDocumentProperties collection.

  35:  oDocCustomProps = oDoc.CustomDocumentProperties;

  36:  object oDocAssemblyNameProp;

  37:  Type typeDocAssemblyNameProp;

  38:  Type typeDocCustomProps = oDocCustomProps.GetType();

  39:  try

  40:  {

  41:  strName = "_AssemblyName";

  42:  oDocAssemblyNameProp = typeDocCustomProps.InvokeMember("Item",

  43:                          BindingFlags.Default | BindingFlags.GetProperty,

  44:                          null, oDocCustomProps, new object[] { strName });

  45:  typeDocAssemblyNameProp = oDocAssemblyNameProp.GetType();

  46:  strValue = typeDocAssemblyNameProp.InvokeMember("Value",

  47:              BindingFlags.Default | BindingFlags.GetProperty,

  48:              null, oDocAssemblyNameProp, new object[] { }).ToString();

  49:  }

  50:  catch

  51:  {

  52:  strName = "_AssemblyName";

  53:  strValue = "*";

  54:  object[] oArgs = { strName, false, MsoDocProperties.msoPropertyTypeString, strValue };

  55:  typeDocCustomProps.InvokeMember("Add",

  56:  BindingFlags.Default | BindingFlags.InvokeMethod, null,

  57:  oDocCustomProps, oArgs);

  58:  }

  59:  try

  60:  {

  61:  strName = "_AssemblyLocation";

  62:  oDocAssemblyNameProp = typeDocCustomProps.InvokeMember("Item",

  63:  BindingFlags.Default | BindingFlags.GetProperty,

  64:  null, oDocCustomProps, new object[] { strName });

65:

  66:  typeDocAssemblyNameProp = oDocAssemblyNameProp.GetType();

  67:  strValue = typeDocAssemblyNameProp.InvokeMember("Value",

  68:  BindingFlags.Default | BindingFlags.GetProperty, null,

  69:  oDocAssemblyNameProp, new object[] { }).ToString();

  70:  }

  71:  catch

  72:  {

  73:  strName = "_AssemblyLocation";

  74:        strValue = @"C:\WordDocument.application"; ;

  75:        object[] oArgs = { strName, false, MsoDocProperties.msoPropertyTypeString, strValue };

  76:        typeDocCustomProps.InvokeMember("Add",

  77:        BindingFlags.Default | BindingFlags.InvokeMethod,

  78:        null, oDocCustomProps, oArgs);

  79:  }

80:

  81:  oDoc.Save();

  82:  oDocBuiltInProps = null;

  83:  oDocCustomProps = null;

  84:  oDoc.Close(ref oMissing, ref oMissing,ref oMissing);

  85:  oDoc = null;

  86:  oWord.Quit(ref oMissing, ref oMissing, ref oMissing);

  87:  oWord = null;

88:

  89:  }

Scroll to the top of the code window, and then add the following lines to the end of the list of using directives:

   1:  using Microsoft.Office.Core;

   2:  using Word = Microsoft.Office.Interop.Word;

   3:  using System.Reflection;

Press F5 to run the application.

Note:- The DocumentProperties and the DocumentProperty interfaces are late bound interfaces. To use these interfaces, you must treat them like you would an IDispatch interface.

For more details, please refer to: How to Use Automation to Get and to Set Office Document Properties with Visual C#.

The next time the document is opened and saved, the Visual Studio Tools for Office runtime attaches the solution assembly to the document, and creates the Runtime Storage Control, if necessary. The Visual Studio Tools for Office runtime also sets the value of the _AssemblyLocation custom document property to the GUID for the Runtime Storage Control.

Presentation Close event is incorrectly fired while issuing Presentation Print Command

2009-06-30T06:42:00Z

Summary

When the print command of a PowerPoint Presentation is issued, the presentation.close event is fired in addition to the Print event・

However, the expected behavior is that the presentation.close event should not get fired when the print command is issued.

Cause

This is a known issue with PowerPoint 2003/ 2007.

Resolution

Either of the solutions mentioned below can be used to work around this issue:

Solution#1:

This solution exploits the fact that there is a temporary presentation created for the purpose of background printing and temporary presentations are not added to the list of open presentations.

So the workaround is to go through the list of presentations and if current presentation is not found there, then it is the temporary print presentation. The Close Event Handler would ignore the event in that case.

The sample code (c#) to implement the workaround is given below:

   1:  void applicationObject_PresentationPrint(Microsoft.Office.Interop.PowerPoint.PresentationPres)

   2:  {

   3:      MessageBox.Show("applicationObject_PresentationPrint");

   4:  }

5:

   6:  void applicationObject_PresentationClose(Microsoft.Office.Interop.PowerPoint.PresentationPres)

   7:  {

   8:      if (!IsPrintPres(Pres))

   9:      {

  10:          //Write your code for presentation close event here. It will get executed only when a presentation is being closed.

  11:          MessageBox.Show("applicationObject_PresentationClose");

  12:      }

  13:  }

14:

  15:  private bool IsPrintPres(Microsoft.Office.Interop.PowerPoint.Presentation Pres)

  16:  {

  17:      foreach (Microsoft.Office.Interop.PowerPoint.Presentation p in applicationObject.Presentations)

  18:      {

  19:          if (p == Pres)

  20:          {

  21:              return false;

  22:          }

  23:      }

  24:      return true;

  25:  }

Solution#2:

Explicitly set the background print option to false (either programmatically or manually). The sample code(C#) to programmatically set the background print option to false is given below:

   1:  void applicationObject_AfterPresentationOpen(Microsoft.Office.Interop.PowerPoint.Presentation Pres)

   2:  {

   3:      MessageBox.Show("applicationObject_AfterPresentationOpen");

   4:      Pres.PrintOptions.PrintInBackground = MsoTriState.msoFalse;

   5:  }

6:

   7:  void applicationObject_AfterNewPresentation(Microsoft.Office.Interop.PowerPoint.Presentation Pres)

   8:  {

   9:      MessageBox.Show("applicationObject_AfterNewPresentation");

  10:      Pres.PrintOptions.PrintInBackground = MsoTriState.msoFalse;

  11:  }

How to Sign the SignatureLine using Office Open XML

2009-06-19T22:51:00Z

Introduction

We can use PackageDigitalSignatureManager class available in System.IO.Packaging namespace to sign any part of an Open XML document. However, when we try to sign a document that has a signature line using this class, we will notice that though the document appears as signed, the signature line still appears as “needs to be signed”. In order to have the signature appear in the signature line, we will need to do some additional tasks which are mentioned in the resolution section below.

Steps to Duplicate the Behaviour

Create a new word document in Word 2007.
Save this document to C:\Test\Test.docx.
Insert a Signature Line by going to -> Insert tab-> in the Text group, point to the arrow next to Signature Line, and then click Microsoft Office Signature Line.

Use the following code to sign the document

// ========First function============
// Entry Point
private void DigiSign()
{
	// Open the Package    
	using (Package package = Package.Open(<< Word File Location >>))
	{
		// Get the certificate
		X509Certificate2 certificate = GetCertificate();
		SignAllParts(package, certificate);
	}
}
// ========End Of First function============

// ========Second function============

private static void SignAllParts(Package package, X509Certificate certificate)
{
	if (package == null) throw new ArgumentNullException("SignAllParts(package)");
	List<Uri> PartstobeSigned = new List<Uri>();
	List<PackageRelationshipSelector> SignableReleationships = new List<PackageRelationshipSelector>();

	foreach (PackageRelationship relationship in package.GetRelationshipsByType(RT_OfficeDocument))
	{
		// Pass the releationship of the root. This is decided based on the RT_OfficeDocument 
		// http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument
		CreateListOfSignableItems(relationship, PartstobeSigned, SignableReleationships);
	}
	// Create the DigitalSignature Manager
	PackageDigitalSignatureManager dsm = new PackageDigitalSignatureManager(package);
	dsm.CertificateOption =  CertificateEmbeddingOption.InSignaturePart;         
	try
	{
		dsm.Sign(PartstobeSigned, certificate, SignableReleationships);
	}
	catch (CryptographicException ex)
	{
		MessageBox.Show(ex.InnerException.ToString());
	}

}// end:SignAllParts()
// ========End of Second function============

// ========Third function============

static void CreateListOfSignableItems(PackageRelationship relationship, List<Uri> PartstobeSigned, List<PackageRelationshipSelector> SignableReleationships)
{
	// This function adds the releation to SignableReleationships. And then it gets the part based on the releationship. Parts URI gets added to the PartstobeSigned list.
	PackageRelationshipSelector selector = new PackageRelationshipSelector(relationship.SourceUri, PackageRelationshipSelectorType.Id, relationship.Id);
	SignableReleationships.Add(selector);
	if (relationship.TargetMode == TargetMode.Internal)
	{
		PackagePart part = relationship.Package.GetPart(PackUriHelper.ResolvePartUri(relationship.SourceUri, relationship.TargetUri));
		if (PartstobeSigned.Contains(part.Uri) == false)
		{
			PartstobeSigned.Add(part.Uri);
			// GetRelationships Function: Returns a Collection Of all the releationships that are owned by the part.
			foreach (PackageRelationship childRelationship in part.GetRelationships())
			{
				CreateListOfSignableItems(childRelationship, PartstobeSigned, SignableReleationships);
			}
		}
	}
}
// ========End of Third function============

// ======== Fourth function============
static X509Certificate2 GetCertificate()
{
	X509Store certStore = new X509Store(StoreLocation.CurrentUser);
	certStore.Open(OpenFlags.ReadOnly);
	X509Certificate2Collection certs =X509Certificate2UI.SelectFromCollection(certStore.Certificates,"Select a certificate","Please select a certificate",
	X509SelectionFlag.SingleSelection);
	return certs.Count > 0 ? certs[0] : null;
}
// ========End of Fourth function============

Open the document, you will notice that the doc is signed but signature line still shows as “needs to be signed”.

Resolution

The point is, Sign method expects an XML file of ContentType “System.Security.Cryptography.Xml.DataObject” which should include the GUID of the signatureLine needs to be signed.

Note: Whenever we create a SignatureLine, it gets an unique GUID which we need to use while signing the SignatureLine.

The structure of the XML file should be

<SignatureProperties xmlns="http://www.w3.org/2000/09/xmldsig#">
  <SignatureProperty Id="idOfficeV1Details" Target="#idPackageSignature">
    <SignatureInfoV1 xmlns="http://schemas.microsoft.com/office/2006/digsig">
      <SetupID>{3CF6B91E-C5F6-46A4-B036-72597274FCC0}</SetupID>
      <SignatureText>Test User</SignatureText>
      <ManifestHashAlgorithm>http://www.w3.org/2000/09/xmldsig#sha1</ManifestHashAlgorithm>
    </SignatureInfoV1>
  </SignatureProperty>
</SignatureProperties>

Where SetupID represents the GUID of the SignatureLine.

Once the XML file is created, we can call the Sign method available in PackageDigitalSignatureManager class. Following is the complete listing of the class:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO.Packaging;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Security.Cryptography.Xml;
using System.Xml;

namespace DigitalSign
{
    public partial class SignDoc
    {
        // Get help about them from http://download.microsoft.com/download/2/4/8/24862317-78F0-4C4B-B355-C7B2C1D997DB/%5BMS-OFFCRYPTO%5D.pdf

        static readonly string RT_OfficeDocument = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
        static readonly string OfficeObjectID = "idOfficeObject";
        static readonly string SignatureID = "idPackageSignature";
        static readonly string ManifestHashAlgorithm = "http://www.w3.org/2000/09/xmldsig#sha1";
        
       // Entry Point
        private void DigiSign()
        {
        // Open the Package    
            using (Package package = Package.Open(<< Word File>>)
            {
                // Get the certificate
                X509Certificate2 certificate = GetCertificate();
                SignAllParts(package, certificate);
            }
        }

        private static void SignAllParts(Package package, X509Certificate certificate)
        {
            if (package == null) throw new ArgumentNullException("SignAllParts(package)");
            List<Uri> PartstobeSigned = new List<Uri>();
            List<PackageRelationshipSelector> SignableReleationships = new List<PackageRelationshipSelector>();

            foreach (PackageRelationship relationship in package.GetRelationshipsByType(RT_OfficeDocument))
            {
                // Pass the releationship of the root. This is decided based on the RT_OfficeDocument (http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument)
                CreateListOfSignableItems(relationship, PartstobeSigned, SignableReleationships);
            }
            // Create the DigitalSignature Manager
            PackageDigitalSignatureManager dsm = new PackageDigitalSignatureManager(package);
            dsm.CertificateOption =  CertificateEmbeddingOption.InSignaturePart;
           
            string signatureID = SignatureID;
            string manifestHashAlgorithm = ManifestHashAlgorithm;
            System.Security.Cryptography.Xml.DataObject officeObject = CreateOfficeObject(signatureID, manifestHashAlgorithm);
            Reference officeObjectReference = new Reference("#" + OfficeObjectID);

            try
            {
              dsm.Sign(PartstobeSigned, certificate, SignableReleationships, signatureID, new System.Security.Cryptography.Xml.DataObject[] { officeObject }, new Reference[] { officeObjectReference }); 
            }
            catch (CryptographicException ex)
            {
                MessageBox.Show(ex.InnerException.ToString());
            }

        }// end:SignAllParts()

        /**************************SignDocument******************************/
        //  This function is a helper function. The main role of this function is to 
        //  create two lists, one with Package Parts that you want to sign, the other 
        //  containing PacakgeRelationshipSelector objects which indicate relationships to sign.
        /*******************************************************************/
        static void CreateListOfSignableItems(PackageRelationship relationship, List<Uri> PartstobeSigned, List<PackageRelationshipSelector> SignableReleationships)
        {
            // This function adds the releation to SignableReleationships. And then it gets the part based on the releationship. Parts URI gets added to the PartstobeSigned list.
            PackageRelationshipSelector selector = new PackageRelationshipSelector(relationship.SourceUri, PackageRelationshipSelectorType.Id, relationship.Id);
            SignableReleationships.Add(selector);
            if (relationship.TargetMode == TargetMode.Internal)
            {
                PackagePart part = relationship.Package.GetPart(PackUriHelper.ResolvePartUri(relationship.SourceUri, relationship.TargetUri));
                if (PartstobeSigned.Contains(part.Uri) == false)
                {
                    PartstobeSigned.Add(part.Uri);
                // GetRelationships Function: Returns a Collection Of all the releationships that are owned by the part.
                    foreach (PackageRelationship childRelationship in part.GetRelationships())
                    {
                        CreateListOfSignableItems(childRelationship, PartstobeSigned, SignableReleationships);
                    }
                }
            }
        }
            /**************************SignDocument******************************/
        //  Once you create the list and try to sign it, Office will not validate the Signature.
        //  To allow Office to validate the signature, it requires a custom object which should be added to the 
        //  signature parts. This function loads the OfficeObject.xml resource.
        //  Please note that GUID being passed in document.Loadxml. 
        //  Background Information: Once you add a SignatureLine in Word, Word gives a unique GUID to it. Now while loading the
        //  OfficeObject.xml, we need to make sure that The this GUID should match to the ID of the signature line. 
        //  So if you are generating a SignatureLine programmtically, then mmake sure that you generate the GUID for the 
        //  SignatureLine and for this element. 
        /*******************************************************************/

        static System.Security.Cryptography.Xml.DataObject CreateOfficeObject(
           string signatureID, string manifestHashAlgorithm)
        {
            XmlDocument document = new XmlDocument();
            document.LoadXml(String.Format(Properties.Resources.OfficeObject, signatureID, manifestHashAlgorithm, "{3CF6B91E-C5F6-46A4-B036-72597274FCC0}"));
            System.Security.Cryptography.Xml.DataObject officeObject = new System.Security.Cryptography.Xml.DataObject();
            // do not change the order of the following two lines
            officeObject.LoadXml(document.DocumentElement); // resets ID
            officeObject.Id = OfficeObjectID; // required ID, do not change
            return officeObject;
        }
        /********************************************************/

        static X509Certificate2 GetCertificate()
        {
            X509Store certStore = new X509Store(StoreLocation.CurrentUser);
            certStore.Open(OpenFlags.ReadOnly);
            X509Certificate2Collection certs =X509Certificate2UI.SelectFromCollection(certStore.Certificates,"Select a certificate","Please select a certificate",
                    X509SelectionFlag.SingleSelection);
            return certs.Count > 0 ? certs[0] : null;
        }

        private void button2_Click(object sender, EventArgs e)
        {
            DialogResult a = openFileDialog1.ShowDialog();
            openFileDialog1.InitialDirectory = "C:\\test";
            textBox1.Text=openFileDialog1.FileName;
        }
  
    }
}

Please note that you need to change the GUID of the signatureLine used in the above sample. Following section shows you to how to get this information for an existing SignatureLine.

How to Check GUID of the SignatureLine

In order to know the GUID of the signatureLine which you have inserted using Word:

Extract the content of the package.
Go to SignatureLine declaration of document.xml. You will see a declaration like:

<o:signatureline v:ext="edit" id="{3CF6B91E-C5F6-46A4-B036-72597274FCC0}" provid="{00000000-0000-0000-0000-000000000000}" o:suggestedsigner="a" o:suggestedsigner2="a" o:suggestedsigneremail="a" issignatureline="t"/>

Where id attribute stands for the GUID. This GUID needs to be passed in the XML file while signing.

Reference for XML generation

http://download.microsoft.com/download/2/4/8/24862317-78F0-4C4B-B355-C7B2C1D997DB/%5BMS-OFFCRYPTO%5D.pdf

MapPoint does not appear in the list of products while creating shared add-in in Visual Studio 2008

2009-06-18T22:02:00Z

Issue Description:

On a machine having Visual Studio 2008 and MapPoint 2009 installed, MapPoint does not appear in the list of products while developing a shared add-in using Visual Studio 2008, as shown below:

This is a bug in MapPoint 2009.

Workaround for this issue is to create necessary registry entries.

Follow the steps below to resolve this issue:

1) Create a blank text document and rename it to have ".reg" extension.

2) Copy & paste the following to the ".reg" file created in step 1.

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Shared Tools\AddinWizard7.1c\Microsoft MapPoint]

"DisplayAdvFeatures"=dword:00000000

"RegistryRoot"="Software\\Microsoft\\MapPoint\\Addins"

"StartupFlag"=dword:00000003

3) Save & close the document.

4) Double click the ".reg" file(alternatively, ".reg" file can also be imported in windows registry)

Now, MapPoint should appear in the list of products in the shared add-in wizard in Visual studio 2008.

Creating charts in Word and PowerPoint using newly introduced Object Model in Office 2007 Service Pack 2

2009-06-16T00:34:00Z

Office 2007 SP2 has added a major inclusion to the Object Models of Word and PowerPoint, i.e., Object Model for Charts. This new object model (OM) provides office application programmers flexibility to manipulate charts programmatically in Word and PowerPoint.

The new OM in Word and PowerPoint is similar to the one that existed for Excel prior to Office SP2. Chart objects can be accessed using the Shape.Chart property. Every Chart object contains a ChartData property which refers to the Excel worksheet which holds the data for the chart. Once you get hold of the worksheet which holds a chart’s data, you can use Excel’s object model to manipulate that data.

In this post, we will try to add charts to Word document using this newly added object model. But, before we dive into the coding part, make sure that Service Pack 2 for Microsoft Office 2007 is installed on your machine. Also, I will be using Visual Studio 2008; however, the steps mentioned here should also work for Visual Studio 2005. In case you face any difficulty, feel free to ask me.

First of all create a new Windows Forms application in your favorite .Net programming language (i.e. C# or VB.Net). Add a new button to the form, and double click it to add the code in the Click event handler’s for it.

Next step is to add references to the required assemblies for enabling .Net code automate Word and PowerPoint. For this, right click on the References folder in your Solution Explorer (if you have created a VB.Net project, you may have to click Show All Files for making the References folder visible). Now select the COM tab in the Add reference dialog box that got opened, and search for following entries:

Microsoft Excel 12.0 Object Library
Microsoft PowerPoint 12.0 Object Library
Microsoft Word 12.0 Object Library

Now, you’ll be asking why we need to select these entries from the COM tab rather than the .Net tab, as we have the Primary Interop Assemblies installed on our machines, and why in the world, do we need Excel object library for?

Well for your first question, as you know Visual Studio 2008 uses its own set of Office Primary Interop Assemblies (PIAs) when you compile and link your projects and not the ones that are installed in your system’s Global Assembly Cache (GAC), selecting assemblies from the COM tab (rather than the .Net tab) ensures that Visual studio will not compile/link your project with its own set of PIAs, but will generate ones from the corresponding COM type libraries. If we do not follow this step, Visual Studio will try to link our code with its own copy of PIAs, which do not contain declarations of the new Office SP2 object model.

And, for your second question, the Chart object model in SP2 has added a new property to the Chart object called ChartData, which (as you might have guessed) represents the data of a chart. This ChartData has a property named Workbook which corresponds to the Excel Workbook containing the data of your chart. Therefore, we need the Excel object library to be able to interact with this workbook programmatically.

Now, let’s first write the code require to insert a chart, set its data, and set some of its visible properties. We will discuss about the new classes/properties of the new object model later.

Below is an example, which shows how to insert a chart to a Word document, accesses chart’s underlying data’s workbook, modify that data and finally sets some of its other properties. (Line numbers mentioned are just for indicative purpose.)

   1:  Word.Application word = null;

   2:  word = new Word.Application();

   3:  word.Visible = true;

   4:  Word.Document doc = word.Documents.Add(ref missing, ref missing, ref missing, ref missing);

   5:  Word.Chart wdChart = doc.InlineShapes.AddChart(Microsoft.Office.Core.XlChartType.xl3DColumn , ref missing).Chart;

   6:  Word.ChartData chartData = wdChart.ChartData;

   7:  Excel.Workbook dataWorkbook = (Excel.Workbook)chartData.Workbook;

   8:  Excel.Worksheet dataSheet = (Excel.Worksheet)dataWorkbook.Worksheets[1];

   9:  Excel.Range tRange = dataSheet.Cells.get_Range("A1", "B5");

  10:  Excel.ListObject tbl1 = dataSheet.ListObjects["Table1"];

  11:  tbl1.Resize(tRange);

  12:  ((Excel.Range)dataSheet.Cells.get_Range("A2", missing)).FormulaR1C1 = "Bikes";

  13:  ((Excel.Range)dataSheet.Cells.get_Range("A3", missing)).FormulaR1C1 = "Accessories";

  14:  ((Excel.Range)dataSheet.Cells.get_Range("A4", missing)).FormulaR1C1 = "Repairs";

  15:  ((Excel.Range)dataSheet.Cells.get_Range("A5", missing)).FormulaR1C1 = "Clothing";

  16:  ((Excel.Range)dataSheet.Cells.get_Range("B2", missing)).FormulaR1C1 = "1000";

  17:  ((Excel.Range)dataSheet.Cells.get_Range("B3", missing)).FormulaR1C1 = "2500";

  18:  ((Excel.Range)dataSheet.Cells.get_Range("B4", missing)).FormulaR1C1 = "4000";

  19:  ((Excel.Range)dataSheet.Cells.get_Range("B5", missing)).FormulaR1C1 = "3000";

  20:  wdChart.ChartTitle.Font.Italic = true;

  21:  wdChart.ChartTitle.Font.Size = 18;

  22:  wdChart.ChartTitle.Font.Color = Color.Black.ToArgb();

  23:  wdChart.ChartTitle.Text = "2007 Sales";

  24:  wdChart.ChartTitle.Format.Line.Visible = Microsoft.Office.Core.MsoTriState.msoTrue;

  25:  wdChart.ChartTitle.Format.Line.ForeColor.RGB = Color.Black.ToArgb();

  26:  wdChart.ApplyDataLabels(Word.XlDataLabelsType.xlDataLabelsShowLabel, missing, missing, missing, missing, missing, missing, missing, missing, missing);

  27:  dataWorkbook.Application.Quit();

As you might have guessed, the main class here is the Chart class. We can get an object of Chart class by accessing the Shape.Chart property. The call to Document.InlineShapes.AddChart() method returns a Shape object and we have accessed its Chart object in line no 5.

The next object in question is the ChartData object. We require this object to access the underlying workbook containing all the data of our chart, and we have accessed it using ChartData.Workbook property.

After getting the Workbook object of the ChartData, the next task is just using object model of Excel to insert/update data in its cells (lines 12 to 19).

Once we are finished with filling the data in the Excel workbook, we set some of the visible properties of chart like, Font, Text and Style of its Title; enable display of labels on the Chart (which are the bars in our example). After doing all this, the last task is to quit the Excel application (which automatically got created when we accessed the ChartData.Workbook object).

Here is how the final chart looks like after running the above code:

Visual Basic 6 Controls stop working after Security Advisory 960715

2009-06-05T04:57:00Z

Summary of the issue: After installing security advisory 960715 and opening a workbook with one of Visual Basic 6 ActiveX controls embedded in the workbook you receive an error:

“Object library invalid or contains references to object definitions that could not be found” or “Element not found.”

See Microsoft security bulletin MS08-070 article 932349 for more information regarding this error:

MS08-070: Vulnerabilities in Visual Basic 6.0 Runtime Extended Files (ActiveX Controls) could allow remote code execution.

Please refer to the “Known issues with this security update” in the “More Information” section.

Cause: The security advisory listed above sets the kill bit for the following Visual Basic 6 ActiveX controls.

The VB6 controls affected are:

File Name	Control Name	Class Identifier (CLSID)
Comct232.ocx	Windows Common Controls	{1E216240-1B7D-11CF-9D53-00AA003C9CB6}
Mschrt20.ocx	Chart Control (OLEDB)	{3A2B370C-BA0A-11d1-B137-0000F8753F5D}
Mscomct2.ocx	Windows Common Controls-2	{B09DE715-87C1-11d1-8BE3-0000F8754DA1}
Msdatgrd.ocx	DataGrid Control 6.0 (OLEDB)	{cde57a43-8b86-11d0-b3c6-00a0c90aea82}
Msflxgrd.ocx	FlexGrid Control 6.0	{6262d3a0-531b-11cf-91f6-c2863c385e30}
Mshflxgd.ocx	Hierarchical FlexGrid Control	{0ECD9B64-23AA-11d0-B351-00A0C9055D8E}
Msmask32.ocx	Masked Edit Control	{C932BA85-4374-101B-A56C-00AA003668DC}
MSWinsck.ocx	Winsock Control 6.0	{248dd896-bb45-11cf-9abc-0080c7e7b78d}

Theses kill bits were necessary because of security vulnerabilities found within these controls and addressed in Microsoft security bulletin MS08-070 http://www.microsoft.com/technet/security/Bulletin/ms08-070.mspx

To ensure that the correct ActiveX control is being used Microsoft had disabled the particular GUID or “kill bit” the control. Setting the kill bit makes sure that even if a vulnerable component (i.e. malicious code) is introduced or is re-introduced to a system, it remains inert and harmless. Kill-Bits must be issued to prevent old / vulnerable signed versions of controls from being effectively imposed on users. Even if you have a fixed version of the control on your system, a renamed and signed DLL or OCX served from a malicious web page can revert the machine to an insecure state. The software vendor cannot just update the control with the same GUID because there is no way ensure that control in use is the updated control.

For more information about the kill bit for ActiveX controls, see the following Microsoft Security Vulnerability Research & Defense Blog posts:

The Kill-Bit FAQ: Part 1 of 3
http://blogs.technet.com/swi/archive/2008/02/06/The-Kill_2D00_Bit-FAQ_3A00_-Part-1-of-3.aspx

The Kill-Bit FAQ: Part 2 of 3
http://blogs.technet.com/swi/archive/2008/02/07/The-Kill_2D00_Bit-FAQ_3A00_-Post-2-of-3.aspx

The Kill-Bit FAQ: Part 3 of 3
http://blogs.technet.com/swi/archive/2008/02/08/The-Kill_2D00_Bit-FAQ_3A00_-Part-3-of-3.aspx

To resolve this issue you must update the development computer with updated controls and then update the controls on the client computer. Please see step by step instructions below.

On Development Computer

1. Install the Microsoft Visual Basic 6.0 Service Pack 6 Cumulative Update http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=cb824e35-0403-45c4-9e41-459f0eb89e36

2. Delete the cached versions of the control type libraries (extender files). To do this, search your hard drive for ".exd," and delete all the .exd files. The .exd files will be re-created automatically using the new controls the next time that you use VBA. The extender files will reside under the users profile and may reside in multiple locations such as:

C:\documents and settings\username\Application Data\Microsoft\Forms

C:\documents and settings\username\AppData\Local\Temp\VBE

Note that you can search the "HKEY_CLASSES_ROOT\TypeLib" key in the registry using the search term "exd" to find the locations where the extender files reside.

3. Open the Excel workbook with the ActiveX control.

4. Open the Visual Basic Editor and under Debug click “Compile VBAProject”

5. Then save and redeploy the updated workbook

Note: If you do not recompile the project on the development computer that has a design time license for the control. When you open the open the workbook on a client computer you will receive the following error “License information for this component not found. You do not have an appropriate license to use this functionality in the design environment.” This is because the runtime time license is stored with the ActiveX control within the workbook and by re-compiling the control on the development computer the run time license is correctly updated.

On Client Computer

1. Delete the cached versions of the control type libraries (extender files). To do this, search your hard drive for ".exd," and delete all the .exd files. The .exd files will be re-created automatically using the new controls the next time that you use VBA. The extender files will reside under the users profile and may reside in multiple locations such as:

C:\documents and settings\username\Application Data\Microsoft\Forms

C:\documents and settings\username\AppData\Local\Temp\VBE

Note that you can search the "HKEY_CLASSES_ROOT\TypeLib" key in the registry using the search term "exd" to find the locations where the extender files reside.

2. Download the update control from the URL associated with the problem control into a browser window (see list below).

3. When prompted, choose to Save the file to client computer.

4. Extract the files from the .CAB

5. Browse to the location of the extracted files. Right-click on the .INF file,
and choose 'Install' (this should take a matter of a couple of seconds and there
will be no confirmation message)

6. Click on Start, then Run, type in 'regsvr32 <OCXNAME>.ocx' (excluding quotes,
substituting the name of the control that was just installed) and click on 'OK'.

7. A message stating the 'DllRegisterServer in <controlname>.ocx succeeded.'
Click 'OK'.

8. Open the re-complied workbook to ensure that the control is working.

Other options

There are two additional workarounds

1. Remove the kill bit for the ActiveX control; this means that the security vulnerabilities are still exposed. (this is not recommended)

2. To remove the AlternateCLSID and keep the Kill Bit; this will cause the control not to load.

When security advisory 960715 is applied, the following two registry keys are added for each control listed above. Example:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer\ActiveX Compatibility\

{CLSID of killed ActiveX control}, Compatibility Flags, 0x0400

*This is the actual Kill Bit, 0x400, which is “COMPAT_EVIL_DONT_LOAD” which means the control is never used.

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer\ActiveX Compatibility\

{CLSID of killed ActiveX control}

This registry key is referred to as the Phoenix-Bit, a.k.a AlternateCLSID. Since a Kill-Bit completely prevents a control from loading, this key points to the updated controls GUID.

Workaround one

Change the Compatibility Flags to 0x00800000 which means Safe for Loading. The information regarding Compatibility Flags can be found at http://msdn.microsoft.com/en-us/library/aa768234.aspx

Workaround Two

Remove the AlternateCLSID registry key, this will remove the control from the form.

*With both of these workarounds, once you install the check security advisory, you must make the same changes again because registry keys revert to the Kill bit behavior.

(Author: Lee Kohrman)

How to merge two or more Word 2003 or Word 2007 XML documents into one Word 2007 XML document.

2009-04-14T03:31:41Z

Here are the steps to merge the documents.

Step 1:

Open a new Microsoft Word 2007 document and type

A
B
C

Save the document to C:\Source.xml. Please change the “Save As Type” to “Word XML Document”.

Step 2:

Open a new Microsoft Word 2007 document and type

D
E
F

Save the document to C:\ Destination.xml. Please change the “Save As Type” to “Word XML Document”.

Step 3:

Open Source.xml in Visual Studio and add a package part to hold the content to be merged. Please note that content type is being used i.e. application/xml.

<pkg:part pkg:name="/word/embed/destination.xml" pkg:contentType="application/xml">

<pkg:xmlData>

</pkg:xmlData>

</pkg:part>

Step 4:

In Source.xml, add a relationship in document.xml.rels section.

Please note that value of the Target attribute should be the same as specified in step 3 for pkg:name attribute.

Step 5:

Please specify the following element in document.xml. This element should appear where you would like to see the merged data.

<w:altChunk r:id="afChunkId1" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"/>

Step 6:

Now open destination.xml, copy everything except the processing instructions and paste in between <pkg:xmlData> element specified in step 3 in Source.xml. Please note that you can also merge the Word 2003 XML document by just copying the XML except the processing instructions and pasting in between <pkg:xmlData> element.

Step 7:

Save Source.xml and open it in Word and you will see that data is merged.

Reference Links
=========================

Please download the ECMA-376 1st edition Part 4 from the following site. The specification for Altchunk is explained in the 4^th part.
http://www.ecma-international.org/publications/standards/Ecma-376.htm
Leveraging content in other formats
http://blogs.msdn.com/brian_jones/archive/2007/01/17/leveraging-content-in-other-formats.aspx

The following link explains as how Altchunk element can be used to merge the Open XML documents using Open XML SDK.

Creating Documents by Using the Open XML Format SDK 2.0 (Part 3 of 3)
http://msdn.microsoft.com/en-us/library/dd469465.aspx
How to Use altChunk for Document Assembly
http://blogs.msdn.com/ericwhite/archive/2008/10/27/how-to-use-altchunk-for-document-assembly.aspx
AltChunk Class (DocumentFormat.OpenXml.Wordprocessing)
http://msdn.microsoft.com/en-us/library/documentformat.openxml.wordprocessing.altchunk(office.14).aspx

Word 2003 SP3 throws intermittent error - There is insufficient memory. Save the document now

2009-03-16T16:07:00Z

Summary

An application automating Word 2003 SP3 intermittently throws below exception from Open method:

"System.Runtime.InteropServices.COMException (0x800A13E9): There is insufficient memory. Save the document now."

Symptoms

Error Message: There is insufficient memory. Save the document now

Cause

This is a generic error message which can arise due to multiple reasons (most of the time, it’s due to an actual memory issue), but in this specific case, error arises when there are a lot of word temporary files.

Resolution

1) Delete temporary files from %Temp% folder (Go to start->Run, type %Temp% and hit enter).

2) Delete temporary files from <Temporary Internet Files>\Content.Word folder. "Temporary Internet Files" folder can be found by opening "Internet Explorer->Tools->Options->General Tab->Browsing history->Settings->View Files".

Note: Word writes temporary files to above folders and sometimes these files cannot be deleted due to abnormal exit of Word instance.