All posts in Visual Studio 2010

iGoogle UI for SharePoint – Part Five : SharePoint 2010 Integration


Series Content

  1. Part One – Overview, Concept, HTML Structure & jQuery Basics
  2. Part Two – Dragging, Dropping, Sorting and Collapsing
  3. Part Three – Saving WebPart states using Cookies
  4. Part Four – Control Adaptersc
  5. Part Five – SharePoint 2010 Integration – Current Article
  6. Part Six – Bringing it all together
  7. Bonus – Saving WebPart States using the Client Object Model


In Part Five, we will take the previous posts and show you how to get it into SharePoint 2010. I’ll show how to create the Visual Studio Project, and then deploy the assets into SharePoint to create a working example.

Visual Studio Project & Assets

For this post will be using Visual Studio 2010 as our development platform. As part of my default development build i like to have the following VS plug-ins installed.

For this post, we will be using Visual Studio 2010 as our development platform. As part of my default development build, I like to have the following VS plug-ins installed:

SPI’s & Features

Our project will contain the following SPI’s (SharePoint Item) to deploy the required assets.

The Project will contain only a single feature which will deploy all the assets required for the iGoogle interface. This will be a SITE scoped feature with an event receiver to manage the addition of values to the compact.browser file.

Visual Studio

The first step for this and pretty much every other SharePoint Project is to fire up Visual Studio 2010 and create a new SharePoint 2010 Project. Call the project LifeInSharePoint.iGoogle. On the next screen we would also like to create this as a FARM solution. Sandbox solutions will not work as control adapters cannot be deployed using a Sandbox Solution.

Now that we have a project created, we first need to create some folders to contain our SPI’s. I like to organise my folders in a manner that I feel makes it easier to understand, so I will first create a Common folder which will contain a sub folder called ControlAdapters. NOTE: I do not have spaces in my folder names as visual studio will replace them with “_” in namespaces. I will now create another top level folder called Root and within this I will create another folder called Content. These two folders will contain the module that will deploy the iGoogle.aspx page and place WebParts onto the page. To ensure that we can access the images, js and css from anywhere, we will place them in the /_layouts folder. To deploy these to the Layouts folder from Visual Studio is very simple. Firstly you will need to right click on the project in Visual Studio > Add > SharePoint “Layouts” Mapped Folder.

This will create you a project named sub folder which we can use to place our css etc. Once this has been done your folder structure should look like this.

Now that I have the basic folder structure, I will now create a new a new class file for my ControlAdapter called WebPartRenderControlAdapter.cs. For the info on how to create and what goes into this class file, please see the previous post where I go into a lot more detail. iGoogle UI for SharePoint 2010 – Part Four: Control Adapters.

The next step is to add the CSS, JS, and Image that we created in the first three parts of this blog series. (These will be available at the end of this post) in the supplied zip file.

Adding Content & Pages

Next, we need to create the root content module. This module contains two items. The first is the Elements.xml file which will contain the XML required to deploy our page, and the second item is the default.aspx page which we will provision. This default.aspx page contains the HTML snippets from the first couple of posts in this series as well as the references to our javascript and css which we are storing above in the /_layouts folder. Below is a snippet from within the default.aspx page.

As you can see I have made some small changes by placing our three columns within a table to keep things nice and neat. The script references have also been updated to point to our deployed assets. The elements.xml file is very simple. It takes the default.aspx page and deploys it to the root of the current site creating an iGoogle.aspx page at that location.

As you can see there is not a lot to it. We are setting the name of the deployed file to iGoogle.aspx and the Url in this case is the relative url within the project, NOT the location it will appear on the site, a common mistake I have made many times. If you wanted to place the page in another location you can modify URL and Path attributes in the <module> tag to point to another location. Since we want to place the page on the root, these are left blank.

Adding WebParts

