The following is a fragment of the Docicon.xml file showing a new entry for files with a .pdf extension, and the associated Pdficon_small.gif file.

<?xml version="1.0" encoding="utf-8"?>
<DocIcons>...
    <ByExtension>
              <Mapping Key="pdf" Value="pdficon_small.gif" />
              <Mapping Key="accdt" Value="icaccdb.gif"/>
              <Mapping Key="accdc" Value="icaccdb.gif"/>
              <Mapping Key="asax" Value="icasax.gif" OpenControl=""/>
...
    </ByExtension>
...
</DocIcons>

After you've run IISRESET, you can test that the new icon is correctly associated with PDF files by simply uploading a file with that extension to a document library anywhere on your site. Figure 6-1 shows the new icon associated with an uploaded PDF file.

Figure 6.1. PDF icon associated with uploaded Adobe Acrobat file

In this recipe, you'll add the ability for end users to provide comments on any document in any library on a site. The recipe will have several components:

Of course, we'll need the standard SharePoint components:

Each feature in SharePoint is stored in its own folder under the .../12/Template/Features folder. In this case, we'll name our feature DocumentComments. Place the following XML in a file named Feature.xml in the .../12/Template/Features/DocumentComments folder.

<?xml version="1.0" encoding="utf-8" ?>
<Feature xmlns="http://schemas.microsoft.com/sharepoint/"
    Id="FD20EE04-D0C4-4bad-B909-D453D89CF7F5"
    Scope="Web"
    Title="DocumentComments"
    Version="1.0.0.0"
    Description="Add Document Comments feature.">
        <ElementManifests>
           <ElementManifest Location="DocumentComments.xml" />
       </ElementManifests>
</Feature>

Key components of each feature are as follows:

Each feature references one or more ElementManifests. In our example, we have just one, DocumentComments.xml.

<Elements xmlns="http://schemas.microsoft.com/sharepoint/">

     <!-- Action to add action to drop-down menu associated with -->
     <!-- document library list items. -->
     <CustomAction
           Id="DC5D5B12-9ACA-4d95-AC54-0E42D4BB4051"
           RegistrationType="List"
           RegistrationId="101"
           Location="EditControlBlock"
           Sequence="999"
           ImageUrl="/_layouts/images/NMW16.GIF"
           Title="Add Comment...">
           <UrlAction Url="http://<yourserver>/<yoursiteurl>/<yourdoclib>/ 

               Comments.aspx?itemId={ItemId}&amp;itemUrl={ItemUrl} 

               &amp;siteUrl={SiteUrl}&amp;listId={ListId}"/>
     </CustomAction>

     <!-- Action to add action to Site Actions menu -->
     <!-- The "UrlAction" element should point to the list where your -->
     <!-- AddComments application is storing the user comments -->
     <CustomAction
           Id="E1E69684-CDFC-4981-B7E0-57DE6EB3C3C8"
           GroupId="SiteActions"
           Location="Microsoft.SharePoint.StandardMenu"
           Sequence="999"
           ImageUrl="/_layouts/images/NMW16.GIF"
           Title="View Comments...">
          <UrlAction Url="http://<yourserver>/<yoursiteurl>/lists/DocComments"/>
     </CustomAction>

</Elements>

Key components of each element manifest are as follows:

The following commands, entered into a Windows .cmd file, will save you time when installing and reinstalling your feature. They also provide good examples of the STSADM commands you'll use when working with features.

stsadm -o deactivatefeature -filename DocumentCommentsfeature.xml 

-url http://<yourserver>/<yoursite>

This command deactivates the feature if it is activated. When you first run the script, you'll receive a warning that the feature had not already been activated. Note that the –url parameter references a web site URL because the feature Scope is Web.

stsadm -o uninstallfeature -filename DocumentCommentsfeature.xml –force

After a feature is deactivated, it can be uninstalled from the web site. As with the preceding command, the first time you run the script, you will receive a warning that the specified feature is not installed yet.

stsadm -o installfeature -filename DocumentCommentsfeature.xml –force

Here we're installing the feature. Note that SharePoint assumes that the path to the specified feature folder will be under ...12TemplateFeatures.

stsadm -o activatefeature -filename DocumentCommentsfeature.xml 

