Sharepoint Server » MOSS – Object Model

Most Common Custom WebParts Part 4 – Flash Media WebPart

G Vijai Kumar — Sun, 28 Nov 2010 21:33:53 +0000

In my previous post you can view the most commonly used custom webparts, Tree View WebPart Shows Sites and Sub-Sites, Menu WebPart Shows Sites and Sub-Sites in Fly-Out Mode, Windows Media Player WebPart

In this continuation series of most commonly used custom webparts, I come up with a simple Flash Player webpart which plays flash files on Sharepoint sites, the webpart also supports to configure the properties as required.

Download the solution file FlashWebPart.wsp

Flash Media Player WebPart

Flash Media Player WebPart Configuration

using System;
using System.ComponentModel;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;

namespace FlashWebPart.Flash
{
    [ToolboxItemAttribute(false)]
    public class Flash : WebPart
    {
        // Visual Studio might automatically update this path when you change the Visual Web Part project item.
        //private const string _ascxPath = @"~/_CONTROLTEMPLATES/FlashWebPart/Flash/FlashWebPartUserControl.ascx";

        private string flashFilePath = "http://www.adobe.com/content/dam/Adobe/en/devnet/flash/samples/time_1/1_timer.swf";
        private string flashWidth = "320";
        private string flashHeight = "240";
        private string bgColor = string.Empty;
        private bool loopPlayBack = true;

        [WebBrowsable(true),
        Personalizable(PersonalizationScope.User),
        WebDescription("Specifies the media file location"),
        Category("Flash Media Properties"),
        WebDisplayName("Media File Location")]
        public string FlashFilePath
        {
            get { return flashFilePath; }
            set { flashFilePath = value; }
        }

        [WebBrowsable(true),
        Personalizable(PersonalizationScope.User),
        WebDescription("Sets the width of the Media player"),
        Category("Flash Media Properties"),
        WebDisplayName("Width")]
        public string FlashWidth
        {
            get { return flashWidth; }
            set { flashWidth = value; }
        }

        [WebBrowsable(true),
        Personalizable(PersonalizationScope.User),
        WebDescription("Sets the height of the Media player"),
        Category("Flash Media Properties"),
        WebDisplayName("Height")]
        public string FlashHeight
        {
            get { return flashHeight; }
            set { flashHeight = value; }
        }

        [WebBrowsable(true),
        Personalizable(PersonalizationScope.User),
        WebDescription("Background Color: Specifies the back color"),
        Category("Flash Media Properties"),
        WebDisplayName("Background Color")]
        public string BGColor
        {
            get { return bgColor; }
            set { bgColor = value; }
        }

        [WebBrowsable(true),
        Personalizable(PersonalizationScope.User),
        WebDescription("Loop Play Back: (True/False) Repeats the video automatically"),
        Category("Flash Media Properties"),
        WebDisplayName("Loop Play Back")]
        public bool LoopPlayBack
        {
            get { return loopPlayBack; }
            set { loopPlayBack = value; }
        }

        //protected override void CreateChildControls()
        //{
        //    Control control = Page.LoadControl(_ascxPath);
        //    Controls.Add(control);
        //}

        protected override void Render(HtmlTextWriter writer)
        {
            SPSite site = null;
            SPWeb web = SPContext.Current.Web;
            if (!string.IsNullOrEmpty(FlashFilePath) && !string.IsNullOrEmpty(FlashWidth) && !string.IsNullOrEmpty(FlashHeight))
            {
                try
                {
                    SPSecurity.RunWithElevatedPrivileges(delegate()
                    {
                        site = new SPSite(web.Site.ID);

                        using (site)
                        {
                            #region Script
                            writer.Write("");
                            writer.Write("");
                            writer.Write("");
                            writer.Write("");
                            writer.Write("");
                            writer.Write("");
                            writer.Write("");
                            #endregion
                        }
                    });
                }
                catch (Exception ex)
                {
                    writer.Write(ex.Message);
                }
            }
            else
            {
                writer.Write("");
                writer.Write("Please configure the Media WebPart properties in webpart properties section");
                writer.Write("");
            }
        }
    }
}

Most Common Custom WebParts Part 3 – Windows OR YouTube Media Player WebPart

G Vijai Kumar — Sun, 28 Nov 2010 10:35:09 +0000

In my previous post you can view the most commonly used custom webparts, Tree View WebPart Shows Sites and Sub-Sites and Menu WebPart Shows Sites and Sub-Sites in Fly-Out Mode

Now I got one more chance to continue the series of most commonly used custom webparts, so once again I come up with a simple Windows Or Youtube Media Player webpart which plays video on Sharepoint sites, the webpart also supports to configure the properties as required.

In the webpart properties section please enter the Windows media or Youtube link, the webpart automatically detects the media type and plays accordingly

Download the solution file WindowsORYouTubeMediaWebPart.wsp

Windows Or YouTube Player WebPart (Playing Windows media Video)

Windows Or YouTube Player WebPart (Playing Youtube Video)

Windows Or YouTube Player WebPart Properties

using System;
using System.ComponentModel;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;

namespace WindowsMediaWebPart.MediaWebPart
{
    [ToolboxItemAttribute(false)]
    public class WindowsMedia : WebPart
    {
        // Visual Studio might automatically update this path when you change the Visual Web Part project item.
        //private const string _ascxPath = @"~/_CONTROLTEMPLATES/WindowsMediaWebPart/MediaWebPart/MediaWebPartUserControl.ascx";

        private string videoFilePath = string.Empty;
        private string videoWidth = "320";
        private string videoHeight = "240";
        private bool animationAtStart = true;
        private bool transparentAtStart = true;
        private bool autoStart = true;
        private bool showControls = true;
        private bool loopPlayBack = true;
        private string frameBorder = "0";

        [WebBrowsable(true),
        Personalizable(PersonalizationScope.User),
        WebDescription("Specifies the media file location"),
        Category("Media Properties"),
        WebDisplayName("Media File Location")]
        public string VideoFilePath
        {
            get { return videoFilePath; }
            set { videoFilePath = value; }
        }

