Tip: Open a .Net Command Prompt Here
Posted on December 21st, 2006
If you find you want to open a command prompt on a certain folder and have access to all the underlying Visual Studio.Net <your version here> options this is for you.
This is based on similar updates to your windows system in which you can add a new option to your right-click context menu inside of your explorer windows. What this particular tip does is shows you how to add a item to your menu that will open a VS.Net 2003 command prompt on the specified folder, however you follow the same procedure for all versions of visual studio.
Note: This involves updating the registry. You should always backup your registry before making manual changes as your changes could make your system unstable. If you are not comfortable with doing these types of changes you should pass on this tip.
Following the steps below:
1. Open regedit.exe
Start->Run->regedit.exe
2. Navigate to the following location:
HKEY_CLASSES_ROOT/Directory/shell
3. Add a new key
VS2003CMD
4. In this key create another key called:
command
5. Click on the key created in step 3. On the right double-click the Default value and type in the following: (this will be displayed in the context menu).
Open &VS2003 Command Prompt
6. Click OK
7. Click on the command subkey and then double-click on the default value on the right. Enter the following: (this is the command that will be run).
cmd.exe /k “cd %L && “c:/Program Files/Microsoft Visual Studio .NET 2003/Common7/Tools/vsvars32.bat” && ver”
Make sure you entered the quotes. This also assumes that you have installed VS.Net 2003 in the default folder. If you did not then adjust accordingly.
That should do it. Now if you go into windows explorer you should see a new menu item when you right-click.
To make this easier we have also included a download of the reg file that you can just apply to your system. As with anything to do with the registry you should always double check files you download that update the registry to make sure nothing malicious exists.
Enjoy.
Tutorial – Google Desktop Sidebar – Hello World Part 4, Loading and Saving our properties
Posted on December 10th, 2006
Requirements
.Net Framework SDK 1.1
Google Desktop SDK
Downloads
The zip file listed here is all inclusive of all four tutorial parts. We broke up the article into four parts for ease of reading. Included in the zip is a Word doc version of all four articles.
Download (231KB)
Purpose
In this article I intend to show you how to extend our simple Google Desktop Sidebar (GDS) component. All the source is in C# 1.1. We assume that all developers looking at this article are familiar with writing code in C# and the .Net framework. For this component we will be doing a simple Hello World type sample. We will show screenshots where appropriate. Otherwise we assume you know your way around.
What it Shows
In this part of our tutorial we will be showing you how to save and load the changes you have made. We do not take it so far as to keep up with the content but it gives you the general idea.
Storing our changes
Ok, as we all know if you make a change to something and you want it to stick we must save it. Well the GDK provides that functionality as well. In order to provide this save / load functionality we must implement the interface IPersistStreamInit. To start with we need to add some basic data to our class. We are going to add the following member variables.
const int dataVersion = 1; private bool isDirty;
The dataVersion property can probably be replaced to read from your assemblyInfo.cs file but we will leave that to you. We need this property so we can support versioning of our component. It will also help if you happen to have multiple versions running that you get the correct data loaded for your component. You don’t really need this but it does provide a bit of added support for later. The isDirty flag will be set and used so we know when anything has changed so that we know when to save our data.
So, for us to know that something has changed we need to add it to our layout property. Let’s change our code:
public GoogleDesktopDisplayContentItemLayout Layout
{
get { return this.layout; }
set { this.layout = value; this.isDirty = true; }
}
All we have done here is add the isDirty flag to our property. Now we also need to initialize it so let’s add some code to our constructor.
this.isDirty = false;
Now we can start looking into the IPersistStreamInit interface. The first thing you will probably notice is that it has an IsDirty property. This is used by the GDK to determine if the Save operation needs to occur. So lets modify the code, note that we need to change a Boolean value into an unsigned integer.
public UInt32 IsDirty()
{
return (UInt32)(isDirty ? 1 : 0);
}
Now that we can tell if our component needs to be saved letss add the code to save our changes. We will do this by adding code to the Save method.
public void Save(UCOMIStream stm, bool clearDirty)
{
MemoryStream memStream = new MemoryStream();
BinaryWriter binWriter = new BinaryWriter(memStream);
// first our version
binWriter.Write(dataVersion);
// then the data.
binWriter.Write(this.Layout.ToString());
// cleanup binWriter.Flush();
// write to actual output stream
byte[] data = memStream.ToArray();
stm.Write(data, data.Length, IntPtr.Zero);
if (clearDirty) isDirty = false;
}
Now again, we assume you know how to use the framework and that includes the IO process. So, what we are doing is setting up a memory stream since the GDK actually handles the file IO. To Write to the stream you should be able to use any type of writer and pass it the memory stream to write to. The first thing we write out is our dataVersion and then we write out the value of our Layout property. You will notice that we are writing the string value representation, this will make it easier to pull back in later. Once we are done we convert the memory stream into an array of bytes so we can pass it to the underlying COM stream that the GDK has provided to us. Last but not least we set the dirty flag only if the stream write was successful.
Once we have saved our data we can now add code to load our data. This works the same way just in reverse. In a more advanced scenario there is no reason why you could not serialize / de-serialize a class into this stream. Let’s add our Load code.
public void Load(UCOMIStream stm)
{
const int maxDataLen = 1000;
// read a large enough number of bytes for us.
byte[] data = new byte[maxDataLen];
stm.Read(data, data.Length, IntPtr.Zero);
MemoryStream memStream = new MemoryStream(data);
BinaryReader binReader = new BinaryReader(memStream);
int version = binReader.ReadInt32();
if (version != dataVersion)
{
MessageBox.Show("Invalid data version, using default values");
}
else
{
string value = binReader.ReadString();
switch (value)
{
case "GDD_CONTENT_ITEM_LAYOUT_NEWS":
this.Layout = GoogleDesktopDisplayContentItemLayout.GDD_CONTENT_ITEM_LAYOUT_NEWS;
break;
case "GDD_CONTENT_ITEM_LAYOUT_EMAIL":
this.Layout = GoogleDesktopDisplayContentItemLayout.GDD_CONTENT_ITEM_LAYOUT_EMAIL;
break;
case "GDD_CONTENT_ITEM_LAYOUT_NOWRAP_ITEMS":
this.Layout = GoogleDesktopDisplayContentItemLayout.GDD_CONTENT_ITEM_LAYOUT_NOWRAP_ITEMS;
break;
}
}
}
In this section of code we are again creating a Memory stream and this time a Reader object. You should create the same type of Reader as you did writer so that it will be compatible. Seeing as how we have only written a small amount we have set an arbitrary size of 1000 bytes to read which is way more than enough to cover getting our info. If you had a large set of data you would need to get the actual size of your data and initialize accordingly. Since we wrote out the first value of our dataVersion we can check it first to make sure we are working with the same file. If we are then we can read the rest of the data and set our Layout property to what we saved the component with last.
Well that should do it so compile your app and you should get the following prompt.
If you don’t fix any problems you have and then try again. You are ready to try it out. So open your GDS and then go into the properties and change the value and then exit the GDS and re-open your data should be displayed the same as when you exited the app.
The first time you run your app you will get an error saying that you have an invalid data version. We could wrap this but we will leave this to you the reader as an exercise.
What you have learned
In this last part of our tutorial set you have learned how to load and save your data changes that you make to your plug-in. If you want to make it more extensive we will leave that to you the reader as an exercise.
Conclusion
We hope that you have found these tutorials helpful. In looking through the developer forum we saw that a lot of people had asked for one and hope this meets the needs of what you were looking for.
Enjoy.
Tutorial – Google Desktop Sidebar – Hello World Part 3, Adding a Property Page
Posted on December 10th, 2006
Requirements
.Net Framework SDK 1.1
Google Desktop SDK
Downloads
The zip file listed here is all inclusive of all four tutorial parts. We broke up the article into four parts for ease of reading. Included in the zip is a Word doc version of all four articles.
Download (231KB)
Purpose
In this article I intend to show you how to extend our simple Google Desktop Sidebar (GDS) component. All the source is in C# 1.1. We assume that all developers looking at this article are familiar with writing code in C# and the .Net framework. For this component we will be doing a simple Hello World type sample. We will show screenshots where appropriate. Otherwise we assume you know your way around.
What it shows
In this part of our tutorial we will be adding a property page to our component that will allow us to change the content format among the three built-in types.
Adding Property Pages
We are assuming you have kept up so far if not pull down the code from above and you can follow along or you can work through the other two parts.
Since we are going to add a property page lets start with the obvious. Add a new Windows Form file to your project. Once complete open up the code window and add the following Using statements.
using System; using System.Drawing; using System.Collections; using System.ComponentModel; using System.Windows.Forms; using System.Runtime.InteropServices; using Google.Base; using Google.Base.Utils; using GoogleDesktopAPILib; // Google Type libraries using GoogleDesktopDisplayLib; // Google Type libraries
As you can see it is mostly the same as a windows form but we have added the google items to the mix. If you look in the GoogleBase folder you will see a base property page object. This is taken pretty much straight from the samples that google provided. What you want to do is change your form class to inherit from the base property page class. That will hookup the form so it can be used by our plug-in. Your class should look something like this:
[GuidAttribute("DFAEFC1E-2466-40d5-80D6-3FF5136627DA")] // CHANGE THIS in your plug-in
[ClassInterface(ClassInterfaceType.None)]
public class frmHelloProperties : Google.Base.PropertyPage
Notice that again just like our main plug-in class we have a GUID Attribute. Since the plug-in / GDS needs a handle to the property page we need the GUID so that COM can get a hook into it for our use. Next by marking our class with the ClassInterface attribute we can control whether or not the class is exposed via a typelib. Since this is used internally we can mark it as none.
Now once you get that done you can setup your form however you want. Just like a normal form. For this tutorial we are going to add a label and a combo box. So add them to the form and change the Label to say “Change Display Layout”. Then change your combobox to be a drop-down list. Next add the following values to the Items collection, NoWrap, Email, and News.
Next let’s get back to our code. We are going to override two methods on our property page, OnPageActivate and OnPageApply. As there names imply we will be handling code when you open the property page and when you hit the Apply or OK button.
Let’s do the Activate method first.
/// <summary>
/// Called just before the property page is displayed
/// </summary>
protected override void OnPageActivate(System.IntPtr wndParent, Rectangle Rect, bool modal)
{
base.OnPageActivate(wndParent, Rect, modal);
HelloWorldPlugin ctl = dataObject as HelloWorldPlugin;
if (ctl != null)
{
// Get the parameter values from the plug-in
switch (ctl.Layout)
{
case GoogleDesktopDisplayContentItemLayout.GDD_CONTENT_ITEM_LAYOUT_EMAIL:
this.cboLayout.SelectedItem = "Email";
break;
case GoogleDesktopDisplayContentItemLayout.GDD_CONTENT_ITEM_LAYOUT_NEWS:
this.cboLayout.SelectedItem = "News";
break;
case GoogleDesktopDisplayContentItemLayout.GDD_CONTENT_ITEM_LAYOUT_NOWRAP_ITEMS:
this.cboLayout.SelectedItem = "NoWrap";
break;
}
}
}
The first thing we do is let the base class do what it needs to do, then we apply our content information / changes. Each property page has a dataObject that equates to the plug-in you are using. So we need to set and cast our object to the type of our plug-in. If we have a plug-in handle then we can continue with our code. The property we have here, which we will create in just a few, is called Layout. It is of the type GoogleDesktopDisplayContentItemLayout which defines the three currently supported display formats out of the box. So what we do here is figure out what we are currently using and then set our combobox to the appropriate value.
Next lets look at the Apply process which is very similar.
/// <summary>
/// Called when user hits OK in the property page
/// </summary>
protected override void OnPageApply()
{
HelloWorldPlugin ctl = dataObject as HelloWorldPlugin;
if (ctl != null)
{
// Set the new parameter values back to the plug-in
switch (this.cboLayout.SelectedItem.ToString())
{
case "NoWrap":
ctl.Layout = GoogleDesktopDisplayContentItemLayout.GDD_CONTENT_ITEM_LAYOUT_NOWRAP_ITEMS;
break;
case "Email":
ctl.Layout = GoogleDesktopDisplayContentItemLayout.GDD_CONTENT_ITEM_LAYOUT_EMAIL;
break;
case "News":
ctl.Layout = GoogleDesktopDisplayContentItemLayout.GDD_CONTENT_ITEM_LAYOUT_NEWS;
break;
}
ctl.GetOurStuff();
}
base.OnPageApply();
}
Again we get a handle to our plug-in object. However this time we do our setting of our data. Now you will also notice that we are making a direct call to the GetOurStuff method. This way we can go through and re-apply our formatting to our content items. Last but not least we call our base method so that the GDK can finish anything else it needs to.
Since we defined the layout variable in part two you should be able to just add this class. Next lets go through and hookup the property pages. To do this we need to implement the ISpecifyPropertyPages interface. It’s pretty simple and straight forward so here is the code:
public void GetPages(ref CAUUID pages)
{
// get our guid
Guid[] g = new Guid[1];
g[0] = typeof(frmHelloProperties).GUID;
pages.SetPages(g);
}
What we are doing here is getting the GUID from our property page and then setting it into the pages object provided by the GDK. It will then get the hook to the property page and display it.
Let’s go ahead and compile it and see what we have so far. When you compile your code you should hopefully get the following dialog. 
If you did not fix any errors you have and then continue. Next if you do not have the GDS running start it up.
To start you should see something like the following: 
Now let’s open the property page by selecting the down arrow and choosing Options. As you will see it will show the NoWrap as the current display style. This is what we set in the constructor of our main plug-in code. Try changing it around and see how it looks.
Email View 
News View 
What you have learned
In this part of our tutorial you have learned how to add a property page and how to apply those changes to your plug-in. In our next part of this tutorial we will show you how to save your view layout information and restore it at run-time.
Tutorial – Google Desktop Sidebar – Hello World Part 2, A simple plug-in with Content
Posted on December 10th, 2006
Requirements
.Net Framework SDK 1.1
Google Desktop SDK
Downloads
The zip file listed here is all inclusive of all four tutorial parts. We broke up the article into four parts for ease of reading. Included in the zip is a Word doc version of all four articles.
Download (231KB)
Purpose
In this article I intend to show you how to extend our simple Google Desktop Sidebar (GDS) component. All the source is in C# 1.1. We assume that all developers looking at this article are familiar with writing code in C# and the .Net framework. For this component we will be doing a simple Hello World type sample. We will show screenshots where appropriate. Otherwise we assume you know your way around.
What it Shows
In this part of our tutorial we will be showing you how to add content items to your basic plug-in. It is assumed that you have the code from the previous article as we will be building from that base. So have it ready.
Adding Content
As stated we are now going to look at what it takes to add content items to our GDS plug-in. We are going to take the simple approach and just build a for loop that will add 10 items to the plug-in every time it’s loaded. That’s it.
So let’s get started. First add a new class file to your project from earlier and add the following using statements:
using System; using System.Text; using System.Windows.Forms; using Google.Base; // Base module to ease plug-in development using Google.Base.Utils; // Base module to ease plug-in development using GoogleDesktopAPILib; // Google Type libraries using GoogleDesktopDisplayLib; // Google Type libraries
As you will see this is very similar to what we had in our earlier tutorial. Now let’s add our class definition. If you want to change the class name go ahead.
public class HellowWorldCI : GoogleDesktopDisplayContentItemHelperClass, IGoogleDesktopDisplayContentItemHandler
Since this class is not created directly you do not need a GUID attribute on it. As you can see we are inheriting directly from the Helper class provided by the GDK and an Interface. Make sure you use the Class viewer to implement the interface for it.
Most everything you can pretty much leave alone. We will only show you the actual methods that we will be changing from the default implementation. As per the documentation you should throw the NotImplementedException when ever you do not implement a particular method. By doing this the underlying api will know to use the default method for handling this as per the application framework.
A lot of this block of code is taken from the samples that come with the GDK only we have cleaned it up a little bit and by breaking it into a separate file we feel that it makes it easier to understand and conceptualize what is going on.
Add the following code to the ProcessDetailsViewFeedback method:
if ((flags & GoogleDesktopDisplayDetailsViewFlags.GDD_DETAILS_VIEW_FLAG_TOOLBAR_OPEN) != 0)
{
OpenItem();
return;
}
if ((flags & GoogleDesktopDisplayDetailsViewFlags.GDD_DETAILS_VIEW_FLAG_NEGATIVE_FEEDBACK) != 0)
{
MessageBox.Show("Not interesting: " + heading + "Doing default processing");
}
// throw this exception to let the default processing happen for all other
// details view commands
throw new NotImplementedException();
The OpenItem method will be defined in just a few minutes. All it will do is popup a message box. What this code does is when you are in the detail view for an item there are several processing options. You can click on the header, the Remove item, or the X in the right hand corner. By clicking on each different element you can have it do several things. In the case of an RSS feed if you click on the title it will normally take you to the web article in your current browser. If you click on the Remove Item it normally tells the interface to delete it, etc. By handling the information in this section you can have your code execute various actions depending on how you interact with it.
Next for the OnDetailsView method add the following code:
// Here we can create any ActiveX control for displaying the details, and // return it via the detailsControl parameter. We choose the // 'GoogleDesktopDisplayDetailsViewHelper' control that will give us a // UI that's inline with how the sidebar looks. GoogleDesktopDisplayDetailsViewHelperClass details = new GoogleDesktopDisplayDetailsViewHelperClass(); // set the details control's content from our own data string text = "Hello World... How are you/r/n/r/nSome sample text/r/n/r/nwithout formatting/r/n"; details.SetContent(source, time_created, text, false, layout); detailsControl = details; title = heading; flags = GoogleDesktopDisplayDetailsViewFlags.GDD_DETAILS_VIEW_FLAG_TOOLBAR_OPEN | GoogleDesktopDisplayDetailsViewFlags.GDD_DETAILS_VIEW_FLAG_NEGATIVE_FEEDBACK; return false; // return false to show details view, true to cancel it.
This block of code is executed when you click on an item and it goes to open the expanded details view for an article. The base class used here as seen is the GoogleDesktopDisplayDetailsViewHelper class. This is the base class used by the API to display the standard details view. If you want to implement your own you would need to write the appropriate ActiveX control to handle this. What we are doing I this class in our case is setting the internal details for each item when opened into details view. This is not good for dynamic content but for this example it works perfect. The SetContent method will take the values of the object in question and use it for rendering the object.
Add this code for the OpenItem method:
MessageBox.Show("Open: " + this.heading);
All are doing here is that when you double click on the item it will display the heading for the item that you double-clicked on.
That pretty much does it for this class. Now we need to update the main plug-in class from Part 1. First we need to add a property to our class to handle the Layout of our content. This will play a bigger part in the later tutorials. For now let’s add this code.
public GoogleDesktopDisplayContentItemLayout Layout
{
get { return this.layout; }
set { this.layout = value; }
}
On our main plug-in class lets add the following method:
public void GetOurStuff()
{
// clear our stuff out first this.
RemoveAllContentItems();
// setup the basic display options needed to add to object.
GoogleDesktopContentItemDisplayOptions options = GoogleDesktopContentItemDisplayOptions.GDD_ITEM_DISPLAY_IN_SIDEBAR | GoogleDesktopContentItemDisplayOptions.GDD_ITEM_DISPLAY_AS_NOTIFICATION_IF_SIDEBAR_HIDDEN;
// We are going to add 10 hello world items.
for (int x=0; x<=9; x++)
{
GDP_HelloWorld.HellowWorldCI content = new HellowWorldCI();
content.heading = "Hello World - " + x.ToString();
content.source = "CaubleStone Ink";
content.snippet = "Sample Content Item from CaubleStone Ink.";
content.time_created = DateTime.UtcNow;
content.flags = GoogleDesktopDisplayContentItemFlags.GDD_CONTENT_ITEM_FLAG_NONE;
content.layout = this.Layout;
this.AddContentItem(content, options);
}
}
The first thing for this method is that we will remove all the existing items from the plug-in. Essentially clear all. In the real-world this should be dynamic but for this tutorial it allows us to recreate all the items easily. Next we set our base options in this case we tell the item that it will be displayed in the Sidebar and that if the Sidebar is set to auto-hide you will get a toast notification of the change. After that we will be adding our content. We setup the loop to add 10 items to our content page. To do that create an instance of our content class that we created earlier. Then set the heading, source, snippet, etc. For the time use the UtcNow otherwise it will not calculate the added time correctly. We have also setup a property on our main class called Layout that will retrieve our base layout. If you look at Part 1 you will see that by default it is set to the No Wrap option. This will also come into play for our Part 3 tutorial. The last and final step is to add our content item.
Next we need to modify the SetSite method so that we can call our setup method and add our content to the screen.
displaySite = (IGoogleDesktopDisplaySite)site;
// Display our content here...
if (displaySite != null)
{
this.SetFlags(GoogleDesktopDisplayPluginFlags.GDD_PLUGIN_FLAG_NONE,
GoogleDesktopDisplayContentFlags.GDD_CONTENT_FLAG_HAVE_DETAILS);
this.GetOurStuff();
}
What we have added is the IF condition and it’s contents. The first thing we do is set the flags on the plug-in to tell it that "Hey we have content here that needs to be displayed". After that we call our GetOurStuff method. If you do not add the flags the content will not be displayed.
Ok it’s now time to compile and test. If you get the following screen that’s good, if not adjust your errors until it compiles. This is what you should see.
Once you click yes open your GDS unless it is already open. You should see something like the screen below.
What we learned
In this part of our tutorial we have walked you through the process of adding content items to your component. You have seen how you can add individual items, remove those items, and the different changes needed in order to add it to your plug-in.
Tutorial – Google Desktop Sidebar – Hello World Part 1, A simple plug-in
Posted on December 10th, 2006
Requirements
.Net Framework SDK 1.1
Google Desktop SDK
Downloads
The zip file listed here is all inclusive of all four tutorial parts. We broke up the article into four parts for ease of reading. Included in the zip is a Word doc version of all four articles.
Purpose
In this article I intend to show you how to build a simple Google Desktop Sidebar (GDS) component. The entire source is in C# 1.1. We assume that all developers looking at this article are familiar with writing code in C# and the .Net framework. For this component we will be doing a simple Hello World type sample. We will show screenshots where appropriate. Otherwise we assume you know your way around.
What it shows
We intend to show you how to hook up a basic no frills .Net C# GDS component. What we have done is setup some basic modules under the folder GoogleBase that you can re-use in any component that you develop. These files wrap up all the API and com interaction that Google had setup in the samples sdk. Now it’s easy for you to use. In the article we will show you how to setup the component. Work with a title changing. Adjusting Layout formats (the canned ones). Adding content items. Using the default reader pane, and setting up Property pages.
This tutorial will walk you through the steps taken to get where the sample code is.
Project Setup
To start with create a new solution with and add a Class Library project. If you have not downloaded the code for this article please do so now as it will have some base files you will need to get going. Also, you need to make sure you have the Google Desktop SDK installed for this to work.
Copy and include the GoogleBase folder and all of it’s contents from the zip file into your project. These modules setup the following, ImageConverter object for getting your resource streams down to COM layer, the COM API, structures, etc needed by the GDK, and the base property page object that you can inherit from in order to create your property pages.
Once you have the files include you need to add some references to your project. The first two references are needed for the plug-in to work. In the references window click on the COM Tab and find the following two objects (figure 1) and add them to your project.
Once you have selected those objects it will create the necessary Interop dll’s needed since we are interacting with COM objects instead of managed code.
You also need to include the following references:
- System.Drawing
- System.Windows.Forms
Once that is done you need to set your project properties. The Google Sidebar is a COM object so we need to build a COM library. To do so we need to enable that in our project properties. So open your project properties and set the basics like Assembly name, root namespace, etc. Once you have that done goto the Configuration Properties -> Build section and at the bottom of your options change the Register for COM Interop to TRUE. This will enable us to build a com library.
That’s the basic setup for the project. Now we need to start putting together the basic plug-in.
Compilation Notes
When building a COM library you will need some registration functions in your code to allow it to hook in properly. We will show that after we get the basic plug-in up and running with a title.
However, once you compile and register your component with the GD Sidebar you cannot modify it unless you exit the Sidebar application. This will remove the hooks so you can re-compile and re-register. Tedious process if you are doing a lot of testing but it works.
Your first plug-in
Ok, lets setup our first plug-in. Create a new Class file in your project and the following includes for the file.
using System; using System.Text; using System.Runtime.InteropServices; using System.Windows.Forms; using System.IO; // used for Registry / Com interop registration using Microsoft.Win32; using Google.Base; // Base module to ease plug-in development using Google.Base.Utils; // Base module to ease plug-in development using GoogleDesktopAPILib; // Google Type libraries using GoogleDesktopDisplayLib; // Google Type libraries
Once you have these in let’s create our first plug-in class. For your class, add the following inheritance chain (or cut / paste and change your class name):
public class HelloWorldPlugin : GoogleDesktopDisplayPluginHelperClass, IGoogleDesktopDisplayPluginHandler, ISpecifyPropertyPages, IObjectWithSite, IPersistStreamInit
Once you have the class inheritance model in place use the Class view to go in and implement all the interfaces.
Now let’s setup some of our base internal values that we will use with our com object. These values will be used with the registration and read by the GDS when you view available plug-ins.
// since this is a com object we can store some info as static members. static string baseTitle = "Hello World"; static string pluginName = "Hello World"; static string pluginDesc = "Hello World sample written in C#";
There is one other item you must add and it is extremely important. All COM objects need a GUID. So let’s add ours. Using the GUIDGEN utility from the framework choose the registry format to generate and take the value and add it to our class in the following ways:
[GuidAttribute("A674FDFF-D816-4eaf-9D5E-97317158733E")]
public class HelloWorldPlugin : GoogleDesktopDisplayPluginHelperClass, IGoogleDesktopDisplayPluginHandler, ISpecifyPropertyPages, IObjectWithSite, IPersistStreamInit
{
// You must set a control GUID and it must match the guid attribute in order to work static string controlGuid = "{A674FDFF-D816-4eaf-9D5E-97317158733E}";
}
The GUID’s in both places need to match. Without this you will be unable to register and use your plug-in.
You will also need to add the following member variables to the class:
// Member variables needed to hook into the Sidebar api // this retrieves the site info for this plug-in. private IGoogleDesktopDisplaySite displaySite; // setup the layout options so the sidebar api knows how to render our information. private GoogleDesktopDisplayContentItemLayout layout;
What this does is allows your app to hook into the panel that is showing your information. You will notice that we set up above a baseTitle object as static. You do not need to do this if you plan to have your title bar be dynamic. However it aids in this demonstration. The layout property will be used in a later tutorial.
Ok, now that we have some member variables, our interfaces implemented (roughly) and a class to use let’s build the constructor. Here we will setup an initial layout format as well as hook in the About box information. Real quick here about the about box. There are three distinct areas that text is put. The first line will use your logo if any and display your main info like a company name. If you use two new line commands it will kick your text down to the main content area.
Here is our constructor:
public HelloWorldPlugin()
{
// setup some basic info.
StringBuilder sb = new StringBuilder();
sb.Append("Hello World Plug-in by CaubleStone Ink");
sb.Append("//n//n");
sb.Append("Shows how to setup basic functionality");
sb.Append("for a sidebar plug-in.//n");
this.layout = GoogleDesktopDisplayContentItemLayout.GDD_CONTENT_ITEM_LAYOUT_NOWRAP_ITEMS; this.about_text = sb.ToString();
}
What we have done here is setup our basic info using a StringBuilder and setting our basic layout to just the plain jane no wrap value. Similar to the TODO list from Google.
Now lets walk through setting up the interfaces. By default you can leave all the interfaces alone however you may need to add a few new keywords on some to aid in the code generation and to help avoid memory leaks.
We are going to start with the IObjectWithSite interface class. All we need to do here is add the following so our app can get a handle to the display surface that the GDS will be using.
public void GetPageContainer(out Object site)
{
// TODO: Add HelloWorldPlugin.GetPageContainer implementation
site = null;
}
public void SetSite(Object site)
{
displaySite = (IGoogleDesktopDisplaySite)site;
}
That’s it. We are slowly on our way to a plug-in. Now on to the next interface IGoogleDesktopDisplayPluginHandler. In this interface we will hook up our Title for our plug-in. What we plan on having is the plug-in adjust the title from Hello World to Hello World – Min when it’s minimized or maximized.
public new void OnCommand(GoogleDesktopDisplayPluginCommand command)
{
if (command == GoogleDesktopDisplayPluginCommand.GDD_CMD_ABOUT_DLG)
{
// always throw this exception when you dont intend to override the default behavior
// and you want the plug-in helper to do it[ES][SQ]s usual stuff.
throw new NotImplementedException();
}
}
public new void OnDisplayStateChange(GoogleDesktopDisplayTileDisplayState display_state)
{
if (display_state == GoogleDesktopDisplayTileDisplayState.GDD_TILE_DISPLAY_STATE_MINIMIZED || display_state == GoogleDesktopDisplayTileDisplayState.GDD_TILE_DISPLAY_STATE_RESTORED)
{
// switching between minimized and normal mode, so update the title
this.GetTitle();
}
}
Notice that we have the new keyword on both of these methods. That is so it hides the underlying implementation (which there is none since it’s an interface) and helps us to prevent memory leaks. What we are doing is checking the value of display_state which comes in from the interface call. If the component has been minimized or restored it will change our title.
Let’s get our GetTitle function in here.
public void GetTitle()
{
this.title = baseTitle;
if (displaySite != null && displaySite.display_state == GoogleDesktopDisplayTileDisplayState.GDD_TILE_DISPLAY_STATE_MINIMIZED)
{
this.title = baseTitle + " - Min";
}
}
What we are doing here is setting the underlying classes title property. We are starting with our baseTitle static variable and then appending the “- Min” to it if we are minimized.
Now we are finished with our basic code. Let’s get our registration functions in place so we can see the final results.
COM Registration functions
#region Registration functions
/// <summary>
/// Called when the plug-in is registered with the system. We add a few registry
/// keys and register with GoogleDesktop as a plug-in.
/// </summary>
/// <param name="t" /></param>
[ComRegisterFunctionAttribute]
static void RegisterFunction(Type t)
{
try
{
// Set the "MiscStatus" value in registry to a valid value string keyName = @"CLSID\" + t.GUID.ToString("B");
using (RegistryKey key = Registry.ClassesRoot.OpenSubKey(keyName, true))
{
key.CreateSubKey("Control").Close();
using (RegistryKey subkey = key.CreateSubKey("MiscStatus"))
{
subkey.SetValue("", "whateveryouwant");
}
key.CreateSubKey("Control").Close();
key.SetValue("",pluginName);
using (RegistryKey subkey = key.CreateSubKey("Description"))
{
subkey.SetValue("", pluginDesc);
}
}
// Create the registrar object
GoogleDesktopRegistrarClass registrar = new GoogleDesktopRegistrarClass();
// Start component registration by specifying our attributes
object[] descriptions = { "Title", pluginName, "Description", pluginName, "Icon", "" };
registrar.StartComponentRegistration(controlGuid, descriptions);
// A single component can register for multiple plugins with Google Desktop.
// Here we register a single display plug-in.
IGoogleDesktopRegisterDisplayPlugin displayRegistration =
(IGoogleDesktopRegisterDisplayPlugin) registrar.GetRegistrationInterface("GoogleDesktop.DisplayPluginRegistration");
displayRegistration.RegisterPlugin(controlGuid, false);
// Done with component registration.
registrar.FinishComponentRegistration();
}
catch (Exception e)
{
MessageBox.Show("Exception thrown during registration. Description=" + e.Message);
}
}
/// <summary>
/// Called when the plug-in is unregistered. We unregister our plug-in with
/// GoogleDesktop.
/// </summary>
/// <param name=""t"" /></param>
[ComUnregisterFunctionAttribute]
static void UnregisterFunction(Type t)
{
try
{
// Create the registrar object
GoogleDesktopRegistrarClass registrar = new GoogleDesktopRegistrarClass();
// Unregister ourselves
registrar.UnregisterComponent(controlGuid);
}
catch (Exception e)
{
MessageBox.Show("Exception thrown during registration. Description=" + e.Message);
}
}
#endregion
What this block of code does is writes to the registry values needed to register your component for COM interop. By using the GoogleDesktopRegistarClass it also registers your COM object for use and visibility by the GDK. For the most part you can just copy / paste whenever you build a plug-in.
Compiling and Running
Ok, now that you have all the code in place it’s time to compile and run your application. If your build was successful you should see the following:
Once you get this message hit yes. If you have the Google Sidebar running you should see it show up immediately. If not startup the Sidebar and if not there add the panel.
Based on what we have done you should see something like the following:
Normal
Minimized
What you are seeing is the Hello World plug-in with only a title. The title will change when you Minimize or Restore the panel.
What you have learned
In this part of our tutorial you have learned the basics of creating a very simple plug-in for the Google Desktop Sidebar using C#. As you can see it only took minimal setup steps thanks to some of the items that Google provided and we broke out for you.
In our next article we will cover adding content items, basic format to the plug-in.
Errata
04-12-2006
Thanks to M. Loeffen for catching this. If you were working through the examples you would indeed recieve a compile error because we did not define the layout property. We have adjusted the tutorial to add this variable to our main plugin class. If you want to see it here this is what you need to add:
// setup the layout options so the sidebar api knows how to render our information. private GoogleDesktopDisplayContentItemLayout layout;