-url http://<yourserver>/<yoursite>

Finally, the activatefeature STSADM command turns the feature on. This is equivalent to a site administrator navigating to the Site Settings

Imports System
Imports System.Data
Imports System.Configuration
Imports System.Web
Imports System.Web.Security
Imports System.Web.UI
Imports System.Web.UI.WebControls
Imports System.Web.UI.WebControls.WebParts
Imports System.Web.UI.HtmlControls
Imports Microsoft.SharePoint
Imports Microsoft.SharePoint.WebControls
Partial Public Class _Default
    Inherits System.Web.UI.Page
    Const COMMENTS_SITE_URL As String = "http://<yourserver>/<siteurl>"
    Const COMMENTS_WEB_NAME As String = "<webname>"
    Const COMMENTS_LIST As String = "DocComments"
    Protected Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs)
        Try
            ' Step 2: Get parse querystring for parameters.
            ' We are assuming that this page is hosted in
            ' a page viewer web part on a web-part page.
            ' So get the parameters passed to the web-part
            ' page contining this page in a PageViewer
            Dim querystring As String() = _
          Server.UrlDecode( _
             Request.UrlReferrer.Query).ToLower().Replace("?", "").Split("&"c)
            For i As Integer = 0 To querystring.Length - 1
                ' Step 3: Display querystring parameters
                If querystring(i).IndexOf("itemid=") <> −1 Then
                    lblItemId.Text = querystring(i).Split("="c)(1)
                End If
                If querystring(i).IndexOf("itemurl=") <> −1 Then
                    hlItemUrl.NavigateUrl = querystring(i).Split("="c)(1)
                    hlItemUrl.Text = querystring(i).Split("="c)(1)
                End If
                If querystring(i).IndexOf("listid=") <> −1 Then
                    lblListId.Text = querystring(i).Split("="c)(1)
                End If
                If querystring(i).IndexOf("siteurl=") <> −1 Then
                    hlSiteUrl.NavigateUrl = querystring(i).Split("="c)(1)
                    hlSiteUrl.Text = querystring(i).Split("="c)(1)
                End If
            Next

' Step 4: Get the list name and URL from its GUID
            Dim site As New SPSite(hlSiteUrl.NavigateUrl)
            'Extract the web name
     Dim webUrl As String
     webUrl = hlSiteUrl.NavigateUrl.ToLower().Replace(site.Url, "")
     If webUrl.IndexOf("/") = 0 Then
        webUrl = webUrl.Substring(1)
     EndIf
     Dim web As SPWeb = site.OpenWeb(webUrl);
            Dim guid As New Guid(lblListId.Text)
            Dim origList As SPList = web.Lists(guid)
            lblListName.Text = origList.Title
            hlListUrl.NavigateUrl = web.Url + "/" + origList.RootFolder.Url
            hlListUrl.Text = web.Url + "/" + origList.RootFolder.Url
            ' Step 5: Display existing comments for this document
            Dim siteComments As New SPSite(COMMENTS_SITE_URL)
            Dim webComments As SPWeb = _
               siteComments.OpenWeb(COMMENTS_WEB_NAME)
            Dim docComments As SPList = webComments.Lists(COMMENTS_LIST)
            Dim dtComments As DataTable = docComments.Items.GetDataTable()
            dtComments.TableName = "Comments"
            Dim dvComments As New DataView( _
                dtComments, "ItemUrl='" + hlItemUrl.NavigateUrl + "'", _
                "Created DESC", DataViewRowState.CurrentRows)
            GridView1.DataSource = dvComments
            GridView1.DataBind()
            webComments.Dispose()
            siteComments.Dispose()
        Catch ex As Exception
        End Try
    End Sub
    Protected Sub cmdSave_Click(ByVal sender As Object, ByVal e As EventArgs) _
         Handles cmdSave.Click
        ' Get handle to web
        Dim siteComments As New SPSite(COMMENTS_SITE_URL)
        Dim webComments As SPWeb = _
           siteComments.OpenWeb(COMMENTS_WEB_NAME)
        webComments.AllowUnsafeUpdates = True
        ' Step 6: Write new comment to DOCCOMMENTS list
        Dim docComments As SPList = webComments.Lists(COMMENTS_LIST)
        Dim item As SPListItem = docComments.Items.Add()
        item("ItemId") = lblItemId.Text
        item("ItemUrl") = hlItemUrl.NavigateUrl
        item("ListId") = lblListId.Text
        item("SiteUrl") = hlSiteUrl.NavigateUrl
        item("Comment") = txtComments.Text
        item.Update()

