Hello Ruby folk! :)


I'm new to this list so I'm just going to take a second to introduce
myself.. My name is Ian Main, and I live in Canada! :)

I mostly have an interest in Ruby because I am working on something called
Entity, the homepage of which is at:

http://entity.evilplan.org

Essentially it's an engine that allows you to create XML objects, and use
those to build applications in XML.

Anyway, I really find Ruby very interesting.. and one feature (besides the
cool OO'ness of it), that would be extremely cool for me was the built in
threading. I took a look at the source code, and I really like the way it
will block and reschedule on IO etc.  I think this would integrate
beautifully into Entity.  (and I can't beleive no other languages do this..
I was actually toying with the idea of implementing something similar myself).

However, having looked at the GTK bindings, I saw something which I thought
could use improvement - namely:

...
gtk_idle_add((GtkFunction)idle, 0); 
...

from rbgtk.c., idle() of course being defined as:

static gint
idle() 
{ 
 struct timeval wait; 
 
 wait.tv_sec  = 0;  
 wait.tv_usec = 1000; /* 100ms */  
   
 CHECK_INTS;    
 if (!rb_thread_critical) rb_thread_wait_for(wait);    
 
 return Qtrue;        
}        
       

Now, this doesn't cause too huge of problems, but I did notice the
sluggish redraw gtk had when run from ruby (because it only gets control
to redraw every 100ms).  It also makes the applications consume a small
amount of CPU when idle.

If I were to embed ruby into entity, it would also cause IO handlers to be
called with a 100ms delay.  I realize this could be made into a smaller
amount (and indeed this is what I did with the Ruby/GTK to make it "feel"
faster), but this causes more idle CPU usage.. not a big deal on my machine,
but the actual amount will vary depending on the platform.

In Entity we've extrapolated all the mainloop functions, and have a
registration function which can be used to insert your own functions for the
mainloop (eg, select()), adding IO watchers (to the select () call)) etc.  We
then provide a default set of handlers (for which we just use the glib
functions), if no alternative is provided.  This allows you to use other
toolkits which assume control of the mainloop, such as Qt etc.

So the point of all this, is that I'm wondering if you would be interested
in implementing a similar thing in Ruby ?  I would be willing to help in any
way possible, including an attempt at supplying patches if this is what it
will take.

I'm really keen on getting Ruby support into Entity, but I think this is
something I'd like to have resolved before doing so.

Thanks,

	Ian