Push-GLib-0.1.9.

Therefore, I started writing one. It takes a different approach than most of the drivers out there. Primarily, it uses the asynchronous model introduced in GIO. This of course adds some extra complexity, but allows you to pipeline some packets together which can be useful.

Additionally, there is a MongoBsonStream object that is useful for reading through a file that contains a stream of BSON documents sequentially. This is the wire format for mongodump. Therefore, if you want to do offline jobs against your mongo backups, this can be quite useful. I in fact use it to verify the BSON schema of our database offline, after backups have occurred.

I don't know what will end up happening with it, but here it is.

Mongo-GLib-0.1.9

• Emmanuele Bassi for his hard work and dedication to bringing us a solid platform. Clutter, gtk+, glib, json-glib. Your attitude and ability to stay calm when surrounded by trolls does not go unnoticed.
• Hub Figuière for never relenting to others revisionist history.
• Andy Isaacson for being 5 steps ahead of everyone else. Every conversation I have with you ends up in amazing stories, a history lesson, and what we can do to make it better. It is always inspiring.
• Jacob Berkman for the indistinguishable mix of charm and bad attitude. It was unforgettable working with you.
• Hylke Bons for taking the rudeness and undeserved aggression too often found in our community and continuing to produce quality.

Thank You!

There are so many others, but I wanted to keep this list short.

http://www.youtube.com/watch?v=bNV8-evh-VY

First, we create GScriptJs which is a thin wrapper around Gjs. Mostly, just to be able to create an object from within the GtkBuilder file. Then, we create a custom connect func that will look for a given function in the script and attach it to the requested signal. All in all, very few lines of code. I'm pleasantly surprised.

Example GtkBuilder+JavaScript

<?xml version="1.0" encoding="UTF-8"?>
<interface>
  <object class="GScriptJs" id="script">
<property name="script">
const Gtk = imports.gi.Gtk;
 
function onClicked() {
  let w = new Gtk.Window();
  w.set_default_size(320, 240);
  w.present();
}
 
function onQuit() {
  Gtk.main_quit();
}
    </property>
  </object>
  <object class="GtkWindow" id="window">
    <signal name="delete-event" handler="onQuit" swapped="no"/>

Example GtkBuilderConnectFunc

static void
connect_func (GtkBuilder    *builder,
              GObject       *object,
              const gchar   *signal_name,
              const gchar   *handler_name,
              GObject       *connect_object,
              GConnectFlags  flags,
              gpointer       user_data)
{
	const gchar *script_name = user_data;
	GScriptJs *script;
	GClosure *closure;
 
	g_return_if_fail(script_name != NULL);
	g_return_if_fail(connect_object == NULL); /* TODO */
 
	script = G_SCRIPT_JS(gtk_builder_get_object(builder, script_name));
	if (!script) {
		g_critical("Cannot locate script %s", script_name);
		return;
	}
 
	closure = g_script_js_get_function(script, handler_name);
	if (!closure) {
		g_critical("Cannot locate function %s", handler_name);
		return;
	}
 
	g_signal_connect_closure(object, signal_name, closure,
	                         !!(flags & G_CONNECT_AFTER));
}

Get the code at https://github.com/chergert/gtkbuilderscript.

Anyway, a while back I played with making a sort of data mapper. I figured it is time to post it here to see if anyone finds interest in it. Otherwise I'll just let it continue to bitrot. It lets you map GObjects to SQL or whatever. I've also only implemented sqlite. But it works okay for that so far. There are probably still a bunch of bugs or corner cases missing.

But it lets you do some fun stuff, like relations. It can handle basic properties, relations and groups, enums, etc etc. It does not do migrations.

Defining a resource

#include "mock-gender.h"
#include "mock-occupation.h"
#include "mock-person.h"
 
GOM_DEFINE_RESOURCE(MockPerson, mock_person,
                    GOM_RESOURCE_TABLE("persons");
                    GOM_RESOURCE_HAS_MANY("friends",
                                          _("Friends"),
                                          _("The persons friends."),
                                          MOCK_TYPE_PERSON,
                                          NULL);
                    GOM_RESOURCE_BELONGS_TO("occupation",
                                            _("Occupation"),
                                            _("The persons occupation."),
                                            MOCK_TYPE_OCCUPATION,
                                            NULL);
                    GOM_RESOURCE_PROPERTY(g_param_spec_uint64("id",
                                                              _("Identifier"),
                                                              _("The persons identifier."),
                                                              0,
                                                              G_MAXUINT64,
                                                              0,
                                                              G_PARAM_READWRITE),
                                          "key", TRUE,
                                          "serial", TRUE,
                                          NULL);
                    GOM_RESOURCE_PROPERTY(g_param_spec_string("name",
                                                              _("Name"),
                                                              _("The persons name."),
                                                              NULL,
                                                              G_PARAM_READWRITE),
                                          NULL);
                    GOM_RESOURCE_PROPERTY(g_param_spec_enum("gender",
                                                            _("Gender"),
                                                            _("The persons gender"),
                                                            MOCK_TYPE_GENDER,
                                                            MOCK_GENDER_UNKNOWN,
                                                            G_PARAM_READWRITE),
                                          NULL););

And no, you don't have to use the macros if you have something more complex.

Saving a resource

 
GomResource *resource;
 
resource = g_object_new(MOCK_TYPE_PERSON,
                        "adapter", sqlite_adapter,
                        "name", "Jane Doe",
                        "gender", MOCK_GENDER_FEMALE,
                        NULL);
gom_resource_save(resource, &error);

Get the code here.

• Graph tracks time rather than "available buckets" for data points. It works so much better I feel stupid for not doing it in the first place.
• Use floating point for positioning throughout pipeline until last possible step.
• Render updates in thread and only blit to cairo xlib surface in main loop. This probably isn't technically safe at the moment as reference counting of images in libpixman aren't thread aware. However, it seems to work pretty well for a single rendering thread. Once that is fixed, we can scale up rendering to more threads (which helps a bit if you have a lot of visualizers in perfkit).
• Not really a performance/smoothing fix, but the renderers are abstracted more from the graph. This means the visualizers and realtime graphs in perfkit share rendering code.

It also now works on gtk+ 3.0. Obligatory screencast below.

http://www.youtube.com/watch?v=Yw88edHU18E

http://www.youtube.com/watch?v=lp6ceGP-6vU
http://www.youtube.com/watch?v=AlvieV-sBJo
http://www.youtube.com/watch?v=_koPfiJ2zn0