The Unknown OneNote Guy's Blog

The GetHierarchy method has three parameters, startNodeId, hsScope and pbstrHierarchyXmlOut. In part I of A Look at GetHierarchy() I posted some demo code that allowed the user to select the hsScope value and dump OneNote data to the console as Xml. If you compiled and ran the demo app you should have seen different console output based on the scope selected. In this post we will cover the startNodeID.

The startNodeID parameter is type string and represents the ID of an object in OneNote 2007. Each unique object in OneNote 2007 contains a unique ID. If you complied and ran the demo app from the first GetHierarchy post you can see more IDs in the console output then you care to see.

An object id in OneNote 2007 must be unique throughout all objects in OneNote. I have not investigated Live Sharing Sessions to see if "shared" objects are unique, but that's for another post. So what is the best way to create globally unique identifier? Well a GUID of course. Well, that and them some.

Here is an example of an object ID:

{68E92C8A-2C70-434E-8721-5257C952B8D8}{1}{B0}

It is probably pretty obvious to a developer that the first portion of this ID is a GUID in "registry format". Tacked on is two other pieces of the id that are "undefined" to the developer but an eagle-eyed developer can see a pattern that associates the second bracketed set in the example ({1}) with page-level objects. For those really into Object IDs you can find it defined in the OneNote 2007 Schemas as a simple type of type string with a defined pattern. Hopefully you have something better to do then read Xml schema's for fun.

So now that we know what an object Id is we can start to use it in our calls to GetHierarchy. To get the OneNote "hierarchy" from the very top you pass in a null value as the first demo app in the original A Look at GetHierarchy() post. If you want to start at some node other than the root node simple pass in the appropriate object ID.

For example I used the GetHierarchy demo, passing in null for the startNodeId. Searching in the Xml results I found the Notebook element with the name attribute equal to "OneNote Guide Beta 2". The id attribute for my OneNote installation is {674B715E-9A47-4A2C-9D11-5B7325B27D4B}{1}{B0}. Your OneNote Guide Beta 2's id attribute will be different.

Now I can modify the original demo. I change the startNodeID from null to " {674B715E-9A47-4A2C-9D11-5B7325B27D4B}{1}{B0}". For your demo insert your specific OneNote Guide Beta 2 id. Quotes are required as this is a string value. Below is the modified line in the original demo:

_AppClass.GetHierarchy("{68E92C8A-2C70-434E-8721-5257C952B8D8}{1}{B0}", hs, out oneNoteAsXml);

Now you can run the demo and choose different HierarchyScope values relative to the OneNote Guide Beta 2 Notebook.

Here is an example of using myOneNote Guide Beta 2 Notebook ID and a HierarchyScope of hsSections (Sections in the demo program):

GetHierarchy is the key to gaining programmatic access to your OneNote information. Prior to OneNote 12 you were limited to importing data the SimpleImport API. OneNote 2007 gives you the ability to import and export data as Xml using OneNote 2007 APIs.

The GetHierarchy method takes three parameters, the startNode Id as a string, hsScope as HierarchyScope enumeration and pbstrHierarchyXmlOut as a string to contain the Xml representation of the OneNote information.

StartNodeId parameter lists the starting node of the export. Passing in null will start the export at the top of the hierarchy. You can start the export from a lower node by passing a OneNote node id. For this post I am only going to pass in a null value for the StartNodeId parameter.

The second parameter hsScope is a enumerated type named HierarchyScope. This enumeration contains five values Children, Notebooks, Pages, Sections and Self. We will look at the difference of the exported data based on the HierarchyScope value.

The third parameter pbstrHierarchyXmlOut is an string parameter that is used to pass back the requested OneNote information as Xml. This is an out parameter and needs to be defined with the out attribute.

Instead of trying to visually explain what each HierarchyScope values do I have created a simple console application that will pass in a null for the StartNodeId and ask for a HierarchyScope. After you provide the scope the code will call GetHierachy and dump the results to the console. You will need VS to compile this simple console app. Make sure you include a reference to the OneNote interop dll. Check my previous post to see how to reference the OneNote interops.

//Start Code -------------------------------------------------------------------------------

//Make sure your project adds the OneNote API reference
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Office.Interop.OneNote;

