Nenad About Programming...

Teamplifier

2012-01-31T17:11:00.000+01:00

Teamplifier is small, off-side, project done in a free time by two members team in Belgrade. But, if I didn't tell you, you would never guess it was the case as it looks like a product of much bigger and expensive team. Although it is in beta phase and some of planned features are still missing, you can already feel the main idea behind it: small and lightweight web based project management tool aimed for small teams, freelancers and entrepreneurs.

It is extremely easy, in only few steps, to kick-start a project. Each project consists of more tasks in different stages. By advancing tasks you keep a track of a project progress, until it ends naturally. Beside projects itself, you have to define users and groups, each with its own settings. And that's all. No complicated rules, workflows and meaningless features. That is exactly what is expected from the ultimate project management tool for small organizations, to be there to help in turbulent and dynamic environments, but not distract processes by imposing its own rules and regulations.

And the best feature of all: it is completely free.

PST Data Structure View Tool

2010-05-31T15:42:00.001+02:00

PST Data Structure View Tool: "PST Data Structure View Tool (PSTViewTool) is a tool supporting the PST file format documentation effort. It allows the user to browse the internal structures of a PST file."

More about structure of a PST file: Outlook Personal Folders File Format (.pst) Structure Specification

Use embedded IE in FHP to show Office documents

2010-01-22T16:44:00.000+01:00

You can use embedded Internet Explorer control, hosted by FHP, to show Office documents. But, by default, IE will open them as read-only, even if they are local files. If you are using SharePoint server, you can notice that it opens Office documents as read/write in that case.
So, in order to resolve this behavior so that IE opens documents that are in the Internet or Local intranet security zones with read/write permissions, you must add the following registry key:

• For Office XP
HKEY_CURRENT_USER\Software\Microsoft\Office\10.0\Common\Internet\OpenDocumentsReadWriteWhileBrowsing = 1

• For Office 2003
HKEY_CURRENT_USER\Software\Microsoft\Office\11.0\Common\Internet\OpenDocumentsReadWriteWhileBrowsing = 1

• For the 2007 Office system
HKEY_CURRENT_USER\Software\Microsoft\Office\12.0\Common\Internet\OpenDocumentsReadWriteWhileBrowsing = 1

PIA for Office 2007 and VSTO 3.0 Improvements

2009-12-11T15:47:00.000+01:00

- Richer support for Outlook Object Model; twice larger, with 85 classes included.
- Performance improvements. Introduced new Table object for faster accessing items and properties and PropertyAccessor for faster property access.
- Richer security model and in some cases simpler appliance. Application object within add-in is trusted as safe by default.
- New forms regions which can be added in Explorer and Inspector to show more properties of displayed item.
- New ribbons can be added.
- Some of context menus are allowed to change.
- Access to Outlook Rules.

Security and FHP

2009-12-03T13:36:00.000+01:00

User control which is embedded in Folder Home Page must be registered as COM object and marked as Safe for Scripting. This is done automatically by Visual Studio during debugging but must be set manually in installer if you want installed application to work properly.

Outlook 2007 has strengthened security model from 2003 version - it will not allow custom FHP for non-default PST file. If you have additional PST file, beside default one you have to allow it by setting this key in the registry to 1:

HKCU\Software\Microsoft\Office\12.0\Outlook\Security\NonDefaultStoreScript

Hosted control in FHP

2009-11-18T13:05:00.002+01:00

Usually Outlook loads all add-ins in their application domains, to isolate them from Outlook and from each other. In that way, unstable add-in will be prevented to influence on Outlook or the other add-ins. If some add-in hung, Outlook will not load it next time it starts.

But, control hosted in custom FHP work in the same application domain as Outlook, which can be risky because any instability in add-in can endanger the whole Outlook. FHP is an acronym for Folder Home Page - an HTML page that may be displayed when user clicks on the folder icon to represent its content. That page may include any other user control, which is a usual way for a developers to embed a new control in Outlook.

New Explorers and Inspectors

2009-04-22T17:29:00.003+02:00

