Tippu’s Blog

Hi All, Microsoft is sharing the sneak peek of sharepoint 2010. Some developer features are looking great. In coming months we can see lots of extensive blogging on this.  Check this out http://sharepoint.microsoft.com/2010/Sneak_Peek/Pages/default.aspx

In this article I am going to show you how to set the Audience Target while adding a web part.

I am adding a Content Editor Web part to the default page of the site  with the Audience Target set the two SharePoint groups named “SharepointGroup1” and “SharepointGroup2”.

Webpart class have a property called AuthorizationFilter, which is used to set the Audience Target for the web part. One thing we need to be careful is to add the “;;;;” before the group filter string on the AuthorizationFilter property.

Note: While using the SPLimitedWebPartManager, do Dispose of the web object on the web part manager class.

Sample Source Code:

using (SPSite oSite = new SPSite("http://Tippu/sites/AudianceTargetTest"))
{
    using (SPWeb oWeb = oSite.OpenWeb())
    {
        using (SPLimitedWebPartManager oWebpartMngr =
            oWeb.GetLimitedWebPartManager("Default.aspx", PersonalizationScope.Shared))
        {
            try
            {
                ContentEditorWebPart wpContent = new ContentEditorWebPart();
                wpContent.ChromeType = PartChromeType.None;

                //The audience target field needs to have this ";;;;" at the
                //beginning of the string
                wpContent.AuthorizationFilter = 
                   ";;;;SharepointGroup1,SharepointGroup2";

                XmlDocument xmlDoc = new XmlDocument();
                XmlElement xmlElement = xmlDoc.CreateElement("SampleText");
                xmlElement.InnerText = 
                  "This web part is only visible to SharepointGroup1 and SharepointGroup2";

                oWebpartMngr.AddWebPart(wpContent, "Left", 1);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                //When using the Web part manager, do dispose the 
                //SPWeb object inside the web part manager class
                oWebpartMngr.Web.Dispose();
            }
        }
    }
}

In this article I will show you how to add the Target Audience on the SharePoint Navigation. The SPNavigationNode class has a property called “Properties”, which allows us to added custom properties to the node. One of the Property is “Audience”, which is used for setting the target audience on the navigation node.

using (SPSite oSite = new SPSite("http://Tippu/sites/AudianceTargetTest"))
{
    using (SPWeb oWeb = oSite.OpenWeb())
    {
        SPNavigationNode oNode = oWeb.Navigation.GlobalNodes[0];

        if (oNode.Properties.Contains("Audience"))
            oNode.Properties["Audience"] = ";;;;SharepointGroup1,SharepointGroup2";
        else
            oNode.Properties.Add("Audience", ";;;;SharepointGroup1,SharepointGroup2");
    }
}

Hi Guys,

After getting good response on one of my article on “Tray Notification”, I am now going to show you how to do the same thing on the Windows Presentation Framework (WPF). Adding It is straight forward as we do in the regular Windows Forms Application. To add the Tray notification to WPF, you just need to add the “System.Windows.Forms” assembly reference to your WPF project. Once you add the reference, you can create new instance of the “NotifyIcon” class and  use it in your WPF application. Lets me show you how to do this in step by step.

Step 1: Create a blank WPF Application project

 Step 2: Add reference to “System.Windows.Forms”

Step 3:  Declare a global variable for NotifyIcon, ContextMenuStrip and ToolStripMenuItem

private System.Windows.Forms.NotifyIcon TippuTrayNotify;
private System.Windows.Forms.ContextMenuStrip ctxTrayMenu;
private System.Windows.Forms.ToolStripMenuItem mnuExit;

NotofyIcon – This is the class which is used to show the application icon on the system tray.

ContentMenuStrip – This is the class which is used to show the context menu when the user right clicks on the system tray icon.

ToolStripMenuItem – This is the class which is used to show the menu item where the user performs the action on the context menu.

Usually in windows forms application, we used to do this by dragging and dropping the icons for the above mentioned classed on the form itself and assign property to it. Here in WPF world, its little different. We need to do some of the stuff manually, so lets continue our WPF tray notification application.

Step 4: 

Add the ToolstripMenuItem object to the ContextMenuStrip and then add the ContextMenuStrip to the NotifyIcon object. Assign the events for the menu item as shown in the sample code.

Enjoy WFP Programming…

- Tippu (Mubarak Musthafa)

