by Buz

Single Instance Application - Part 2 : activating existing instance

Buz & Skup — Thu, 24 Nov 2005 18:00:00 GMT

Well, I did not have post for a long time. I was working hard on the next version of PixVillage, which will be released soon now.

I'm coming back with a new post in the Single Instance Application series.

In the previous post, we have written a ProcessLock object that help us to detect an existing instance of the program we attempt to run, so that we can prevent running it twice.

Today I'm dealing with the ability to activate an existing instance of a Windows Forms application when running a new one. In order to achieve that, we have to notify the application it has to go foreground and get focus.

This can be done though a message send to the main thread of the application. The message is received by the thread, not by a window, so we have to write a specific handler and register it. The IMessageFilter interface helps providing this kind of service. Let's implement it!

Code Copy HideScrollFull

namespace SingleInstance {/// <summary>
/// Provides a thread message filter and handle messages.
/// </summary>
public class ThreadMessageFilter : IMessageFilter {private Form owner;

/// <summary>
/// Initializes a new instance of the <see cref="ThreadMessageFilter"/> class.
/// </summary>
/// <param name="owner">The owner.</param>
public ThreadMessageFilter(Form owner) {this.owner = owner;
}

/// <exclude/>
[SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode=true)]
bool IMessageFilter.PreFilterMessage(ref Message m) {if (m.HWnd != IntPtr.Zero) // Get rid of message if it's sent to a window...return false;
// Handle the message here...

return false;
}
}
}

Now, supposing we want to activate the window when a new instance of the application is launched, we can, for instance, send a WM_SHOWWINDOW message to the thread, using the Windows PostThreadMessage API. The IMessageFilter.PreFilterMessage is implemented as follow:

Code Copy HideScrollFull

/// <exclude/>
[SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode=true)]
bool IMessageFilter.PreFilterMessage(ref Message m) {if (m.HWnd != IntPtr.Zero) // Get rid of message if it's sent to a window...return false;
if (m.Msg == WM_SHOWWINDOW) {// Shows the window
try {owner.Show();
if (owner.WindowState == FormWindowState.Minimized)owner.WindowState = FormWindowState.Normal;
return true;
}
catch {} // return false;
}

return false;
}

With WM_SHOWWINDOW declared as follow:

Code Copy

private const int WM_SHOWWINDOW = 0x18;

Now, we just have to modify the Main() method in order to:

Create and show the form the first time the application is started.
Registers and unregisters a ThreadMessageFilter object.
Send the message to any thread of any process having the same name as the current assembly.

The code is given below. (MainForm is a class derived from System.Windows.Form).

Code Copy HideScrollFull

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace SingleInstance
{public sealed class SingleInstance
{private SingleInstance(){}
private static readonly string assemblyName = Assembly.GetExecutingAssembly().GetName().Name;

[DllImport("user32.dll")]
private static extern bool PostThreadMessage(int threadId, int message, int wParam, int lParam);

private const int WM_SHOWWINDOW = 0x18;

/// <summary>
/// Application entry point.
/// </summary>
[STAThread]
static void Main() {using(ProcessLock processLock = new ProcessLock(assemblyName)) {if (processLock.AlreadyExists)
{// Sets the existing application foreground.
SetForeground();
}
else
{// The program operation must run inside the 'using' block.
Run();
}
}
}

private static void SetForeground() {// Find all processes having the same name
Process[] processes = Process.GetProcessesByName(assemblyName);
foreach (Process process in processes)
{if (process.Id == Process.GetCurrentProcess().Id)                // This is the current process, pass
continue;
// Activates the other instance window by sending the message to any thread in the process.
foreach (ProcessThread thread in process.Threads)PostThreadMessage(thread.Id, WM_SHOWWINDOW, 0, 0);
}
}

private static void Run() {using(MainForm form = new MainForm()) {IMessageFilter filter = new ThreadMessageFilter(form);
Application.AddMessageFilter(filter);

try
{form.Show();
Application.Run(form);
}
finally {Application.RemoveMessageFilter(filter);
}
}
}
}
}

. . .

Single Instance Application - Part 1 : preventing multiple instances

Buz & Skup — Thu, 21 Apr 2005 13:48:00 GMT

Don't worry, the Exif series is not closed yet... preparing Part 4 just requires more work...

This new post series is dedicated to - as title say - the creation of a single instance application. That is, application that can only run once simultaneously. That's a frequently encountered issue, particularly when your program makes use of resources that cannot be shared (overlay video surfaces, network listen ports, etc.)

My solution to the single instance application problem is to create a class called ProcessLock that can be locked, unlocked, and indicate whether the application is running.
The ProcessLock implements the IDisposable interface, so that the process lock can be locked and unlocked through a using statement. The implementation uses a named mutex (with is global to the user session).

The ProcessLock tries to create the underlying mutex in the constructor. A failure means that the mutex does already exist : the application is running.

Code Copy HideScrollFull

#region
    References

using System;
using System.Diagnostics;
using System.Threading;

#endregion

     

     namespace SingleInstance {///
      <summary>
/// Provides a lock object to 
      prevent a program from being launched multiple times.
/// </summary>
public class ProcessLock 
     : IDisposable {
#region Fields

private string applicationName;
private Mutex mutex;
private bool created;
private bool disposed;

#endregion

       

       #region Instance Management

/// <summary>
/// Initializes a new instance 
       of the <see cref="ProcessLock"/>
       class.
/// </summary>
/// <param 
       name="applicationName">Name of the 
       process lock</param>
public ProcessLock(string
      applicationName) {this.applicationName 
       = applicationName;

       TryLock();

      }

/// <summary>
/// Disposes the process lock 
       resources.
/// </summary>
public void Dispose() 
      {if (mutex!=null){if
        (created)Unlock();

        else {mutex.Close();

         mutex = null;

        }

       }


       disposed = true;

      }

#endregion

       

       #region Properties

/// <summary>
/// Indicates whether a process 
       for the given name does already exist.
/// </summary>
public bool AlreadyExists 
      {get {return
        !created;

       }

      }

/// <summary>
/// Indicates whether the 
       process lock is disposed.
/// </summary>
public bool Disposed 
      {get {return
        disposed;

       }

      }

#endregion

       

       #region Methods

/// <summary>
/// Try to get the process lock 
       again.
/// </summary>
public bool TryLock(){if
       (disposed)throw
         new ObjectDisposedException("ProcessLock");

        
       

       if (created)throw
         new InvalidOperationException();

        
       

       if (mutex!=null)mutex.Close();

       mutex = new Mutex(true, 
       applicationName, out created);

return created;

      }

/// <summary>
/// Releases the process lock.
/// </summary>
public void Unlock() 
      {if (disposed)throw
         new ObjectDisposedException("ProcessLock");
if (!created)

        throw new InvalidOperationException();

       Debug.Assert(mutex!=null);


       mutex.ReleaseMutex();

       mutex = null;

       created = false;

      }

#endregion

     }

    }

