PowerPoint Presentation from SharePoint Content via VSTO

In this article, we will create a PowerPoint Presentation using content of the lists from a SharePoint site.

Windows SharePoint Services (WSS) provides an easy way to create workspaces where information can be collected to share information among users working toward a common goal. This goal may be of different types, including making presentations for an event, execution of a business process, or even materials for a project. Always, organizations build presentations as an output of this collaboration or as a part of regular reporting on the status of the team. Microsoft PowerPoint provides users with a powerful platform to make presentations. However, the presentation creator expend to much effort and time to locate, duplicate and organize this information into the presentation. The presentation's authors are likely retyping, cutting, and pasting or otherwise manually importing content. But this way is somehow error prone and time consuming. So, in this article we not only look for reducing the effort; we also look for increase of accuracy. This article details how we can extend PowerPoint to provide a tool that has capability of building slides populated with content stored in a SharePoint site.

To understand the how this will be useful, let's take an example. Almost any time there is a chain of command in any organization; people farther down are always summarizing and reporting up. For example, in the Software Development firm, there is a project which is of long term work and needs every week a meeting of the work and presentation of the work by PowerPoint slide show. So, they prepare a SharePoint Meeting workspace for their need to be fulfilled and keep their agendas for meeting, the members of the meeting and much other information. Every week, the presentation creators get their agenda information from the site and create presentation in PowerPoint. He does his work by copying and pasting and sometime manually importing content. Also there are so many types of examples are there in the commercial world. So, in this article we will see how to reduce this type of work by providing some handy tool to PowerPoint which will fetch the SharePoint meeting agendas to the PowerPoint and create the slides.

Example Overview

For this type of solution, we will extend Microsoft PowerPoint to provide a tool for the author to import data from a SharePoint site. We have focused our efforts to build a briefing presentation made of the items which are imported from a typical meeting workspace in WSS. Once the tool has been launched, it will examine a site provided by user to see if it contains an objectives list, a list of agenda items, or any slide libraries. The objectives list and agenda lists are default list templates for meeting workspace in SharePoint. In this example, we also have included slide library because users who are a part of this collaboration may have built slides of their own that may be included in our briefing output presentation. Once the site has been crawled, the custom import tool will give a wizard process that offers the user to build slides for the content it finds in the site.

This application is flexible enough so that the presentation author can build slide in any presentation he is working on. To fulfil this requirement, the solution will be an application-level add-in. As an add-in this tool will always be available to the authoring user from within PowerPoint. The controls for this tool will be added to the Microsoft Office ribbon interface as the launching point of the tool. From the ribbon, the author will be able to launch the tool, which presents itself as a custom task pane. This pane provides the user with the wizard experience of steps and prompts, building slides as per current presentation instructions.

As the wizard runs, it asks the user about if he wants to have a presentation slide built for the content it finds in the site. If the user goes for it, the add-in will query the SharePoint site for the objective list items and place them in a new slide as a bulleted list. Same way, if the user selects to build slide from the agenda, the add-in will query the SharePoint site for the agenda list items and place them in a new slide displayed within a table. Also, the add-in will populate the notes page of the slide with details such as owner of the agenda item and notes that are contained in the SharePoint site. At the last step, the add-in will display a list of slide libraries it finds on the site as the links. Each link will open the library in the browser so that the user can select slides to import into the presentation he is working.

Walking through the example development

In the following section we will details the main elements of the solution. The walkthrough will guide you how to get started with Visual Studio to create the briefing PowerPoint add-in. We will also see how we can extend the Office ribbon interface using VSTO. The wizard process will also be explained so you can see how it is implement. Also, the walkthrough will explain the work that goes into building each of the PowerPoint slides for our briefing. This includes creating new slides, putting content as a bulleted list, inserting and populating a table, placing content on a slide’s notes page and linking the SharePoint slide libraries.

Creating the Project

