diff options
Diffstat (limited to 'qtruby/ChangeLog')
| -rw-r--r-- | qtruby/ChangeLog | 1640 |
1 files changed, 1640 insertions, 0 deletions
diff --git a/qtruby/ChangeLog b/qtruby/ChangeLog new file mode 100644 index 00000000..89e65292 --- /dev/null +++ b/qtruby/ChangeLog @@ -0,0 +1,1640 @@ +2007-02-19 Richard Dale <[email protected]> + + * Fixed a bug where the sort method of Qt::ListView and Qt::ListViewItem + was no longer working, as the classes are 'Enumerable' and ruby was + calling the ruby sort method instead. Thanks to kelko for reporting it + on #kde-ruby. + +2006-12-05 Richard Dale <[email protected]> + + * Backported some improvements to Qt::Variants from Qt4 QtRuby + * 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 + * When marshalling QValueList<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' + * Change all instances of strcmp() to qstrcmp() + +2006-11-20 Richard Dale <[email protected]> + + * Made Qt::ListView, Qt::ListViewItem, Qt::BoxLayout, Qt::HBoxLayout, + Qt::VBoxLayout and Qt::GridLayout Enumerable with implementations + of each() so they don't need to use the Qt External iterators like + Qt::LayoutIterator anymore. For instance: + + lv = Qt::ListView.new do + ["one", "two", "three", "four"].each do |label| + Qt::ListViewItem.new(self, label, "zzz") + end + end + + lv.each do |item| + p item.inspect + pp item.inspect + end + + * Add inspect() and pretty_print() methods to Qt::ListViewItem so that + they show the text of their columns + +2006-09-19 Richard Dale <[email protected]> + + * Upped the QtRuby version to 1.0.13 for the KDE 3.5.5 release + + * Fixed a crash when a slot was inherited by a subclass, and the + subclass had no slots or signals of its own + +2006-09-17 Richard Dale <[email protected]> + + * 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-14 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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-08-29 Richard Dale <[email protected]> + + * Backported some memory leak fixes from Qt4 QtRuby + +2006-08-10 Richard Dale <[email protected]> + + * The Ruby VALUE to 'uchar *' marshaller wasn't working correctly if the + Ruby string contained nulls. Fixed by Dirk Mueller (thanks) and also + applied for 'char *' types. + +2006-07-12 Richard Dale <[email protected]> + + * 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-05 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * For Qt::QObject classes which are immediate subclasses of Qt::Base, + don't add C metaObject() and qt_invoke() 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. + +2006-05-20 Richard Dale <[email protected]> + + * 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. + +2006-05-15 Richard Dale <[email protected]> + + * Removed the customized version of Kernel.exec, Kernel.open etc + as they aren't needed anymore. + +2006-05-14 Richard Dale <[email protected]> + + * 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 + * A boolean Qt::Variant can now be constructed with a Qt::Variant.new(true) + call, and a dummy second arg (as for C++) is no longer needed. + +2006-05-07 Richard Dale <[email protected]> + + * An an type of Q_UINT16 wasn't working with QtRuby. Fixes problem + reported by maelclerambault. + +2006-05-03 Richard Dale <[email protected]> + + * The qt_emit() and qt_invoke() methods are overriden by the QtRuby + runtime. When they are called the runtime looks for a Ruby slot or + signal matching the call, and invokes it if found. If a Ruby version + wasn't found for a signal however, the qt_invoke() method was being + called in the Smoke library instead of qt_emit(). This occasionally + caused a crash in code using KDE::HTMLPart. + +2006-04-17 Richard Dale <[email protected]> + + * Made :foobar a synonym for 'foobar()' for slots and signals + * Added some calls for Qt::Event.type methods to force them + to go via method_missing() + +2006-03-29 Richard Dale <[email protected]> + + * 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-29 Richard Dale <[email protected]> + + * Added a KDE::KonsolePart class for when a konsolePart KPart is + dynamically loaded. + +2006-03-21 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Fixed bugs in const lists marshallers, where the items in the ruby + Array were wrongly being updated after a method call + +2006-02-09 Richard Dale <[email protected]> + + * The Kernel#select method was being redefined as it clashed with + Qt::SqlCursor#select and Qt::SqlSelectCursor#select methods. This + caused a problem when QtRuby was used with Rails ActiveRecord which + also has a select method. So the methods are now defined in the Sql + classes, and use method_missing() to explictly invoke the methods in + the Smoke library. Fixes problem reported by Imo Sosa. + +2006-01-18 Richard Dale <[email protected]> + + * Improved the debug logging of virtual method callbacks so that the + arg types are shown too + +2005-12-16 Richard Dale <[email protected]> + + * 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-16 Richard Dale <[email protected]> + + * Improved the code to call a C++ slot via qt_invoke() when a ruby slot hasn't + been defined. It now invokes the method in the Smoke lib directly, rather + than going via method_missing(). + +2005-12-08 Richard Dale <[email protected]> + + * 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, Qt::WhatsThis and Qt::TimeEdit. 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 'signed int&' types were not being matched or marshalled correctly + +2005-11-02 Richard Dale <[email protected]> + + * A Qt::Canvas owned by a Qt::CanvasItem is marked as in use + and not needing garbage collection + +2005-10-21 Richard Dale <[email protected]> + + * Argument types of 'unsigned short int' were not working. Fixes + problem reported by Ian Monroe + +2005-10-05 Richard Dale <[email protected]> + + * More fixes from the Qt4 version + * 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 + + +2005-09-26 Richard Dale <[email protected]> + + * Added some fixes from the Qt4 version of QtRuby + * There was a clash between operator methods in Kernel + for '>', '>=', '<' and '<=' and the ones in the Smoke lib. + * Fixed a Qt::ByteArray marshalling problem + +2005-09-12 Richard Dale <[email protected]> + + * Fixed various problems with the rbuic code generation for database + .ui forms reported by Daniel Morris + +2005-09-11 Richard Dale <[email protected]> + + * Fixed problem with Qt::SqlCursor.select() reported by Daniel Morris + +2005-09-02 Richard Dale <[email protected]> + + * Added a Qt::Char.to_s method for converting a Qt::Char to a ruby + string + +2005-08-09 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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-30 Richard Dale <[email protected]> + + * Qt::version and Qt::ruby_version are now module methods + +2005-07-15 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Upped the version to 1.0.10 + +2005-06-04 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * The rbuic '-subimpl' option now works correctly + +2005-05-29 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * '!=' 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 <[email protected]> + + * 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 <[email protected]> + + * Improved the format of enums displayed by rbqtapi and rbkdeapi + +2005-05-20 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Removed superfluous "require 'pp'" statement + +2005-04-25 Richard Dale <[email protected]> + + * Upped the version to 1.0.9 for the RubyForge release + +2005-04-09 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Upped the version to 1.0.8 for the RubyForge release + +2005-03-30 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Added a KNS:: namespace for the KNewStuff library + +2005-02-06 Richard Dale <[email protected]> + + * The KDE::Win::WindowInfo nested class is included in the Korundum runtime + +2005-01-27 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * If a ruby Array is passed as an argument to an overloaded method, give + priority to QStringList args. + +2005-01-21 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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: [email protected] + +2005-01-16 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Upped the version to 1.0.6 for the KDE 3.4 beta 1 release + +2005-01-02 Richard Dale <[email protected]> + + * The Qt::Object pretty_print method now shows the class name of enum properties + +2004-12-30 Richard Dale <[email protected]> + + * 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: [email protected] + +2004-12-28 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Added a work round for a bug caused by an incompatibility between QtRuby + the 'require time' statement, reported by David Crosby + + CCMAIL: [email protected] + +2004-12-18 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Fixed bug in lower case/underscore method naming to camel case conversion + +2004-12-15 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Qt::Object properities of type enum are shown by name in the KDevelop debugger, + and not as numeric literals + +2004-12-14 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Upped the QtRuby version to 1.0.5 for the KDE 3.3.2 release + +2004-10-30 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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: [email protected] + +2004-10-16 Richard Dale <[email protected]> + + * Upped the version to 1.0.4 for the RubyForge release + * Added some names to AUTHORS from the ChangeLog + +2004-10-14 Richard Dale <[email protected]> + + * 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: [email protected] + +2004-10-13 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Added Qt::Application.ARGV. It returns the original ruby ARGV array with Qt command line + options removed. + +2004-10-11 Richard Dale <[email protected]> + + * 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: [email protected] + +2004-10-10 Richard Dale <[email protected]> + + * The recent fix for checking invalid arg types, didn't work with nil passed as a value + +2004-10-10 Richard Dale <[email protected]> + + * A QRgb[] color table was being wrongly deleted after marshalling + +2004-10-10 Richard Dale <[email protected]> + + * 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: [email protected] + +2004-10-10 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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: [email protected] + +2004-10-05 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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: <[email protected]> + +2004-10-04 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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: [email protected] + +2004-10-03 Richard Dale <[email protected]> + + * 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: [email protected] + +2004-10-03 Richard Dale <[email protected]> + + * 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: [email protected] + +2004-10-03 Richard Dale <[email protected]> + + * Upped version to 1.0.3 for the KDE 3.3.1 release + +2004-10-02 Richard Dale <[email protected]> + + * Added Ruby Array to QPair<int,int>& marshaller + +2004-09-30 Richard Dale <[email protected]> + + * 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: [email protected] + +2004-09-29 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Upped the version to 1.0.2 for Rubyforge release + +2004-09-12 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Upped the version to 1.0.1 for the current Rubyforge release + +2004-09-05 Richard Dale <[email protected]> + + * Added Kate:: and KTextEdit:: namespaces for writing Kate plugins + +2004-09-03 Richard Dale <[email protected]> + + * Some newer changes from the uic were added to the rbuic tool. + +2004-09-03 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Added Kontact module to provide a namespace for the kontact plugin api + +2004-08-25 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Upped the QtRuby version to 1.0.0 - it must work now then.. + +2004-08-02 Richard Dale <[email protected]> + + * Added 'long long' and 'unsigned long long' marshallers + +2004-07-29 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Added a template based method for QValueList marshallers, and several + QValueList types. + +2004-07-28 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Replaced QString casts to 'const char *' with latin1() calls + +2004-07-27 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Added error messages for invalid slot or signal declarations + +2004-07-27 Richard Dale <[email protected]> + + * 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: [email protected] + +2004-07-27 Richard Dale <[email protected]> + + * Added qDebug(), qFatal() and qWarning() module methods + +2004-07-26 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Added marshallers for QMap<QString,QString> and QMap<QString,QVariant> to and from ruby hashes + +2004-07-26 Richard Dale <[email protected]> + + * 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: [email protected] + +2004-07-19 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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: [email protected] + +2004-07-11 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Added QChar marshalling + +2004-07-06 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Replaced obsolete STR2CSTR() calls with StringValuePtr() + +2004-06-29 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Added QStrList marshalling + +2004-06-29 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Fixed bug in rbuic generated code for setResizeMode() + +2004-04-05 Richard Dale <[email protected]> + + * Improved classname resolution for QListViewItem and QTableItem subclasses using rtti() calls + +2004-03-26 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * The f'n new_qobject is no longer static, and can be called from korundum + +2004-03-01 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Added method selector caching for class methods and constructors, + although performance still 'sedate' compared with C++ or Perl. + +2003-10-29 Richard Dale <[email protected]> + + * The smokeruby_mark() f'n now marks the QListViewItems in a QListView + * Fixed a QLayoutItem crash in smokeruby_free() + +2003-10-27 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Changed some error messages in do_method_missing() to be 'debug only' for now. + +2003-10-22 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Added KIO:: and KParts:: namespaces for the new classes in libsmokekde + +2003-10-08 Richard Dale <[email protected]> + + * Korundum KDE ruby extension + - made various changes so it can be linked against the QtRuby code + +2003-09-18 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * The rbuic -embed option finally works. Fixed QByteArray marshalling. + +2003-09-13 Richard Dale <[email protected]> + + * Improved the rbuic -embed option, and added some fixes + +2003-09-12 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Marshallers now return Qnil, rather than Qundef (for internal use only) + +2003-09-10 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Added QByteArray <-> Ruby string marshaller + +2003-09-09 Richard Dale <[email protected]> + + * Blocks can now be passed to constructors, like this: + w = MyWidget.new { setCaption("foobar") } + +2003-09-08 Richard Dale <[email protected]> + + * Added method selector caching, scribbling may be slightly faster.. + +2003-09-08 Richard Dale <[email protected]> + + * GC getting closer to working. Debugging code improved. + +2003-09-08 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Set methods such as autoMask= are converted to setAutoMask() + * Get methods such as modal? are converted to isModal() + +2003-08-31 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * rbuic() code generation fixes + +2003-08-30 Richard Dale <[email protected]> + + * Added 'Run Selection' menu option to the QtRuby shell + +2003-08-30 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Updated TODO list, improved rbuic code generation for images + +2003-08-28 Richard Dale <[email protected]> + + * Improved operator overloading to work with operators not in QGlobalSpace + +2003-08-27 Richard Dale <[email protected]> + + * Changed the operator overloading implementation to be more like PerlQt + +2003-08-27 Richard Dale <[email protected]> + + * Translated the rbqtsh filePrint() method from perl + +2003-08-26 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Removed ugly _current_object global variable. + The current target object is now passed to the MethodCall constructor. + +2003-08-25 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Added rbuic tool for ruby Qt Designer support + +2003-08-12 Alexander Kellett <[email protected]> + + * 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 <[email protected]> + + * 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 <[email protected]> + + * Added support for operator overloading + +2003-08-07 Alexander Kellett <[email protected]> + + * Added rbqtapi and rbqt tools (port of the PerlQt tools of the same name) + +2003-08-06 Richard Dale <[email protected]> + + * Added some TODO list entries, added Alex to the AUTHORS list + +2003-08-06 Richard Dale <[email protected]> + + * Fixed 'int&' marshalling so script name appears in window title + +2003-08-12 Alexander Kellett <[email protected]> + + * 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 <[email protected]> + + * Moved SLOT(), SIGNAL() and emit() to global scope + +2003-08-05 Richard Dale <[email protected]> + + * Removed redundant 'rb_eval_string("include Qt")' call from extension initialization. + +2003-08-05 Richard Dale <[email protected]> + + * Qt::Application constructor safer, but program name still not appearing in the window title + +2003-08-05 Richard Dale <[email protected]> + + * Fixed bug in resolution of overloaded Qt::Popup.insertItem() methods + +2003-08-05 Richard Dale <[email protected]> + + * 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 <[email protected]> + + * Allow for accumulative slots/signals declarations in a class + * Minor build fixes + +2003-08-02 Alexander Kellett <[email protected]> + + * Fix several deprecation warnings when running under 1.8.x + * Several more build fixes + +2003-08-01 Alexander Kellett <[email protected]> + + * 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 <[email protected]> + + * Remove need to manually run extconf.rb by some automation via a configure.in.in + * Various other build fixes + +2003-07-31 Richard Dale <[email protected]> + + * Fixed bug in marshalling QString::null to a ruby VALUE + +2003-07-31 Richard Dale <[email protected]> + + * Changed require in Qt.cpp to 'Qt/Qt.rb' instead of 'lib/Qt/Qt.rb' + +2003-07-31 Richard Dale <[email protected]> + + * Fixed problem with non-working installed version, lib/Qt.rb moved to lib/Qt/Qt.rb + +2003-07-30 Richard Dale <[email protected]> + + * QtRuby - a Ruby SMOKE adaptor for Qt, initial checkin + + |