The Unknown OneNote Guy's Blog

PowerShell Send To OneNote 2007

2007-02-14T13:57:00.000-08:00

[editing note: Changed the incorrect name of PowerNote in the title to PowerShell - had OneNote on the brain and it was late....]

I have been working with Microsoft PowerShell a new "interactive" command line tool. PowerShell can be downloaded from http://www.microsoft.com/windowsserver2003/technologies/management/powershell/default.mspx and if you are a command line junkie, you will want to look at this tool. Over the last week I have been working with PowerShell to create command line scripts and cmdlets (an extensibility mechanism) to administer a custom Microsoft-based solution.

I spent the last few days pouring over documents , web sites, blogs and even a book to quickly get up to speed with PowerShell and honestly the sheer number of PowerShell features not to include the numerous major extensibility points requires more than a few days to become fluent with. Of course as I dove into PowerShell there were many places where I can easily see how OneNote 2007 and PowerShell would work well together. Most of these integration points will require some custom coding but to do a Send to OneNote 2007 from PowerShell is practically built into PowerShell.

So lets look at the output created by PowerShell using the default PowerShell host - the console. Here is the output Get-Process which will return a list of process on the host machine:

PowerShell uses a pipeline pattern where the output of one command can be the input to another command generally using the pipe character "". PowerShell will output to the default host without a terminating out command. Other out options include files and printers and OneNote 2007 (seen below) installs a print driver named" Send To OneNote 2007".

Whenever you select the Send To OneNote 2007 printer the output will create a new OneNote page located in the Unfiled Notes section of your OneNote 2007. Any application that can output to a printer can "Send to OneNote".

Armed with this we can now send the output of our Get-Process example to OneNote 2007 with no custom coding. To do this simply pipe the Get-Process output to the Out-Printer cmdlet with the -name argument of "Send To OneNote 2007" as shown below.

Sending the PowerShell output to the Send To OneNote 2007 printer will result in a new page located in the Unfiled Notes section as seen below. It will insert the output as an image. Unfortunately you do not have easy access to the text but OneNote 2007 will "full-text" search the image.

PowerShell is a very powerful command line tool - many times more powerful than Cmd.exe. This blog is dedicated to OneNote 2007 and not PowerShell so I don't expect to go into much detail with the capibilites of PowerShell. It is too expansive to cover it without writing a book. But I have more than enough interest in how PowerShell can work with OneNote 2007 out of the box as well as possible extension points of PowerShell and OneNote 2007. So you can probably expect more PowerShell/OneNote 2007 posts in the future For those of you who wish to learn more about PowerShell go to the PowerShell Technology Center located at: http://www.microsoft.com/windowsserver2003/technologies/management/powershell/default.mspx which contains many resources including the download for PowerShell.

OneNote 2007 Trial Version Released

2006-12-03T07:39:00.000-08:00

Grab the OneNote 2007 Trial version from Office Online!

Windows Live Messenger Send To OneNote 2007

2006-12-02T18:41:00.000-08:00

You know how it goes, a long IM session where the topic of discussion is how to take over the world. Good ideas have been had from both sides and then back to real work. But not before someone says "hey make sure we save a copy of the IM session!". No problem , as simple as Save As… Except it's now day 3 of a marathon of IM sessions all with good ideas and I already have a collection of text files detailing bits and pieces of our grand scheme.

Sure I can open each file, copy the text, and paste it into OneNote 2007 but strangely enough I just never get around to doing that. Necessity is the mother of invention and so I set out to create a simple but effective Windows Live Messenger To OneNote 2007 (WLM2ON) add in. It turns out that with Microsoft Live Messenger's Add In Api creating a basic Send To OneNote 2007 is fairly simple. Simple enough that I will post the project code in a separate blog post.

For now if you feel the need to capture your Live Messenger content to OneNote 2007 feel free to grab the install file: WLMOneNote2007AddIn.zip which is hosted by the owners of www.onenote2006.com. This simple Send To Add In requires Microsoft Live Messenger and OneNote 2007 (RTM).

But before I go into details about how to install the binaries you should take a look at the figure below which displays a very basic page created when using this tool. I originally set out to create a robust capture tool but after reviewing the Live Messenger Add In object model it became apparent that a robust tool is either not possible yet or beyond the very short time frame I had set.

So I have settled on a secondary, simpler approach that will allow me to post the code for others to use and improve. In this approach I have created the Windows Live Messenger OneNote 2007 Add In along with a simple install project that will allow you to send session messages to a new OneNote page. There are a few issues - first you must install the add in and turn it on. Next the add in can not differentiate between Messenger sessions. This appears to be a limitation of the Live Messenger Add In framework. Messages from all sessions are saved to the same OneNote page. But it is more of a working demo than the prescriptive guidance on Live Messenger Add In development.

