Creating a dynamic site page banner using SharePoint and Silverlight


How to create a dynamic banner for SharePoint 2007/2010 site pages to surface images stored within SharePoint while also making it easy for site authors to upload their own images to be displayed in the banner rotation.


  • Develop a Silverlight application to dynamically display images stored in any standard SharePoint 2007/2010 picture library.

  • Provide an easy way to configure which picture library is used to display the banner images using the Silverlight application initParams. 

  • Use the content editor web part to add the dynamic banner to SharePoint 2007/2010 site pages.




· Easy for users to add new images to the banner.

· Works on existing SharePoint 2007/2010 picture libraries.

· Easy to deploy using Silverlight and the SharePoint content editor web-part.

· All files can be stored in SharePoint.

Download Files

Link to XAP file, test page, and content editor web-part you can use to add this functionality to your Silverlight enabled SharePoint 2007/2010 site.

Installation and Configuration of Silverlight files


Have fun.

Did you know? Silverlight Client for Facebook download available

Excerpt from

Here is an impressive list of Silverlight 4 features that the Facebook application leverages:

  • Out-of-browser support—fully trusted with offline capability
  • Hosting HTML content interactively—with a number of Facebook like features you’d expect
  • Local Device access (webcam)—Add a photo to a FB post using your web camera on your computer
  • Rich-Text control—distributed throughout the application
  • Embedding alternative media content—all video in FB can be played in the application
  • Desktop notifications—for status updates, etc.
  • COM integration (with Microsoft Outlook) on the Windows platform—Outlook integration with FB events and generating emails
  • Right-click—to uninstall the application and the outlook example above.
  • Drag-n-drop—pictures straight from your computer to the application
  • Window control—distributed throughout the application
  • Animations–and let’s face it—what good XAML based app doesn’t have gratuitous animations


FYI: I am just getting around to installing this and will have a follow-up post shortly.

Have fun!


Using SharePoint Designer and Silverlight to embed Silverlight applications directly into your SharePoint blog posts

We have been looking at ways to increase the discoverability of internally produced video content and rich user experiences developed on Silverlight currently stored in various document libraries throughout our SharePoint intranet/extranet.  One area of particular interest is finding a way to easily incorporate rich user experiences and streaming video directly into individual blog posts taking advantage of the the built-in commenting form provided in the SharePoint blog template. 

One challenge has been finding a "start small" approach to providing the benefits of streaming the video content vs. downloading from document libraries without the need to provision large media servers and associate infrastructure in the short-term.   Another challenge as been finding an approach to surface our rich user experiences developed on Silverlight on our internet-facing site as well as our intranet/extranet environment. 

To address these efforts we recently customized a standard SharePoint blog template using SharePoint Designer to display both streaming video content and Silverlight 2 applications we currently have stored on the Silverlight Streaming Service

The only technical requirements for this solution are that you have access to edit the blog in SharePoint Designer, a free Silverlight Streaming account set-up with your Windows Live Id, and upload at least one video or Silverlight application to the service for use in your blog post. 


Blog Home Page

Features: Modified layout, video and/or Silverlight application plays inline, blog title linked to full post page, caption linked to full screen play.


Full Post Page

Features: Video or Silverlight application plays inline, full screen link.


Example short video:



  • Modified layout.
  • Continued ability to post regular blog posts. 
  • Ability to embed videos stored on Silverlight Streaming Service directly into blog posts.
  • Ability to embed your own custom Silverlight applications directly into blog posts.
  • Ability to categorize video posts.
  • Ability to comment on video posts.
  • Makes use of XSLT and CSS for customizations-no custom javascript to deploy or maintain.
  • Ability to add functionality to existing blogs.
  • Ability to further customize via centralized custom XSLT files and custom CSS.
  • Silverlight streaming provides metrics/reporting on downloads, streaming data, etc.  

What is the Silverlight Streaming Service?

