2009-01-10  Arno Rehn  <arno@arnorehn.de>

	* Add QGraphicsItemInternal that implements QGraphicsItem's abstract methods.
	  This should fix a bug reported by Eric Butler.

2008-12-23  Arno Rehn  <arno@arnorehn.de>

	* Add a QList<const char*> marshaller. For the moment it only works in the
	  'ToObject' direction.
	* Add support for on-the-fly compilation of dataengines.

2008-12-20  Arno Rehn  <arno@arnorehn.de>

	* Revert pointerMap to a Dictionary. The crash that was reported by Eric
	  occured because Dictionary isn't thread-safe. Enclose the operations on
	  pointerMap in a lock (pointerMap) { ... } to synchronise the threads and
	  prevent the crash.

2008-12-19  Richard Dale  <richard.j.dale@gmail.com>
	* When the construct_copy() function was used to copy and instance, it
	  wasn't initializing the binding for the new instance. This caused a
	  crash when the destructor for the instance tried to make a callback with
	  the null binding. 

2008-12-16  Arno Rehn  <arno@arnorehn.de>

	* Make the pointerMap a Hashtable instead of a Dictionary - its implementation
	  in Mono seems buggy. This should fix a crash reported by Eric Butler.
	* Add FromArray() convenience method to Pointer<T>.

2008-12-14  Arno Rehn  <arno@arnorehn.de>

	* Don't use StackItem.s_long if we are on a 32 bit platform (i.e. a long isn't
	  64 bits). Use s_int instead if that's the case, otherwise the value would be
	  wrong. Is there a better solution than the one I implemented here?
	  Thanks to Eric Butler for reporting the bug!

2008-12-09  Arno Rehn  <arno@arnorehn.de>

	* Watch out for itemChange() calls and if necessary, add or remove global refs
	  to QGraphicsItems and subclasses. Thanks to Eric Butler for reporting the bug.

2008-11-30  Arno Rehn  <arno@arnorehn.de>

	* Check for return values being null and if so, don't alloc a GCHandle to it.
	  Fixes crashes when a virtual method returned null. Thanks to Eric Butler for
	  reporting the bug.

2008-11-28  Richard Dale  <richard.j.dale@gmail.com>
	* Add missing implicit QVariant constructors for QDate and QTime

2008-11-25  Arno Rehn  <arno@arnorehn.de>

	* Try initializing the smoke modules when creating a SmokeInvocation instance.

2008-10-25  Arno Rehn  <arno@arnorehn.de>

	* Use List<IQGraphicsItem> instead of List<QGraphicsItem> and check for
	  multiple inheritance in ConstructList(). Fixes bug reported by Eric Butler.
	* Add QCoreApplication.Invoke() which executes a delegate in the same thread
	  in which Q(Core)Application's main loop runs (usually the main thread).

2008-08-29  Arno Rehn  <arno@arnorehn.de>

	* Support char as a method return type.
	* Add a QIODeviceWrapper class which provides a System.IO.Stream interface
	  to a QIODevice.

2008-08-10  Richard Dale  <richard.j.dale@gmail.com>

	* Fix a bug reported by Stefano Crocco where primitives types and QStrings
	  were not working as arguments to slots and signals in smoke libs outside
	  the qt one.

2008-08-10  Arno Rehn  <arno@arnorehn.de>

    * Make uics work with KDE classes.
    * Support uint as a method return type.

2008-08-09  Arno Rehn  <arno@arnorehn.de>

	* Fix TryDispose() for custom subclasses that don't implement Dispose().

2008-07-31  Arno Rehn  <arno@arnorehn.de>

	* If a custom subclass of one of the binding's classes is destroyed, try to
	  call the Dispose() method of it. This might be useful since finalizers are
	  usually called much to late by the GC for doing a proper cleanup.

2008-07-28  Arno Rehn  <arno@arnorehn.de>

	* Various fixes for the signal->delegate connection stuff.
	* Added a class 'StreamWrapper'. It inherits from QIODevice and maps the
	  calls to a System.IO.Stream. Also added an implicit conversion to QIODevice
	  so Streams can be directly passed to methods that expect a QIODevice.

2008-07-27  Arno Rehn  <arno@arnorehn.de>

	* Created a generic Pointer<T> type, which holds an IntPtr pointing to
	  an unmanaged value. It's needed for methods that expect a pointer to
	  an array and because we can't wrap a System.Array around an unmanaged
	  pointer and pointers inside C# can't be boxed and passed to
	  MethodInfo.Invoke() (needed for overriding virtual methods). So
		void Foo(byte[] bytes)
		void Foo(byte* bytes)
	  are not possible. For now it looke like
		void Foo(Pointer<byte> bytes)
	  The Pointer<T> type behaves much like a real pointer, so you can do
	  bytes[3]. To dereference it, just call bytes.Value.
	  For now it's only used as Pointer<sbyte> when the C++ side expects a char*.
	  This fixes a bug reported by Christoph Spielmann some months ago.
	  There are probably more classes that need to be regenerated than just those
	  I checked in.
	* Add some more marshallers for reference types.

2008-07-26  Arno Rehn  <arno@arnorehn.de>

	* If CreateInstance() doesn't find a type, it now replaces the last '.'
	  with a '+' and tries again to find nested classes.

2008-07-26  Richard Dale  <richard.j.dale@gmail.com>

	* Look in all loaded Assemblies for types in lists that might not be in
	  the Qt assembly such as List<KUrl>.
	* The code to look up the types of slot arguments was failing for types
	  in the KTextEditor library

2008-07-26  Arno Rehn  <arno@arnorehn.de>

	* Add a qobject_cast based on C# reflection and qt_metacast.

2008-07-25  Richard Dale  <richard.j.dale@gmail.com>

	* Add implicit conversion operations for converting QVariants to types
	  that QVariant holds.

2008-07-20  Arno Rehn  <arno@arnorehn.de>

	* Put the classes derived from Marshall in the 'Qyoto' namespace.
	* Set the SmokeBinding for each class individually by calling the
	  method with index 0 on the instance.

2008-07-12  Arno Rehn  <arno@arnorehn.de>

    * Special case QDBusVariant in SlotReturnValue.
    * Make QDBusVariant work with CreateInstance()
    * Make QDBusReply similar to C++'s QDBusReply.

2008-07-12  Richard Dale  <richard.j.dale@gmail.com>

	* Change the slot/signal argument parsing code to work the same way as in
	  QtRuby. Use a QList<MocArgument*> type instead of just an array of
	  'MocArgument *'.
	* The type of a slot arg should always be in the smoke module of the slot
	  being invoked. However, that isn't true for a dataUpdated() slot in a 
      PlasmaScripting.Applet. So make GetMocArguments search through all the
	  loaded smoke modules if the arg type isn't found at first.

2008-07-11  Arno Rehn  <arno@arnorehn.de>

    * Use IntPtrFromQString instead of StringFromQString.
    * Export the rest of the C# marshalling functions.

2008-07-09  Richard Dale  <richard.j.dale@gmail.com>

	* When looking up the smoke type of a slot or signal argument, iterate 
	  through all the loaded smoke modules, rather than just looking in the
	  qt one.

2008-07-08  Richard Dale  <richard.j.dale@gmail.com>

	* Add marshallers for QHash types such as QHash<QString, QVariant> based
	  on the QMap marshalling code.

2008-07-07  Arno Rehn  <arno@arnorehn.de>

	* Allow to call InitRuntime() multiple times to make sure every binding
	  is initialized.

2008-07-06  Richard Dale  <richard.j.dale@gmail.com>

	* Where multiple inheritance was catered for in the Qyoto bindings each
	  superclass class other than the 'main' one was supposed to be an
	  interface type in method calls rather than the real type of the class.
	  For instance, QGraphicsWidget inherits from QObject, QGraphicsItem and
	  QGraphicsLayoutItem, and the last two classes have interfaces 
	  IQGraphicsItem IQGraphicsLayoutItem respectively The two classes were
	  correctly implementing the interfaces, but the types in the method calls
	  were not using these interface types. So fix that.
	* In the generated code, tabs are now replaced with 4 spaces.

2008-07-01  Arno Rehn  <arno@arnorehn.de>

	* Moved the runtime initialization from the static SmokeInvocation
	  constructor to a new method 'InitRuntime'. This is necessary for
	  KMonoPluginFactory to work.

2008-06-30  Richard Dale  <richard.j.dale@gmail.com>

	* When a C# value was marshalled to C++, and the actual type of
	  the C++ instance was cast to the type of the return value, it
	  wasn't working correctly if the target type for the cast wasn't in
	  the same smoke module as the type of the instance. For instance,
	  an instance of type Plasma::Applet wasn't being correctly cast
	  to a QGraphicsLayoutItem, which caused a crash.
	* Fixed a similar bug to the above description, but for where the target
	  of a method call was being cast to the correct class. For instance,
	  a call of parentWidget() on a Plasma::Applet() needed the correct cast
	  to a QWidget for it to work.

2008-06-20  Richard Dale  <richard.j.dale@gmail.com>

	* Call QMetaObject.NormalizedSignature() on the Q_SLOT and Q_SIGNAL
	  strings when creating a QMetaObject with them, otherwise space and 
	  other things will be significant.

2008-06-19  Richard Dale  <richard.j.dale@gmail.com>

	* If SmokeMarshallers.CreateInstance() couldn't find a C# class with
	  the name passed to it, it just crashed. So output an error message
	  so it is obvious what is going on.
	* The names of the C# classes were not being set up correctly in the
	  C++ to C# name maps.

2008-06-18  Richard Dale  <richard.j.dale@gmail.com>

	* Don't convert QChars to C# chars, keep them as QChars

2008-06-17  Richard Dale  <richard.j.dale@gmail.com>

	* Added an implicit constructor operator for converting strings to
	  QByteArrays as it is useful for the KAboutData classes

2008-06-16  Richard Dale  <richard.j.dale@gmail.com>

	* Add a header 'marshall_macros.h' with the template methods and macros
	  for QList and QVector pointer and value based marshallers.
	* Regenerate the Qt sources with the recent changes in code generation
	  for namespaces and nested structs

2008-06-13  Richard Dale  <richard.j.dale@gmail.com>

	* Pass the resolve_classname() functions a 'smokeqyoto_object *' so that
	  they can change the smoke lib and classId on it.

2008-06-11  Arno Rehn  <arno@arnorehn.de>

	* Added the AssemblySmokeInitializer Attribute. It takes a Type of
	  another class as an argument and is intended to initialize the
	  underlying smoke lib for the binding. A method named 'InitSmoke'
	  has to exist in the class specifed by the 'Type' argument and this
	  will be called once to initialize the smoke lib. It is applied like
	  this:
	      [assembly: AssemblySmokeInitializer(typeof(InitSoprano))]
	* Added C++ sources to the kimono bindings. They work now.
	* Applied this change to the Kimono and Soprano# bindings.

2008-06-04  Richard Dale  <richard.j.dale@gmail.com>

	* Remove references to QtWebKit from the Qyoto handlers.cpp so it 
	  links
	* Remove superfluous semi-colon from an extern C block

2008-05-31  Arno Rehn  <arno@arnorehn.de>

	* Updated AssemblyInfo.cs
	* Regenerated the QScintilla sources from the 2.2 release.
	* Removed the ReadProperty and WriteProperty classes and inlined the
	  code instead. It's not worth to have 2 extra classes for 5 or 6
	  lines of code.

2008-05-17  Arno Rehn  <arno@arnorehn.de>

	* Don't build kimono because the classes won't compile.
	* Fixed resolve_classname.
	* Changed 'modules' to 'qyoto_modules' in QScintillaSharp, too.
	* Added delegate support. This is now possible:
		Connect(slider, SIGNAL("valueChanged(int)"), delegate(int i) {
			Console.WriteLine("value: {0}", i);
		});
	  For the above to work you need either Mono 1.9+ or specify -langversion:linq.
	  Alternatively, you can give the parameter types as generic arguments, like
	  Connect<int>(...)

2008-05-16  Richard Dale  <richard.j.dale@gmail.com>

	* After the modular smoke changes, the QtWebKit classes were not being
	  built
	* Rename the 'modules' global variable qyoto_modules to reduce the chances
	  of a name clash

2008-05-13  Arno Rehn  <arno@arnorehn.de>

	* Fix memory leak in WriteProperty.
	* Added missing license information.

2008-05-06  Richard Dale  <richard.j.dale@gmail.com>

	* Regenerate the C# sources from the Qt 4.4 release headers

2008-04-10  Richard Dale  <richard.j.dale@gmail.com>

	* Added the missing QWebHitTestResult.cs source. Thanks to annma for 
	  noticing

2008-04-20  Arno Rehn  <arno@arnorehn.de>

	* Since Mono 1.9 inherited private members are not included in the search
	  by Type.Get*. So now search in the whole hierarchy for the private field
	  'smokeObject'.


	* Regenerated the Qyoto sources from the Qt 4.4 rc1 headers

2008-03-03  Richard Dale  <richard.j.dale@gmail.com>

	* Added some more Qt 4.4 classes
	* Added some marshallers for new Qt 4.4 QList types
	* Brought the MonoDevelopment Qyoto project up to date with the current
	  sources

2008-02-25  Richard Dale  <richard.j.dale@gmail.com>

	* Regenerated the sources with the Qt 4.4 headers
	* Added the QtWebKit classes

2007-11-29  Richard Dale  <rdale@foton.es>

	* Fixed the simpletreemodel example so that the Flags() method returns
	  a uint
	* The GetCPPEnumValue() used by uics generate code now returns a uint
	* Thanks to Jos van den Oever for reporting these two bugs

2007-11-10  Richard Dale  <rdale@foton.es>

	* Fix regressions caused by attempt to tidy up the skipped methods code
	  generation

2007-10-18  Richard Dale  <rdale@foton.es>

	* Simply the code to special case which classes and methods are to be skipped
	  when generating the bindings. Regenerate to add a few missing methods

2007-08-11  Arno Rehn  <arno@arnorehn.de>

	* If a marshaller is given a zero pointer, return zero and don't free
	  the GCHandle.
	* Added implicit type conversions for QUrl.
	* Fixed generation of ToolBarArea and DockWidgetArea related stuff in
	  uics.
	* Improved Qyoto.GetPrimitiveString()

2007-08-09  Richard Dale  <rdale@foton.es>

	* Added some missing implicit type conversions to better match 
	  the C++ api

2007-07-15  Arno Rehn  <arno@arnorehn.de>

	* Moved Init_qyoto() from the Q(Core)Application constructor to the
	  static SmokeInvocation constructor. It's now called before anything
	  else, even if you hadn't created a Q(Core)Application before.

2007-06-26  Richard Dale  <rdale@foton.es>

	* Fixed a bug parsing Q_PROPERTIES which messed up the code generation
	* Code for nested classes is now generated

2007-06-25  Arno Rehn  <arno@arnorehn.de>

	* Made a seperate assembly out of the QScintilla namespace.

2007-06-19  Richard Dale  <rdale@foton.es>

	* Moved the QScintilla classes to a QScintilla namespace instead of 
	  Qyoto.QScintilla as Qyoto should really just contain the Qt classes
	* #ifdef'd the code to register a callback for events so the code
	  compiles with Qt 4.2.x

2007-06-23  Arno Rehn  <arno@arnorehn.de>

	* Added classes for QScintilla2
	* Added a marshaller for QList<QWizard::WizardButton>
	* Added FindSmokeQt.cmake (might be useful when someone wants to create a standalone
	  package)
	* Added a LINK_DIRECTORIES rule in CMakeLists.txt

2007-06-21  Arno Rehn  <arno@arnorehn.de>

	* When the assembly is installed, a symlink is created in the "2.0" directory, so
	  it can be directly referenced from gmcs with -r:qt-dotnet

2007-06-19  Richard Dale  <rdale@foton.es>

	* Added the missing QUiLoader class
	* Improved the layout of the README, and made some changes to the text

2007-06-18  Arno Rehn  <arno@arnorehn.de>

	* Update CSharpMacros.cmake to work currectly with relative paths and improved
	  the build-comments a bit.

2007-06-18  Richard Dale  <rdale@foton.es>

	* Removed the various commented out QAbstractItemModel methods as they
	  aren't needed
	* Fix the code generation for QWizard.cs so it has a C# List for the
	  'const QList<QWizard::WizardButton>&', although it doesn't have a
	  corresponding marshaller yet

2007-06-13  Richard Dale  <rdale@foton.es>

	* Finished fixing the virtual method callback code
	* Removed a memory leak from the 'int&' marshaller
	* Fixed some other minor problems reported by valgrind
	* Don't garbage collect QGraphicsItem instance for now

2007-06-12  Richard Dale  <rdale@foton.es>

	* When the stack was allocated for a virtual method callback, an entry 
	  wasn't being included for the reply value
	* When the arguments for a virtual method callback were copied to the
	  C# arg stack, they were off by one
	* The colliding mice example currently crashes with memory corruption
	  problems

2007-06-10  Richard Dale  <rdale@foton.es>

	* Added an event callback handler to look for ChildAdded and ChildRemoved
	  events. It then creates or removes global references. Now call references
	  'global refs' instead of 'strong refs' in the code.
	* Added some more list marshallers.

2007-06-07  Arno Rehn  <arno@arnorehn.de>

	* Added README
	* Updated AUTHORS and TODO

2007-06-05  Arno Rehn  <arno@arnorehn.de>

	* Improved the build system:
		* Added FindMono.cmake to find mono, gmcs, mcs and gacutil
		* Added CSharpMacros.cmake which consists of macros for dealing with C#.
		  It's now much easier to build C# libraries and executables and to
		  install them.
		  Further, a C# target is only built if the output file is missing
		  or the sources were modified.
	* Updated all CMakeLists.txt to work with the improved build system.

2007-06-04  Richard Dale  <rdale@foton.es>

	* Added the QBitArray class for completeness

2007-06-03  Richard Dale  <rdale@foton.es>

	* Fixed implicit type conversions code for non-QtCore classes to QVariants

2007-06-02  Richard Dale  <rdale@foton.es>

	* Updated the uics tool against the Qt 4.3 sources
	* Changed the code generation to generate properties for QDOC_PROPERTY
	  macros
	* Added a space after the '///'s for the documentation tags so that they
	  have Kate syntax highlighting
	* Added a string to QKeySequence implicit type conversion

2007-06-02  Arno Rehn  <arno@arnorehn.de>

	* Special cased the QCoreApplication constructor, too.
	* Added AssemblyInfo.cs
	* Added a keyfile for strong naming the qt-dotnet assembly so it can
	  be added to the GAC. It won't be generated at compile time since there
	  might occur problems when it is regenerated and the assembly is reinstalled.
	* Added rules in CMakeLists.txt for installing libqyoto.so.
	* Added rules in CMakeLists.txt for installing qt-dotnet.dll into the GAC.

2007-06-01  Arno Rehn  <arno@arnorehn.de>

	* Special cased the QApplication constructor call to work correctly

2007-05-31  Arno Rehn  <arno@arnorehn.de>

	* Added a hack in uics for QFrame.Shape and QFrame.Shadow

2007-05-31  Richard Dale  <rdale@foton.es>

	* Regenerated the Qyoto sources from the release version of Qt 4.3

2007-05-29  Richard Dale  <rdale@foton.es>

	* Try Arno's suggestion of 'return (int) (qint64) o->ptr;' in the
	  QyotoHash f'n to make it compile on all architectures.

2007-05-28  Arno Rehn  <arno@arnorehn.de>

	* Updated the code of the first tutorials to be more like C++ ones.

2007-05-28  Richard Dale  <rdale@foton.es>

	* Further simplified the marshalling of primitive reference types. As
	  a pointer the the value on the C# stack is copied to the smoke stack 
	  before the method call, the value after the method call doesn't need
	  to be copied back.
	* Added a marshaller for 'short&' and 'short*' arg types
	* Attempted to add a QyotoHash function that will compile on 64 bit 
	  machines

2007-05-27  Arno Rehn  <arno@arnorehn.de>

	* Removed the redundant stuff for ref arguments again and implemented them
	  based on Richard's proposal, which is much simpler.
	* Added marshallers for qreal (double) and bool references.

2007-05-18  Arno Rehn  <arno@arnorehn.de>

	* Made 'ref' arguments work.

2007-05-15  Richard Dale  <rdale@foton.es>

	* Regenerated the Qyoto sources from the current qt-copy snapshot as 
	  there have been quite a few changes
	* Added a QSsl class with enums, but this should really be a C# namespace
	  as the C++ version is a namespace.

2007-05-14  Richard Dale  <rdale@foton.es>

	* Added code generation for 'ref' argument types

2007-04-26  Richard Dale  <rdale@foton.es>

	* The classes which need to have interfaces, such as QUrl because they
	  are used with multiple inheritance in C++, were always being defined
	  as interface types in method arguments. This isn't needed, so change
	  arg types from 'IQUrl' etc to 'QUrl' etc.

2007-04-25  Arno Rehn  <arno@arnorehn.de>

	* Special cased QVector<QRgb> when marshalling.
	* Fixed two more memory leaks.
	* Removed all the instances of delegates in SmokeMarshallers.cs. In C# 2.0
	  we can directly specify a method, we don't need an instance of a correspondending
	  delegate anymore.

2007-04-16  Richard Dale  <rdale@foton.es>

	* Added a QyotoHash() method for deriving a hash value from the c++
	  pointer of an instance.

2007-04-15  Richard Dale  <rdale@foton.es>

	* The Qyoto project is built with no symbols visible by default in
	  kdebindings, so add function declarations in qyoto.h to make it work.
	* Added some more implicit type conversion operator methods and chaanged
	  the code in the tutorial t14 example to use them

2007-04-14  Richard Dale  <rdale@foton.es>
	
	* Fixed some compiler warnings
	* Added implicit operator conversions for various types to QVariants

2007-04-13  Arno Rehn  <arno@arnorehn.de>

	* Fixed CMakeLists.txt's to work with the new directory structure. Some lines of
	  the top-level CMakeLists.txt should be put in subdirectories, though.
	* Subclasses of QTextBlockUserData are now contained instances.

2007-04-09  Richard Dale  <rdale@foton.es>

	* Added marshallers for some of the new Qt 4.3 list types

2007-04-08  Richard Dale  <rdale@foton.es>

	* Improved the code to only generate C# properties instead of normal
	  method calls. Only generate code for the Read and write methods of
	  the property if they are slots, signals or virtual methods.
	* Fixed the uics tool to generate code that compiles with the above
	  change.

2007-04-08  Arno Rehn  <arno@arnorehn.de>

	* Renamed all QAbstract*Helper classes to QAbstract*Internal and
	  marked them as internal, so they cannot be accessed from outside
	  the assembly.

2007-04-06  Richard Dale  <rdale@foton.es>

	* Fixed all compiler warnings in the generated code, except for 180 
	  warnings about the smokeObject private variable not being used.

2007-04-06  Arno Rehn  <arno@arnorehn.de>

	* Added missing QItemModel.cs. Forgot to do a 'svn add' last time.
	* Added more helper classes for abstract base classes which are returned by
	  public methods.
	* Fixed little bug in qdbus/chat/chat.cs.

2007-04-06  Richard Dale  <rdale@foton.es>

	* Improved the code generation to fix some of the many warnings, and fixed
	  some compiler warnings in the Qyoto runtime code too.
	* Added a MonoDevelop project for the Qyoto source files

2007-04-05  Richard Dale  <rdale@foton.es>

	* Regenerated the Qyoto classes from the Qt 4.3 headers, and added new 
	  classes
	* The test for instance operator methods was changing 'operator>>' and
	  'operator<<' calls from static to instance methods, when they are
	  actually still instance methods 'Read()' and 'Write()' in C#.
	* Add some marshallers for the QVector types in the new QXmlStream*
	  classes

2007-04-03  Richard Dale  <rdale@foton.es>

	* No need to special case the metaObject() method any more when caching 
	  smoke method ids
	* After a smoke method has been called, free the GCHandle for the instance
	  on the C# side

2007-04-02  Arno Rehn  <arno@arnorehn.de>

	* Added a subclass of QAbstractItemModel called QItemModel which implements
	  the abstract methods of its super class by calling the original methods of
	  its C++ base class.
	* Added workaround in resolve_classname to return "QItemModel" instead of "QAbstractItemModel"
	  so instances of this class can be constructed. Makes calls which return a QAbstractItemModel
	  work.

2007-04-01  Richard Dale  <rdale@foton.es>

	* Replace transparent proxies to invoke methods, with a direct call to 
	  'SmokeInvocation.Invoke()' to invoke a method in the Smoke library.
	  Performance is now 20x better than two weeks ago for a test consisting
	  of 5 goes at the cannon game with force 40. The new method to call a 
	  method in the Smoke library looks like this:

		public object Invoke(	string mungedName, 
								string signature, 
								Type returnType, 
								params object[] args );

	  Where the 'params' object[] argument is a list of arg type/arg value pairs.

	  An example of calling it:

		public QPoint(int xpos, int ypos) : this((Type) null) {
			CreateProxy();
			interceptor.Invoke(	"QPoint$$", 
								"QPoint(int, int)", 
								typeof(void), 
								typeof(int), xpos, typeof(int), ypos);
		}


2007-03-27  Richard Dale  <rdale@foton.es>

	* When a reference in the weak reference map is found to be dead, remove
	  it from the map
	* Fixed bug in debugging logging where weak refs were wrongly being
	  labelled as dead

2007-03-26  Richard Dale  <rdale@foton.es>

	* Before an entry was removed from the weak reference map, a check was
	  made to see if it was still there. But the check always returned 0
	  because the reference was a dead weak reference, and so no entries
	  were ever removed causing a memory leak
	* Tidied up the code to call the C# delegate pointers directly, rather
	  than via C wrapper functions, which didn't really do anything useful
	* The 'CreateInstance()' method is now passed a pointer to a 
	  smokeqyoto_object instance

2007-03-25  Richard Dale  <rdale@foton.es>

	* Tidy up the caching the slot and signal type signatures and removed
	  duplicated code. The signal signatures are no longer obtained every
	  time is signal is emitted, but got from a cache in a dictionary.

2007-03-25  Arno Rehn  <arno@arnorehn.de>

	* If a object is destroyed, don't call any methods on it anymore (fixes
	  the crash of e.g. the pingpong example)

2007-03-24  Richard Dale  <rdale@foton.es>

	* The 'IsSmokeClass()' test now uses the Smoke class data cache
	* Renamed the method to retrieve a C# instance given a pointer to the C++
	  instance as 'GetInstance(). Given it an a boolean argument 'allInstances'
	  and if false, GetInstance() will only return instances that are custom 
	  subclasses of Qyoto classes. This is useful when dealing with overriden
	  virtual method callbacks, as only custom subclasses can have their own
	  slots or overriden virtual methods.
	* These two improvements give a 2-3 times speed up, and Qyoto now uses 
	  about 6 times less mill than it did a week ago.

2007-03-23  Richard Dale  <rdale@foton.es>

	* Cache various items in a dictionary with a key of the Smoke class's
	  type to avoid using reflection to look up the items each time. A timing
	  test consisting of starting the t14 cannon game and firing 5 shots at
	  force 40, used half the mill of the version without caching.

	* The following class is used to cache the data:

		public class SmokeClassData {
			public string className;
			public ConstructorInfo constructorInfo;
			public object[] constructorParamTypes;
			public MethodInfo proxyCreator;
			public FieldInfo smokeObjectField;
		}

		- classname: the C++ signature of the Smoke class
		- constructorInfo: the ConstructorInfo to construct a new instance
		- constructorParamTypes: the argument to pass to the constructorInfo
		- proxyCreator: the method to create the transparent proxy for the 
			new instance
		- smokeObjectField: the field for holding a pointer to the 
			smokeqyoto_object struct for the instance

	* Add an entry to the strong reference map for custom QWidget subclasses 
	  to prevent them being GC'd prematurally.

2007-03-22  Richard Dale  <rdale@foton.es>

	* Added debug methods for logging GCHandle.Alloc() and Free() calls
	* Freed GCHandles in a few places, but there are still a lot of leaks
	* Hmm, a fix for a GCHandle leak stopped custom slots from working for
	  no apparent reason.
	* The above problem is caused by the GCHandle leak preventing premature
	  garbage collection, and once the leak problem was fixed it exposed
	  Qyoto's problems with coordinatign C#'s GC with Qt memory management
	  via QObject trees etc.
	* Qyoto method calls can now return null values

2007-03-21  Arno Rehn  <arno@arnorehn.de>

	* Moved the check and 'workaround' for instance operators from C# to C++.
	  Doesn't create any additional overhead like the C# solution.

2007-03-18  Richard Dale  <rdale@foton.es>

	* Changed the name of the debug class from Debug to QDebug as it made 
	  using Debug.Asserts inconvenient
	* Added some copyright headers to the source files
	* Build the project with debug by default

2007-03-20  Arno Rehn  <arno@arnorehn.de>

	* Allow 'zero' return types for methods and for args of methods being called
	  from C++
	* Made instance operators work

2007-03-18  Richard Dale  <rdale@foton.es>

	* Instead of setting and getting properties via QObject.SetProperty() and
	  QObject.Property() and creating QVariants, call the methods in the
	  Smoke library directly.

2007-03-17  Richard Dale  <rdale@foton.es>

	* Removed redundant method calls for invoking methods on the interceptors,
	  that only cast the interceptor to the type of the current class. Just
	  do the cast directly. The 'staticInterceptor' field now has the type of
	  the instance for which it is proxying the static methods and doesn't
	  need casting at all.
	* When marshalling pointer lists from C++ to C# use the 
	  'resolve_classname()' function to get a more accurate name of the class
	  to instantiate.
	* Improved resolve_classname() for QGraphicsItem subclasses

2007-03-16  Richard Dale  <rdale@foton.es>

	* Overriding abstract methods wasn't working because no SmokeMethod
	  Attribute was being generated for them
	* Fixed bug in invoking constructors where wrapper instances were being
	  created twice
	* When constructing an instance via CreateInstance() the CreateProxy()
	  method is now optional, so just don't call it if not found.

2007-03-14  Richard Dale  <rdale@foton.es>

	* Only generate destructors if the class is implementing IDisposible
	* Only generate code to set up transparent proxy interceptors for instance
	  or static methods if the class has some instance or static methods that
	  would need an interceptor
	* Order the generated code:
		1) Enums
		2) Properties
		3) Methods not converted
		4) Instance methods
		5) Static methods

2007-03-12  Richard Dale  <rdale@foton.es>

	* When the access level of an overriden method is changed, use 'new' in
	  the method declaration allow the change, rather than always making
	  these methods public
	* Allow covariant return types as C# has them
	* Make some classes non-abstract by adding the missing methods
	* Fix code generation of QApplication.Exec() so apps don't crash on exit
	* Convert 'qreal*' to 'double out' argument types

2007-03-11  Richard Dale  <rdale@foton.es>

	* For pure virtual methods with optional arguments, only translate the
	  longest version to a C# abstract method. Otherwise, it was necessary
	  to add extra methods in subclasses that wouldn't be needed in the C++
	  equivalent code. Fixed example code that needed to do that.

2007-03-08  Richard Dale  <rdale@foton.es>

	* Improved the code generation for overriden methods and they are
	  now labelled 'virtual' or 'override' where appropriate, rather than
	  as 'new'
	* Classes with pure virtual methods are now 'abstract' as are the pure
	  virtual methods.
	* Made the code generated for Q_PROPERTIES shorter for clarity
	* Fixed some compile errors in the examples as a result of the above 
	  changes
	* The tutorial application t14 now seg faults on exit
	* Pure virtual protected methods such as 
	  QSyntaxHighlighter.HighlightBlock() are no longer omitted from the
	  generated code

2007-03-07  Richard Dale  <rdale@foton.es>

	* Made the simpletreemodel example use the csrcc resource compiler
	* Removed the 'qt_metacall NOT CONVERTED' messages from the sources as
	  were just noise
	* Don't generate destructors for the Qt class as it only has static 
	  methods

2007-03-06  Richard Dale  <rdale@foton.es>

	* A GCHandle was being used to hold the 'internalPointer' value in a 
	  QModelIndex. A new one was being allocated everytime a new index
	  was created by QAbstractItemModel.CreateIndex(), which meant that
	  different GCHandles could hold the same underlying 'Target' instance.
	  However, this meant that the equality operator for QModelIndex no longer
	  worked correctly. So GCHandles for holding the InternalPointer() 
	  references are kept in a Dictionary with the object instance to be 
	  wrapped as the key. A reference count against the handle is used to 
	  ensure that the GCHandle is freed once there are no references to it 
	  via InternalPointer().

2007-03-06  Arno Rehn  <arno@arnorehn.de>
 
	* GCHandles for QModelIndex'es are now stored in a Dictionary.
	  QAbstractItemModel.CreateIndex() looks up a GCHandle in the Dictionary
	  and if it exists it is passed to the C++ function. Child items of a tree model
	  can now be selected.
	* In the simpletreemodel example the entries of default.txt are now being read correctly

2007-03-05  Richard Dale  <rdale@foton.es>

	* Free up some GCHandles when they're finished with

2007-03-03  Arno Rehn  <arno@arnorehn.de>

	* Added QModelIndex.InternalPointer() and QAbstractItemModel.CreateIndex()
	* Added simpletreemodel example (doesn't fully work yet)
	* Fixed invocation of methods with an enum as a argument

2007-02-28  Arno Rehn  <arno@arnorehn.de>

	* Don't include inherited signals/slots when building up the metaobject
	* Added seperate methods for getting all the signals/slots of a class, including
	  inherited ones. This is needed for InvokeCustomSlot() and SignalInvocation.Invoke()
	* Changed qt_metacall to be more like the one genereted by moc:
		* First call qt_metacall of the base class
		* If the return value is postive, it was a C++ slot/signal/property, return
		* If the return value is negative, look for C# slots/signals/properties
		  and call them
	* Made QObject.FindChild() and QObject.FindChildren() work

2007-02-27  Richard Dale  <rdale@foton.es>

	* Made the QMetaObject creation work correctly with nested subclasses

2007-02-24  Arno Rehn  <arno@arnorehn.de>

	* Added ReadProperty and WriteProperty classes. Now custom properties can
	  be accessed via Property() and SetProperty() (and dbus?). However there seems
	  to be a problem with marshalling, see FIXMEs in the code. The workaround should
	  work as well as with marshalling, though.
	* Autogeneration of Q_PROPERTY signatures and types now works properly.
	* Flags of properties should now be set correctly.
	
2007-02-21  Arno Rehn  <arno@arnorehn.de>

	* QMetaObjects are now correctly inherited.
	* If there was a request for a QMetaObject of a native Qt class, a new
	  QMetaObject was created with all the signals and slots of the class and
	  the native QMetaObject was just used as a parent. The resulting object had
	  every definition twice. Fixed.

2007-02-20  Richard Dale  <rdale@foton.es>

	* Commented out QList<QHostAddress> marshallers as it caused a linking
	  problem on Mac OS X
	* Change 'ADD_LIBRARY (qyoto SHARED ${SRC_CPP})' to 
	  'ADD_LIBRARY (qyoto MODULE ${SRC_CPP})' to build libqyoto.so, rather
	  than libqyoto.dyld on Mac OS X

2007-02-19  Arno Rehn  <arno@arnorehn.de>

	* Implemented adding Q_PROPERTY's to the QMetaObject. Next step is
	  adding classes like InvokeSlot for properties in qyoto.cpp.
	* When retrieving slot signatures, also include the slots of the superclass,
	  if it isn't a native C++ class. Same has to be done for signals.
	* Did some code cleanup:
		* Moved QyotoMetaData class into a seperate file, QyotoMetaData.cs
		* Made code in QyotoMetaData better readable

2007-02-14  Arno Rehn  <arno@arnorehn.de>

	* Fixed compilation error in t14
	* Modified all CMakeLists.txt to produce nicer output

2007-02-14  Richard Dale  <rdale@foton.es>

	* Added cmake files for building the csrcc tool
	* Fix the cmake file for building the uics tool
	* Specify the ${UICS_PATH} and ${CSRCC_PATH} as their relative positions
	  within the qyoto project.

2007-02-13  Richard Dale  <rdale@foton.es>

	* Removed the signal spy check and replaced it with a global flag 
	  'application_terminated'. Once the flag is set, destructors are no
	  longer called.

2007-02-12  Richard Dale  <rdale@foton.es>

	* The scheme for caching the smoke methodId inside a SmokeMethod Attribute
	  didn't work, and the value returned was always -1, even when it had been
	  set to a value. So use a dictionary of type Dictionary<MethodInfo, int>
	  as a cache instead.
	* When a destructor has been called, remove the item from the weak 
	  reference map
	* Additionally, in a destructor free the smokeqyoto_object struct, and
	  set the pointer to it in the C# instance to 0.

2007-02-11  Richard Dale  <rdale@foton.es>

	* Don't call a destructor is the instance was allocated in the C++ world
	* If a destructor has been called then set the ptr field on the 
	  smokeqyoto_object struct to 0, and don't call methods on it again.
	* Renamed IsInstanceContained() as IsContainedInstance(), and only call
	  a destructor for instances where it is false, as the C++ side will
	  delete the instance.
	* Q_INIT_RESOURCE() now correctly finds the resource class to load
	* Added QT_TRANSLATE_NOOP() and QT_TR_NOOP() methods

2007-02-10  Arno Rehn  <arno@arnorehn.de>

	* If the aboutToQuit() signal is catched, no destructors will be called.
	  Replaces the check for qApp == 0. No warning about QSocketNotifiers at
	  the end of the main event loop anymore.

2007-02-10  Richard Dale  <rdale@foton.es>

	* Improved debug messages in SmokeInvocation.cs
	* The csrcc tool nearly works, but Qt.Q_INIT_RESOURCE() can't find the
	  class where the resource is.

2007-02-09  Arno Rehn  <arno@arnorehn.de>

	* When a qApp instance was destroyed, it would automatically destroy all
	  other Qt objects, in some cases our own destructor calls could interfere
	  with this mechanism. Fixed by checking if qApp == 0 and if so skipping
	  the destructor calls.

2007-02-09  Richard Dale  <rdale@foton.es>

	* Renamed CreateStrongReference() as IsInstanceContained()
	* Added 'csrcc', a C# version of the Qt rcc tool
	* Added the graphicsview/collidingmice example
	* Fixed code generation of the csrcc tool, and added a static
	  constructor
	* Added a cmake rule for a ${CSRCC_PATH} variable

2007-02-08  Arno Rehn  <arno@arnorehn.de>

	* Made destructors work. The only problem was that we have to check
	  if the instance of which a method should be invoked still exists.
	  This was not the case, e.g. if the QApplication instance was destroyed
	  at the end of an app and with it all other Qt instances.
	  Now the DeleteQApp-Hack isn't needed anymore, too.

2007-02-08  Richard Dale  <rdale@foton.es>

	* Added a first attempt at setting up the strongReferenceMap and calling
	  destructors. A boolean function CreateStrongReference() checks whether
	  or not a strong reference is needed when a new instance has been
	  constructed. Another function is needed to checked whether the C++
	  instance still has a parent or container, and not delete if it has.

	* Currently apps crash on exit, but the Qyoto.DeleteQApp()
	  hack shouldn't be need anymore once destructors are working.

2007-02-08  Arno Rehn  <arno@arnorehn.de>

	* Fixed names of flags in Qyoto.cs
	* Modified CMakeLists.txt to output more infos and to get out-of-source-dir
	  builds working

2007-02-08  Richard Dale  <rdale@foton.es>

	* Fixed bugs in the debug dump of QMetaObjects created at runtime
	* Normalized some code layout
	* Only QApplication and QCoreApplication destructors are now called
	* Added a strongReferenceMap to hold a mapping from a C++ pointer to
	  a C# instance. It is used to prevent garbage collection for instances
	  which are contained in another instance, such as a QObject with a
	  parent, even when there are no references to the child within the C#
	  Qyoto application code. When the parent finally deletes the child on 
	  the C++ side, the reference is removed from the Dictionary by the 
	  SmokeMarshallers.UnmapPointer() method.
	* Renamed the QTDB_METHOD_MISSING debugging flag as QTDB_TRANSPARENT_PROXY

2007-02-07  Richard Dale  <rdale@foton.es>

	* Added a Debug.DebugChannel() method to get debug setting in C#

2007-02-06  Richard Dale  <rdale@foton.es>

	* Added a QPair struct corresponding to the C++ one, and generate
	  method calls with arguments that use it
	* Generate accessor methods for static variables and instance variables
	* Added the widgets/analogclock example
	* Fixed bug in marshalling QVector types with an unitialise variable in
	  a for loop
	* Added QMin() and QMax() methods
	* Added marshalling for StringBuilder <--> QStrings
	* Add a generically typed QDBusVariant.FromValue() method to make 
	  constructing them less ugly.
	* Use reflection via GetType() to find out whether a string or a 
	  StringBuilder needs to be marshalled to a QString

2007-02-05  Richard Dale  <rdale@foton.es>

	* Moved operator methods out of Qt.cs, and made them operator
	  methods in the classes of their arguments. In Qt.cs they
	  had to be translated to use names like op_mult() or op_add()
	  because C# only allows operator methods to be defined in the
	  class of one of their arguments. Now they are proper operator
	  methods which looks better.

2007-02-04  Richard Dale  <rdale@foton.es>

	* Updated the project TODO list
	* Added a a Qyoto Debug class for turning on debugging options
	  Example usage:

		Debug.SetDebug(QtDebugChannel.QTDB_VIRTUAL);

	  This will show the virtual method callbacks from the Smoke lib
	* Removed core/QGlobalSpace.cs as it isn't needed because the methods in 
	  it are in Qt.cs
	* The 'operator<<' and 'operator>>' methods are no longer renamed 
	  'op_write' and 'op_read', but 'Write' and 'Read' instead.
	* Started to implement QObject.FindChild() and QObject.FindChildren(),
	  but the code needs to be translated from QtRuby.
	* Removed unwanted blank lines from the generated code.

2007-02-03  Richard Dale  <rdale@foton.es>

	* The SmokeMethod attribute constructor now takes three arguments,
	  for example:

		[SmokeMethod("eventFilter", "(QObject*, QEvent*)", "##")]
		public virtual bool EventFilter(QObject arg1, QEvent arg2) {
			return ProxyQObject().EventFilter(arg1,arg2);
		}

	* There are four properties to access the values of a SmokeMethod.
	  For example:

		SmokeMethod.Name => "eventFilter"
		SmokeMethod.ArgsSignature => "(QObject*, QEvent*)"
		SmokeMethod.MungedName => "eventFilter##"
		SmokeMethod.Signature => "eventFilter(QObject*, QEvent*)"

	* Virtual method callbacks are now working again
	* In SmokeInvocation.Invoke() destructors aren't called until a way of
	  coordinating C# GC with C++ Qt instance deletion has been implemented.
	* C# operator methods are always static, and so the SmokeMethod Attribute
	  must be for the method in the I<classname>Proxy interface, rather than
	  on the static method call implementation.
	* Added a SmokeClass Attribute to the interfaces used to create the 
	  transparent proxy for static method invocations.
	* The SmokeClass Attribute is now used for the name of the class to use
	  when looking up methods in the Smoke library
	* The default format of a string in mono is utf8, and so assume that when
	  converting to and from QStrings.

2007-02-03  Richard Dale  <rdale@foton.es>

	* Added qdbus/remotecontrolledcar example
	* The enums named 'Type' clash with the C# method of the same name,
	  instead of renaming them 'E_Type', use 'TypeOf' as it looks better.
	* Changed the SmokeMethod Attribute to include the 'munged method name'
	  as well as the C++ type signature of the method's arguments. This 
	  make it easier and faster to look up the method in the Smoke library
	  at runtime. The SmokeMethod attribute wasn't working with static
	  methods as it needed to be on the interface where the static method
	  was defined, and not on the method itself. For instance, an instance
	  method is now defined like this:

		[SmokeMethod("setParent#", "(QObject*)")]
		public void SetParent(QObject arg1) {
			ProxyQObject().SetParent(arg1);
		}

	  And a static method is defined like this:

		[SmokeMethod("sessionBus", "()")]
		QDBusConnection SessionBus();
		...

		public static QDBusConnection SessionBus() {
			return StaticQDBusConnection().SessionBus();
		}

	  Once a methodId method selector has been looked up, it is cached inside
	  the SmokeMethod Attribute.
	* The generation of the 'munged method names' in the Attributes is currently
	  wrong, and needs fixing.

2007-02-02  Richard Dale  <rdale@foton.es>

	* Improved the debugging output for the content of a QMetaObject
	* Added the qdbus/chat example
	* Made the classes generated by uics public
	* Added a rule for setting up ${UICS_PATH}

2007-31-01  Richard Dale  <rdale@foton.es>

	* Changed the uics code generation to use C# properties
	* Special case shortcut properties to create a QKeySequence
	* Added an '-x' option to the uics tool to generate a Main method
	  for testing purposes
	* Made QWidget.MiniumumSizeHint a method rather than a property
	  and changed the uics code generation to match.

2007-30-01  Arno Rehn  <arno@arnorehn.de>

	* Fixed off-by-one mistake when invoking signals in SmokeInvocation.cs
	  and qyoto.cpp

2007-30-01  Richard Dale  <rdale@foton.es>

	* Fixed regressions caused by adding signal return values
	* Added a QDBusVariant class and marshalling for it
	* The complexpong example still doesn't return a QDBusVariant value

2007-29-01  Richard Dale  <rdale@foton.es>

	* Added reply values when emitting signals
	* Some static methods were being dropped because they had the same
	  name as property names. So make the static methods start with a
	  lower case letter and keep them.
	* When marshalling a QDBusVariant, special case as a QVariant as it
	  doesn't exist in the Smoke library, but is needed for QtDBus support.
	* Added a not quite working qdbus/complexpingpong example

2007-29-01  Arno Rehn  <arno@arnorehn.de>

	* Fixed compiler options in examples to use -r instead of -addmodule

2007-28-01  Richard Dale  <rdale@foton.es>

	* Commented out the QMetaObject.InvokeMethod() call in the pong.cs
	  example as it causes a crash
	* Fixed bug where the name of a slot was being lost when passed to
	  Invoke slot as a temporary 'const char *' that was being deleted
	  before it could be used.
	* In the C# to C++ list marshaller the temporary list of 'void*'s
	  was not being deleted. If a C++ list element instance aleady has
	  a mapping onto a C# instance, then use that.
	* Added a Q_PROPERTY atttribute to C# properties, restored Q_SLOT
	  properties which were not being generated from slots labelled
	  Q_SLOTS.

2007-26-01  Richard Dale  <rdale@foton.es>

	* Added the qdbus/listnames example
	* Added the qdbus/pingpong example
	* When the type signature of a slot was being derived from the types of
	  the C# arguments, a C# string should map onto 'QString' and not 'string'

2007-25-01  Richard Dale  <rdale@foton.es>

	* QObject.Emit is now a property, rather than a method. For example:

		protected new ICannonFieldSignals Emit {
			get {
				return (ICannonFieldSignals) Q_EMIT;
			}
		}

		...

		Emit.forceChanged(currentForce);

	* Only add C# set properties for Q_PROPERTYs with a WRITE option
	* Added cannon game tutorial t12
	* Added tutorials t13 and t14
	* QWidget.SizeHint is no longer a property as it needs to be overriden in
	  subclasses.

2007-24-01  Richard Dale  <rdale@foton.es>

	* Q_PROPERTYs are now mapped onto C# properties, and the correponding set
	  and get methods removed from the api
	* QDomNodeList is no longer an ArrayList type
	* Added QList<QRgb> as a C# List<uint> type
	* QVariant.Value() and QVariant.FromValue() now work correctly with enums
	* The Enums in properties are now fully qualified with the classname
	* Fixed up the code for the t11 example
	* Added some more CMakeLists.txt files
	* Implemented callbacks to construct QVariants and to get values via
	  QVariant.FromValue() and QVariant.Value() when the type is greater
	  than QVariant::LastCoreType

2007-22-01  Arno Rehn  <arno@arnorehn.de>

	* Updated marshallers to work with generic types

2007-22-01  Richard Dale  <rdale@foton.es>

	* Add QApplicationExtras.cs, QCoreApplicationExtras.cs and QtExtras.cs
	* Fix bug in setting up argv array passed to QApplication constructor
	  pointed out by Arno.
	* Convert to generic types for marshalling QLists, QVectors and QMaps,
	  and use C# List<>s and Dictionary<>s.
	* Convert qint64 and qlonglong to C# longs, and quint64 and qulonglong to
	  C# ulongs.

2007-21-01  Richard Dale  <rdale@foton.es>

	* Split QVariant.cs and QDBusConnectionInterface in two files with partial
	  classes to make customisation easier to maintain.
	* Fixed bugs in the code generation for args with QStrings or QStringLists
	  inside template type.
	* operator methods '<<' and '>>' were being converted to static methods even
	  when the methods couldn't be operator methods in C# and should have been
	  either 'op_read()' or 'op_write()' in which case they should be instance
	  methods.
	* Fixed parsing in for Q_PROPERTY which meant that some methods in 
	  QToolBar.cs were lost.
	* Added a QVariant.FromValue() method
	* Removed QTextCodecPlugin.cs
	* Fixed build error in QSysInfo.cs

2007-17-01  Arno Rehn  <arno@arnorehn.de>

	* Split SmokeInvocation.cs into SmokeInvocation.cs and SmokeMarshallers.cs
	* Updated CMakeLists.txt to work with more variables

2007-16-01  Richard Dale  <rdale@foton.es>

	* Added missing QX11EmbedContainer and QX11EmbedWidget classes

2007-15-01  Richard Dale  <rdale@foton.es>

	* Change the names of the methods that setup callbacks from
	  AddFoobar() to InstallFoobar(), where Foobar() is the callback
	  being setup.

2007-14-01  Paolo Capriotti  <paolo.capriotti@gmail.com>

	* Ported most of the .NET 1.1 code to .NET 2.0
	
2007-13-01  Richard Dale  <rdale@foton.es>

	* Added a generically typed QVariant.Value() method
	* QDBusReply uses QVariant.Value()
	* Added a couple of methods using QDBusReply to QDBusConnectionInterface

2007-12-01  Richard Dale  <rdale@foton.es>

	* Change the cmake build to use gmcs rather than mcs
	* Added a QDBusReply class using a generic type
	* Added some missing methods to QDBusConnectionInterface

2006-12-07  Richard Dale  <rdale@foton.es>

	* Use QDate, QDateTime and QTime for dates and times, not the C#
	  DateTime class
	* Added missing QAccessible* and QFileSystemWatcher classes

2006-12-06  Richard Dale  <rdale@foton.es>

	* Regenerate the Qyoto classes against the Qt 4.2.2 headers
	* Split the classes into core, qdbus, gui, network, opengl, sql, svg
      and xml directories corresponding to the Qt modules.
	* Changed the CMakeLists.txt build file to match the new structure

2006-12-04  Arno Rehn  <arno@arnorehn.de>

	* Added marshallers for QMaps

2006-12-02  Arno Rehn  <arno@arnorehn.de>

	* Added marshalling function for QList<int>

2006-11-26  Arno Rehn  <arno@arnorehn.de>

	* Added marshall_ItemList and all DEF_LIST_MARSHALLER and
	  DEF_VALUELIST_MARSHALLER from qtruby.
	* Added a CMake file for compilation with CMake. Still keeping
	  the old makefile in case for some reason we need it again.

2006-10-23  Arno Rehn  <arno@arnorehn.de>

	* Marshalling ItemLists should now fully work. But we still need
	  many of the DEF_VALUELIST_MARSHALLER things.

2006-10-23  Arno Rehn  <arno@arnorehn.de>

	* Added more code for marshalling QLists. QList<T> return types
	  should now work for all QLists where T is not a primitive type.

2006-10-23  Richard Dale  <rdale@foton.es>

	* When a QMetaObject was constructed, the parent was wrongly being
	  set to the superclass of the superclass, rather than just the
	  superclass
	* If no Emit() method is found for a class, assume it doesn't have
	  any signals and don't include any in the QMetaObject for it.
	* Only look for methods marked Q_SLOT in the current class, and not
	  the superclasses when constructing a QMetaObject.

2006-10-22  Arno Rehn  <arno@arnorehn.de>

	* Currect return value for QyotoSmokeBinding::callMethod() where
	  it would return 'true' if metaObject() was overriden
	  (fixes QDockWidget bug)
	* Fixed some internal class names

2006-10-20  Richard Dale  <rdale@foton.es>

	* Added alloc_smokeqyoto_object() and free_smokeqyoto_object() f'ns

2006-10-19  Arno Rehn  <arno@arnorehn.de>

	* Fixed marshalling of QStringLists

2006-10-19  Arno Rehn  <arno@arnorehn.de>

	* Added support for marshalling C++-QStringLists to C#-ArrayLists
	  (not tested yet)

2006-10-19  Richard Dale  <rdale@foton.es>

	* Removed Qt3 Qyoto sources
	* Moved Qyoto.cs to the top directory, so that only autogenerated
	  classes are in the qyoto directory.
	* Added some non-working list marshalling code for QStringLists and 
	  QList<QVector> so that they can be used for getting QDBus to work
	* Removed assignment to the qApp global variable in the QCoreApplication
	  constructor as C# doesn't support downcasting.

2006-10-18  Richard Dale  <rdale@foton.es>

	* Enum return types were failing with an invalid cast error.
	  They are now created correctly with a Enum.ToObject() call.
	* Regenerated the QDBus* classes from the Qt 4.2 headers

2006-10-18  Arno Rehn  <arno@arnorehn.de>

	* Implemented a very ugly hack to construct a QMainWindow in C++ and set
	  the resulting smokeqyoto_object to the C#-instance. This fixes the
	  QDockWidgets not being movable.
	  Needs improvement!

2006-10-18  Arno Rehn  <arno@arnorehn.de>

	* Added a methodCache, so if a methodId has already been looked up it can
	  be retrieved from the methodCache.

2006-10-15  Richard Dale  <rdale@foton.es>

	* When there was more than one possible candidate for a method in the
	  Smoke library, the SmokeInvocation code was just choosing the first one
	  it found. Added some code to select the one that matched the SmokeMethod()
	  type signature annotation. Fixes problem reported by Arno Rehn.

2006-10-06  Arno Rehn  <arno@arnorehn.de>

	* Fixed some problems with enums in uics.
	* Fixed problem where SetupUi() and RetranslateUi() weren't accessible
	  due to a missing 'public'

2006-10-06  Arno Rehn  <arno@arnorehn.de>

	* Copied over some fixes from QtRuby:
		* Fixed a bug in slot return values where they were only
		  working when a signal was emitted in Ruby, and not when
		  a C++ signal was emitted. The zeroth element in the array
		  of 'void*'s passed to qt_metacall() was being overwritten
		  by a pointer to the result of the slot invocation. Instead
		  the pointer in the zeroth element is now correctly deref'd,
		  and the result put where it points to.

2006-10-06  Arno Rehn  <arno@arnorehn.de>

	* Implemented Q_CLASSINFO and Q_SCRIPTABLE attributes.
	* Fixed an error in the automatic signature generation when return type was
	  void.

2006-10-04  Arno Rehn  <arno@arnorehn.de>

	* Now slot return values should work, but didn't test it.

2006-10-03  Arno Rehn  <arno@arnorehn.de>

	* Fixed crash when constructing a QSpacerItem (may need improvement)
	* Fixed crash when GetSmokeObject() was called without a proper InstanceHandle

2006-09-23  Richard Dale  <rdale@foton.es>

	* Fixed crash when a class didn't have any signals defined

2006-09-23  Arno Rehn  <arno@arnorehn.de>

	* The signatures for slots and signals are now autogenerated, so it's not necessary
	  anymore to specify them by hand. It's still possible, though.
	* The signal signatures are now stored in a Hashtable, too.

2006-09-22  Arno Rehn  <arno@arnorehn.de>

	* The return type of a slot is now being added to the definition in the QMetaObject
	* Added a struct which holds the MethodInfo, the signature and the return type of a slot.
	  This struct is now the 'Value' in the Slot-Hashtable

2006-09-17  Richard Dale  <rdale@foton.es>

	* Applied patches from Arno Rehn:
		* Added the code from QtRuby to marshall slot return types
		* TODO: add code to parse the return type in a Q_SLOT() attribute, and add it
		  to the slot's definition in the QMetaObject

2006-09-11  Richard Dale  <rdale@foton.es>

	* Applied patches from Arno Rehn:
		* Fixed a bug in emitting signals where the arguments were being
		  wrongly copied from the C# argument array to the smoke stack
		  with an 'off by one' error.
		* A Qt.dll is now built by the makefile instead of all the sources
		  always all being compiled.

2006-08-24  Richard Dale  <rdale@foton.es>

	* Applied patches from Arno Rehn:
		* Prevent crash when a custom slot was defined with no arguments
		* Fix crash when on application exit by deleting the qApp
		  QApplication instance

2006-07-16  Richard Dale  <rdale@foton.es>

	* Regenerated the C# sources from the Qt 4.2 headers

2006-06-08  Richard Dale  <rdale@foton.es>

	* Add SmokeMethod() attribute to destructors
	* More list arguments are now C# ArrayLists

2006-06-09  Paolo Capriotti  <paolo.capriotti@gmail.com>

	* Added example t10.

2006-06-09  Paolo Capriotti  <paolo.capriotti@gmail.com>

	* Added example t9.

2006-06-09  Paolo Capriotti  <paolo.capriotti@gmail.com>

	* Added example t8. It almost works.
	* Fixed resolve_classname.
	* Added IDisposable to QObject's parents.
	* Fixed off-by-one error when handling arguments in
	  SmokeInvocation.InvokeMethod.

2006-06-08  Richard Dale  <rdale@foton.es>

	* Example t7 now works, which means that both custom slots
	  slots and signals work.
	* At present an Emit() method and signals interface is
	  needed for classes which don't have any custom signals
	* The example wasn't working because the slots and signals
	  had return types of 'void', and slot/signal return values
	  haven't been implemented yet.

2006-06-08  Paolo Capriotti  <paolo.capriotti@gmail.com>

	* The overriden MetaObject is now called in place
	  of the qt version.
	* make_metaObject didn't create the parent meta object
	  correctly. Modified it so that it calls the parent version
	  of metaObject().
	* Slot arguments are now handled correctly.
	* Added static IsSmokeClass method to Qyoto.

2006-06-08  Richard Dale  <rdale@foton.es>

	* Added the QtDBus classes

2006-06-07  Paolo Capriotti  <paolo.capriotti@gmail.com>

	* Changed all occurences of Qt namespace to Qyoto in qyoto.cpp
	* Restored the _smokeObject field in QObject.

2006-06-06  Richard Dale  <rdale@foton.es>

	* Added a Q_SCRIPTABLE attribute for dbus support
	* The Qt class needs to be a MarshallByRefObject instance for
	  transparent proxies to work with its subclasses
	* Added a Q_CLASSINFO attribute for dbus support

2006-06-05  Richard Dale  <rdale@foton.es>

	* QObject is now a subclass of Qt, as suggested in the previous
	  commit.
	* The Qyoto classes are now in a namespace called 'Qyoto' rather
	  than 'Qt'. It would probably be best to make QObject.cs a sub
	  class of Qt, to avoid needed to prefix SLOT() and SIGNAL() with
	  'Qt.' in QObject subclasses.
	* Added QObject.MetaObject() as specified by Paolo for custom slots
	  and signals.
	* Fixed the 'Hello.cs' example to work with the new namespace

2006-06-02  Richard Dale  <rdale@foton.es>

	* Invocations of signals via the qt_metacall() C function
	  are now special cased, and QMetaObject::activate() is used
	  to call them. C# slots are still invoked via the InvokeSlot
	  class.
	* Fixed bug when emitting signals for pointer arg types
	* setMocType() now works with reference types when there
	  in no corresponding value type in the Smoke lib.

2006-05-31  Paolo Capriotti  <paolo.capriotti@gmail.com>

	* Avoided some useless method calls to handle qt_metacall
	  (removed InvokeMetaCallMethod and QyotoMetaCall)
	* Fixed QMetaObject creation
		* data and stringdata are now copied in C++ code to prevent 
		  garbage collection.
		* Changed data in QMetaObject to an array of uint instead of int.
	* Removed the void** marshaller since it was unneeded.
	* Partially implemented custom slot invocation.
	* Added tutorial 7 (doesn't work yet).

2006-05-31  Richard Dale  <rdale@foton.es>

	* Moved the tutorial examples to examples/tutorial

2006-05-31  Paolo Capriotti  <paolo.capriotti@gmail.com>

	* Added a void** marshaller in handler.cpp (needed for qt_metacall).
	* Decommented InvokeSlot and ported to qt4 (invokeSlot() method still empty).
	* Added some code to intercept a qt_metacall and invoke the corresponding slot (doesn't work yet).
	* Rewritten Hello.cs to test custom slot invocation.

2006-05-30  Richard Dale  <rdale@foton.es>

	* Applied patch from Arno Rehn for bringing the Qt3 version of Qyoto
	  up to date with the Qt4 one wrt Paulo's changes

2006-05-29  Richard Dale  <rdale@foton.es>

	* More fixes from Paulo:
	* To avoid virtual method dispatch resulting in infinite loop, the
	  meta object instance is now created in c++ code using smoke (just as
	  in qtruby).
	* Qyoto.GetMetaObject now works for Qt types as well
	* Decommented code in set_obj_info. This function is used by the
	  return value marshaller for non-primitive types and by
	  make_metaObject.

	* Added patch from Paulo Capriotti to create a QMetaObject at runtime
	  for a Qyoto class with custom slots and/or signals

2006-05-26  Richard Dale  <rdale@foton.es>

	* Added code from Arno Rehn to access obtain the return value of
	  a classes Emit() method as an interface and obtain the C++ signal 
	  type signatures and set them up in HashTables with a top level
	  table with the classes as keys, containing sub tables with the
	  C++ signatures as keys which map onto the correponding C# 
	  MethodInfo as a value
	* Some fixes from Paolo Capriotti:
		* Added fix for a crash in SmokeInvocation.cs when a class with
		  virtual methods wasn't a subclass of Qt
		* The code for emitting signals now works with Qt4
		* The code in QObject.cs to set up the transparent proxy Q_EMIT 
		  for an instance's signal interfaces now works.

2006-05-26  Richard Dale  <rdale@foton.es>

	* The Hash table to get a marshaller given a type name wasn't working.
	  Thanks to Paolo Capriotti for the fix.

2006-04-21  sedwards

	* C# bindings roughly converted from Qt3 to Qt4. (doesn't work yet).

2006-05-01  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Regenerated the Qt4 *.cs sources

2006-02-14  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added a TODO list, and this ChangeLog to the project