Once you have the binaries extracted simply run the setup file. The install is pretty simple - just remember where you install the files to. By default it will go to [install drive]\program files\Unknown OneNote Guy\WLMOneNote2007AddIn . The install will enable Live Messenger Add Ins by adding a registry key. The install will only copy the add in files to the file system. To use the add in you must "install" it in Live Messenger and then "turn it on".

To install the add in into Live Messenger you must access the Add In tab located in the Options Dialog box. The fiigure on the right displays the Add In Tab. Click Add To Messenger button and navigate to the install directory. If you did not change the install directory it will be located at: [install drive]\program files\Unknown OneNote Guy\WLMOneNote2007AddIn. Select the OneNote2007AddIn.OneNoteAddIn.dll file and click ok.The figure below displays the Add In tab with the add in selected. Click the Ok button to close the dialog box. The add in should be installed.

Note: During some of the install testing the Add In tab was available but the controls contained in the tab were not enabled. I am unsure why this is but it appears that if you restart Live Messenger and start an IM session the controls will enable.

Now that the add in is enabled you need to start the add in. To start the add in click on the control that allows you to change your online status. Select Send To OneNote to start the add in. See figure on the right.

You can use Live Messenger to send and receive IMs as before. When you want to capture your IMs in OneNote type Send To OneNote on a single line and click Send. This is interpreted as a command and will create a new page under the Unfiled Notes Section. Figure 5 displays a OneNote 2007 page that has captured messages from Windows Live Messenger. If you wish to define a title then append the command with a colon and title. For example Send To OneNote : Test IM. Figures blow displays a page that was created using the Send To OneNote command with a title parameter as well as the OneNote pages created.

Over all this was a very simple add in built to solve a relatively simple issue. The OneNote code was minimal and to be honest, simpler then the code related to the Live Messenger Add In. Give it a try and let me know how it goes. In the next post I will provide the Add In code.

Blogging From OneNote 2007

2006-11-15T08:32:00.000-08:00

I maintain more than a few blogs based on various technologies. Some are actually read! All the blogs including this blog provides a web-based editing experience. These editing tools are Ok but they just cannot compare to a rich client editing scenario.

When I started this blog, I did so using OneNote 12, probably beta 2 version. I have tried Livewriter the MS blogging tool. It does a good job but it just did not provide the same writing experience as OneNote. My blog posts are part of my collection of information contained and organized in OneNote as sections and pages. Another benefit using OneNote for a blogging tool is spell check. OneNote like other Office products will provide "real-time" spell check whereas the version of Livewriter I used did not. Seeing all my misspelings:) appear with red squiggly lines is a big benefit because I can not spell.

The problem with blogging from OneNote 2007 is that it relies on Word 2007 to actually connect and push to the blog. Not a big deal, but not a great experience. Currently I create a new page under my OneNote blogging section and create my post. Once finished I then copy to NotePad. This will clean out any style tags and provide me with clean text only copy. Then it is off to the web-based blog editor where verify how it looks and tweak anything like links and images. It is truly a manual process but for some reason it is still a better fit then working out of Word or Livewriter.

So here lies opportunity, one that I can't help but think is already being addressed by the community. With the Xml-based apis for OneNote 2007 I believe it is entirely possible to create a OneNote 2007 MetaBlogAPI add in where I can go directly from OneNote 2007 to most blog by the touch of a button! If no one is moving in this direction well then lets join up and create a CodePlex site for this and have at it.

The second opportunity is that OneNote 14 should include this as a feature, similar to Word 2007. Blog postings are simply another bit of information. I go through a similar publishing process, from thought or idea to finished product on a blog site as I do with say a requirements doc. Given the choice I would like to see OneNote become the MS Blog Editor of choice…

Now that this is finished I will cut to NotePad and paste to Blogger.

Robert Gets It...

2006-11-15T07:56:00.000-08:00

Robert Bogue, SharPoint MVP, is getting into OneNote. Check out Robert's short blog post on Article: More Effective Requirements Gathering with Microsoft OneNote.

I think OneNote 14 should…

2006-10-25T19:57:00.000-07:00

Well it has been a busy few weeks. Office 2007 is about to go into RTM mode. And that means I have been busy working on Office 2007 - related products that need to be finalized. Conferences are upon us again. Seems like the last round just got over… so I am busy finalizing my various slide decks. No I will not be speaking about OneNote this time around. I have other content that must be presented and I have yet to see a conference that has some OneNote content other than TechEd and PDC. So now you know why I have not been able to post. Rest assured the OneNote XML Viewer is being improved as well as a few other interesting little apps. But for the next few weeks I am dedicated to development and slide decks...

For those of you in the OneNote community, those of you who follow all the blogs, you probably have seen Daniel's post on Send us your notes! We really want them!. You might have caught that at least some of the OneNote team is thinking vNext . Well today I was working in PowerPoint 2007 I found myself wishing the two played nicer together. So instead of keeping my thoughts to my self I decided that I should create a reoccurring topic . It seems that Blogger does not really have "categories" so I can not easily tag a set of posts as part of a specific topic. So today I create a post called I think OneNote 14 should…