Using Visual Studio to build a PowerPoint add-in project is very easy by using VSTO’s project types. Simply open Visual Studio 2008 and select to create new project. Under the Visual C# language node, expand the Office node and select 2007. This will display Office 2007 VSTO project templates. Select PowerPoint 2007 Add-in. Name the project and solution BriefingCS. Note that the dropdown list of framework selection has the value .NET Framework 3.5.

Once the project is created, you should see few files which are already created by the project template in the Solution Explorer. The PowerPoint node, that when expanded, will have a code file named ThisAddIn.cs. This file is the main entry point for our add-in. In this file a developer can write code for events at the add-in scope. These events include Startup and Shutdown. There are also PowerPoint application-level events such as SlideShowBegin and SlideShowEnd. These events are accessible by registering the events to the Application object in code.

Ribbon Customization

First, we need a way for the user to launch our briefing application from within PowerPoint. To provide this starting point, we will focus our attention on the Microsoft Office ribbon. The ribbon interface occupies the top portion of most of the Office applications and provides a different experience then the layered menus and toolbars of previous Office products. This interface provides a simple user experience by improving the organization of commands and providing a more graphical representation of options.


In earlier versions of Office, developer spent enormous efforts and time in writing code for custom CommandBars object to create new buttons, extend menus, and hide existing options and other customizations. By using compiled code to make these changes, developers found that the code was not portable and reusable across different Microsoft Office applications. So, the ribbon interface provides the developer with an improved programming mode for customizing it, in addition to providing enhanced end user experience.


The biggest difference in the ribbon programming mode is that customizations to the UI are done using XML. Using a custom XML file, a developer can manipulate the ribbon interface, controlling its tabs, groups and controls. This customization includes adding as well as hiding the controls in the ribbon. As the customizations are XML based, they are reusable in different projects and different Office applications. In addition to XML declarations, a class that serves the XML also provided and includes event handlers for running code in response to user interaction. VSTO does most of the plumbing of this automatically, allowing us to focus just on the customization and saves us from much more labour.

To implement the ribbon add-in in our project, first add a new item. From the Add New Item dialog box, select the Ribbon(Visual Designer) support template and name the file RibbonAddin1.cs. When the process is complete, Visual Studio will have added actually three files, RibbonAddin1.cs, RibbonAddin1.designer.cs and RibbonAddin.resx. And opens the RibbonAddin.cs in designer and the designer looks like below image. Now in designer select the tab named “TabAddIns (Built-In)” and change its Label to “Add-Ins” from the property window. Now in the designer select the “group1”  and set its Label property to “SharePoint”. Add a ToggleButton from the toolbox to this group box. Set the ToggleButton’s Label property to “Briefing” and set its image property to the appropriate one. Also set its ControlSize property to “RibbonControlSizeLarge”. Now double click that toggle button to generate its click event handler int RibbonAddIn.cs file. There in that event handler method write the following code:

Globals.ThisAddIn.CustomTaskPane.Visible = toggleButton1.Checked;

This code will take the responsibility of hiding and showing our custom task pane for our application. Of course, we need the task pane, which is nothing else but a user control named ucBriefingTaskPane. You need to add a blank user controls with the name ucBriefingTaskPane if you want to simply test the application at this stage. The following code snippet shows you how the add-in creates an instance of the custom task pane.

private CustomTaskPane _customTaskPane;
         public CustomTaskPane CustomTaskPane
        {
            get { return _customTaskPane; }
            set { _customTaskPane = value; }
         }

        private void ThisAddIn_Startup(object sender, System.EventArgs e)
        {
            _customTaskPane = Globals.ThisAddIn.CustomTaskPanes.Add(new ucBriefingTaskPane(), "Custom Briefing");
            _customTaskPane.DockPosition = MsoCTPDockPosition.msoCTPDockPositionRight;
            _customTaskPane.Width = 250;
        }

By adding the ribbon support to the project, the user now has a way to start the briefing application, which will provide the user with a series of steps for building PowerPoint slides from SharePoint site content.