Microsoft® Silverlight™ Streaming by Windows Live™ is a companion service for Silverlight that makes it easier for developers and designers to deliver and scale rich media as part of their Silverlight applications. The service offers web designers and developers a free (*) and convenient solution for hosting and streaming cross-platform, cross-browser media experiences and rich interactive applications that run on Windows™ and Mac. Combined with the ability to create content with Microsoft® Expression and other 3rd party tools, web designers and content publishers wishing to integrate Silverlight applications into their online properties can enjoy complete control of the end user experience. 

More details and sign-up free here

Can I use my existing .wmv video files? 

Yes, there are some exceptions and size restrictions but providing you have a valid Windows Live ID account you can upload your .wmv video files directly to the Silverlight Streaming Service using the Manage Videos, Upload Videos feature.  For added features check out Expression Encoder 2 for encoding your videos to specific needs.

Can I use my existing Silverlight 2 .xap files?

Yes, there are some exceptions and size restrictions but providing you have a valid Windows Live ID account you can upload your Silverlight .xap files directly to the Silverlight Streaming Service using the Manage Applications, Upload Applications feature.  For added features check out Expression Blend 2 for designing Silverlight applications without code. 

What SharePoint Designer Customizations  do I need to make to add this functionality to my existing SharePoint blogs?

We added three new site columns on our blog’s post list to allow users to add their own Silverlight Streaming videos and applications and a caption when creating a new post.

    • SilverlightStreamingServiceApplicationUrl (Text Field: Multiple Lines of Text, Plain Text)
    • PostImageCaption (Text Field: Muliple Lines of Text, Rich Text)
    • PostImageUrl (Text Field: Single Line of Text, Plain Text)


Download source custom XSLT files and CSS file here

We modified the default.aspx and post.aspx pages to use a customized version of each XSLT that both reformats the layout and incorporates an iframe to display the user-provided SilverlightStreamingApplicationUrl since the default SharePoint editing controls strip out any iframe, embed, or script references.   To accomplish this we first saved back-up versions of our default.aspx and post.aspx pages the opened each in SharePoint Designer in design mode and converted the appropriate dataview web-parts to XSLT (right click, convert to XSLT option)

    • Modifications to Default.aspx
      • Upload the provided default.xsl to the blog’s root folder
      • Convert the post dataview web-part to XSLT
      • Apply the custom XSLT: From the dataview web-part’s Common Data View Properties pane choose DataView Properties, then select the XSLT Source tab and browse to the default.xsl file.
    • Modification to Post.aspx
      • Upload the provided post.xsl to the blog’s root folder
      • Convert the post dataview web-part to XSLT (Ignore @Author error message)
      • Apply the custom XSLT: From the dataview web-part’s Common Data View Properties pane choose DataView Properties, then select the XSLT Source tab and browse to the post.xsl file.
      • Create a filter and parameter to filter the post DVWP by id : From the dataview web-part’s Common Data View Properties pane choose Filter, if not displayed create a new URL parameter for ID and set the value to [id]

We also created a custom version of the blog templates core.css and referenced from the default.aspx and post.aspx pages as a link:

Add custom style sheet reference in default.aspx:

<asp:Content ContentPlaceHolderId="PlaceHolderAdditionalPageHead" runat="server">

<SharePoint:RssLink runat="server"/>

<link rel="stylesheet" type="text/css" href="customblog.css">


Add custom style sheet reference in post.aspx:

<asp:Content ContentPlaceHolderId="PlaceHolderAdditionalPageHead" runat="server">

<SharePoint:RssLink runat="server"/>

<link rel="stylesheet" type="text/css" href="../../customblog.css">


Once my blog is configured how do I create new blog posts that include this new functionaility? 

Simply create you blog post as normal including your post title and post body. 

Then fill in the SilverlightStreamingApplicationUrl and PostImageCaption fields and save your post as normal.  (*see Obtaining the SilverlightStreamingApplicationUrl for details on the URL to use)


*Obtaining the SilverlightStreamingApplicationUrl:

From Silverlight Administration Home Upload your .wmv video or Silverlight 2 application to the Silverlight Streaming Service