So today's I think OneNote 14 should... theme is specifically about PowerPoint 2007 and PowerPoint vNext. I think you can easily extrapolate this concept beyond PowerPoint.

I think the notes page as well as normal page view where notes are displayed should be a OneNote 14 "control". Why should I settle for a basic text editor when I create notes for my presentation. Why would I not want to have my notes in a format that I can reuse? How about working on my notes in OneNote and opening up my presentation and seeing my notes show up?

To me this is a no-brainer - from a usability standpoint - not necessarily from a technical perspective. But when you think of it, why would my applications and third party applications benefit from an rich WinForm control where ever my users might benefit from collecting notes.

Now I know you are probably thinking - why not use a Side Note? That's a good question to ask. And I have the answer. I am not a big Side Note fan. Oh I use them but side notes break my momentum and thought flow. For myself Side Notes are ok for capturing quick thoughts and ideas - if later you go back and do something with them even if it is nothing more then deleting them.

I use a laptop 90 percent of the time (no tablet but that was another post:). I have limited screen space and nearly always work in full screen mode. Using a Side Note requires me to move it around or find a place one the screen that I am not using at the moment. It is pinned as the "top" screen by default and I can unpin the side note. With it pinned as the top screen I need to move it around as needed and if I change to say Outlook it is still pinned as the top screen and I have no need for that. If I unpin the Side Note it will be sent behind my PowerPoint app. Embedding the OneNote user interface as a control inside of a client will give me the basic power of OneNote located where I am used to seeing notes.

Ok, I know this is not an easy "fix" and is filled with implementation details that I would not even try to enumerate today. But if creating a embeddable control is beyond the 014 timeframe then the next step is to consider a "Smart" Side Note. One that can attach to a existing application window and would "disappear" when that specific application no longer has focus

Just an idea....

Dave Blogs About ON File Format

2006-10-09T06:25:00.000-07:00

If you don't follow follow Dave Rasmussen's blog you should head over and read his newest post on OneNote 2003 and 2007 file format compatibility.

Why the OneNote 2007 and 2003 file format are different

Sample Application up on OneNote Extensibility & More

2006-10-04T06:07:00.000-07:00

Daniel Escapa has posted a good example of using the OneNote API in his Send to OneNote from Windows Explorer – Sample App post. For any of you who are interested in extensibility and OneNote you should head over and take a look at his sample. The Send to OneNote from Windows Explorer sample application explains how to use the OneNote interops APIs to embed files into a new Unfiled Section page.

New Marketing Survey on OneNote PowerToys

2006-09-28T05:39:00.001-07:00

Make sure you head over to OneNote Power Toys to submit your vote in the Slogan for OneNote Keyboard Campaign survey that got started by my "Coffee Shop Denizen - Almost Gets It!" post. Get out and vote!

Coffee Shop Denizen - Almost Gets It!

2006-09-27T13:29:00.000-07:00

The story goes something like this...

While sitting at the local coffee shop this morning - working on some OneNote 2007 code a fellow coffee denizen at the next table asked about my computer backpack. Seems she was unable to find one that fit her tiny little white laptop which apparently will run Windows and someother cat-based os. I think it was tiger, panther, kitty cat, I'm not sure. I had not seen this tiny white laptop before so we starting into a conversation about laptops and gadgets.

To make a long story short our conversation progressed to our Pocket Pc phones and how much we used them. She explained how she really used her phone for emails and calendaring. Of course I came back with OneNote Mobile and how nice it is to be able to capture your ideas easily without requiring the laptop all the time. When I asked if she had ever used OneNote Mobile or even OneNote she promptly replied that she "did not have a tablet pc and therefore could not use it." Coffee Shop Denizen does not get it

Being the OneNote Guy that I am, I explained that there is no requirement for a tablet or handwriting to use OneNote.To be honest I only personally know about two or three individuals with tablet pcs and one of them does not use OneNote. Everyone else I know that uses OneNote does so with a laptop and a good old fashion keyboard. Surprised and amazed she took a few minutes to look over OneNote2007 on the good old laptop and after showing her pages, notebooks and sections she blurted out that OneNote 2007 appeared looked like a cool "organization" application. Coffee Shop Denizen now starts to get it!

I always wonder how it came to be that there are these misconceptions out in the wild. Maybe with a name that contains "Note" makes the application automatically register in people's mind that OneNote is a note-taking application (ok, so it is a note taking application but that is a fairly simplistic view of OneNote). Maybe it was the Tablet PC's marketing hype of handwriting recognition and OneNote that has gotten the masses convinced it is a Tablet PC application. (I wonder if those same people will think that they can not use Vista with a monitor now that Vista can do some really good text to speech!) Somehow the wrong impression seems to be the first impression. I find it is interesting that it is not just the general public that has these perceptions but educators and computer professionals alike.

