OpenVista CIS

Novell has released a Gtk# Win32 installer for Gtk# 2.12.6, based on the installer source code released by Medsphere.  This is really cool to see more work by Medsphere being integrated into the "upstream" open source communities.

The release announcement: http://lists.ximian.com/pipermail/mono-devel-list/2008-December/030125.html

I will still stress that this is not the officially supported installer or Gtk# version for Medsphere products, and we recommend not using it in a production environment.

P/Invoke, short term for Platform Invoke, is the mechanism provided by the .NET framework to invoke unmanaged code (methods or functions from libraries written in C or C++ programming languages) from managed code. As an example let's look at some code from the OpenVistaCIS code base.

Let's look at the code that brings spelling support. If you have CIS's source code available go ahead and read the file src/Medsphere.OpenVista.Spelling/AspellSpeller.cs. The basic P/Invoke suport is based on the use of the DllImport attribute. What the DllImport attribute does is to provide the information needed to call a function from unmanaged code, which is described by the method's signature (which involves the name, return type and parameters types).

In order to create an Aspell dictionary on OpenVistaCIS we have two external libraries definitions that take care of what's the platform we are running on, either GNU/Linux or MS Windows

[DllImport ("aspell-15.dll", EntryPoint="new_aspell_speller")]
private static extern IntPtr new_aspell_speller_win32 (IntPtr config);
 
[DllImport ("libaspell")]
private static extern IntPtr new_aspell_speller (IntPtr config);

The first parameter for the DllImport attribute is the library name, that for the Win32 version is aspell-15.dll but for the Linux version is libaspell, we have to define two external method declarations due to that fact, then for the Win32's signature comes a named argument called EntryPoint that let us map the declaration to the original name of the method in the unmanaged library, so in that case we map new_aspell_speller_win32 to new_aspell_speller. Another important thing that we must highlight is the use of the extern method's modifier to "mark" the method as being implemented externally (that allow us to just use semi-colon as the method's body. And finally, we must highlight the use of the IntPtr type to represent a pointer or handle that's coming back from the unmanaged library.

Now, the way we use them inside the managed code is as follows:

public AspellSpeller (AspellConfig config)
{
    if (IsWindows) {
        error = new AspellCanHaveError (new_aspell_speller_win32 (config.Handle));
    } else {
        error = new AspellCanHaveError (new_aspell_speller (config.Handle));
    }
    .
    .
    .
}

Where the IsWindows property is defined as:

private static bool IsWindows {
    get { return ((int)Environment.OSVersion.Platform <= 3); }
}

The types used in an external method declaration can go from very simple Int32, String or more complicated types that need explicit marshalling. One very detailed article about is the one found in the Mono project's Interop with Native Libraries. Check it out for more details about P/Invoke.

I'm releasing the first Gtk# 2.12 installer for Windows today.  There has been a lot of community demand for this, so I wanted to get it out.  However I do want to be clear that this should be considered an EXPERIMENTAL installer by Medsphere's standards.  It has not gone through any QA process, and Medsphere will absolutely not be providing any official support for this.

That said, I'd be happy for people to use it, abuse it, and send bug reports to me regarding either the installer itself or for GTK+ on Windows in general.

If you're interested in using it, you can grab it from: http://bzr.medsphere.com/~cody/installers/gtksharp-sdk-2.12.3-1.msi