namespace OneNoteDemo
{
class OneNote_DemoApp
{
ApplicationClass _AppClass;

static void Main(string[] args)
{
OneNote_DemoApp app = new OneNote_DemoApp();
app.Run();
}

private void Run()
{
//create a new OneNote ApplicationClass
_AppClass = new ApplicationClass();
DumpOneNoteHierarhcy();
Console.WriteLine("\nDone");
Console.ReadLine();
}

private void DumpOneNoteHierarhcy()
{
string oneNoteAsXml;
string result;
HierarchyScope hs;
Console.WriteLine("Dump OneNote Hierarchy");
Console.WriteLine("Select a HierarchyScope:");
Console.WriteLine("Children");
Console.WriteLine("Notebooks");
Console.WriteLine("Pages");
Console.WriteLine("Sections");
Console.WriteLine("Self");
result = Console.ReadLine();

switch (result.ToUpper())
{
case "CHILDREN": { hs = HierarchyScope.hsChildren; break; }
case "NOTEBOOKS": { hs = HierarchyScope.hsNotebooks; break; }
case "PAGES": { hs = HierarchyScope.hsPages; break; }
case "SECTIONS": { hs = HierarchyScope.hsSections; break; }
case "SELF": { hs = HierarchyScope.hsSelf; break; }
default: { hs = HierarchyScope.hsSelf; break; }
}

Console.WriteLine("Scope = " + hs.ToString());

//The key function call is here!
_AppClass.GetHierarchy(null, hs, out oneNoteAsXml);
Console.Write(oneNoteAsXml);
}

~OneNote_DemoApp()
{
//ON Interops call into unmanaged code
//So make sure we destroy it
_AppClass = null;
}
}
}
//End Code ---------------------------------------------------------------------------------

This is a 'fun" little demo app. The xml results are dumped to the console so the reults maybe a little difficult to read. To get a better look at the results I suggest running this application from the console and piping the results to a .xml file and viewing in IE.

I created the code in C#. If there is a request for VB.Net let me know and I will see what I can do. Of course the demo code should not be interpreted as well designed and robust code. It’s demo code.

It seems most everyone I talk to now knows about OneNote. It usually goes something like this "yes I heard of OneNote. Its that note taking app from MS." Many friends and acquaintances have loaded and tried OneNote, took a few notes, clicked around, made a few folders and pages. Maybe they actually open it once later in the week and try it all over again. "You know it just doesn't click for me. It's easier to take my notes by hand."

It's no surprise that OneNote does not overwhelm everyone with it's note-taking abilities. Come on its just notes. You know how easy it is to take a note on a scrap piece of paper and shove it in your pocket. Just take a look at my desk, notes and scraps all over. Check my car, more notes - hey is that my appointment card for my dentist? Wait there's a few lunches I was supposed to expense last month. Three pads of paper each with various client design notes. Check my dresser where I empty out my pockets at the end of the day. There's a napkin with a design for a OneNote PowerToy - got to remember to put that someplace and not accidently throw it away.

Yes taking notes is easy, just grab a business card, napkin, back side of a bank statement and you are in business. And if OneNote was only good for creating electronic versions of these notes well then there just isn't much sense in losing my notes in a computer. If you think OneNote is just about taking notes then you my friend have not figured it out yet.

The problem with notes is that notes come in all forms and from everywhere. I have "notes" on scraps of paper, whiteboards and even on occasion the back of my hand. I once had a job where the most common place to find your notes was on pieces of medical tape stuck to your pants leg. On the road? Well a call to my office and a "note" left on my voice mail works real nice when I have good idea I know I will forget before I get to where I am going. Like I said "notes" come in all forms - paper like a business card, audio like my voice mail, images like the picture I took of a white board.

And lets not forget the subjects of the notes. I have notes on clients, notes on policies, notes to go to the dentist and doctors. I got a note to remember to get some trim for the house, and don’t forget to call whoever about such and such after Tech Ed. And remember to call about brakes for the car.

When you look at the simple concept of "taking notes" it is suddenly not so simple. As a matter of fact taking notes is the easy part. Organizing them, finding them and working on them is the hard part. Ever spend a day looking for that scrap of paper that has that all important phone number? Or have you moved your desk to find a note written months before reminding you to submit your PowerToy to certain contest? And that is why you need OneNote. Not as another place to lose your notes but a place where you can capture, organize, find and use your notes.

So have you figured it out yet? Start capturing your notes in all their forms into OneNote. Along the way organize them, search for them and actually use them. I wish I would have started using OneNote earlier- I could use the thirty dollars for those lunches I forgot to expense, or one of those slick tablets.