It seems to me that the community and Microsoft needs to somehow change the general perception of OneNote and increase the general public awareness of OneNote. Maybe we need a 12-step program. Maybe we should have the world write on a blackboard (do those even exist anymore?) one-hundred times "OneNote works with a keyboard. OneNote is more than just a note-taking applicatoin." Maybe that is too harsh. How about a marketing campaign? That is the ticket - instead of doing a Power Toy competitiontion how about a marketing competition?

Here's my submissions:

OneNote- Its not just for Tablets Anymore - And to be Honest it was Never Just for Tablets!
OneNote: Where the Keyboard is as mighty as the ~~Sword~~, ah... Pen
OneNote: We Don't Need No Stinkin' Pen!

Let me know if you need my address to ship the prize!

Ok, maybe it is just my perception that is messed up and not the general public but it seems that you either "get" OneNote and can be considered a OneNote convert or you don't "get" OneNote and are not a OneNote convert. I don't think I have seen too many people that falls in the middle road of "getting" OneNote and not using OneNote.

Just my thoughts after a morning coffee shop conversation. I would be interested in your thoughts - do you agree there is still general misconception in the wild with OneNote? Drop a comment or send an email to onenoteguy@hotmail.com

Another OneNote Blogger

2006-09-27T11:53:00.000-07:00

I appears another OneNote PM has leaped into the the blogging domain. Make sure you take a look at Olya's blog at http://blogs.msdn.com/olya_veselova.

Welcome to the community!

Toolbar AddIn for OneNote 2007 Project Files

2006-09-22T09:16:00.000-07:00

I had been waiting for sometime to play with Toolbar Addins and with the updates included in the Technical Refresh I am finally able to give it a spin.

Daniel Escapa has provided beta documentation to create a sample Toolbar AddIn. You can download it from his blog posting titled "Creating Toolbar Buttons in OneNote 2007". Using Visual Studio.Net 2005 you can follow the step-by-step example and create a Toolbar Addin.

To help you along I followed Daniel's document as closely as possible and created the sample Toolbar AddIn. There were a few places in the document that needs a little clarification and I will pass those on to Daniel but over all you can follow it pretty easily. For your coding pleasure I have zipped up the completed VS.Net 2005 solution and the install files for Daniel's sample. You should be able to download the files, extract them to your hard drive and compile the code. Or if you just wish you can run the install files included in the archive.

The archive can be downloaded from the storage provided by owners of OneNote 2006 and OneNote PowerToys community sites. Here is the link you will need: http://www.adminid.com/onenoteguy/OneNoteSampleAddIn.zip

While you are downloading the file stop by and leave a read or post on their sites!

Office Technical Refresh is Available!

2006-09-14T10:21:00.000-07:00

Here is the link for the Office Client Technical Refresh:

http://www.microsoft.com/downloads/details.aspx?FamilyID=b07a3387-01cf-4bc3-821a-0bb10e7a59fa&DisplayLang=en

A Touch of Community

2006-09-13T06:23:00.000-07:00

If you have not heard OneNote 2006 is a new community blog. This blog will allow you to sign up as an author and contribute. I have already claimed my id and password but have not yet made my first post. This is one more step in the community-building process. I hope some of you who are OneNote advocates take the opportunity to post your thoughts and ideas at OneNote 2006 and help build up the OneNote community which is a benefit for us all.

I am also happy to announce that the owners of OneNote 2006 and OneNote PowerToys have graciously extended some file space hosting to the Unknown OneNote Guy blog. So for anyone looking for the OneNote 2007 Xml Viewer download you should be able to access it now at

http://www.adminid.com/onenoteguy/OneNote2007XmlViewer.zip

I will be leaving the download for the xml viewer on the original hosted server but I expect that if all goes well we will post our files only to shared spaced provided by the owners of OneNote2006 and OneNote PowerToys owners.

Check out Daniel's Post on GUIDs!

2006-09-11T08:57:00.000-07:00

If you read my previous post - A Look at GetHierarchy() Part II you will want to have a look at Daniel Escapa's post title "Small chat about OneNote GUIDs ". You get a little better understanding on how GUIDs and ids are used in OneNote. Of importance in this post if I read it correctly - certain ids are not persisted between starts and stops of OneNote - which I did not know.

Armed with a little more knowledge of GUIDs and IDs I will need to find some time to dig into the OneNote Xml Viewer and see how that effects other toys on my workbench. Obviously if I understand the post correctly we will not want to persist any hierarchical ids.

I appreciate anyone who can comment on my posts and clarify or correct any of the technical aspects of it. Got a comment, idea, correction or criticism drop me a comment. It is great that one of the PMs of the team is taking time to add to our community. There is obviously lots of little items that will not be readily apparent to us without some insider knowledge.

OneNote 2007 Xml Viewer

2006-09-09T19:45:00.000-07:00