webComments.Dispose()
        siteComments.Dispose()
        ' Step 7: Return user to list
        returnToList()
    End Sub
    Protected Sub cmdCancel_Click(ByVal sender As Object, ByVal e As EventArgs) _
         Handles cmdCancel.Click
        returnToList()
    End Sub
    Private Sub returnToList()
        ' Because this page is running in a page viewer
        ' (i.e. in an <IFRAME>), a redirect statement would
        ' display the target URL in the frame, whereas we
        ' want the target page displayed at the top level.
        ' To accomplish this, we'll insert a bit of JavaScript
        ' to perform a window.open().
        Response.Write("<script>window.open('" + hlListUrl.NavigateUrl + _
             "','_top'),</script>")
    End Sub
End Class

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
public partial class _Default : System.Web.UI.Page
{
    const string COMMENTS_SITE_URL = "http://<yourserver>/<siteurl>";
    const string COMMENTS_WEB_NAME = "<webname>";
    const string COMMENTS_LIST = "DocComments";
    protected void Page_Load(object sender, EventArgs e)
    {
        try
        {
            // Step 2: Get parse querystring for parameters.
            // We are assuming that this page is hosted in
            // a page viewer web part on a web-part page.
            // So get the parameters passed to the web-part
            // page contining this page in a PageViewer

string[] querystring =
                Server.UrlDecode(
                    Request.UrlReferrer.Query).ToLower().Replace("?", "") 

                        .Split('&'),
            // Step 3: Display querystring parameters
            for (int i = 0; i < querystring.Length; i++)
            {
                if (querystring[i].IndexOf("itemid=") != −1)
                    lblItemId.Text = querystring[i].Split('=')[1];
                if (querystring[i].IndexOf("itemurl=") != −1)
                {
                    hlItemUrl.NavigateUrl = querystring[i].Split('=')[1];
                    hlItemUrl.Text = querystring[i].Split('=')[1];
                }
                if (querystring[i].IndexOf("listid=") != −1)
                    lblListId.Text = querystring[i].Split('=')[1];
                if (querystring[i].IndexOf("siteurl=") != −1)
                {
                    hlSiteUrl.NavigateUrl = querystring[i].Split('=')[1];
                    hlSiteUrl.Text = querystring[i].Split('=')[1];
                }
            }
            // Step 4: Get the list name and URL from its GUID
            SPSite site = new SPSite(hlSiteUrl.NavigateUrl);
            // Extract the web URL
            string webUrl = hlSiteUrl.NavigateUrl.ToLower().Replace(site.Url, "");
            if (webUrl.IndexOf("/") == 0) webUrl = webUrl.Substring(1);
            SPWeb web = site.OpenWeb(webUrl);
            Guid guid = new Guid(lblListId.Text);
            SPList origList = web.Lists[guid];
            lblListName.Text = origList.Title;
            hlListUrl.NavigateUrl = web.Url + "/" + origList.RootFolder.Url;
            hlListUrl.Text = web.Url + "/" + origList.RootFolder.Url;
            // Step 5: Display existing comments for this document
            SPSite siteComments = new SPSite(COMMENTS_SITE_URL);
            SPWeb webComments = siteComments.OpenWeb(COMMENTS_WEB_NAME);
            SPList docComments = webComments.Lists[COMMENTS_LIST];
            DataTable dtComments = docComments.Items.GetDataTable();
            dtComments.TableName = "Comments";
            DataView dvComments = new DataView(
                dtComments, "ItemUrl='"
                    + hlItemUrl.NavigateUrl
                    + "'", "Created DESC",
                DataViewRowState.CurrentRows);
            GridView1.DataSource = dvComments;
            GridView1.DataBind();
            web.Dispose();
            site.Dispose();

webComments.Dispose();
            siteComments.Dispose();
        }
        catch (Exception ex)
        {
        }
    }
    protected void cmdSave_Click(object sender, EventArgs e)
    {
        // Get handle to web
        SPSite siteComments = new SPSite(COMMENTS_SITE_URL);
        SPWeb webComments = siteComments.OpenWeb(COMMENTS_WEB_NAME);
        webComments.AllowUnsafeUpdates = true;
        // Step 6: Write new comment to DOCCOMMENTS list
        SPList docComments = webComments.Lists[COMMENTS_LIST];
        SPListItem item = docComments.Items.Add();
        item["ItemId"] = lblItemId.Text;
        item["ItemUrl"] = hlItemUrl.NavigateUrl;
        item["ListId"] = lblListId.Text;
        item["SiteUrl"] = hlSiteUrl.NavigateUrl;
        item["Comment"] = txtComments.Text;
        item.Update();
        webComments.Dispose();
        siteComments.Dispose();
        // Step 7: Return user to list
        returnToList();
    }
    protected void cmdCancel_Click(object sender, EventArgs e)
    {
        returnToList();
    }
    private void returnToList()
    {
        // Because this page is running in a page viewer
        // (i.e. in an <IFRAME>), a redirect statement would
        // display the target URL in the frame, whereas we
        // want the target page displayed at the top level.
        // To accomplish this, we'll insert a bit of JavaScript
        // to perform a window.open().
        Response.Write(
             "<script>window.open('" + hlListUrl.NavigateUrl + "','_top'),</script>"
        );
    }
}