From Silverlight Administration Home select the link to the video or application.

From Method 1: Embed the video into a web page obtain the embed link for the video or application



Important: Copy only the URL inside the iframe (example in red) . 

<iframe src="" scrolling="no" frameborder="0" style="width:500px; height:375px"></iframe>


What’s next?

  • Investigate how to add YouTube and MSN videos into the posts.
  • Simplify deployment for new blogs via site template (.stp file)
  • Create custom site definition with custom columns included.
  • Create SharePoint application page to allow users to upload videos/display in blog post in one step. 
  • Investigate using Silverlight Streaming Services API and existing solutions to provide reporting on #downloads, video streaming data, etc.




Use SharePoint and Silverlight to display a summary of SharePoint blog posts on any site page


We have been investigating ways on our intranet at Allyis to surface information via a more automatic and less manual process through various features and also to Implement multiple ways for discovering data/information across the site.  One area in particular we have been looking for improvement has been to increase the discoverability of our leadership blogs and encourage employees throughout our organization to blog as as way to increase collaboration and information sharing. 

As a way to address these efforts we recently developed and deployed a suite of web-parts (one of which we call the BlogRollUp web-part) which displays details on the most recent post made to any of our SharePoint blogs.  The web-part can be added to any site page, configured to point to a specific blog, and uploaded into the web-part gallery for others to use as well. 


Screenshot (Single Post Version): Screenshot (Multi-Post Version)


  • Displays blog title as a hyperlink to the original full post.
  • Displays the first 215 characters of the post body as an excerpt.
  • Displays an image for the blogger or blog.
  • Displays the post’s category as a hyperlink to view all similiar posts.
  • Displays the number of comments as a hyperlink to the comments page.
  • Displays an alert icon hyperlinked to the blog’s alert page.
  • Highlights background on mouseover.
  • Users can configure the web-part settings. 


Technical Approach:

  • The user-interface was designed and developed entirely using Microsoft Expression Blend, Silverlight, and Visual Studio 2008. 
  • Custom SharePoint web-part to host the Silverlight application which allow users to configure which blog, blogger image, and alerts link from the web-part properties pane directly. 
  • The Silverlight application code uses the initParams provided from the webpart or HTML test page and the URL protocol to access the blog’s post list directly.
  • The web-part can be configured once and easily exported from and imported to the webpart gallery and added to any site page on any site collection.  
  • The Silverlight application was deployed into a SharePoint document library for ease of future updates. 

Advantages of using Silverlight:
Rich support for animation, rich set of controls, good development tools, i.e. Microsoft Expression Blend and Visual Studio 2008, and all the advantages of coding in C# with a simple deployment process. You can even copy the Silverlight XAP files (essentially a compressed zip file with all your code) into a SharePoint document library and run from there along with a simple HTML page.

Deployment Methods

Deployment using only a document library and a content editor web-part without the need to install server-side code and as such administrative access typically not required.

  1. Download the Visual Studio solution .zip and extract the files.
  2. Download

  3. Create a folder named ClientBin in a SharePoint document library to store the Silverlight application. 
  4. Locate the BlogRollUp_Web\ClientBin\BlogRollUp.xap file and copy into your new ClientBin folder
  5. Locate the BlogRollUpTestPage.html, update the initParams to use the settings for your particular blog including siteurl, imagepath, listid, and alerturl. 
  6. Copy the updated BlogRollUpTestPage.html file to the root of your new document library.
  7. On a site page add a content editor web-part and reference the BlogRollUpTestPage.html file inside an iframe. 
  8. Export the now pre-configured web-part to your desktop and upload back into the webpart gallery with an appropriate name identifying the BlogRollUp webpart so other users can add to their site pages without having to configure themselves. 