        [WebBrowsable(true),
        Personalizable(PersonalizationScope.User),
        WebDescription("Sets the width of the Media player"),
        Category("Media Properties"),
        WebDisplayName("Width")]
        public string VideoWidth
        {
            get { return videoWidth; }
            set { videoWidth = value; }
        }

        [WebBrowsable(true),
        Personalizable(PersonalizationScope.User),
        WebDescription("Sets the height of the Media player"),
        Category("Media Properties"),
        WebDisplayName("Height")]
        public string VideoHeight
        {
            get { return videoHeight; }
            set { videoHeight = value; }
        }

        [WebBrowsable(true),
        Personalizable(PersonalizationScope.User),
        WebDescription("Animation At Start: (True/False)"),
        Category("Media Properties"),
        WebDisplayName("Animation At Start")]
        public bool AnimationAtStart
        {
            get { return animationAtStart; }
            set { animationAtStart = value; }
        }

        [WebBrowsable(true),
        Personalizable(PersonalizationScope.User),
        WebDescription("Transparent At Start: (True/False)"),
        Category("Media Properties"),
        WebDisplayName("Transparent At  Start")]
        public bool TransparentAtStart
        {
            get { return transparentAtStart; }
            set { transparentAtStart = value; }
        }

        [WebBrowsable(true),
        Personalizable(PersonalizationScope.User),
        WebDescription("Auto Start: (True/False) Starts the video automatically"),
        Category("Media Properties"),
        WebDisplayName("Auto Start")]
        public bool AutoStart
        {
            get { return autoStart; }
            set { autoStart = value; }
        }

        [WebBrowsable(true),
        Personalizable(PersonalizationScope.User),
        WebDescription("Show Controls: (True/False) Displays media player controls"),
        Category("Media Properties"),
        WebDisplayName("Show Controls")]
        public bool ShowControls
        {
            get { return showControls; }
            set { showControls = value; }
        }

        [WebBrowsable(true),
        Personalizable(PersonalizationScope.User),
        WebDescription("Loop Play Back: (True/False) Repeats the video automatically"),
        Category("Media Properties"),
        WebDisplayName("Loop Play Back")]
        public bool LoopPlayBack
        {
            get { return loopPlayBack; }
            set { loopPlayBack = value; }
        }

        [WebBrowsable(true),
        Personalizable(PersonalizationScope.User),
        WebDescription("Sets the border of the media (applicable for youtube videos)"),
        Category("Media Properties"),
        WebDisplayName("Allow Full Screen")]
        public string FrameBorder
        {
            get { return frameBorder; }
            set { frameBorder = value; }
        }

        protected override void CreateChildControls()
        {
            //Control control = Page.LoadControl(_ascxPath);
            //Controls.Add(control);
            this.TitleUrl = VideoFilePath;
        }

        protected override void Render(HtmlTextWriter writer)
        {
            SPSite site = null;
            SPWeb web = SPContext.Current.Web;
            if (!string.IsNullOrEmpty(VideoFilePath) && !string.IsNullOrEmpty(VideoWidth) && !string.IsNullOrEmpty(VideoHeight))
            {
                try
                {
                    SPSecurity.RunWithElevatedPrivileges(delegate()
                    {
                        site = new SPSite(web.Site.ID);

                        using (site)
                        {
                            if ((videoFilePath.ToLower()).Contains("youtube.com/"))
                            {
                                Uri youtubeUri = new Uri(videoFilePath);
                                string query = youtubeUri.Query;
                                string mediaID = HttpUtility.ParseQueryString(query).Get("v");
                                string source = "http://www.youtube.com/embed/" + mediaID;
                                writer.Write("");
                            }
                            else
                            {

                                writer.Write("");
                                writer.Write("");
                                writer.Write("");
                                writer.Write("");
                                writer.Write("");
                                writer.Write("");
                                writer.Write("");
                                writer.Write("");
                                writer.Write("");

                            }
                        }
                    });
                }
                catch (Exception ex)
                {
                    writer.Write(ex.Message);
                }
            }
            else
            {
                writer.Write("");
                writer.Write("Please configure the Media WebPart properties in webpart properties section");
                writer.Write("");
            }
        }
    }
}

Most Common Custom WebParts Part 2 – Menu WebPart Shows Sites and Sub-Sites in Fly-Out Mode

G Vijai Kumar — Fri, 29 Oct 2010 05:12:49 +0000

In my previous post can view the most common custom webparts part 1

From last post I want to continue the series of most commonly used custom webparts, so once again I come up with a simple and small custom menu webpart shows all the sites and sub-sites of a SharePoint site in fly-out style

SharePoint Menu WebPart in fly-Out Style

using System;
using System.ComponentModel;
using System.Web;
using System.Drawing;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;

namespace CustomWebParts.VisualWebPart1
{
    [ToolboxItemAttribute(false)]
    public class VisualWebPart1 : WebPart
    {
        // Visual Studio might automatically update this path when you change the Visual Web Part project item.
       // private const string _ascxPath = @"~/_CONTROLTEMPLATES/CustomWebParts/TreeView/TreeViewUserControl.ascx";

        System.Web.UI.WebControls.Menu menu = null;