Source Code:

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace NotifyIconWPFSampl
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        private System.Windows.Forms.NotifyIcon TippuTrayNotify;
        private System.Windows.Forms.ContextMenuStrip ctxTrayMenu;
        private System.Windows.Forms.ToolStripMenuItem mnuExit;
        private bool isAppExiting = false;

        public Window1()
        {
            InitializeComponent();

            //Create an instance of the NotifyIcon Class
            TippuTrayNotify = new System.Windows.Forms.NotifyIcon();

            // This icon file needs to be in the bin folder of the application
            TippuTrayNotify.Icon = new System.Drawing.Icon(“Application.ico”);

            //show the Tray Notify Icon
            TippuTrayNotify.Visible = true;

            //Create a object for the context menu
            ctxTrayMenu = new System.Windows.Forms.ContextMenuStrip();

            //Add the Menu Item to the context menu
            System.Windows.Forms.ToolStripMenuItem mnuExit = new System.Windows.Forms.ToolStripMenuItem();
            mnuExit.Text = “Exit”;
            mnuExit.Click += new EventHandler(mnuExit_Click);
            ctxTrayMenu.Items.Add(mnuExit);

            //Add the Context menu to the Notify Icon Object
            TippuTrayNotify.ContextMenuStrip = ctxTrayMenu;

        }

        void mnuExit_Click(object sender, EventArgs e)
        {
            isAppExiting = true;
            this.Close();
            TippuTrayNotify.Visible = false;
        }

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            //When the application is closed, check wether the application is
            //exiting from menu or forms close button
            if (!isAppExiting)
            {
                //if the forms close button is triggered, cancel the event and hide the form
                //then show the notification ballon tip
                e.Cancel = true;
                this.Hide();
                TippuTrayNotify.BalloonTipIcon = System.Windows.Forms.ToolTipIcon.Info;
                TippuTrayNotify.BalloonTipTitle = “Tippu Tray Notify”;
                TippuTrayNotify.BalloonTipText = “Tippu Tray Notify has been minimized to the system tray. To open the application, double-click the icon in the system tray.”;
                TippuTrayNotify.ShowBalloonTip(400);
            }
        }
    }
}

On this week end, my very close friend asked me about having a Windows application running with the icon on the system tray, just like the Google talk application. I told my friend that I will check on this, because I have done this on our good old Visual Basic 6.0 during the start of my carrier. I taught it should be straight forward in C# and it happened to be the same.

Step 1: Create a Windows Forms Application.

Step 2: Drag and Drop the NotifyIcon control from Visual Studio Tools box onto the form.

Step 3: Drag and Drop the ContextMenuStrip control from Visual Studio Tools box onto the form.

Step 4: Click on the ContextMenuStrip control on the form and add "Restore Application" and "Exit" menu item and add click event for them.

Step 5: Click the "NotifyIcon1" control on the form and set the "ContextMenuStrip" to the context menu that we added on the form.

Step 6: After the following code to the forms and build the application. Add  the "SizeChanged" event to the form. When you run the application, the form will run in normal windows mode. When you minimize the application, the application goes to the system tray and shows the notification icon.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace TrayIcon
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        /// <summary>
        /// Show the form and set the window state to normal.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void restoreApplicationToolStripMenuItem_Click(object sender, EventArgs e)
        {
            {
                Show();
                WindowState = FormWindowState.Normal;
                this.Focus();
            }
        }

        /// <summary>
        /// Close the application when the exit menu is clicked.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void exitToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Close();
        }

        /// <summary>
        /// When the form is resized, check the window state and hide the form if minimized.
        /// Set the notify icon visibility to true when window is minimized.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Form1_SizeChanged(object sender, EventArgs e)
        {
            if (WindowState == FormWindowState.Minimized)
            {
                Hide();
                notifyIcon1.Visible = true;
            }
            else
                notifyIcon1.Visible = false;
        }
    }
}

Step 7: Run the application and minimize the form, the notification icon will appear in the task bar.

Hope this helped you guys on how to add a application icon to the system tray.

Hi,

I came across the blog site of Roni about using Property Bag of SPWeb. In his blog he missed out on explaining how to remove the Property from the SPWeb after adding it. There might be scenario where we need to remove the Property from the property Bag. This Blog entry is the extension of the blog entry writte by Roni. http://www.sharepointblogs.com/roni/archive/2007/08/27/moss-2007-using-property-bag-of-spweb-to-store-metadata.aspx.

SPWeb.Properties.Remove(string pKey) doesn’t work for removing a property.

To remove a property use the following lines:

webCurrent.Properties[strKey] = null;
webCurrent.Properties.Update();

In one of my project, there was a requirement to modify the QuickLaunch for a site which was created dynamically through object model. When we modify the QuickLaunch or add a new SPNavigationNode, the QuickLaunch on the site comes as blank for the fist time. If you refresh the page, then the QuickLaunch shows the updated Navigation. First we taught that this is due to the timing mismatch of the publishing web object updating and the page load. Latter we found that after we created the site and viewed the site at least once, the navigation never get updated.

After digging into the issue, I found that the publishing web’s navigation doesn’t get refreshed, unless we load the all the publishing page once after we update the navigation.

Following snippet of code solves the issue.

When we are creating a ListViewWebPart through program, Even if we set the View for the ListViewWebPart, Sharepoint displays the web part with full toolbar property set on it. The only option that we can change this view is to set the View for the ListViewWebPart and add the webpart to the Web Part Manager. After adding the web part on the page, load the webpart again and get the view which is cached by the list view web part and update the Type by reading the xml node and updating the type to the desired toolbar type. Once the Toolbar type is set to “Freeform” (i.e Summary Toolbar), we can add the innerXml to the node having the CAML for showing the “add new item” link to the toolbar. Make sure the position attribute in the xml is “After”. This will make the web part to show the “add new item” link below the List View Web Part.

[code]