Since OneNote extensibility revolves around an Xml-based interface its makes sense to deep dive into the Xml. In the earlier GetHierarchy posts I provided some basic demo code so you can view some of your OneNote's exported Xml in the console.

To make my life a little easier I created the OneNote Xml Viewer. It’s not rocket science, far from it in fact. The only OneNote object model method used by the OneNote Xml Viewer is GetHierarchy. Most of the code revolves around populating tree views, options, and parsing Xml. Simple as it is though it will give you a nice little User Interface to view the exported Xml.

Here's a screenshot:

Click here for a larger image....

I am not providing the base code on this little application. Not because I don’t wish to share, but because I used the bull in the china shop methodology for the User Interface code. As for the OneNote code I placed it all in a data access class and here it is:

//--------Start code -------

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Office.Interop.OneNote;

namespace unknown_onenote_blogspot
{
class ON_DataAccess
{
public ON_DataAccess()
{
_app = new ApplicationClass();
}

~ON_DataAccess()
{
_app = null;
}

public string GetAllInfo()
{
try
{
string resultsXml = "";
_app.GetHierarchy(null, HierarchyScope.hsPages , out resultsXml);
return resultsXml;
}
catch (Exception Ex)
{
throw Ex;
}
}

public string GetUnfiledNoteSection()
{
try
{
string unfiledNoteSectionID = "";
string loc = "";
_app.GetSpecialLocation(SpecialLocation.slUnfiledNotesSection, out loc);
_app.OpenHierarchy(loc, null, out unfiledNoteSectionID, CreateFileType.cftNone);
string resultsXml = "";
_app.GetHierarchy(unfiledNoteSectionID, HierarchyScope.hsPages, out resultsXml);
return resultsXml;
}
catch (Exception Ex)
{
throw Ex;
}
}

public string getNotebookXml(string notebookID, string hsScope)
{
string resultsXml = "";
try
{
_app.GetHierarchy(notebookID, getHsScope(hsScope), out resultsXml);
return resultsXml;
}
catch (Exception Ex)
{
return "Err";
}
}

public string getSectionXml(string sectionID, string hsScope)
{
string resultsXml = "";
try
{
_app.GetHierarchy(sectionID , getHsScope(hsScope) , out resultsXml);
return resultsXml;
}
catch (Exception Ex)
{
return "Err";
}
}

public string getSectionGroupXml(string sectionID, string hsScope)
{
string resultsXml = "";
try
{
_app.GetHierarchy(sectionID, getHsScope(hsScope), out resultsXml);
return resultsXml;
}
catch (Exception Ex)
{
return "Err";
}
}

public string getPageXml(string sectionID, string hsScope)
{
string resultsXml = "";
try
{
_app.GetHierarchy(sectionID, getHsScope(hsScope) , out resultsXml);
return resultsXml;
}
catch (Exception Ex)
{
return "Err";
}
}

private HierarchyScope getHsScope(string scope)
{
switch (scope.ToUpper())
{
case "HSSELF": return HierarchyScope.hsSelf;
case "HSSECTIONS": return HierarchyScope.hsSections;
case "HSNOTEBOOKS": return HierarchyScope.hsNotebooks;
case "HSPAGES": return HierarchyScope.hsPages ;
case "HSCHILDREN": return HierarchyScope.hsChildren;
default: return HierarchyScope.hsSelf;
}
}
ApplicationClass _app;
}
}

// ------ End Code ---------
If you were really planning on using this data access class I would seriously look at a little refactoring. I tossed it together late one night.

A few things to note about this application - I would not consider this a solid app. There was little if any design, no refactoring, and the User Interface portion was beat into submission with a stick - sorry I am a Web Developer and more behind the scenes then out in front. Big disclaimer here - please don’t use this in your mission critical applications. You get what you pay for in this application. It is meant for entertainment purposes only!

Also if you read Daniel Escapa's blog you will know that when Tech Refresh releases the namespace will more than likely change. But don’t worry - the namespace for this application is stored in the app configuration. So assuming GetHierarchy and the OneNote xml schema has not changed (other than the namespace) you can easily replace the old namespace with the new namespace by editing the config file.

The file is avaialble for download at this location:

http://oreys.com/download/2670f5718826/OneNote2007XmlViewer.zip.html

This is a free file hosting page and it seemed pretty innocuous. It seems like Blogger does not support any file hosting outside of basic images. Let me know if you have trouble bringing this zip file down. It contains two files, the exe and the config. Place them both in the same directory on a machine with OneNote 2007 Beta 2 installed and have a look around your Notebooks.

Check out the menu for options to select all, export the Xml to the file system and change the scope options. I intentially left all scopes in so you can play with Node Type v Hierarchial Scope. See my previous post. Some combos will return an error - you can check the post on Node Type v Hierarchial Scope to see what combos will give you errors.

WinWF and OneNote 2007?