To test the application and to see how your RibbonAddin1 is integrated with the PowerPoint application, just press F5 or Click the Debug button the top toolbar. This will start the PowerPoint and adds the Add-Ins tab at the last in the PowerPoint’s Ribbon bar, as show in below image.

Clicking on the Briefing button in the toolbar will show you the CustomTaskPane at the right site, which we added by the previous code.

Implementation of the Task Pane and Wizard Steps User Controls

Our solution presents its user interface through a custom task pane that loads to the right-hand side of PowerPoint’s application window. The wizard experience for the user is a series of steps. The required logic and actions for each of the steps is written into a single user control. Primary goal of each step is as follows.
1. Get the URL of the SharePoint site and check its contents
2. Building a presentation slide for the items in the objectives list
3. Building a presentation slide for the items in the agenda list
4. Displaying a list of slide libraries so the user can import presentation slides from the site.
5. Conclusion message.

The user may not need to follow or complete all the steps. Based on the crawl of the site in step 1, it may be possible that the wizard may skip certain subsequent steps. For example, if the site does not contain any objective list, the user should not even be exposed to step 2. For this reason, our architecture compartmentalizes each of the steps into its own user control. Each step user control is responsible for displaying an interface, gathering input from the user, doing its work and reporting back to parent. The task-pane control serves as a controller, taking on the responsibility of orchestrating the step controls and collecting the information they report back that may be necessary later in the process.


To provide uniformity to the step user controls, we defined an object interface with some common elements that each control must implement. This makes it easier for our task-pane controller to interact with them since it can be guaranteed that the elements of the interface are a part of the step control.

delegate void CompletedEventHandler(object sender, EventArgs e);
public interface IWizardStep
{
ucBriefingTaskPane Parent { get; }
event CompletedEventHandler Completed;
void WorkComplete();
void Start();
}

The IWizardStep interface requires that each step user control have the following:
• A read only property that provides a reference to the task pane which is parent of it.
• An Event named Completed that will be used to inform the parent task pane that a particular step has done its work and the task pane should move on. The Completed event is created by using CompletedEventHanlder delegate.
• A WorkComplete() method used to support multithreading so that the step control can execute its work on a separate thread than the user interface one.
• A Start() method that will be called by the task pane, telling the step control that it is its turn in the process.

The task pane controller is a no user interface user control. It is simply a container control that will organize and manage step controls that present them to the user. An instance of each of the Stepn controls named wizard (where n represents the sequence number) is loaded into its controls collection. As these are loaded from code, each has its visibility off by default. In the task pane’s load event, the instance wizard1 is loaded first for start-up. Also the task pane maintains some information obtained from a step control that will be used later in the process. This includes the URL of the SharePoint site entered by user, information about whether it had any of the lists it could build content from, as well as a collection of information about the slide libraries contained in the site.


WizardStep1: Examining the Site
The wizardStep1 control is responsible for examining the SharePoint site specified by URL the user entered. For our example, the wizardStep1 control is looking to see if the site contains a list named “Objectives”, a list named “Agenda”, and information on any slide libraries. For our example, we simply created a meeting workspace to act as a test environment and populated it with some content. The objects and agenda lists are there already, created by site template by default, but you have to create at least one slide library if you want to test. Following are the steps to create a slide library to your site:

1. Go to your meeting workspace site.
2. From the Site Actions menu, choose Create.
3. In the Libraries group, click the Slide Library link.
4. Enter a suitable name for the slide library, for example, Meeting Slides.
5. Click Create button.
6. You will be redirected to a page that displays the library’s items.
7. For testing purpose, you need to upload a sample PowerPoint 2007 presentation.


Back to our step controls, this step control is designed to first ask the user for site Url of the meeting workspace. When user enters and clicks Next button, the step control tries to discover information about the lists and libraries contained in the site. SharePoint’s web services are used to get information and content of the lists in this example. To add a web reference in the project, go through the following steps.