        protected override void CreateChildControls()
        {
            //Control control = Page.LoadControl(_ascxPath);
            //Controls.Add(control);

            menu = new System.Web.UI.WebControls.Menu();
            SPSite site = SPContext.Current.Site;
            SPWeb web = SPContext.Current.Web;

            menu.StaticDisplayLevels = 1;
            menu.MaximumDynamicDisplayLevels = 200;
            menu.Orientation = System.Web.UI.WebControls.Orientation.Horizontal;
            menu.StaticEnableDefaultPopOutImage = false;
            menu.StaticPopOutImageUrl = "/_layouts/images/menudark.gif";
            menu.SkipLinkText = "";
            menu.DynamicHoverStyle.BackColor = System.Drawing.Color.FromName("#CBE3F0");
            menu.CssClass = "ms-topNavContainer";

            menu.StaticMenuItemStyle.ItemSpacing = Unit.Pixel(0);
            menu.StaticSelectedStyle.CssClass = "ms-topnavselected";
            menu.StaticHoverStyle.CssClass = "ms-topNavHover";

            menu.DynamicMenuStyle.BackColor = System.Drawing.Color.FromName("#F2F3F4");
            menu.DynamicMenuStyle.BorderColor = System.Drawing.Color.FromName("#A7B4CE");
            menu.DynamicMenuStyle.BorderWidth = Unit.Pixel(1);

            menu.DynamicMenuItemStyle.CssClass = "ms-topNavFlyOuts";
            menu.DynamicHoverStyle.CssClass = "ms-topNavFlyOutsHover";
            menu.DynamicSelectedStyle.CssClass = "ms-topNavFlyOutsSelected";

            MenuItemStyle stMenuStyle = menu.StaticMenuItemStyle;
            stMenuStyle.CssClass = "ms-topnav";

            stMenuStyle.HorizontalPadding = 0;
            stMenuStyle.VerticalPadding = 0;
            stMenuStyle.ItemSpacing = Unit.Pixel(0);

            MenuItemStyle dyMenuStyle = menu.DynamicMenuItemStyle;
            dyMenuStyle.CssClass = "ms-topNavFlyOuts";
            dyMenuStyle.HorizontalPadding = 0;
            dyMenuStyle.VerticalPadding = 0;

            System.Web.UI.WebControls.MenuItem mItem = new System.Web.UI.WebControls.MenuItem(web.Title);
            mItem.NavigateUrl = web.Site.Url;
            menu.Items.Add(mItem);

            GenerateMenu(menu, Context);
            menu.DataBind();
            this.Controls.Add(menu);
        }

        public static void GenerateMenu(System.Web.UI.WebControls.Menu menu, HttpContext context)
        {
            SPSite site = SPContext.Current.Site;
            SPWeb web = SPContext.Current.Web;

            foreach (SPWeb subsite in web.Webs)
            {
                System.Web.UI.WebControls.MenuItem mItem = new System.Web.UI.WebControls.MenuItem();
                mItem.NavigateUrl = subsite.Url;
                mItem.Text = subsite.Title;
                mItem.ToolTip = subsite.Title;
                menu.Items.Add(mItem);
                BuildMenu(subsite, mItem, context);
            }
        }

        private static void BuildMenu(SPWeb subweb, System.Web.UI.WebControls.MenuItem mItem, HttpContext context)
        {
            SPSite site = SPContext.Current.Site;
            SPWeb web = SPContext.Current.Web;

            foreach (SPWeb subsite in subweb.Webs)
            {
                System.Web.UI.WebControls.MenuItem mSubItem = new System.Web.UI.WebControls.MenuItem();
                mSubItem.NavigateUrl = subsite.Url;
                mSubItem.Text = subsite.Title;
                mSubItem.ToolTip = subsite.Title;
                mItem.ChildItems.Add(mSubItem);
            }
        }
    }
}

Most Common Custom WebParts Part 1 – Tree View WebPart Shows Sites and Sub-Sites

G Vijai Kumar — Fri, 29 Oct 2010 04:26:07 +0000

I desired to support most common custom webparts used by the SharePoint professional, so that these can be helpful for them.
A custom tree view webpart shows all the sites and sub-sites of a SharePoint site

SharePoint Custom Tree View WebPart

Please use the below code and to get the exact look as show in the aboave image, the tree view webpart can expand/collapse

using System;
using System.ComponentModel;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;

namespace CustomWebParts.CustomTreeView
{
    [ToolboxItemAttribute(false)]
    public class CustomTreeView : WebPart
    {
        // Visual Studio might automatically update this path when you change the Visual Web Part project item.
        //private const string _ascxPath = @"~/_CONTROLTEMPLATES/CustomWebParts/CustomTreeView/CustomTreeViewUserControl.ascx";

        TreeView myTree;
        LinkButton lnkBtnExpand;
        LinkButton lnkBtnCollapse;
        Label lblPipeDivider;
        Label lbl_ErrorMsg;
        private string errorMessage = string.Empty;
        private int level = 0;

        protected override void CreateChildControls()
        {
            //Control control = Page.LoadControl(_ascxPath);
            //Controls.Add(control);

            this.Controls.Clear();
            myTree = new TreeView();
            myTree.ExpandImageUrl = "/_layouts/images/tvplus.gif";
            myTree.RootNodeStyle.ImageUrl = "/_layouts/images/stsicon.gif";
            myTree.ParentNodeStyle.ImageUrl = "/_layouts/images/stsicon.gif";
            myTree.LeafNodeStyle.ImageUrl = "/_layouts/images/stsicon.gif";
            myTree.CollapseImageUrl = "/_layouts/images/tvminus.gif";
            myTree.NoExpandImageUrl = "/_layouts/images/stsicon.gif";            

            myTree.NodeWrap = true;
            myTree.ShowLines = true;
            myTree.ShowExpandCollapse = true;
            myTree.EnableClientScript = true;

            GenerateTreeView();
            myTree.CollapseAll();
            myTree.CssClass = "ms-navitem a";
            this.Controls.Add(myTree);

            lnkBtnExpand = new LinkButton();
            lnkBtnExpand.Click += new EventHandler(expandAll_Click);
            lnkBtnExpand.Text = "Expand all";
            lnkBtnExpand.CssClass = "ms-navitem a";
            this.Controls.Add(lnkBtnExpand);

            lblPipeDivider = new Label();
            lblPipeDivider.Text = "  |  ";
            this.Controls.Add(lblPipeDivider);

            lnkBtnCollapse = new LinkButton();
            lnkBtnCollapse.Click += new EventHandler(collapseAll_Click);
            lnkBtnCollapse.Text = "Collapse all";
            lnkBtnCollapse.CssClass = "ms-navitem a";
            this.Controls.Add(lnkBtnCollapse);

            lbl_ErrorMsg = new Label();
            this.Controls.Add(lbl_ErrorMsg);

            base.CreateChildControls();
        }