2006-09-07T11:38:00.000-07:00

So here is a thought that I have been pondering - Where lies the value of a custom Windows Workflow Foundation/OneNote 2007 activity? I think this is a great topic for this blog since many of my posts revolve around extensibility and integration. So I will pose this question to you the reader.

What is the envisioned scenario around a custom WinWF/OneNote 2007 activity?

I have a few scenarios but I want to open it up to the readers for some community involvement. If we find a convincing scenario I might be just inclined to start working on it.

For those of you who might not be following .Net Framework 3.0 (a.k.a. WinFX) let me point you to a few links based on Windows Workflow Foundation.

Microsoft .Net Framework 3.0 - Windows Workflow Foundation Technology Page
http://msdn.microsoft.com/winfx/technologies/workflow/default.aspx

Windows Workflow Foundation(WF)
http://wf.netfx3.com/

ScottGu's Blog
http://weblogs.asp.net/scottgu/archive/2006/08/31/Windows-Workflow-Foundation.aspx

Matt W's Blog
http://blogs.msdn.com/mwinkle/

And let us not forget the Microsoft Office System's Workflow Implementation as well.

Walkthrough: Creating Office SharePoint Server 2007 Workflows in Visual Studio 2005
http://msdn2.microsoft.com/en-us/library/ms564355.aspx

Paul Andrew's Blog
http://blogs.msdn.com/pandrew/archive/2006/08/29/WorkflowInOfficePaper.aspx

So post a comment and let me know what you think is a worthwhile custom OneNote activity.

Larry Gets It!

2006-09-07T06:54:00.000-07:00

In a continuing attempt convince the general populace that OneNote is not just a "note taking utility" I am scouring the Net to find testimonials of successful OneNote users. Maybe I should start a So and So Doesn't Get It group. I digress... Anyway last night I stumbled onto Larry's posts on OneNote and it appears that Larry is someone who gets it!

Programming OneNote 12

Getting Things Done With OneNote12

OneNote 2007 Article on Organizing and Sharing Information

2006-09-06T08:08:00.000-07:00

Speaking of community....

Organize and share all your information with Microsoft Office OneNote 2007

This is a nice little primer on some OneNote 2007 features to help you capture, organize, find and share your information.

The OneNote Community

2006-09-05T07:48:00.000-07:00

If you haven't figured it out yet, I am big on technical communities. The OneNote community is not the only community that i am involved in and this is not the only blog that I post on. Why am I so interested in the community? It takes a community around a product or technology for that product to be adopted. I could almost go as far as stating without a community a product or technology will probably not become widely adopted. That may be stretching it a little. Maybe it is a synergy between a solid product and a strong community that results in quick and high adoption rates. Almost every major product has a strong community behind it but what is a community.

What is a community?
Well there is no one correct answer for the question "What is a community?". Communities are really nebulous and my concept of a community will be different than yours. It is interesting to see one technical community start a new concept and see other communities follow suit.

For myself communities are everything that revolves around the product. It is the newsgroups and list servers. It is the free power toys, readily available SDKs and KB articles. It is the free downloadable add-ins and demo code. It is web casts, pod casts and blogs. It is the chats, emails and white papers from the product team and evangelism team. It is partner, end-user and developer training and certification. Lets not forget the conference sessions, books, magazine articles and assorted swag.

Initially I had concluded being part of the community involved non-commercial interests but I am leaning away from that concept. Initially I was a purist - Not that I don't believe there needs to be a strong commercial side to the product - just that if it was to be community it should be non-monetary motivated. As a community member I have no problem suggesting that someone look at a third-party application to solve their problem. What bothers me about "commercial-community" is the answers to question are - "Look at my product" which may or may not be the correct answer. In general you should not have to purchase something to have free exchange of concepts and ideas. Lately I have seen commercial companies support community-related events in such a way as to not definitively link the event to the commercial company.

Another reason I now generally consider commercialism in the community world - if done correctly - is because of training, books and articles. These are great community resources but you generally need to purchase the product. The community would be missing a key element if there was no support for training companies and authors. And being an author at times I myself cannot just give away all that time and energy for nothing. Sorry, that is just the way it is. We all got to eat. :) And I would be remiss if I answered newsgroup postings with a pat " get my book, your answer is in Chapter 4". That type of answer does the community no good in my opinion.

So what makes a community?
Well there is obviously no one single answer. Certainly having a solid and useful product is required. Without a product that has a definite place in the software industry the community will be continue to struggle. To be honest a second generation product is almost required for a solid community. I should state that with any first round product like ON2003 there are some dedicated leaders and followers creating a community. It seems that it is that second iteration (and here comes ON 2007) where the community starts to grow and gets over the hump. That's not to say that first round products are bad or not worth the communities time, just that there is a certain amount of community leaders and community followers that is required to start the snowball effect.

There are certain items that all communities must have - again in my opinion.