You will also need to tell ASP.NET to pass the user's credentials through to the AddComment application. You do this by editing the Web.config file in the AddComment application, adding the <identity impersonate="true"/> element just after the <authentication mode="Windows"/> tag.

Before you can use your new custom action, you'll need to create a web-part page to display the AddComment/Default.aspx form that you have created:

You're not quite there yet. You'll need a custom list named DocComments in the same site you placed your web-part page in the preceding steps. This list will hold all user comments. The finished list should have the fields shown in Figure 6-11.

Figure 6.11. Structure of the DocComments list

Now that all the pieces are in place and installed, let's take our comments feature for a spin. First, be sure to run the command script to install the two custom actions. Then navigate to a document library on the web site in which you installed the feature (http://<yourserver>/<yoursite>), mouse over a document, and display the context menu. You should see a new option titled Add Comment, as shown in Figure 6-12. Click the Add Comment link to display the web-part page containing a reference to the AddComment application Default.aspx page.

The AddComment application will be displayed in the Page Viewer web part, as shown in Figure 6-13.

Figure 6.12. Chosing the Add Comment option for a selected document

Figure 6.13. The AddComment application page

As shown in Figure 6-13, the AddComment application extracts the querystring parameters sent to its containing web-part page and displays them on the web form, along with any preexisting comments for the source document.

You will also find a new option on the Site Actions menu titled View Comments, as shown in Figure 6-14.

Figure 6.14. Selecting the View Comments site action

Selecting this option will redirect the browser to the default view of the DocComments list on the Docs web site ( Figure 6-15).

Figure 6.15. The DocComments list

Figure 6-16 shows how the <Configuration> attributes map to template-selection page elements in SharePoint.

Figure 6.16. Webtemp <Configuration> attributes as displayed in the New SharePoint Site page

The following is the XML that SharePoint creates when I export my Page Viewer web part, without the opening <?xml...> tag. This is what you will need to pass between the <![CDATA[ and ]]> tags of the first <AllUsersWebPart> element. Essentially you are telling SharePoint to automate the process of adding a Page Viewer web part and setting its properties when it provisions a new web site.

<WebPart xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

   xmlns:xsd="http://www.w3.org/2001/XMLSchema" 

   xmlns="http://schemas.microsoft.com/WebPart/v2">
  <Title>And here's my page viewer web part!</Title>
  <FrameType>Default</FrameType>
  <Description>Use to display linked content, such as files, folders, or Web pages. 

         The linked content is isolated from other content on the 

         Web Part Page.</Description>