        private void GenerateTreeView()
        {
            SPSite mySite = null;
            SPWeb myWeb = SPContext.Current.Web;
            SPSecurity.RunWithElevatedPrivileges(delegate()
            {
                try
                {
                    mySite = new SPSite(myWeb.Site.ID);
                    using (mySite)
                    {
                        level = 1;
                        foreach (SPWeb subWeb in myWeb.Webs)
                        {
                            TreeNode myTreeNode = new TreeNode(subWeb.Title);
                            myTreeNode.NavigateUrl = subWeb.Url;
                            ReadSubSites(subWeb, ref myTreeNode);
                            myTree.Nodes.Add(myTreeNode);
                        }

                    }
                }
                catch (Exception ex)
                {
                    errorMessage = ex.ToString();
                }
            });
        }

        private void ReadSubSites(SPWeb subWeb, ref TreeNode myTreeNode)
        {
            try
            {
                foreach (SPWeb myChildSubWeb in subWeb.Webs)
                {
                    TreeNode subnode = new TreeNode(myChildSubWeb.Title);
                    subnode.NavigateUrl = myChildSubWeb.Url;

                    myTreeNode.ChildNodes.Add(subnode);

                    if (myChildSubWeb.Webs.Count > 0)
                    {
                        if (myTreeNode.ChildNodes.Count > 0)
                        {
                            level = level + 1;
                            TreeNode myChildNode = myTreeNode.ChildNodes[myTreeNode.ChildNodes.Count - 1];
                            ReadSubSites(myChildSubWeb, ref myChildNode);
                            level = level - 1;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                errorMessage = ex.ToString();
            }
        }

        void expandAll_Click(object sender, EventArgs e)
        {
            myTree.ExpandAll();
        }

        void collapseAll_Click(object sender, EventArgs e)
        {
            myTree.CollapseAll();
        }      

        protected override void RenderContents(HtmlTextWriter writer)
        {
            EnsureChildControls();
            lnkBtnExpand.RenderControl(writer);
            lblPipeDivider.RenderControl(writer);
            lnkBtnCollapse.RenderControl(writer);
            RenderChildren(writer);
        }
    }
}

Understanding SharePoint Property Bag Settings

G Vijai Kumar — Mon, 30 Aug 2010 16:14:23 +0000

Today my ex-coworker and friend ask me regarding SharePoint property bag, therefore I got an opportunity of posting this article on understanding SharePoint property bag settings.

SharePoint property bag is a good place where we are able to accumulate key and value like a couple, It’s a hash table.

There is no such user interface to view/add/edit/delete the property bag key-value, but there is an option to perform the actions on property bag via SharePoint designer.

After you open a site in SharePoint Designer, go to Site menu click on Settings option, a Site Settings dialog box opens, click on Parameters tab where you can see the list of existing properties, from the same place you can even perform add/modify/remove actions.

View SharePoint property bag properties using SharePoint Designer

Subsequently, prior to start on deep into property bag, we will discuss going on additional area some where we can store up value other than SharePoint property bag.

web.config file is too a place where we be able to accumulate the settings such as file location, URLs, etc.
Example:

In view of the fact that we have single global web.config file meant for complete site. If we would like to accumulate additional settings correlated to several sites we have to make multiple entries in web.config file.

One more method of storing the settings by creating table in database, this approach is not recommend all the time in SharePoint.

Even we can store values in SharePoint list by creating two columns like Keys and Values using OOTB functionality and still can access the key-value pair using object model.

But, if you have several settings related to different sites with some unique permissions for individuals sites then we have to decide where the list is to be created.

On the way to over come this situation SharePoint provided property bag to store the properties in several levels like SPFarm, SPWebApplication, SPSite, SPWeb and SPList.

Storing key-value in SPFarm include more danger that require farm administrator privileges.

Below are few examples on SPFarm, SPWebApplication, SPSite, SPWeb add/view/edit/delete property bag values.

Add property in SPFarm level

static void Main(string[] args)
        {
            SPFarm myFarm = SPFarm.Local;
            myFarm.Properties.Add("SPFarmKey", "SPFarmValue");
            myFarm.Update();
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

View SPFarm property


static void Main(string[] args)
        {
            SSPFarm myFarm = SPFarm.Local;
            if (myFarm.Properties != null && myFarm.Properties.Count > 0)
            {
                if (myFarm.Properties.ContainsKey("SPFarmKey"))
                {
                    Console.WriteLine(myWebApplication.Properties["SPFarmKey"]);
                }
            }
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Modify property in SPFarm level


static void Main(string[] args)
        {
            SPFarm myFarm = SPFarm.Local;
            myFarm.Properties["SPFarmKey"] = "NewSPFarmValue";
            myFarm.Update();
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Delete property in SPFarm level


static void Main(string[] args)
        {
            SPFarm myFarm = SPFarm.Local;
            myFarm.Properties["SPFarmKey"] = null;
            myFarm.Properties.Remove("SPFarmKey");
            myFarm.Update();
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Add property in SPWebApplication level


static void Main(string[] args)
        {
            SPWebApplication myWebApplication = SPWebApplication.Lookup(new Uri("http://WebApplicationURL"));
            myWebApplication.Properties.Add("SPWebAppKey", "SPWebAppValue");
            myWebApplication.Update();
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

View SPWebApplication property


static void Main(string[] args)
        {
            SPWebApplication myWebApplication = SPWebApplication.Lookup(new Uri("http://WebApplicationURL"));
            if (myWebApplication.Properties != null && myWebApplication.Properties.Count > 0)
            {
                if (myWebApplication.Properties.ContainsKey("SPWebAppKey"))
                {
                    Console.WriteLine(myWebApplication.Properties["SPWebAppKey"]);
                }
            }
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Modify property in SPWebApplication level


static void Main(string[] args)
        {
            SPWebApplication myWebApplication = SPWebApplication.Lookup(new Uri("http://WebApplicationURL"));
            myWebApplication.Properties["SPWebAppKey"] = "NewSPWebAppValue";
            myWebApplication.Update();
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Delete property in SPWebApplication level


static void Main(string[] args)
        {
            SPWebApplication myWebApplication = SPWebApplication.Lookup(new Uri("http://WebApplicationURL"));
            myWebApplication.Properties["WebAppKey"] = null;
            myWebApplication.Properties.Remove("WebAppKey");
            myWebApplication.Update();
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

There is no facility to store properties in SPSite object similar to SPWeb object, if you want to store the settings in site collection level we have to use SPSite.RootWeb

Add/retrieve SPSite property


static void Main(string[] args)
        {
            SPSite siteCollection = new SPSite("http://servername:port");
            SPWeb site = siteCollection.RootWeb;
            //Addning SPSite Property
            site.Properties.Add("SPSiteKey", "SPSiteValue");
            site.Properties.Update();

            //Reading SPSite Property
            Console.WriteLine(site.Properties["SPSiteKey"]);
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Add/retrieve SPWeb property

static void Main(string[] args)
        {
            SPSite mySite = new SPSite("http://servername:port");
            SPWeb myWeb = mySite.OpenWeb("Your Web Name.....");
            //Adding SPWeb Property
            myWeb.Properties.Add("SPWebKey", "SPWebValue");
            myWeb.Properties.Update();

            //Reading SPWeb Property
            Console.WriteLine(myWeb.Properties["SPWebKey"]);
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

A quick look on Sharepoint object model programs – Part 3

G Vijai Kumar — Sat, 28 Aug 2010 13:55:02 +0000

I have got the chance to post useful Sharepoint object model programs (part 3) with bare minimum lines of code and really handy even.
Please follow the link for a quick look on Sharepoint object model programs Part 1 and Part 2

Creating a Folder in a Document Library:

static void Main(string[] args)
        {
            try
            {
                SPSite mySite = new SPSite("http://servername:port");
                SPWeb myWeb = mySite.OpenWeb();
                SPList MyLibrary = myWeb.Lists["Your Document Library Name....."];
                SPFolder myFolder = MyLibrary.RootFolder;
                SPFolder myChildFolder = myFolder.SubFolders.Add("Your Folder Name.....");
                myFolder.Update();
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex);
            }
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Add fields to list:

static void Main(string[] args)
        {
            try
            {
                SPSite mySite = new SPSite("http://servername:port");
                SPWeb myWeb = mySite.OpenWeb();
                SPList myList = myWeb.Lists["Your List Name....."];
                Guid listId = myList.ID;
                myList.Fields.Add("Employee ID", SPFieldType.Number, true);
                myList.Fields.Add("Employee Name", SPFieldType.Text, false);
                myList.Fields.Add("Designation", SPFieldType.Text, false);
                myList.Update();
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex);
            }
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Creating a new view in a list:

static void Main(string[] args)
        {
            try
            {
                SPSite mySite = new SPSite("http://servername:port");
                SPWeb myWeb = mySite.OpenWeb();
                SPList mylist = myWeb.Lists["Your List Name....."];
                StringCollection myFields = new StringCollection();
                myFields.Add("Employee Name");
                myFields.Add("Designation");
                SPView myView= mylist.Views.Add("Your View Name.....", myFields, null, 100, false, false, SPViewCollection.SPViewType.Html, false);
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex);
            }
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Creating a new Content Type:

static void Main(string[] args)
        {
            try
            {
                SPSite mySite = new SPSite("http://servername:port");
                SPWeb myWeb = mySite.OpenWeb();
                SPContentTypeCollection myContentTypeCollection = myWeb.ContentTypes;
                SPContentType myContentType= new SPContentType(myContentTypeCollection[SPBuiltInContentTypeId.Item], myContentTypeCollection, "Content Type Name.....");
                myContentTypeCollection.Add(myContentType);
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex);
            }
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Adding the existing Site Columns to existing Content Type:

static void Main(string[] args)
        {
            try
            {
                SPSite mySite = new SPSite("http://servername:port");
                SPWeb myWeb = mySite.OpenWeb();
                SPFieldCollection myFieldCollection = myWeb.Fields;
                SPContentType myContentType=myWeb.ContentTypes["Content Type Name"];
                myContentType.FieldLinks.Add(new SPFieldLink(myFieldCollection["Employee Name"]));
                myContentType.FieldLinks.Add(new SPFieldLink(myFieldCollection["Designation"]));
                myContentType.Update();
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex);
            }
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Save site as template:

static void Main(string[] args)
        {
            try
            {
                SPSite mySite = new SPSite("http://servername:port");
                SPWeb myWeb = mySite.OpenWeb();
                myWeb.SaveAsTemplate("FiveNumber.stp", "FiveNumber", "Its All About SharePoint", true);
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex);
            }
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Delete Recycle Bin Items:

static void Main(string[] args)
        {
            SPSite mySite = new SPSite("http://servername:port");
            SPWeb myWeb = mySite.OpenWeb();
            SPRecycleBinItemCollection myRecycleBinCollection = mySite.RecycleBin;
            for (int i = 0; i < myRecycleBinCollection.Count; i++)
            {
                myRecycleBinCollection[i].Delete();
                i--;
            }
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

SharePoint Event Handlers – Asynchronous Vs Synchronous

G Vijai Kumar — Sat, 21 Aug 2010 11:54:26 +0000

There is a little puzzlement among Asynchronousand Synchronous events, however I believe after reading this article, there will be no place for confusion in your brain, the reason for that I go behind a childlike practice to memorize what is Asynchronous ? and what is Synchronous ?

The same babyish method, I want to share with you.

A for Apple, A for Asynchronous and A for After events, so all Asynchronous events occur after the event, which does not stop the code to execute. All Asynchronous events end with ‘ed’ letters like SiteDeleted, FieldAdded, ItemAdded etc.

Now, let’s talk on the subject of Synchronous events, all Synchronous events occur before the event, which stop the code to execute. All Synchronous events end with ‘ing’ letters like SiteDeleting, FieldAdding, ItemAdding etc.

SPWebEventReceiver Asynchronous Events

SiteDeleted	Occurs after an existing site collection deleted.
WebDeleted	Occurs after an existing web site is completely deleted.
WebMoved	Occurs after an existing web site has been moved.

SPWebEventReceiver Synchronous Events

SiteDeleting	Occurs before an existing site collection is being deleted.
WebDeleting	Occurs before an existing web site is deleted.
WebMoving	Occurs before an existing web site has been renamed or moved

SPListEventReceiver Asynchronous Methods

FieldAdded	Occurs after a field link is added.
FieldDeleted	Occurs after a field has been removed from the list.
FieldUpdated	Occurs after a field link has been updated

SPListEventReceiver Synchronous Methods

FieldAdding	Occurs before a field link is added to a content type.
FieldDeleting	Occurs before a field is removed from the list.
FieldUpdating	Occurs before a field link is updated

SPItemEventReceiver Asynchronous Methods

ItemAdded	Occurs after a new item has been added
ItemAttachmentAdded	Occurs after an attachment added to an item.
ItemAttachmentDeleted	Occurs after an attachment removed from an item.
ItemCheckedOut	Occurs after an item is checked out.
ItemDeleted	Occurs after an item is completely deleted.
ItemFileMoved	Occurs after a file is moved.
ItemUpdated	Occurs after an item is modified/edited.

SPListItemEventReceiver Synchronous Methods

ItemAdding	Occurs before a new item is added.
ItemAttachmentAdding	Occurs before an attachment is added to an item.
ItemAttachmentDeleting	Occurs before an attachment when a user removed from an item.
ItemCheckingIn	Occurs before a file is checking-in.
ItemCheckingOut	Occurs before an item is checking-out.
ItemDeleting	Occurs before an item is completely deleted.
ItemFileMoving	Occurs before a file is moved.
ItemUncheckedOut	Occurs before an item is unchecked out.
ItemUncheckingOut	Before event that occurs when an item is being unchecked out.
ItemUpdating	Occurs before an existing item is modified/edited.

SharePoint Foundation 2010 New Events

Microsoft added several new events to SharePoint Foundation 2010 on Site, List and Item level. These fresh events are intended to meet up the requirements and for better elasticity.

SPWebEventReceiver

WebAdding	Occurs before a new web site is created.
WebProvisioned	Occurs after the web is provisioned.

WebAdding: event arises prior to a fresh web site is created, we can control the website to create or not to create by WebAdding event, then no SharePoint site is created and the provisioning process is not started.

WebProvisioned: event arise after the web is totally provisioned and process has stopped up. WebProvisioned can be configured to control in any synchronous or asynchronous methods.

If user wants to add few webparts to the newly provisioned web we can use this event to meet up the necessity

SPListEventReceiver

ListAdding	Occurs before a list is created.
ListAdded	Occurs after a list is created.
ListDeleting	Occurs before a list is deleted.
ListDeleted	Occurs after a list is deleted.

Please follow Catalog of SharePoint Foundation Events for newly added event in SharePoint Foundation 2010

A quick look on WSS Out Of Box web services – Part 2

G Vijai Kumar — Mon, 19 Apr 2010 09:31:08 +0000

In my previous post you can have a quick look on WSS Out Of Box web services – Part 1

In this post once again I want to update few WSS web service handy programs with minimum lines of code.

Before executing the code first of all add web reference http://servername:port/_vti_bin/Webs.asmx
In this example I have given the web reference folder name as myWebswebservice

Show all subsites:

 static void Main(string[] args)
        {
myWebswebservice.Webs allWebs = new myWebswebservice.Webs();
//credentials for password based authentication
//System.Net.NetworkCredential mycredentials = new System.Net.NetworkCredential("g.vijaikumar", "mypassword", "fivenumber");
//allWebs.Credentials = mycredentials;
//using system credentials of the application
allWebs.Credentials = System.Net.CredentialCache.DefaultCredentials;
try
{
string webTitle = null;
XmlNode myNode = allWebs.GetAllSubWebCollection();
XmlNodeList nodes = myNode.SelectNodes("*");
foreach (XmlNode node in nodes)
{
Console.WriteLine(webTitle + node.Attributes["Title"].Value);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
Console.WriteLine("Press any key to continue.....");
Console.ReadLine();
}

A quick look on Sharepoint object model programs – Part 2

G Vijai Kumar — Mon, 29 Mar 2010 12:04:03 +0000

In my previous post you can have a quick look on Sharepoint object model programs – Part 1

Here, once again am going to post Sharepoint object model programs (part 2) with minimum lines of code and are really handy, which are actually most useful even.

Show only BLOG sites:

//STS#0 – Team Site
//STS#1 – Blank Site
//STS#2 – Document Workspace
//MPS#0 – Basic Meeting Workspace
//MPS#1 – Blank Meeting Workspace
//MPS#2 – Decision Meeting Workspace
//MPS#3 – Social Meeting Workspace
//MPS#4 – Multipage Meeting Workspace
//WIKI#0 – Wiki
//BLOG#0 – Blog

static void Main(string[] args)
        {
            SPSite site = new SPSite("http://servername:port");
            foreach (SPWeb web in site.AllWebs)
            {
                string template = web.WebTemplate + "#" + web.Configuration;
                if (template.ToUpper() == "BLOG#0")
                {
                    Console.WriteLine(web.Title);
                }
            }
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Show services and status in Sharepoint server farm:

static void Main(string[] args)
        {
            SPServiceCollection services = SPFarm.Local.Services;
            foreach (SPService service in services)
            {
                Console.WriteLine("Service Name: {0}", service.Name);
                Console.WriteLine("Service Status: {0}", service.Status);
                Console.WriteLine("-------------------------------------");
            }
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Adding/Retrieving values to property bag:

static void Main(string[] args)
        {
            using (SPSite siteCollection = new SPSite("http://servername:port"))
            {
                using (SPWeb site = siteCollection.RootWeb)
                {
                    site.Properties.Add("TempKey", "TempValue");//Adding value
                    site.Properties.Update();

                    Console.WriteLine(site.Properties["TempKey"]);//Reading value
                }
            }
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Read files in a folder:

static void Main(string[] args)
        {
            SPSite site = new SPSite("http://servername:port");
            SPWeb web = site.OpenWeb();
            SPFolder folder = web.GetFolder("Shared Documents");
            SPFileCollection files = folder.Files;
            foreach (SPFile file in files)
            {
                Console.WriteLine(file.Name.ToString());
            }
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Get content database for all site collections:

 static void Main(string[] args)
        {
                SPSite site = new SPSite("http://CentralAdminSiteURL");
                SPFarm farm = site.WebApplication.Farm;
                SPWebService service = farm.Services.GetValue("");
                foreach (SPWebApplication webapp in service.WebApplications)
                {
                    foreach (SPSite mysite in webapp.Sites)
                    {
                        Console.WriteLine(mysite.Url+" ----- "+ mysite.ContentDatabase.Name);
                    }
                }
            Console.WriteLine("Press any key to continue.....");
            Console.ReadLine();
        }

Sharepoint list form generator

G Vijai Kumar — Wed, 14 Oct 2009 15:49:38 +0000

Today I am going to show you how to generate a list form dynamically as soon as you select the list name you can see the form generated for you with file upload field (attachment). I also know that there is an excellent solution Sharepoint Form Generator developed by Alon Havivi, but still I want to share with you, so that for some one the code may be helpful as a whole or part of it

No problem whether your list contains 1 field or 100 fields, code will generate all the ‘n’ no.of fields with file upload field (attachment) contained in the list. It loops through all the input fields and creates at runtime.

All you have to do is, open visual studio 2005/2008 create a new project using webpart template use the code from WebPart1.cs and FormGeneratorToolPart.cs build the project, place the .dll file in GAC or site bin directory, add the necessary safe control tag in Web.config file, import the webpart in to gallery, and add the same on to your site, after adding the webpart in your site you have to select the list name from the webpart properties, so that you can see the generated form similar to the form as in NewForm.aspx

Select the list name from the list of lists

List form generated

Download the complete source code (Please Note: Code cannot be viewed properly on the web page, so please use the below links to view the code or for downloading)

WebPart1.cs
FormGeneratorToolPart.cs

WebPart1.cs

using System;
using System.Web;
using System.IO;
using System.Runtime.InteropServices;
using System.Web.UI;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Serialization;
using System.Web.UI.WebControls;

using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using Microsoft.SharePoint.WebPartPages;

namespace FormGenerator
{
    [Guid("93612d52-737c-4e83-83c3-a228910e87a3")]
    public class FormGenerator : Microsoft.SharePoint.WebPartPages.WebPart
    {
        Table oFormTable;
        FileUpload oFormFileUpload;
        FieldLabel oFormLabelField;
        FormField oFormField;
        Button oFormButtonSubmit;
        Label oFormLabelMessage;

        SPList oFormList;

        private string _FormList = string.Empty;

        string qstitle = string.Empty;
        string qsmission = string.Empty;

        public string FormList
        {
            get { return _FormList; }
            set { _FormList = value; }
        }

        protected override void CreateChildControls()
        {
            base.CreateChildControls();

            oFormTable = new Table();
            oFormTable.CellPadding = 0;
            oFormTable.CellSpacing = 0;            

            oFormLabelMessage = new Label();
            oFormLabelMessage.ID = "lbl_message";
            oFormLabelMessage.CssClass = "ms-formvalidation";
            this.Controls.Add(oFormLabelMessage);

            //Generate Form
            GenerateFormList();
        }

        private void GenerateFormList()
        {
            SPWeb oWeb = Microsoft.SharePoint.WebControls.SPControl.GetContextWeb(Context);
            if (FormList != "")
            {
                try
                {
                    oFormList = oWeb.Lists[FormList];
                    foreach (SPField oField in oFormList.Fields)
                    {
                        if (oField.Type == SPFieldType.Attachments)
                        {
                            FieldLabel oLabelAttachmentField = new FieldLabel();
                            oLabelAttachmentField.ControlMode = SPControlMode.New;
                            oLabelAttachmentField.ListId = oFormList.ID;
                            oLabelAttachmentField.FieldName = oField.InternalName;

                            oFormFileUpload = new FileUpload();
                            oFormFileUpload.ID = "FileUpload";

                            AttachmentsField oAttachmentField = new AttachmentsField();
                            oAttachmentField.ControlMode = SPControlMode.New;
                            oAttachmentField.ListId = oFormList.ID;
                            oAttachmentField.FieldName = oField.InternalName;
                            oAttachmentField.Controls.Add(oFormFileUpload);
                            oAttachmentField.ID = "Control_" + oField.InternalName;

                            TableRow oRowAttachment = new TableRow();
                            oFormTable.Rows.Add(oRowAttachment);
                            TableCell oCellAttachmentLabel = new TableCell();
                            oRowAttachment.Cells.Add(oCellAttachmentLabel);

                            oCellAttachmentLabel.Controls.Add(oLabelAttachmentField);
                            oCellAttachmentLabel.CssClass = "ms-formlabel";
                            TableCell oCellAttachment = new TableCell();
                            oRowAttachment.Cells.Add(oCellAttachment);
                            oCellAttachment.Controls.Add(oAttachmentField);
                            oCellAttachment.CssClass = "ms-formbody";
                        }
                    }

                    // Loop through all the fields in the list
                    foreach (SPField oField in oFormList.Fields)
                    {
                        // Avoid Hidden, Read Only, Attachments field
                        if (!oField.Hidden && !oField.ReadOnlyField && oField.Type != SPFieldType.Attachments)
                        {
                            oFormLabelField = new FieldLabel();
                            oFormLabelField.ControlMode = SPControlMode.New;
                            oFormLabelField.ListId = oFormList.ID;
                            oFormLabelField.FieldName = oField.InternalName;

                            oFormField = new FormField();
                            oFormField.ControlMode = SPControlMode.New;
                            oFormField.ListId = oFormList.ID;
                            oFormField.FieldName = oField.InternalName;
                            oFormField.ID = "Control_" + oField.InternalName;

                            TableRow oRow = new TableRow();
                            oFormTable.Rows.Add(oRow);

                            TableCell oCellLabel = new TableCell();
                            oRow.Cells.Add(oCellLabel);
                            TableCell oCellControl = new TableCell();
                            oRow.Cells.Add(oCellControl);

                            oCellLabel.Controls.Add(oFormLabelField);
                            oCellControl.Controls.Add(oFormField);

                            oCellLabel.CssClass = "ms-formlabel";
                            oCellControl.CssClass = "ms-formbody";
                        }
                    }

                    //Create ASP.Net button
                    oFormButtonSubmit = new Button();
                    oFormButtonSubmit.ID = "btn_submit";
                    oFormButtonSubmit.Text = "OK";
                    oFormButtonSubmit.CssClass = "ms-ButtonHeightWidth";
                    oFormButtonSubmit.Click += new EventHandler(oFormButtonSubmit_Click);
                    this.Controls.Add(oFormButtonSubmit);

                    // Create the row for the Submit button
                    TableRow oRowButton = new TableRow();
                    oFormTable.Rows.Add(oRowButton);

                    // Create the cell for the Submit button
                    TableCell oCellButton = new TableCell();
                    oCellButton.ColumnSpan = 2;
                    oRowButton.Cells.Add(oCellButton);

                    Controls.Add(oFormTable);
                }
                catch (Exception ex)
                {
                    Page.Response.Write(ex.ToString());
                }
            }
            else
            {
                Page.Response.Write("Select valid List from webpart properties");
            }
        }

        void oFormButtonSubmit_Click(object sender, EventArgs e)
        {
            SPSite mySite = SPControl.GetContextSite(Context);
            SPWeb myWeb = SPControl.GetContextWeb(Context);
            SPList myList = myWeb.Lists[FormList];
            SPListItem myItem = myList.Items.Add();

            //Validating the controls
            foreach (SPField sField in myList.Fields)
            {
                if (sField.Required == true)
                {
                    string oControl = "Control_" + sField.InternalName.ToString();
                    Control oFieldControl = this.FindControl(oControl);
                    FormField sFormField = (FormField)oFieldControl;
                    if ((sFormField.Value) == null || (sFormField.Value.ToString()) == "")
                    {
                        oFormLabelMessage.Visible = true;
                        oFormLabelMessage.Text = "* indicates required fields";
                        return;
                    }
                }
            }
            foreach (SPField oField in myList.Fields)
            {
                string oFieldID = "Control_" + oField.InternalName;
                Control sFieldControl = this.FindControl(oFieldID);
                if (sFieldControl != null)
                {
                    if (oField.Type != SPFieldType.Attachments)
                    {
                        FormField sFormField = (FormField)sFieldControl;
                        myItem[oField.InternalName] = sFormField.Value;
                    }
                    else
                    {
                        AttachmentsField sAttachmentField = (AttachmentsField)sFieldControl;
                        FileUpload oFileControl = (FileUpload)sAttachmentField.FindControl("FileUpload");
                        if (oFileControl != null)
                        {
                            try
                            {
                                HttpPostedFile oPostedFile = oFileControl.PostedFile;
                                string oFileName = Path.GetFileName(oPostedFile.FileName);
                                if (oPostedFile.ContentLength > 0)
                                {
                                    Stream oInputStream = oPostedFile.InputStream;
                                    byte[] oBT = new byte[oPostedFile.InputStream.Length];
                                    oPostedFile.InputStream.Seek(0, SeekOrigin.Begin);
                                    oPostedFile.InputStream.Read(oBT, 0, oBT.Length);
                                    myItem.Attachments.Add(oFileName, oBT);
                                }
                            }
                            catch (Exception ex)
                            {
                                oFormLabelMessage.Visible = true;
                                oFormLabelMessage.Text = ex.ToString();
                            }
                        }
                    }
                }
                myWeb.AllowUnsafeUpdates = true;
                myItem.Update();
                myWeb.AllowUnsafeUpdates = false;
                oFormLabelMessage.Visible = true;
                oFormLabelMessage.Text = "Record updated";
            }
        }

        protected override void Render(HtmlTextWriter writer)
        {
            if (FormList != "")
            {
                writer.Write("");
                oFormLabelMessage.RenderControl(writer);
                writer.Write("");
                writer.Write("
");
                writer.Write("");
                writer.Write("");
                oFormTable.RenderControl(writer);
                writer.Write("
");
                oFormButtonSubmit.RenderControl(writer);
                writer.Write("");
            }
            else
            {
                oFormLabelMessage.RenderControl(writer);
            }
        }

        public override ToolPart[] GetToolParts()
        {
            ToolPart[] allToolParts = new ToolPart[3];
            WebPartToolPart standardToolParts = new WebPartToolPart();
            CustomPropertyToolPart customToolParts = new CustomPropertyToolPart();
            allToolParts[0] = standardToolParts;
            allToolParts[1] = customToolParts;
            allToolParts[2] = new FormGeneratorToolPart();
            return allToolParts;
        }
    }
}

FormGeneratorToolPart.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Web.UI.WebControls;
using Microsoft.SharePoint;

namespace FormGenerator
{
    class FormGeneratorToolPart: Microsoft.SharePoint.WebPartPages.ToolPart
    {
        FormGenerator oFG;
        Panel oToolPartPanel;
        DropDownList oDDLListProvider;

        protected override void CreateChildControls()
        {
            base.CreateChildControls();

            oToolPartPanel = new Panel();
            Controls.Add(oToolPartPanel);

            oDDLListProvider = new DropDownList();
            oToolPartPanel.Controls.Add(oDDLListProvider);

            PopulateProviderList();
        }

        private void PopulateProviderList()
        {
            SPListCollection myListCol = SPContext.Current.Web.Lists;
            oDDLListProvider.AppendDataBoundItems = true;
            foreach (SPList myList in myListCol)
            {
                ListItem myListItem = new ListItem(myList.Title, myList.Title);
                oFG = (FormGenerator)this.ParentToolPane.SelectedWebPart;
                if (oFG.FormList == myList.Title)
                    myListItem.Selected = true;
                oDDLListProvider.Items.Add(myListItem);
            }
        }

        public override void ApplyChanges()
        {
            base.ApplyChanges();
            oFG.FormList = oDDLListProvider.SelectedValue;
        }

        public override void SyncChanges()
        {
            base.SyncChanges();
            oDDLListProvider.SelectedValue = oFG.FormList.ToString();
        }

        protected override void RenderToolPart(System.Web.UI.HtmlTextWriter output)
        {
            output.Write("List Name Lookup:");
            output.Write("

");
            oDDLListProvider.RenderControl(output);
            output.Write("

 


");
        }
    }
}