There is no way to change look and feel of the Explorer window which displays current folder in the Outlook. But, Inspector which displays the content of the opened item for some item type can be changed. More accurate, the default one can be prevented to show, and any other Windows form can be displayed instead of.
There is a supported way to make some new form for displaying item or to change existing one. But this can’t be done programmatically. Furthermore, user can always change form again by changing Outlook properties.
You can make brand new Message class which is bounded to Outlook item, but there is no way to introduce brand new Outlook item. It is possible only to add a new one which is inherited from existing one, for example: IPM.Note.MyNote from IPM.Note.
New item can be displayed by a custom form as well.

ItemRemove Event in Outlook 2003

2009-04-03T13:44:00.002+02:00

There is a problem with ItemRemove event on Items collection of a folder in Outlook 2003: it does not return item removed, so the only option to find out which item has been removed is to count items before and after delete.
The individual item objects have a BeforeDelete event, but it's usable only if you're willing to use a wrapper class to instantiate an instance for every open or selected item.
Problem is not in Outlook Object Model, it is on the MAPI level, TABLE_CHANGED
event is fired rather than TABLE_ROW_DELETED.
This was fixed in Outlook 2007.

ItemAdd Event

2009-04-01T17:07:00.003+02:00

There is one event that is fired when a new item is arrived in the folder. It's a folder event. But, there is a problem with that event: ItemAdd may not fire if many items arrive in the folder at once.
A workaround would be to process the Item that ItemAdd passes as an argument and mark that item as processed (you can use Mileage property for that purpose). Then process any other unmarked items in the folder.

Mutithreading and Outlook Programming

2009-03-27T11:48:00.003+01:00

Outlook Object Model is run in a STA COM server. Single-Threaded Apartment COM server will execute all calls on its main (and single) thread. If a client running on another thread wants to call an object in a single threaded apartment, the two threads need to be forcibly synchronized. It is known as 'marshaling'.
That means that you don't gain any performance when using multithreading. All the calls are going to run on the same thread anyway and you incur the overhead hit. There's not really an advantage to multithreading Outlook Object Model.
You can learn more about COM programming here and here.

Activate and Close Events

2009-03-25T16:17:00.003+01:00

When an Activate or Close event occurs (on Explorer and Inspector objects), it doesn't tell you which inspector or explorer is activate or closed. Even worse, the CurrentExplorer or CurrentInspector references are the previous instance, not the newly activated instance.
Solution is as follows: when a NewExplorer or NewInspector event comes in (from the Explorers and Inspectors collections, respectively), create a wrapper object. This wrapper holds a reference to the explorer or inspector object to which you register for Activate and Close events. In your add-in you should keep a collection of the wrapper objects and register for Activate and Close events with your wrapper object which forwards the underlying explorer or inspector events. Now when an event comes in, you know which explorer or inspector it is because it is identified by the wrapper object.

Event Handlers

2009-03-23T14:22:00.002+01:00

When adding event handlers to any Outlook object, such as the Explorers and Inspectors collections or the Explorer and Inspector objects, you have to retain a reference to those items in your add-in. The reason for this is because the objects presented to the add-in by Outlook are not the actual objects, but rather interface objects providing limited access to the actual underlying objects. When the object goes out of scope it is discarded. Every time you get a reference, it's a new interface object so you never actually see the same object twice. Thus if you do not save a reference, your event handlers are discarded and garbage collected. Thus they don't throw events or at least not for long.

VSTO is COM object

2009-02-02T15:48:00.002+01:00