The community must have strong product and evangelism team support and contact. I think everyone understands the product team. And the OneNote community seems to have pretty good support from the product team via blogs and email. Many may not know what I am referring to when I say evangelism team. The evangelism team is who ever is out there speaking about and around OneNote. This includes the Product Managers, MS community people, MVPs and other individuals not associated with Microsoft. Anyone who speaks at a conference, maintains a blog ect. is part of the evangelism team.

The community must have a strong, free knowledge base for support. This includes the blogs, newsgroups, web casts, list servers ect. Take a look at MS Exchange or MS Sql Server both produts with strong communities. If you Google either product you will so many results you could not possible look at it. Googling "SQL Server" results in about 119,000,000 results; "Exchange Server" has 30,900,000 and OneNote 7,540,000. Maybe it is unfair to compare OneNote to SQL Server. So lets look at "Microsoft Word" with 81,200,000 and "Microsoft OneNote" at 371,000.

Training and certifications are high on my list for fostering a strong community. Training either free or paid is important - both end user and developer are required in my opinion. Participating or integrating with existing MS training and certification structures is a must. As a developer or end user striving to achieve a specific MS certification I should have the option to choose a OneNote test instead of say an Excel or PowerPoint test. This gives OneNote some credibility. It shows that Microsoft considers OneNote as important as other products in the Office Suite. Without it OneNote will look like a distant cousin.

The last item I will cover under the guise of what makes a community is Books, Articles and Conferences. Any solid product has a following of authors who write books and articles supporting the product. And as the community grows we will be needing more and varied conference topics at the major conferences. I don’t think we get to a point where we will see a OneNote-specific conference - but anywhere Word or Excel shows up, OneNote speakers should be there.

Why do we care if we have community?
Community is legitimacy - in my mind. Community is promoting what we like to do and if you don’t like working with OneNote, then I would question why you are even reading this. With a strong community our ideas and concepts will carry more weight, be heard in more places.

Having a strong community is important for us that use ON both personally and professionally. It will give us tips, ideas and examples. It will help us use ON better in ways we do not think of. Community will give us ideas on new ways to use OneNote that we do not think of, helps us look outside of the box.

A strong community will allow us to have a "ring" of people to ask questions and receive answers.

A strong community will elevate the product in personal and corporate use. Will give us more opportunity to install, develop and design solutions to problems - and that means Jobs!

These are just One Guy's thoughts on community, Jotted down in OneNote no less and pushed to a blog. The sub title for this blog contains the words random and semi-useful and this post probably slips neatly into both categories. I feel that community is vitally important to the "success" of OneNote - particularly within corporate business. Let me know if you think I missed something or if I hit the nail right on the head so to speak. You have an idea that should be considered? Let me know. Think I am way off base - let me know.

Hierarchy Scope versus Node Type

2006-08-30T14:17:00.000-07:00

I was just about to call this post A Look at GetHierarchy() III but I think two posts named the "same" is enough. The previous posts I demonstrated how you can get access to content from OneNote using GetHierarchy() using the startNodeID and the HierarchyScope enumeration. I hope you took a few minutes to play with and view the different outcomes based on the startNode and the HierarchyScope. In this post I am covering how the startNodeID type and the HierarchyScope parameters effect the Xml returned.

In this post the actual startNodeID is not as important as the type of node startNodeID refers to. The startNodeID does signifies the "starting node" or what the top-level element in the retuned hierarchy will be. It also determines what element nodes are returned to the caller when reviewed in conjunction with the HierachyScope element.

For example for any given node type and a scope of hsSelf the returned Xml will include a single node of that type with attributes defined for the specific node based on the object ID. Here are examples of resultant Xml based on the node type referenced by the startNodeID

Notebook / hsSelf:
<?xml version="1.0"?>
<one:Notebook xmlns:one="http://schemas.microsoft.com/office/onenote/12/2004/onenote" name="OneNote Guide Beta 2" nickname="OneNote Guide Beta 2" ID="{674B715E-9A47-4A2C-9D11-5B7325B27D4B}{1}{B0}" path="C:\Documents and Settings\OneNoteGuy\My Documents\OneNote Notebooks\OneNote Guide Beta 2" lastModifiedTime="2006-08-25T12:13:41.000Z" color="none"/>

Section Group / hsSelf:
<?xml version="1.0"?>
<one:Folder xmlns:one="http://schemas.microsoft.com/office/onenote/12/2004/onenote" name="Test" ID="{20476F31-4276-4DC7-ADBE-A50D4F54D711}{1}{B0}" path="C:\Documents and Settings\OneNoteGuy\My Documents\OneNote Notebooks\OneNote Guide Beta 2\Test" lastModifiedTime="2006-08-30T18:42:22.000Z"/>

