2009-02-02  Richard Dale  <richard.j.dale@gmail.com>
	* Make Korundum build with Ruby 1.9

2009-01-13  Richard Dale  <richard.j.dale@gmail.com>
	* The enum KDE::File::File was conflicting with the Ruby class 'File' and
	  not working properly. So special case it and make it a constant. Thanks
	  to David Palacio for finding the problem.

2008-12-17  Richard Dale  <richard.j.dale@gmail.com>
	* The KCmdLineArgs.count method was looping - thanks to Simon St James
	  for reporting the bug.

2008-11-24  Richard Dale  <richard.j.dale@gmail.com>
	* Added a QMap<QString,KTimeZone> marshaller

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

	* Special case the KDE::StandardAction.open method so it gets called and not
	  Kernel.open. Thanks to Stefano Crocco for reporting the error.

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

	* The KDE::Dialog exec method was giving a ArgumentError exception.
	  Also fixed some other classes with exec() methods. Problem reported 
	  by Stefano Crocco

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

	* Added a KSharedPtr<KMimeType> marshaller so that the 
	  KMimeType::findByPath() method can be used in Ruby

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

	* The KDE::ActionCollection#addAction method wasn't working with the two
	  argument form where the second arg was either a KDE::Action or a 
	  Qt::Action as the normal overloaded method resolution code can't 
	  distinguish between the two. So special case it for now. Fixes problem 
	  reported by Stafono Crocco. For example, the following code now works
	  correctly:

		 a1 = KDE::RecentFilesAction.new "Recent", action_collection
		 action_collection.addAction "recent", a1
		 a2 = Qt::Action.new(self)
		 action_collection.addAction "foobar", a2


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

	* The special cased KDE::ConfigSkeleton.new(nil) constructor wasn't 
	  working

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

	* Fix the KService offer list marshaller

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

	* Change the layout of the smokeruby_object struct in kpluginfactory to
	  match the new layout in QtRuby.

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

	* In krubypluginfactory only call ruby_init_loadpath() once as otherwise
	  the same paths get added everytime a new plugin is loaded.

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

	* Add more ruby friendly versions of KDE::ConfigGroup.readEntry() and
	  writeEntry(). Update the tutorial examples to match.

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

	* The rbkconfig_compiler wasn't being built as the CMakeLists.txt
	  file was missing from korundum/tools. Thanks to Stefano Crocco for
	  spotting that.
	* Korundum now builds ok as it needed to include marshall_basetypes.h
	  from QtRuby

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

	* Don't embed qtruby into korundum, but link against qtruby4shared
	  instead.

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

	* Fix the KDE::CmdLineArgs.init() method to work with Ruby Strings and
	  convert them to Qt::ByteArrays.

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

	* Remove the remaining soprano parts from korundum.

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

	* When a Ruby class called MyApp::FooBar is instantiated it is put in a
	  global variable called '$my_app_foo_bar + <numeric id>' to prevent it
	  being garbage collected. The numeric id is used to allow more than
	  instance of a class to be run, the plugin runtime looks for the first
	  global variable for the class that isn't being used, starting at an
	  id of 1.

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

	* Changed the way the Ruby classname is derived from a 
	  X-KDE-PluginKeyword entry in a desktop file. The directory name is now
	  used to derive a Ruby module name and the Ruby script name used to 
	  derive a class name within that module. So given a path of 
	  'my_app/foo_bar.rb' krubypluginfactory would expect a MyApp::FooBar 
	  class in the Ruby file. Otherwise the Ruby classname would need to
	  be unique across all plugins loaded by a KDE app, and it is easy
	  to get clashes such as two 'Clock' classes.
	* Special cased KDE::ComponentData so you can pass Ruby Strings to it
	  as well as Qt::ByteArrays

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

	* Oops, the KConfigSkeleton constructors didn't quite work..

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

	* Added an rbkconfig_compiler4 tool for compiling .kcfg and .kcfgc
	  files to Ruby.
	* The various KDE::ConfigSkeletonItem classes needed special casing
	  because of the C++ specific way they manage a reference to an
	  instance outside themselves. In Ruby the value of a 
	  KDE::ConfigSkeletonItem can only be accessed via property() and 
	  setProperty() methods.

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

	* The krubyapplication executable now works correctly. It was creating
	  the mainComponent to find the top level ruby script, which meant a 
	  dummy KAboutData instance was being created for the app. When the
	  real KAboutData was provided by the Ruby code it was ignored. 
	* krubyapplication now only takes one argument:

		krubyapplication <application directory>/<ruby script>

	  The application directory is always the same as the app name and so
	  a seperate arg was redundant.

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

	* Made KDE::CmdLineArgs Enumerable so that it is easy to iterate through
	  the args. For example:

		args = KDE::CmdLineArgs.parsedArgs
		args.each {|arg| puts arg}

	* Allow args["formfactor"] as an alternative to args.getOption("formfactor"),
	  and args[1] as an alternative to args.arg(1)

	* Improved the KDE::MainWindow.kRestoreMainWindows method so that you
	  no longer need to pass it a list of classes, and you can give it an
	  optional block to execute for each newly created window. For example:

		KDE::MainWindow.kRestoreMainWindows {|window| window.caption = "foo"}

2008-04-22  Richard Dale  <rdale@foton.es>

	* Made the krubyapplication executable work with args to be passed to the
	  KDE ruby app. 
	* Changed the dbpedia_references example to use a .desktop file and be 
	  installed by a CMakeLists.txt file

2008-04-21  Richard Dale  <rdale@foton.es>

    * Add a krubyapplication executable for starting ruby KDE apps. It takes
	  two args; the name of the app followed by the directory/ruby script
	  name. Example usage:

	  krubyapplication dbpedia dbpedia_references/dbpedia_references.rb

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

	* Special cased the name() method in various classes as it clashes with
	  a Ruby method called name() as wasn't getting called. Thanks to
	  Stefano Crocco for reporting the bug.

2008-04-14  Richard Dale  <rdale@foton.es>

	* When a KDE::Application is created set up the $qApp global variable
	  as well as $kapp

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

	* Improved the code to special case Ruby String to Qt::ByteArray 
	  conversions in the KDE::About* classes

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

	* The name of the main class to load for a plugin is derived from the
	  source filename, and so in a file called 'foo_bar_baz.rb' expect a class
	  called FooBarBaz

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

	* Borrowed a function from the kross code to put out an error message 
	  and stacktrace on stderr for the current exception in the 
	  krubypluginfactory code.

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

	* Added some range=(Range) methods as synonyms for setRange(Integer, Integer),
	  for KDE::DoubleNumInput, KDE::IntNumInput and KDE::IntValidator

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

	* If anything goes wrong with the krubypluginfactory ruby plugin loading, then
	  print a ruby backtrace before exiting.
	* Use rb_protect() when creating the plugin instance for more robustness

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

	* Fixed problem with the KDE::CmdLineOptions.add() method reported by Andreas
	  Pakulat - it will now convert String args to Qt::ByteArrays
	* Now KConfigGroup readEntry() and writeEntry() can be passed QVariants as value
	  it shouldn't be necessary to special case them in ruby.
	* Added a KSharedConfigPtr marshaller

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

	* Literals in a Soprano ActiveRDF SPARQL query result set are now returned as
	  just the ruby values from the underlying QVariant instead of a string with the
	  xsd type in it.
	* Added the Qt types Qt::ByteArray, Qt::Date, Qt::DateTime and Qt::Time to the
	  ActiveRDF Literal module in the adapter. It adds the methods xsd_type() and
	  typed() to these classes.
	* Oops, the module is now called QtLiteral so it doesn't wipe out the original
	  one.

2008-03-26  Richard Dale  <rdale@foton.es>
	
	* Added update methods to the Soprano ActiveRDF adaptor
	* Fixed bug in the Soprano::Node inspect method

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

	* Remove the rbkconfig_compiler and associated code as afaik it wasn't being used
	  in kde3 korundum and currently causes crashes in korundum4.

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

	* Work round the problem with DBusQueryResultIterator.current only ever returning
	  one binding by retrieving each binding value individually with bindingByName()

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

	* Added some more methods to the Soprano::Client::DBusQueryResultIterator class
	  from the org.soprano.QueryResultIterator.xml interface
	* Added an adaptor for using ActiveRDF with soprano

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

	* Added support for communicating with the Soprano server over DBus
	  For example:

		client = Soprano::Client::DBusClient.new
		model = client.createModel("NewModel")

		statements = model.listStatements(Soprano::Statement.new(Soprano::Node.new, Soprano::Node.new, Soprano::Node.new))
		statements.each do |statement|
  			p statement.subject
  			p statement.predicate
  			p statement.object
		end

		query = <<EOS
		PREFIX xls: <http://www.w3.org/2001/XMLSchema#>

		SELECT ?person
		WHERE {
    		?person <http://www.w3.org/2000/01/rdf-schema#comment> "Another Class"^^xls:string .
		}
		EOS

		results = model.executeQuery(query, Soprano::Query::QueryLanguageSparql)
		results.each do |result|
  			p result[:person]
		end

	* Note that where a C++ iterator would have been returned, a Ruby Enumerable instance
	  is returned.

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

	* Make a start with converting the UISampler example app to KDE4

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

	* Ported the tutorial examples p1-p9 to KDE4 and DBus
	* The KAboutData constructor and addAuthor methods can be passed strings
	  which are then converted to Qt::ByteArrays for convenience
 
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-09-18  Richard Dale  <rdale@foton.es>

	* Added a patch from  Matthias Kretz to use generic plugin code for loading a ruby plugin. 
	  Thanks to Matthias for the patch.
	* Added marshalling from the args in a QList<QVariant> to a Ruby array
	* After the new QObject instance is created set its to the parent passed to the 
	  KPluginFactory::create() method

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

	* The KDE::Application.exec method wasn't being called correctly

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

	* Made korundum build with the current kdelibs classes

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

	* Korundum now builds with KDE4, renamed the extension 'korundum4' for 
	  now
	* Added some KDE4 list type marshallers

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

	* Qt4/KDE4 port, initial checkin
	* The korundum sources compile against Qt4

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

	* DCOP signals were failing with a 'undefined method `fullSignalName'' error
	* Fixes problem reported by Chris Gow

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

	* At the moment require 'Qt' and require 'Korundum' statements can't appear
	  in the same ruby program. Suitable fatal error messages are now displayed
	  to indicate the cause of the problem. Fixes bug reported by Caleb Tennis
	  and Dave M

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

	* KDE::DCOPRef.methods now returns remote DCOP methods as well as the local methods in
	  the DCOPRef. So now irb tab completion works with dynamically discovered DCOP methods,
	  in a DCOPRef.

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

	* Added some #ifdefs so the bindings build with KDE 3.1.x
	* Fixed problem with rbkconfig_compile Makefile.am

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

	* Fixed problems caused ''include Qt'' and "include KDE" statements in korundum.rb where a 
	  couple of methods were being added to  class Module was causing all the Qt and KDE methods
	  to be added to Module.

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

	* Added marshallers for KIO::UDSEntry and KIO::UDSEntryList, and accessor methods for
	  fields in the KIO::UDSAtom struct. Fixes problem reported by Ian Monroe.

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

	* Added some fixes for the rbkconfig_compiler code generation and
	  example code.
	* The method 'isImmutable' is added to KDE::ConfigSkeletonItems
	  as a special case - it's missing from the Smoke runtime as it's
	  from a template based superclass.

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

	* Translated the rbkconfig_compiler examples from C++ to ruby,
	  and improved the build rules in the Makefile.ams

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

	* The rbkconfig_compiler now uses Qt::Variants to hold the values in KDE::ConfigSkeleton 
	   instance variables. 
	* The values of the KDE::ConfigSkeletonItems are then set as properties with the Qt::Variants. 
	  It wasn't possible to handle references to primitive types such as 'int&' via ruby, so properties are 
	  a more 'scripting language' oriented approach. 
	* The embedded code in the .kcfg examples was converted from C++ to ruby 

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

	* Tidied up the rbkconfig_compiler code
	* Added marshaller for KConfigSkeleton::ItemEnum::Choice lists to and from ruby Arrays,
	  and accessor methods for the Item::Enum::Choice struct.

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

	* Added rbkconfig_compiler for compiling .kcfg files to ruby

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

	* Added inspect() and pretty_print() methods for KDE::AboutPerson and KDE::AboutTranslator,
	  along with some more fields in the KDE::AboutData inspector

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

 * The DCOPObject inspect method was crashing if the instance hadn't been fully
   constructed
 * The kde_resolve_classname function's arg types were changed to match the new
   ones in the resolve_classname() function of QtRuby/handlers.cpp.

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

 * DCOPObject inspect() and pretty_print() methods added

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

 * More inspect() and pretty_print() methods for common classes to improve debugging -
   KDE::DCOPRef, KDE::Service, KDE::URL, KDE::AboutData.

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

 * References to Qt.qWarning() changed to qWarning()

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

 * Fixed crashes in the KURL::List marshalling. A copy is now made of each KURL item
   in the list when being marshalled to a ruby Array. When a KURL::List is deleted the
   contents are all deleted too as it's a QValueList. Hence, the need to make copies.

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

 * The RESTORE() method is no longer an KDE::Mainwindow method, but a globally available
   Object method

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

 * Added I18N_NOOP() and I18N_NOOP2() methods

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

 * Set global flag 'application_terminated' when KDE::Application or KDE::UniqueApplication
   has returned from exec(). 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-08  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Reverted recent fix for crash on exit, as it only occured with a Qt::Application and
   seems to introduce a crash in KDE apps where none existed before.

 CCMAIL: kde-bindings@kde.org
 CCMAIL: thibauld.favre@laposte.net

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

 * When a Korundum application exits, the top level widgets are now destroyed
   as well as the KDE::Application itself. This fixes a problem where the ruby garbage
   collection frees instances in an arbitrary order afer the program has exited, and
   destroys a Hash containing QMetaData info needed for tidying up.

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 KDE::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-03  Richard Dale  <Richard_Dale@tipitina.demon.co.uk>

 * Removed warning about '*' being used as an argument prefix

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

 * Added some rtti tests for DOM::Node to instantiate a more accurate ruby class

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

 * The resolve_classname() function in qtruby 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.

 * This fixes a problem reported by Zack Rusin where a KArchiveEntry returned to ruby was not being
   correctly constructed as either a KArchiveDirectory or KArchiveFile according to 
   the KArchiveEntry::isDirectory() method

 CCMAIL: zack@kde.org


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

 * Added marshallers for KPluginInfo::List and QPtrList<KParts::Plugin>

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

 * The KDE::UniqueApplication constructor now sets up the $kapp global variable

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

 * Added $kapp global variable, example usage:

     config = $kapp.config()

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 DCOP 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 dcop function:
  
     process_can_be_reused(1234)
  
     processCanBeReused(1234)

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

 * The form 'foo?' can be used as a synonym for isFoo() or hasFoo() dcop methods. 
 * Instead of:
         result = dcopRef.isFoo()
 * Use this more rubyish form:
         result = dcopRef.foo?
         if result.nil?
             puts "DCOP predicate failed"
         else
             puts "foo? is #{result}"
         end


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

 * The 'qWarning()' calls in korundum.rb needed to be prefixed with the 'Qt.'' module
   otherwise a missing dcop call causes an infinite loop.

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

 * Added KServiceGroup::List to ruby array marshaller

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

 * Fixed regression bug in emitting dcop signals

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

 * Added a KMountPoint::List marshaller

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

 * Removed the various Q_INT32 etc types from the Smoke stack <--> QDataStream
	  marshalling. This was because the code generated by the dcopidl2cpp tool
	  doesn't have them. So if a machine has native 64 bit ints, then that width 
	  will be used rather than Q_INT32.

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

	* Added a couple of template methods for marshalling QValueLists and QMaps.
	* Included a quite a few new marshaller functions for QPtrLists, as well as
	  the two types above.

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

	* Fixed crash in marshalling KMimeTypes and KServiceGroups to ruby values

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>

	* Added error messages for invalid dcop slot or signal declarations

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

	* DCOP error messages now go via qWarning() rather than puts()

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

	* Added QMap<QCString,DCOPRef> marshalling to and from Smoke as well as dcop

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

	* DCOP reply types can now contain colons
	* Added KURL::List to ruby Array marshalling, fixed crash when
	  marshalling from a ruby Array to a KURL::List
	* Add KURL::List ruby <--> dcop marshalling

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

	* Added QMap<QString,DCOPRef> ruby <--> dcop marshalling

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

	* Tidied up the dcop meta object code a bit

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

	* If a ruby class with 'k_dcop' declarations isn't a subclass of DCOPObject,
	  only one instance of a DCOPObject is created no matter how many instances
	  are instantiated.

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

	* Tidied code - removed unnecessary action_map_to_list helper method

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

	* QDataStream temporary variables added for the Q_INT32 etc types when
	  writing to a Smoke stack from a QDataStream.

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

	* Added casts to the various macros like 'Q_INT32' when writing a Smoke
	  stack to a QDataStream

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

	* Added QValueList<QCString> marshalling ruby <--> dcop

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

	* Ruby dcop slots can now return actionMaps and windowLists as
	  'QMap<QString,DCOPRef>' and 'QValueList<DCOPRef>' types

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

	* Added missing 'QMap<QString,DCOPRef>' dcop reply marshalling
	* The recently added dcop reply type 'QValueList<DCOPRef>' now works
	* The parsing of a dcop function type signature to add it to the cache
	  was wrong if the reply type contained angle brackets or commas

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

	* Added dynamic ruby to C++ argument type resolution in DCOPRef calls.
	  When a call of the form 'dcopRef.getPoint(5, "foobar")' is made, the C++
	  type signature is obtained from the list of those returned by 
	  DCOPRef.functions(). If the function name is overloaded, the ruby arg
	  types are used to pick the correct call.

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

	* Made 'parrot.age = 7' a synonym for 'parrot.setAge(7)' with dcop refs

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

	* More missing DCOP marshallers - QStringList and QCStringList
	* A class with a 'k_dcop' slots declaration can now be an instance
	  of DCOPObject
	* Converted the 'petshop' DCOP server example from pykde python

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

	* Added missing QCString DCOP marshalling

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

	* Removed the recently added QValueList<DCOPRef> marshaller as no '<<'
	  or '<<' QDataStream marshallers are in the Smoke runtime
	* Added missing primitive type marshalling to and from a DCOP QByteArray

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

	* Fixed completely non-working DCOP call reply marshalling. An instance wasn't
	  being constructed to read the QByteArray containing the reply via a QDataStream.

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

	* Added QValueList<DCOPRef> marshalling

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

	* Converted various example app templates from pykde to ruby Korundum

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

	* A DCOP send() now correctly returns true or false according to success
	* DCOP call()s with void or ASYNC return types return true on success,
	  or nil on failure

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

	* Improved the KSharePtr item marshalling so that a copy of the item
	  is constructed with no accompanying smart pointer. The new item
	  can be owned by ruby without needing to special case deref'ing
	  the pointer on destruction. Apart from KService's don't have a 
	  public copy constructor, where the ref count is incremented to
	  prevent their destruction.

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

	* The full C++ type signature is no longer needed in DCOP calls:

	    dcopRef = KDE::DCOPRef.new("dcopslot", "MyWidget")
		
	  There are three different ways to specify the call:
	    1) res = dcopRef.call("getPoint(QString)", "Hello from dcopsend")
	    2) res = dcopRef.call("getPoint", "Hello from dcopsend")
	    3) res = dcopRef.getPoint("Hello from dcopsend")
		
	    puts "result class: #{res.class.name} x: #{res.x} y: #{res.y}"

	* Send to a DCOPRef is similar:
	    1) dcopRef.send("mySlot(QString)", "Hello from dcopsend")
	    2) dcopRef.send("mySlot", "Hello from dcopsend")

	* If the type signature of the target dcop slot is ommited it is derived
	  from the ruby argument types:
	  
	    String => QString
	    Float => double
	    Integer => int
	    Qt::Widget etc => QWidget
	    KDE::URL etc => KURL
	    [] => QStringList

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

	* Reverted fix for QChar args being passed as ruby strings after
	  discussion with Germain Garand. A QChar arg is now passed like this:

	    cs = KDE::CharSelect.new(self, "chselect", nil, Qt::Char.new(0), 0)

	  This will no longer work for now:

	    cs = KDE::CharSelect.new(self, "chselect", nil, ' ', 0)

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

	* Translated the excellent pykde 'UISampler' app to ruby
	* Added KAction list marshalling
	* KDE::MainWindow.RESTORE() and kRestoreMainWindows() methods added.

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

	* Added more translated pykde examples
	* The type signatures of dcop signals and slots are now normalized and unwanted
	  white space is removed

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

	* Translated some pykde example programs from python to ruby
	* Added various marshallers for the KSharedPtr related methods/classes

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

	* Replaced obsolete STR2CSTR() calls with StringValuePtr()

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

	* DCOP Signals now work, they are defined like this:
	
	    k_dcop_signals 'void testEmitSignal(QString)'
		
	    def doit()
	        puts "In doit.."
	        emit testEmitSignal("Hello DCOP Slot")
	    end
	  	  
	* Connect slot 'mySlot' to a DCOP signal like this:
	
	    res = slottest.connectDCOPSignal("dcopsignal", "SenderWidget", 
		                             "testEmitSignal(QString)", "mySlot(QString)", 
					      true)

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

	* Added DCOPRef.call() and send() support. 
	* Define a dcop slot like this in one ruby program:

	    k_dcop 'QPoint getPoint(QString)'

	    def getPoint(msg)
		puts "message: #{msg}"
		return Qt::Point.new(50, 100)
	    end

	* Call it from another program and print the reply, like this:

	    dcopRef = KDE::DCOPRef.new("dcopslot", "MyWidget")
	    res = dcopRef.call("QPoint getPoint(QString)", "Hello from dcopsend")
	    puts "result class: #{res.class.name} x: #{res.x} y: #{res.y}"

	* Send to a DCOPRef is similar:
	    
	    dcopRef = KDE::DCOPRef.new("dcopslot", "MyWidget")
	    dcopRef.send("mySlot(QString)", "Hello from dcopsend")
	
	* Note that the full type signature of the target dcop slot must be
	  specified at present.

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

	* Added marshaller for KTrader::OfferList to ruby array
	* Used DOM::Node rtti to instantiate a ruby value with the correct subclass

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

	* If the DCOP reply type is 'void' or 'ASYNC', it isn't marshalled into the
	  QByteArray 'replyData' arg of DCOPObject::process().

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

	* Slots and signals couldn't be added to KDE classes, such as KDE::PushButton

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

	* A DCOPClient instance is now created for classes with a 'k_dcop_signals'
	  declaration, and emitDCOPSignal() is called on that.

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

	* Ruby DCOP support now working - here is some example code:

		require 'Korundum'
		class MyWidget < KDE::PushButton
			k_dcop 'QPoint mySlot(int,QString)'
	
			def initialize(parent, name)
				super
			end
			
			def mySlot(counter,greeting)
				return Qt::Point.new(50, 100)
			end
		end

	  - This slot is passed an integer and a string, and returns a Qt::Point.
	  - Note that the class doesn't have to inherit from DCOPObject. If you
	    include a 'k_dcop' slots declaration a 'listener' dcop object instance
	    is created automatically.


2004-01-08  Alexander Kellett  <lypanov@kde.org>
	* Imported krubyinit sources, thus at last fixing the startup segv's with gentoo/x86/qt 3.2.

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

	* Korundum - a Ruby SMOKE adaptor for KDE, initial checkin (proxy commit from lypanov)