Using a ProcessLock is quite straight-forward. A sample Console application follows (you will note the use of System.Reflection.Assembly for retrieving the application name) :

Code Copy HideScrollFull

using
    System;
using System.Reflection;

namespace SingleInstance

    {public
      sealed class SingleInstance

     {private SingleInstance(){}
private static
       readonly string assemblyName = 
      Assembly.GetExecutingAssembly().GetName().Name;

/// <summary>
/// Application entry point.
/// </summary>

      [STAThread]
static void Main() {using(ProcessLock 
       processLock = new ProcessLock(assemblyName)) {if
        (processLock.AlreadyExists)return;

         
        

        // The program operation must run inside the 'using' block.

        Run();

       }

      }

private static
       void Run() {Console.WriteLine("{0} 
        running. Press 'Enter' to exit.", assemblyName);

       Console.ReadLine();

      }

     }

    }

In the next post, I will explain how to bring a window to the foreground, even if it is currently invisible...

Exif Properties in .Net - Part 3 : converting properties

Buz & Skup — Tue, 19 Apr 2005 12:20:00 GMT

In the first post of this Exif series, I talked about a technique for loading Exif properties as fast as GDI+ is able to do.
The second post was dealing with adding new properties to an empty image.

Now it's time to look more precisely at the Exif properties. How is a PropertyItem structured ?
The final goal of this post is to convert the raw data exposed by GDI+ (and the .Net Framework) into more useable data types.

An Exif property consists in the following information:

An identifier, determining the "meaning" of the property.
A data type, indicating how the data are represented.
A length (the number of bytes the property data contains).
A value which is a raw array of bytes.

The Exif property data type is a 16-bit integer, but it's quite simple to build an enum type that maps the values to a more comprehensive type :

Code Copy HideScrollFull

///
     <summary>

     /// Defines types for Exif Properties.
/// </summary>
public enum ExifPropertyType 
    {/// <summary>

     /// Specifies that the value 
      data member is an array of bytes.

     /// </summary>

     Byte = 1,

     /// <summary>

     /// Specifies that the value 
      data member is a null-terminated ASCII string.

     /// </summary>

     /// <remarks>If 
      you set <see 
      cref="PropertyItem.Type">PropertyItem.Type</see>
      to <see cref="PropertyItem.Type"/>, 
      you should set the length data member to the length of the string including the 
      NULL terminator. For example, the string HELLO would have a length of 6.</remarks>

     Ascii = 2,

     /// <summary>

     /// Specifies that the value 
      data member is an array of signed short (16-bit) integers.

     /// </summary>

     UInt16 = 3,

     /// <summary>

     /// Specifies that the value 
      data member is an array of unsigned long (32-bit) integers.

     /// </summary>

     UInt32 = 4,

     /// <summary>

     /// Specifies that the value 
      data member is an array of pairs of unsigned long integers. Each pair 
      represents a fraction; the first integer is the numerator and the second 
      integer is the denominator.

     /// </summary>

     URational = 5,

     /// <summary>

     /// Specifies that the value 
      data member is an array of bytes that can hold values of any data type.

     /// </summary>

     Raw = 7,

     /// <summary>

     /// Specifies that the value 
      data member is an array of signed long (32-bit) integers.

     /// </summary>

     Int32 = 9,

     /// <summary>

     /// Specifies that the value 
      data member is an array of pairs of signed long integers. Each pair represents 
      a fraction; the first integer is the numerator and the second integer is the 
      denominator.

     /// </summary>

     Rational = 10,

    }

As you can see in the code above, most of the data types are simple and can be directly mapped to .Net data types, excepted for rational and unsigned rational values. We need to create a .Net representation for each of them :

Rational :

Code Copy HideScrollFull

///
     <summary>

     /// Represents a signed rational number.
/// </summary>
public class Rational 
    {private
      int numerator;
private int denominator;

/// <summary>
/// Initializes a new instance 
      of the <see cref="Rational"/>
      class.
/// </summary>
/// <param 
      name="numerator">The numerator of the 
      rational number.</param>
/// <param 
      name="denominator">The denominator of 
      the rational number.</param>
public Rational(int numerator,
      int denominator) {this.numerator 
      = numerator;

      this.denominator = denominator;

     }

/// <summary>
/// Gets the numerator of the 
      rational number.
/// </summary>
public int Numerator 
     {get {return
       numerator;

      }

     }

/// <summary>
/// Gets the denominator of the 
      rational number.
/// </summary>
public int Denominator 
     {get {return
       denominator;

      }

     }

/// <summary>
/// Gets the floating-point 
      value of the rational number.
/// </summary>
public double Value {get
      {return (double) 
       numerator/(double) denominator;

      }

     }

/// <exclude/>
public override
      string ToString() {return
      Value.ToString();

     }

    }

. . .

URational :

Code Copy HideScrollFull

///
     <summary>

     /// Represents an unsigned rational number.
/// </summary>
public class URational 
    {private
      uint numerator;
private uint denominator;

/// <summary>
/// Initializes a new instance 
      of the <see cref="Rational"/>
      class.
/// </summary>
/// <param 
      name="numerator">The numerator of the 
      rational number.</param>
/// <param 
      name="denominator">The denominator of 
      the rational number.</param>
public URational(uint 
     numerator, uint denominator) {this.numerator 
      = numerator;

      this.denominator = denominator;

     }

/// <summary>
/// Gets the numerator of the 
      rational number.
/// </summary>
public uint Numerator 
     {get {return
       numerator;

      }

     }

/// <summary>
/// Gets the denominator of the 
      rational number.
/// </summary>
public uint Denominator 
     {get {return
       denominator;

      }

     }

/// <summary>
/// Gets the floating-point 
      value of the rational number.
/// </summary>
public double Value {get
      {return (double) 
       numerator/(double) denominator;

      }

     }

/// <exclude/>
public override
      string ToString() {return
      Value.ToString();

     }

    }

. . .

According to the Exif specification, properties may contain arrays of values. Our conversion tool must consequently have the following signature :

Code Copy

public
     static Array FromPropertyItem(PropertyItem propertyItem) {}

The conversion code is quite simple (a switch... case construct branching on different code depending on the data type).
When converting raw data into integers, just take care that Exif properties are stored as big endian values.

Code Copy HideScrollFull

#region
    References

using System;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using System.Text;

#endregion

     

     namespace ExifNative {///
      <summary>
/// Summary description for 
      ExifConvert.
/// </summary>
public sealed
      class ExifConvert {private
      ExifConvert() {}

/// <summary>
/// Converts a property item to 
       an array of objects.
/// </summary>
/// <param 
       name="propertyItem">The property item 
       to convert.</param>
/// <returns>An 
       array of <see cref="object"/>
       items.</returns>
public static Array 
      FromPropertyItem(PropertyItem propertyItem) {ExifPropertyType 
       type = (ExifPropertyType) propertyItem.Type;

switch (type) {case
        ExifPropertyType.Raw:// The value 
          represents raw data (a single byte[] value)

         return new
          byte[][] {propertyItem.Value};

         

        
case ExifPropertyType.Ascii:// 
          The value represents an array of strings separated by \0 characters

         string stringValue = 
         Encoding.ASCII.GetString(propertyItem.Value, 0, propertyItem.Len - 1);

         return stringValue.Split('\0');

         

        
case ExifPropertyType.Byte:// 
          The value represents an array of bytes

         return propertyItem.Value;

         

        
case ExifPropertyType.UInt16:// 
          The value represents an array of unsigned 16-bit integers.
int ushortCount = propertyItem.Len/ushortSize;

ushort[] ushortResult = new
          ushort[ushortCount];
for (int i = 0; i 
         < ushortCount; i++)ushortResult[i] = 
          ReadUInt16(propertyItem.Value, i * ushortSize);

         return ushortResult;

case ExifPropertyType.Int32:// 
          The value represents an array of signed 32-bit integers.
int intCount = propertyItem.Len/intSize;

int[] intResult = new
          int[intCount];
for (int i = 0; i 
         < intCount; i++)intResult[i] = 
          ReadInt32(propertyItem.Value, i * intSize);

         return intResult;

case ExifPropertyType.UInt32:// 
          The value represents an array of unsigned 32-bit integers.
int uintCount = propertyItem.Len/uintSize;

uint[] uintResult = new
          uint[uintCount];
for (int i = 0; i 
         < uintCount; i++)uintResult[i] = 
          ReadUInt32(propertyItem.Value, i * uintSize);

         return uintResult;

case ExifPropertyType.Rational:// 
          The value represents an array of signed rational numbers
// Numerator is an Int32 value, denominator a UInt32 value.
int rationalCount = propertyItem.Len/rationalSize;


         Rational[] rationalResult = new Rational[rationalCount];
for (int i = 0; i 
         < rationalCount; i++)rationalResult[i] =
           new Rational(ReadInt32(propertyItem.Value, 
           i * rationalSize),

           ReadInt32(propertyItem.Value, i * rationalSize + intSize));

         

         return rationalResult;

case ExifPropertyType.URational:// 
          The value represents an array of signed rational numbers
// Numerator and denominator are UInt32 values.
int urationalCount = 
         propertyItem.Len/rationalSize;


         URational[] urationalResult = new URational[urationalCount];
for (int i = 0; i 
         < urationalCount; i++)urationalResult[i] =
           new URational(ReadUInt32(propertyItem.Value, 
           i * urationalSize),

           ReadUInt32(propertyItem.Value, i * urationalSize + uintSize));

         

         return urationalResult;

default:return
          null;

       }

      }

#region Static Fields

private static
       readonly int ushortSize = 
      Marshal.SizeOf(typeof (ushort));
private static
       readonly int intSize = Marshal.SizeOf(typeof
      (int));
private static
       readonly int uintSize = Marshal.SizeOf(typeof
      (uint));
private static
       readonly int rationalSize = 2 * 
      Marshal.SizeOf(typeof (int));
private static
       readonly int urationalSize = 2 * 
      Marshal.SizeOf(typeof (uint));

#endregion

       

       #region Private Helpers

private static
       ushort ReadUInt16(byte[] buffer,
       int offset) {return
       (ushort) (((ushort) 
        buffer[offset] +

        ((ushort) buffer[offset + 1] << 8)));

      }

private static
       int ReadInt32(byte[] buffer,
       int offset) {return
       (int) (((uint) 
        buffer[offset] +

        ((uint) buffer[offset + 1] << 8) +

        ((uint) buffer[offset + 2] << 16) +

        ((int) buffer[offset + 3] << 24)));

      }

private static
       uint ReadUInt32(byte[] buffer,
       int offset) {return
       (uint) (((uint) 
        buffer[offset] +

        ((uint) buffer[offset + 1] << 8) +

        ((uint) buffer[offset + 2] << 16) +

        ((uint) buffer[offset + 3] << 24)));

      }

#endregion

     }

    }

The following code is a sample console application that make use of the code above to load an image and display the content of Exif properties.

Code Copy

[STAThread]
private static
     void Main(string[] args) {using(Image 
     image = Image.FromFile(args[0])) {Console.WriteLine("{0} 
       : {1} properties", args[0], image.PropertyItems.Length);

foreach (PropertyItem propertyItem
       in image.PropertyItems) {Array result = 
       ExifConvert.FromPropertyItem(propertyItem);

       Console.WriteLine("Property #{0}, type : {1}, {2} 
        value(s)", propertyItem.Id, 
       (ExifPropertyType)propertyItem.Type, result.Length);

foreach (object
        value in result)Console.WriteLine("\t{0}",
         value);

       

       Console.WriteLine();

      }

     }

    }
   

C# code and copyright notice

Buz & Skup — Mon, 18 Apr 2005 15:51:00 GMT

Some people asked me the question so...

If you wish to use the C# code we are publishing on this blog, you're free to do so, under the following condition : if your application source code is public, you must include the following header at the top of the source code you got from this blog :

/* Copyright © 2005, The PixVillage Team All rights reserved. http://www.pixvillage.com/blogs/devblog/ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - Neither the name of the PixVillage Team, nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */

Implementing UPnP Nat Traversal

Buz & Skup — Thu, 31 Mar 2005 10:29:00 GMT

When creating a end-user network application, a number of problems arise such as, for instance, connectivity through firewalls and/or routers. Luckily, there is a number of standards and/or Windows API that deal with these problems, and the only thing we have to do to ensure a state-of-art support of networking technologies is to implement standards or stubs for API.

For instance, in order to make a network-aware application available through an IGD (Internet Gateway Device), The UPnP forum defines a standard for configuring IGD using UPnP: this is called NAT Traversal (where NAT stands for Network Address Translation). Microsoft exposes an API that implement NAT Traversal. The scope of this post is to use it in C#.

The NAT Traversal API is a COM Type Library. The first step is to add a stub for this component:

First, add a reference to the CustomMarshalers assembly (in the Solution Explorer, right-click on the project's References node, Add References..., .NET tab),
Then, create a file containing the following COM Interop code:

Code Copy HideScrollFull

using System.Collections;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.CustomMarshalers;

namespace NatTraversal.Interop {
[ComImport, Guid("624BD588-9060-4109-B0B0-1ADBBCAC32DF"), TypeLibType(4160)]
internal interface INATEventManager {
[DispId(1)]
object ExternalIPAddressCallback { [param: In, MarshalAs(UnmanagedType.IUnknown)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(1)] set; }
[DispId(2)]
object NumberOfEntriesCallback { [param: In, MarshalAs(UnmanagedType.IUnknown)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(2)] set; }
}

[ComImport, TypeLibType(4160), Guid("6F10711F-729B-41E5-93B8-F21D0F818DF1")]
internal interface IStaticPortMapping {
[DispId(1)]
string ExternalIPAddress { [return: MarshalAs(UnmanagedType.BStr)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(1)] get; }
[DispId(2)]
int ExternalPort { [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(2)] get; }
[DispId(3)]
int InternalPort { [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(3)] get; }
[DispId(4)]
string Protocol { [return: MarshalAs(UnmanagedType.BStr)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(4)] get; }
[DispId(5)]
string InternalClient { [return: MarshalAs(UnmanagedType.BStr)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(5)] get; }
[DispId(6)]
bool Enabled { [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(6)] get; }
[DispId(7)]
string Description { [return: MarshalAs(UnmanagedType.BStr)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(7)] get; }
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(8)]
void EditInternalClient([In, MarshalAs(UnmanagedType.BStr)] string bstrInternalClient);
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(9)]
void Enable([In] bool vb);
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(10)]
void EditDescription([In, MarshalAs(UnmanagedType.BStr)] string bstrDescription);
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(11)]
void EditInternalPort([In] int lInternalPort);
}