Deployment using the custom web-part where server-side code is installed via the .wsp solution file for the webpart and typically requiring administrative access

  1. Download the Visual Studio solution .zip and extract the files.
  2. Download

  3. Create a folder named ClientBin in a SharePoint document library to store the Silverlight application. 
  4. Locate the BlogRollUp_Web\ClientBin\BlogRollUp.xap file and copy into your new ClientBin folder.
  5. Download the .wsp solution file
  6. DownLoad

  7. Install the provided .wsp solution file via stsadm -addsolution
  8. Activate the solution from SharePoint Central Administration or stsadm -activatefeature
  9. Upload the provided webpart .dwp file into your web-part gallery via site setting, web parts. 
  10. Add the web-part to a site page, update the Silverlight web-part settings section with the appropriate .XAP fullpath, siteurl, imagepath, listid, and alerturl for your particular blog
  11. Export the now pre-configured web-part to your desktop and upload back into the webpart gallery with an appropriate name identifying the blogrollup webpart so other users can add to thier site pages without having to configure themselves. 


This is just one way of displaying some pertinent details on recent posts from the blogs dispersed throughout the intranet while also making it easy for users to add to any site page.  Using Silverlight allows .NET developers to develop rich UI in Expression and Visual Studio and store the .xap files in SharePoint document libraries for future updates. 



SharePoint Generic Wrapper for Silverlight with initParams

Here is a freebie…just finished a generic SharePoint web-part to host Silverlight apps inside SharePoint.

There are other  out there for sure but I had a need for a generic one that I could specify any number of initParams from the web-part properties in addition to ones I developed that contained separate wp properties for each name/value pair. 

Using just a single wp property for the initParams allows you handle any number of parameters from any of your Silverlight apps using the same web-part-just set both the XAP source location and InitParams for the appropriate Silverlight application.  nbd but it is easier to deploy just a xap file for every new Silverlight application than having to prop a new web part every time:)


SLViewer SLViewerWP


Web Part Features:

Has a few properties for Silverlight you can set in the web-part properties pane:

Height: sets the SL plugin height (int)

Width: sets the SL plugin width (int)

XAP file location: sets the SL plugin xap file location (string)

Silverlight plug-in id: sets the SL plugin id (string-appended in the web-part code with a GUID to be safe)

InitParams: sets the InitParams for the plugin as one complete name/value pair string (same string you parse on the Silverlight application side as normal)


Deployment Instructions:

  1. Download:
  2. from command line: stsadm -o addsolution -filename [path on your server where you downloaded file]\Silverlight2ViewerWebPart.wsp
  3. From Central Admin go to operations-solutions management-deploy solution
  4. Download webpart file (.dwp)
  5. Go to site settings, web parts, and upload silverlightviewer_web_part.dwp file into web part gallery
  6. (Optional) Download blank Silverlight Application (.xap)
  7. Drop the blanksilverlightapp.xap in a document library or in your SharePoint virtual directory somewhere handy or just use your own xap file and reset the xap file location property of the webpart from the site page. 

System Requirements:

  1. SharePoint 2007 up and running on the server.
  2. Silverlight 2 dll installed in GAC.
  3. MIME types all set in IIS for both .xap and XAML files
  4. Web.config updated with all the Silverlight and AJAX sections. 

Try this link for details on hosting Silverlight on SharePoint (nice post by Karine Bosche)

Coming Soon: I am packaging everything up as a single site feature and maybe even a feature stapler.

have fun:) 


Using LINQ to parse XML data coming back from SharePoint web services

Quick example of using one of the many built-in SharePoint web services to populate a WPF control. 

In this particular instance I am connecting to the SharePoint lists web service Lists.asmx to retrieve data from the list and bind to a WPF listbox control. 
Should be easily ported over to a SharePoint web part or ASPNET web page etc.   No warranties:)


private ObservableCollection<Notification> notifications;
        public void getData()

//hardcoding the list name as the ID for the web service call-feel free to do something more creative:)           