<IsIncluded>true</IsIncluded>
  <ZoneID>Left</ZoneID>
  <PartOrder>0</PartOrder>
  <FrameState>Normal</FrameState>
  <Height>1000px</Height>
  <Width />
  <AllowRemove>true</AllowRemove>
  <AllowZoneChange>true</AllowZoneChange>
  <AllowMinimize>true</AllowMinimize>
  <AllowConnect>true</AllowConnect>
  <AllowEdit>true</AllowEdit>
  <AllowHide>true</AllowHide>
  <IsVisible>true</IsVisible>
  <DetailLink />
  <HelpLink />
  <HelpMode>Modeless</HelpMode>
  <Dir>Default</Dir>
  <PartImageSmall />
  <MissingAssembly>Cannot import this Web Part.</MissingAssembly>
  <PartImageLarge />
  <IsIncludedFilter />
  <Assembly>Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral,  

        PublicKeyToken=71e9bce111e9429c</Assembly>
  <TypeName>Microsoft.SharePoint.WebPartPages.PageViewerWebPart</TypeName>
  <ContentLink xmlns="http://schemas.microsoft.com/WebPart/v2/PageViewer"> 

        http://www.apress.com/book/view/1430209615</ContentLink>
  <SourceType xmlns="http://schemas.microsoft.com/WebPart/v2/PageViewer">URL
       </SourceType>
</WebPart>

As with the Page Viewer web-part definition in the preceding section, you will paste the following portion of the Content Editor web-part definition file between the <![CDATA[ and ]]> tags of the second <AllUsersWebPart> element.

<WebPart xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

       xmlns:xsd="http://www.w3.org/2001/XMLSchema" 

       xmlns="http://schemas.microsoft.com/WebPart/v2">
  <Title>Hello World web part</Title>
  <FrameType>Default</FrameType>
  <Description>Use for formatted text, tables, and images.</Description>
  <IsIncluded>true</IsIncluded>
  <ZoneID>Right</ZoneID>
  <PartOrder>0</PartOrder>
  <FrameState>Normal</FrameState>
  <Height />
  <Width />

<AllowRemove>true</AllowRemove>
  <AllowZoneChange>true</AllowZoneChange>
  <AllowMinimize>true</AllowMinimize>
  <AllowConnect>true</AllowConnect>
  <AllowEdit>true</AllowEdit>
  <AllowHide>true</AllowHide>
  <IsVisible>true</IsVisible>
  <DetailLink />
  <HelpLink />
  <HelpMode>Modeless</HelpMode>
  <Dir>Default</Dir>
  <PartImageSmall />
  <MissingAssembly>Cannot import this Web Part.</MissingAssembly>
  <PartImageLarge />
  <IsIncludedFilter />
  <Assembly>Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, 

        PublicKeyToken=71e9bce111e9429c</Assembly>
  <TypeName>Microsoft.SharePoint.WebPartPages.ContentEditorWebPart</TypeName>
  <ContentLink xmlns="http://schemas.microsoft.com/WebPart/v2/ContentEditor" />
  <Content xmlns="http://schemas.microsoft.com/WebPart/v2/ContentEditor">
        Hello World!
  </Content>
  <PartStorage xmlns="http://schemas.microsoft.com/WebPart/v2/ContentEditor" />
</WebPart>

At this point, you've created your new site definition, edited the Onet.xml file to contain the two web-part definitions, added a new Webtemp*.xml file to tell SharePoint about the new site definition, and you've run the IISRESET command to force SharePoint to refresh its list of site definitions in memory. You're now ready to provision a site based on the new template.

To test your new site-definition template, follow these steps:

Figure 6.17. New site based on the modified Onet.xml

Note that in addition to the standard image and links web parts that are part of the base sts template, our two additional web parts are displayed.

Figure 6.20. Configuring the SelectWebParts virtual directory properties

We're now ready to code our SelectWebParts application.

Figure 6-21 shows the page layout for SelectWebParts.aspx.

Figure 6.21. SelectWebParts.aspx page layout

The following fields are defined on the form:

Imports System
Imports System.Data
Imports System.Configuration
Imports System.Web
Imports System.Web.Security
Imports System.Web.UI
Imports System.Web.UI.WebControls
Imports System.Web.UI.WebControls.WebParts
Imports System.Web.UI.HtmlControls
Imports Microsoft.SharePoint
Imports Microsoft.SharePoint.WebControls
Imports Microsoft.SharePoint.WebPartPages
Imports System.Xml
Partial Public Class _Default
    Inherits System.Web.UI.Page
    Private Shared Function AddContentEditorWebPart(ByVal strContent As String, _
        ByVal strTitle As String, _
        ByVal strSiteUrl As String, _
        ByVal strWebName As String, _
        ByVal strDocLibName As String, _
        ByVal strPage As String, _
        ByVal strZone As String, _
        ByVal numOrder As Integer, _
        ByVal pScope As System.Web.UI.WebControls.WebParts.PersonalizationScope) _
        As Microsoft.SharePoint.WebPartPages.ContentEditorWebPart
        Try
            ' Create an empty Content Editor web part.
            Dim cewp As New Microsoft.SharePoint.WebPartPages.ContentEditorWebPart()
            ' Create an xml element object and transfer the content
            'into the web part.
            Dim xmlDoc As New XmlDocument()
            Dim xmlElem As System.Xml.XmlElement = xmlDoc.CreateElement("xmlElem")
            xmlElem.InnerText = strContent
            cewp.Content = xmlElem
            ' Call generic method to add the web part
            cewp = AddWebPart(cewp, _
                strTitle, _
                strSiteUrl, _
                strWebName, _

strDocLibName, _
                strPage, _
                strZone, _
                numOrder, _
                System.Web.UI.WebControls.WebParts.PersonalizationScope.[Shared])
            Return cewp
        Catch ex As Exception
            Throw New Exception("AddContentEditorWebPart() error: " + ex.Message)
        End Try
    End Function
    Private Shared Function AddWebPart(_
        ByVal oWebPart As System.Web.UI.WebControls.WebParts.WebPart, _
        ByVal strTitle As String, _
        ByVal strSiteUrl As String, _
        ByVal strWebName As String, _
        ByVal strDocLibName As String, _
        ByVal strPage As String, _
        ByVal strZone As String, _
        ByVal numOrder As Integer, _
        ByVal pScope As System.Web.UI.WebControls.WebParts.PersonalizationScope) _
        As System.Web.UI.WebControls.WebParts.WebPart
        Try
            ' Get handles to site, web, and page to which
            ' web part will be added.
            Dim site As New SPSite(strSiteUrl)
            Dim web As SPWeb = site.OpenWeb(strWebName)
            ' Enable update of page
            web.AllowUnsafeUpdates = True
            Dim webParts As SPLimitedWebPartManager
            If (strDocLibName <> "") Then
                webParts = web.GetLimitedWebPartManager(strDocLibName + "/" _
                     + strPage, pScope)
            Else
                webParts = web.GetLimitedWebPartManager(strPage, pScope)
            End If
            ' If web-part page is in a document library,
            ' disable checkout requirement
            ' for duration of update
            Dim list As SPList = Nothing
            Dim origForceCheckoutValue As Boolean = False
            If (strDocLibName <> "") Then
                list = web.Lists(strDocLibName)
                origForceCheckoutValue = list.ForceCheckout
                list.ForceCheckout = False
                list.Update()
            End If