The final addition to this elements.xml file is to add some default WebParts on to the page. For this demo we are going to use some Content Editor WebParts which will have some dummy Lorem Ipsum text within. (You can replace the xml with some other WebParts if you like, as long as you know the XML) The XML element you need to add WebParts on to the page is the <AllUsersWebPart> Node. This node has attributes which we use to define the order on the page, as well as the WebPart Zone the WebPart is to appear in. The Snippet below shows a single item.

You can also see from the code above that we are surrounding the WebPart XML with a <![CDATA[]]> tag which means that the text within will be ignored by the XML Parser.

Creating the Feature

Now that we have nearly all the pieces of the puzzle, the next step is to create a feature in our solution which will deploy the items to SharePoint. You should notice in your project there is a Web scoped default feature called Feature1. We need to rename our feature to something more meaningful, so in the Solution Explorer right click and rename the feature. My preference for naming Features is as follows:


The reason for this is that there is no quick and easy way to know the scope of a feature from glancing at the solution explorer as all icons are the same. Therefore in our solution the feature will be:


The next step is to double click on this feature and it should open the feature management screen on the left side of the window. Within this window you are able to change the Display Title and Description as well as manage the items in the feature. We will call our feature LifeInSharePoint.iGoogle, the description can be what ever you please and the Scope should be set to SITE. Finally add the Root.Content.Pages SPI into the feature and we are nearly complete.

Writing the Feature Receiver

For those who remember the last post, the control adapter requires an entry into the compact.browser file. This entry registers our control adapter for use and it would be very useful if this was added automatically as part of our deployment. To do this we will need to create a small feature receiver to do this for us. To add a receiver, right click on the feature and click the Add Event Receiver link.

We are only going to manage the addition of the code to the compact.browser and not the retraction from the solution. This can be added to your solution if you wish but to save time I will ignore it.

Our first step is to create two string constants which will contain the Control Adapter Type and the Assembly Name of the Solution. The Assembly name will only contain the first part as the full assembly name will be retrieved later through reflection.

The next step is to uncomment the FeatureActivated method and add the following code in.

This code simply gets the current Site Collection from the features property collection and then passes that SPSite object to the UpdateCompactBrowser method which is explained below in the code comments for each line.

If we save all the items in the project, we are now ready to deploy our project to our site. When the feature activates it will run the code above which will make the necessary changes to the compact.browser file and our solution should work as expected.

Deployment & Testing

To deploy the solution we need to build the solution by right clicking on the project and clicking Build. After the project has been built and no errors are found, we can then deploy by again right clicking on the project and clicking Deploy. The default deployment configuration in Visual Studio will automatically activate the feature on the destination site. After deployment, navigate to the site and view the site collection features. We should see our feature deployed and activated.

If we now navigate to the root of the site collection and change the url to http://[SITE URL]/igoogle.aspx, then you should see our newly deployed interface with 5 different CEWP with some Lorem Ipsum text.

You should now be able to drag and drop these WebParts around the page, close, and change the colour. When you have finished and navigate away, refresh the page and the WebParts will remember their states. If you edit the page you will see how the Control Adapter does not render in edit mode enabling you to add new WebParts. You can see below that I have added a new Image WebPart to show how easy it is to create new “Widgets”.

NOTE: It is important to understand that this interface is designed for “Rollup” style WebParts. Due to how SharePoint 2010 and the Ribbon works with WebParts you may find some OOTB WebParts do not function fully. (Calendar WebPart, ListViewWebPart) The reason for some WebParts not working is that we are replacing the Chrome around the WebParts with our custom HTML (ControlAdapter). Many of the required ID’s etc are removed and therefore the Javascript that works with the Ribbon & Ajax fails. I am working on this and will post an update when I find a solution.


In this post we have outlined how to get the iGoogle interface into a SharePoint environment. Using a Visual Studio 2010 Project we have deployed css, images and javascript, created and deployed a Control Adapter, and added a page full of WebParts on to a site. I hope this post gives you a stepping stone on how to implement something similar on your SharePoint Deployments. Below I have uploaded a link to my Solution ZIP file that you can use and test on your environments. I have not done lots of cross browser or different environment testing of the solution so should you find an issue let me know and I will try my best to find a solution. In the next post I will show you how you can use the techniques shown in this series to come up with some innovative designs and implementations.


iGoogle UI for SharePoint 2010 – Part Four: Control Adapters

Series Content

  1.     Part One – Overview, Concept,  HTML Structure & jQuery Basics
  2.     Part Two – Dragging, Dropping,  Sorting and Collapsing
  3.     Part Three – Saving WebPart states using Cookies
  4.     Part Four – Control Adapters – Current Article
  5.     Part Five – SharePoint 2010 Integration
  6.     Part Six – Bringing it all together
  7.     Bonus – Saving WebPart States using the Client Object Model


In Part Four we will take the take a look at how we will create our widgets in SharePoint 2010.  As the title of this post mentions we are going to use what is known as a Control Adapter.  This Post will outline what they are, how they work, and how we are going to use them in this series.  There will also be a code snippet to explain how we can use it.

Control Adapters

Rather than try to explain these myself I thought it would be easier to grab a snippet from a Microsoft Article which i think does a great job of explaining what and how they work from an architectural level and in more detail than I could probably achieve :).

At their core, control adapters are simply a way of providing different renderings for controls without actually modifying the controls themselves. Because control adapters are designed to provide alternate renderings for different clients, you specify control adapter mappings in a .browser file, which is where associations between User Agent strings and browser capabilities are defined. The control adapter class itself must inherit from the System.Web.UI.Adapters.ControlAdapter, which is an abstract base class that looks much like the Control base class, with events for Init, Load, PreRender, and Unload, as well as a virtual Render method.

The next step to use a control adapter is to derivatively bind your adapter to a specific control.  To do this you use a Browser Definition File Schema which is found in the App_Browsers folder of the IIS WebSite you are using.

How are we going to use Control Adapters?

Now we know what a control adapter is, what do we need them for?  Well, if we are going to have our WebPart rendering like we have built in the previous three post then we will need to use a Control Adapter to do the hard work for us.  WebParts can be placed onto a SharePoint 2010 Page in many ways.  They can be either added to content inline using the rich content editor, they can be added directly into a page layout or masterpage, or (the most common way) is that they can be placed into a WebPart zone.  It is this final method that we are going to use to modify the rendering of our WebParts.

A basic WebPart Control Adapter Code looks like this:

As you can see from the code above we have a class which inherits from System.Web.UI.Adapters.ControlAdapters.  We first get a reference to the current WebPartZone on the Adapter.  If this is not null then we can start to override the WebPart rendering.  We then check how many WebParts exist in the current WebPartZone that we are in and if there are some then we create a new WebPartCollection object with all the WebParts in the current zone.

We can then loop through each WebPart in the collection and render the WebPart control.   This alone will remove all the tables for each WebPart rendered in a WebPartZone.  The final step to get this basic Control Adapter working is to update the compact.browser file stored (in my case) in the inetpub > webapp > App_Browsers > compact.browser file.

We need to add a single line into the <controlAdapters> node to register our new custom adapter.

Save this file and ensure that the dll is in the GAC and then the control adapter should work.  One thing that is important to know about Control Adapters is that when they are in use they will by default process EVERY WebPart on the site.  For our implementation however we want to be able to choose which WebParts are rendered as our widgets.  To do this we will place some logic into our control adapter which will check the title of the WebPartZone to ensure it contains the text “iGoogle” and only process WebParts that are contained within those specific zones.  Another piece of logic that we need to place into our zones is that we only want our rendering to process WebParts when the page is in the Display mode and not in Edit mode.  The code below shows the updated adapter with the new pieces of logic included.

As you can now see we have first added a line to get a reference to the current WebPartManager on the page which will enable use to get the state of the page and check if we are in display or edit mode.

We are then able to set a boolean value to the state of the page.

The final step is to wrap a new if statement around the render code which will control when the table removal is processed.

When this code is run only WebPartZones with the iGoogle text value in the title will be rendered.

Adding the Widget Code Wrapper

Now that we have the basics sorted for our Control Adapter we now need to wrap our widget code around the render control and this can be done like it would be done in a normal WebPart.  We need to add the following code and replace it within the foreach loop around for each WebPart.

Those who have been following the previous three posts will recognize the HTML from above.  I have use the writer object to inject the HTML and have also ensured that the ID of my widget wrapper div is generated from the current WebPart ID – (wp.ID), and the title of the WebPart is injected into the <H3> tag.


That wraps up part four of the iGoogle series.  The next post will be to integrate the code above into a SharePoint 2010 solution and include some of the extra pieces such as CSS to enable the this solution to come to life.  The final code for this Control Adapter is shown below.  Thanks for reading and all the positive feedback is greatly appreciated.


SPLongOperation – Explained & Branded



When you are performing out of the box operations in SharePoint 2010 normally in Central Administration you will get a nice loading screen from SharePoint with an animated loading gif. Have you ever wondered how you can use this in your own SharePoint Solution? I have been doing SharePoint for a while now and only recently discovered the SPLongOperation method and it is quite the little gem.

I have been writing a site provisioning service recently and have used the above code to help provide the end users some feedback while a

Would still products feeling dating service for nerdy girls according the to also lds 30 singles ward and better wide title getting. Paraben mine so fun other kept washignton d c web cams esp My be web cam visita into runs as It. Organizing essex dating Greasy then of. No response peel s itching free sms dating numbers oils went place beta-carotene oz.

new site collection is being created. Only a couple of lines of code but it transformed the solution.

Want to change the text that is displayed in the loading screen? No problem.

This will change the text on the page to reflect your specific requirements.

Branding the Loading Page

Do you want to match the loading page to your corporate colour scheme? No problem. Below is the output of the page in raw html.

As you can see the markup is very simple. What you can then do is create a new CSS style sheet and inject the reference to it in the LeadingHTML property as the property is not escaped.

This will then enable you to customize the page as you need to changing background colours, fonts images etc. This is the kind of result that you will get.

Do download a working solution with branding included please use the link below.

Twitter Rollup Webpart


Today i am releasing the beta version of my Twitter Rollup Webpart.  Do you have a favorite Celebrity or user / group that you enjoy following via twitter.  Now you can surface multiple twitter accounts into a single webpart and utilizing Jquery Accordion you can view the one you are most interested in and collapse the rest.

The webpart currently uses twitters json service to retrieve the values it needs to display the tweets.  If you have any suggestions, problems or praise please let me know either via a comment on this post or email me using the contact page.

Codeplex Link :


SPTwitter – Internal Twitter Application for Teams


I have been looking around the web at new applications and came accross the TeamTalk for SharePoint 2010 by ZevenSeas.  They released a no code (server code) site template for internal twitter team talks.  I thought that the concepts was fantastic and simple to implement, so i decided to create my own version using Visual Studio 2010 and Utilise SharePoint 2010’s new Sandbox Solutions.

My Solution which is now on the LifeInSharePoint Codeplex page is a sandbox solution which deploys content types, list definitions, and contains three webparts which you can place anywhere on the page / site.  The Solution is designed so you can install the solution on multiple Webs and they will work individually.

The release at the moment is a beta release and any comments, additions and recommendations would be fantastic.  I will be implementing a “Re-tweeting” functionality as well as a SharePoint Server version which links in with user profiles for a more enhanced experience.  Like i said, its still work in progress, but please feel free to try it out.



Direct WSP Download Link :

Update: Now Includes webpart fix and Re-Tweets