string listId = "Notifications";
            XNamespace s = "";
            XNamespace rs = "urn:schemas-microsoft-com:rowset";
            XNamespace z = "#RowsetSchema";

            string userDisplayName = System.Security.Principal.WindowsIdentity.GetCurrent().Name.Replace(‘\\’, ‘,’);
            string[] userFriendlyNameArr = userDisplayName.Split(‘,’);
            userDisplayName = userFriendlyNameArr[1].ToString();

            lists.Lists ws = new lists.Lists();
            ws.UseDefaultCredentials = true;

            ws.Url = "http://[server]/[site]/_vti_bin/Lists.asmx";
            XElement queryOptions = new XElement("QueryOptions",

               new XElement("IncludeMandatoryColumns", false)


            XElement viewFields = new XElement("ViewFields",

            new XElement("FieldRef", new XAttribute("Name", "ActorName")),

            new XElement("FieldRef", new XAttribute("Name", "ItemTitle")),

            new XElement("FieldRef", new XAttribute("Name", "ItemURL")),

            new XElement("FieldRef", new XAttribute("Name", "ListTitle")),

            new XElement("FieldRef", new XAttribute("Name", "EventTime")),

            new XElement("FieldRef", new XAttribute("Name", "ListType")),

            new XElement("FieldRef", new XAttribute("Name", "ItemType")),

            new XElement("FieldRef", new XAttribute("Name", "ListUrl")),

            new XElement("FieldRef", new XAttribute("Name", "ActorID")),

            new XElement("FieldRef", new XAttribute("Name", "Action"))


           XElement notifications = new XElement("Notifications",

                                   ws.GetListItems((string)listId, "" , null,

                                    viewFields.GetXmlNode(), "", queryOptions.GetXmlNode(), "")


                                     .Descendants(z + "row")

                                     .Select(r =>

                                         new XElement("row",













        private void ProcessResponse(string response)

//using my own custom list in SharePoint as the source-custom fields and all so make sure to use whatever fields are appropriate for your case

XDocument results = XDocument.Parse(response);

            var items = from item in results.Descendants("row")
                        where item.Attribute("ows_ItemTitle") != null
                        orderby (DateTime)item.Attribute("ows_EventTime") descending
                        select new Notification
                            ActorName = (string)item.Attribute("ows_ActorName"),
                            ActorId = (int)item.Attribute("ows_ActorID"),
                            Action = (string)item.Attribute("ows_Action"),
                            ItemTitle = (string)item.Attribute("ows_ItemTitle"),
                            ItemType = (string)item.Attribute("ows_ItemType"),
                            ItemUrl = (string)item.Attribute("ows_ItemURL"),
                            ListTitle = (string)item.Attribute("ows_ListTitle"),
                            ListUrl = (string)item.Attribute("ows_ListUrl"),
                            EventTime = (DateTime)item.Attribute("ows_EventTime"),
                            ListType = (string)item.Attribute("ows_ListType"),
                            ActivitiesText = (string)item.Attribute("ows_ActorName") + " " + (string)item.Attribute("ows_Action") + " " + (string)item.Attribute("ows_ItemTitle") + " " + "into" + " " + (string)item.Attribute("ows_ListType") + " " + "named " + (string)item.Attribute("ows_ListTitle"),


            ActivitiesListView.ItemsSource = items;


//Extension methods credit to Eric White Technical Evangelist for Open XML for these.

public static class MyExtensions


public static XElement GetXElement(this XmlNode node)

            XDocument xDoc = new XDocument();

            using (XmlWriter xmlWriter = xDoc.CreateWriter())


            return xDoc.Root;


        public static XmlNode GetXmlNode(this XElement element)

            using (XmlReader xmlReader = element.CreateReader())

                XmlDocument xmlDoc = new XmlDocument();


                return xmlDoc;



        public static string ToStringAlignAttributes(this XElement element)

            XmlWriterSettings settings = new XmlWriterSettings();

            settings.Indent = true;

            settings.OmitXmlDeclaration = true;

            settings.NewLineOnAttributes = true;

            StringBuilder stringBuilder = new StringBuilder();

            using (XmlWriter xmlWriter = XmlWriter.Create(stringBuilder, settings))


            return stringBuilder.ToString();




Wrap-Up on using Silverlight, SharePoint Lists, and URL Protocol.


Recently I had a client request an animated carousel or filmstrip like player for displaying both images and video on their SharePoint intranet. The idea is to display many images and videos without taking up a ton of screen space in the process. Also, they wanted to be able to manage what images and videos that get displayed via a standard SharePoint list i.e. they could add links and descriptions in the SharePoint list and those would display appropriately in the filmstrip.

When evaluating a technical solution seemed like Silverlight would be the way to go for the filmstrip-Silverlight has built-in animation support, a media player for playing video, a rich set of controls, and good tool support with Expression Blend and Visual Studio 2008. For accessing the links etc. stored in the SharePoint list the SharePoint web service lists.asmx seemed a logical choice.

The catch:

The client’s IT department didn’t support custom ASPNET web applications or web services to be deployed without a huge review process and maybe neverJ The client’s SharePoint was pretty locked down to any custom development.

The resolution:
There is a nifty yet fairly unknown protocol built-in to SharePoint described on MSDN and the SharePoint SDK as the URL Protocol that allows you to query a list directly for all its list items. Plus, you can do this using a simple URL in the browser and also from javascript on the client. I have used this fairly often since back in 2003 when I had to come up with a way to populate a Flash map with SharePoint data so I was familiar with this protocol but not sure it would work in Silverlight.

I broke out my Swiss-Army knife for SharePoint (URL Protocol aka owssrv.dll) and good news-it actually worked! Silverlight can access data from a SharePoint list without the need to have a web service call. Essentially using the same built-in web client classes inside Silverlight designed to access external web pages or files.

So what is the SharePoint URL Protocol?

Excerpt from MSDN:

Embedding a request in a URL is a basic mechanism for issuing a method and its parameters to a server running Windows SharePoint Services.

The syntax for using this mechanism is as follows:


Details for the code below but actually a simple implementation in your Silverlight project using the built-in web client classes commonly used to access external files from Silverlight-in our case we are essentially accessing the SharePoint list as an XML file of sorts.

The technical approach for the solution using Silverlight, a SharePoint list, and the URL protocol:

Using Microsoft Expression Blend for the initial layout and Visual Studio 2008 for the C# code I created an animated filmstrip (a variation of the all too familiar carousel in SilverlightJ) to display thumbnail images of the images and videos along with a main player area to display the larger view of the image/video when the user selected a thumbnail from the animated filmstrip.

Advantages of using Silverlight:

Rich support for animation, rich set of controls, good development tools i.e. Microsoft Expression Blend and Visual Studio 2008, and all the advantages of coding in C# with a simple deployment process. You can even copy the Silverlight XAP files (essentially a compressed zip file with all your code) into a SharePoint document library and run from there along with a simple HTML page.

Advantage of using a SharePoint list as the source data for the filmstrip player

The administrator of the SharePoint list can designate what gets displayed in the filmstrip player automatically via the SharePoint list:

· Designate the initial image/video that loads when the page loads.

· Turn individual items visibility on/off

· Select the appropriate thumbnail image and larger image

· Select the appropriate URL for a video to be played in the video player

Advantages of using the URL protocol to populate the Silverlight filmstrip items

It’s a lightweight HTTP protocol, can be accessed via a simple URL, and does not require web services to access the data in a SharePoint list.

Example of the solution:

Filmstrip player functionality:

· Animated filmstrip displaying thumbnail images based on links provided in the SharePoint list.

· Video player to play embedded .wmv video also based on links provided in the SharePoint list.

· Image viewer to display larger image based on user selection in the filmstrip.

· Main player section hot-linked to external URLs based on links provided in the SharePoint list.

· User controls for the filmstrip animation

· Pause/Play controls that turn on when video is loaded.

Image of application


Live Demo here…

Silverlight Filmstrip Player for SharePoint Demo

Other Potential uses?

  • Could be used on a Real Estate site to dynamically display images/video of the advertised home.
  • A video player for a blog using the blog to collect comments.
  • Basic slide show for a SharePoint document library or to display images from Flickr for instance in your SharePoint.

What’s interesting about this implementation?

Using the URL protocol provides a simple mechanism for accessing SharePoint list data from within Silverlight without the need to add a web service reference.

Using LINQ to XML to parse the returned data from the SharePoint in XML greatly simplifies working with the SharePoint list data in Silverlight once it’s retrieved.    

Using LINQ to XML also simplifies restructuring the data to a standard RSS feed format to use the data from the SharePoint list’s built-in RSS feature as another option.

What’s next on the feature front?

  • Adding the ability for users to leave comments and ratings.
  • Adding the ability for users to upload their own videos.

Example C# code for accessing the SharePoint list in Silverlight:

Silverlight 2 application attached to a ASPNET web project (I don’t host the ASPNET app in SharePoint but easy way to generate the test.html and .XAP file)

public partial class Page : UserControl
        private XNamespace z = "#RowsetSchema";      
        public Page()
            this.Loaded += new RoutedEventHandler(Page_Loaded);
        public void Page_Loaded(object sender, RoutedEventArgs e)
            string sUrl = "http://[server]/[site]/_vti_bin/owssvr.dll?Cmd=Display&List={[listguid]}&XMLDATA=TRUE";
            WebClient sp = new WebClient();
            sp.OpenReadCompleted += new OpenReadCompletedEventHandler(sp_OpenReadCompleted);
            sp.OpenReadAsync(new Uri(sUrl));
void sp_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
            if (e.Error == null)
var items = from item in results.Descendants(z + "row")
                        where item.Attribute("ows_LinkTitle") != null
                        orderby (DateTime)item.Attribute("ows_Created") descending
                        select new FilmFrame
                            ItemTitle = (string)item.Attribute("ows_Title"),
                            ItemLinkTitle = (string)item.Attribute("ows_LinkTitle"),
                            ItemType = (string)item.Attribute("ows_ItemType"),
                            ItemSourceUrl = (string)item.Attribute("ows_SourceUrl"),
                            ItemThumbnailUrl = (string)item.Attribute("ows_Thumbnail"),
                            ItemDescription = (string)item.Attribute("ows_Description"),
                            ItemDisplayFilmStrip = (string)item.Attribute("ows_DisplayInFilmstrip"),
                            ItemCreated = (DateTime)item.Attribute("ows_Created"),
//You can bind to an itemtemplate for a listview directly for simplicity-the specfic example UI above builds the XAML dynamically to provide more

//ListView.ItemsSource = items;

Separate namespace for filmstripitem:
namespace FilmStrip
    public class FilmStripItem
        public string ItemTitle { get; set; }
        public string ItemLinkTitle{ get; set; }
        public string ItemSourceUrl { get; set; }
        public string ItemType { get; set; }
        public string ItemDescription { get; set; }
        public string ItemDisplayFilmStrip { get; set; }
        public DateTime ItemCreated { get; set; }

Things you might want to consider when making use of this example:

The test.html and .xap file is being hosted inside SharePoint.  In this case I just dropped on the SP Site at the root site level via SharePoint Designer.

For a quick way to databind the XML returned from the SharePoint list to XAML I initially used listbox and a data item template.

Rod Stagg
SharePoint Solutions Architect
Allyis Inc. Kirkland Wa

Silverlight Filmstrip Demo

What does it do? 
Displays thumbnail and full size images and plays video. 

Where does it get the data for the images and videos to display/play inline?
The data to populate the intranet version is pulled from SharePoint using the URL protocol (no web services required provided you are hosting this inside SharePoint)  I will post the web service example soon.

For the demo on this site I uploaded as an application to the Silverlight Streaming Service.  The SharePoint list for managing what items are displayed in the filmstrip I created on my Office Live site but published a public list view and use the RSS feed to load the Filmstrip since this version is all in the cloud:) 


See previous post for more details

Click the waterfall thumbnail to test the video playback



Silverlight 2 Search UI with Web Services

If you are bored and have Silverlight 2 Beta 2 installed check out an example of using Silverlight as a front-end to your
web services.  More details later this week.  Silverlight looking promising…
Press Link: Silverlight based search explorer using web services

Concept was conceived by

Silverlight Search UI using web services

The UI is build exclusively with C# in Visual Studio 2008 which is also nicely
integrated with Microsoft Expression Blend (thank you Microsoft)  virtually all the
UI is developed in C# procedural code with only the container elements hard-coded
into the XAML.  Interesting way to do filtering of results sets is filtering the
container elements rather than making repeated call to web service when filtering-
providing virtually instananeous filtering of results.  cool.

Re-Publishing Silverlight Player for including videos in Sharepoint Blog posts


NEW! Silverlight 1.0 Player embedded into Sharepoint blog template via Sharepoint Designer, customized DVWP, and added javascript in canvas_loaded…assuming you already know how to use Silverlight 1.0. 

First, since Sharepoint blogs posts don’t support embed tags, javascript, or even iframes you need a way to render the silverlight player from within the blog post-answer: added two text-only fields to hold the paths to both the video file and placeholderimage that the Silverlight player will use when playing videos.  Add the Silverlight 1.0 files to your server (Sharepoint Designer makes this easy if you do not have server access but are at least a site collection owner.  Also, the MIME type for XAML files must be enabled by your sys admin for Silverlight to work.

Second, since this is a solution that needed to be deployed without the use of server-side code I developed a separate HTML page to render the player similiar to any default.htm page used for Silverlight 1.0 except referencing a modified script for loading the player (more on that in a minute)

source in right column >>>>

Third, modify the silverlightplayer.js to include an event handler for when the canvas loads:

source in right column >>>>

The function to obtain the parameters is courtesy of the Microsoft SharepointDesigner team blog also included as part of the Fab 40 templates to pre-fill newitem forms via querystring params-dawned on me while trying to figure this all out that this script could be used in the canvas_loaded event to set the Silverlight mediaelement’s source attribute among other things.

source in right column >>>>

Fourth, from post.aspx add another DVWP for the posts list and convert to XSLT so we can insert an iframe and set it’s source url to the video url field our users so kindly provide when adding new posts etc.  The row item template is a convenient place to add our iframe and set the source URL and placeholderimage url if you want as well.  Also a nice place to pass height, width, whatever the need.

<xsl:if test="string(@Video) != ”"><TR><TD style="padding-top:10px">
                    <div><iframe src="[yoursitepath]/silverlightplayer.htm?Source={@Video}&amp;Placeholder={@videoimage}" frameborder="0" height="410" width="424"></iframe>
There you go, all from client-side code a way to add Silverlight player allowing your users to easily add video to thier posts-of course you need to drop the Silverlight javascript and xaml files on your server.  Also, the XAML for your player can be whatever you like just make sure to remove the source attribute from the mediaelement.  Same with the placeholderimage.



source for .htm file

<html xmlns="">

    <script type="text/javascript" src="Silverlight.js"></script>
    <script type="text/javascript" src="silverlightplayercreate.js"></script>
    <script type="text/javascript" src="silverlightplayer.js"></script>
    <style type="text/css">
        .silverlightHost {
            height: 400px;
            width: 414px;
            position:absolute;left:0; top:0;

    <div id="SilverlightControlHost" class="silverlightHost">
        <script type="text/javascript">


function canvas_loaded(sender, args)
    var plugin = sender.getHost();
    plugin.content.onfullScreenChange = onFullScreenChanged;
    var qs =,;

      var args = qs.split("&");

      var vals = new Object();

      for (var i=0; i < args.length; i++) {

        var nameVal = args[i].split("=");

        var temp = unescape(nameVal[1]).split(‘+’);

        nameVal[1] = temp.join(‘ ‘);

        vals[nameVal[0]] = nameVal[1];

    var mediaPlayer = sender.findName("media");
    mediaPlayer.Source = vals["Source"]; 
    var placeholder = sender.findName("PlaceholderImage");
    placeholder.Source = vals["Placeholder"];