' Add the web part
            oWebPart.Title = strTitle
            webParts.AddWebPart(oWebPart, strZone, numOrder)
            ' Save changes back to the SharePoint database
            webParts.SaveChanges(oWebPart)
            web.Update()
            ' If necessary, restore ForceCheckout setting
            If (strDocLibName <> "") Then
                list.ForceCheckout = origForceCheckoutValue
                list.Update()
            End If
            web.Dispose()
            site.Dispose()
            Return oWebPart
        Catch ex As Exception
            Throw New Exception(("AddWebPart() error: " + ex.Message))
        End Try
    End Function
    Protected Sub Finish_Click(ByVal sender As Object, ByVal e As EventArgs) _
          Handles cmdFinish.Click
        ' Step 1: Get handle to web site being created
        Dim web As SPWeb = SPControl.GetContextWeb(Context)
        web.AllowUnsafeUpdates = True
        ' Step 2: If requested, clear out any existing
        ' web parts
        If cbRemoveExisting.Checked Then
            Dim webparts As SPLimitedWebPartManager _
                 = web.GetLimitedWebPartManager( _
                    "default.aspx", PersonalizationScope.[Shared])
            For i As Integer = webparts.WebParts.Count - 1 To −1 + 1 Step −1
                webparts.DeleteWebPart(webparts.WebParts(i))
            Next
        End If
        ' Step 3: If requested, add an instance of a SharePoint
        ' "ContentEditorWebPart", which is a descendent of
        ' the generic .NET 2.0 WebPart class
        If cbCEWP.Checked Then
            Dim oCEwp As New _
                 Microsoft.SharePoint.WebPartPages.ContentEditorWebPart()
            oCEwp = AddContentEditorWebPart( _
"Hello World!", _
"Hello World web part", _
web.Site.Url.ToString(), web.ServerRelativeUrl.Substring(1), "", _
"Default.aspx", _
                      "Right", 0, _

System.Web.UI.WebControls.WebParts.PersonalizationScope.[Shared])
        End If
        ' Step 4: If requested, add a PageViewer web part
        If cbPVWP.Checked Then
            Dim oPVwp As New Microsoft.SharePoint.WebPartPages.PageViewerWebPart()
            oPVwp.SourceType = PathPattern.URL
            oPVwp.ContentLink = txtPVUrl.Text
            oPVwp.Height = "1000px"
            oPVwp = AddWebPart(oPVwp, _
"And here's my page viewer web part!", _
web.Site.Url.ToString(), _
web.ServerRelativeUrl.Substring(1), "", _
"Default.aspx", _
                      "Left", 0, _
System.Web.UI.WebControls.WebParts.PersonalizationScope.[Shared])
        End If
        ' Step 5: Now take the user to the home page of the new
        ' web site
        Response.Redirect(web.ServerRelativeUrl)
    End Sub
    ' Determine whether Url text box should
    ' be enabled based on whether
    ' option to add a Page Viewer web part
    ' is checked
    Protected Sub cbPVWP_CheckedChanged( _
            ByVal sender As Object, ByVal e As EventArgs) _
            Handles cbPVWP.CheckedChanged
        txtPVUrl.Enabled = cbPVWP.Checked
    End Sub
End Class

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using Microsoft.SharePoint.WebPartPages;
using System.Xml;

