Index: trunk/sources/HeuristicLab 3.3.sln
===================================================================
--- trunk/sources/HeuristicLab 3.3.sln	(revision 2571)
+++ trunk/sources/HeuristicLab 3.3.sln	(revision 2572)
@@ -106,4 +106,6 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Core.Views-3.3", "HeuristicLab.Core.Views\3.3\HeuristicLab.Core.Views-3.3.csproj", "{E226881D-315F-423D-B419-A766FE0D8685}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Collections-3.3", "HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj", "{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}"
 EndProject
 Global
@@ -495,4 +497,12 @@
 		{E226881D-315F-423D-B419-A766FE0D8685}.Release|x64.ActiveCfg = Release|Any CPU
 		{E226881D-315F-423D-B419-A766FE0D8685}.Release|x86.ActiveCfg = Release|Any CPU
+		{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}.Release|Any CPU.Build.0 = Release|Any CPU
+		{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}.Release|x64.ActiveCfg = Release|Any CPU
+		{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
Index: trunk/sources/HeuristicLab 3.3/CopyAssemblies.cmd
===================================================================
--- trunk/sources/HeuristicLab 3.3/CopyAssemblies.cmd	(revision 2571)
+++ trunk/sources/HeuristicLab 3.3/CopyAssemblies.cmd	(revision 2572)
@@ -9,4 +9,5 @@
 copy "%SolutionDir%\HeuristicLab.Charting\3.3\%Outdir%\HeuristicLab.Charting-3.3.dll" .\plugins
 copy "%SolutionDir%\HeuristicLab.Charting.Data\3.3\%Outdir%\HeuristicLab.Charting.Data-3.3.dll" .\plugins
+copy "%SolutionDir%\HeuristicLab.Collections\3.3\%Outdir%\HeuristicLab.Collections-3.3.dll" .\plugins 
 copy "%SolutionDir%\HeuristicLab.Common\3.2\%Outdir%\HeuristicLab.Common-3.2.dll" .\plugins 
 copy "%SolutionDir%\HeuristicLab.Common.Resources\3.2\%Outdir%\HeuristicLab.Common.Resources-3.2.dll" .\plugins
Index: trunk/sources/HeuristicLab.Collections/3.3/CollectionChangedEventsBase.cs
===================================================================
--- trunk/sources/HeuristicLab.Collections/3.3/CollectionChangedEventsBase.cs	(revision 2572)
+++ trunk/sources/HeuristicLab.Collections/3.3/CollectionChangedEventsBase.cs	(revision 2572)
@@ -0,0 +1,61 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Runtime.Serialization;
+
+namespace HeuristicLab.Collections {
+  [Serializable]
+  [EmptyStorableClass]
+  public abstract class CollectionChangedEventsBase<T> : ICollectionChangedEvents<T> {
+    [field: NonSerialized]
+    public event CollectionItemsChangedEventHandler<T> ItemsAdded;
+    protected virtual void OnItemsAdded(IEnumerable<T> items) {
+      if (ItemsAdded != null)
+        ItemsAdded(this, new CollectionItemsChangedEventArgs<T>(items));
+    }
+
+    [field: NonSerialized]
+    public event CollectionItemsChangedEventHandler<T> ItemsRemoved;
+    protected virtual void OnItemsRemoved(IEnumerable<T> items) {
+      if (ItemsRemoved != null)
+        ItemsRemoved(this, new CollectionItemsChangedEventArgs<T>(items));
+    }
+
+    [field: NonSerialized]
+    public event CollectionItemsChangedEventHandler<T> ItemsReplaced;
+    protected virtual void OnItemsReplaced(IEnumerable<T> items, IEnumerable<T> oldItems) {
+      if (ItemsReplaced != null)
+        ItemsReplaced(this, new CollectionItemsChangedEventArgs<T>(items, oldItems));
+    }
+
+    [field: NonSerialized]
+    public event CollectionItemsChangedEventHandler<T> CollectionReset;
+    protected virtual void OnCollectionReset(IEnumerable<T> items, IEnumerable<T> oldItems) {
+      if (CollectionReset != null)
+        CollectionReset(this, new CollectionItemsChangedEventArgs<T>(items, oldItems));
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Collections/3.3/CollectionItemsChangedEventArgs.cs
===================================================================
--- trunk/sources/HeuristicLab.Collections/3.3/CollectionItemsChangedEventArgs.cs	(revision 2572)
+++ trunk/sources/HeuristicLab.Collections/3.3/CollectionItemsChangedEventArgs.cs	(revision 2572)
@@ -0,0 +1,48 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.Specialized;
+
+namespace HeuristicLab.Collections {
+  public class CollectionItemsChangedEventArgs<T> : EventArgs {
+    private IEnumerable<T> items;
+    public IEnumerable<T> Items {
+      get { return items; }
+    }
+    private IEnumerable<T> oldItems;
+    public IEnumerable<T> OldItems {
+      get { return oldItems; }
+    }
+
+    public CollectionItemsChangedEventArgs(IEnumerable<T> items) {
+      this.items = items;
+      this.oldItems = null;
+    }
+    public CollectionItemsChangedEventArgs(IEnumerable<T> items, IEnumerable<T> oldItems) {
+      this.items = items;
+      this.oldItems = oldItems;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Collections/3.3/CollectionItemsChangedEventHandler.cs
===================================================================
--- trunk/sources/HeuristicLab.Collections/3.3/CollectionItemsChangedEventHandler.cs	(revision 2572)
+++ trunk/sources/HeuristicLab.Collections/3.3/CollectionItemsChangedEventHandler.cs	(revision 2572)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.Specialized;
+
+namespace HeuristicLab.Collections {
+  public delegate void CollectionItemsChangedEventHandler<T>(object sender, CollectionItemsChangedEventArgs<T> e);
+}
Index: trunk/sources/HeuristicLab.Collections/3.3/HeuristicLab.Collections-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Collections/3.3/HeuristicLab.Collections-3.3.csproj	(revision 2572)
+++ trunk/sources/HeuristicLab.Collections/3.3/HeuristicLab.Collections-3.3.csproj	(revision 2572)
@@ -0,0 +1,94 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Collections</RootNamespace>
+    <AssemblyName>HeuristicLab.Collections-3.3</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <DocumentationFile>bin\Release\HeuristicLab.Collections-3.3.XML</DocumentationFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Xml.Linq">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data.DataSetExtensions">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="IndexedCollectionChangedEventsBase.cs" />
+    <Compile Include="ObservableCollection.cs" />
+    <Compile Include="IIndexedCollectionChangedEvents.cs" />
+    <Compile Include="IndexedItem.cs" />
+    <Compile Include="CollectionChangedEventsBase.cs" />
+    <Compile Include="ObservableList.cs" />
+    <Compile Include="CollectionItemsChangedEventArgs.cs" />
+    <Compile Include="CollectionItemsChangedEventHandler.cs" />
+    <Compile Include="ICollectionChangedEvents.cs" />
+    <Compile Include="HeuristicLabCollectionsPlugin.cs" />
+    <Compile Include="ObservableDictionary.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+    <None Include="Properties\AssemblyInfo.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
+      <Project>{102BC7D3-0EF9-439C-8F6D-96FF0FDB8E1B}</Project>
+      <Name>HeuristicLab.Persistence-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\HeuristicLab.PluginInfrastructure.csproj">
+      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
+      <Name>HeuristicLab.PluginInfrastructure</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd</PreBuildEvent>
+  </PropertyGroup>
+</Project>
Index: trunk/sources/HeuristicLab.Collections/3.3/HeuristicLabCollectionsPlugin.cs
===================================================================
--- trunk/sources/HeuristicLab.Collections/3.3/HeuristicLabCollectionsPlugin.cs	(revision 2572)
+++ trunk/sources/HeuristicLab.Collections/3.3/HeuristicLabCollectionsPlugin.cs	(revision 2572)
@@ -0,0 +1,36 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Collections {
+  /// <summary>
+  /// Plugin class for HeuristicLab.Collections plugin.
+  /// </summary>
+  [ClassInfo(Name = "HeuristicLab.Collections-3.2")]
+  [PluginFile(Filename = "HeuristicLab.Collections-3.3.dll", Filetype = PluginFileType.Assembly)]
+  [Dependency(Dependency = "HeuristicLab.Persistence-3.3")]
+  public class HeuristicLabCollectionsPlugin : PluginBase {
+  }
+}
Index: trunk/sources/HeuristicLab.Collections/3.3/ICollectionChangedEvents.cs
===================================================================
--- trunk/sources/HeuristicLab.Collections/3.3/ICollectionChangedEvents.cs	(revision 2572)
+++ trunk/sources/HeuristicLab.Collections/3.3/ICollectionChangedEvents.cs	(revision 2572)
@@ -0,0 +1,34 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace HeuristicLab.Collections {
+  public interface ICollectionChangedEvents<T> {
+    event CollectionItemsChangedEventHandler<T> ItemsAdded;
+    event CollectionItemsChangedEventHandler<T> ItemsRemoved;
+    event CollectionItemsChangedEventHandler<T> ItemsReplaced;
+    event CollectionItemsChangedEventHandler<T> CollectionReset;
+  }
+}
Index: trunk/sources/HeuristicLab.Collections/3.3/IIndexedCollectionChangedEvents.cs
===================================================================
--- trunk/sources/HeuristicLab.Collections/3.3/IIndexedCollectionChangedEvents.cs	(revision 2572)
+++ trunk/sources/HeuristicLab.Collections/3.3/IIndexedCollectionChangedEvents.cs	(revision 2572)
@@ -0,0 +1,31 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace HeuristicLab.Collections {
+  public interface IIndexedCollectionChangedEvents<T> : ICollectionChangedEvents<T> {
+    event CollectionItemsChangedEventHandler<T> ItemsMoved;
+  }
+}
Index: trunk/sources/HeuristicLab.Collections/3.3/IndexedCollectionChangedEventsBase.cs
===================================================================
--- trunk/sources/HeuristicLab.Collections/3.3/IndexedCollectionChangedEventsBase.cs	(revision 2572)
+++ trunk/sources/HeuristicLab.Collections/3.3/IndexedCollectionChangedEventsBase.cs	(revision 2572)
@@ -0,0 +1,40 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Runtime.Serialization;
+
+namespace HeuristicLab.Collections {
+  [Serializable]
+  [EmptyStorableClass]
+  public abstract class IndexedCollectionChangedEventsBase<T> : CollectionChangedEventsBase<T>, IIndexedCollectionChangedEvents<T> {
+    [field: NonSerialized]
+    public event CollectionItemsChangedEventHandler<T> ItemsMoved;
+    protected virtual void OnItemsMoved(IEnumerable<T> items, IEnumerable<T> oldItems) {
+      if (ItemsMoved != null)
+        ItemsMoved(this, new CollectionItemsChangedEventArgs<T>(items, oldItems));
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Collections/3.3/IndexedItem.cs
===================================================================
--- trunk/sources/HeuristicLab.Collections/3.3/IndexedItem.cs	(revision 2572)
+++ trunk/sources/HeuristicLab.Collections/3.3/IndexedItem.cs	(revision 2572)
@@ -0,0 +1,50 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace HeuristicLab.Collections {
+  [Serializable]
+  public struct IndexedItem<T> {
+    private int index;
+    public int Index {
+      get { return index; }
+    }
+    private T value;
+    public T Value {
+      get { return value; }
+    }
+
+    public IndexedItem(int index, T value) {
+      this.index = index;
+      this.value = value;
+    }
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      sb.Append("[").Append(index).Append(", ").Append(value != null ? value.ToString() : "null").Append("]");
+      return sb.ToString();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Collections/3.3/ObservableCollection.cs
===================================================================
--- trunk/sources/HeuristicLab.Collections/3.3/ObservableCollection.cs	(revision 2572)
+++ trunk/sources/HeuristicLab.Collections/3.3/ObservableCollection.cs	(revision 2572)
@@ -0,0 +1,160 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Collections {
+  [Serializable]
+  public class ObservableCollection<T> : CollectionChangedEventsBase<T>, ICollection<T> {
+    [Storable]
+    private List<T> list;
+
+    #region Properties
+    public int Capacity {
+      get { return list.Capacity; }
+      set { list.Capacity = value; }
+    }
+    public int Count {
+      get { return list.Count; }
+    }
+    public bool IsReadOnly {
+      get { return ((ICollection<T>)list).IsReadOnly; }
+    }
+    #endregion
+
+    #region Constructors
+    public ObservableCollection() {
+      list = new List<T>();
+    }
+    public ObservableCollection(int capacity) {
+      list = new List<T>(capacity);
+    }
+    public ObservableCollection(IEnumerable<T> collection) {
+      list = new List<T>(collection);
+    }
+    #endregion
+
+    #region Access
+    public bool Contains(T item) {
+      return list.Contains(item);
+    }
+
+    public bool Exists(Predicate<T> match) {
+      return list.Exists(match);
+    }
+
+    public T Find(Predicate<T> match) {
+      return list.Find(match);
+    }
+    public ICollection<T> FindAll(Predicate<T> match) {
+      return list.FindAll(match);
+    }
+    public T FindLast(Predicate<T> match) {
+      return list.FindLast(match);
+    }
+    #endregion
+
+    #region Manipulation
+    public void Add(T item) {
+      list.Add(item);
+      OnItemsAdded(new T[] { item });
+    }
+    public void AddRange(IEnumerable<T> collection) {
+      list.AddRange(collection);
+      OnItemsAdded(collection);
+    }
+
+    public bool Remove(T item) {
+      if (list.Remove(item)) {
+        OnItemsRemoved(new T[] { item });
+        return true;
+      }
+      return false;
+    }
+    public void RemoveRange(IEnumerable<T> collection) {
+      List<T> items = new List<T>();
+      foreach (T item in collection) {
+        if (list.Remove(item))
+          items.Add(item);
+      }
+      if (items.Count > 0)
+        OnItemsRemoved(items);
+    }
+    public int RemoveAll(Predicate<T> match) {
+      List<T> items = list.FindAll(match);
+      int result = list.RemoveAll(match);
+      OnItemsRemoved(items);
+      return result;
+    }
+
+    public void Clear() {
+      T[] items = list.ToArray();
+      list.Clear();
+      OnCollectionReset(new T[0], items);
+    }
+    #endregion
+
+    #region Conversion
+    public ReadOnlyCollection<T> AsReadOnly() {
+      return list.AsReadOnly();
+    }
+    public T[] ToArray() {
+      return list.ToArray();
+    }
+    public void CopyTo(T[] array, int arrayIndex) {
+      list.CopyTo(array, arrayIndex);
+    }
+    public ICollection<TOutput> ConvertAll<TOutput>(Converter<T, TOutput> converter) {
+      return list.ConvertAll<TOutput>(converter);
+    }
+    #endregion
+
+    #region Processing
+    public void ForEach(Action<T> action) {
+      list.ForEach(action);
+    }
+    public bool TrueForAll(Predicate<T> match) {
+      return list.TrueForAll(match);
+    }
+    #endregion
+
+    #region Enumeration
+    public IEnumerator<T> GetEnumerator() {
+      return ((IEnumerable<T>)list).GetEnumerator();
+    }
+    IEnumerator IEnumerable.GetEnumerator() {
+      return ((IEnumerable)list).GetEnumerator();
+    }
+    #endregion
+
+    #region Helpers
+    public void TrimExcess() {
+      list.TrimExcess();
+    }
+    #endregion
+  }
+}
Index: trunk/sources/HeuristicLab.Collections/3.3/ObservableDictionary.cs
===================================================================
--- trunk/sources/HeuristicLab.Collections/3.3/ObservableDictionary.cs	(revision 2572)
+++ trunk/sources/HeuristicLab.Collections/3.3/ObservableDictionary.cs	(revision 2572)
@@ -0,0 +1,153 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Runtime.Serialization;
+
+namespace HeuristicLab.Collections {
+  [Serializable]
+  public class ObservableDictionary<TKey, TValue> : CollectionChangedEventsBase<KeyValuePair<TKey, TValue>>, IDictionary<TKey, TValue> {
+    [Storable]
+    private Dictionary<TKey, TValue> dict;
+
+    #region Properties
+    public ICollection<TKey> Keys {
+      get { return dict.Keys; }
+    }
+    public ICollection<TValue> Values {
+      get { return dict.Values; }
+    }
+    public int Count {
+      get { return dict.Count; }
+    }
+    public IEqualityComparer<TKey> Comparer {
+      get { return dict.Comparer; }
+    }
+    bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly {
+      get { return ((ICollection<KeyValuePair<TKey, TValue>>)dict).IsReadOnly; }
+    }
+
+    public TValue this[TKey key] {
+      get {
+        return dict[key];
+      }
+      set {
+        KeyValuePair<TKey, TValue> item = new KeyValuePair<TKey, TValue>(key, dict[key]);
+        dict[key] = value;
+        OnItemsReplaced(new KeyValuePair<TKey, TValue>[] { new KeyValuePair<TKey, TValue>(key, value) }, new KeyValuePair<TKey, TValue>[] { item });
+      }
+    }
+    #endregion
+
+    #region Constructors
+    public ObservableDictionary() {
+      dict = new Dictionary<TKey, TValue>();
+    }
+    public ObservableDictionary(int capacity) {
+      dict = new Dictionary<TKey, TValue>(capacity);
+    }
+    public ObservableDictionary(IEqualityComparer<TKey> comparer) {
+      dict = new Dictionary<TKey, TValue>(comparer);
+    }
+    public ObservableDictionary(IDictionary<TKey, TValue> dictionary) {
+      dict = new Dictionary<TKey, TValue>(dictionary);
+    }
+    public ObservableDictionary(int capacity, IEqualityComparer<TKey> comparer) {
+      dict = new Dictionary<TKey, TValue>(capacity, comparer);
+    }
+    public ObservableDictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer) {
+      dict = new Dictionary<TKey, TValue>(dictionary, comparer);
+    }
+    #endregion
+
+    #region Access
+    public bool ContainsKey(TKey key) {
+      return dict.ContainsKey(key);
+    }
+    public bool ContainsValue(TValue value) {
+      return dict.ContainsValue(value);
+    }
+    bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item) {
+      return dict.Contains(item);
+    }
+    public bool TryGetValue(TKey key, out TValue value) {
+      return dict.TryGetValue(key, out value);
+    }
+    #endregion
+
+    #region Manipulation
+    public void Add(TKey key, TValue value) {
+      dict.Add(key, value);
+      OnItemsAdded(new KeyValuePair<TKey, TValue>[] { new KeyValuePair<TKey, TValue>(key, value) });
+    }
+    void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item) {
+      ((ICollection<KeyValuePair<TKey, TValue>>)dict).Add(item);
+      OnItemsAdded(new KeyValuePair<TKey, TValue>[] { item });
+    }
+
+    public bool Remove(TKey key) {
+      TValue value;
+      if (dict.TryGetValue(key, out value)) {
+        dict.Remove(key);
+        OnItemsRemoved(new KeyValuePair<TKey, TValue>[] { new KeyValuePair<TKey, TValue>(key, value) });
+        return true;
+      }
+      return false;
+    }
+    bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item) {
+      if (((ICollection<KeyValuePair<TKey, TValue>>)dict).Remove(item)) {
+        OnItemsRemoved(new KeyValuePair<TKey, TValue>[] { item });
+        return true;
+      }
+      return false;
+    }
+
+    public void Clear() {
+      KeyValuePair<TKey, TValue>[] items = dict.ToArray();
+      dict.Clear();
+      OnCollectionReset(new KeyValuePair<TKey, TValue>[0], items);
+    }
+    #endregion
+
+    #region Conversion
+    void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) {
+      ((ICollection<KeyValuePair<TKey, TValue>>)dict).CopyTo(array, arrayIndex);
+    }
+    #endregion
+
+    #region Enumeration
+    public Dictionary<TKey, TValue>.Enumerator GetEnumerator() {
+      return dict.GetEnumerator();
+    }
+    IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator() {
+      return ((IEnumerable<KeyValuePair<TKey, TValue>>)dict).GetEnumerator();
+    }
+    IEnumerator IEnumerable.GetEnumerator() {
+      return ((IEnumerable)dict).GetEnumerator();
+    }
+    #endregion
+  }
+}
Index: trunk/sources/HeuristicLab.Collections/3.3/ObservableList.cs
===================================================================
--- trunk/sources/HeuristicLab.Collections/3.3/ObservableList.cs	(revision 2572)
+++ trunk/sources/HeuristicLab.Collections/3.3/ObservableList.cs	(revision 2572)
@@ -0,0 +1,302 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Collections {
+  [Serializable]
+  public class ObservableList<T> : IndexedCollectionChangedEventsBase<IndexedItem<T>>, IList<T> {
+    [Storable]
+    private List<T> list;
+
+    #region Properties
+    public int Capacity {
+      get { return list.Capacity; }
+      set { list.Capacity = value; }
+    }
+    public int Count {
+      get { return list.Count; }
+    }
+    bool ICollection<T>.IsReadOnly {
+      get { return ((ICollection<T>)list).IsReadOnly; }
+    }
+
+    public T this[int index] {
+      get {
+        return list[index];
+      }
+      set {
+        T item = list[index];
+        list[index] = value;
+        OnItemsReplaced(new IndexedItem<T>[] { new IndexedItem<T>(index, value) }, new IndexedItem<T>[] { new IndexedItem<T>(index, item) });
+      }
+    }
+    #endregion
+
+    #region Constructors
+    public ObservableList() {
+      list = new List<T>();
+    }
+    public ObservableList(int capacity) {
+      list = new List<T>(capacity);
+    }
+    public ObservableList(IEnumerable<T> collection) {
+      list = new List<T>(collection);
+    }
+    #endregion
+
+    #region Access
+    public List<T> GetRange(int index, int count) {
+      return list.GetRange(index, count);
+    }
+
+    public bool Contains(T item) {
+      return list.Contains(item);
+    }
+
+    public int IndexOf(T item) {
+      return list.IndexOf(item);
+    }
+    public int IndexOf(T item, int index) {
+      return list.IndexOf(item, index);
+    }
+    public int IndexOf(T item, int index, int count) {
+      return list.IndexOf(item, index, count);
+    }
+
+    public int LastIndexOf(T item) {
+      return list.LastIndexOf(item);
+    }
+    public int LastIndexOf(T item, int index) {
+      return list.LastIndexOf(item, index);
+    }
+    public int LastIndexOf(T item, int index, int count) {
+      return list.LastIndexOf(item, index, count);
+    }
+
+    public int BinarySearch(T item) {
+      return list.BinarySearch(item);
+    }
+    public int BinarySearch(T item, IComparer<T> comparer) {
+      return list.BinarySearch(item, comparer);
+    }
+    public int BinarySearch(int index, int count, T item, IComparer<T> comparer) {
+      return list.BinarySearch(index, count, item, comparer);
+    }
+
+    public bool Exists(Predicate<T> match) {
+      return list.Exists(match);
+    }
+
+    public T Find(Predicate<T> match) {
+      return list.Find(match);
+    }
+    public List<T> FindAll(Predicate<T> match) {
+      return list.FindAll(match);
+    }
+    public T FindLast(Predicate<T> match) {
+      return list.FindLast(match);
+    }
+
+    public int FindIndex(Predicate<T> match) {
+      return list.FindIndex(match);
+    }
+    public int FindIndex(int startIndex, Predicate<T> match) {
+      return list.FindIndex(startIndex, match);
+    }
+    public int FindIndex(int startIndex, int count, Predicate<T> match) {
+      return list.FindIndex(startIndex, count, match);
+    }
+
+    public int FindLastIndex(Predicate<T> match) {
+      return list.FindLastIndex(match);
+    }
+    public int FindLastIndex(int startIndex, Predicate<T> match) {
+      return list.FindLastIndex(startIndex, match);
+    }
+    public int FindLastIndex(int startIndex, int count, Predicate<T> match) {
+      return list.FindLastIndex(startIndex, count, match);
+    }
+    #endregion
+
+    #region Manipulation
+    public void Add(T item) {
+      list.Add(item);
+      OnItemsAdded(new IndexedItem<T>[] { new IndexedItem<T>(list.Count - 1, item) });
+    }
+    public void AddRange(IEnumerable<T> collection) {
+      int index = list.Count;
+      list.AddRange(collection);
+      List<IndexedItem<T>> items = new List<IndexedItem<T>>();
+      foreach (T item in collection) {
+        items.Add(new IndexedItem<T>(index, item));
+        index++;
+      }
+      OnItemsAdded(items);
+    }
+
+    public void Insert(int index, T item) {
+      list.Insert(index, item);
+      OnItemsAdded(new IndexedItem<T>[] { new IndexedItem<T>(index, item) });
+    }
+    public void InsertRange(int index, IEnumerable<T> collection) {
+      list.InsertRange(index, collection);
+      List<IndexedItem<T>> items = new List<IndexedItem<T>>();
+      foreach (T item in collection) {
+        items.Add(new IndexedItem<T>(index, item));
+        index++;
+      }
+      OnItemsAdded(items);
+    }
+
+    public bool Remove(T item) {
+      int index = list.IndexOf(item);
+      if (index != -1) {
+        list.RemoveAt(index);
+        OnItemsRemoved(new IndexedItem<T>[] { new IndexedItem<T>(index, item) });
+        return true;
+      }
+      return false;
+    }
+    public int RemoveAll(Predicate<T> match) {
+      List<IndexedItem<T>> items = new List<IndexedItem<T>>();
+      for (int i = 0; i < list.Count; i++) {
+        if (match(list[i]))
+          items.Add(new IndexedItem<T>(i, list[i]));
+      }
+      int result = list.RemoveAll(match);
+      OnItemsRemoved(items);
+      return result;
+    }
+    public void RemoveAt(int index) {
+      T item = list[index];
+      list.RemoveAt(index);
+      OnItemsRemoved(new IndexedItem<T>[] { new IndexedItem<T>(index, item) });
+    }
+    public void RemoveRange(int index, int count) {
+      IndexedItem<T>[] items = GetIndexedItems(index, count);
+      list.RemoveRange(index, count);
+      OnItemsRemoved(items);
+    }
+
+    public void Clear() {
+      IndexedItem<T>[] items = GetIndexedItems();
+      list.Clear();
+      OnCollectionReset(new IndexedItem<T>[0], items);
+    }
+
+    public void Reverse() {
+      IndexedItem<T>[] oldItems = GetIndexedItems();
+      list.Reverse();
+      OnItemsMoved(GetIndexedItems(), oldItems);
+    }
+    public void Reverse(int index, int count) {
+      IndexedItem<T>[] oldItems = GetIndexedItems(index, count);
+      list.Reverse(index, count);
+      OnItemsMoved(GetIndexedItems(index, count), oldItems);
+    }
+
+    public void Sort() {
+      IndexedItem<T>[] oldItems = GetIndexedItems();
+      list.Sort();
+      OnItemsMoved(GetIndexedItems(), oldItems);
+    }
+    public void Sort(Comparison<T> comparison) {
+      IndexedItem<T>[] oldItems = GetIndexedItems();
+      list.Sort(comparison);
+      OnItemsMoved(GetIndexedItems(), oldItems);
+    }
+    public void Sort(IComparer<T> comparer) {
+      IndexedItem<T>[] oldItems = GetIndexedItems();
+      list.Sort(comparer);
+      OnItemsMoved(GetIndexedItems(), oldItems);
+    }
+    public void Sort(int index, int count, IComparer<T> comparer) {
+      IndexedItem<T>[] oldItems = GetIndexedItems(index, count);
+      list.Sort(index, count, comparer);
+      OnItemsMoved(GetIndexedItems(index, count), oldItems);
+    }
+    #endregion
+
+    #region Conversion
+    public ReadOnlyCollection<T> AsReadOnly() {
+      return list.AsReadOnly();
+    }
+    public T[] ToArray() {
+      return list.ToArray();
+    }
+    void ICollection<T>.CopyTo(T[] array, int arrayIndex) {
+      list.CopyTo(array, arrayIndex);
+    }
+    public List<TOutput> ConvertAll<TOutput>(Converter<T, TOutput> converter) {
+      return list.ConvertAll<TOutput>(converter);
+    }
+    #endregion
+
+    #region Processing
+    public void ForEach(Action<T> action) {
+      list.ForEach(action);
+    }
+    public bool TrueForAll(Predicate<T> match) {
+      return list.TrueForAll(match);
+    }
+    #endregion
+
+    #region Enumeration
+    public List<T>.Enumerator GetEnumerator() {
+      return list.GetEnumerator();
+    }
+    IEnumerator<T> IEnumerable<T>.GetEnumerator() {
+      return ((IEnumerable<T>)list).GetEnumerator();
+    }
+    IEnumerator IEnumerable.GetEnumerator() {
+      return ((IEnumerable)list).GetEnumerator();
+    }
+    #endregion
+
+    #region Helpers
+    public void TrimExcess() {
+      list.TrimExcess();
+    }
+    #endregion
+
+    #region Private helpers
+    private IndexedItem<T>[] GetIndexedItems() {
+      IndexedItem<T>[] items = new IndexedItem<T>[list.Count];
+      for (int i = 0; i < list.Count; i++)
+        items[i] = new IndexedItem<T>(i, list[i]);
+      return items;
+    }
+    private IndexedItem<T>[] GetIndexedItems(int index, int count) {
+      IndexedItem<T>[] items = new IndexedItem<T>[count];
+      for (int i = 0; i < count; i++)
+        items[i] = new IndexedItem<T>(index + i, list[index + i]);
+      return items;
+    }
+    #endregion
+  }
+}
Index: trunk/sources/HeuristicLab.Collections/3.3/Properties/AssemblyInfo.frame
===================================================================
--- trunk/sources/HeuristicLab.Collections/3.3/Properties/AssemblyInfo.frame	(revision 2572)
+++ trunk/sources/HeuristicLab.Collections/3.3/Properties/AssemblyInfo.frame	(revision 2572)
@@ -0,0 +1,58 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2009 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using HeuristicLab.PluginInfrastructure;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Collections")]
+[assembly: AssemblyDescription("HeuristicLab collection classes")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2009 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("3652919c-21fb-4fbc-b4fc-5b15bbdfbc39")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("3.3.0.$WCREV$")]
+[assembly: AssemblyFileVersion("3.3.0.$WCREV$")]
+[assembly: AssemblyBuildDate("$WCNOW$")]