1. In Visual Studio’s Solution Explorer window, right-click the Project name and select Add Web Reference or Add Service Reference. (If you have added any web service reference to the project earlier, then the Add Web Reference will be available otherwise select Add Service Reference.)
2. If you have Add Web Reference option and selected it then directly jump to the step 5.
3. Click Advanced… Button.
4. Click “Add Web Reference…” button.
5. Type the URL of the meeting workspace with a _vti_bin/lists.asmx ending. SharePoint’s web services are called by adding the _vti_bin folder on to the end of any site URL. This enables the web service call to discover its context and return answers specifically to the site referred to by the rest of the URL. So, for our example the URL would be like http://vpc2003:1351/_vti_bin/lists.asmx.
6. Click Go. The window below the URL will display a listing of all the methods in the Lists Web service.
7. In the Web reference name text box, change the name to WSLists.
8. Click Add Reference.


Just as the web reference added, following is the code for the Next buttons click event.

this.UseWaitCursor = true;
            WSLists.Lists listService = new BreifingCS.WSLists.Lists();
            listService.Credentials = System.Net.CredentialCache.DefaultCredentials;
            listService.Url = this.txtSiteUrl.Text.Trim("/".ToCharArray()) + "/_vti_bin/lists.asmx";
            listService.GetListCollectionCompleted += new BreifingCS.WSLists.GetListCollectionCompletedEventHandler(listService_GetListCollectionCompleted);
            listService.GetListCollectionAsync();

One more thing to keep in mind that, when we examine the site content, this work does not interfere with the PowerPoint application’s user interface. Therefore, this work will be set up to run on a different thread. To support this, the Next button’s event handler first changes the user’s cursor to the WaitCursor. The web-service proxy is then configured to make a call under the user’s security context and to access the service through the site URL. The GetListCollectionAsync method is called so that the current thread will not wait for a response. The listService_GetListCollectionCompleted method of this step user control will be called when it receives its response.


Once the service has returned a response to the briefing add-in application, our code will execute and examines the response looking for the Objectives and Agenda lists as well as any slide library. The response from the web-service call is a string of XML that includes references to many different namespaces. Therefore this XML is loaded in XmlDocument object and XmlNamespaceNavigator is set up to easily search for the information. See the following code snippet.

XmlNode result = e.Result;
                XmlDocument doc = new XmlDocument();
                doc.LoadXml(result.OuterXml);
                XmlNamespaceManager namespaceMrg = new XmlNamespaceManager(doc.NameTable);
                namespaceMrg.AddNamespace(ucBriefingTaskPane.SharePointNamespacePrefix, ucBriefingTaskPane.SharePointNamespaceUri);
                XmlNodeList agendaListNode = doc.SelectNodes("//sp:List[@Title='Agenda']", namespaceMrg);
                 if (agendaListNode == null || agendaListNode.Count == 0)
                    Parent.HasAgendaList = false;
                XmlNodeList objectiveListNode = doc.SelectNodes("//sp:List[@Title='Objectives']", namespaceMrg);
                 if (objectiveListNode == null || objectiveListNode.Count == 0)
                    Parent.HasObjectiveList = false;
                XmlNodeList slideLibraries = doc.SelectNodes("//sp:List[@ServerTemplate='2100']", namespaceMrg);

After gathering all the required information, this step wraps up its work and at the end the WaitCursor is turned off and the parent task pane invokes a delegate referring to the WorkComplete method. By using the this.Parent.Invoke() technique, we are returning control back to the original thread, leaving the one that performed the background processing.


WizardStep2: Building Objectives
The WizardStep2 user control is responsible for building a presentation slide containing the content in the SharePoint site’s Objectives list. The parent task pane will move control to this step by calling its Start method. In this method, first a check to Objectives list in the user’s site is done. If it did, the step makes itself visible, exposing its user interface to the user. If it didn’t this control simply calls WorkComplete to raise its Completed event, skipping itself and moving on to the next step in the process. Assuming that your site contains Objectives list, the user is presented with two options. The first is for the application to build a presentation slide that contains a bulleted list of the objective items from the site. The other option is to skip this feature and move on to the next step.