Visual Studio Tools for Office (VSTO) add-ins are COM objects.
Almost every object that is used in Outlook is a COM object (inspectors, explorers, etc). They won't be discarded as long as any kind of reference is held on them. That means that when you are finished with these objects you must release your references to them. But you must also release the object from COM using Marshal.ReleaseComObject().
In many cases unless you do use Marshal.ReleaseComObject() you don't know when the objects are actually released and as a result you can get memory leaks.
You do have to be careful as to when you call Marshal.ReleaseComObject() because it releases all references to an object, including copies and different instances of the object. For example call Marshal.ReleaseComObject() on an Inspector passed to a class or method and not only that copy but the original object are released and attempts to use the object result in an invalid RCW error.
Only call Marshal.ReleaseComObject() when you are completely finished with an object and any copies/instances of the object.
Another reason to call Marshal.ReleaseComObject() is the default 256 RPC channel limit to Exchange. If you end up with that many or more current objects instantiated, for example in a loop, then you will get errors back when trying to instantiate any additional objects. That applies even to implicit objects internally instantiated due to dot operators. Setting the instances to null often isn't enough to release RPC channels due to the indeterminate nature of when the GC runs. In those cases often the only way to complete a loop is to explicitly call to Marshal.ReleaseComObject() and then to GC.Collect().

Navigation Pane in Outlook

2008-11-20T23:06:00.002+01:00

There are no way to influence on a look and feel of the navigation pane in Outlook 2003 and 2007. It is possible only to add a new shortcut in the shortcuts pane. Outlook documentations doesn't recommend adding new functionalities in Outlook navigation pane in any case.

Transfer Old Solutions to New Visual Studio

2008-11-10T15:39:00.002+01:00

If you have developed applications in Visual Studio 2005 for Office 2003 and you are willing to make a transfer to new versions of Visual Studio and Office it wouldn't be a problem at all.
First be sure to have installed PIA for Office 2007 and VSTO 3.0 on a new machine. Than just open an old project in Visual Studio 2008 an it will automatically convert older VS 2005 solution and project files and additionaly will update all references to work on Office 2007.

Add-In for Outlook 2003 and 2007

2008-11-07T14:16:00.000+01:00

MSDN Documentation states that: ‘There is no supported way to use VSTO to create add-in that that works on both Outlook 2003 and 2007.’
But actually it is possible to make add-in for Outlook 2003 which works on Outlook 2007 because VSTO 3.0 runtime can detect that add-in is made for previous version of Outlook and can set environment for it.
However, backward compatibility is not possible.
Additional difficulty is that Outlook 2003 and 2007 can’t work on the same machine, which makes development and testing a little bit harder than usual.

Office Programming Models

2008-10-24T15:43:00.006+02:00

Beside VSTO (Visual Studio for Office) and PIA (Primary Interop Assemblies) for Office 2003/2007, there are two additional older technologies to program against MAPI stores:

Extended MAPI (Messaging Application Program Interface) is set of functions that can be used to create MAPI enabled applications. Extended MAPI (or MAPI 1.0) allows complete control over the messaging system on the client computer, creation and management of messages, management of the client mailbox, service providers, and so forth. Extended MAPI is programming using C or C++.
CDO (Collaboration Data Objects) is a COM wrapper of the MAPI library and can be called from any development language that supports automation. CDO implements most but not all MAPI functionality.

Both of them provide a way to read and write more properties for MAPI store and items than PIA and to accomplish more tasks that using VSTO so sometimes they are the only way to do something. But VSTO 3.0 and PIA for Office 2007 provides more options to make custom MAPI items and stores so there is less need for using additional technologies.

Proof Of Concept Outlook Add-In

2008-10-14T13:59:00.003+02:00

Three months ago, I got a task to make Proof Of Concept Outlook Add-In for an internal project in my company.

As I have some experience in using Office platform, specifically Outlook, I thought that I shouldn't have any problem in programming against Office platform.

Microsoft has put a lot of effors in making Office easy to learn and use as a programming platform and in some extent they manage to make it so. But, if you need to do something in a way which is not meant by API creators you'll get a lot of problems, so I had them a lot.

To make a long story short, these were my targets at the begining:

Make an add-in for Outlook (versions 2003 and 2007). Support look & feel of Outlook. List all items in a folder structure. Support preview of items for common types and in an addition, changing and saving items where it is possible.
Use Visual Studio Tools for Office (VSTO) to create add-in. Alternative is to use COM development targeting Office platform (no indentified advantages over VSTO).

In the following posts, I will try to describe all problems that I had and what I did to solve them in a single aim: not to forget them.