Section / hsSelf:
<one:Section xmlns:one="http://schemas.microsoft.com/office/onenote/12/2004/onenote" name="More Cool Features" ID="{AD8C801C-F573-0C63-1AC6-624F5676F284}{1}{B0}" path="C:\Documents and Settings\OneNoteGuy\My Documents\OneNote Notebooks\OneNote Guide Beta 2\More Cool Features.one" lastModifiedTime="2006-06-19T18:15:48.000Z" color="#FFD869"/>

Page / hsSelf:
<?xml version="1.0" encoding="utf-16"?>
<one:Page xmlns:one="http://schemas.microsoft.com/office/onenote/12/2004/onenote" ID="{68B0DC18-EC17-0B54-1699-913646F56278}{1}{B0}" name="1. Get a Quick Feel for OneNote" dateTime="2006-06-19T18:15:41.000Z" lastModifiedTime="2006-06-19T18:15:45.000Z" />

The value hsSelf will always return a single element of that type with attributes for the specific instance of the node determined by the startNodeID.

The hsSelf value is self explanatory. hsChildren is just about as self explanatory as hsSelf. Depending on the node type you will see the major nodes below it. hsChildren generally does not recurse below the immediate child node. For example if you use a startNodeId that references a Notebook element and the hsChildren scope the returned Xml will contain the root Notebook element and the immediate children elements which based on the schema include Folder and Section elements. You will not see Page elements nested within the Section element. Apparently the singular exception to this "immediate child only" scope is when the startNodeID references a Page node. In this instance you will get all node contained within the Page node element. This includes nodes that nested within other nested nodes.

Below is a table that displays the resultant Xml for node type versus scope. Where the element is referred to in the singular form it means only one element. Elements referred to in the plural form means zero or more. Elements include all the elements attributes in the Xml result. Error indicates that the node type/scope is not applicable and you will receive a COM exception.

I should mention I am running OneNote 2007 Beta2 so things might change. Also note that a Section Group is defined in Xml as a Folder element.

As always if you find anything contrary to this info please post a comment. I just dont have the time to test every scenerio possible and appreciate a critical eye so we have the most accurate information available to the community.

A Look at GetHierarchy() Part II

2006-08-25T07:04:00.000-07:00

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):

<?xml version="1.0"?>
<one:Notebook xmlns:one="http://schemas.microsoft.com/office/onenote/12/2004/onenote" name="OneNote Guide Beta 2" nickname="OneNote Guide Beta 2" ID="{674B715E-9A47-4A2C-9D11-5B7325B27D4B}{1}{B0}" path="C:\Documents and Settings\OneNoteGuy\My Documents\OneNote Notebooks\OneNote Guide Beta 2" lastModifiedTime="2006-08-25T03:04:48.000Z" color="none"><one:Section name="Getting Started with OneNote" ID="{BDD843A3-B7E2-0FAB-37B6-C7A9F317F049}{1}{B0}" path="C:\Documents and Settings\OneNoteGuy\My Documents\OneNote Notebooks\OneNote Guide Beta 2\Getting Started with OneNote.one" lastModifiedTime="2006-08-25T03:04:48.000Z" color="#D5A4BB"/><one:Section name="More Cool Features" ID="{AD8C801C-F573-0C63-1AC6-624F5676F284}{1}{B0}" path="C:\Documents and Settings\OneNoteGuy\My Documents\OneNote Notebooks\OneNote Guide Beta 2\More Cool Features.one" lastModifiedTime="2006-06-19T18:15:48.000Z" color="#FFD869"/></one:Notebook>

Brendon Wilson Gets It

2006-08-23T14:11:00.000-07:00

It doesn't take a genius or even a completed MBA to see the value in OneNote. Take a look at what Brendon Wilson has to say about it.

OneNote: PM Super Tool

A look at GetHierarchy()

2006-08-22T13:43:00.000-07:00

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.

Referencing the OneNote 2007 APIs in Visual Studio

2006-08-20T18:28:00.000-07:00

OneNote 2007 APIs are COM-based APIs. Luckily OneNote like other Office-based apps installs an interop dll into the GAC for .Net developers. Before we can start working with OneNote in Visual Studio we need to create a reference to the OneNote interop dll which will take care of the marshaling of data between managed .Net code and unmanaged COM code.

Creating a VS .Net references is simple. In a Visual Studio 2005 you can access the references from the Solution Explorer. If the Solution Explorer is not visible you can access it from the View menu or use the shortcut Ctrl-W, S. Figure 1 shows my Visual Studio's Solution Explorer.

Figure 1: VS Solution Explorer

To create a reference to the OneNote interop dll right click the reference node in the Solution Explorer , and select Add Reference to bring up the Add Reference Dialog as shown in Figure 2.

Figure 2: Add Reference Dialog

Select Microsoft.Office.Interop.OneNote and click the Ok button. You should see the reference listed under the Reference node in the Solution Explorer as shown in Figure 3.

Figure 3: VS Solution Explorer with OneNote reference

You can now access the OneNote API. Check back later as we work our way though the OneNote 2007 API.