public partial class _Default : System.Web.UI.Page
{
    private static Microsoft.SharePoint.WebPartPages.ContentEditorWebPart
    AddContentEditorWebPart(
        string strContent,
        string strTitle,
        string strSiteUrl,
        string strWebName,
        string strDocLibName,
        string strPage,
        string strZone,
        int numOrder,
        System.Web.UI.WebControls.WebParts.PersonalizationScope pScope)
        {
            try
            {
                // Create an empty content editor web part.
                Microsoft.SharePoint.WebPartPages.ContentEditorWebPart cewp
                    = new Microsoft.SharePoint.WebPartPages.ContentEditorWebPart();
                // Create an xml element object and transfer the content
                //into the web part.
                XmlDocument xmlDoc = new XmlDocument();
                System.Xml.XmlElement xmlElem = xmlDoc.CreateElement("xmlElem");
                xmlElem.InnerText = strContent;
                cewp.Content = xmlElem;
                // Call generic method to add the web part
                cewp = (Microsoft.SharePoint.WebPartPages.ContentEditorWebPart)
                AddWebPart(
                    cewp,
                    strTitle,
                    strSiteUrl,
                    strWebName,
                    strDocLibName,
                    strPage,
                    strZone,
                    numOrder,
                    System.Web.UI.WebControls.WebParts.PersonalizationScope.Shared);
                return cewp;
            }
            catch (Exception ex)
            {
                throw new Exception(
                    "AddContentEditorWebPart() error: " + ex.Message);
            }
        }

private static System.Web.UI.WebControls.WebParts.WebPart
    AddWebPart(
    System.Web.UI.WebControls.WebParts.WebPart oWebPart,
    string strTitle,
    string strSiteUrl,
    string strWebName,
    string strDocLibName,
    string strPage,
    string strZone,
    int numOrder, System.Web.UI.WebControls.WebParts.PersonalizationScope pScope)
        {
            try
            {
                // Get handles to site, web, and page to which
                // web part will be added.
                SPSite site = new SPSite(strSiteUrl);
                SPWeb web = site.OpenWeb(strWebName);
                // Enable update of page
                web.AllowUnsafeUpdates = true;
                SPLimitedWebPartManager webParts;
                if ((strDocLibName != ""))
                {
                    webParts = web.GetLimitedWebPartManager(
                        strDocLibName + "/" + strPage, pScope);
                }
                else
                {
                    webParts = web.GetLimitedWebPartManager(strPage, pScope);
                }
                // If web-part page is in a document library,
                // disable checkout requirement
                // for duration of update
                SPList list = null;
                bool origForceCheckoutValue = false;
                if ((strDocLibName != ""))
                {
                    list = web.Lists[strDocLibName];
                    origForceCheckoutValue = list.ForceCheckout;
                    list.ForceCheckout = false;
                    list.Update();
                }
                // Add the web part
                oWebPart.Title = strTitle;
                webParts.AddWebPart(oWebPart, strZone, numOrder);
                // Save changes back to the SharePoint database
                webParts.SaveChanges(oWebPart);
                web.Update();

// If necessary, restore ForceCheckout setting
                if ((strDocLibName != ""))
                {
                    list.ForceCheckout = origForceCheckoutValue;
                    list.Update();
                }
                web.Dispose();
                site.Dispose();
                return oWebPart;
            }
            catch (Exception ex)
            {
                throw new Exception(("AddWebPart() error: " + ex.Message));
            }
        }
    protected void Finish_Click(object sender, EventArgs e)
    {
        // Step 1: Get handle to web site being created
        SPWeb web = SPControl.GetContextWeb(Context);
        web.AllowUnsafeUpdates = true;
        // Step 2: If requested, clear out any existing
        // web parts
        if (cbRemoveExisting.Checked)
        {
            SPLimitedWebPartManager webparts
                = web.GetLimitedWebPartManager("default.aspx", _
                   PersonalizationScope.Shared);
            for (int i = webparts.WebParts.Count - 1; i > −1; i--)
            {
                webparts.DeleteWebPart(webparts.WebParts[i]);
            }
        }
        // Step 3: If requested, add an instance of a SharePoint
        // "ContentEditorWebPart", which is a descendent of
        // the generic .NET 2.0 WebPart class
        if (cbCEWP.Checked)
        {
            Microsoft.SharePoint.WebPartPages.ContentEditorWebPart oCEwp
                = new Microsoft.SharePoint.WebPartPages.ContentEditorWebPart();
            oCEwp = AddContentEditorWebPart(
                "Hello World!",
                "Hello World web part",
                web.Site.Url.ToString(),
                web.ServerRelativeUrl.Substring(1),
                "",
                "Default.aspx",
                "Right",

0,
                System.Web.UI.WebControls.WebParts.PersonalizationScope.Shared);
        }
        // Step 4: If requested, add a PageViewer web part
        if (cbPVWP.Checked)
        {
            Microsoft.SharePoint.WebPartPages.PageViewerWebPart oPVwp
                = new Microsoft.SharePoint.WebPartPages.PageViewerWebPart();
            oPVwp.SourceType = PathPattern.URL;
            oPVwp.ContentLink = txtPVUrl.Text;
            oPVwp.Height = "1000px";
            oPVwp = (Microsoft.SharePoint.WebPartPages.PageViewerWebPart)
            AddWebPart(
                    oPVwp,
                    "And here's my page viewer web part!",
                    web.Site.Url.ToString(),
                    web.ServerRelativeUrl.Substring(1),
                    "",
                    "Default.aspx",
                    "Left",
                    0,
                System.Web.UI.WebControls.WebParts.PersonalizationScope.Shared);
        }
        // Step 5: Now take the user to the home page of the new
        // web site
        Response.Redirect(web.ServerRelativeUrl);
    }
    // Determine whether Url text box should
    // be enabled based on whether
    // option to add a Page Viewer web part
    // is checked
    protected void cbPVWP_CheckedChanged(object sender, EventArgs e)
    {
        txtPVUrl.Enabled = cbPVWP.Checked;
    }
}

There are so many possible variations when it comes to adding custom postprovisioning code. Here are a few possibilities: