2010-08-17  Richard Dale  <richard.j.dale@gmail.com>

    * Don't use rb_during_gc() to skip virtual method callbacks during virtual
      method callbacks as it's probably a bad idea and causes build problems
      with old ruby interpreters.

2010-06-22  Richard Dale  <richard.j.dale@gmail.com>

    * Added snakecase versions of the methods in the Qt::DBusConnectionInterface
      class
    * Fixed bug with missing QVector<double> marshaller. Fixes problem reported
      by Sylvain Sauvage http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=586672
      Thanks for the bug report.

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

	* Qualify all Qt includes with the module name, as not doing so is a bad
	  idea IMHO.

2010-03-14  Richard Dale  <richard.j.dale@gmail.com>
	
	* The QtDBus classes weren't being correctly initialized as the count of 
	  classes was being taken from the QtSvg smoke lib. Thanks to Paulo 
	  Capriotti for finding the bug.

2010-03-07  Richard Dale  <richard.j.dale@gmail.com>
	* Fixed Qt::Object properties that were no longer working. Fixes bug 229784
	  reported by ruby.twiddler
	* Drag and drop events in Plasma applets weren't being handled correctly.
	  Fixes problem reported by Robert Riemann
	* QtRuby overrides public_methods(), singleton_methods() and 
	  protected_methods(), but omitted the optional 'all' argument. Thanks to
	  Paolo Capriotti for the fix and bug report.

2009-12-11  Richard Dale  <richard.j.dale@gmail.com>

    * Qt::DynamicPropertyChangeEvents were not being created correctly. Thanks
      to Snufkin for reporting the bug.

2009-11-13  Richard Dale  <richard.j.dale@gmail.com>

    * The QtTest module expects test slots to be private which isn't possible
      in QtRuby, so add a 'private_slots' method to declare them. For example:

        class MyFirstTest < Qt::Object
            private_slots   :initTestCase, :myFirstTest, 
                            :mySecondTest, :cleanupTestCase

2009-11-12  Richard Dale  <richard.j.dale@gmail.com>

    * The Qt::SizePolicy.horizontalStretch= method wasn't working with a Smoke
      library created with the new generator as the type 'unsigned char' wasn't
      recognized. Thanks to Stefano Crocco for reporting the bug.
    * Applied a patch from Davor Ocelic. Here's an overview of the changes:


        ruby/qtruby/src/handlers.cpp:

        Added { "unsigned char*", marshall_ucharP } so that conversion
        from String to "unsigned char*" would work. Qt code doesn't
        have unsigned char*, but Smoke seems to internally convert
        uchar* to unsigned char*.


        ruby/qtruby/src/Qt.cpp:

        The code at the place of patch checks whether a method is overriden
        in Ruby. But during GC, it's not allowed to execute Ruby code anyway,
        so the patch removes this check altogether. (In rare, but existing
        situations, this check itself lead to new object allocation, crashing
        the application).

        (New info: the function we've used to check if it's running during
        GC or not seems to be Ruby 1.9 specific, so a simple compatibility
        for 1.8 should be added before committing).


        ruby/qtruby/src/lib/Qt/qtruby4.rb

        1) Added GC.disable around line of code that says: "@block = block".
        This makes a difference between being and being not able to run
        with GC.stress= true. Reason unclear, comments appreciated.

        2) Extended typename =~ /^(?:u?char\*)$/ checks to support 
        unsigned char.

        3) Skip "def instance_exec" if it is already defined
        (it is in Ruby 1.9)

    * Thanks to Davor for the patch
    * Added a patch from 'Ruby Twiddler'. Qt::DBusInterface.call() didn't work
      when the first argument is an enum. For example:

        iface = Qt::DBusInterface.new(SERVICE_NAME, "", "",
        Qt::DBusConnection.sessionBus)
        msg = iface.call(Qt::DBus::BlockWithGui, "somemethod", param)
        p msg   # => nil
        reply = Qt::DBusReply.new(msg)  # => Error!
    * Thanks to Twiddler for the patch

2009-08-19  Richard Dale  <richard.j.dale@gmail.com>
    * Added a patch from Youhei Kondou to make the is_a? and kind_of? methods
      use the C++ class ancestors obtained from the smoke libary

2009-07-24  Richard Dale  <richard.j.dale@gmail.com>
	* Replace the obsolete STR2CSTR macro with StringValueCStr to make QtRuby
	  compile with Ruby 1.9.2. Thanks to Youhei Kondou for the patch.

2009-07-21  Richard Dale  <richard.j.dale@gmail.com>
	* Revert a commit made by 'divide' some time ago. It was a hack to allow
	  primitive types to be passed as arguments where the expected arg type
	  was a Qt::Variant. However, it subverts the 'munged method name' scheme
	  of fast overloaded method resolution because for every method argument of
	  type '#' (a class), it adds another of type '$' (a primitive type). So 
	  with that scheme we might as well have only two of the munged method 
	  types instead of three. Sometime we need to add support for C++ implicit
	  constructors in resolving overloaded methods at runtime, but that is a
	  really hard problem. In the meantime I think it is best to add support
	  for implicitely converting args to Qt::Variants on a case by case basis,
	  such as was done for the QtDBus and Plasma Data Engine apis.

2009-06-23  Richard Dale  <richard.j.dale@gmail.com>
	* In smokeruby_mark() layouts owned by QWidgets or QGraphicsWidgets are 
	  now marked. Items owned by QLayouts or QGraphicsLayouts are also marked.
	  This fixes some premature garbage collection problems in Plasma Applets,
	  reported by David Palacio.

2009-06-18  Richard Dale  <richard.j.dale@gmail.com>
	* Made Qt::ItemSelection Enumerable

2009-04-24  Richard Dale  <richard.j.dale@gmail.com>
	* The resolve_classname() function was not resolving names for QObject
	  derived classes when the class wasn't in the base Qt smoke library.
	  For instance, this meant that a Plasma::Applet was not being resolved to
	  a Plasma::PopupApplet to match the underlying C++ type.

2009-04-17  Richard Dale  <richard.j.dale@gmail.com>
	* When Qt::StandardItemModel#setItemPrototype was used with a 
      Qt::StandardItem it crashed because the clone() method was using 
      Object#clone. So special case the clone() method. Thanks to Stefano Crocco
      for reporting the bug.

2009-04-07  Richard Dale  <richard.j.dale@gmail.com>
	* The ActiveRecord based model classes were setting changed values in the 
	  'attributes' and then saving the changed instance, like this
 
	  foo.attributes['my_att'] = value
	  foo.save

	  However, this no longer works with ActiveRecord, and the instance can 
	  be changed more directly like this
	  
	  foo['my_att'] = value
	  foo.save
	* QtRuby wasn't building on Mac OS X with a version of Qt built without 
	  QtDBus support, so add some #ifdefs to fix that

2009-03-24  Richard Dale  <richard.j.dale@gmail.com>
	* Raised the QtRuby version to 2.0.3 for the RubyForge release

2009-03-20  Richard Dale  <richard.j.dale@gmail.com>
	* Remove 'LIBRARY' from this line in qtruby/src/CMakeLists.txt:

	  install(TARGETS qtruby4shared 
	          LIBRARY DESTINATION 
	          ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX} )

	  It was causing problems with a configuration error when building QtRuby
	  on Windows. Thanks to David Palacio for reporting the problem

2009-03-19  Richard Dale  <richard.j.dale@gmail.com>
	* The rbqtap was calling 'each' on a string which no longer works in Ruby
	  1.9.1 as they aren't Enumerable. So use split instead so that the code
	  works on both Ruby 1.8.x and 1.9.1. Thanks to Youhei Kondou for the bug
	  report and fix.
	* The inspect method for Qt::SizePolicy instances was wrong

2009-03-16  Richard Dale  <richard.j.dale@gmail.com>
	* Make the dispose() method always return nil. Otherwise, when an instance
	  is deleted from within irb, it makes irb crash when it tries to run
	  run inspect() on the newly deleted value returned by dispose(). Thanks
	  to Stefano Crocco for finding the problem.
	* A problem has been found with QtRuby when it is run with Ruby 1.9.1
	  and GC.stess is true. Thanks to Davor Ocelic for reporting it.
	  In the smokeruby_mark() function called during garbage collection, 
	  any virtual methods which are called on the instances being checked 
	  could have overriden by Ruby methods.  So the Wt::Ruby runtime uses 
	  'respond_to()' to find out whether they have been overriden.
	  However, this involves calling 'rb_intern()' on the method name,
	  which means memory could be allocated, giving an error when running under
	  GC.stress mode. So workround it by pre-allocating any strings with
	  rb_intern() for all the C++ methods used in smokeruby_mark()

2009-03-13  Richard Dale  <richard.j.dale@gmail.com>
	* Improved the rbqtapi '-s' option

2009-03-11  Richard Dale  <richard.j.dale@gmail.com>
	* Rewritten the rbqtapi command line tool to simplify the code
		- Added a '-r' or '--require' option for specifying QtRuby extension.
		  This means that there is no longer a need for different sym links to
		  the script for each QtRuby extension.
		- One or more class names can be specifed. If no class name is given
		  it means that all of the classes in the loaded QtRuby extensions 
		  should be searched
		- A '-s' option attempts to show matching methods with Ruby types
	* Removed the rbqtsh program as it was never really very useful
	* The 'Type' enum was not working with the Qt::Graphics* classes, and so
	  special case them as Ruby constants

2009-03-10  Richard Dale  <richard.j.dale@gmail.com>
	* Change the license text in the QtRuby headers to LGPL

2009-03-02  Richard Dale  <richard.j.dale@gmail.com>
	* Add method_missing and const_missing handlers for top level modules such
	  as Soprano

2009-02-25  Richard Dale  <richard.j.dale@gmail.com>
	* Restored the note in the COPYING file about having permission from 
	  Trolltech, now Qt Software, to use the 'Qt' in QtRuby.

2009-02-07  Richard Dale  <richard.j.dale@gmail.com>
	* Add a Qt::dynamic_cast method as a synonym with a less clunky name for 
	  Qt::Internal.cast_object_to

2009-02-04  Richard Dale  <richard.j.dale@gmail.com>
	* In Ruby 1.9.1 the arity of a block with no arguments is 0, whereas in 
	  Ruby 1.8.x it is -1. This meant that blocks passed to QtRuby 
	  constructors with no args weren't working with Ruby 1.9.1

2009-02-02  Richard Dale  <richard.j.dale@gmail.com>
	* Set up a RUBY_VERSION macro to use to test for whether QtRuby is being 
	  built for Ruby 1.9 or not. Add patches from Mr Napalm for building with
	  Ruby 1.9, for the new 'per string' encoding. Also add conditional code
	  for whether to use the new rb_frame_callee() function or the old
	  rb_frame_last_func() one.

2009-02-01  Richard Dale  <richard.j.dale@gmail.com>
	* The construct_copy() function was using the full classname of the class
	  to construct which meant that it didn't work with classnames containing
	  '::' scope operators. So strip out the scope part of the classname to
	  create the consructor name.
	* Make Qt::Internal#try_initialize catch a ':newqt' symbol rather than a 
	  string.

2009-01-14  Richard Dale  <richard.j.dale@gmail.com>
	* For the enum values whose names clashed with Ruby classes, make them
	  Qt::Enums instead of just Fixnums

2009-01-13  Richard Dale  <richard.j.dale@gmail.com>
	* Upped the QtRuby version number to 2.0.0
	* Special cased some constants whose names clashed with Ruby classes. 

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. Fixes a crash in a Qt::Image destructor reported by David
	  Palacio

2008-12-18  Richard Dale  <richard.j.dale@gmail.com>
	* Added another patch from Davor Ocelic for Ruby 1.9 compatible RSTRING 
	  usage - thanks Davor

2008-12-12  Richard Dale  <richard.j.dale@gmail.com>
	* When resolving overloaded methods with 'uchar*' and 'const uchar*' arg
	  types prefer the non-const version of the arg. Thanks to Davor Ocelic
	  for explaining why this was a good idea in the case of the Qt::Image
	  constructors.
	* Revert the recent change for marshalling 'unsigned char*' types which
	  expected them to be null terminated. After more thought it is pretty
	  likely they won't be null terminated because if they were they would
	  have been defined as just 'char *' instead. It better to have a clear
	  message saying they aren't supported and need special casing, rather
	  than needing to track down possible random buggy effects.
	* Added Davor Ocelic's patch for Ruby 1.9 compatible RSTRING usage and
	  improved instructions for building QtRuby without KDE.
	* When an overriden virtual method with a non-const QVector/QList argument
	  was called, such as Generator.openDocument() in Okular, the Ruby values
	  in the Ruby Array were not being converted back to the values in the
	  C++ list after the method call. Thanks to David Palacio for the bug
	  report.

2008-12-11  Richard Dale  <richard.j.dale@gmail.com>
	* Make some changes from the patch at 
      http://napalm.sf.cz/qt4-qtruby-ruby1.9.patch to make it easier to port
	  qtruby to Ruby 1.9. Thanks to Davor Ocelic and Mr Napalm.

2008-12-10  Richard Dale  <richard.j.dale@gmail.com>
	* Special case the Qt::Image.bits() method. Use the const variant so that
	  Qt doesn't make a deep copy. Is that what Davor Ocelic and David Palacio
	  would like it to do?
	* For other uses of 'uchar *' return types add a marshaller, hoping that
	  will be null terminated.
	* Add a Qt::Image.scanLine() method

2008-12-09  Richard Dale  <richard.j.dale@gmail.com>
	* Added an ancestors() method to Qt::Base that returns an Array of the
	  super classes of a class in the Smoke library. For instance:

		irb(main):001:0> Qt::Widget.ancestors
		=> [Qt::Widget, Qt::Object, Qt::PaintDevice, Object, Kernel]

	* Fixed regression caused by adding to Qt::Object.connect() the feature
	  to connect an arbitrary ruby method to a signal. It was causing the
	  standard three argument form of connect() to not work.
	* Renamed the QHash of smoke index against class name as 'IdToClassNameMap'
	  instead of 'classname'.
	* The child items of a QGraphicsItem are marked as not needing garbage
	  collection of they have corresponding ruby instances.

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

	* From Bartosz Wadolowski (thanks for the patch):

	unsigned char* marshalling in qtruby didn't work. The patch works as char* 
	case does - I simply copied code and added one casting.
	It also fixes method matching with string argument in qtruby4.rb. In
	cases when method could take constant or regular (unsigned)char
	pointer Qt::Internal.checkarg was returning the same value. Now in
	case of constant arguments it returns lower value. I also made this
	part of code a little bit more readable.
	Those changes made possible to use those QImage constructors and
	probably some other methods:

	  QImage ( uchar * data, int width, int height, Format format )
	  QImage ( const uchar * data, int width, int height, Format format )
	  QImage ( uchar * data, int width, int height, int bytesPerLine, Format 
               format )
	  QImage ( const uchar * data, int width, int height, int bytesPerLine,
			  Format format )

	IMPORTANT NOTE:
	Some Qt/KDE objects use Ruby String*, passed as (unsigned )char*
	method argument, as internal buffer/array(call it as you like). In
	those cases programmer need to make sure that Ruby String object is
	not being garbage collected or changed(in most cases) for the time its
	being used by Qt/KDE object. It is also quite possible that Qt/KDE
	object will change Ruby String (or rather its internal C char array).

2008-11-24  Richard Dale  <richard.j.dale@gmail.com>
	* Added a DEF_MAP_MARSHALLER() macro for defining marshallers for
	  QMaps with QString keys and value types as the values
	* The YAML library was adding a y() method to Kernel, which was messing
	  up the inspect() methods for Qt::Rects and Qt::RectFs. So instead of
	  calling y(), call self.y() instead. Thanks to Stefano Crocco for the
	  bug report and fix.

2008-11-17  Richard Dale  <richard.j.dale@gmail.com>
	* Comparisons between Qt instances and nil were causing QtRuby to
	  crash. Fixes bug reported by Stefano Crocco.

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

	* Rename get_VALUEtype() as value_to_type_flag()
	* Change the inspect() method for Qt::Rects and RectFs to use the
	  Qt4 convention of x, y, width, height
	* module_method_missing() had the Qt:: module hard wired into it, and
	  so constants in other modules wouldn't be found

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

	* Argument types of 'unsigned short' were not being matched in the 
	  overloaded method resolution code which was causing a Qt::KeyEvent
	  constructor to fail. Fixes a problem reported by Stefano Crocco.

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

	* The disposed? method was round the wrong way, and true if an instance
	  had not been disposed. Thanks to Stefano Crocco for finding the bug.

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

	* The new qobject_cast() method was wrongly changing the smoke classId of
	  the Ruby source instance. This was messing up method calls such as
	  empty?, and fixes a problem reported by Stefano Crocco (thanks again
	  Stefano for all these reports!).

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

	* Added a qobject_cast() method that uses qt_metacast() to cast one 
	  instance of QObject to another. This allow the KTextEditor:: 
	  interface classes to be used. Fixes a problem reported by Stefano
	  Crocco. Example usage:

		doc = KTextEditor::EditorChooser.editor('katepart').create_document( nil)
		annotator = doc.qobject_cast(KTextEditor::AnnotationInterface)
	* Special case the Qt::SignalMapper#mapping and Qt::SignalMapper#setMapping
	  methods so they work with both Qt::Object and Qt::Widget arguments as it
	  confuses the method overloading resolution code at present.
	* Add lower case/underscore methods as well as camel case for special cased
	  methods

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-07  Richard Dale  <richard.j.dale@gmail.com>

	* Fix the Qt::CoreApplication constructor so it handles the ARGV array
	  correctly

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

	* The code to look up the types of slot arguments was failing for types
	  in the KTextEditor library

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

	* Qt::Variant.fromValue() and Qt::Variant.value() now both work correctly
	  with custom types, after a regression in the change to modular smoke. 
	  It should no longer be necessary to use qVariantValue() or 
	  qVariantFromValue().
	* In the smoke library method calls for pure virtual methods were not
	  being generated, only callbacks to override them. However, that
	  meant that interfaces which were based on classes with pure virtual
	  methods, with private implementation classes wouldn't work. This fixes
	  a problem reported by Stefano Crocco where he found the ktexteditor
	  ruby extension didn't work.

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

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

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

	* Fixed the Qt::Application constructor so that it can subclassed. Thanks
	  to Stefano Crocco for reporting the bug

2008-07-13  Cyrille Berger  <cberger@cberger.net>
  * Reverting kross2smoke to use a pointer, since that what kross use for now.

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

	* Remove the smoke2kross() function as it isn't needed anymore. Change
	  the kross2smoke() function so that it assumes Kross will return a 
	  pointer to a pointer, instead of just a pointer to the C++ instance.

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

	* Change the layout of the smokeruby_object struct so that the ptr to
      the C++ instance is at the start. This should make it easier for
	  QtRuby to interoperate with Kross
	* 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.
	* In the GC mark function the tests for a QObject type had gone missing, so
	  restore it.

2008-07-11  Cyrille Berger <cberger@cberger.net>

	* Make it possible to call set_qtruby_embedded from ruby.

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

	* Fixed bug in the rbuic4 tool where a QPixmap constructor was not being
	  converted to ruby correctly. Thanks to Henrik Tikanvaara for reporting
	  the error.

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

	* When a ruby value was marshalled to C++, and the actual type of
	  the C++ instance was cast to the type of the return value, it
	  was 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. This fixes the strange error messages in
	  Plasma applets like the clock, about zero pixmap sizes and QPainter
	  problems.

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

	* Special case QDBusVariants in SlotReturnValue and make it behave
	  like the moc. This makes the complexpingpong example work.
	  Maybe more things need to be special cased, like in
	  SigSlotBase::prepareReturnValue().
	* Add special cases for lists and maps to
	  SigSlotBase::prepareReturnValue().
	* Add 'QList<QObject*>' to the handlers array.
	* Small fixes to complexping.rb.

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

	* Change prepareQtReturnType from a standalone function to a method
	  in the SigSlotBase class. It should work with int types, and fix
	  the bug reported by Stefano Crocco.

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

	* Fix bug in resolve_classname_qt() caused by missing break statments
	* Move list marshaller macro definitions to the top of the 
	  marshall_macros.h header, and add a DEF_HASH_MARSHALLER macro
	* Add a set_qtruby_embedded() function to qtruby for use with plugins
	  like plasma

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

	* Fix bug reported by Stefano Crocco. qt_metacall tried to write
	  data via an uninitialized pointer.

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

	* Partly fix bug reported by Stefan Crocco - this explains why a slot
	  return value of type QPoint was nil. However, it's value is wrong,
	  and the problem with a QString return value crashing is still not
	  explained.

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

	* Remove unnecessary special casing for Qt::TextEdit::ExtraSelection,
      just make it an ording QtRuby class instead of a Struct, and add a 
	  marshaller for QList<QTextEdit::ExtraSelection>

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

	* Since every smoke module defines a class 'QGlobalSpace', don't rely
	  on Smoke::classMap and search every smoke module for methods of this
	  class.

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

	* Pass the resolve_classname() functions a 'smokeruby_object *' so that
	  they can change the smoke lib and classId on it.
	* Added Qt::KeySequence inspect and pretty_print methods

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

	* When resolve_classname_qt() was given a class outside the Qt smoke
	  library, such as KAction, it was failing to resolve it. This was
	  because it was only looking in the smoke library of the arg type
	  declared in the method. Hence, an arg type of 'QAction' was not
	  being resolved to 'KAction'. Thanks to Stefano Crocco for reporting 
	  the bug.

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

	* The rb_id2name() function has changed to return a 'const char *'
	  in Ruby 1.8.7, which meant the QtRuby wouldn't compile. So attempt
	  to make it build on both 1.8.6 and 1.8.7. Thanks to Stefano Crocco
	  for reporting the bug.

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

	* Move the template based List marshallers to a new header
	  marshall.macros.h and add marshallers for QLinkedList types

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

	* Make the template based QList marshallers more DRY by moving them
	  to marshall_complex.h instead of copied into every extension.

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

	* Make it possible to include marshall_basetypes.h so that korundum
	  can build

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

	* Updated qtruby.cpp's header.

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

	* Fixed bug in the FindAllMethods() f'n, and made the debug logging work
	  when a method couldn't be found in do_method_missing()

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

	* The enum Qt::Process::StandardError was clashing with the exception of
	  the same name, so add a constant to the Qt::Process class instead. 
	  Thanks to Stefano Crocco for reporting the bug.

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

	* Fixed dumpCandidates().

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

	* The method selector cache function had an off by one error, which meant
	  it assumed there was one more argument to a method than there actually
	  was. This caused a crash. Why such a major problem hasn't caused any
	  problems before is a mystery - it wasn't a result of the modular smoke
	  changes.
	* qtruby4.rb calls Kernel#y instead of Qt::Point#y on inspect and 
	  pretty_print when the yaml gem is loaded.
	  The attached patch fixes the problem by calling Qt::Point#y and 
	  Qt::PointF#y explicitly. Thanks to Paolo Capriotti for the bug report
	  and fix.

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

	* Bring qtruby.cpp up to date with the branch-version.

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

	* Rename the 'modules' global variable qtruby_modules to reduce the chances
	  of a name clash

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

	* Added a marshaller for references to unsigned ints
	* Added initialization for the various KDE::ConfigSkeleton classes

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

	* Fixed a couple of differences between C++ code generation and Ruby.
	  The variable names weren't being stripped of any leading 'q' or 'k',
	  and the brush initialization hadn't been updated for Qt 4.4.

2008-04-22  Sebastian Sauer <mail@dipe.org>

	* Fix reported crash on shutdown if QtRuby is used embedded.

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

	* Special case the KDE::DateTime and KDE::TimeZone classes so that
	  nested classes, such as KDE::DateTime::Spec work with them. 
	  TODO: make this work automatically without needing extra code.

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

	* When matching arg types, strip off an '::Ptr' or 'Ptr' at the end
	  of the type. This is to ensure that something like a KDE::Service
	  ruby instance can be passed to a method expecting a type of
      KService::Ptr

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

	* Added a QTRUBY_FUNCALL2 macro. If QtRuby is built with the
	  -DRUBY_EMBEDDED option, then the rb_funcall2s for invoking
	  virtual method callbacks and slot invocations in wrapped with
	  a rb_protect() call. Otherwise, rb_funcall() is called directly
	  and any uncaught Ruby exceptions will terminate the app.
	* Borrowed a function from the kross code to put out an error message 
	  and stacktrace on stderr for the current exception, when qtruby
	  has been compiled with the embedded option.

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

	* Change the way the 'MocArgument*' structs are created, instead
	  building them up in a Ruby Array, use a QList<MocArgument*>.
	  Move all the code to C/C++ and don't call Ruby anymore.
	* Add QTRUBY_INIT_STACK and QTRUBY_RESTORE_STACK macros based on
	  the SWIG_INIT_STACK and SWIG_RESTORE_STACK macros. If QtRuby is
	  compiled with a '-DRUBY_EMBEDDED' option, then before each virtual
	  method callback and slot invocation call, which isn't nested
	  within another, call RUBY_INIT_STACK.
	* This fixes a problem with Ruby Plasmoids where the Ruby runtime was
	  giving sys stackerror exceptions because the stack underflowed
	  relative to where it was when the krubypluginfactory was loaded.
	* Add more checking for Qnil in the marshallers for primitive types
	  to make the runtime more robust. 
	* Added some more range=(Range) methods as synonyms for 
	  setRange(Integer, Integer)
	* Changed the examples to use range=
	* Added a rbplasmaapi command line tool for introspecting the Ruby api

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

	* Added rb_protect() wrappers around virtual method callbacks and
	  slot invocations. When there is a Ruby exception, the app no
	  longer terminates which is useful for Plasma applets.

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

	* Ensure the class and module names in rbuic4 generated code
	  start with an upper case letter, even if they didn't in the
	  .ui file

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

	* Updated the rbuic4 to be in line with the Qt 4.4 uic code
	* Added a '-k' or '-kde' option to the rbuic4 tool, used in
	  conjunction with '-x' to generate a KDE app korundum4 test stub

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

	* Qt::TimeLine.setFrameRange() can now be called like this:
		time_line.frameRange = 0..90
	* Qt::Timer.singleShot can now be called with a block:
		timer = Qt::Timer.singleShot(5000, obj) { puts "In a block" }
	* Thanks to stefo on #kde-bindings for both suggestions
	* Added a few more 'range=' methods
	* Fixed range setters so that both 1..10 and 1...10 work properly

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

	* Added a QList<QTextEdit::ExtraSelection> marshallers as requested
	  by volty on the #qtruby irc channel. Qt::TextEdit::ExtraSelection
	  is a Ruby Struct with cursor and format fields.

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

	* Attempt to improve the marshalling of WIds and assume they are
	  either signed ints (Mac OS) or signed longs.

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

	* Fixed a bug in constructing Qt::Variants with custom types such
	  as Soprano::Statement
	* Added a Soprano:: namespace

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

	* When a method call began or ended with an underscore, and it
	  was missing from a qtruby instance, it caused ruby to loop,
	  rather than report the method as missing. Thanks to Daniel 
	  Brumbaugh Keeney for reporting the bug.

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

	* Make symbolic links to rbqtapi as rbqt3api, rbqt4api, rbkdeapi 
	  and rbkde4api

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

	* Added some marshallers for new Qt 4.4 QList types

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

	* The QModelIndex::internalPointer() method was returning nil, as
	  as result of the code change attempting to return nil if the C++
	  pointer is 0. Thanks to CyrilleB for reportin the error

2008-02-18  Richard Dale  <rdale@foton.es>

	* Ignore the WebCore:: and std:: namespaces when loading classes
	* Added marshallers for the WebKit QList types

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

	* The Qt::Polygon and Qt::PolygonF classes had no means of getting
	  the array of Qt::Points that they hold. Added count() and size()
	  methods and made the classes Enumerable, so this is now possible:

	  irb(main):002:0> poly = Qt::Polygon.new([Qt::Point.new(1,2),
Qt::Point.new(3,4)])
	  => #<Qt::Polygon:0xb5ee3094>
	  irb(main):003:0> poly.each {|t| p t}
	  #<Qt::Point:0xb5ee0510 x=1, y=2>
	  #<Qt::Point:0xb5ee018c x=3, y=4>

	* Thanks to Sylvain Sauvage for reporting the problem on the Korundum
help forum

2007-11-21 �    Sebastian Sauer <mail@dipe.org>

	* Fixed crash on shutdown of Ruby cause of a partly destroyed
	  pointer_map QHash.

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

	* Slot arguments types of 'uint', 'long' and 'ulong' weren't working.
	  Thanks to maniel for the bug report.
	* When calling a slot directly, it wouldn't work when then slot had
no
	  arguments
	* Special case any classes which are sub classes of
QDBusAbstractInterface
	  when calling slots directly as the slots will be remote.
	* When there is more than one return value in a Qt::DBusMessage the
value
	  method now will return a Ruby Array

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

	* At the suggestion of Vincent Fourmond added a Qt::DateTime.to_time
	  method which returns a Ruby time. Also enhanced the Qt::DateTime
	  constructor so that it can be passed a Ruby Time.
	* Qt::Variants containing either QDBusObjectPaths or QDBusSignatures
	  can now be converted to Ruby Strings with a Qt::Variant.value call.
	  Fixes bug reported by maniel on the #qtruby IRC channel.

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

	* If QModelIndex.internalPointer() is zero, return Qnil
	* Don't attempt to mark a zero internalPointer() for the garbage
	  collector. Thanks to cheiron for reporting the bug.

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

	* Fixed a regression introduced when slots were made directly
callable.
	  It broke the code to invoke remote QtDBus methods because the 
	  remote methods become slots in the QMetaObject of the
QDBusInterface
	  being used as a proxy. The code was trying to invoke those slots
	  directly which didn't work. So special case any QMetaObjects which
	  have classNames of "local::Merge" as it means they are remote.

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

	* Don't build the qtrubyinternal library anymore as it gave trouble
on
	  AMD64 machines and needed an '-fPIC' option there. Instead just
	  include the qtruby sources in the korundum (and plasma) projects.

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

	* The Qt::KeyEvent#type method wasn't working. Fixes problem reported
	  by Magicloud Magiclouds

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

	* Ruby signal declared in superclasses were not being inherited by
	  subclasses correctly. Fixed bug reported by cheiron on the #qtruby
	  irc channel - thanks for the report and test program.

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

	* The QScintilla class names now all start with Qsci instead of Qext,
	  so change the QtRuby module name from Qext:: to Qsci::
	* Fixes a seg fault pointed out by Adreas Pakulat

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

	* Added some missing modules for namespaces in the KDE4 classes

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

	* Added a kross2qtruby method from Cyrille Berger to convert from a
kross 
	  instance to a qtruby instance
	* Fixed bug in overloaded method resolution where a quint32 was being
given
	  equal priority to a qint32 type. Thanks to joseph/vista on #qtruby
for
	  reporting the bug

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

	* Up the version to 1.4.9
	* Add a Plasma:: module for the plasma classes

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

	* Released Qt4 QtRuby 1.4.8 on Rubyforge
	* Fixed an error in the QGraphicsPixmapItem class which made it
impossible
	  to instantiate
	* Building QtRuby against Qt 4.2 failed because of a reference to 
	  the Qt 4.3 QMdiSubWindow class not being #ifdef'd correctly. Thanks
to
	  mhlmi on #qtruby irc for reporting these two bugs.

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

	* When a Qt::Object is subclassed more than once, a Qt::MetaObject is
	  now correctly constructed for each subclass. Before a half-working
	  hack was used where a Qt::MetaObject containing all the slots and
	  signal of its superclass too, was constructed for the twice
sub-classed
	  class. Fixes problems reported by Caleb Tennis amoungst several
others.
	* When a signal is defined, and Ruby method is created to call it.
Before
	  the signal methods were only being created when the Qt::MetaObject
for
	  a class was created. This caused problems if the signal was emitted
	  before the Qt::MetaObject was created. Fixes problem reported for
Qt3
	  QtRuby by Gadi Aleksandrowicz on the Korundum Rubyforge help forum.

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

	* Added some missing list marshallers
	* Fixed a bug in the resolution of QGraphicsItem subclass names

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

	* Fixed a bug in resolving overloaded methods where an enum passed as
an
	  quint64 arg type needed to be given a lower priority that an
Integer one
	* Added two models useful for Rails ActiveRecord or ActiveResource
with Qt
	  widgets
	* Fixed a bug in the Qt::HttpRequestHeader method() method

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

	* Add some marshallers for the QVector types in the new Qt 4.3
QXmlStream*
	  classes
	* Improved the cannon game t14 code

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

	* The code to allow the type() method to be used for Qt::GraphicsItem 
	  classes had the wrong names for the classes
	* Improved the resolution of QGraphicsItem classes in
resolve_classname()

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

	* Added some marshallers for Qt 4.3 classes
	* Fixed bug in deleting Qt::StandardItems when they had a parent or
model

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

	* When a ruby string was converted to a 'char *' arg, a copy was
malloc'd
	  and then never freed. This behaviour was added to fix a problem
with the
	  small number of methods that 'took ownership' of the string and
expected
	  it to stay around after the method call. However, it introduces a 
	  memory leak for the 95% of methods that don't need it, and also
means
	  that if the 'char *' is changed during the method call, the changes 
	  aren't reflected in the ruby string. Thanks to Jan Wedekind for the
	  discussion leading up to changing the code. Any methods where this 
	  behaviour is wrong will now need to be special cased.

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

	* Call rb_gc_mark() on the internalPointer VALUE within a
Qt::ModelIndex 
	  to prevent it being GC'd too early
	* Added 'double&' and 'double*' marshallers
	* Fixed memory leak when creating new Qt::ModelIndexes

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

	* Added marshallers for QwtArray<double> and QwtArray<int> 
	  (ie QVector<int>)
	* Added a fix from Knut Franke to make the QVector<double> marshaller
	  work with any sort of Ruby number. Thanks Knut..

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

	* Made 'Qt::Variant.new(nil)' a synonym for 'Qt::Variant.new'

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

	* Added inspect and pp methods for Qt::MetaEnums
	* Qt::Variants can be constructed from ruby Dates, Times and
DateTimes.
	  Qt::Dates, Qt::Times and Qt::DateTimes can also be constructed from
	  their ruby equivalents as a single arg. This makes it easier to
	  integrate Qt::AbstractItemModels with Rails ActiveRecord and 
	  ActiveResource

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

	* If a new Ruby class is created for a custom C++ QObject derived
class,
	  then create Ruby constants in the class for any enums defined via 
	  Q_ENUMS which are in the same scope as the new class. For instance:

		class TestObject : public QObject
		{
			Q_OBJECT
			Q_ENUMS(Priority)
			public:
				enum Priority { High, Low, VeryHigh, VeryLow };

		...

		irb(main):001:0> app = Qt::Application.new(ARGV)
		=> #<Qt::Application:0xb6aaaf58 objectName="irb">
		irb(main):002:0> require 'testqobject'
		=> true
		irb(main):003:0> test = app.findChild(Qt::Object, "QtRuby
TestObject")
		=> #<TestObject:0xb6aa5184 objectName="QtRuby TestObject">
		irb(main):004:0> TestObject::High
		=> 0
		irb(main):005:0> TestObject::Low
		=> 1
		irb(main):006:0> TestObject::VeryHigh
		=> 2

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

	* Thomas Moenicke fixed the qtruby cmake build so it works on
	  all machines by adding a KDE_EXPORT macro to Init_qtruby4()
	  Big thanks to Thomas and Guillaume Laurent for getting it all
working.
	* Added calling slots directly in custom C++ QObject classes.
	  If a method isn't found in the Smoke library, and the instance is
	  a kind of QObject with a class not in the Smoke library, then look
	  for a slot matching the method name and invoke it. Thanks to Eric
Landuy
	  for the idea and discussion leading to implementing it.
	* Added a check for QtDBus in the qtruby cmake file and set a define
	  of -DQT_QTDBUS if the library was found
	* Changed the ADD_LIBRARY line in the qtruby cmake file to use MODULE
	  so that a bundle should be built on Mac OS X.

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

	* Fixed bugs in the debug dump of QMetaObjects created at runtime
	* When a block was used as a slot, a new entry was being added to
	  the QMetaObject object every time they were connected. A new
	  entry is now only created if a slot with the same signature didn't
	  already exist.

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

	* The ListModel internal class was being wrongly named as TableModel

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

	* Added the qdbus/complexpingpong example
	* Qt::DBusVariant have to be passed Qt::Variants, and a suitable
	  Qt::Variant will be created
	* Improved the format of debugging info for the contents of a
QMetaObject
	* A Qt::Variant can now be obtained when contained in a
Qt::DBusVariant

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

	* Added a Qt::DBusVariant class and a marshaller for it

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

	* QtRuby was crashing in virtual method callbacks with a memory
corruption
	  problem. The stack of ruby VALUES for the arguments to the callback
is 
	  now allocated via ALLOCA_N, rather than calloc which cures the
crashes.
	* Changed tabs to spaces in the pixelator example

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

	* Code generated with the rbuic tool '-x' option has a require 'Qt4'
	  option. Fixes problem reported by Sylvain Joyeux
	* Add setup_ui() and retranslate_ui() methods as aliases for the
camel
	  case ones as suggested by Sylvain Joyeux

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

	* Added the painting/fontsampler example
	* There is no way to distinguish between the two constructors:
	 	 QTreeWidgetItem (const QTreeWidgetItem & other) 
		 QTreeWidgetItem (QTreeWidgetItem * parent, const QStringList & 
           strings, int type = Type)
	  when the latter has a single argument. So force the second variant
to 
      be called
	* Added the desktop/screenshot example
	* Added the desktop/systray example

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

	* Added the painting/svgviewer example
	* Added the painting/imagecomposition example
	* Added a convenience method Qt::Image.fromImage() to assign one
image
	  from another. This is because the C++ QImage::operator=(const
QImage&)
	  method isn't easily called from QtRuby
	* Fixed do_method_missing() so that 'operator=' methods don't get 
	  transformed into setOperator() methods

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

	* Removed the qtrubyinit program as it's a pita to build, and isn't
very
	  useful

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

	* Add a QMap<int,QVariant> marshaller
	* When marhalling QMap types with QVariant values, if the Ruby value
isn't
	  a Qt::Variant then one is created
	* Qt::Variants can now be constructed with Hash's of
String/Qt::Variant
	  pairs, and from Arrays of Qt::Variants
	* Custom types know to the QMetaType system, such as some QtDBus
types,
	  can be used to construct Qt::Variant via the
QMetaType::constructor() call
	* Fixed a bug in Qt::AbstractItemModel.createIndex() which meant it
wouldn't
	  work on 64 bit machines
	* When marshalling QList<QVariant> types from Ruby to C++, if any
elements
	  aren't Ruby Qt::Variants, they are automatically converted. Hence,
the
	  following will work:

		v = Qt::Variant.new([1, 2, 3])

	  The Qt::Variant v will contain a list of 3 QVariants with
typeName 'int'

	* Add an option extra argument to Qt::Variant.fromValue() and
qVariantFromValue
	  to specify a type string, for use with QtDBus args. For example:

		v = Qt::Variant.fromValue(5, "uint")

	  Will force the Qt::Variant to be a specific type
	* Change all instances of strcmp() to qstrcmp()

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

	* The Qt::KeySequence constructor wasn't working when passed a
	  Qt::Key enum type and it needed to be cast to an Integer via 
	  a to_i() call.
	* When a Qt::DBusInterface.call() method was invoked without using
	  the call() method, but by calling the method directly, and the
method
	  returned a QVariant Qt::DBusArgument value, the QVariant return
	  value was converted to nil.
	* Fixed some errors in the mainwindows/mdi example, thanks to shirk
	  and |Vargas| for pointing them out.
	  
2006-11-23  Richard Dale  <rdale@foton.es>

	* Made Qt::TreeWidgetItem and Qt::TreeWidget Enumerable
	* Added a Qt::TreeWidgetItemIterator.current() method to get the
	  current value of the iterator without needing to use 'operator*'
	* Added inspect() and pretty_print() methods to Qt::TreeWidgetItem,
	  Qt::ListWidgetItem and Qt::TableWidgetItem
	* Removed instructions for creating a 'rubyw' executable in Mac OS X
	  as it isn't needed anymore with Qt 4.x. Thanks to Hans Fugal for 
	  pointing that out.

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

	* The rbuic and rbrcc tools were being built with a .app extension
	  on Mac OS X when using qmake. Fixed the .pro files so this doesn't
	  happen. Thanks to Hans Fugel for reporting the problem.

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

	* When Qt::DBusInterface.call() was called with a single argument,
	  it was failing with a method_missing() error. Fixes problem
	  reported by Carsten Niehaus.

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

	* Fixed a crash when a slot was inherited by a subclass, and the
	  subclass had no slots or signals of its own

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

	* Upped the QtRuby version to 1.4.7 for the RubyForge release

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

	* All allocs and frees for the smokeruby_object struct now go through
	  two methods alloc_smokeruby_object() and free_smokeruby_object().
	  Before some instances were being allocated with Ruby's ALLOC, and
	  some with malloc(). Now they are all created with malloc().
	* Removed a call to ALLOC_N and replaced it will calloc().

	* Reversed the decision to get rid of ALLOC, and replaced all mallocs
	  with ALLOC and all callocs with ALLOCA_N
	* Commented out some code that mapped an instance which was allocated
	  in the C++ world onto the corresponding ruby instance. It doesn't
	  work if the C++ address is reused and the Ruby side doesn't know
	  about it.

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

	* A Qt::DBusArgument can be obtained via a call to qVariantValue(),
like
	  this:

		qVariantValue(Qt::DBusArgument, variant)

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

	* Fixed Qt::DBusInterface.call() so it automatically wraps the
arguments
	  as Qt::Variants. Thanks to prullmann for testing and finding
problems.

	* Improved the pingpong example to be more like the C++ version.

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

	* Added marshallers for QList<QPair<QString,QString> > and
QGradiantStops
	  (QPair<qreal,QColor>) types

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

	* Added the QtDBus pingpong example

	* 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-05  Richard Dale  <rdale@foton.es>

	* Each rbuic generated class is now wrapped in a Ui module so that as 
	  well as class 'Ui_Foobar' there is a 'Ui::Foobar' version.

	* Added the QtDBus chat example

	* Made the Qt::DBusMessage '<<' create a Qt::Variant if the arg
passed
	  to it wasn't already a Qt::Variant

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

	* Added the QtDBus remote contoller car example

	* Fixed warning messsage caused be the Qt::Variant::Time value

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

	* Added ruby implementations of
Qt::DBusConnectionInterface.serviceOwner(), 
	  registeredServiceNames(), isServiceRegistered(), servicePid(),
serviceUid()
	  and startService()

	* Added a Qt::DBusMessage.value() method to return the Ruby value of
the Qt::Variant
	  at the beginning of the arguments array, or nil if the message
wasn't a ReplyMessage.

	* Fixed incorrect Qt::Variant.toUInt() method name

	* Added a ruby version of the Qt::DBusReply class

	* Converted the qdbus/listnames example to Ruby

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

	* qVariantFromValue() wasn't working with non-Qt classes as
arguments,
	  such as Ruby Strings and Integers

	* The rbuic4 tool was not setting up slot/signal connections.

	* It is now possible to call on a Qt::DBusInterface instance directly
like
	  this:

		app = Qt::Application.new(ARGV)
		bus = Qt::DBusConnection.sessionBus()
		proxy = Qt::DBusInterface.new(  "org.freedesktop.DBus", 
		                                "/org/freedesktop/DBus", 
		                                "org.freedesktop.DBus", 
		                                bus )
		
		result = proxy.ListNames()

		# result is
["org.freedesktop.DBus", ":1.0", "com.trolltech.Assistant", ":1.15"]

	* Fixed bugs in Qt::Variant where some constants were missing, and
the one for 'String'
		gave a warning

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

	* The Qt::DBusMessage.type method now works. Fixes problem reported
by 
	  Peter Rullmann.

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

	* Redone the rbuic tool based on the Qt 4.2 code with the
ruby-specific
	  code generation in a 'ruby' subdirectory.

	* The rbuic tool has been renamed 'rbuic4' so it can be used at the
same
	  time as the Qt3 one.

	* Changed 'setShortcut' method calls so a string can be passed to
them
	  as well as a Qt::KeySequence to be more similar to the C++ api.

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

	* Sym links 'rbqt3api' and 'rbqt4api' to rbqtapi created so that the
Qt3
	  and Qt4 apis can still be queried when both QtRuby versions are
installed

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

	* Renamed 'qtruby.rb' as qtruby4.rb, and qtruby.so as qtruby4.so

	* Qt4.rb and Qt3.rb files are installed to allow either Qt3 or
	  Qt4 versions of QtRuby to be used with require 'Qt4' or 
	  require 'Qt3' statements

	* A Qt.rb symbolic link is created by the install so that by default
	  a require 'Qt' statement will use Qt4 QtRuby

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

	* Fixed bug reported by Caleb Tennis where temporary QString const
arguments
	  were only being deleting after marshalling if they weren't const
types.

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

	* Fixed bug reported by Henri Sundelin where Qwt classes in .ui files
weren't
	  being correctly given Qwt:: module namespaces

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

	* Added a new variant of connect, which takes a SIGNAL as an
argument, along with
	  a block. For example:

		quit.connect(SIGNAL(:clicked)) { puts 'quit pressed' }

	  The block is called in the context of where the connect call was
made, and 'self'
	  needn't be a Qt::Object. It is similar to the signal_connect()
method in
	  ruby-gnome. This was suggested by rickdangerous on the #qtruby irc
channel.

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

	* Blocks can now be used as slots in Qt::Object.connect() calls.
There are two
	  versions, a singleton method and an instance method. 

	* Here is an example of the class method connect() call with a block
as a target:

		app = Qt::Application.new(ARGV)
		quit = Qt::PushButton.new('Quit')
		Qt::Object.connect(quit, SIGNAL('clicked()'), app) { puts 'quit
clicked' }

	  The block is executed in the context of the target instance, 'app'
in this 
	  case.

	* And the instance method form:

		class MyButton < Qt::Button
			def initialize(text)
				super(text)
				connect(self, SIGNAL('clicked()')) { puts 'button clicked' }
			end
			...

	  The block is executed in the context of self - the instance making
the 
	  connect() call.

	* The Rails version of the Ruby 1.9 method Object#instance_exec was
used
	  to invoke the block. Thanks to kelko on the #kde-ruby channel for
the
	  idea and the code, and rickdangerous for further discussion.

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

	* The 'default.txt' file was missing from the
itemviews/simpletreemodel
	  example. Added it, and converted the example to use the rbrcc tool.

	* Fixed a bug in the rbrcc compiler in the code generation for the
	  qt_resource_struct.

	* Fixed some bugs in the network/ftp and itemviews/chart examples

	* Made marshall_primitives.h compile

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

	* Fixed bug in the rbuic tool where a QTextEdit::AutoNone value
wasn't
	  being converted into the Qt::TextEdit::AutoNone qtruby form.
Reported
	  by #freqmod on the irc channel #kde-ruby.

	* Brought the rbrcc code in line with the latest Qt 4.2 version with
	  changes to the locale handling.

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

	* Reimplemented the Qt::Object.findChild() and findChildren() methods
	  using code based on the implementation in qobject.cpp. Fixes
problem
	  reported by Robert Gstoehl. It is now possible to pass a regular
	  expression to findChildren() in the same way as the C++ original:

		mywidget.findChildren(Qt::Pushbutton, /^foo/)

	* Added a Qt::Object.staticMetaObject method to work round the
problem
	  of it being missing from the Smoke runtime.

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

	* Some more leak fixing and minimising use of the heap

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

	* Used the excellent MallocDebug tool on Mac OS X to track down and
fix
	  some memory leaks. Some QRegExps and QByteArrays are now allocated
	  statically to minimise memory usage.

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

	* The code to change a Ruby 'foo?' method call to a Qt C++ 'setFoo()'
was 
	  using QStrings to change the text. However, it then converted the
result
	  to a QByteArray via toLatin() and referenced the contents of the 
	  QByteArray via a 'const char *' cast when the QByteArray had gone
out of
	  scope and had been deleted. Thanks to Carlto Wang again for
reporting 
      this bug.

	* Some of the code for debug logging of garbage collection wrote
spurious
	  newlines

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

	* Some QtRuby QHash based caches were defined with QStrings, and when
the value
	  was accessed the QString was converted to a QByteArray via toLatin
() and then
	  to a 'char *'. However, the 'char *' only lasted as long as the
QByteArray,
	  and this caused memory corruption if the 'char *' was still in use
after the
	  QByteArray was freed. So the QHash's are now defined like this:

		QHash<QByteArray, Smoke::Index *> methcache;
		QHash<QByteArray, Smoke::Index *> classcache;
		QHash<int, QByteArray> classname;

	  This doesn't completely fix a crash in QtRuby though, although it
does seem to
	  improve things. Thanks to Charlton Wang for tracking down where the
string was
	  being corrupted.

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

	* Added a QVariantList marshaller
	* The correct QGraphicsScene event class instance is instantianted
from
	  the event.type()'s
	* The Qt::GraphicsItems in a Qt::GraphicsScene are marked so they
won't
	  won't get garbage collected prematurely
	* Added QT_TR_NOOP() and QT_TRANSLATE_NOOP() methods for completeness
	* Added Qt::Graphics examples: graphicsview/collidingmice and
dragdroprobot

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

	* Added some marshallers for Qt 4.2, for QList<QGraphicsItem*>,
	  QList<QStandardItem*> and QList<QUndoStack*> types.
	* The Ruby String to 'char *' and String to 'unsigned char *' were
using
	  the pointer within the Ruby String directly which meant they were
	  deleted when the Ruby String was gc'd. So they are copied with
	  strdup () instead.

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

	* Applied a fix from Cvetoslav Ludmiloff to make 
	  Qt::AbstractItemModel.createIndex() work without conversion errrors
	  for large Ruby BigNum values.

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

	* The 'EmitSignal' class in marshall_types.cpp was not linking
against
	  the code calling it from Qt.cpp with some versions of the gcc
	  compiler/linker. So the code was moved to Qt.cpp so that it should
	  build on all environments.
	* Added a 'designer/calculatorbuilder' example using the
Qt::UiBuilder
	  class to load .ui files from a .qrc file compiled with the rbrcc
	  resource compiler
	* Added some extra marshallers for QList<QWidget*> and QVector<qreal>
	  types.

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

	* Slot and signals can now have return types and return values.
	  For example:

		class Foo < Qt::PushButton
			slots 'int greeting(QString)'
			signals 'int doit(QString)'
		
			def initialize
				super
				connect(self, SIGNAL('doit(QString)'), self,
SLOT('greeting(QString)'))
			end
			...
	* Added some missing marshaller types for QTreeWidgetItem and
QListWidgetItem
	  lists

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

	* qt_metacall() was returning an incorrect value when called with, 
	  Ruby slots. This doesn't normally matter, but was causing D-BUS
	  slot invocations via qt-dbus to fail.

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

	* Added support for q_classinfo() attributes, equivalent to the c++
	  Q_CLASSINFO() macro. If the key of the q_classinfo is 'D-Bus
Interface'
	  the slots in the class are marked as Q_SCRIPTABLE in the
QMetaObject.
	  For example:

		class LCDRange < Qt::Widget
			q_classinfo('D-Bus Interface', 'MyInterface')
    		signals 'valueChanged(int)'
    		slots 'setValue(int)'
			...

	* The metaObject methods for slots and signals are no longer added
when
	  a Qt::Object is constructed, but when slots or signals are added to
	  a class. This means that signals as well as slots can be added to
an
	  existing instance.

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

	* For Qt::QObject classes which are immediate subclasses of Qt::Base,
	  don't add C metaObject() and qt_metacall() methods as they aren't
	  needed. This means that a QMetaObject is no longer constructed for
	  these classes, and the one that the corresponding C++ class has is
	  returned instead.
	* Bring the itemviews/pixelator example code in line with the current
	  C++ version.

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

	* Added a rbrcc resource compiler, a ruby version of rcc
	* Two new module methods Qt.qRegisterResourceData() and
	  Qt.qRegisterResourceData() were added to Qt.cpp to support the
	  resource compiler.

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

	* With code like the following, the QtRuby runtime was choosing
	  an operator method which took a QByteArray and a QString and
	  returned a QString. So the 'block' became a Ruby String, rather
	  than staying as a Qt::ByteArray:

        block = Qt::ByteArray.new
    
        if comment
            block += "/*\n"
            block += "    " + header + "\n"

	  So the operator '+' for Qt::ByteArray is special cased to return
	  a Qt::ByteArray.
	* The example dialogs/simplewizard now works correctly

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

	* Fix regression for dynamic class creation via QMetaObject info
causing
	  a crash.
	* A list of properties is now returned via
Qt::MetaObject.propertyNames
	  for a Qt::Object with properties for the inspect and pretty_print 
	  methods.
	* Fixed a pile of errors in the itemviews/chart example
	* Added Qt::ItemSelection.at, [], count and length methods

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

	* When an unknown C++ class is found, a corresponding Ruby class is
now
	  created. For instance, if a KPresenter KPart is loaded, a 
	  KDE::PresenterDoc class is created.
	* It is now possible to set and get properties without needing to use
	  Qt::Object.property() and Qt::Object.setProperty(). For instance:

		factory = KDE::LibLoader.self().factory("libkpresenterpart")
		@kpresenter = factory.create(self)
		p @kpresenter.presentationDuration
		@kpresenter.presentationDuration = true

	* A Qt::Variant.to_ruby method has been added which returns a Ruby
value
	  corresponding to the current value of a Qt::Variant
	* Added a Qt::MetaObject.propertyNames method to return a list of
property
	  names

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

	* Added an entry for a missing marshaller for QModelIndexLists.
	  Thanks to Daniel Morris for the bug report and fix.

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

	* Added a Qt3:: module for the Q3* support classes
	* The rbuic now correctly gives Q3* classes a Qt3::
	  module prefix.

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

	* A spurious warning was be output when Qt::ContextMenuEvent.type
	  was called. Fixes problem reported by Alessio Caiazza

2006-04-25  Richard Dale  <rdale@foton.es>

	* Added a namespace of Qwt:: for use with widgets from the Qwt
	  3D plotting library

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

	* Added marshalling for WId and Q_PID types which will work
	  on Windows.
	* Fixed the rbuic qmake project file so it will build on Windows

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

	* Removed a call to vasprintf() as it didn't compile with mingw
	  on Windows. Replaced with qvsnprintf() using a statically
	  allocated buffer.
	* Fixed bugs in slot/signal marshalling. The qint64 type is now
	  marshalled correctly.
	* Added a line to extconf.rb for the libraries needed to link the
	  QtRuby extension on Window.

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

	* Added the network/http and loopback examples
	* Slots with 'qint64' arg types don't yet work
    * Fixed bug where qtruby failed to link on some machines
	  such as Windows, where the 'char' type defaults to
	  unsigned, so define them as 'signed char' instead.
 
2006-04-17  Richard Dale  <rdale@foton.es>

	* Added the network/ftp, broadcastreceiver and broadcastsender
examples

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

	* Change source files to headers to make it easier to build the
qtruby
	  extension on Windows and Mac OS X. marshall_basetypes.cpp,
marshall_complex.cpp
	  and marshall_primitives.cpp are now all headers. marshall_types.cpp
is now split
	  into an implementation source file and a header.

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

	* Added xml/saxbookmarks, xml/dombookmarks and widgets/tooltips
examples
	* Improved garbage collection marking, Children QTreeWidgets and 
	  QListWidgets are now marked. QObject tree instances are only marked
	  starting at an instance which has no parent to improved efficiency,
	  otherwise the same sub trees would be marked several times as a
	  traversal is started for each node in the heirarchy.
	* The 'type' method in QEvent subclasses now works correctly.
	* Added inspect and pretty_print methods to the Qt::WidgetTreeItem
class

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

	* Added mainwindows/dockwidgets example
	* Added mainwindows/mdi example
	* Added widgets/movie example

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

	* Added draganddrop/dropsite example
	* Fixed bug where non-primitive signal types weren't working

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

	* Various fixes to the rbuic tool:
		* Variable names were not always correct. Now they always start with
		  a '@' if they are ruby instances variables, and all have an
initial
		  lower case letter.
		* The various names used in signal/slot connect statements should
now
		  be correct.
		* Qt::SizePolicy literals were not always correct
		* The code for embedded icons is now translated into Ruby
		* Multiline string literals are now terminated with a '\' on each
line

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

	* Added the dialogs/configdialog example
	* Fixed bug in slot invocation marshalling where non-primitive
	  types, apart from QStrings weren't working
	* Fixed crash caused by recently introduced 'fix',
	  deleting 'argv' passed to QApplication

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

	* Marshalling of Value lists to Ruby wasn't working at all. The
	  bug was because the following two lines are not equivalent:

	    void *p = &valuelist[i];
	    void *p = (void *) &(valuelist->at(i));

	  The first line doesn't work correctly, but the second was does.

	* The marshaller for QList<QImageTextKeyLang> was defined wrongly.

2006-04-05  Richard Dale  <rdale@foton.es>
	
	* Added the itemviews/puzzle example
	* Added a QModelIndexList marshaller
	* Added inspect and pretty_print methods for Qt::ModelIndex

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

	* Added the itemviews/sortingmodel example

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

	* Simplify the Qt::AbstractItemModel.createIndex() code
	* Fix bug where return values from rb_call_super() were being ignored
	* Make :foobar a synonym for 'foobar()' in SLOT()/SIGNAL() calls and
	  slot/signal declarations

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

	* Added the itemviews/simpledommodel and itemviews/simpletreemodel
	  examples

	* Special cased the Qt::AbstractItemModel.createIndex() and 
	  Qt::ModelIndex.internalPointer() methods so they can save
	  and restore Ruby VALUE instances.

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

	* The QtRuby runtime's overloaded method resolution mechanism can't
currently
	  distinguish between Ruby Arrays containing different sort of
instances.
	  Unfortunately Qt::Painter.drawLines() and Qt::Painter.drawRects()
methods can
	  be passed a Ruby Array as an argument containing either Qt::Points
or Qt::PointFs
	  for instance. These methods need to call the correct Qt C++
methods, so special case
	  the overload method resolution for now..

2006-04-03  Richard Dale  <rdale@foton.es>
	
	* The models used for QTableView and QListView are the private
classes
	  QTableModel and QListModel. They are accessed as
QAbstractItemModels
	  via the apis for the view classes. Unfortunately,
QAbstractItemModel
	  has pure virtual functions which don't appear in the corresponding
	  Ruby class Qt::AbstractItemModel. So Ruby implementations of
Qt::TableModel
	  and Qt::ListModel need to be special cased, and given the missing
	  methods in order to access the model data.

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

        * Don't special case open() in virtual method callbacks,
because all
          the Qt classes with open methods now have explicit open()
method
          calls. So it isn't possible that Kernel.open() will be
called
          wrongly anymore.

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

	* Added various explicit calls to method_missing() for methods which
	  are defined in Kernel and Object, such
as 'exec', 'select', 'format'
	  etc. Otherwise, the corresponding methods in the Smoke library were 
	  not being invoked correctly.
	* Removed a virtual destructor compile warning
	* Removed obsolete qtruby-only.patch and kdevelop project file

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

	* Fixed bugs in const lists marshallers, where the items in the ruby
Array
	  were wrongly being updated after a method call

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

	* Added a '-x' option to the rbuic tool to generate a ruby top level
	  code for testing a compiled .ui file
	* Removed spurious "Warning: action `%s' not declared\n" message
	* Fixed bug in code generation where the top level arg name in
	  setupUI() was being wrongly referenced as an instance variable.
	  Fixes bug reported by Florent Ruard-Dumaine
	* Fixed bug in const pointer lists, where the items in the ruby Array
	  were wrongly being updated after a method call

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

	* After a const value based list such as QVector<QPointF> was passed
	  to a C++ method, the correspoding Ruby Array was being updating 
	  with the values when it didn't need to be. There is also a bug
which
	  meant the the values in the Ruby Array were being set to nil. That
	  bug still isn't fixed. Partly fixes bug reported by akincisor on
the
	  #qtruby irc channel.
	 
2006-02-16  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>
	
	* In Qt4 when the type signature of a slot or signal argument type is
	  normalized, any '&' character for a reference type is removed,
along
	  with any 'const' qualifiers. So 'const QString&' becomes 'QString'.
	  After a 'QString' slot type has been marshalled to a Ruby string it
	  is deleted, as it was assumed to be a temporary copy. However, this
	  caused a crash with QString references such as in the
widgets/wiggly
	  example. Fixes a problem reported by mserms on #qtruby.

	* Added the correct Qt4 libs to the extconf.rb compile command

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

	* Improved the debug logging of virtual method callbacks so that the
	  arg types are shown too

2005-12-20  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Restored Caleb Tennis's refactored marshall_types.cpp code after
	  accidently deleting it in August.

2005-12-16  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The logger_backend() function has been removed and replaced with 
	  qWarning() calls. This was because of problems with getting the 
	  logger_backend() code to work on Windows.

2005-12-08  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The ruby display() method was clashing with a display() method in
some
	  QtRuby classes, and so it was aliased to _display(). However, this
caused
	  problems with the ruby RMagick extension. The display methods are
now
 	  special cased in Qt::LCDNumber. Fixes problem reported by David
Corbin.
	* The slots and signals methods are now module methods of Qt::Base,
	  rather than defined as ordinary methods in class Module, reducing
name
	  space pollution. Thanks to Esteban Manchado for pointing this out.

2005-12-06  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* QtRuby didn't work with versions of ruby > 1.8.3, as it didn't call
	  initialize methods correctly. It used the rb_respond_to() method
	  to check it a newly created qt instance responded to :initialize.
	  However, in newer versions of ruby rb_responds_to() ignores
	  private methods such as initialize(). The solution was to just
remove
	  the test, as it was redundant anyway.
	* Fixes problem reported by Hans Fugel and Caleb Tennis.

2005-11-21  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* When dispose() was used to delete a ruby instance, the mapping
between
	  the C++ ptr and corresponding ruby instance was not being removed,
and
	  this caused a crash. Fixes problem reported by Christopher
Chan-Nui.

2005-11-04  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* 'signed int&' types were not being matched or marshalled correctly

2005-10-21  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Argument types of 'unsigned short int' were not working. Fixes
	  problem reported by Ian Monroe

2005-10-05  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added network/fortuneserver and fortuneclient examples
	* The Qt::ByteArray class is now a normal Smoke class, 
	  rather than a special case, as it's easier to make a
	  Qt::ByteArray look like a ruby String, than the other way
	  round.
	* The overloaded method resolution for enum arg types has been 
	  improved
	* Added missing relational operators to Qt::Integer
	* Fixed bug in marshalling unsigned shorts

2005-10-03  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Ported the RuBoids OpenGL artificial life example to Qt4 and 
	  added opengl/grabber

2005-10-01  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The the value of a Qt::Variant can now be accessed with
	  with to_s, to_i, to_a and to_f methods
	* Deleted the svn:mime-type property from the qtruby.rb source
	  so that diffs will be shown on checkin

2005-09-25  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added richtext/calendar, orderform and syntaxhighlighter examples
	* Fix bug in '>', '<=', '<' and '<=' operator methods where they were
	  clashing with methods in Kernel
	* The struct Qt::TextLayout::FormatRange is now in QtRuby

2005-09-24  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added painting/basicdrawing,  concentriccircles,  painterpaths  and
	  transformations examples

2005-09-23  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added mainwindows/application, menus, recentfiles and sdi examples

2005-09-22  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added layouts/basiclayouts, borderlayout and flowlayouts examples
	* Either a Qt::Layout, Qt::WidgetItem or Qt::SpacerItem ruby instance
	  is created to wrap a C++ QLayoutItem instance, using
	  QLayoutItem::widget() and QLayoutItem::spacerItem() methods to
	  determine the exact class.

2005-09-18  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Initial checkin of the Qt4 version of the rbuic tool
	* Added designer/calculatorform example

2005-09-11  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed problem with Qt::SqlTableModel.select() reported by
	  Daniel Morris as a Qt3 QtRuby bug

2005-09-01  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added draganddrop/draggabletext, draggableicons, fridgemagnets, 
	  puzzle examples.
	* Added itemviews/dirview, chart and pixelator Qt4 examples.
	* Fixed bug in QtByteArray marshalling where an underlying QByteArray
	  was not being created if the Qt::ByteArray was created by passing a
          ruby String to the constructor.
	* Qt::ModelIndex's are not deleted on garbage collection as it caused
a
	  crash
	* Added qVariantValue() and qVariantFromValue() methods

2005-08-25 Caleb Tennsi <caleb@aei-tech.com>
	* Changed metaobject creation to not use d pointers per the comment
in the
	  code.

2005-08-24  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added dialogs examples; complexwizard, extension,  findfiles,  
	  simplewizard,  standarddialogs and  tabdialog
	* Changed the types of Qt3 long longs and other Q_* types to the 
	  Qt4 equivalents

2005-08-24  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added windowflags example
	* Some enum names for Qt::WindowFlags were clashing with QtRuby
	  class names, such as Qt::Dialog. So some constants were added to
	  use instead, renamed with an ending of 'Type'.

2005-08-23  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed some code to obtain a Qt::Object's properties for Qt4. Added 
	  property inspecting code for the new QPointF, QRectF etc types
	* Fixed a missing attr accessor bug in Qt::Enum
	* Added the sliders, spinboxes and tetrix code examples

2005-08-22  Caleb Tennis <caleb@aei-tech.com>
        * Started a migration to more template based classes. 
Hopefully this is
          just a start, but this *should* reduce redundant code by
making use of
          C++ templates for marshalling the various types.

2005-08-22  Caleb Tennis <caleb@aei-tech.com>

        * Readded findChildren and findChild methods in C code under
Qt::Object

2005-08-22  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* It isn't an error to pass a NULL void** stack to a qt_metacall()
invocation.
	  So don't throw a ruby exception, and assume it's for a slot with no
args and
	  no return type.
	* Added the icons, imageviewer, lineedits, screenshot and scribble
example
	  programs
	* Qt::Enum is no longer a subclass of Qt::Integer, and it handles its
own
	  arithmetic ops. A logical or arithmetic op on a Qt::Enum always
returns a
	  ruby Integer, rather than a Qt::Enum as before.


2005-08-21  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added calculator, charactermap, groupbox and wiggly to code
examples
	* Fixed crash in ruby QString signal types
	* Improved runtime resolution of the Qt4 Qt::Event classes
	* Added a Qt::Char.to_s method for converting a Qt::Char to a ruby
	  string

2005-08-21  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added digitalclock example

2005-08-20  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added various marshallers for QVector list types
	* Added the analogclock example from Qt4
	* Added inspect methods for the new Qt::PointF, Qt::RectF etc
	  types

2005-08-19  Caleb Tennis <caleb@aei-tech.com>
        * For marshalling ItemLists, prefer using ->at(index) over an
iterator

	* Add findChild and findChildren methods which attempt to mimic their
Qt::Object
          counterparts.  Unit tests included.  e.g.:   
            object.findChildren(Qt::Widget) 
            object.findChildren(Qt::Object, "ObjectName")
            object.findChildren(Qt::Object, /SomeName*/)

            findChild just returns the closest child to the parent
from findChildren

2005-08-19  Caleb Tennis <caleb@aei-tech.com>

        * Added a unittests.rb file as the start of a unit test suite
for
          verifying QtRuby things are working properly and we don't
create
          regressions.

        * Qt4ify some of the code in handlers.cpp

        * Modified new_qobject to only add method definitions if the
kclass
          doesn't respond_to qt_metacall (was a TODO item).
 
        * Prefer using Ruby's ALLOCA_N over calloc in new_qt

2005-08-19  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added various marshallers for converting Qt4 C++ lists to and from
	  ruby Arrays

2005-08-19  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added marshaller to convert QMap<int,QVariant> to ruby Hash

2005-08-18  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* When a QMetaObject was constructed on the fly, the metaObject
	  for the superClass was being obtained via Qbject::staticMetaClass()
	  which returns a copy. However, this messed up qobject_cast() and
	  QMetaObject::cast(), so now the parent metaObject is obtained via
	  QObject::metaObject() which returns a pointer to a QMetaObject.

2005-08-17  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added Qt::MetaObject.slotNames() and signalNames() from Qt3 as they
	  are very useful when using the KDevelop debugger
	* If Qt::Object.metacall() can't be found in the Smoke library a ruby
exception
	  is thrown

2005-08-17  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Left some debugging code in. qt_metacall() was not being called 
	  correctly for non-ruby C++ slots.

2005-08-17  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* QtRuby now ported to Qt4. Pure Qt4 code with no dependencies on
	  libQt3Support
	* Qt4 style QMetaObjects are created on the fly. Slots and signals
work
	  using QObject::qt_metacall() and QMetaObject::activate()
	* The Cannon games tutorials t1 to t14 have been ported to Qt4
QtRuby.
	* More work needed on the garbage collection mark() function. For
instance,
	  it isn't possible to iterate through the items in a QListView in
the same way as
	  before.

2005-08-09  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>
	
	* Caleb Tennis wrote:
	  One nice feature would be to allow Qt::Object::inherits() to use
the QtRuby 
	  naming scheme for valid lookups.  For example, right now:

	    irb(main):001:0> w = Qt::Widget.new(nil)
	    irb(main):002:0> w.inherits("Qt::Widget")
	    => true
	    irb(main):003:0> w.inherits("Qt::Object")
	    => false
	    irb(main):004:0> w.inherits("QWidget")
	    => true
	    irb(main):005:0> w.inherits("QObject")
	    => true

	* Inherits now works for "QObject", and for "Qt::Object" as well.

2005-08-04  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

        * Added a file called 'COPYING' to the qtruby project, with a
note that
          the 'Qt' trademark in the QtRuby name is used with
Trolltech's permission,
          followed by the text of the GPL v2 license.

2005-07-28  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Qt4 port, initial checkin
	* Very little works yet, just hello world

2005-07-15  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Qt::Socket started working correctly when I and regenerated and
rebuilt 
	  my Smoke library. Before then it was calling the wrong version of 
	  QSocket::at() for some reason, and wasn't discarding bytes that had 
	  already been read.
	* Removed comment from the client.rb example about
Qt::Socket.canReadLine
	  always returning true now it works.

2005-07-14  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added example programs for client/server programming with
Qt::Socket
	  and associated classes. client.rb illustrates current bugs in
QtRuby
	* Qt::Socket.canReadLine() always returns true
	* Qt::readLine() seg faults when called a second time
	* A memory leak and seg faulting problems like the above were
reported
	  by Caleb Tennis

2005-07-09  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* When a Qt method returned a QString value type, such as:
	       QString QSocket::readLine()
	  A temporary QString was being created that wasn't deleted and
caused a 
	  memory leak. Fixes problem reported by Caleb Tennis.

2005-06-28  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Improved display of Qt::Enums in the KDevelop debugger. With a p
	  command it just looks like a constant, but a pretty print pp
command
	  shows the type of the underlying C++ enum:

	  (rdb:1) p AlignTop 
	  16

	  (rdb:1) pp AlignTop 
	  #<Qt::Enum:0x1825db68 @type=Qt::AlignmentFlags, @value=16>

2005-06-04  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>
	
	* Upped the version to 1.0.10

2005-06-04  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The Object.id method was clashing with the one in Qt::WidgetStack.
	  Both methods now work correctly. Fixes problem reported by Dave M.

2005-05-29  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The rbuic '-subimpl' option now works correctly

2005-05-29  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The initialize methods in code generated by the rbuic tool, now
have
	  named parameters with default values, rather than '*k'

2005-05-29  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed bug where the rbuic tool was generating incorrect code
	  for an array of strings used as a combo box value

2005-05-28  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added support for the QScintilla text editing widget, including an
optional 
	   '--enable-qscintilla=yes' configure option. The QScintilla classes
are included in a
	  Qext:: namespace. Thanks to Blackshack for the idea and configure
code.
	* The KDE namespace modules are only created if the Korundum
extension is used.
	  Otherwise the Object namespace was being polluted with unused
constants.
	* Some enums in the QScintilla headers had a spurious comma after
	  the last enum value, and kalyptus was failing with a parse error.
	  The comma is now ignored.

2005-05-25  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* '!=' operator methods in the Smoke library were being shown via
ruby introspection when they
	  can't actually be written in ruby, and are derived from the
corresponding '==' operator method.
	* '==' operator methods can now be called.

2005-05-22  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

        * Fixed bug in Smoke code generation where spaces were not
being removed from operator
          methods such as 'operator *'
        * Operator methods are now displayed correctly via ruby
introspection

2005-05-21  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Improved the format of enums displayed by rbqtapi and rbkdeapi

2005-05-20  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Removed unused Qt::Internal functions
	* Added KNS:: to the namespaces expected by the rbkdeapi tool
	* Introspection via Object#methods, public_methods, protected_methods
and singleton_methods
	  or Module#constants, instance_methods, protected_instance_methods
and public_instance_methods
	  now all include methods from the Smoke runtime. This fixes part of
the request in bug 105772, but
	  not enabling 'respond_to?' to be used with Smoke methods.

2005-05-16  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The Kernel.format() method was clashing with the
Qt::MimeSource.format() method.
	  The correct method is now called according to the type of the first
argument. Fixes
	  problem reported by Armin Joellenbeck

2005-04-29  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Removed superfluous "require 'pp'" statement

2005-04-25  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	*  Upped the version to 1.0.9 for the RubyForge release

2005-04-09  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed regressions in the rbqtapi and rbkdeapi utilities caused by
the Qt::Internal namespace
	  tidy up
	* Qt::version and Qt::ruby_version had wrongly been moved to the
Qt::Internal module

2005-04-03  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Upped the version to 1.0.8 for the RubyForge release

2005-03-30  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* An 'include Qt' statement in qtruby.rb where a couple of methods
were being added to
	  class Module was causing all the Qt methods to be added to Module.
Oops, this a really
	  serious bug. Various methods in qtruby.rb are now module methods in
the Qt::Internal
	  module. Big thanks to Eric Veensta and Samir Patel for pointing out
this can of worms.

	* It also fixes a problem reported by David Crosby where
a "require 'time'" statement was
	  incompatible with a "require 'Qt'" statement. As the cause was
unknown, a hacky workround
	  had to be added, which is no longer needed.

2005-03-24  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* When a subclass of QObject is instantiated in the C++ world, and
the exact class doesn't
	  exist in ruby, then scan up the inheritance heirarchy via
QObject::metaObject() until a
	  class is found which does have a ruby equivalent. Fixes problem
reported by Dmitry Morozhnikor
	  where a KViewPart was being returned as a Qt::Object, rather than a
KParts::ReadOnlyPart.
	* The internal method 'cast_object_to()' now takes a class literal as
a second parameter,
	  rather than the class name as a string

2005-03-21  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Moved Qt.rb from qtruby/lib/Qt to qtruby/lib. Fixes problem
building qtruby on Mac OS X
	  with extconf.rb reported by Michael Doppler
	* Rename 'README.build' as INSTALL

2005-02-21  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Upped the version to 1.0.7 for the KDE 3.4 release
	* Removed the khtml:: namespace as it wasn't being used

2005-02-07  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added a KNS:: namespace for the KNewStuff library

2005-02-06  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The KDE::Win::WindowInfo nested class is included in the Korundum
runtime

2005-01-27  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Made some changes to get code generated by the rbkconfig_compiler
	  to work. When an argument is a non-const reference to a primitive 
	  type, or a QString or QStringList, then don't delete it after the
	  method call. This is because a class like KConfigSkeleton takes
	  references, and then 'squirrels them away' - before the references
	  were just pointing to junk on the stack.
	* The method 'isImmutable' is added to KDE::ConfigSkeletonItems

2005-01-26  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* If a ruby Array is passed as an argument to an overloaded method,
give
	  priority to QStringList args.

2005-01-21  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* rbuic was giving widgets names containing a '@' to match the ruby
instance variable
	  name. However, this doesn't work with KDE::ConfigDialog which
expects the names to
	  match the ones generated in a KDE::ConfigSkeleton by
rbkconfig_compiler so '@' is no
	  longer added.

2005-01-20  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed bug reported by Ian Monroe where the KIO.copy() method wasn't
being found in
	  the Smoke runtime. Modules methods are now trapped with
method_missing and
	  despatched to call Smoke methods correctly
	* Added support for the KDE::ConfigSkeleton and subclasses.
Constructors for nested
	  classes can now be called correctly

	CCMAIL: ian.monroe@gmail.com

2005-01-16  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added a Qt::Integer.coerce method so that Qt::Integers and
Qt::Enums can be
	  combined in arithmetic expressions with ruby Integers. 

2005-01-04  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Upped the version to 1.0.6 for the KDE 3.4 beta 1 release

2005-01-02  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The Qt::Object pretty_print method now shows the class name of enum
properties

2004-12-30  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed an interesting bug reported by Stephan Oehlert. Kernel has a
method called 
	  open() which takes a String as the first argument. But when a call
is made to an open() 
	  method in the Qt classes, it messes up the method_missing() logic
to divert it to the 
	  Smoke library. Instead it attempts to call the Kernel method with
the wrong arg types.

	* The problem is fixed by calling the appropriate method based on the 
	  type of the first arg. However, it is no longer possible to
override virtual methods
	  called 'open'.

	CCMAIL: stephan.oehlert@gmx.net

2004-12-28  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added a parent attribute to the Qt::Object pretty_print() method
	* Removed all the properties from the Qt::Object inspect() method
except name,
	  x, y, width, height (the last four for for Qt::Widgets only). This
speeds up fetching
	  the details of Qt::Objects that have more than just a handful of
children.
	  The full details can still be fetched with a pretty_print() call
via a debugger 'pp'
	  command.

2004-12-21  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The qtruby runtime needs to be able to run the code for an
initialize() method up
	  to the point where the C++ instance has been constructed and
wrapped, and then
	  jump out. It then re-runs initialize() with the wrapped instance.
Before a callcc() call
	  had been used for the jumping which worked fine. However, it made
the frame stack
	  look strange when debugging code with the KDevelop debugger. The
fix is to use 
	  catch and throw instead, as they leave the stack in a more normal
looking state.

2004-12-20  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added a work round for a bug caused by an incompatibility between
QtRuby
	  the 'require time' statement, reported by David Crosby
	
	CCMAIL: dcrosby42@gmail.com

2004-12-18  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added a 'receivers' property to the Qt::Object inspector. This
allows the active signal
	  connections for a Qt::Object instance to be viewed in the KDevelop
debugger as a 
	  Hash. The hash keys are the signal names, and the hash values are
arrays of the target 
	  signals/slots as Qt::Connection instances.

2004-12-17  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added 'metaObject' as an expandable property for Qt::Objects. This
allows the
	  Qt::MetaClass class heirarchy to be browsed, and signals/slots
declarations inspected.

2004-12-17  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed bug in lower case/underscore method naming to camel case
conversion

2004-12-15  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Added an attribute of 'children' to the Qt::Object inspect method,
which is an array
   of the Qt::Object's children
 * The QObjects in a QObjectList were not being created with the exact
ruby class
   if they hadn't been allocated from within the ruby code, and just
left as Qt::Objects

2004-12-14  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Qt::Object properities of type enum are shown by name in the
KDevelop debugger,
   and not as numeric literals

2004-12-14  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Changed the format of the Qt::Color inspect string to
#<Qt::Color:0x0 #ffffff>
 * Added some more attributes to the Qt::Font inspector
 * Added a Qt::Cursor inspector

2004-12-12  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Fixed a bug where the debugger was calling an inspect method on an
instance
   which wasn't fully initialized yet, and not of type T_DATA.

2004-12-10  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Added inspect() and pretty_print() methods for Qt::SizePolicy
 * Greatly improved the Qt::Object Qt property based inspect() and
pretty_print()
   methods. Property types such as Qt::Point, Qt::Font and Qt::Rect
can be 
   viewed as expandable items in the KDevelop debugger variable tree.

2004-12-09  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * More inspect() and pretty_print() methods for common classes to
improve debugging -
   Qt::Color, Qt::Font, Qt::Point, Qt::Rect, Qt::Size, Qt::Date,
Qt::DateTime and Qt::Time
   
2004-12-08  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Added inspect() and pretty_print() methods for Qt::Objects that get
the QObject properties and
   show them as 'name=value' pairs. This means the KDevelop debugger
can make Qt::Object 
   variables expandable and show their properties.

2004-11-29  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Upped the QtRuby version to 1.0.5 for the KDE 3.3.2 release

2004-10-30  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * qError(), qWarning() and qFatal() are now Object instance methods,
rather than Qt module
   methods. This means they don't need to be referenced with an
ugly 'Qt.' module scope anymore.

2004-10-21  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * If a class method was called before super, it was wrongly throwing
an exception
   as an error. For instance, this call to i18n():

               def initialize()
                   super(TreeList, i18n("My App Preferences"),
                            Help|Default|Ok|Apply|Cancel, Ok)
      ...


2004-10-16  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Until super has been called in an initialize() method, Qt methods
can't be called on
   it. An exception is now thrown 'Instance not initialized', instead
of it causing a seg fault.
 * For instance:

     class MyWidget < Qt::ComboBox
         def initialize
             # Must call super first
             insertItem('abc')
             super
         end
     end

 * Fixes problem reported by Han Holl
 CCMAIL: kde-bindings@kde.org

2004-10-16  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Upped the version to 1.0.4 for the RubyForge release
 * Added some names to AUTHORS from the ChangeLog

2004-10-14  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * If the smokeruby_mark() function was called for an instance of a
QObject, it should
   mark all the instances below it in the QObject tree, as not needing
garbage collection. 
   However, if a node in the tree didn't have a mapping onto a ruby
instance the marking 
   process stopped there, even though the grandchildren and their
descendants might 
   have a valid mapping onto ruby instances.
 * The solution is to always traverse the entire tree. Fixes problem
reported by Han Holl.

 CCMAIL: kde-bindings@kde.org

2004-10-13  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * All the Qt::CanvasItems owned by a Qt::Canvas are marked with
rb_gc_mark() to
   prevent them being garbage collected
 * The top level widgets are no longer disposed() on Qt::Application
exit
 * Fixed some bugs in the chart example. 

2004-10-13  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Fixed arg matching to give priority to 'int' or 'signed' when
passed a ruby Integer, or
   'double' when passed a ruby Float
 * The chart example can now save and load chart files

2004-10-13  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Added greater than and less than operators to Qt::Enum, so that
enums can be compared with
   Integers
 * Added the chart example for Qt Tutorial #2

2004-10-12  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Added Qt::Application.ARGV. It returns the original ruby ARGV array
with Qt command line 
   options removed.

2004-10-11  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Added a global flag 'application_terminated'. Once this is set the
QtRuby runtime will no longer
   delete any C++ instances. This will hopefully fix crash on
application exit problems reported 
   by Thibauld Favre.

 CCMAIL: kde-bindings@kde.org

2004-10-10  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * The recent fix for checking invalid arg types, didn't work with nil
passed as a value

2004-10-10  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * A QRgb[] color table was being wrongly deleted after marshalling

2004-10-10  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * If a ruby method overriding a virtual method returned a primitive
type when an instance of a class
   was expected, it caused a seg fault. A ruby exception is now thrown
instead. Fixes problem reported by
   Han Holl.

 * For instance,
                    class ContainerGrid < Qt::Widget
                        def sizeHint
                            # next line should return a Qt::Size, not
an integer
                            100
                        end
                     end
 
   Now gives the following error:

               qsize.rb:12:in `method_missing': Invalid type,
expecting QSize (ArgumentError)
                   from qsize.rb:12

 CCMAIL: kde-bindings@kde.org

2004-10-10  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * The smokeruby_mark() function was only marking the immediate
children of a
   Qt::Object for not being garbage collected. It now marks all the
Qt::Objects
   in the object tree below it.

2004-10-07  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Added Qt Designer Tutorial 'Creating Dialogs' translated into
QtRuby. It
   shows how you can combine ruby code generated from .ui files with
the rbuic
   tool, with your own code.

 * The .ui files and images are identical to the original C++
versions.

 * It features a simple Makefile to run rbuic when you change the .ui
files, and
   regenerate the ruby sources.

2004-10-06  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Fixed rbuic '-embed' option which had been broken after adding DCOP
suppot
   to Korundum, after changes in the Qt::ByteArray class.
 * Fixed QRgb* marshalling problem where the ruby value was
overflowing a signed int.
   The target for marshalling is now an array of unsigned ints.
 * When a Qt::Application exits after returning for an
Qt::Application.exec() call, the top
   level widgets are deleted as well as the Qt::Application itself.
This fixes a problem where
   ruby does garbage collection in an arbitrary order after the ruby
app has exited. It destroys
   a ruby Hash of QMetaData info that the Qt::Application or
Qt::MainWindow need to clean up.
 * The layout of the ruby code generated by rbuic has been improved
with better indenting.
 * attr_reader attribute accessors have been added for the most
important instance variables 
   in an rbuic generated class to make them more easily accessed from
another class.

2004-10-05  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Given a C++ instance and an approximate classname, the QtRuby
runtime uses the
   various Qt rtti mechanisms such as QObject::className() to improve
the resolution
   of the name. However, the numeric classId into the array of
classnames in the Smoke
   runtime was not being updated in line with the more accurate name. 
 * This caused problems with method argument matching which uses the
numeric classId
   rather than the ruby object's classname, and so QtRuby wrongly
assumed that a an
   instance of a Qt::Widget was a Qt::Object.
 * Fixes problem reported by Han Holl

 CCMAIL: kde-bindings@kde.org

2004-10-05  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Fixed a couple of errors in the rbuic generated code found as a
result of
   the recently improved stricter arg type matching.

2004-10-04  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * When a ruby app exits, rb_gc_call_finalizer_at_exit() is called and
all the ruby
   instances are garbage collected. The problem is that this is done
in an arbitrary
   order, and Qt::Application was occasionally crashing in its
destructor because 
   QMetaObject info it still needed was being deleted before then.

 * Fixes problem reported by Thibauld Favre

 CCMAIL: <tfavre@mandrakesoft.com>

2004-10-04  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * When a QMetaData object was contructed the class name was a pointer
from a ruby
   string, and was being corrupted when the string was freed. The
string is now copied.

2004-10-03  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Han Holl's report about a when you pass an incorrect arg type to a
QtRuby
   method, it caused a crash has opened a 'can of worms'. This was
because there
   was no arg type checking if there was only one candidate method in
the
   Smoke runtime. Now that arg type checking is applied to all QtRuby
method calls, not
   not just those that after lookup in Smoke map onto a single method,
the overloaded
   method resolution via the arg types has had to be greatly improved.
This has
   been done, and so the arg type matching is now extremely fussy.

 CCMAIL: kde-bindings@kde.org

2004-10-03  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * An optimization in the overloaded method resolution matching causes
a crash;
   instead of throwing a ruby exception when a programming error is
made.
   If there is only one method found in the Smoke runtime, it assumes
that it must 
   be the right one and just takes that.

 * For example:

     lay = Qt::HBoxLayout.new(self)
     ed = Qt::LineEdit.new('blah',self)
     # The next line should be: lay.addWidget(ed)
     lay.addLayout(ed)

  * Fixes problem reported by Han Holl

  CCMAIL: kde-bindings@kde.org

2004-10-03  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * A common programming error is to accidently leave off the 'new'
method call when
   creating an instance. The QtRuby runtime wasn't correctly trapping
an attempt to
   call an instance method on a class object, and was seg faulting
rather than
   throwing an exception.

 * For example:

                    # The next line should be:  lay =
Qt::HBoxLayout.new(self)
                   lay = Qt::HBoxLayout
                   ed = Qt::LineEdit.new('blah',self)
                   lay.addWidget(ed)

 * Fixes problem reported by Han Holl

 CCMAIL: kde-bindings@kde.org

2004-10-03  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Upped version to 1.0.3 for the KDE 3.3.1 release

2004-10-02  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Added Ruby Array to QPair<int,int>& marshaller

2004-09-30  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * The resolve_classname() function in handlers.cpp uses the various
Qt rtti mechanisms to
   get a more accurate classname to instantiate as a ruby instance. It
has now been extended
   with a callback to the Korundum library to do the same for KDE
classes.

 CCMAIL: zack@kde.org

2004-09-29  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Added Jim Menard's ruboids as an OpenGL/Qt::GL* Widgets example
 * Improved instructions and exconf.rb for building the gui extension
from Michal 'hramrach' Suchanek

2004-09-13  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Upped the version to 1.0.2 for Rubyforge release

2004-09-12  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Added a 'qui' extension for reading in .ui Qt Designer files at
runtime
 * For example:

     require 'Qt'
     require 'qui'

     a = Qt::Application.new(ARGV)
     if ARGV.length == 0
         exit
     end

     if ARGV.length == 2
         QUI::WidgetFactory.loadImages( ARGV[ 0 ] )
             w = QUI::WidgetFactory.create( ARGV[ 1 ] )
             if w.nil?
             exit
         end
             w.show()
            a.connect( a, SIGNAL('lastWindowClosed()'), a,
SLOT('quit()') )
            a.exec()
     end


2004-09-07  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Upped the version to 1.0.1 for the current Rubyforge release

2004-09-05  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Added Kate:: and KTextEdit:: namespaces for writing Kate plugins

2004-09-03  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Some newer changes from the uic were added to the rbuic tool.

2004-09-03  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Brought the rbuic code to uncompress zip files in line with the
current uic code
 * Added a qmake project file for building the rbuic tool on Mac OS X,
and some
   notes on how to build QtRuby on a Mac.

2004-08-29  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Added Kontact module to provide a namespace for the kontact plugin
api

2004-08-25  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Underscore naming for can be used for method names instead of camel
case if
   preferred. Any underscores in method names are removed, and the
following
   character is capitalised. For example, either of these two forms
can be used
   to call the same method:
  
     create_standard_status_bar_action()
  
     createStandardStatusBarAction()

2004-08-23  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * A 'thing?' ruby method can now be used as a synonym for either
isThing() or hasThing() in the Smoke runtime

2004-08-04  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Upped the QtRuby version to 1.0.0 - it must work now then..

2004-08-02  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Added 'long long' and 'unsigned long long' marshallers

2004-07-29  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * The smokeruby_mark() gc marking f'n now marks the QTableItems owned
   by a QTable so they don't get garbage collected, even if there are
no
   remaining references in the user code.

2004-07-29  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Added a template based method for QValueList marshallers, and
several
   QValueList types.

2004-07-28  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Removed any marshaller types that weren't in the Smoke runtime from
the
   type name to marshaller function lookup table.

2004-07-28  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * If a class doesn't have a virtual destructor, then no mapping was
being
   kept from the C++ instance to the corresponding ruby value. If the
class
   had virtual method callbacks, this meant that the ruby instance
couldn't
   be found, and the callback couldn't be made.
 
 * Hence, the Qt::ToolTip callback in examples/qt-examples/tooltip
didn't
   work, as that class doesn't have a virtual destructor.

 * Added an 'isEnum()' function to use when matching args in
overloaded
   method resolution.

 * QCString arg types are chosen in preference to QByteArray ones,
matching
   against ruby strings, when resolving an overloaded method call.

 * Qt::Enums and Qt::Integers can be marshalled to uints, longs and
ulongs as
   well as ints.
   
 * Added a '==' operator to Qt::Enums so they can be compared with
ruby Integers

2004-07-27  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Qt::Integer arithmetic and bit operations return Qt::Integers,
rather
   than ruby Integers so that ops can be nested as for Qt::Enums.

2004-07-27  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * The recently added Qt::Integer bit operators were returning a ruby
Integer
   type. When they were nested, the Integer didn't know how to convert
the
   Enum it was being or'd with to an Integer.
 
 * The solution is to add bit operators to the Enum class which return
Enums
   rather than Integers.

 * The following code didn't work:
     
     def initialize(message)
         super(nil, "passivedlg",
                 Qt::WStyle_Customize | Qt::WX11BypassWM |
Qt::WStyle_StaysOnTop |
                 Qt::WStyle_Tool | Qt::WStyle_NoBorder)

2004-07-27  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Replaced QString casts to 'const char *' with latin1() calls

2004-07-27  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * The Qt::Enum class was missing bit operations, so various bit
methods
   were added to Qt::Enum's superclass, Qt::Integer.
 
 * This was causing this line from examples/uimodules/uidialogs.rb to
fail:

     dlg =   KDE::DialogBase.new(parent, "sample_dialog", false,
caption,
                                        KDE::DialogBase::Ok |
KDE::DialogBase::Cancel, 
                                 KDE::DialogBase::Ok, true )

2004-07-27  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added error messages for invalid slot or signal declarations

2004-07-27  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The standard ruby error message for missing constants and methods
is
	  now used when they can't be found in the Smoke library. Removed
Alex's
	  comment about the previous approach, now I agree this is the best
way 
	  to show errors.

	CCMAIL: me@lypanov.ne

2004-07-27  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added qDebug(), qFatal() and qWarning() module methods

2004-07-26  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The parsing of types passed to slots, (or returned from dcop slots)
didn't
	  work with template types containing commas such
as 'QMap<QString,QString>'.
	* Added 'QMap<QString,QString>&' and 'QMap<QString,QVariant>&' to the
	  handlers.cpp string to marshaller lookup table.

2004-07-26  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added marshallers for QMap<QString,QString> and
QMap<QString,QVariant> to and from ruby hashes

2004-07-26  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The error messages for missing methods or missing constants now
give the
	  name of the missing item.
	* For example, this incorrect line:

	    color_group.setColor( ColorGroup::MyMissingConst, blue )
	  
	  Gives this error:

	    splitter.rb:16:in `const_missing': unresolved constant 
	        reference MyMissingConst (ArgumentError)

	* Implements suggestion from Jeff on the kdebindings list

	CCMAIL: kde-bindings@kde.org

2004-07-19  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added Qt::Enum type. Before a C++ enum was being marshalled to a
ruby
	  Integer, and the type name of the enum was lost. A Qt::Enum is a
subclass
	  of Integer with an extra type name.
	* This fixes a problem with overloaded method resolution where two
methods differ
	  only be an enum type such as this:

	    # KPasswordEdit(EchoMode echoMode, QWidget *parent, const char
*name);
	    # KPasswordEdit(EchoModes echoMode, QWidget *parent, const char
*name);

	    pw2 = KDE::PasswordEdit.new(KDE::PasswordEdit::ThreeStars,
page, "")

2004-07-17  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* After a non-const string arg was passed to a method, the value of
the QString
	  is copied into the ruby value. But it wasn't being correctly
converted to the
	  correct string format according to $KCODE.
	* QString to ruby string conversions in QStringLists were not
localised either.

2004-07-14  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Removed superfluous '(void *)' cast which was causing compilation
	  problems with gcc 3.4
	* Fixes problem reported by Jochen Immend�fer on comp.lang.ruby
	  CCMAIL: kde-bindings@kde.org

2004-07-11  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Qt eucJP and Shift-JIS codecs used to support ruby $KCODE values
of 's' 
	  for SJIS and 'e' for EUC

2004-07-08  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added support for strings in QtRuby programs being written in
UTF-8.
	  Use the '-Ku' command line option or '$KCODE=u' in the program.
	* Removed recently added QChar marshalling as it wasn't very i18n
friendly

2004-07-07  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added QChar marshalling

2004-07-06  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fix for passing C++ 'bool*' and 'bool&' argument types
	  There is a similar problem for bool arg types as with ints, and the
mutable
	  Qt::Boolean class can be used like this:
		
	    # QFont getFont(bool * ok, const QFont&initial, QWidget* parent =
0);		
		
	    ok = Qt::Boolean.new
	    font = Qt::FontDialog.getFont(ok, Qt::Font.new("Helvetica
[Cronyx]", 10), self)
	    if !ok.nil? 
                # font is set to the font the user selected
	    else 
                # the user canceled the dialog
	    end
		
	  Use 'nil?' to test the value returned in the Boolean
	* Signal and slot type signatures are 'normalized' and any unwanted
white space
	  removed
	* Fixed problem with QByteArray arg type matching in overloaded
method resolution

2004-07-04  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fix for passing C++ 'int*' and 'int&' argument types
	  Ruby passes numeric values by value, and so they can't be changed
when passed to a
	  method. The Qt::Integer class provides a mutable numeric type which
does get updated
	  when passed as an argument. For example, this C++
method 'findByFileContent()':
		
		# static Ptr findByFileContent( const QString &fileName, int
*accuracy=0 );

		acc = Qt::Integer.new(0)
        	fc = KDE::MimeType.findByFileContent("mimetype.rb", acc)
		
	  It supports the arithmetic operators, and so expressions such
as 'acc + 3' 
	  will work.

2004-07-02  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Replaced obsolete STR2CSTR() calls with StringValuePtr()

2004-06-29  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The internal findAllMethods() method now returns nil rather than an
empty array
	  if the given classid is greater than 'smoke->numClasses'.
Otherwise, it wasn't 
	  possible to distinguish between a class with no methods, or
reaching the end of
	  the classes array.

2004-06-29  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added QStrList marshalling

2004-06-29  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Improved Garbage Collection, dispose() and isDisposed() methods
	  - When a ruby instance is garbage collected, the underlying C++
instance will only be
	    deleted if it isn't 'owned' by a parent object. Normally this
will 'just work', but
	    there are occasions when you need to delete the C++ ahead of
garbage collection, and
	    whether or not it has a parent. Use the dispose() and
isDisposed() methods like
	    this:
		
		item0.takeItem(item1)  
		item0.insertItem(item1)  
		
		item2.dispose
		if item2.isDisposed
		    puts "item2 is disposed"
		end

	  - Fixes problem reported by Hans Fugel
	
2004-06-26  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The marshalling TypeHandler function pointers are now looked up in
a
	  QAsciiDict, rather than a ruby Hash.
	* Some unused functions removed
	* QtRuby version upped to 0.9.8

2004-06-09  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* New flags were added for Smoke methods - mf_internal and
mf_copyctor.
	  This allows copy constructors which are only used internally by the
ruby
	  runtime, to be excluded from the standard api.


2004-05-12  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* When ARGV was passed to the Qt::Application constructor, it was
being
	  altered, and the name of the ruby program added as a first entry.
The
	  constructor now uses a copy of the array, and ARGV is left
unchanged.

2004-05-03  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added a '-kde' option to the rbuic tool to generate
require 'Korundum'
	  instead of require 'Qt' statements, and use KDE widgets.

2004-04-30  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Applied patch from Marek Janukowicz.
	* The patch fixes some perlisms, that caused errors on loading a Ruby
file
	  generated from .ui file for Qt::MainWindow subclass

2004-04-20  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The rbuic now correctly names KDE widgets with a KDE:: prefix
	* If the rbuic -x option is used, a KDE top level is generated if any
	  KDE widgets have been found.

2004-04-17  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed bug in rbuic generated code for setResizeMode()

2004-04-05  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Improved classname resolution for QListViewItem and QTableItem
subclasses using rtti() calls

2004-03-26  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Ruby slots and signals are now inherited correctly
	* This causes problems with code generated by the rbuic utility
	* Fixes bug 78273 reported by Imobach Sosa

2004-03-10  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* When a mutable, non-const QString, int*, int&, bool* or bool& is
passed
	  to a method, the corresponding ruby value is now updated after the 
	  method call.
	* Some f'ns are no longer static, so that the korundum extension can
link
	  against them.

2004-03-03  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The f'n new_qobject is no longer static, and can be called from
korundum

2004-03-01  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed bugs in QCString, QString and QByteArray marshalling.
	  - When a C++ method with a mutable, non-const QCString arg type 
	    is called from ruby, the C++ arg value is copied back into the
	    corresponding ruby arg VALUE after the call.
	  - A pointer to a locally allocated QString was being returned,
	    giving memory corruption problems.
	* The default debug level in qtruby.rb is DebugLevel::OFF, otherwise
	  very verbose error messages are produced.

2004-01-28  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed bug where a QCString was being ranked equally with a QString,
	  when resolving ambiguous method overloading. Caused the KDE::URL
	  constructor to fail with a string arg.

2003-11-29  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added DOM:: namespace for the DOM:: classes in the Smoke library.
	* The scope operator in nested classnames is now '::' rather
	  than '__', so changed the qtruby runtime to expect that.

2003-11-13  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added the KillerFilter event filtering example from chapter 16
	  of 'Programming with Qt'
	* Improved classname resolution via the Qt rtti mechanisms in
	  QObject, QEvent and QCanvasItem. This fixed a problem in the
	  KillerFilter example when a QMouseEvent was passed to the ruby 
	  event handler, it was being instantiated as a ruby Qt::Event, 
	  rather than a Qt::MouseEvent.

2003-11-11  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Improved nil argument matching, and nil can match any type now
	  not just classes. Translated the code from the Qt.pm in PerlQt,
	  after discussion on the kde-perl list.
	* Fixed bug in rbuic where a C++ 'QString::null' was "" in ruby, and
	  should have been a nil.

2003-11-08  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Finally fixed huge leak, causing the progress.rb example to grow by
	  1 Mb a minute.
	* Added a cache from ruby classname to Smoke class id
	* Speeded up method selector look ups
	* Put some C++ code inside blocks to ensure that the destructor clean
	  up code was called, when the current f'n longjmp's up the stack
rather
	  than returns normally.
	* QtRuby looking good, raised the version to 0.9.6 to celebrate

2003-11-07  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed some memory leaks
	* Ensured that any instance 'owned' by ruby, ie with the the
allocated
	  flag set to true, is always added to the pointer_map.
	  Otherwise, the same C++ instance can be wrapped twice and will be
deleted
	  twice.

2003-11-03  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* When marshalling a const ref type to a ruby VALUE, it is now copied
	* Applied some fixes for construct_copy() from the PerlQt version of
	  handlers.cpp
	* Fixed some minor bugs in the progress.rb Qt example

2003-11-03  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added method selector caching for class methods and constructors,
	  although performance still 'sedate' compared with C++ or Perl.

2003-10-29  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The smokeruby_mark() f'n now marks the QListViewItems in a
QListView
	* Fixed a QLayoutItem crash in smokeruby_free()

2003-10-27  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The smokeruby_mark() f'n was completely wrong, as it is only called
if 
	  the current object is already marked. So marking the current object
	  doesn't make a lot of sense. Instead, if the instance is a kind of
	  QObject then its childeren are marked.
	* The smokeruby_delete() object doesn't delete instances which have
	  parents of one sort or another.
	* Made some fixes to the tutorial examples
	* Removed equality '==' operator overloading as it only expects a
single
	  arg in ruby, and not two.

2003-10-22  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Changed some error messages in do_method_missing() to be 'debug
only' for now.

2003-10-22  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Got the checklists.rb example working after bug report from Mikhail
Yakshin
	  - Corrected some coding errors in the example itself.
	  - The arg matching code in method_missing() has been improved and
simplified.
	  - In the overloaded arg type resolution matching, an enum is
type 'long'
	  - A class which matches exactly is a better match than a subclass.
	    Multiple matches are allowed as long as there is a 'best match'.
	  - Operator overloading now looks for methods of the
form 'operator+=',
	    'operator-=' etc in the Smoke runtime.

2003-10-14  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed serious random crash problem
	  - qt_invoke() and qt_emit() were not calling super if a ruby signal
or
	    slot hadn't been found, which stopped C++ signals from working. 
	  - This prevented destroy() signals from invoking event filter list
clean
	    up when a QObject was deleted, leaving deleted instances in the
list.
	  - 'QUObject*' args are now marshalled as a ruby list with a single
	    entry of a VALUE wrapping the pointer.
	* The ruby ALLOCA_N macro is no longer used as it is based on
alloca(),
	  which doesn't seem a good idea. malloc(), calloc() and free() are
used
	  instead

2003-10-11  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added khtml:: namespace, although it isn't in the SmokeKDE runtime
yet
	* Improved method_missing error messages if a method can't be
resolved

2003-10-09  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added KIO:: and KParts:: namespaces for the new classes in
libsmokekde

2003-10-08  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Korundum KDE ruby extension 
	  - made various changes so it can be linked against the QtRuby code

2003-09-18  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Removed leading 'K' from class names of when adding to KDE::
namespace.
	  As per Germain Garand's suggestion on the kde-bindings list:

	  ..actually, I used the same scheme as for Qt when possible, that
is:
	        $class =~ s/^Q/Qt::/ or
	        $class =~ s/^K/KDE::/ or
	        $class = "KDE::" . $class
	        unless $class eq "Qt";

2003-09-18  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added support for KDE classes under module KDE:: for use with
	  the new libsmokekde.so. You can now write KDE programs in Ruby,
	  here is Hello World:

	    about = KDE::KAboutData.new("one", "two", "three")
	    KDE::KCmdLineArgs.init(1, ["four"], about)
	    a = KDE::KApplication.new()
	    hello = KDE::KPushButton.new(nil) { setText "Hello World" }
	    a.setMainWidget(hello)
	    hello.show()
	    a.exec()

2003-09-14  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The rbuic -embed option finally works. Fixed QByteArray
marshalling.

2003-09-13  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Improved the rbuic -embed option, and added some fixes

2003-09-12  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* More passing blocks to constructors fun! You can now also pass 
	  an arg to the block, and it will be run in the context of the arg:
		
		w = MyWidget.new { |theWidget| theWidget.setCaption "foobar" }

	I got this idea from the FXRuby bindings, from the ChangeLog:

	"This approach has the advantage that the initialization code now has
	access to the outer scope, as blocks normally would. Thanks to
	Rich Kilmer for this suggestion."

	If you don't pass an arg to the block, the block is run in the
context 
	  of the new instance as before.

	* Debugging left in handlers.cpp (must stop doing this)

2003-09-12  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Marshallers now return Qnil, rather than Qundef (for internal use
only)

2003-09-10  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Improved garbage collection with various 'ad hoc' rules from the
	  QtJava bindings about when it's ok/not ok to destruct an instance.
	  Not always just a 'parent() != 0' check in Qt.

2003-09-10  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added QByteArray <-> Ruby string marshaller

2003-09-09  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Blocks can now be passed to constructors, like this:
	    w = MyWidget.new { setCaption("foobar") }

2003-09-08  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added method selector caching, scribbling may be slightly faster..

2003-09-08  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* GC getting closer to working. Debugging code improved.

2003-09-08  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* From below 'watch out for extra crashes!' - indeed! Have now
disabled
	  smokeruby_free() and smokeruby_mark() until garbage collection
works.

2003-09-08  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* The pointer_map is now a QPtrDict rather than a ruby Hash, and
	  the entries are weak references. An implementation was tried 
	  using the ruby WeakRef class, but it didn't work because
rb_gc_mark()
	  didn't prevent them being garbage collected.
	* smokeruby_free() and smokeruby_mark() have been implemented
	* The C++ instance for a ruby object is deleted in smokeruby_free(),
	  so watch out for extra crashes!
	* Improved README with more details about QtRuby

2003-09-07  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Improved error message handling, changed rb_error() calls to
rb_raise()
	* Decided changing method calls like foobar? to isFoobar() not a good
idea,
	  as the Qt property could just as also be hasFoobar() or foobar() 

2003-09-06  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Set methods such as autoMask= are converted to setAutoMask()
	* Get methods such as modal? are converted to isModal()

2003-08-31  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* rbuic code generation brought up to date wrt Qt 3.2 uic
	  Main change is that a 'languageChanged()' method is generated

2003-08-30  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* rbuic() code generation fixes

2003-08-30  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added 'Run Selection' menu option to the QtRuby shell

2003-08-30  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Operator methods are now called 'operator..' in QGlobalSpace and
not renamed
	* Added unary minus, and a test in opoverloading.rb

2003-08-29  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Updated TODO list, improved rbuic code generation for images

2003-08-28  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Improved operator overloading to work with operators not in
QGlobalSpace

2003-08-27  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Changed the operator overloading implementation to be more like
PerlQt

2003-08-27  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Translated the rbqtsh filePrint() method from perl

2003-08-26  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added 'changed' attribute to the MetaInfo class, so that the C++
metaObject
	  is reconstructed if the slots or signals are changed.
	* Changed window title on rbqtsh to 'QtRuby'. The example slot now
works
	  correctly. Only just tried this utility - Wow Alex!!

2003-08-26  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* findMethod() now looks in the QGlobalSpace pseudo class as well as
the normal target class.
	* The bitBlt() code in the scribble example works correctly

2003-08-25  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Removed ugly _current_object global variable. 
          The current target object is now passed to the MethodCall
constructor.

2003-08-25  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Removed obsolete rb_enable_super() calls
	* Removed test for _current_object in class_method_missing()
	* Fixed missing index in signalInfo() method
	* Added Qt scribble example - TODO add Qt::PaintDevice.bitBlt() calls
to SMOKE runtime

2003-08-23  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added rbuic tool for ruby Qt Designer support

2003-08-12  Alexander Kellett   <lypanov@kde.org>

	* Add debug level setting via Qt::debug_level
	* When calling .new on a Qt object with a incorrect prototype
	  the list of appropriate constructors is printed
	* Fix a number of cases in which imperfect code would cause a crash

2003-08-11  Alex Zepeda   <zipzippy@sonic.net>

	* Various fixes to get QStringList marshalling working
	* Treat Ruby strings as UTF-8 strings in order to fix the QFont
examples

2003-08-09  Alexander Kellett   <lypanov@kde.org>

	* Added support for operator overloading

2003-08-07  Alexander Kellett   <lypanov@kde.org>

	* Added rbqtapi and rbqt tools (port of the PerlQt tools of the same
name)

2003-08-06  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Added some TODO list entries, added Alex to the AUTHORS list

2003-08-06  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed 'int&' marshalling so script name appears in window title

2003-08-12  Alexander Kellett   <lypanov@kde.org>

	* Add several new marshalling types - QCanvasItemList for example,
	  unfortuantely due to several improvements in Qt 3.2 these 
	  improvements will not be seen when compiling against Qt 3.1.2

2003-08-05  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Moved SLOT(), SIGNAL() and emit() to global scope

2003-08-05  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Removed redundant 'rb_eval_string("include Qt")' call from
extension initialization.

2003-08-05  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Qt::Application constructor safer, but program name still not
appearing in the window title

2003-08-05  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed bug in resolution of overloaded Qt::Popup.insertItem()
methods

2003-08-05  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Use new const_missing from ruby 1.8.x to allow for constant access
from base class, for example "Qt::RichText"
	* QString::null now maps onto Qnil, rather than a zero length ruby
string

2003-08-04  Alexander Kellett   <lypanov@kde.org>

	* Allow for accumulative slots/signals declarations in a class
	* Minor build fixes

2003-08-02  Alexander Kellett   <lypanov@kde.org>

	* Fix several deprecation warnings when running under 1.8.x
	* Several more build fixes

2003-08-01  Alexander Kellett   <lypanov@kde.org>

	* Slightly improve ease of debugging of qtruby programs 
	  which subclass Qt base classes by print out some useful
	  debugging informationn when/if method_missing ever 
	  fails to find a matching function in the baseclass.

2003-08-01  Alex Zepeda   <zipzippy@sonic.net>

	* Remove need to manually run extconf.rb by some automation via a
configure.in.in
	* Various other build fixes

2003-07-31  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed bug in marshalling QString::null to a ruby VALUE

2003-07-31  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Changed require in Qt.cpp to 'Qt/Qt.rb' instead of 'lib/Qt/Qt.rb'

2003-07-31  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* Fixed problem with non-working installed version, lib/Qt.rb moved
to lib/Qt/Qt.rb

2003-07-30  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

	* QtRuby - a Ruby SMOKE adaptor for Qt, initial checkin