[ComImport, Guid("CD1F3E77-66D6-4664-82C7-36DBB641D0F1"), TypeLibType(4160)]
internal interface IStaticPortMappingCollection /*: IEnumerable*/ {
[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(EnumeratorToEnumVariantMarshaler))]
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(-4), TypeLibFunc(0x41)]
IEnumerator GetEnumerator();
[DispId(0)]
IStaticPortMapping this[int lExternalPort, string bstrProtocol] { [return: MarshalAs(UnmanagedType.Interface)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(0)] get; }
[DispId(1)]
int Count { [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(1)] get; }
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(2)]
void Remove([In] int lExternalPort, [In, MarshalAs(UnmanagedType.BStr)] string bstrProtocol);
[return: MarshalAs(UnmanagedType.Interface)]
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(3)]
IStaticPortMapping Add([In] int lExternalPort, [In, MarshalAs(UnmanagedType.BStr)] string bstrProtocol, [In] int lInternalPort, [In, MarshalAs(UnmanagedType.BStr)] string bstrInternalClient, [In] bool bEnabled, [In, MarshalAs(UnmanagedType.BStr)] string bstrDescription);
}

[ComImport, Guid("B171C812-CC76-485A-94D8-B6B3A2794E99"), TypeLibType(4160)]
internal interface IUPnPNAT {
[DispId(1)]
IStaticPortMappingCollection StaticPortMappingCollection { [return: MarshalAs(UnmanagedType.Interface)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(1)] get; }
[DispId(2)]
object /*IDynamicPortMappingCollection*/ DynamicPortMappingCollection { [return: MarshalAs(UnmanagedType.Interface)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(2)] get; }
[DispId(3)]
INATEventManager NATEventManager { [return: MarshalAs(UnmanagedType.Interface)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(3)] get; }
}

[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("9C416740-A34E-446F-BA06-ABD04C3149AE")]
internal interface INATExternalIPAddressCallback {
void NewExternalIPAddress([MarshalAs(UnmanagedType.BStr)]string newExternalIPAddress);
}

[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("C83A0A74-91EE-41B6-B67A-67E0F00BBD78")]
internal interface INATNumberOfEntriesCallback {
void NewNumberOfEntries(int newNumberOfEntries);
}

[ComImport, Guid("B171C812-CC76-485A-94D8-B6B3A2794E99"), CoClass(typeof(UPnPNATCreator))]
internal interface UPnPNAT : IUPnPNAT {}

[ComImport, TypeLibType(2), Guid("AE1E00AA-3FD5-403C-8A27-2BBDC30CD0E1"), ClassInterface(ClassInterfaceType.None)]
internal class UPnPNATCreator {}
}

. . .

According to the documentation, the IUPnPNAT.DynamicPortMappingCollection property is not implemented: I removed the definition of IDynamicPortMappingCollection and replaced it with a simple object in the interface definition.

Now we can work with the API. First, create a simple object that will represents the UPnP-compatible IGD, if present. The object initializer will create the COM object and check for availability of the StaticPortMappingCollection property:

Code Copy HideScrollFull

#region References

using System;
using System.Collections;
using System.Net;
using NatTraversal.Interop;

#endregion

namespace NatTraversal {
public class UPnPNat {
#region Fields
private UPnPNAT uPnpNat;
#endregion

#region Instance Management

public UPnPNat() {
try {
UPnPNAT nat = new UPnPNAT();
if (nat.NATEventManager != null && nat.StaticPortMappingCollection != null)
uPnpNat = nat;
}
catch { }

// No configurable UPNP NAT is available.
if (uPnpNat == null)
throw new NotSupportedException();
}

#endregion
}
}

In order to enumerate port mappings, we have to represent each mapping by a single object instead of a set of variables : the PortMappingInfo class is a helper that contains all the settings of a port mapping :

Code Copy HideScrollFull

. . .

Now, we can enumerate the existing port mappings. Since the StaticPortMappingCollection is an enumerator we should use the foreach statement, but unfortunately it does not work and throw an exception. That's why we enumerate the items using IEnumerator.MoveNext:

Code Copy HideScrollFull

public PortMappingInfo[] PortMappings {
get {
// Builds port mappings list
ArrayList portMappings = new ArrayList();

// Enumerates the ports without using the foreach statement (causes the interop to fail).
int count = uPnpNat.StaticPortMappingCollection.Count;
IEnumerator enumerator = uPnpNat.StaticPortMappingCollection.GetEnumerator();
enumerator.Reset();

for (int i = 0; i <= count; i++) {
IStaticPortMapping mapping = null;
try {
if (enumerator.MoveNext())
mapping = (IStaticPortMapping)enumerator.Current;
}
catch { }

if (mapping != null) {
portMappings.Add(new PortMappingInfo(
mapping.Description,
mapping.Protocol.ToUpper(),
mapping.InternalClient,
mapping.InternalPort,
IPAddress.Parse(mapping.ExternalIPAddress),
mapping.ExternalPort,
mapping.Enabled));
}
}

// Now copies the ArrayList to an array of PortMappingInfo.
PortMappingInfo[] portMappingInfos = new PortMappingInfo[portMappings.Count];
portMappings.CopyTo(portMappingInfos);

return portMappingInfos;
}
}

Invoking this property is done this way:

Code Copy

UPnPNat nat = new UPnPNat();

foreach (PortMappingInfo info in nat.PortMappings)
Console.WriteLine("{0} : {1} -> {2}:{3} ({4})", info.Description, info.ExternalPort, info.InternalHostName, info.InternalPort, info.Protocol); 

In order to use UPnP to configure the IGD, we have to implement stubs for adding and removing port mappings :

Code Copy

public void AddPortMapping(PortMappingInfo portMapping) {
uPnpNat.StaticPortMappingCollection.Add(portMapping.ExternalPort, portMapping.Protocol, portMapping.InternalPort, portMapping.InternalHostName, portMapping.Enabled, portMapping.Description);
}

public void RemovePortMapping(PortMappingInfo portMapping) {
uPnpNat.StaticPortMappingCollection.Remove(portMapping.ExternalPort, portMapping.Protocol);
} 

Now, last but not least, you have to configure both your IGD and Windows box to use UPnP !

Exif Properties in .Net - Part 2 : creating new properties

Buz & Skup — Sun, 27 Mar 2005 20:04:00 GMT

When you manage Exif properties, you commonly have two basic tasks to handle : reading Exif properties (which is quite simple), and writing Exif properties, which is, in C#, as simple as:

Code Copy

PropertyItem 
    property = ...;

    Image image = ...;

    image.SetPropertyItem(property);

In the code above, the Image object may have been created from a file, a stream, an existing image, or just from scratch...
The PropertyItem may have been retrieved from an image, or... nothing : the System.Drawing.Imaging.PropertyItem class do not have a public constructor!

In this post, I am describing a workaround that enable to create new PropertyItem objects.

The method is, in fact, quite simple. It consists in having a small Jpeg image with Exif information embedded in you application, and loading PropertyItem from it when necessary.

First, you have to add your Jpeg file (let's call it "property.jpg") to your project, and mark it as an embedded resource.

In the Solution Explorer, select the project icon,
In the Project menu, click the Add an existing item menu,
In the dialog box, choose a valid Jpeg file and click Open; the file does appear in the Solution Explorer,
In the Solution Explorer, select the Jpeg file ,
In the Properties view, set the "Build Action" property to "Embedded Resource".

The second step is to add a reference on the System.Drawing assembly to the project, if not present, and to add the following lines at the top of the source file:

Code Copy

using
    System;

    using System.Drawing;

    using System.Drawing.Imaging;

    using System.IO;

    using System.Reflection;

Now when have to load the image and return the first property item it contains :

Code Copy

///
     <summary>

     /// Creates a new property item.
/// </summary>

     /// <returns>A 
     new instance of the <see 
     cref="PropertyItem"/> class.</returns>
public static PropertyItem 
    CreatePropertyImage()

    {// Gets the current assembly, 
      retrieves the stream for the resource and loads the associated image.

     Assembly currentAssembly = Assembly.GetExecutingAssembly();
using(Stream propertyStream = 
     currentAssembly.GetManifestResourceStream(currentAssembly.GetName().Name + 
     "." + "property.jpg"))
using(Image resourceImage = 
     (Image)Image.FromStream(propertyStream))

     {return resourceImage.PropertyItems[0];

     }

    }
   

The job is almost complete : we can now optimize this code to load the image only once and to return a clean object.

Code Copy HideScrollFull

private
     static Image propertyImage;

private static Image 
    PropertyImage

    {get

     {if (propertyImage==null)propertyImage 
       = LoadPropertyImage();

       
      

      return propertyImage;

     }

    }

private static Image 
    LoadPropertyImage()

    {// Gets the current assembly, 
      retrieves the stream for the resource and loads the associated image.

     Assembly currentAssembly = Assembly.GetExecutingAssembly();
using(Stream propertyStream = 
     currentAssembly.GetManifestResourceStream(currentAssembly.GetName().Name + 
     "." + "property.jpg"))
using(Image resourceImage = 
     (Image)Image.FromStream(propertyStream))

     {// Creates a lightweight (1x1 
       pixel) bitmap with a single, empty exif property item.

      // This bitmap will remain in memory during the entire 
       application runtime.

      Image propertyImage = new Bitmap(1, 1);

      PropertyItem propertyItem = resourceImage.PropertyItems[0];

      propertyItem.Id = 0;

      propertyItem.Type = 0;

      propertyItem.Len = 0;

      propertyItem.Value = new byte[0];

      

      propertyImage.SetPropertyItem(propertyItem);

      

      return propertyImage;

     }

    }

/// <summary>

     /// Creates an empty property item.
/// </summary>

     /// <returns>A 
     new, empty instance of the <see 
     cref="PropertyItem"/> class.</returns>
public static PropertyItem 
    CreatePropertyItem()

    {return PropertyImage.PropertyItems[0];

    }

/// <summary>

     /// Creates a new property item having the given 
     id, type and value.
/// </summary>

     /// <param name="id">The 
     identifier of the property item.</param>

     /// <param name="type">The 
     type of value the property item does contain.</param>

     /// <param name="len">The 
     length of the property value.</param>

     /// <param name="value">The 
     property value.</param>

     /// <returns>A 
     new, initialized, instance of the <see 
     cref="PropertyItem"/> class.</returns>
public static PropertyItem 
    CreatePropertyItem(int id, short
    type, int len, byte[]
     value)

    {PropertyItem property = CreatePropertyItem();

     property.Id = id;

     property.Type = type;

     property.Len = len;

     property.Value = value;

    }

. . .

In the next post, we will convert the raw Exif data buffer (the PropertyItem.Value) into the native type.

Minimizing a window to the System Tray on a Close event

Buz & Skup — Sat, 26 Mar 2005 12:02:00 GMT

A question that .Net programmers does frequently ask is the following : how to minimize a window in the systray when the user clicks the "Close" button ? This post exposes solutions to the various problems this quite simple need implies.

The first step is to prevent the window to close. This can be done either by handling the Closing event or by overriding the OnClosing protected virtual method. For performance and memory consumption reasons, I'd prefer not to use event handlers whenever possible. The code is quite simple since whe only need to cancel the operation, and looks like the following...

Code Copy

///
     <summary>

     /// Occurs when the window is requested to be 
     closed.
/// </summary>

     /// <param name="e">The 
     event arguments</param>
protected override
     void OnClosing(CancelEventArgs e)

    {// The window must only be 
      minimized in tray

     e.Cancel = true;

     MinimizeInTray();

     

     base.OnClosing(e);

    }

... and the MinimizeInTray method must do the following:

Minimize the window,
Hide the window item in the taskbar.

Code Copy

private
     void MinimizeInTray()

    {this.ShowInTaskbar =
      false;

     this.WindowState = FormWindowState.Minimized;

    }

Now, supposing that you have a context menu attached to the NotifyIcon object that represents the systray icon for your application, you can add the following menu items:

An openMenu menu item that restores the window,

Code Copy

private
     void openMenu_Click(object sender, 
    System.EventArgs e)

    {ShowFromTray();

    }

private void ShowFromTray()

    {this.WindowState = 
     FormWindowState.Normal;

     this.ShowInTaskbar = true;

    }

And an exitMenu item that closes the application.

Code Copy

private
     void exitMenu_Click(object sender, 
    System.EventArgs e)

    {Application.Exit();

    }

Note that calling Close() fails because our OnClosing method prevents the window to close...