If the user chooses to have an Objectives slide built, the add-in again uses SharePoint’s lists.asmx web service and at this time the GetListItems method is used to get the objective list items. Same here, the asynchronous implementation of this method is used to prevent the main thread waiting for results. Below code snippet shows how the objective items are get using lists.asmx web service.

WSLists.Lists listService = new BreifingCS.WSLists.Lists();
            listService.Credentials = System.Net.CredentialCache.DefaultCredentials;
            listService.Url = Parent.SiteUrl + "/_vti_bin/lists.asmx";

            XmlDocument doc = new XmlDocument();
            XmlNode nodeQuery = doc.CreateNode(XmlNodeType.Element, "Query", "");
            XmlNode nodeViews = doc.CreateNode(XmlNodeType.Element, "ViewFields", "");
            XmlNode nodeQueryOptions = doc.CreateNode(XmlNodeType.Element, "QueryOptions", "");
            nodeQueryOptions.InnerXml = "<IncludeMandatoryColumns>FALSE</IncludeMandatoryColumns>";
            nodeViews.InnerXml = "<FieldRef Name='Objectives'/>";
            nodeQuery.InnerXml = "";

            listService.GetListItemsCompleted += new BreifingCS.WSLists.GetListItemsCompletedEventHandler(listService_GetListItemsCompleted);
            listService.GetListItemsAsync("Objectives", null, nodeQuery, nodeViews, null, nodeQueryOptions, null);

Once the GetListItemsAsync method is received its results, it transfers control to the GetListItemsCompleted method. Once the results are separated from other XML nodes, returned in the response, by using each object item a slide is created by the following way.

Microsoft.Office.Interop.PowerPoint.Presentation presentation =
                    Globals.ThisAddIn.Application.ActivePresentation;
                Microsoft.Office.Interop.PowerPoint.Slide slide = presentation.Slides.Add(presentation.Slides.Count + 1,
                    Microsoft.Office.Interop.PowerPoint.PpSlideLayout.ppLayoutText);
                slide.Shapes[1].TextFrame.TextRange.Text = "Objectives";
                StringBuilder sb = new StringBuilder();
                foreach (XmlNode node in objectiveNodeList)
                 {
                      sb.Append(node.Attributes["ows_Objective"].InnerText);
                    sb.Append(Environment.NewLine);
                }
                slide.Shapes[2].TextFrame.TextRange.Text = sb.ToString();
                 Globals.ThisAddIn.Application.ActiveWindow.View.GotoSlide(slide.SlideIndex);

To create the slide, the code obtains a reference to the user’s active presentation and uses its slide collection’s Add method. The Add method takes 2 parameters: the index of the new slide and the layout of the slide. In this case we want to add the slide at the end of the presentation and the layout should be the one that has only a title and a text box. With the slide created, the content is placed on it by accessing its different shapes. As per our selected layout, two shapes need attention. The first is at index one and it represents the title of the slide. This is set to “Objectives”. The second shape, at index two, is populated using a StringBuilder, having each objective separated by a carriage return. Placing the carriage-return character is what gives us each objective as a bullet item. And at last, the new created slide is made active one.

WizardStep3: Building Agenda Items

The wizardStep3 control is not so different than the wizardStep2. In its start method, it also decides whether it should show itself or not. Instead of simply building another bulleted list, this slide presents the agenda items in a PowerPoint table while providing more-detailed content in the Notes portion of the slide. To get the slide set up for a table, the layout used in the Add method is ppLayoutTable. After we set the title of the presentation slide, the table is added by accessing the slide’s Shareps collection and calling its AddTable method. See the following code snippet:

Microsoft.Office.Interop.PowerPoint.Presentation presentation =
                    Globals.ThisAddIn.Application.ActivePresentation;
                Microsoft.Office.Interop.PowerPoint.Slide slide = presentation.Slides.Add(presentation.Slides.Count + 1,
                    Microsoft.Office.Interop.PowerPoint.PpSlideLayout.ppLayoutTable);
                slide.Shapes[1].TextFrame.TextRange.Text = "Agenda";
                Microsoft.Office.Interop.PowerPoint.Shape tblAgenda = slide.Shapes.AddTable(agendaNodeList.Count, 2, -1, -1, -1, -1);
                tblAgenda.Table.Columns[1].Width = 200;
                tblAgenda.Table.Columns[2].Width = 400;
                tblAgenda.Table.FirstRow = false;

The result of our efforts is a slide that presents the time and title of each agenda item in a nicely formatted table.


WizardStep4: Integration with Slide Libraries
The step 4 user control is responsible for informing the user of the slide libraries that exists in the SharePoint site. A slide library is a new SharePoint library type that allows users to work on individual slides. This granularity allows for a great collaboration experience as users are able to work on just their portion while others edit their own portions simultaneously. The slide library also promotes slide reuse because these slides can be imported into other decks. Our assumption with this example is that the meeting workspace has at least one slide library and that there are existing slides there that should be imported into this presentation.

Like other steps, the step 4 also check if at least one slide library was discovered previously and shows itself only if that is the case. This control’s Start method includes a call to the ListOutSlideLibrariesLinks method. This method populate a panel with LinkLabel controls for each of the slide library in the site.

private void ListOutSlideLibrariesLinks()
        {
            pnlLinks.Controls.Clear();
            LinkLabel[] linkLabels = new LinkLabel[Parent.SlideLibraries.Count];
            for (int i = 0; i < Parent.SlideLibraries.Count; i++)
            {
                linkLabels[i] = new LinkLabel();
                linkLabels[i].Location = new Point(5, 25 * i);
                linkLabels[i].LinkClicked += new LinkLabelLinkClickedEventHandler(ucWizardStep4_LinkClicked);
                linkLabels[i].LinkBehavior = LinkBehavior.AlwaysUnderline;
                linkLabels[i].Text = ((LibraryItem)Parent.SlideLibraries[i]).Name;
                LinkLabel.Link link = linkLabels[i].Links.Add(0, ((LibraryItem)Parent.SlideLibraries[i]).Name.Length);
                link.LinkData = Parent.SiteUrl + ((LibraryItem)Parent.SlideLibraries[i]).Url;
             }
             pnlLinks.Controls.AddRange(linkLabels);
        }

As per above code, linkControls is an array of LinkLabels containing enough controls for the number of slide libraries in the site. Within the loop, a new LinkLabel control is created for each slide library. The LinkLabel’s LinkBehavior is set to always present its text as underlined, and the actual text value is set to be the name of the slide library. When the user clicks on one of the LinkLabels, our event hanlder responds by opening the browser and directing the user to the URL of the slide library. This event handler launches the browser automatically by using the System.Diagnostics namespace and starting a process with the URL as a parameter. Once in a browser, the user will be able to use the out-of-the-box functionality of selecting slides and importing them to the current presentation. To perform this operation, the user must select the check boxes next to the slides he wants to import and click the Copy Slide to Presentation button. The user is then asked if he wants to send the selected slideds imported into the presentation we have been constructing. Note that there is also an option to receive notifications if the slide in the site were to change after this import has done. If that’s selected, each time the user opens the presentation, PowerPoint will check to see if the souce slide has been modified since the last import. If so, the user will be alerted and asked if he wishes to update the presentation.



Though there is a step5 user control, this is a last step in which presentation slides are contructed. The last step user control simply informs the user that he has completed the briefing application and that he can close the task pane by clicking the button in the ribbon user interface.

You can download the souce code for this example from here.

By Jatin Prajapati   Popularity  (4078 Views)
Picture
Biography - Jatin Prajapati
I think, most of the people are interested only in answers so no Biography provided... Want know more just write me at jatin.prajapati.er@gmail.com