Now, we should think that our job is completed. But (yes, there's always a but in programming), what happens if the computer is being shutdown ? The answer is quite simple : our OnClosing implementation prevents the window to be closed, which prevents the computer to be shutdown...

To solve this issue, we need some lightweight Interop :

First, override the WndProc virtual method to handle the WM_QUERYENDSESSION message:

Code Copy

private
     const int WM_QUERYENDSESSION = 0x11;
private bool endSessionPending;

     

     protected override void
    WndProc(ref Message m)

    {if (m.Msg == 
     WM_QUERYENDSESSION)endSessionPending =
       true;

     base.WndProc(ref m);

    }

Then, modify the OnClosing method to handle the event in a different way :

Code Copy HideScrollFull

///
     <summary>

     /// Occurs when the window is requested to be 
     closed.
/// </summary>

     /// <param name="e">The 
     event arguments</param>
protected override
     void OnClosing(CancelEventArgs e)

    {if (endSessionPending)

     {// The session is ending.

      e.Cancel = false;

     }
else

     {// The window must only be 
       minimized in tray

      e.Cancel = true;

      MinimizeInTray();

     }

base.OnClosing(e);

    }

And that's all!

The full C# sample code is available below. There's only missing icon resources, but you will correct them by yourself!

Code Copy HideScrollFull

#region
    References

using System;
using System.ComponentModel;
using System.Windows.Forms;
using System.Security.Permissions;

#endregion

     

     namespace MinimizeOnClose

    {/// <summary>
/// Represents the main window 
      of the application.
/// </summary>
public class MinimizeOnClose 
     : System.Windows.Forms.Form

     {#region Interop 
      Constants

private const
       int WM_QUERYENDSESSION = 0x11;

#endregion

       

       #region Fields

private System.Windows.Forms.NotifyIcon 
      notifyIcon;
private System.Windows.Forms.ContextMenu 
      notifyIconMenu;
private System.Windows.Forms.MenuItem openMenu;
private System.Windows.Forms.MenuItem hideMenu;
private System.Windows.Forms.MenuItem exitMenu;
private System.ComponentModel.IContainer 
      components;
private System.Windows.Forms.MenuItem blankMenu;

private bool endSessionPending;

#endregion

       

       #region Instance Management

public MinimizeOnClose()

      {InitializeComponent();

      }

#endregion

       

       #region Protected Overrides

/// <summary>
/// Cleans all the resources.
/// </summary>
protected override
       void Dispose(bool disposing)

      {if (disposing)

       {if (components !=
         null)components.Dispose();

       }
base.Dispose(disposing);

      }

/// <summary>
/// Occurs when the window is 
       requested to be closed.
/// </summary>
/// <param 
       name="e">The event arguments</param>
protected override
       void OnClosing(CancelEventArgs e)

      {if (endSessionPending)

       {// The session is ending

        e.Cancel = false;

       }
else

       {// The window must only be 
         minimized in tray

        e.Cancel = true;

        MinimizeInTray();

       }

base.OnClosing(e);

      }
[SecurityPermission(SecurityAction.LinkDemand, 
       UnmanagedCode=true)]

      protected override void
      WndProc(ref Message m)

      {if (m.Msg == 
       WM_QUERYENDSESSION)endSessionPending =
         true;

       base.WndProc(ref m);

      }
#endregion

      

      #region Private Members

#region Event Handlers

private void openMenu_Click(object
      sender, System.EventArgs e)

      {ShowFromTray();

      }

private void hideMenu_Click(object
      sender, System.EventArgs e)

      {MinimizeInTray();

      }

private void exitMenu_Click(object
      sender, System.EventArgs e)

      {Application.Exit();

      }

#endregion

       

       #region Private Methods

private void MinimizeInTray()

      {this.ShowInTaskbar =
        false;

       this.WindowState = FormWindowState.Minimized;

       

       openMenu.Visible = true;

       hideMenu.Visible = false;

      }

private void ShowFromTray()

      {this.WindowState = 
       FormWindowState.Normal;

       this.ShowInTaskbar = true;

       

       openMenu.Visible = true;

       hideMenu.Visible = false;

      }

#endregion

       

       #region Windows Form Designer generated code

/// <summary>
/// Required method for Designer 
       support - do not modify
/// the contents of this method 
       with the code editor.
/// </summary>
private void InitializeComponent()

      {this.components =
        new System.ComponentModel.Container();

       System.Resources.ResourceManager resources = new System.Resources.ResourceManager(typeof(MinimizeOnClose));
this.notifyIcon = new 
       System.Windows.Forms.NotifyIcon(this.components);
this.notifyIconMenu = new
       System.Windows.Forms.ContextMenu();
this.openMenu = new System.Windows.Forms.MenuItem();
this.hideMenu = new System.Windows.Forms.MenuItem();
this.blankMenu = new System.Windows.Forms.MenuItem();
this.exitMenu = new System.Windows.Forms.MenuItem();
//
// notifyIcon
//
this.notifyIcon.ContextMenu = this.notifyIconMenu;
this.notifyIcon.Icon = 
       ((System.Drawing.Icon)(resources.GetObject("notifyIcon.Icon")));
this.notifyIcon.Text = 
       "MinimizeOnClose";
this.notifyIcon.Visible = true;
//
// notifyIconMenu
//
this.notifyIconMenu.MenuItems.AddRange(new
       System.Windows.Forms.MenuItem[] {this.openMenu,

        this.hideMenu,

        this.blankMenu,

        this.exitMenu});

       //
// openMenu
//
this.openMenu.Index = 0;
this.openMenu.Text = "&Open";
this.openMenu.Visible = false;
this.openMenu.Click += new
       System.EventHandler(this.openMenu_Click);
//
// hideMenu
//
this.hideMenu.Index = 1;
this.hideMenu.Text = "&Hide";
this.hideMenu.Click += new
       System.EventHandler(this.hideMenu_Click);
//
// blankMenu
//
this.blankMenu.Index = 2;
this.blankMenu.Text = "-";
//
// exitMenu
//
this.exitMenu.Index = 3;
this.exitMenu.Text = "E&xit";
this.exitMenu.Click += new
       System.EventHandler(this.exitMenu_Click);
//
// MinimizeOnClose
//
this.AutoScaleBaseSize = new
       System.Drawing.Size(5, 13);
this.ClientSize = new 
       System.Drawing.Size(240, 78);
this.Icon = 
       ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
this.Name = "MinimizeOnClose";
this.Text = "MinimizeOnClose";

      }
#endregion

      
/// <summary>
/// The application entry point.
/// </summary>

      [STAThread]
static void Main()

      {Application.Run(new MinimizeOnClose());

      }

#endregion

     }

    }

. . .

Have a nice week-end, and do not overindulge in Easter eggs too much!

COM Interop without additional assemblies

Buz & Skup — Thu, 24 Mar 2005 00:08:00 GMT

In this post, I'm about to deal with the use of COM components inside a .Net project.

Access to Windows or third-party API is commonly made through COM, and when you're working on a .Net project, this is typically done by adding a reference to the project (Project, Add Reference... menu, COM tab). Visual Studio then creates an assembly that contains the stub of interop code for the COM Type Library.

Unfortunatelly, each assembly corresponds to a file on the disk, and each file is at least 64KBytes large.

In the PixVillage project, the installation package need to be as small as possible in order to reduce download time and bandwidth, so we looked after a way to reduce the number and size of COM Interop assemblies.

A (quite) simple way to achieve both these goals is to use Lutz Roeder's Reflector to generate the C# code of the COM stub directly from the assembly IL.

To do so (xxx represents the name of the Type Library) :

Start Reflector,
Find the COM Interop assembly (refer to the properties of the reference : the file name should be "Interop.xxx.dll"),
Open the COM Interop assembly in Reflector,
Expand both the assembly (Interop.xxx) and file (xxx.dll) nodes in the treeview,
Select the node of the Type Library base namespace in the tree (the node called xxx with a { } icon),
Press the Space bar to generate C# code for the namespace,
Click in the right pane, select all code (Ctrl+A) and copy it to the clipboard (Ctrl+C),
Paste the code in a new C# (.cs) file in Visual Studio.

Now, there might be missing references : you must add them (with the using keyword) at the very beginning of the new file. For instance, you may have to add references to the following namespace : System, System.Collections, System.Runtime.InteropServices, System.Reflection, System.Runtime.CompilerServices...

You may also have duplicate member definitions because inheriting interfaces define the same members as their parent : remove them.

The last thing to do is to clean the content of the classes (which are different from interfaces) contained in the namespace. When rendered by Reflector, a class implements one or more interfaces and contains a number of properties / methods with no code, which do not compile. To make your code compile, remove all of its base interfaces and all of its content to make it empty.

Now you might have in your code :

A number of enums and interfaces that represents the interfaces and constant values exposed by the Class Library,
One or more interfaces having a CoClass attribute, corresponding to the components exposed by the Class Library
One or mode classes used by the framework to create the instances of the exposed components.

For instance, if you are importing the MSN Messenger API, you may have a IMessenger interface, a Messenger component and a MessengerClass class. In order to access the API, you will have to type IMessenger msn = new Messenger();

Exif Properties in .Net - Part 1 : (fast) loading

Buz & Skup — Thu, 17 Mar 2005 11:51:00 GMT

In .Net, handling a picture's Exif properties seems, at first sight, to be a very simple job.

Since System.Drawing is only a wrapper around GDI+, loading Exif information from an image file is as simple as the following :

Code Copy

public static PropertyItem[] GetExifProperties(string fileName) {
using(Image image = Image.FromFile(fileName))
return image.PropertyItems;
}

Unfortunately, this method requires to load - and validate - all image data in order to access the Exif properties. For instance, if you want to retrieve the thumbnail contained in the Exif properties, you first have to load and uncompress the entire image file.

This problem has been workarounded in the .Net Framework 1.1 Service Pack 1, and now you can process as follow :

Code Copy

public static PropertyItem[] GetExifProperties(string fileName) {
using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
using (Image image = Image.FromStream(stream,
/* useEmbeddedColorManagement = */ true,
/* validateImageData = */ false))

return image.PropertyItems;
}

However, since there is only a small share of PixVillage users that have the .Net Framework 1.1 Service Pack 1 installed, I eventually have implemented a custom ExifLoader helper class that use Interop to load Exif properties.

The first step is to load the image using the GDI+ Flat API and get the Exif properties raw data :

Code Copy HideScrollFull

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;

/// <summary>
/// Contains helper methods for loading Exif properties.
/// </summary>
public sealed class ExifLoader {
private ExifLoader() {}

/// <summary>
/// Retrieves Exif properties from a file.
/// </summary>
/// <param name="fileName">The name of the Exif image file.</param>
/// <returns>An array of <see cref="PropertyItem"/> objects containing the Exif properties.</returns>
public static PropertyItem[] GetExifProperties(string fileName) {
// Loads the image file using the GDI+ Flat API
IntPtr imageHandle = IntPtr.Zero;
if (GdipLoadImageFromFile(fileName, out imageHandle)!=0)
throw new InvalidOperationException();
int count;
int totalSize;
IntPtr data = IntPtr.Zero;

try {
// Retrieves the number of properties the image contains
if (GdipGetPropertyCount(imageHandle, out count)!=0)
throw new InvalidOperationException();
// Gets the total size, in bytes, of the properties
if (GdipGetPropertySize(imageHandle, out totalSize, ref count)!=0)
throw new InvalidOperationException();
// There is no available properties...
if (count == 0 || totalSize == 0)
return new PropertyItem[0];
// Loads all properties into memory.
data = Marshal.AllocHGlobal(totalSize);
if (GdipGetAllPropertyItems(imageHandle, totalSize, count, data)!=0)
throw new InvalidOperationException();
// Convert the properties buffer into an array of PropertyItem objects.
return ExifPropertyItem.ConvertFromMemory(data, count);
}
finally {
if (data != IntPtr.Zero)
Marshal.FreeHGlobal(data);
// Releases the GDI+ image.
GdipDisposeImage(imageHandle);
}
}

ExifPropertyItem Helper Class

// GDI+ Interop
[DllImport("gdiplus.dll", CharSet=CharSet.Unicode, ExactSpelling=true)]
private static extern int GdipLoadImageFromFile(string filename, out IntPtr image);

[DllImport("gdiplus.dll", CharSet=CharSet.Unicode, ExactSpelling=true)]
private static extern int GdipDisposeImage(IntPtr image);

[DllImport("gdiplus.dll", CharSet=CharSet.Unicode, ExactSpelling=true)]
private static extern int GdipGetPropertyCount(IntPtr image, out int count);

[DllImport("gdiplus.dll", CharSet=CharSet.Unicode, ExactSpelling=true)]
private static extern int GdipGetPropertySize(IntPtr image, out int totalSize, ref int count);

[DllImport("gdiplus.dll", CharSet=CharSet.Unicode, ExactSpelling=true)]
private static extern int GdipGetAllPropertyItems(IntPtr image, int totalSize, int count, IntPtr buffer);
}

Then, we have to decode the buffer filled by GdipGetAllPropertyItems. This is done using a private inner class, as follow :

Code Copy HideScrollFull

#region ExifPropertyItem Helper Class

/// <summary>
/// Represents an helper class for marshaling Exif property items.
/// </summary>
[StructLayout(LayoutKind.Sequential)]
private class ExifPropertyItem {

// Public members used for marshaling.
public int id = 0;
public int len = 0;
public short type = 0;
public IntPtr value = IntPtr.Zero;

/// <summary>
/// Initializes a new instance of the <see cref="ExifPropertyItem"/> class.
/// </summary>
/// <remarks>Used only by the <see cref="Marshal.PtrToStructure"/> method.</remarks>
public ExifPropertyItem() {}

/// <summary>
/// Gets the value of the property.
/// </summary>
public byte[] Value {
get {
byte[] buffer = new byte[len];
if (len > 0)
Marshal.Copy(value, buffer, 0, len);
return buffer;
}
}

/// <summary>
/// Converts a buffer into an array of PropertyItem objects.
/// </summary>
/// <param name="propertyData">The properties data buffer.</param>
/// <param name="count">The number of properties in the buffer.</param>
/// <returns>An array of <see cref="PropertyItem"/> objects.</returns>
public static PropertyItem[] ConvertFromMemory(IntPtr propertyData, int count) {
PropertyItem[] itemArray = new PropertyItem[count];
for (int i = 0; i < count; i++) {
// Marshals the buffer into a ExifPropertyItem structure.
ExifPropertyItem item = (ExifPropertyItem)Marshal.PtrToStructure(propertyData, typeof(ExifPropertyItem));

// Creates the PropertyItem from the data.
itemArray[i] = Create(item.type,  item.id, item.len, item.Value);

// Seek to next property.
propertyData = (IntPtr)(((long)propertyData) + Marshal.SizeOf(typeof(ExifPropertyItem)));
}

return itemArray;
}

/// <summary>
/// Creates a PropertyItem from its components.
/// </summary>
/// <param name="type">The property type.</param>
/// <param name="tag">The property tag.</param>
/// <param name="len">The length of the property.</param>
/// <param name="value">The property value.</param>
/// <returns></returns>
private static PropertyItem Create(short type, int tag, int len, byte[] value){
PropertyItem item;

// Loads a PropertyItem from a Jpeg image stored in the assembly as a resource.
Assembly assembly = Assembly.GetExecutingAssembly();
using(Stream emptyBitmapStream = assembly.GetManifestResourceStream("ExifLoader.empty.jpg"))
using(Image empty = Image.FromStream(emptyBitmapStream))
item = empty.PropertyItems[0];
// Copies the data to the property item.
item.Type = type;
item.Len = len;
item.Id = tag;
item.Value = new byte[value.Length];
value.CopyTo(item.Value, 0);

return item;
}
}

#endregion

Note that in the class above, we load a jpeg file from resources into memory. This file is named "empty.jpg" but the resource is referenced as "ExifLoader.empty.jpg" since "ExifLoader" is the name of the assembly.

Since the PropertyItem class does not provide a public initializer to create a property "from scratch", we have to use an existing property item.

Soon blogging...

Buz & Skup — Fri, 04 Mar 2005 00:17:00 GMT

Welcome on the PixVillage DevTeam blog !

PixVillage is a photo sharing software that use both a web service and a P2P protocol to transmit data between users, and has been (and is still being) developed in C# using the .Net Framework.

During the development process, we have to solve design and implementation problems, find workarounds for OS or framework bugs, etc. That's we'll deal with in this blog !

In the next weeks, I will work on the development of an EXIF handling framework. I guess that will be my first series of posts on this blog.

Soon blogging...

For the PixVillage DevTeam,
Buz