Merge lp:~timo-jyrinki/ciborium/port_to_qml.v1 into lp:ciborium

[Timo Jyrinki]

Port to qml.v1, fixing FTBFS.

(trust me, I don't know what I'm doing, but it builds and runs its unit tests)

[lp:~timo-jyrinki/ciborium/port_to_qml.v1]

141. By Timo Jyrinki on 2015-06-11

Update debian/copyright

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:140
http://jenkins.qa.ubuntu.com/job/ciborium-ci/39/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ciborium-vivid-amd64-ci/33
    FAILURE: http://jenkins.qa.ubuntu.com/job/ciborium-vivid-armhf-ci/33/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ciborium-vivid-i386-ci/33

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ciborium-ci/39/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:141
http://jenkins.qa.ubuntu.com/job/ciborium-ci/40/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ciborium-vivid-amd64-ci/34
    FAILURE: http://jenkins.qa.ubuntu.com/job/ciborium-vivid-armhf-ci/34/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ciborium-vivid-i386-ci/34

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ciborium-ci/40/rebuild

review: Needs Fixing (continuous-integration)

[Timo Jyrinki (timo-jyrinki)]

Build on x86, fails to build on armhf due to some OpenGL stuff.

[lp:~timo-jyrinki/ciborium/port_to_qml.v1]

142. By Timo Jyrinki on 2015-06-12

Remove everything from qml.v1/gl except for glbase

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:142
http://jenkins.qa.ubuntu.com/job/ciborium-ci/41/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ciborium-vivid-amd64-ci/35
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ciborium-vivid-armhf-ci/35
        deb: http://jenkins.qa.ubuntu.com/job/ciborium-vivid-armhf-ci/35/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ciborium-vivid-i386-ci/35

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ciborium-ci/41/rebuild

review: Approve (continuous-integration)

[Manuel de la Peña (mandel)]

Looks good to get around the build issues.

review: Approve

=== modified file 'cmd/ciborium-ui/main.go'
--- cmd/ciborium-ui/main.go	2015-03-11 01:54:55 +0000
+++ cmd/ciborium-ui/main.go	2015-06-12 10:54:44 +0000
@@ -28,7 +28,7 @@
 
 	"log"
 
-	"launchpad.net/ciborium/qml.v0"
+	"launchpad.net/ciborium/qml.v1"
 	"launchpad.net/ciborium/udisks2"
 	"launchpad.net/go-dbus/v1"
 	"launchpad.net/go-xdg/v0"
@@ -77,7 +77,8 @@
 	// set default logger flags to get more useful info
 	log.SetFlags(log.LstdFlags | log.Lshortfile)
 
-	qml.Init(nil)
+	// not in qml.v1
+	//qml.Init(nil)
 	engine := qml.NewEngine()
 	component, err := engine.LoadFile(mainQmlPath)
 	if err != nil {

=== modified file 'debian/changelog'
--- debian/changelog	2015-03-18 10:06:56 +0000
+++ debian/changelog	2015-06-12 10:54:44 +0000
@@ -1,3 +1,9 @@
+ciborium (0.2.12+15.04.20150611-0ubuntu1) UNRELEASED; urgency=medium
+
+  * Port to QML.v1 
+
+ -- Timo Jyrinki <[e-mail]>  Thu, 11 Jun 2015 10:12:09 +0000
+
 ciborium (0.2.12+15.04.20150316.7-0ubuntu2) vivid; urgency=medium
 
   * No-change rebuild against Qt 5.4.1.

=== modified file 'debian/copyright'
--- debian/copyright	2014-08-26 23:42:39 +0000
+++ debian/copyright	2015-06-12 10:54:44 +0000
@@ -6,8 +6,8 @@
 Copyright: 2012-2013 José Carlos Nieto
 License: MIT
 
-Files: qml.v0/*
-Copyright: 2013-2014, Gustavo Niemeyer <[e-mail]>
+Files: qml.v1/*
+Copyright: 2013-2015, Gustavo Niemeyer <[e-mail]> and gopkg.in/qml.v1 contributors
 License: LGPL-3
 
 Files: *

=== removed directory 'qml.v0'
=== removed file 'qml.v0/LICENSE'
--- qml.v0/LICENSE	2014-08-26 19:38:51 +0000
+++ qml.v0/LICENSE	1970-01-01 00:00:00 +0000
@@ -1,185 +0,0 @@
-This software is licensed under the LGPLv3, included below.
-
-As a special exception to the GNU Lesser General Public License version 3
-("LGPL3"), the copyright holders of this Library give you permission to
-convey to a third party a Combined Work that links statically or dynamically
-to this Library without providing any Minimal Corresponding Source or
-Minimal Application Code as set out in 4d or providing the installation
-information set out in section 4e, provided that you comply with the other
-provisions of LGPL3 and provided that you meet, for the Application the
-terms and conditions of the license(s) which apply to the Application.
-
-Except as stated in this special exception, the provisions of LGPL3 will
-continue to comply in full to this Library. If you modify this Library, you
-may apply this exception to your version of this Library, but you are not
-obliged to do so. If you do not wish to do so, delete this exception
-statement from your version. This exception does not (and cannot) modify any
-license terms which apply to the Application, with which you must still
-comply.
-
-
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.

=== removed file 'qml.v0/README.md'
--- qml.v0/README.md	2014-08-26 19:38:51 +0000
+++ qml.v0/README.md	1970-01-01 00:00:00 +0000
@@ -1,151 +0,0 @@
-# QML support for the Go language
-
-This is an ALPHA release
-------------------------
-
-This package is in an alpha stage, and still in heavy development. APIs
-may change, and things may break.
-
-At this time contributors and developers that are interested in tracking
-the development closely are encouraged to use it. If you'd prefer a more
-stable release, please hold on a bit and subscribe to the mailing list
-for news. It's in a pretty good state, so it shall not take too long.
-
-
-Demos
------
-
-These introductory videos demonstrate the use of Go QML:
-
-  * [Initial demo and overview](http://youtu.be/FVQlMrPa7lI)
-  * [Initial demo running on an Ubuntu Touch phone](http://youtu.be/HB-3o8Cysec)
-  * [Spinning Gopher with Go + QML + OpenGL](http://youtu.be/qkH7_dtOyPk)
-  * [SameGame QML tutorial in Go](http://youtu.be/z8noX48hiMI)
-
-
-Community
----------
-
-Please join the [mailing list](https://groups.google.com/forum/#!forum/go-qml) for
-following relevant development news and discussing project details.
-
-
-Documentation
--------------
-
-The introductory documentation as well as the detailed API documentation is
-available at [gopkg.in/qml.v0](http://godoc.org/gopkg.in/qml.v0).
-
-
-Installation
-------------
-
-To try the alpha release you'll need:
-
-  * Go 1.2, for the C++ support of _go build_
-  * Qt 5.0.X or 5.1.X with the development files
-  * The Qt headers qmetaobject_p.h and qmetaobjectbuilder_p.h, for the dynamic meta object support
-
-See below for more details about getting these requirements installed in different environments and operating systems.
-
-After the requirements are satisfied, _go get_ should work as usual:
-
-    go get gopkg.in/qml.v0
-
-
-Requirements on Ubuntu
-----------------------
-
-If you are using Ubuntu, the [Ubuntu SDK](http://developer.ubuntu.com/get-started/) will take care of the Qt dependencies:
-
-    $ sudo add-apt-repository ppa:ubuntu-sdk-team/ppa
-    $ sudo apt-get update
-    $ sudo apt-get install ubuntu-sdk qtbase5-private-dev qtdeclarative5-private-dev libqt5opengl5-dev
-
-and Go 1.2 may be installed using [godeb](http://blog.labix.org/2013/06/15/in-flight-deb-packages-of-go):
-
-    $ # Pick the right one for your system: 386 or amd64
-    $ ARCH=amd64
-    $ wget -q https://godeb.s3.amazonaws.com/godeb-$ARCH.tar.gz
-    $ tar xzvf godeb-$ARCH.tar.gz
-    godeb
-    $ sudo mv godeb /usr/local/bin
-    $ godeb install 1.2
-    $ go get gopkg.in/qml.v0
-
-
-Requirements on Ubuntu Touch
-----------------------------
-
-After following the [installation instructions](https://wiki.ubuntu.com/Touch/Install) for Ubuntu Touch,
-run the following commands to get a working build environment inside the device:
-
-    $ adb shell
-    # cd /tmp
-    # wget https://github.com/go-qml/qml/raw/master/cmd/ubuntu-touch/setup.sh
-    # /bin/bash setup.sh
-    # su - phablet
-    $
-
-At the end of setup.sh, the phablet user will have GOPATH=$HOME in the environment,
-the qml package will be built, and the particle example will be built and run. For
-stopping it from the command line, run as the phablet user:
-
-    $ upstart-app-stop gopkg.in.qml.particle-example
-
-for running it again:
-
-    $ upstart-app-launch gopkg.in.qml.particle-example
-
-These commands depend on the following file, installed by setup.sh:
-
-    ~/.local/share/applications/gopkg.in.qml.particle-example.desktop
-
-
-Requirements on Mac OS X
-------------------------
-
-On Mac OS X you'll need gcc (not a symlinked clang, as it complains about `-std=c++11`), and
-must specify the `CXX`, `PKG_CONFIG_PATH`, and `CGO_CPPFLAGS` environment variables.
-
-Something along these lines should be effective:
-
-    $ brew tap homebrew/versions
-    $ brew install gcc48 qt5
-
-    $ export PKG_CONFIG_PATH=`brew --prefix qt5`/lib/pkgconfig
-    $ CXX=g++-4.8 go get gopkg.in/qml.v0
-
-For Mac OS X Mavericks you may need to use `brew install qt5 --HEAD` and check that QT5VERSION
-is something reasonable like `5.2.0`, `ls /usr/local/Cellar/qt5/HEAD/include/QtCore/ | grep '^5'`
-should also work.
-
-Requirements on Windows
------------------------
-
-On Windows you'll need the following:
-
-  * [MinGW gcc](http://sourceforge.net/projects/mingw/files/latest/download) 4.8.1 (install mingw-get and install the gcc from within the setup GUI)
-  * [Qt 5.1.1](http://download.qt-project.org/official_releases/qt/5.1/5.1.1/qt-windows-opensource-5.1.1-mingw48_opengl-x86-offline.exe) for MinGW 4.8
-  * [Go 1.2rc1](https://code.google.com/p/go/downloads/list?can=1&q=go1.2rc1) for Windows
-
-Then, assuming Qt was installed under `C:\Qt5.1.1\`, set up the following environment variables in the respective configuration:
-
-    CPATH += C:\Qt5.1.1\5.1.1\mingw48_32\include
-    LIBRARY_PATH += C:\Qt5.1.1\5.1.1\mingw48_32\lib
-    PATH += C:\Qt5.1.1\5.1.1\mingw48_32\bin
-
-After reopening the shell for the environment changes to take effect, this should work:
-
-    go get gopkg.in/qml.v0
-
-
-Requirements everywhere else
-----------------------------
-
-If your operating system does not offer these dependencies readily,
-you may still have success installing [Go 1.2rc1](https://code.google.com/p/go/downloads/list?can=1&q=go1.2rc1)
-and [Qt 5.0.2](http://download.qt-project.org/archive/qt/5.0/5.0.2/)
-directly from the upstreams.  Note that you'll likely have to adapt
-environment variables to reflect the custom installation path for
-these libraries. See the instructions above for examples.

=== removed file 'qml.v0/all.cpp'
--- qml.v0/all.cpp	2014-08-26 19:38:51 +0000
+++ qml.v0/all.cpp	1970-01-01 00:00:00 +0000
@@ -1,8 +0,0 @@
-
-#include "cpp/capi.cpp"
-#include "cpp/govalue.cpp"
-#include "cpp/govaluetype.cpp"
-#include "cpp/idletimer.cpp"
-#include "cpp/connector.cpp"
-
-#include "cpp/moc_all.cpp"

=== removed file 'qml.v0/bridge.go'
--- qml.v0/bridge.go	2014-08-26 19:38:51 +0000
+++ qml.v0/bridge.go	1970-01-01 00:00:00 +0000
@@ -1,632 +0,0 @@
-package qml
-
-// #cgo CPPFLAGS: -I./cpp
-// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing
-// #cgo LDFLAGS: -lstdc++
-// #cgo pkg-config: Qt5Core Qt5Widgets Qt5Quick
-//
-// #include <stdlib.h>
-//
-// #include "cpp/capi.h"
-//
-import "C"
-
-import (
-	"fmt"
-	"os"
-	"reflect"
-	"runtime"
-	"sync"
-	"sync/atomic"
-	"unsafe"
-
-	"launchpad.net/ciborium/qml.v0/tref"
-)
-
-var hookWaiting C.int
-
-// guiLoop runs the main GUI thread event loop in C++ land.
-func guiLoop() {
-	// This is not an option in Init to avoid forcing people to patch
-	// and recompile an application just so it runs on Ubuntu Touch.
-	deskfile := os.Getenv("DESKTOP_FILE_HINT")
-	cdeskfile := (*C.char)(nil)
-	if deskfile != "" {
-		os.Setenv("DESKTOP_FILE_HINT", "")
-		cdeskfile = C.CString("--desktop_file_hint=" + deskfile)
-	}
-
-	runtime.LockOSThread()
-	guiLoopRef = tref.Ref()
-	C.newGuiApplication(cdeskfile)
-	C.idleTimerInit(&hookWaiting)
-	guiLoopReady.Unlock()
-	C.applicationExec()
-}
-
-var (
-	guiFunc      = make(chan func())
-	guiDone      = make(chan struct{})
-	guiLock      = 0
-	guiLoopReady sync.Mutex
-	guiLoopRef   uintptr
-	guiPaintRef  uintptr
-)
-
-// RunMain runs f in the main QML thread and waits for f to return.
-//
-// This is meant for extensions that integrate directly with the
-// underlying QML logic.
-func RunMain(f func()) {
-	ref := tref.Ref()
-	if ref == guiLoopRef || ref == atomic.LoadUintptr(&guiPaintRef) {
-		// Already within the GUI or render threads. Attempting to wait would deadlock.
-		f()
-		return
-	}
-
-	// Tell Qt we're waiting for the idle hook to be called.
-	if atomic.AddInt32((*int32)(unsafe.Pointer(&hookWaiting)), 1) == 1 {
-		C.idleTimerStart()
-	}
-
-	// Send f to be executed by the idle hook in the main GUI thread.
-	guiFunc <- f
-
-	// Wait until f is done executing.
-	<-guiDone
-}
-
-// Lock freezes all QML activity by blocking the main event loop.
-// Locking is necessary before updating shared data structures
-// without race conditions.
-//
-// It's safe to use qml functionality while holding a lock, as
-// long as the requests made do not depend on follow up QML
-// events to be processed before returning. If that happens, the
-// problem will be observed as the application freezing.
-//
-// The Lock function is reentrant. That means it may be called
-// multiple times, and QML activities will only be resumed after
-// Unlock is called a matching number of times.
-func Lock() {
-	// TODO Better testing for this.
-	RunMain(func() {
-		guiLock++
-	})
-}
-
-// Unlock releases the QML event loop. See Lock for details.
-func Unlock() {
-	RunMain(func() {
-		if guiLock == 0 {
-			panic("qml.Unlock called without lock being held")
-		}
-		guiLock--
-	})
-}
-
-// Flush synchronously flushes all pending QML activities.
-func Flush() {
-	// TODO Better testing for this.
-	RunMain(func() {
-		C.applicationFlushAll()
-	})
-}
-
-// Changed notifies all QML bindings that the given field value has changed.
-//
-// For example:
-//
-//     qml.Changed(&value, &value.Field)
-//
-func Changed(value, fieldAddr interface{}) {
-	valuev := reflect.ValueOf(value)
-	fieldv := reflect.ValueOf(fieldAddr)
-	for valuev.Kind() == reflect.Ptr {
-		valuev = valuev.Elem()
-	}
-	if fieldv.Kind() != reflect.Ptr {
-		panic("qml.Changed received non-address value as fieldAddr")
-	}
-	fieldv = fieldv.Elem()
-	if fieldv.Type().Size() == 0 {
-		panic("cannot report changes on zero-sized fields")
-	}
-	offset := fieldv.UnsafeAddr() - valuev.UnsafeAddr()
-	if !(0 <= offset && offset < valuev.Type().Size()) {
-		panic("provided field is not a member of the given value")
-	}
-
-	RunMain(func() {
-		tinfo := typeInfo(value)
-		for _, engine := range engines {
-			fold := engine.values[value]
-			for fold != nil {
-				C.goValueActivate(fold.cvalue, tinfo, C.int(offset))
-				fold = fold.next
-			}
-			// TODO typeNew might also be a linked list keyed by the gvalue.
-			//      This would prevent the iteration and the deferrals.
-			for fold, _ = range typeNew {
-				if fold.gvalue == value {
-					// Activate these later so they don't get recursively moved
-					// out of typeNew while the iteration is still happening.
-					defer C.goValueActivate(fold.cvalue, tinfo, C.int(offset))
-				}
-			}
-		}
-	})
-}
-
-// hookIdleTimer is run once per iteration of the Qt event loop,
-// within the main GUI thread, but only if at least one goroutine
-// has atomically incremented hookWaiting.
-//
-//export hookIdleTimer
-func hookIdleTimer() {
-	var f func()
-	for {
-		select {
-		case f = <-guiFunc:
-		default:
-			if guiLock > 0 {
-				f = <-guiFunc
-			} else {
-				return
-			}
-		}
-		f()
-		guiDone <- struct{}{}
-		atomic.AddInt32((*int32)(unsafe.Pointer(&hookWaiting)), -1)
-	}
-}
-
-type valueFold struct {
-	engine *Engine
-	gvalue interface{}
-	cvalue unsafe.Pointer
-	init   reflect.Value
-	prev   *valueFold
-	next   *valueFold
-	owner  valueOwner
-}
-
-type valueOwner uint8
-
-const (
-	cppOwner = 1 << iota
-	jsOwner
-)
-
-// wrapGoValue creates a new GoValue object in C++ land wrapping
-// the Go value contained in the given interface.
-//
-// This must be run from the main GUI thread.
-func wrapGoValue(engine *Engine, gvalue interface{}, owner valueOwner) (cvalue unsafe.Pointer) {
-	gvaluev := reflect.ValueOf(gvalue)
-	gvaluek := gvaluev.Kind()
-	if gvaluek == reflect.Struct && !hashable(gvalue) {
-		name := gvaluev.Type().Name()
-		if name != "" {
-			name = " (" + name + ")"
-		}
-		panic("cannot hand an unhashable struct value" + name + " to QML logic; use its address instead")
-	}
-	if gvaluek == reflect.Ptr && gvaluev.Elem().Kind() == reflect.Ptr {
-		panic("cannot hand pointer of pointer to QML logic; use a simple pointer instead")
-	}
-
-	painting := tref.Ref() == atomic.LoadUintptr(&guiPaintRef)
-
-	prev, ok := engine.values[gvalue]
-	if ok && (prev.owner == owner || owner != cppOwner || painting) {
-		return prev.cvalue
-	}
-
-	if painting {
-		panic("cannot allocate new objects while painting")
-	}
-
-	parent := nilPtr
-	if owner == cppOwner {
-		parent = engine.addr
-	}
-	fold := &valueFold{
-		engine: engine,
-		gvalue: gvalue,
-		owner:  owner,
-	}
-	fold.cvalue = C.newGoValue(unsafe.Pointer(fold), typeInfo(gvalue), parent)
-	if prev != nil {
-		prev.next = fold
-		fold.prev = prev
-	} else {
-		engine.values[gvalue] = fold
-	}
-	//fmt.Printf("[DEBUG] value alive (wrapped): cvalue=%x gvalue=%x/%#v\n", fold.cvalue, addrOf(fold.gvalue), fold.gvalue)
-	stats.valuesAlive(+1)
-	C.engineSetContextForObject(engine.addr, fold.cvalue)
-	switch owner {
-	case cppOwner:
-		C.engineSetOwnershipCPP(engine.addr, fold.cvalue)
-	case jsOwner:
-		C.engineSetOwnershipJS(engine.addr, fold.cvalue)
-	}
-	return fold.cvalue
-}
-
-func addrOf(gvalue interface{}) uintptr {
-	return reflect.ValueOf(gvalue).Pointer()
-}
-
-// typeNew holds fold values that are created by registered types.
-// These values are special in two senses: first, they don't have a
-// reference to an engine before they are used in a context that can
-// set the reference; second, these values always hold a new cvalue,
-// because they are created as a side-effect of the registered type
-// being instantiated (it's too late to reuse an existent cvalue).
-//
-// For these reasons, typeNew holds the fold for these values until
-// their engine is known, and once it's known they may have to be
-// added to the linked list, since mulitple references for the same
-// gvalue may occur.
-var typeNew = make(map[*valueFold]bool)
-
-//export hookGoValueTypeNew
-func hookGoValueTypeNew(cvalue unsafe.Pointer, specp unsafe.Pointer) (foldp unsafe.Pointer) {
-	// Initialization is postponed until the engine is available, so that
-	// we can hand Init the qml.Object that represents the object.
-	init := reflect.ValueOf((*TypeSpec)(specp).Init)
-	fold := &valueFold{
-		init:   init,
-		gvalue: reflect.New(init.Type().In(0).Elem()).Interface(),
-		cvalue: cvalue,
-		owner:  jsOwner,
-	}
-	typeNew[fold] = true
-	//fmt.Printf("[DEBUG] value alive (type-created): cvalue=%x gvalue=%x/%#v\n", fold.cvalue, addrOf(fold.gvalue), fold.gvalue)
-	stats.valuesAlive(+1)
-	return unsafe.Pointer(fold)
-}
-
-//export hookGoValueDestroyed
-func hookGoValueDestroyed(enginep unsafe.Pointer, foldp unsafe.Pointer) {
-	fold := (*valueFold)(foldp)
-	engine := fold.engine
-	if engine == nil {
-		before := len(typeNew)
-		delete(typeNew, fold)
-		if len(typeNew) == before {
-			panic("destroying value without an associated engine; who created the value?")
-		}
-	} else if engines[engine.addr] == nil {
-		// Must never do that. The engine holds memory references that C++ depends on.
-		panic(fmt.Sprintf("engine %p was released from global list while its values were still alive", engine.addr))
-	} else {
-		switch {
-		case fold.prev != nil:
-			fold.prev.next = fold.next
-			if fold.next != nil {
-				fold.next.prev = fold.prev
-			}
-		case fold.next != nil:
-			fold.next.prev = fold.prev
-			if fold.prev != nil {
-				fold.prev.next = fold.next
-			} else {
-				fold.engine.values[fold.gvalue] = fold.next
-			}
-		default:
-			before := len(engine.values)
-			delete(engine.values, fold.gvalue)
-			if len(engine.values) == before {
-				panic("destroying value that knows about the engine, but the engine doesn't know about the value; who cleared the engine?")
-			}
-			if engine.destroyed && len(engine.values) == 0 {
-				delete(engines, engine.addr)
-			}
-		}
-	}
-	//fmt.Printf("[DEBUG] value destroyed: cvalue=%x gvalue=%x/%#v\n", fold.cvalue, addrOf(fold.gvalue), fold.gvalue)
-	stats.valuesAlive(-1)
-}
-
-func deref(value reflect.Value) reflect.Value {
-	for {
-		switch value.Kind() {
-		case reflect.Ptr, reflect.Interface:
-			value = value.Elem()
-			continue
-		}
-		return value
-	}
-	panic("cannot happen")
-}
-
-//export hookGoValueReadField
-func hookGoValueReadField(enginep, foldp unsafe.Pointer, reflectIndex, getIndex, setIndex C.int, resultdv *C.DataValue) {
-	fold := ensureEngine(enginep, foldp)
-
-	var field reflect.Value
-	if getIndex >= 0 {
-		field = reflect.ValueOf(fold.gvalue).Method(int(getIndex)).Call(nil)[0]
-	} else {
-		field = deref(reflect.ValueOf(fold.gvalue)).Field(int(reflectIndex))
-	}
-	field = deref(field)
-
-	// Cannot compare Type directly as field may be invalid (nil).
-	if field.Kind() == reflect.Slice && field.Type() == typeObjSlice {
-		// TODO Handle getters that return []qml.Object.
-		// TODO Handle other GoValue slices (!= []qml.Object).
-		resultdv.dataType = C.DTListProperty
-		*(*unsafe.Pointer)(unsafe.Pointer(&resultdv.data)) = C.newListProperty(foldp, C.intptr_t(reflectIndex), C.intptr_t(setIndex))
-		return
-	}
-
-	fieldk := field.Kind()
-	if fieldk == reflect.Slice || fieldk == reflect.Struct && field.Type() != typeRGBA {
-		if field.CanAddr() {
-			field = field.Addr()
-		} else if !hashable(field.Interface()) {
-			t := reflect.ValueOf(fold.gvalue).Type()
-			for t.Kind() == reflect.Ptr {
-				t = t.Elem()
-			}
-			panic(fmt.Sprintf("cannot access unaddressable and unhashable struct value on interface field %s.%s; value: %#v", t.Name(), t.Field(int(reflectIndex)).Name, field.Interface()))
-		}
-	}
-	var gvalue interface{}
-	if field.IsValid() {
-		gvalue = field.Interface()
-	}
-
-	// TODO Strings are being passed in an unsafe manner here. There is a
-	// small chance that the field is changed and the garbage collector is run
-	// before C++ has a chance to look at the data. We can solve this problem
-	// by queuing up values in a stack, and cleaning the stack when the
-	// idle timer fires next.
-	packDataValue(gvalue, resultdv, fold.engine, jsOwner)
-}
-
-//export hookGoValueWriteField
-func hookGoValueWriteField(enginep, foldp unsafe.Pointer, reflectIndex, setIndex C.int, assigndv *C.DataValue) {
-	fold := ensureEngine(enginep, foldp)
-	v := reflect.ValueOf(fold.gvalue)
-	ve := v
-	for ve.Type().Kind() == reflect.Ptr {
-		ve = ve.Elem()
-	}
-	var field, setMethod reflect.Value
-	if reflectIndex >= 0 {
-		// It's a real field rather than a getter.
-		field = ve.Field(int(reflectIndex))
-	}
-	if setIndex >= 0 {
-		// It has a setter.
-		setMethod = v.Method(int(setIndex))
-	}
-
-	assign := unpackDataValue(assigndv, fold.engine)
-
-	// TODO Return false to the call site if it fails. That's how Qt seems to handle it internally.
-	err := convertAndSet(field, reflect.ValueOf(assign), setMethod)
-	if err != nil {
-		panic(err.Error())
-	}
-}
-
-func convertAndSet(to, from reflect.Value, setMethod reflect.Value) (err error) {
-	var toType reflect.Type
-	if setMethod.IsValid() {
-		toType = setMethod.Type().In(0)
-	} else {
-		toType = to.Type()
-	}
-	fromType := from.Type()
-	defer func() {
-		if v := recover(); v != nil {
-			err = fmt.Errorf("cannot use %s as a %s", fromType, toType)
-		}
-	}()
-	if fromType == typeList && toType.Kind() == reflect.Slice {
-		list := from.Interface().(*List)
-		from = reflect.MakeSlice(toType, len(list.data), len(list.data))
-		elemType := toType.Elem()
-		for i, elem := range list.data {
-			from.Index(i).Set(reflect.ValueOf(elem).Convert(elemType))
-		}
-	} else if fromType == typeMap && toType.Kind() == reflect.Map {
-		qmap := from.Interface().(*Map)
-		from = reflect.MakeMap(toType)
-		elemType := toType.Elem()
-		for i := 0; i < len(qmap.data); i += 2 {
-			key := reflect.ValueOf(qmap.data[i])
-			val := reflect.ValueOf(qmap.data[i+1])
-			if val.Type() != elemType {
-				val = val.Convert(elemType)
-			}
-			from.SetMapIndex(key, val)
-		}
-	} else if toType != fromType {
-		from = from.Convert(toType)
-	}
-	if setMethod.IsValid() {
-		setMethod.Call([]reflect.Value{from})
-	} else {
-		to.Set(from)
-	}
-	return nil
-}
-
-var (
-	dataValueSize  = uintptr(unsafe.Sizeof(C.DataValue{}))
-	dataValueArray [C.MaxParams]C.DataValue
-)
-
-//export hookGoValueCallMethod
-func hookGoValueCallMethod(enginep, foldp unsafe.Pointer, reflectIndex C.int, args *C.DataValue) {
-	fold := ensureEngine(enginep, foldp)
-	v := reflect.ValueOf(fold.gvalue)
-
-	// TODO Must assert that v is necessarily a pointer here, but we shouldn't have to manipulate
-	//      gvalue here for that. This should happen in a sensible place in the wrapping functions
-	//      that can still error out to the user in due time.
-
-	method := v.Method(int(reflectIndex))
-	methodt := method.Type()
-	methodName := v.Type().Method(int(reflectIndex)).Name
-
-	// TODO Ensure methods with more parameters than this are not registered.
-	var params [C.MaxParams]reflect.Value
-	var err error
-
-	numIn := methodt.NumIn()
-	for i := 0; i < numIn; i++ {
-		paramdv := (*C.DataValue)(unsafe.Pointer(uintptr(unsafe.Pointer(args)) + (uintptr(i)+1)*dataValueSize))
-		param := reflect.ValueOf(unpackDataValue(paramdv, fold.engine))
-		if argt := methodt.In(i); param.Type() != argt {
-			param, err = convertParam(methodName, i, param, argt)
-			if err != nil {
-				panic(err.Error())
-			}
-		}
-		params[i] = param
-	}
-
-	result := method.Call(params[:numIn])
-
-	if len(result) == 1 {
-		packDataValue(result[0].Interface(), args, fold.engine, jsOwner)
-	} else if len(result) > 1 {
-		if len(result) > len(dataValueArray) {
-			panic("function has too many results")
-		}
-		for i, v := range result {
-			packDataValue(v.Interface(), &dataValueArray[i], fold.engine, jsOwner)
-		}
-		args.dataType = C.DTVariantList
-		*(*unsafe.Pointer)(unsafe.Pointer(&args.data)) = C.newVariantList(&dataValueArray[0], C.int(len(result)))
-	}
-}
-
-func convertParam(methodName string, index int, param reflect.Value, argt reflect.Type) (reflect.Value, error) {
-	out := reflect.New(argt).Elem()
-	err := convertAndSet(out, param, reflect.Value{})
-	if err != nil {
-		err = fmt.Errorf("cannot convert parameter %d of method %s from %s to %s; provided value: %#v",
-			index, methodName, param.Type(), argt, param.Interface())
-		return reflect.Value{}, err
-	}
-	return out, nil
-}
-
-//export hookGoValuePaint
-func hookGoValuePaint(enginep, foldp unsafe.Pointer, reflectIndex C.intptr_t) {
-	// The main GUI thread is mutex-locked while paint methods are called,
-	// so no two paintings should be happening at the same time.
-	atomic.StoreUintptr(&guiPaintRef, tref.Ref())
-
-	fold := ensureEngine(enginep, foldp)
-	v := reflect.ValueOf(fold.gvalue)
-
-	painter := &Painter{fold.engine, &Common{fold.cvalue, fold.engine}}
-
-	method := v.Method(int(reflectIndex))
-	method.Call([]reflect.Value{reflect.ValueOf(painter)})
-
-	atomic.StoreUintptr(&guiPaintRef, 0)
-}
-
-func ensureEngine(enginep, foldp unsafe.Pointer) *valueFold {
-	fold := (*valueFold)(foldp)
-	if fold.engine != nil {
-		return fold
-	}
-
-	if enginep == nilPtr {
-		panic("accessing value without an engine pointer; who created the value?")
-	}
-	engine := engines[enginep]
-	if engine == nil {
-		panic("unknown engine pointer; who created the engine?")
-	}
-	fold.engine = engine
-	prev := engine.values[fold.gvalue]
-	if prev != nil {
-		for prev.next != nil {
-			prev = prev.next
-		}
-		prev.next = fold
-		fold.prev = prev
-	} else {
-		engine.values[fold.gvalue] = fold
-	}
-	before := len(typeNew)
-	delete(typeNew, fold)
-	if len(typeNew) == before {
-		panic("value had no engine, but was not created by a registered type; who created the value?")
-	}
-
-	// TODO Would be good to preserve identity on the Go side. See unpackDataValue as well.
-	obj := &Common{engine: fold.engine, addr: fold.cvalue}
-	fold.init.Call([]reflect.Value{reflect.ValueOf(fold.gvalue), reflect.ValueOf(obj)})
-
-	return fold
-}
-
-//export hookPanic
-func hookPanic(message *C.char) {
-	defer C.free(unsafe.Pointer(message))
-	panic(C.GoString(message))
-}
-
-func listSlice(fold *valueFold, reflectIndex C.intptr_t) *[]Object {
-	field := deref(reflect.ValueOf(fold.gvalue)).Field(int(reflectIndex))
-	return field.Addr().Interface().(*[]Object)
-}
-
-//export hookListPropertyAt
-func hookListPropertyAt(foldp unsafe.Pointer, reflectIndex, setIndex C.intptr_t, index C.int) (objp unsafe.Pointer) {
-	fold := (*valueFold)(foldp)
-	slice := listSlice(fold, reflectIndex)
-	return (*slice)[int(index)].Common().addr
-}
-
-//export hookListPropertyCount
-func hookListPropertyCount(foldp unsafe.Pointer, reflectIndex, setIndex C.intptr_t) C.int {
-	fold := (*valueFold)(foldp)
-	slice := listSlice(fold, reflectIndex)
-	return C.int(len(*slice))
-}
-
-//export hookListPropertyAppend
-func hookListPropertyAppend(foldp unsafe.Pointer, reflectIndex, setIndex C.intptr_t, objp unsafe.Pointer) {
-	fold := (*valueFold)(foldp)
-	slice := listSlice(fold, reflectIndex)
-	var objdv C.DataValue
-	objdv.dataType = C.DTObject
-	*(*unsafe.Pointer)(unsafe.Pointer(&objdv.data)) = objp
-	newslice := append(*slice, unpackDataValue(&objdv, fold.engine).(Object))
-	if setIndex >= 0 {
-		reflect.ValueOf(fold.gvalue).Method(int(setIndex)).Call([]reflect.Value{reflect.ValueOf(newslice)})
-	} else {
-		*slice = newslice
-	}
-}
-
-//export hookListPropertyClear
-func hookListPropertyClear(foldp unsafe.Pointer, reflectIndex, setIndex C.intptr_t) {
-	fold := (*valueFold)(foldp)
-	slice := listSlice(fold, reflectIndex)
-	newslice := (*slice)[0:0]
-	if setIndex >= 0 {
-		reflect.ValueOf(fold.gvalue).Method(int(setIndex)).Call([]reflect.Value{reflect.ValueOf(newslice)})
-	} else {
-		for i := range *slice {
-			(*slice)[i] = nil
-		}
-		*slice = newslice
-	}
-}

=== removed directory 'qml.v0/cpp'
=== removed file 'qml.v0/cpp/capi.cpp'
--- qml.v0/cpp/capi.cpp	2015-02-09 10:57:11 +0000
+++ qml.v0/cpp/capi.cpp	1970-01-01 00:00:00 +0000
@@ -1,849 +0,0 @@
-#include <QApplication>
-#include <QQuickView>
-#include <QQuickItem>
-#include <QtQml>
-#include <QDebug>
-#include <QQuickImageProvider>
-
-#include <string.h>
-
-#include "govalue.h"
-#include "govaluetype.h"
-#include "connector.h"
-#include "capi.h"
-
-static char *local_strdup(const char *str)
-{
-    char *strcopy = 0;
-    if (str) {
-        size_t len = strlen(str) + 1;
-        strcopy = (char *)malloc(len);
-        memcpy(strcopy, str, len);
-    }
-    return strcopy;
-}
-
-error *errorf(const char *format, ...)
-{
-    va_list ap;
-    va_start(ap, format);
-    QString str = QString().vsprintf(format, ap);
-    va_end(ap);
-    QByteArray ba = str.toUtf8();
-    return local_strdup(ba.constData());
-}
-
-void panicf(const char *format, ...)
-{
-    va_list ap;
-    va_start(ap, format);
-    QString str = QString().vsprintf(format, ap);
-    va_end(ap);
-    QByteArray ba = str.toUtf8();
-    hookPanic(local_strdup(ba.constData()));
-}
-
-void newGuiApplication(char *deskfile)
-{
-    static char empty[1] = {0};
-    static char *argv[] = {empty, empty, empty};
-    static int argc = 1;
-    if (deskfile) {
-        argv[argc] = deskfile;
-        argc++;
-    }
-    new QApplication(argc, argv);
-
-    // The event should never die.
-    qApp->setQuitOnLastWindowClosed(false);
-}
-
-void applicationExec()
-{
-    qApp->exec();
-}
-
-void applicationFlushAll()
-{
-    qApp->processEvents();
-}
-
-void *currentThread()
-{
-    return QThread::currentThread();
-}
-
-void *appThread()
-{
-    return QCoreApplication::instance()->thread();
-}
-
-QQmlEngine_ *newEngine(QObject_ *parent)
-{
-    return new QQmlEngine(reinterpret_cast<QObject *>(parent));
-}
-
-QQmlContext_ *engineRootContext(QQmlEngine_ *engine)
-{
-    return reinterpret_cast<QQmlEngine *>(engine)->rootContext();
-}
-
-void engineSetContextForObject(QQmlEngine_ *engine, QObject_ *object)
-{
-    QQmlEngine *qengine = reinterpret_cast<QQmlEngine *>(engine);
-    QObject *qobject = reinterpret_cast<QObject *>(object);
-
-    QQmlEngine::setContextForObject(qobject, qengine->rootContext());
-}
-
-void engineSetOwnershipCPP(QQmlEngine_ *engine, QObject_ *object)
-{
-    QQmlEngine *qengine = reinterpret_cast<QQmlEngine *>(engine);
-    QObject *qobject = reinterpret_cast<QObject *>(object);
-
-    qengine->setObjectOwnership(qobject, QQmlEngine::CppOwnership);
-}
-
-void engineSetOwnershipJS(QQmlEngine_ *engine, QObject_ *object)
-{
-    QQmlEngine *qengine = reinterpret_cast<QQmlEngine *>(engine);
-    QObject *qobject = reinterpret_cast<QObject *>(object);
-
-    qengine->setObjectOwnership(qobject, QQmlEngine::JavaScriptOwnership);
-}
-
-QQmlComponent_ *newComponent(QQmlEngine_ *engine, QObject_ *parent)
-{
-    QQmlEngine *qengine = reinterpret_cast<QQmlEngine *>(engine);
-    //QObject *qparent = reinterpret_cast<QObject *>(parent);
-    QQmlComponent *qcomponent = new QQmlComponent(qengine);
-    // Qt 5.2.0 returns NULL on qmlEngine(qcomponent) without this.
-    QQmlEngine::setContextForObject(qcomponent, qengine->rootContext());
-    return qcomponent;
-}
-
-class GoImageProvider : public QQuickImageProvider {
-
-    // TODO Destroy this when engine is destroyed.
-
-    public:
-
-    GoImageProvider(void *imageFunc) : QQuickImageProvider(QQmlImageProviderBase::Image), imageFunc(imageFunc) {};
-
-    virtual QImage requestImage(const QString &id, QSize *size, const QSize &requestedSize)
-    {
-        QByteArray ba = id.toUtf8();
-        int width = 0, height = 0;
-        if (requestedSize.isValid()) {
-            width = requestedSize.width();
-            height = requestedSize.height();
-        }
-        QImage *image = reinterpret_cast<QImage *>(hookRequestImage(imageFunc, (char*)ba.constData(), ba.size(), width, height));
-        *size = image->size();
-        if (requestedSize.isValid() && requestedSize != *size) {
-            *image = image->scaled(requestedSize, Qt::KeepAspectRatio);
-        }
-        return *image;
-    };
-
-    private:
-
-    void *imageFunc;
-};
-
-void engineAddImageProvider(QQmlEngine_ *engine, QString_ *providerId, void *imageFunc)
-{
-    QQmlEngine *qengine = reinterpret_cast<QQmlEngine *>(engine);
-    QString *qproviderId = reinterpret_cast<QString *>(providerId);
-
-    qengine->addImageProvider(*qproviderId, new GoImageProvider(imageFunc));
-}
-
-void componentSetData(QQmlComponent_ *component, const char *data, int dataLen, const char *url, int urlLen)
-{
-    QByteArray qdata(data, dataLen);
-    QByteArray qurl(url, urlLen);
-    QString qsurl = QString::fromUtf8(qurl);
-    reinterpret_cast<QQmlComponent *>(component)->setData(qdata, qsurl);
-}
-
-char *componentErrorString(QQmlComponent_ *component)
-{
-    QQmlComponent *qcomponent = reinterpret_cast<QQmlComponent *>(component);
-    if (qcomponent->isReady()) {
-        return NULL;
-    }
-    if (qcomponent->isError()) {
-        QByteArray ba = qcomponent->errorString().toUtf8();
-        return local_strdup(ba.constData());
-    }
-    return local_strdup("component is not ready (why!?)");
-}
-
-QObject_ *componentCreate(QQmlComponent_ *component, QQmlContext_ *context)
-{
-    QQmlComponent *qcomponent = reinterpret_cast<QQmlComponent *>(component);
-    QQmlContext *qcontext = reinterpret_cast<QQmlContext *>(context);
-
-    if (!qcontext) {
-        qcontext = qmlContext(qcomponent);
-    }
-    return qcomponent->create(qcontext);
-}
-
-QQuickWindow_ *componentCreateWindow(QQmlComponent_ *component, QQmlContext_ *context)
-{
-    QQmlComponent *qcomponent = reinterpret_cast<QQmlComponent *>(component);
-    QQmlContext *qcontext = reinterpret_cast<QQmlContext *>(context);
-
-    if (!qcontext) {
-        qcontext = qmlContext(qcomponent);
-    }
-    QObject *obj = qcomponent->create(qcontext);
-    if (!objectIsWindow(obj)) {
-        QQuickView *view = new QQuickView(qmlEngine(qcomponent), 0);
-        view->setContent(qcomponent->url(), qcomponent, obj);
-        view->setResizeMode(QQuickView::SizeRootObjectToView);
-        obj = view;
-    }
-    return obj;
-}
-
-// Workaround for bug https://bugs.launchpad.net/bugs/1179716
-struct DoShowWindow : public QQuickWindow {
-    void show() {
-        QQuickWindow::show();
-        QResizeEvent resize(size(), size());
-        resizeEvent(&resize);
-    }
-};
-
-void windowShow(QQuickWindow_ *win)
-{
-    reinterpret_cast<DoShowWindow *>(win)->show();
-}
-
-void windowHide(QQuickWindow_ *win)
-{
-    reinterpret_cast<QQuickWindow *>(win)->hide();
-}
-
-uintptr_t windowPlatformId(QQuickWindow_ *win)
-{
-    return reinterpret_cast<QQuickWindow *>(win)->winId();
-}
-
-void windowConnectHidden(QQuickWindow_ *win)
-{
-    QQuickWindow *qwin = reinterpret_cast<QQuickWindow *>(win);
-    QObject::connect(qwin, &QWindow::visibleChanged, [=](bool visible){
-        if (!visible) {
-            hookWindowHidden(win);
-        }
-    });
-}
-
-QObject_ *windowRootObject(QQuickWindow_ *win)
-{
-    if (objectIsView(win)) {
-        return reinterpret_cast<QQuickView *>(win)->rootObject();
-    }
-    return win;
-}
-
-QImage_ *windowGrabWindow(QQuickWindow_ *win)
-{
-    QQuickWindow *qwin = reinterpret_cast<QQuickWindow *>(win);
-    QImage *image = new QImage;
-    *image = qwin->grabWindow().convertToFormat(QImage::Format_ARGB32_Premultiplied);
-    return image;
-}
-
-QImage_ *newImage(int width, int height)
-{
-    return new QImage(width, height, QImage::Format_ARGB32_Premultiplied);
-}
-
-void delImage(QImage_ *image)
-{
-    delete reinterpret_cast<QImage *>(image);
-}
-
-void imageSize(QImage_ *image, int *width, int *height)
-{
-    QImage *qimage = reinterpret_cast<QImage *>(image);
-    *width = qimage->width();
-    *height = qimage->height();
-}
-
-unsigned char *imageBits(QImage_ *image)
-{
-    QImage *qimage = reinterpret_cast<QImage *>(image);
-    return qimage->bits();
-}
-
-const unsigned char *imageConstBits(QImage_ *image)
-{
-    QImage *qimage = reinterpret_cast<QImage *>(image);
-    return qimage->constBits();
-}
-
-void contextSetObject(QQmlContext_ *context, QObject_ *value)
-{
-    QQmlContext *qcontext = reinterpret_cast<QQmlContext *>(context);
-    QObject *qvalue = reinterpret_cast<QObject *>(value);
-
-    // Give qvalue an engine reference if it doesn't yet have one.
-    if (!qmlEngine(qvalue)) {
-        QQmlEngine::setContextForObject(qvalue, qcontext->engine()->rootContext());
-    }
-
-    qcontext->setContextObject(qvalue);
-}
-
-void contextSetProperty(QQmlContext_ *context, QString_ *name, DataValue *value)
-{
-    const QString *qname = reinterpret_cast<QString *>(name);
-    QQmlContext *qcontext = reinterpret_cast<QQmlContext *>(context);
-
-    QVariant var;
-    unpackDataValue(value, &var);
-
-    // Give qvalue an engine reference if it doesn't yet have one .
-    QObject *obj = var.value<QObject *>();
-    if (obj && !qmlEngine(obj)) {
-        QQmlEngine::setContextForObject(obj, qcontext);
-    }
-
-    qcontext->setContextProperty(*qname, var);
-}
-
-void contextGetProperty(QQmlContext_ *context, QString_ *name, DataValue *result)
-{
-    QQmlContext *qcontext = reinterpret_cast<QQmlContext *>(context);
-    const QString *qname = reinterpret_cast<QString *>(name);
-
-    QVariant var = qcontext->contextProperty(*qname);
-    packDataValue(&var, result);
-}
-
-QQmlContext_ *contextSpawn(QQmlContext_ *context)
-{
-    QQmlContext *qcontext = reinterpret_cast<QQmlContext *>(context);
-    return new QQmlContext(qcontext);
-}
-
-void delObject(QObject_ *object)
-{
-    delete reinterpret_cast<QObject *>(object);
-}
-
-void delObjectLater(QObject_ *object)
-{
-    reinterpret_cast<QObject *>(object)->deleteLater();
-}
-
-const char *objectTypeName(QObject_ *object)
-{
-    return reinterpret_cast<QObject *>(object)->metaObject()->className();
-}
-
-int objectGetProperty(QObject_ *object, const char *name, DataValue *result)
-{
-    QObject *qobject = reinterpret_cast<QObject *>(object);
-    
-    QVariant var = qobject->property(name);
-    packDataValue(&var, result);
-
-    if (!var.isValid() && qobject->metaObject()->indexOfProperty(name) == -1) {
-            // TODO May have to check the dynamic property names too.
-            return 0;
-    }
-    return 1;
-}
-
-error *objectSetProperty(QObject_ *object, const char *name, DataValue *value)
-{
-    QObject *qobject = reinterpret_cast<QObject *>(object);
-    QVariant var;
-    unpackDataValue(value, &var);
-
-    // Give qvalue an engine reference if it doesn't yet have one.
-    QObject *obj = var.value<QObject *>();
-    if (obj && !qmlEngine(obj)) {
-        QQmlContext *context = qmlContext(qobject);
-        if (context) {
-            QQmlEngine::setContextForObject(obj, context);
-        }
-    }
-
-    // Check that the types are compatible. There's probably more to be done here.
-    const QMetaObject *metaObject = qobject->metaObject();
-    int propIndex = metaObject->indexOfProperty(name);
-    if (propIndex == -1) {
-            return errorf("cannot set non-existent property \"%s\" on type %s", name, qobject->metaObject()->className());
-    }
-
-    QMetaProperty prop = metaObject->property(propIndex);
-    int propType = prop.userType();
-    void *valueArg;
-    if (propType == QMetaType::QVariant) {
-        valueArg = (void *)&var;
-    } else {
-        int varType = var.userType();
-        QVariant saved = var;
-        if (propType != varType && !var.convert(propType)) {
-            if (varType == QMetaType::QObjectStar) {
-                return errorf("cannot set property \"%s\" with type %s to value of %s*",
-                        name, QMetaType::typeName(propType), saved.value<QObject*>()->metaObject()->className());
-            } else {
-                return errorf("cannot set property \"%s\" with type %s to value of %s",
-                        name, QMetaType::typeName(propType), QMetaType::typeName(varType));
-            }
-        }
-        valueArg = (void *)var.constData();
-    }
-
-    int status = -1;
-    int flags = 0;
-    void *args[] = {valueArg, 0, &status, &flags};
-    QMetaObject::metacall(qobject, QMetaObject::WriteProperty, propIndex, args);
-    return 0;
-}
-
-error *objectInvoke(QObject_ *object, const char *method, int methodLen, DataValue *resultdv, DataValue *paramsdv, int paramsLen)
-{
-    QObject *qobject = reinterpret_cast<QObject *>(object);
-
-    QVariant result;
-    QVariant param[MaxParams];
-    QGenericArgument arg[MaxParams];
-    for (int i = 0; i < paramsLen; i++) {
-        unpackDataValue(&paramsdv[i], &param[i]);
-        arg[i] = Q_ARG(QVariant, param[i]);
-    }
-    if (paramsLen > 10) {
-        panicf("fix the parameter dispatching");
-    }
-
-    const QMetaObject *metaObject = qobject->metaObject();
-    // Walk backwards so descendants have priority.
-    for (int i = metaObject->methodCount()-1; i >= 0; i--) {
-        QMetaMethod metaMethod = metaObject->method(i);
-        QMetaMethod::MethodType methodType = metaMethod.methodType();
-        if (methodType == QMetaMethod::Method || methodType == QMetaMethod::Slot) {
-            QByteArray name = metaMethod.name();
-            if (name.length() == methodLen && qstrncmp(name.constData(), method, methodLen) == 0) {
-                if (metaMethod.parameterCount() < paramsLen) {
-                    // TODO Might continue looking to see if a different signal has the same name and enough arguments.
-                    return errorf("method \"%s\" has too few parameters for provided arguments", method);
-                }
-
-                bool ok;
-                if (metaMethod.returnType() == QMetaType::Void) {
-                    ok = metaMethod.invoke(qobject, Qt::DirectConnection, 
-                        arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9]);
-                } else {
-                    ok = metaMethod.invoke(qobject, Qt::DirectConnection, Q_RETURN_ARG(QVariant, result),
-                        arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9]);
-                }
-                if (!ok) {
-                    return errorf("invalid parameters to method \"%s\"", method);
-                }
-
-                packDataValue(&result, resultdv);
-                return 0;
-            }
-        }
-    }
-
-    return errorf("object does not expose a method \"%s\"", method);
-}
-
-void objectFindChild(QObject_ *object, QString_ *name, DataValue *resultdv)
-{
-    QObject *qobject = reinterpret_cast<QObject *>(object);
-    QString *qname = reinterpret_cast<QString *>(name);
-    
-    QVariant var;
-    QObject *result = qobject->findChild<QObject *>(*qname);
-    if (result) {
-        var.setValue(result);
-    }
-    packDataValue(&var, resultdv);
-}
-
-void objectSetParent(QObject_ *object, QObject_ *parent)
-{
-    QObject *qobject = reinterpret_cast<QObject *>(object);
-    QObject *qparent = reinterpret_cast<QObject *>(parent);
-
-    qobject->setParent(qparent);
-}
-
-error *objectConnect(QObject_ *object, const char *signal, int signalLen, QQmlEngine_ *engine, void *func, int argsLen)
-{
-    QObject *qobject = reinterpret_cast<QObject *>(object);
-    QQmlEngine *qengine = reinterpret_cast<QQmlEngine *>(engine);
-    QByteArray qsignal(signal, signalLen);
-
-    const QMetaObject *meta = qobject->metaObject();
-    // Walk backwards so descendants have priority.
-    for (int i = meta->methodCount()-1; i >= 0; i--) {
-            QMetaMethod method = meta->method(i);
-            if (method.methodType() == QMetaMethod::Signal) {
-                QByteArray name = method.name();
-                if (name.length() == signalLen && qstrncmp(name.constData(), signal, signalLen) == 0) {
-                    if (method.parameterCount() < argsLen) {
-                        // TODO Might continue looking to see if a different signal has the same name and enough arguments.
-                        return errorf("signal \"%s\" has too few parameters for provided function", name.constData());
-                    }
-                    Connector *connector = new Connector(qobject, method, qengine, func, argsLen);
-                    const QMetaObject *connmeta = connector->metaObject();
-                    QObject::connect(qobject, method, connector, connmeta->method(connmeta->methodOffset()));
-                    return 0;
-                }
-            }
-    }
-    // Cannot use constData here as the byte array is not null-terminated.
-    return errorf("object does not expose a \"%s\" signal", qsignal.data());
-}
-
-QQmlContext_ *objectContext(QObject_ *object)
-{
-    return qmlContext(static_cast<QObject *>(object));
-}
-
-int objectIsComponent(QObject_ *object)
-{
-    QObject *qobject = static_cast<QObject *>(object);
-    return dynamic_cast<QQmlComponent *>(qobject) ? 1 : 0;
-}
-
-int objectIsWindow(QObject_ *object)
-{
-    QObject *qobject = static_cast<QObject *>(object);
-    return dynamic_cast<QQuickWindow *>(qobject) ? 1 : 0;
-}
-
-int objectIsView(QObject_ *object)
-{
-    QObject *qobject = static_cast<QObject *>(object);
-    return dynamic_cast<QQuickView *>(qobject) ? 1 : 0;
-}
-
-error *objectGoAddr(QObject_ *object, GoAddr **addr)
-{
-    QObject *qobject = static_cast<QObject *>(object);
-    GoValue *goValue = dynamic_cast<GoValue *>(qobject);
-    if (goValue) {
-        *addr = goValue->addr;
-        return 0;
-    }
-    GoPaintedValue *goPaintedValue = dynamic_cast<GoPaintedValue *>(qobject);
-    if (goPaintedValue) {
-        *addr = goPaintedValue->addr;
-        return 0;
-    }
-    return errorf("QML object is not backed by a Go value");
-}
-
-QString_ *newString(const char *data, int len)
-{
-    // This will copy data only once.
-    QByteArray ba = QByteArray::fromRawData(data, len);
-    return new QString(ba);
-}
-
-void delString(QString_ *s)
-{
-    delete reinterpret_cast<QString *>(s);
-}
-
-GoValue_ *newGoValue(GoAddr *addr, GoTypeInfo *typeInfo, QObject_ *parent)
-{
-    QObject *qparent = reinterpret_cast<QObject *>(parent);
-    if (typeInfo->paint) {
-        return new GoPaintedValue(addr, typeInfo, qparent);
-    }
-    return new GoValue(addr, typeInfo, qparent);
-}
-
-void goValueActivate(GoValue_ *value, GoTypeInfo *typeInfo, int addrOffset)
-{
-    GoMemberInfo *fieldInfo = typeInfo->fields;
-    for (int i = 0; i < typeInfo->fieldsLen; i++) {
-        if (fieldInfo->addrOffset == addrOffset) {
-            if (typeInfo->paint) {
-                static_cast<GoPaintedValue *>(value)->activate(fieldInfo->metaIndex);
-            } else {
-                static_cast<GoValue *>(value)->activate(fieldInfo->metaIndex);
-            }
-            return;
-        }
-        fieldInfo++;
-    }
-
-    // TODO Return an error; probably an unexported field.
-}
-
-void unpackDataValue(DataValue *value, QVariant_ *var)
-{
-    QVariant *qvar = reinterpret_cast<QVariant *>(var);
-    switch (value->dataType) {
-    case DTString:
-        *qvar = QString::fromUtf8(*(char **)value->data, value->len);
-        break;
-    case DTBool:
-        *qvar = bool(*(char *)(value->data) != 0);
-        break;
-    case DTInt64:
-        *qvar = *(qint64*)(value->data);
-        break;
-    case DTInt32:
-        *qvar = *(qint32*)(value->data);
-        break;
-    case DTUint64:
-        *qvar = *(quint64*)(value->data);
-        break;
-    case DTUint32:
-        *qvar = *(quint32*)(value->data);
-        break;
-    case DTFloat64:
-        *qvar = *(double*)(value->data);
-        break;
-    case DTFloat32:
-        *qvar = *(float*)(value->data);
-        break;
-    case DTColor:
-        *qvar = QColor::fromRgba(*(QRgb*)(value->data));
-        break;
-    case DTVariantList:
-        *qvar = **(QVariantList**)(value->data);
-        delete *(QVariantList**)(value->data);
-        break;
-    case DTObject:
-        qvar->setValue(*(QObject**)(value->data));
-        break;
-    case DTInvalid:
-        // null would be more natural, but an invalid variant means
-        // it has proper semantics when dealing with non-qml qt code.
-        //qvar->setValue(QJSValue(QJSValue::NullValue));
-        qvar->clear();
-        break;
-    default:
-        panicf("unknown data type: %d", value->dataType);
-        break;
-    }
-}
-
-void packDataValue(QVariant_ *var, DataValue *value)
-{
-    QVariant *qvar = reinterpret_cast<QVariant *>(var);
-
-    // Some assumptions are made below regarding the size of types.
-    // There's apparently no better way to handle this since that's
-    // how the types with well defined sizes (qint64) are mapped to
-    // meta-types (QMetaType::LongLong).
-    switch ((int)qvar->type()) {
-    case QVariant::Invalid:
-        value->dataType = DTInvalid;
-        break;
-    case QMetaType::QUrl:
-        *qvar = qvar->value<QUrl>().toString();
-        // fallthrough
-    case QMetaType::QString:
-        {
-            value->dataType = DTString;
-            QByteArray ba = qvar->toByteArray();
-            *(char**)(value->data) = local_strdup(ba.constData());
-            value->len = ba.size();
-            break;
-        }
-    case QMetaType::Bool:
-        value->dataType = DTBool;
-        *(qint8*)(value->data) = (qint8)qvar->toInt();
-        break;
-    case QMetaType::LongLong:
-        // Some of these entries will have to be fixed when handling platforms
-        // where sizeof(long long) != 8 or sizeof(int) != 4.
-        value->dataType = DTInt64;
-        *(qint64*)(value->data) = qvar->toLongLong();
-        break;
-    case QMetaType::ULongLong:
-        value->dataType = DTUint64;
-        *(quint64*)(value->data) = qvar->toLongLong();
-        break;
-    case QMetaType::Int:
-        value->dataType = DTInt32;
-        *(qint32*)(value->data) = qvar->toInt();
-        break;
-    case QMetaType::UInt:
-        value->dataType = DTUint32;
-        *(quint32*)(value->data) = qvar->toUInt();
-        break;
-    case QMetaType::VoidStar:
-        value->dataType = DTUintptr;
-        *(uintptr_t*)(value->data) = (uintptr_t)qvar->value<void *>();
-        break;
-    case QMetaType::Double:
-        value->dataType = DTFloat64;
-        *(double*)(value->data) = qvar->toDouble();
-        break;
-    case QMetaType::Float:
-        value->dataType = DTFloat32;
-        *(float*)(value->data) = qvar->toFloat();
-        break;
-    case QMetaType::QColor:
-        value->dataType = DTColor;
-        *(unsigned int*)(value->data) = qvar->value<QColor>().rgba();
-        break;
-    case QMetaType::QVariantList:
-        {
-            QVariantList varlist = qvar->toList();
-            int len = varlist.size();
-            DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len);
-            for (int i = 0; i < len; i++) {
-                packDataValue((void*)&varlist.at(i), &dvlist[i]);
-            }
-            value->dataType = DTValueList;
-            value->len = len;
-            *(DataValue**)(value->data) = dvlist;
-        }
-        break;
-    case QMetaType::QVariantMap:
-        {
-            QVariantMap varmap = qvar->toMap();
-            int len = varmap.size() * 2;
-            DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len);
-            QMapIterator<QString, QVariant> it(varmap);
-            for (int i = 0; i < len; i += 2) {
-                if (!it.hasNext()) {
-                    panicf("QVariantMap mutated during iteration");
-                }
-                it.next();
-                QVariant key = it.key();
-                QVariant val = it.value();
-                packDataValue((void*)&key, &dvlist[i]);
-                packDataValue((void*)&val, &dvlist[i+1]);
-            }
-            value->dataType = DTValueMap;
-            value->len = len;
-            *(DataValue**)(value->data) = dvlist;
-        }
-        break;
-    default:
-        if (qvar->type() == (int)QMetaType::QObjectStar || qvar->canConvert<QObject *>()) {
-            QObject *qobject = qvar->value<QObject *>();
-            GoValue *goValue = dynamic_cast<GoValue *>(qobject);
-            if (goValue) {
-                value->dataType = DTGoAddr;
-                *(void **)(value->data) = goValue->addr;
-                break;
-            }
-            GoPaintedValue *goPaintedValue = dynamic_cast<GoPaintedValue *>(qobject);
-            if (goPaintedValue) {
-                value->dataType = DTGoAddr;
-                *(void **)(value->data) = goPaintedValue->addr;
-                break;
-            }
-            value->dataType = DTObject;
-            *(void **)(value->data) = qobject;
-            break;
-        }
-        {
-            QQmlListReference ref = qvar->value<QQmlListReference>();
-            if (ref.isValid() && ref.canCount() && ref.canAt()) {
-                int len = ref.count();
-                DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len);
-                QVariant elem;
-                for (int i = 0; i < len; i++) {
-                    elem.setValue(ref.at(i));
-                    packDataValue(&elem, &dvlist[i]);
-                }
-                value->dataType = DTValueList;
-                value->len = len;
-                *(DataValue**)(value->data) = dvlist;
-                break;
-            }
-        }
-        if (qstrncmp(qvar->typeName(), "QQmlListProperty<", 17) == 0) {
-            QQmlListProperty<QObject> *list = reinterpret_cast<QQmlListProperty<QObject>*>(qvar->data());
-            if (list->count && list->at) {
-                int len = list->count(list);
-                DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len);
-                QVariant elem;
-                for (int i = 0; i < len; i++) {
-                    elem.setValue(list->at(list, i));
-                    packDataValue(&elem, &dvlist[i]);
-                }
-                value->dataType = DTValueList;
-                value->len = len;
-                *(DataValue**)(value->data) = dvlist;
-                break;
-            }
-        }
-        panicf("unsupported variant type: %d (%s)", qvar->type(), qvar->typeName());
-        break;
-    }
-}
-
-QVariantList_ *newVariantList(DataValue *list, int len)
-{
-    QVariantList *vlist = new QVariantList();
-    vlist->reserve(len);
-    for (int i = 0; i < len; i++) {
-        QVariant var;
-        unpackDataValue(&list[i], &var);
-        vlist->append(var);
-    }
-    return vlist;
-}
-
-QObject *listPropertyAt(QQmlListProperty<QObject> *list, int i)
-{
-    return reinterpret_cast<QObject *>(hookListPropertyAt(list->data, (intptr_t)list->dummy1, (intptr_t)list->dummy2, i));
-}
-
-int listPropertyCount(QQmlListProperty<QObject> *list)
-{
-    return hookListPropertyCount(list->data, (intptr_t)list->dummy1, (intptr_t)list->dummy2);
-}
-
-void listPropertyAppend(QQmlListProperty<QObject> *list, QObject *obj)
-{
-    hookListPropertyAppend(list->data, (intptr_t)list->dummy1, (intptr_t)list->dummy2, obj);
-}
-
-void listPropertyClear(QQmlListProperty<QObject> *list)
-{
-    hookListPropertyClear(list->data, (intptr_t)list->dummy1, (intptr_t)list->dummy2);
-}
-
-QQmlListProperty_ *newListProperty(GoAddr *addr, intptr_t reflectIndex, intptr_t setIndex)
-{
-    QQmlListProperty<QObject> *list = new QQmlListProperty<QObject>();
-    list->data = addr;
-    list->dummy1 = (void*)reflectIndex;
-    list->dummy2 = (void*)setIndex;
-    list->at = listPropertyAt;
-    list->count = listPropertyCount;
-    list->append = listPropertyAppend;
-    list->clear = listPropertyClear;
-    return list;
-}
-
-void internalLogHandler(QtMsgType severity, const QMessageLogContext &context, const QString &text)
-{
-    QByteArray textba = text.toUtf8();
-    int fileLength = context.file ? strlen(context.file) : 0;
-    LogMessage message = {severity, textba.constData(), textba.size(), context.file, fileLength, context.line};
-    hookLogHandler(&message);
-}
-
-void installLogHandler()
-{
-    qInstallMessageHandler(internalLogHandler);
-}
-
-// vim:ts=4:sw=4:et:ft=cpp

=== removed file 'qml.v0/cpp/capi.h'
--- qml.v0/cpp/capi.h	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/capi.h	1970-01-01 00:00:00 +0000
@@ -1,206 +0,0 @@
-#ifndef CAPI_H
-#define CAPI_H
-
-#include <stdint.h>
-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// It's surprising that MaximumParamCount is privately defined within qmetaobject.cpp.
-// Must fix the objectInvoke function if this is changed.
-// This is Qt's MaximuParamCount - 1, as it does not take the result value in account.
-enum { MaxParams = 10 };
-
-typedef void QApplication_;
-typedef void QMetaObject_;
-typedef void QObject_;
-typedef void QVariant_;
-typedef void QVariantList_;
-typedef void QString_;
-typedef void QQmlEngine_;
-typedef void QQmlContext_;
-typedef void QQmlComponent_;
-typedef void QQmlListProperty_;
-typedef void QQuickWindow_;
-typedef void QQuickView_;
-typedef void QMessageLogContext_;
-typedef void QImage_;
-typedef void GoValue_;
-typedef void GoAddr;
-typedef void GoTypeSpec_;
-
-typedef char error;
-error *errorf(const char *format, ...);
-void panicf(const char *format, ...);
-
-typedef enum {
-    DTUnknown = 0, // Has an unsupported type.
-    DTInvalid = 1, // Does not exist or similar.
-
-    DTString  = 10,
-    DTBool    = 11,
-    DTInt64   = 12,
-    DTInt32   = 13,
-    DTUint64  = 14,
-    DTUint32  = 15,
-    DTUintptr = 16,
-    DTFloat64 = 17,
-    DTFloat32 = 18,
-    DTColor   = 19,
-
-    DTGoAddr       = 100,
-    DTObject       = 101,
-    DTValueMap     = 102,
-    DTValueList    = 103,
-    DTVariantList  = 104,
-    DTListProperty = 105,
-
-    // Used in type information, not in an actual data value.
-    DTAny     = 201, // Can hold any of the above types.
-    DTMethod  = 202
-} DataType;
-
-typedef struct {
-    DataType dataType;
-    char data[8];
-    int len;
-} DataValue;
-
-typedef struct {
-    char *memberName; // points to memberNames
-    DataType memberType;
-    int reflectIndex;
-    int reflectGetIndex;
-    int reflectSetIndex;
-    int metaIndex;
-    int addrOffset;
-    char *methodSignature;
-    char *resultSignature;
-    int numIn;
-    int numOut;
-} GoMemberInfo;
-
-typedef struct {
-    char *typeName;
-    GoMemberInfo *fields;
-    GoMemberInfo *methods;
-    GoMemberInfo *members; // fields + methods
-    GoMemberInfo *paint;   // in methods too
-    int fieldsLen;
-    int methodsLen;
-    int membersLen;
-    char *memberNames;
-
-    QMetaObject_ *metaObject;
-} GoTypeInfo;
-
-typedef struct {
-    int severity;
-    const char *text;
-    int textLen;
-    const char *file;
-    int fileLen;
-    int line;
-} LogMessage;
-
-void newGuiApplication(char *deskfile);
-void applicationExec();
-void applicationFlushAll();
-
-void idleTimerInit(int *hookWaiting);
-void idleTimerStart();
-
-void *currentThread();
-void *appThread();
-
-QQmlEngine_ *newEngine(QObject_ *parent);
-QQmlContext_ *engineRootContext(QQmlEngine_ *engine);
-void engineSetOwnershipCPP(QQmlEngine_ *engine, QObject_ *object);
-void engineSetOwnershipJS(QQmlEngine_ *engine, QObject_ *object);
-void engineSetContextForObject(QQmlEngine_ *engine, QObject_ *object);
-void engineAddImageProvider(QQmlEngine_ *engine, QString_ *providerId, void *imageFunc);
-
-void contextGetProperty(QQmlContext_ *context, QString_ *name, DataValue *value);
-void contextSetProperty(QQmlContext_ *context, QString_ *name, DataValue *value);
-void contextSetObject(QQmlContext_ *context, QObject_ *value);
-QQmlContext_ *contextSpawn(QQmlContext_ *context);
-
-void delObject(QObject_ *object);
-void delObjectLater(QObject_ *object);
-const char *objectTypeName(QObject_ *object);
-int objectGetProperty(QObject_ *object, const char *name, DataValue *result);
-error *objectSetProperty(QObject_ *object, const char *name, DataValue *value);
-void objectSetParent(QObject_ *object, QObject_ *parent);
-error *objectInvoke(QObject_ *object, const char *method, int methodLen, DataValue *result, DataValue *params, int paramsLen);
-void objectFindChild(QObject_ *object, QString_ *name, DataValue *result);
-QQmlContext_ *objectContext(QObject_ *object);
-int objectIsComponent(QObject_ *object);
-int objectIsWindow(QObject_ *object);
-int objectIsView(QObject_ *object);
-error *objectConnect(QObject_ *object, const char *signal, int signalLen, QQmlEngine_ *engine, void *func, int argsLen);
-error *objectGoAddr(QObject_ *object, GoAddr **addr);
-
-QQmlComponent_ *newComponent(QQmlEngine_ *engine, QObject_ *parent);
-void componentSetData(QQmlComponent_ *component, const char *data, int dataLen, const char *url, int urlLen);
-char *componentErrorString(QQmlComponent_ *component);
-QObject_ *componentCreate(QQmlComponent_ *component, QQmlContext_ *context);
-QQuickWindow_ *componentCreateWindow(QQmlComponent_ *component, QQmlContext_ *context);
-
-void windowShow(QQuickWindow_ *win);
-void windowHide(QQuickWindow_ *win);
-uintptr_t windowPlatformId(QQuickWindow_ *win);
-void windowConnectHidden(QQuickWindow_ *win);
-QObject_ *windowRootObject(QQuickWindow_ *win);
-QImage_ *windowGrabWindow(QQuickWindow_ *win);
-
-QImage_ *newImage(int width, int height);
-void delImage(QImage_ *image);
-void imageSize(QImage_ *image, int *width, int *height);
-unsigned char *imageBits(QImage_ *image);
-const unsigned char *imageConstBits(QImage_ *image);
-
-QString_ *newString(const char *data, int len);
-void delString(QString_ *s);
-
-GoValue_ *newGoValue(GoAddr *addr, GoTypeInfo *typeInfo, QObject_ *parent);
-void goValueActivate(GoValue_ *value, GoTypeInfo *typeInfo, int addrOffset);
-
-void packDataValue(QVariant_ *var, DataValue *result);
-void unpackDataValue(DataValue *value, QVariant_ *result);
-
-QVariantList_ *newVariantList(DataValue *list, int len);
-
-QQmlListProperty_ *newListProperty(GoAddr *addr, intptr_t reflectIndex, intptr_t setIndex);
-
-int registerType(char *location, int major, int minor, char *name, GoTypeInfo *typeInfo, GoTypeSpec_ *spec);
-int registerSingleton(char *location, int major, int minor, char *name, GoTypeInfo *typeInfo, GoTypeSpec_ *spec);
-
-void installLogHandler();
-
-void hookIdleTimer();
-void hookLogHandler(LogMessage *message);
-void hookGoValueReadField(QQmlEngine_ *engine, GoAddr *addr, int memberIndex, int getIndex, int setIndex, DataValue *result);
-void hookGoValueWriteField(QQmlEngine_ *engine, GoAddr *addr, int memberIndex, int setIndex, DataValue *assign);
-void hookGoValueCallMethod(QQmlEngine_ *engine, GoAddr *addr, int memberIndex, DataValue *result);
-void hookGoValueDestroyed(QQmlEngine_ *engine, GoAddr *addr);
-void hookGoValuePaint(QQmlEngine_ *engine, GoAddr *addr, intptr_t reflextIndex);
-QImage_ *hookRequestImage(void *imageFunc, char *id, int idLen, int width, int height);
-GoAddr *hookGoValueTypeNew(GoValue_ *value, GoTypeSpec_ *spec);
-void hookWindowHidden(QObject_ *addr);
-void hookSignalCall(QQmlEngine_ *engine, void *func, DataValue *params);
-void hookSignalDisconnect(void *func);
-void hookPanic(char *message);
-int hookListPropertyCount(GoAddr *addr, intptr_t reflectIndex, intptr_t setIndex);
-QObject_ *hookListPropertyAt(GoAddr *addr, intptr_t reflectIndex, intptr_t setIndex, int i);
-void hookListPropertyAppend(GoAddr *addr, intptr_t reflectIndex, intptr_t setIndex, QObject_ *obj);
-void hookListPropertyClear(GoAddr *addr, intptr_t reflectIndex, intptr_t setIndex);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#endif // CAPI_H
-
-// vim:ts=4:et

=== removed file 'qml.v0/cpp/connector.cpp'
--- qml.v0/cpp/connector.cpp	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/connector.cpp	1970-01-01 00:00:00 +0000
@@ -1,46 +0,0 @@
-#include <QObject>
-
-#include "connector.h"
-#include "capi.h"
-
-Connector::~Connector()
-{
-    hookSignalDisconnect(func);
-}
-
-void Connector::invoke()
-{
-    panicf("should never get called");
-}
-
-int Connector::qt_metacall(QMetaObject::Call c, int idx, void **a)
-{
-    if (c == QMetaObject::InvokeMetaMethod && idx == metaObject()->methodOffset()) {
-        DataValue args[MaxParams];
-        QObject *plain = NULL;
-        for (int i = 0; i < argsLen; i++) {
-            int paramType = method.parameterType(i);
-            if (paramType == 0 && a[1 + i] != NULL) {
-                const char *typeName = method.parameterTypes()[i].constData();
-                void *addr = a[1 + i];
-                if (typeName[strlen(typeName)-1] == '*') {
-                    addr = *(void **)addr;
-                }
-                plain = new PlainObject(typeName, addr, plain);
-                QVariant var = QVariant::fromValue((QObject *)plain);
-                packDataValue(&var, &args[i]);
-            } else {
-                QVariant var(method.parameterType(i), a[1 + i]);
-                packDataValue(&var, &args[i]);
-            }
-        }
-        hookSignalCall(engine, func, args);
-        if (plain != NULL) {
-                delete plain;
-        }
-        return -1;
-    }
-    return standard_qt_metacall(c, idx, a);
-}
-
-// vim:ts=4:sw=4:et

=== removed file 'qml.v0/cpp/connector.h'
--- qml.v0/cpp/connector.h	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/connector.h	1970-01-01 00:00:00 +0000
@@ -1,58 +0,0 @@
-#ifndef CONNECTOR_H
-#define CONNECTOR_H
-
-#include <QObject>
-
-#include <stdint.h>
-
-class Connector : public QObject
-{
-    Q_OBJECT
-
-    public:
-
-    Connector(QObject *sender, QMetaMethod method, QQmlEngine *engine, void *func, int argsLen)
-        : QObject(sender), engine(engine), method(method), func(func), argsLen(argsLen) {};
-
-    virtual ~Connector();
-
-    // MOC HACK: s/Connector::qt_metacall/Connector::standard_qt_metacall/
-    int standard_qt_metacall(QMetaObject::Call c, int idx, void **a);
-
-    public slots:
-
-    void invoke();
-
-    private:
-
-    QQmlEngine *engine;
-    QMetaMethod method;
-    void *func;
-    int argsLen;
-};
-
-class PlainObject : public QObject
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString plainType READ getPlainType)
-    Q_PROPERTY(void *plainAddr READ getPlainAddr)
-
-    QString plainType;
-    void *plainAddr;
-
-    public:
-
-    PlainObject(QObject *parent = 0)
-        : QObject(parent) {};
-
-    PlainObject(const char *plainType, void *plainAddr, QObject *parent = 0)
-        : QObject(parent), plainType(plainType), plainAddr(plainAddr) {};
-
-    QString getPlainType() { return plainType; };
-    void *getPlainAddr() { return plainAddr; };
-};
-
-#endif // CONNECTOR_H
-
-// vim:ts=4:sw=4:et

=== removed file 'qml.v0/cpp/govalue.cpp'
--- qml.v0/cpp/govalue.cpp	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/govalue.cpp	1970-01-01 00:00:00 +0000
@@ -1,237 +0,0 @@
-#include <private/qmetaobjectbuilder_p.h>
-
-#include <QtOpenGL/QtOpenGL>
-#include <QtOpenGL/QGLFunctions>
-
-#include <QtQml/QtQml>
-#include <QQmlEngine>
-#include <QDebug>
-
-#include "govalue.h"
-#include "capi.h"
-
-class GoValueMetaObject : public QAbstractDynamicMetaObject
-{
-public:
-    GoValueMetaObject(QObject* value, GoAddr *addr, GoTypeInfo *typeInfo);
-
-    void activatePropIndex(int propIndex);
-
-protected:
-    int metaCall(QMetaObject::Call c, int id, void **a);
-
-private:
-    QObject *value;
-    GoAddr *addr;
-    GoTypeInfo *typeInfo;
-};
-
-GoValueMetaObject::GoValueMetaObject(QObject *value, GoAddr *addr, GoTypeInfo *typeInfo)
-    : value(value), addr(addr), typeInfo(typeInfo)
-{
-    //d->parent = static_cast<QAbstractDynamicMetaObject *>(priv->metaObject);
-    *static_cast<QMetaObject *>(this) = *metaObjectFor(typeInfo);
-
-    QObjectPrivate *objPriv = QObjectPrivate::get(value);
-    objPriv->metaObject = this;
-}
-
-int GoValueMetaObject::metaCall(QMetaObject::Call c, int idx, void **a)
-{
-    //qWarning() << "GoValueMetaObject::metaCall" << c << idx;
-    switch (c) {
-    case QMetaObject::ReadProperty:
-    case QMetaObject::WriteProperty:
-        {
-            // TODO Cache propertyOffset, methodOffset (and maybe qmlEngine)
-            int propOffset = propertyOffset();
-            if (idx < propOffset) {
-                return value->qt_metacall(c, idx, a);
-            }
-            GoMemberInfo *memberInfo = typeInfo->fields;
-            for (int i = 0; i < typeInfo->fieldsLen; i++) {
-                if (memberInfo->metaIndex == idx) {
-                    if (c == QMetaObject::ReadProperty) {
-                        DataValue result;
-                        hookGoValueReadField(qmlEngine(value), addr, memberInfo->reflectIndex, memberInfo->reflectGetIndex, memberInfo->reflectSetIndex, &result);
-                        if (memberInfo->memberType == DTListProperty) {
-                            if (result.dataType != DTListProperty) {
-                                panicf("reading DTListProperty field returned non-DTListProperty result");
-                            }
-                            QQmlListProperty<QObject> *in = *reinterpret_cast<QQmlListProperty<QObject> **>(result.data);
-                            QQmlListProperty<QObject> *out = reinterpret_cast<QQmlListProperty<QObject> *>(a[0]);
-                            *out = *in;
-                            // TODO Could provide a single variable in the stack to ReadField instead.
-                            delete in;
-                        } else {
-                            QVariant *out = reinterpret_cast<QVariant *>(a[0]);
-                            unpackDataValue(&result, out);
-                        }
-                    } else {
-                        DataValue assign;
-                        QVariant *in = reinterpret_cast<QVariant *>(a[0]);
-                        packDataValue(in, &assign);
-                        hookGoValueWriteField(qmlEngine(value), addr, memberInfo->reflectIndex, memberInfo->reflectSetIndex, &assign);
-                        activate(value, methodOffset() + (idx - propOffset), 0);
-                    }
-                    return -1;
-                }
-                memberInfo++;
-            }
-            QMetaProperty prop = property(idx);
-            qWarning() << "Property" << prop.name() << "not found!?";
-            break;
-        }
-    case QMetaObject::InvokeMetaMethod:
-        {
-            if (idx < methodOffset()) {
-                return value->qt_metacall(c, idx, a);
-            }
-            GoMemberInfo *memberInfo = typeInfo->methods;
-            for (int i = 0; i < typeInfo->methodsLen; i++) {
-                if (memberInfo->metaIndex == idx) {
-                    // args[0] is the result if any.
-                    DataValue args[1 + MaxParams];
-                    for (int i = 1; i < memberInfo->numIn+1; i++) {
-                        packDataValue(reinterpret_cast<QVariant *>(a[i]), &args[i]);
-                    }
-                    hookGoValueCallMethod(qmlEngine(value), addr, memberInfo->reflectIndex, args);
-                    if (memberInfo->numOut > 0) {
-                        unpackDataValue(&args[0], reinterpret_cast<QVariant *>(a[0]));
-                    }
-                    return -1;
-                }
-                memberInfo++;
-            }
-            QMetaMethod m = method(idx);
-            qWarning() << "Method" << m.name() << "not found!?";
-            break;
-        }
-    default:
-        break; // Unhandled.
-    }
-    return -1;
-}
-
-void GoValueMetaObject::activatePropIndex(int propIndex)
-{
-    // Properties are added first, so the first fieldLen methods are in
-    // fact the signals of the respective properties.
-    int relativeIndex = propIndex - propertyOffset();
-    activate(value, methodOffset() + relativeIndex, 0);
-}
-
-GoValue::GoValue(GoAddr *addr, GoTypeInfo *typeInfo, QObject *parent)
-    : addr(addr), typeInfo(typeInfo)
-{
-    valueMeta = new GoValueMetaObject(this, addr, typeInfo);
-    setParent(parent);
-}
-
-GoValue::~GoValue()
-{
-    hookGoValueDestroyed(qmlEngine(this), addr);
-}
-
-void GoValue::activate(int propIndex)
-{
-    valueMeta->activatePropIndex(propIndex);
-}
-
-GoPaintedValue::GoPaintedValue(GoAddr *addr, GoTypeInfo *typeInfo, QObject *parent)
-    : addr(addr), typeInfo(typeInfo)
-{
-    valueMeta = new GoValueMetaObject(this, addr, typeInfo);
-    setParent(parent);
-
-    QQuickItem::setFlag(QQuickItem::ItemHasContents, true);
-    QQuickPaintedItem::setRenderTarget(QQuickPaintedItem::FramebufferObject);
-}
-
-GoPaintedValue::~GoPaintedValue()
-{
-    hookGoValueDestroyed(qmlEngine(this), addr);
-}
-
-void GoPaintedValue::activate(int propIndex)
-{
-    valueMeta->activatePropIndex(propIndex);
-}
-
-void GoPaintedValue::paint(QPainter *painter)
-{
-    //qWarning() << "paint: x=" << x() << "; y=" << y() << "; width=" << width() << "; height=" << height();
-    painter->beginNativePainting();
-    hookGoValuePaint(qmlEngine(this), addr, typeInfo->paint->reflectIndex);
-    painter->endNativePainting();
-}
-
-QMetaObject *metaObjectFor(GoTypeInfo *typeInfo)
-{
-    if (typeInfo->metaObject) {
-            return reinterpret_cast<QMetaObject *>(typeInfo->metaObject);
-    }
-
-    QMetaObjectBuilder mob;
-    if (typeInfo->paint) {
-        mob.setSuperClass(&QQuickPaintedItem::staticMetaObject);
-    } else {
-        mob.setSuperClass(&QObject::staticMetaObject);
-    }
-    mob.setClassName(typeInfo->typeName);
-    mob.setFlags(QMetaObjectBuilder::DynamicMetaObject);
-
-    GoMemberInfo *memberInfo;
-    
-    memberInfo = typeInfo->fields;
-    int relativePropIndex = mob.propertyCount();
-    for (int i = 0; i < typeInfo->fieldsLen; i++) {
-        mob.addSignal("__" + QByteArray::number(relativePropIndex) + "()");
-        const char *typeName = "QVariant";
-        if (memberInfo->memberType == DTListProperty) {
-            typeName = "QQmlListProperty<QObject>";
-        }
-        QMetaPropertyBuilder propb = mob.addProperty(memberInfo->memberName, typeName, relativePropIndex);
-        propb.setWritable(true);
-        memberInfo->metaIndex = relativePropIndex;
-        memberInfo++;
-        relativePropIndex++;
-    }
-
-    memberInfo = typeInfo->methods;
-    int relativeMethodIndex = mob.methodCount();
-    for (int i = 0; i < typeInfo->methodsLen; i++) {
-        if (*memberInfo->resultSignature) {
-            mob.addMethod(memberInfo->methodSignature, memberInfo->resultSignature);
-        } else {
-            mob.addMethod(memberInfo->methodSignature);
-        }
-        memberInfo->metaIndex = relativeMethodIndex;
-        memberInfo++;
-        relativeMethodIndex++;
-    }
-
-    // TODO Support default properties.
-    //mob.addClassInfo("DefaultProperty", "objects");
-
-    QMetaObject *mo = mob.toMetaObject();
-
-    // Turn the relative indexes into absolute indexes.
-    memberInfo = typeInfo->fields;
-    int propOffset = mo->propertyOffset();
-    for (int i = 0; i < typeInfo->fieldsLen; i++) {
-        memberInfo->metaIndex += propOffset;
-        memberInfo++;
-    }
-    memberInfo = typeInfo->methods;
-    int methodOffset = mo->methodOffset();
-    for (int i = 0; i < typeInfo->methodsLen; i++) {
-        memberInfo->metaIndex += methodOffset;
-        memberInfo++;
-    }
-
-    typeInfo->metaObject = mo;
-    return mo;
-}
-
-// vim:ts=4:sw=4:et:ft=cpp

=== removed file 'qml.v0/cpp/govalue.h'
--- qml.v0/cpp/govalue.h	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/govalue.h	1970-01-01 00:00:00 +0000
@@ -1,56 +0,0 @@
-#ifndef GOVALUE_H
-#define GOVALUE_H
-
-// Unfortunatley we need access to private bits, because the
-// whole dynamic meta-object concept is sadly being hidden
-// away, and without it this package wouldn't exist.
-#include <private/qmetaobject_p.h>
-
-#include <QQuickPaintedItem>
-#include <QPainter>
-
-#include "capi.h"
-
-class GoValueMetaObject;
-
-QMetaObject *metaObjectFor(GoTypeInfo *typeInfo);
-
-class GoValue : public QObject
-{
-    Q_OBJECT
-
-public:
-    GoAddr *addr;
-    GoTypeInfo *typeInfo;
-
-    GoValue(GoAddr *addr, GoTypeInfo *typeInfo, QObject *parent);
-    virtual ~GoValue();
-
-    void activate(int propIndex);
-
-private:
-    GoValueMetaObject *valueMeta;
-};
-
-class GoPaintedValue : public QQuickPaintedItem
-{
-    Q_OBJECT
-
-public:
-    GoAddr *addr;
-    GoTypeInfo *typeInfo;
-
-    GoPaintedValue(GoAddr *addr, GoTypeInfo *typeInfo, QObject *parent);
-    virtual ~GoPaintedValue();
-
-    void activate(int propIndex);
-
-    virtual void paint(QPainter *painter);
-
-private:
-    GoValueMetaObject *valueMeta;
-};
-
-#endif // GOVALUE_H
-
-// vim:ts=4:sw=4:et:ft=cpp

=== removed file 'qml.v0/cpp/govaluetype.cpp'
--- qml.v0/cpp/govaluetype.cpp	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/govaluetype.cpp	1970-01-01 00:00:00 +0000
@@ -1,254 +0,0 @@
-#include "govaluetype.h"
-
-#define DEFINE_GOVALUETYPE(N) \
-    template<> QMetaObject GoValueType<N>::staticMetaObject = QMetaObject(); \
-    template<> GoTypeInfo *GoValueType<N>::typeInfo = 0; \
-    template<> GoTypeSpec_ *GoValueType<N>::typeSpec = 0;
-
-#define DEFINE_GOPAINTEDVALUETYPE(N) \
-    template<> QMetaObject GoPaintedValueType<N>::staticMetaObject = QMetaObject(); \
-    template<> GoTypeInfo *GoPaintedValueType<N>::typeInfo = 0; \
-    template<> GoTypeSpec_ *GoPaintedValueType<N>::typeSpec = 0;
-
-DEFINE_GOVALUETYPE(1)
-DEFINE_GOVALUETYPE(2)
-DEFINE_GOVALUETYPE(3)
-DEFINE_GOVALUETYPE(4)
-DEFINE_GOVALUETYPE(5)
-DEFINE_GOVALUETYPE(6)
-DEFINE_GOVALUETYPE(7)
-DEFINE_GOVALUETYPE(8)
-DEFINE_GOVALUETYPE(9)
-DEFINE_GOVALUETYPE(10)
-DEFINE_GOVALUETYPE(11)
-DEFINE_GOVALUETYPE(12)
-DEFINE_GOVALUETYPE(13)
-DEFINE_GOVALUETYPE(14)
-DEFINE_GOVALUETYPE(15)
-DEFINE_GOVALUETYPE(16)
-DEFINE_GOVALUETYPE(17)
-DEFINE_GOVALUETYPE(18)
-DEFINE_GOVALUETYPE(19)
-DEFINE_GOVALUETYPE(20)
-DEFINE_GOVALUETYPE(21)
-DEFINE_GOVALUETYPE(22)
-DEFINE_GOVALUETYPE(23)
-DEFINE_GOVALUETYPE(24)
-DEFINE_GOVALUETYPE(25)
-DEFINE_GOVALUETYPE(26)
-DEFINE_GOVALUETYPE(27)
-DEFINE_GOVALUETYPE(28)
-DEFINE_GOVALUETYPE(29)
-DEFINE_GOVALUETYPE(30)
-
-DEFINE_GOPAINTEDVALUETYPE(1)
-DEFINE_GOPAINTEDVALUETYPE(2)
-DEFINE_GOPAINTEDVALUETYPE(3)
-DEFINE_GOPAINTEDVALUETYPE(4)
-DEFINE_GOPAINTEDVALUETYPE(5)
-DEFINE_GOPAINTEDVALUETYPE(6)
-DEFINE_GOPAINTEDVALUETYPE(7)
-DEFINE_GOPAINTEDVALUETYPE(8)
-DEFINE_GOPAINTEDVALUETYPE(9)
-DEFINE_GOPAINTEDVALUETYPE(10)
-DEFINE_GOPAINTEDVALUETYPE(11)
-DEFINE_GOPAINTEDVALUETYPE(12)
-DEFINE_GOPAINTEDVALUETYPE(13)
-DEFINE_GOPAINTEDVALUETYPE(14)
-DEFINE_GOPAINTEDVALUETYPE(15)
-DEFINE_GOPAINTEDVALUETYPE(16)
-DEFINE_GOPAINTEDVALUETYPE(17)
-DEFINE_GOPAINTEDVALUETYPE(18)
-DEFINE_GOPAINTEDVALUETYPE(19)
-DEFINE_GOPAINTEDVALUETYPE(20)
-DEFINE_GOPAINTEDVALUETYPE(21)
-DEFINE_GOPAINTEDVALUETYPE(22)
-DEFINE_GOPAINTEDVALUETYPE(23)
-DEFINE_GOPAINTEDVALUETYPE(24)
-DEFINE_GOPAINTEDVALUETYPE(25)
-DEFINE_GOPAINTEDVALUETYPE(26)
-DEFINE_GOPAINTEDVALUETYPE(27)
-DEFINE_GOPAINTEDVALUETYPE(28)
-DEFINE_GOPAINTEDVALUETYPE(29)
-DEFINE_GOPAINTEDVALUETYPE(30)
-
-static int goValueTypeN = 0;
-static int goPaintedValueTypeN = 0;
-
-template<int N>
-int registerSingletonN(char *location, int major, int minor, char *name, GoTypeInfo *info, GoTypeSpec_ *spec) {
-    GoValueType<N>::init(info, spec);
-    return qmlRegisterSingletonType< GoValueType<N> >(location, major, minor, name, [](QQmlEngine *qmlEngine, QJSEngine *jsEngine) -> QObject* {
-        QObject *singleton = new GoValueType<N>();
-        QQmlEngine::setContextForObject(singleton, qmlEngine->rootContext());
-        return singleton;
-    });
-}
-
-template<int N>
-int registerPaintedSingletonN(char *location, int major, int minor, char *name, GoTypeInfo *info, GoTypeSpec_ *spec) {
-    GoPaintedValueType<N>::init(info, spec);
-    return qmlRegisterSingletonType< GoPaintedValueType<N> >(location, major, minor, name, [](QQmlEngine *qmlEngine, QJSEngine *jsEngine) -> QObject* {
-        QObject *singleton = new GoPaintedValueType<N>();
-        QQmlEngine::setContextForObject(singleton, qmlEngine->rootContext());
-        return singleton;
-    });
-}
-
-#define GOVALUETYPE_CASE_SINGLETON(N) \
-        case N: return registerSingletonN<N>(location, major, minor, name, info, spec);
-#define GOPAINTEDVALUETYPE_CASE_SINGLETON(N) \
-        case N: return registerPaintedSingletonN<N>(location, major, minor, name, info, spec);
-
-int registerSingleton(char *location, int major, int minor, char *name, GoTypeInfo *info, GoTypeSpec_ *spec)
-{
-    if (!info->paint) {
-        switch (++goValueTypeN) {
-        GOVALUETYPE_CASE_SINGLETON(1)
-        GOVALUETYPE_CASE_SINGLETON(2)
-        GOVALUETYPE_CASE_SINGLETON(3)
-        GOVALUETYPE_CASE_SINGLETON(4)
-        GOVALUETYPE_CASE_SINGLETON(5)
-        GOVALUETYPE_CASE_SINGLETON(6)
-        GOVALUETYPE_CASE_SINGLETON(7)
-        GOVALUETYPE_CASE_SINGLETON(8)
-        GOVALUETYPE_CASE_SINGLETON(9)
-        GOVALUETYPE_CASE_SINGLETON(10)
-        GOVALUETYPE_CASE_SINGLETON(11)
-        GOVALUETYPE_CASE_SINGLETON(12)
-        GOVALUETYPE_CASE_SINGLETON(13)
-        GOVALUETYPE_CASE_SINGLETON(14)
-        GOVALUETYPE_CASE_SINGLETON(15)
-        GOVALUETYPE_CASE_SINGLETON(16)
-        GOVALUETYPE_CASE_SINGLETON(17)
-        GOVALUETYPE_CASE_SINGLETON(18)
-        GOVALUETYPE_CASE_SINGLETON(19)
-        GOVALUETYPE_CASE_SINGLETON(20)
-        GOVALUETYPE_CASE_SINGLETON(21)
-        GOVALUETYPE_CASE_SINGLETON(22)
-        GOVALUETYPE_CASE_SINGLETON(23)
-        GOVALUETYPE_CASE_SINGLETON(24)
-        GOVALUETYPE_CASE_SINGLETON(25)
-        GOVALUETYPE_CASE_SINGLETON(26)
-        GOVALUETYPE_CASE_SINGLETON(27)
-        GOVALUETYPE_CASE_SINGLETON(28)
-        GOVALUETYPE_CASE_SINGLETON(29)
-        GOVALUETYPE_CASE_SINGLETON(30)
-        }
-    } else {
-        switch (++goPaintedValueTypeN) {
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(1)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(2)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(3)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(4)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(5)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(6)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(7)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(8)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(9)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(10)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(11)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(12)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(13)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(14)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(15)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(16)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(17)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(18)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(19)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(20)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(21)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(22)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(23)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(24)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(25)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(26)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(27)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(28)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(29)
-        GOPAINTEDVALUETYPE_CASE_SINGLETON(30)
-        }
-    }
-    panicf("too many registered types; please contact the Go QML developers");
-    return 0;
-}
-
-#define GOVALUETYPE_CASE(N) \
-    case N: GoValueType<N>::init(info, spec); return qmlRegisterType< GoValueType<N> >(location, major, minor, name);
-#define GOPAINTEDVALUETYPE_CASE(N) \
-    case N: GoPaintedValueType<N>::init(info, spec); return qmlRegisterType< GoPaintedValueType<N> >(location, major, minor, name);
-
-int registerType(char *location, int major, int minor, char *name, GoTypeInfo *info, GoTypeSpec_ *spec)
-{
-    if (!info->paint) {
-        switch (++goValueTypeN) {
-        GOVALUETYPE_CASE(1)
-        GOVALUETYPE_CASE(2)
-        GOVALUETYPE_CASE(3)
-        GOVALUETYPE_CASE(4)
-        GOVALUETYPE_CASE(5)
-        GOVALUETYPE_CASE(6)
-        GOVALUETYPE_CASE(7)
-        GOVALUETYPE_CASE(8)
-        GOVALUETYPE_CASE(9)
-        GOVALUETYPE_CASE(10)
-        GOVALUETYPE_CASE(11)
-        GOVALUETYPE_CASE(12)
-        GOVALUETYPE_CASE(13)
-        GOVALUETYPE_CASE(14)
-        GOVALUETYPE_CASE(15)
-        GOVALUETYPE_CASE(16)
-        GOVALUETYPE_CASE(17)
-        GOVALUETYPE_CASE(18)
-        GOVALUETYPE_CASE(19)
-        GOVALUETYPE_CASE(20)
-        GOVALUETYPE_CASE(21)
-        GOVALUETYPE_CASE(22)
-        GOVALUETYPE_CASE(23)
-        GOVALUETYPE_CASE(24)
-        GOVALUETYPE_CASE(25)
-        GOVALUETYPE_CASE(26)
-        GOVALUETYPE_CASE(27)
-        GOVALUETYPE_CASE(28)
-        GOVALUETYPE_CASE(29)
-        GOVALUETYPE_CASE(30)
-        }
-    } else {
-        switch (++goPaintedValueTypeN) {
-        GOPAINTEDVALUETYPE_CASE(1)
-        GOPAINTEDVALUETYPE_CASE(2)
-        GOPAINTEDVALUETYPE_CASE(3)
-        GOPAINTEDVALUETYPE_CASE(4)
-        GOPAINTEDVALUETYPE_CASE(5)
-        GOPAINTEDVALUETYPE_CASE(6)
-        GOPAINTEDVALUETYPE_CASE(7)
-        GOPAINTEDVALUETYPE_CASE(8)
-        GOPAINTEDVALUETYPE_CASE(9)
-        GOPAINTEDVALUETYPE_CASE(10)
-        GOPAINTEDVALUETYPE_CASE(11)
-        GOPAINTEDVALUETYPE_CASE(12)
-        GOPAINTEDVALUETYPE_CASE(13)
-        GOPAINTEDVALUETYPE_CASE(14)
-        GOPAINTEDVALUETYPE_CASE(15)
-        GOPAINTEDVALUETYPE_CASE(16)
-        GOPAINTEDVALUETYPE_CASE(17)
-        GOPAINTEDVALUETYPE_CASE(18)
-        GOPAINTEDVALUETYPE_CASE(19)
-        GOPAINTEDVALUETYPE_CASE(20)
-        GOPAINTEDVALUETYPE_CASE(21)
-        GOPAINTEDVALUETYPE_CASE(22)
-        GOPAINTEDVALUETYPE_CASE(23)
-        GOPAINTEDVALUETYPE_CASE(24)
-        GOPAINTEDVALUETYPE_CASE(25)
-        GOPAINTEDVALUETYPE_CASE(26)
-        GOPAINTEDVALUETYPE_CASE(27)
-        GOPAINTEDVALUETYPE_CASE(28)
-        GOPAINTEDVALUETYPE_CASE(29)
-        GOPAINTEDVALUETYPE_CASE(30)
-        }
-    }
-    panicf("too many registered types; please contact the Go QML developers");
-    return 0;
-}
-
-// vim:sw=4:st=4:et:ft=cpp

=== removed file 'qml.v0/cpp/govaluetype.h'
--- qml.v0/cpp/govaluetype.h	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/govaluetype.h	1970-01-01 00:00:00 +0000
@@ -1,48 +0,0 @@
-#ifndef GOVALUETYPE_H
-#define GOVALUETYPE_H
-
-#include "govalue.h"
-
-template <int N>
-class GoValueType : public GoValue
-{
-public:
-
-    GoValueType()
-        : GoValue(hookGoValueTypeNew(this, typeSpec), typeInfo, 0) {};
-
-    static void init(GoTypeInfo *info, GoTypeSpec_ *spec)
-    {
-        typeInfo = info;
-        typeSpec = spec;
-        static_cast<QMetaObject &>(staticMetaObject) = *metaObjectFor(typeInfo);
-    };
-
-    static GoTypeSpec_ *typeSpec;
-    static GoTypeInfo *typeInfo;
-    static QMetaObject staticMetaObject;
-};
-
-template <int N>
-class GoPaintedValueType : public GoPaintedValue
-{
-public:
-
-    GoPaintedValueType()
-        : GoPaintedValue(hookGoValueTypeNew(this, typeSpec), typeInfo, 0) {};
-
-    static void init(GoTypeInfo *info, GoTypeSpec_ *spec)
-    {
-        typeInfo = info;
-        typeSpec = spec;
-        static_cast<QMetaObject &>(staticMetaObject) = *metaObjectFor(typeInfo);
-    };
-
-    static GoTypeSpec_ *typeSpec;
-    static GoTypeInfo *typeInfo;
-    static QMetaObject staticMetaObject;
-};
-
-#endif // GOVALUETYPE_H
-
-// vim:ts=4:sw=4:et

=== removed file 'qml.v0/cpp/idletimer.cpp'
--- qml.v0/cpp/idletimer.cpp	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/idletimer.cpp	1970-01-01 00:00:00 +0000
@@ -1,58 +0,0 @@
-#include <QBasicTimer>
-#include <QThread>
-#include <QDebug>
-#include <mutex>
-
-#include "capi.h"
-
-class IdleTimer : public QObject
-{
-    Q_OBJECT
-
-    public:
-
-    static IdleTimer *singleton() {
-        static IdleTimer singleton;
-        return &singleton;
-    }
-
-    void init(int *hookWaiting)
-    {
-        this->hookWaiting = hookWaiting;
-    }
-
-    Q_INVOKABLE void start()
-    {
-        timer.start(0, this);
-    }
-
-    protected:
-
-    void timerEvent(QTimerEvent *event)
-    {
-        __sync_synchronize();
-        if (*hookWaiting > 0) {
-            hookIdleTimer();
-        } else {
-            timer.stop();
-        }
-    }
-
-    private:
-
-    int *hookWaiting;
-
-    QBasicTimer timer;    
-};
-
-void idleTimerInit(int *hookWaiting)
-{
-    IdleTimer::singleton()->init(hookWaiting);
-}
-
-void idleTimerStart()
-{
-    QMetaObject::invokeMethod(IdleTimer::singleton(), "start", Qt::QueuedConnection);
-}
-
-// vim:ts=4:sw=4:et:ft=cpp

=== removed file 'qml.v0/cpp/moc_all.cpp'
--- qml.v0/cpp/moc_all.cpp	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/moc_all.cpp	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-// This file is automatically generated by cpp/update-moc.sh
-#include "cpp/moc_connector.cpp"
-#include "cpp/moc_govalue.cpp"
-#include "cpp/moc_idletimer.cpp"

=== removed file 'qml.v0/cpp/moc_connector.cpp'
--- qml.v0/cpp/moc_connector.cpp	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/moc_connector.cpp	1970-01-01 00:00:00 +0000
@@ -1,211 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'connector.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.2.1)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include "connector.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'connector.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.2.1. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-struct qt_meta_stringdata_Connector_t {
-    QByteArrayData data[3];
-    char stringdata[19];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    offsetof(qt_meta_stringdata_Connector_t, stringdata) + ofs \
-        - idx * sizeof(QByteArrayData) \
-    )
-static const qt_meta_stringdata_Connector_t qt_meta_stringdata_Connector = {
-    {
-QT_MOC_LITERAL(0, 0, 9),
-QT_MOC_LITERAL(1, 10, 6),
-QT_MOC_LITERAL(2, 17, 0)
-    },
-    "Connector\0invoke\0\0"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_Connector[] = {
-
- // content:
-       7,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       1,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
- // slots: name, argc, parameters, tag, flags
-       1,    0,   19,    2, 0x0a,
-
- // slots: parameters
-    QMetaType::Void,
-
-       0        // eod
-};
-
-void Connector::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        Connector *_t = static_cast<Connector *>(_o);
-        switch (_id) {
-        case 0: _t->invoke(); break;
-        default: ;
-        }
-    }
-    Q_UNUSED(_a);
-}
-
-const QMetaObject Connector::staticMetaObject = {
-    { &QObject::staticMetaObject, qt_meta_stringdata_Connector.data,
-      qt_meta_data_Connector,  qt_static_metacall, 0, 0}
-};
-
-
-const QMetaObject *Connector::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *Connector::qt_metacast(const char *_clname)
-{
-    if (!_clname) return 0;
-    if (!strcmp(_clname, qt_meta_stringdata_Connector.stringdata))
-        return static_cast<void*>(const_cast< Connector*>(this));
-    return QObject::qt_metacast(_clname);
-}
-
-int Connector::standard_qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QObject::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 1)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 1;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 1)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 1;
-    }
-    return _id;
-}
-struct qt_meta_stringdata_PlainObject_t {
-    QByteArrayData data[3];
-    char stringdata[33];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    offsetof(qt_meta_stringdata_PlainObject_t, stringdata) + ofs \
-        - idx * sizeof(QByteArrayData) \
-    )
-static const qt_meta_stringdata_PlainObject_t qt_meta_stringdata_PlainObject = {
-    {
-QT_MOC_LITERAL(0, 0, 11),
-QT_MOC_LITERAL(1, 12, 9),
-QT_MOC_LITERAL(2, 22, 9)
-    },
-    "PlainObject\0plainType\0plainAddr\0"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_PlainObject[] = {
-
- // content:
-       7,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       0,    0, // methods
-       2,   14, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
- // properties: name, type, flags
-       1, QMetaType::QString, 0x00095001,
-       2, QMetaType::VoidStar, 0x00095001,
-
-       0        // eod
-};
-
-void PlainObject::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    Q_UNUSED(_o);
-    Q_UNUSED(_id);
-    Q_UNUSED(_c);
-    Q_UNUSED(_a);
-}
-
-const QMetaObject PlainObject::staticMetaObject = {
-    { &QObject::staticMetaObject, qt_meta_stringdata_PlainObject.data,
-      qt_meta_data_PlainObject,  qt_static_metacall, 0, 0}
-};
-
-
-const QMetaObject *PlainObject::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *PlainObject::qt_metacast(const char *_clname)
-{
-    if (!_clname) return 0;
-    if (!strcmp(_clname, qt_meta_stringdata_PlainObject.stringdata))
-        return static_cast<void*>(const_cast< PlainObject*>(this));
-    return QObject::qt_metacast(_clname);
-}
-
-int PlainObject::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QObject::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    
-#ifndef QT_NO_PROPERTIES
-     if (_c == QMetaObject::ReadProperty) {
-        void *_v = _a[0];
-        switch (_id) {
-        case 0: *reinterpret_cast< QString*>(_v) = getPlainType(); break;
-        case 1: *reinterpret_cast< void**>(_v) = getPlainAddr(); break;
-        }
-        _id -= 2;
-    } else if (_c == QMetaObject::WriteProperty) {
-        _id -= 2;
-    } else if (_c == QMetaObject::ResetProperty) {
-        _id -= 2;
-    } else if (_c == QMetaObject::QueryPropertyDesignable) {
-        _id -= 2;
-    } else if (_c == QMetaObject::QueryPropertyScriptable) {
-        _id -= 2;
-    } else if (_c == QMetaObject::QueryPropertyStored) {
-        _id -= 2;
-    } else if (_c == QMetaObject::QueryPropertyEditable) {
-        _id -= 2;
-    } else if (_c == QMetaObject::QueryPropertyUser) {
-        _id -= 2;
-    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
-        if (_id < 2)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 2;
-    }
-#endif // QT_NO_PROPERTIES
-    return _id;
-}
-QT_END_MOC_NAMESPACE

=== removed file 'qml.v0/cpp/moc_govalue.cpp'
--- qml.v0/cpp/moc_govalue.cpp	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/moc_govalue.cpp	1970-01-01 00:00:00 +0000
@@ -1,155 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'govalue.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.2.1)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include "govalue.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'govalue.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.2.1. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-struct qt_meta_stringdata_GoValue_t {
-    QByteArrayData data[1];
-    char stringdata[9];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    offsetof(qt_meta_stringdata_GoValue_t, stringdata) + ofs \
-        - idx * sizeof(QByteArrayData) \
-    )
-static const qt_meta_stringdata_GoValue_t qt_meta_stringdata_GoValue = {
-    {
-QT_MOC_LITERAL(0, 0, 7)
-    },
-    "GoValue\0"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_GoValue[] = {
-
- // content:
-       7,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       0,    0, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
-       0        // eod
-};
-
-void GoValue::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    Q_UNUSED(_o);
-    Q_UNUSED(_id);
-    Q_UNUSED(_c);
-    Q_UNUSED(_a);
-}
-
-const QMetaObject GoValue::staticMetaObject = {
-    { &QObject::staticMetaObject, qt_meta_stringdata_GoValue.data,
-      qt_meta_data_GoValue,  qt_static_metacall, 0, 0}
-};
-
-
-const QMetaObject *GoValue::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *GoValue::qt_metacast(const char *_clname)
-{
-    if (!_clname) return 0;
-    if (!strcmp(_clname, qt_meta_stringdata_GoValue.stringdata))
-        return static_cast<void*>(const_cast< GoValue*>(this));
-    return QObject::qt_metacast(_clname);
-}
-
-int GoValue::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QObject::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    return _id;
-}
-struct qt_meta_stringdata_GoPaintedValue_t {
-    QByteArrayData data[1];
-    char stringdata[16];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    offsetof(qt_meta_stringdata_GoPaintedValue_t, stringdata) + ofs \
-        - idx * sizeof(QByteArrayData) \
-    )
-static const qt_meta_stringdata_GoPaintedValue_t qt_meta_stringdata_GoPaintedValue = {
-    {
-QT_MOC_LITERAL(0, 0, 14)
-    },
-    "GoPaintedValue\0"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_GoPaintedValue[] = {
-
- // content:
-       7,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       0,    0, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
-       0        // eod
-};
-
-void GoPaintedValue::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    Q_UNUSED(_o);
-    Q_UNUSED(_id);
-    Q_UNUSED(_c);
-    Q_UNUSED(_a);
-}
-
-const QMetaObject GoPaintedValue::staticMetaObject = {
-    { &QQuickPaintedItem::staticMetaObject, qt_meta_stringdata_GoPaintedValue.data,
-      qt_meta_data_GoPaintedValue,  qt_static_metacall, 0, 0}
-};
-
-
-const QMetaObject *GoPaintedValue::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *GoPaintedValue::qt_metacast(const char *_clname)
-{
-    if (!_clname) return 0;
-    if (!strcmp(_clname, qt_meta_stringdata_GoPaintedValue.stringdata))
-        return static_cast<void*>(const_cast< GoPaintedValue*>(this));
-    return QQuickPaintedItem::qt_metacast(_clname);
-}
-
-int GoPaintedValue::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QQuickPaintedItem::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    return _id;
-}
-QT_END_MOC_NAMESPACE

=== removed file 'qml.v0/cpp/moc_idletimer.cpp'
--- qml.v0/cpp/moc_idletimer.cpp	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/moc_idletimer.cpp	1970-01-01 00:00:00 +0000
@@ -1,108 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'idletimer.cpp'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.2.1)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'idletimer.cpp' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.2.1. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-struct qt_meta_stringdata_IdleTimer_t {
-    QByteArrayData data[3];
-    char stringdata[18];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    offsetof(qt_meta_stringdata_IdleTimer_t, stringdata) + ofs \
-        - idx * sizeof(QByteArrayData) \
-    )
-static const qt_meta_stringdata_IdleTimer_t qt_meta_stringdata_IdleTimer = {
-    {
-QT_MOC_LITERAL(0, 0, 9),
-QT_MOC_LITERAL(1, 10, 5),
-QT_MOC_LITERAL(2, 16, 0)
-    },
-    "IdleTimer\0start\0\0"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_IdleTimer[] = {
-
- // content:
-       7,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       1,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
- // methods: name, argc, parameters, tag, flags
-       1,    0,   19,    2, 0x02,
-
- // methods: parameters
-    QMetaType::Void,
-
-       0        // eod
-};
-
-void IdleTimer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        IdleTimer *_t = static_cast<IdleTimer *>(_o);
-        switch (_id) {
-        case 0: _t->start(); break;
-        default: ;
-        }
-    }
-    Q_UNUSED(_a);
-}
-
-const QMetaObject IdleTimer::staticMetaObject = {
-    { &QObject::staticMetaObject, qt_meta_stringdata_IdleTimer.data,
-      qt_meta_data_IdleTimer,  qt_static_metacall, 0, 0}
-};
-
-
-const QMetaObject *IdleTimer::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *IdleTimer::qt_metacast(const char *_clname)
-{
-    if (!_clname) return 0;
-    if (!strcmp(_clname, qt_meta_stringdata_IdleTimer.stringdata))
-        return static_cast<void*>(const_cast< IdleTimer*>(this));
-    return QObject::qt_metacast(_clname);
-}
-
-int IdleTimer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QObject::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 1)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 1;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 1)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 1;
-    }
-    return _id;
-}
-QT_END_MOC_NAMESPACE

=== removed directory 'qml.v0/cpp/private'
=== removed file 'qml.v0/cpp/private/qmetaobject_p.h'
--- qml.v0/cpp/private/qmetaobject_p.h	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/private/qmetaobject_p.h	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-#include "private/qtheader.h"
-#include QT_PRIVATE_HEADER(QtCore,qmetaobject_p.h)

=== removed file 'qml.v0/cpp/private/qmetaobjectbuilder_p.h'
--- qml.v0/cpp/private/qmetaobjectbuilder_p.h	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/private/qmetaobjectbuilder_p.h	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-#include "private/qtheader.h"
-#include QT_PRIVATE_HEADER(QtCore,qmetaobjectbuilder_p.h)

=== removed file 'qml.v0/cpp/private/qobject_p.h'
--- qml.v0/cpp/private/qobject_p.h	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/private/qobject_p.h	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-#include "private/qtheader.h"
-#include QT_PRIVATE_HEADER(QtCore,qobject_p.h)

=== removed file 'qml.v0/cpp/private/qtheader.h'
--- qml.v0/cpp/private/qtheader.h	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/private/qtheader.h	1970-01-01 00:00:00 +0000
@@ -1,70 +0,0 @@
-#ifndef QTPRIVATE_H
-#define QTPRIVATE_H
-
-#include <QtCore/qglobal.h>
-
-#define QT_MAJOR_ (QT_VERSION>>16)
-#define QT_MINOR_ (QT_VERSION>>8&0xFF)
-#define QT_MICRO_ (QT_VERSION&0xFF)
-
-#if QT_MAJOR_ == 5
-#define QT_MAJOR 5
-#else 
-#error Unupported Qt major version. Please report.
-#endif
-
-#if QT_MINOR_ == 0
-#define QT_MINOR 0
-#elif QT_MINOR_ == 1
-#define QT_MINOR 1
-#elif QT_MINOR_ == 2
-#define QT_MINOR 2
-#elif QT_MINOR_ == 3
-#define QT_MINOR 3
-#elif QT_MINOR_ == 4
-#define QT_MINOR 4
-#elif QT_MINOR_ == 5
-#define QT_MINOR 5
-#elif QT_MINOR_ == 6
-#define QT_MINOR 6
-#elif QT_MINOR_ == 7
-#define QT_MINOR 7
-#elif QT_MINOR_ == 8
-#define QT_MINOR 8
-#elif QT_MINOR_ == 9
-#define QT_MINOR 9
-#elif QT_MINOR_ == 10
-#define QT_MINOR 10
-#else 
-#error Unupported Qt minor version. Please report.
-#endif
-
-#if QT_MICRO_ == 0
-#define QT_MICRO 0
-#elif QT_MICRO_ == 1
-#define QT_MICRO 1
-#elif QT_MICRO_ == 2
-#define QT_MICRO 2
-#elif QT_MICRO_ == 3
-#define QT_MICRO 3
-#elif QT_MICRO_ == 4
-#define QT_MICRO 4
-#elif QT_MICRO_ == 5
-#define QT_MICRO 5
-#elif QT_MICRO_ == 6
-#define QT_MICRO 6
-#elif QT_MICRO_ == 7
-#define QT_MICRO 7
-#elif QT_MICRO_ == 8
-#define QT_MICRO 8
-#elif QT_MICRO_ == 9
-#define QT_MICRO 9
-#elif QT_MICRO_ == 10
-#define QT_MICRO 10
-#else 
-#error Unupported Qt micro version. Please report.
-#endif
-
-#define QT_PRIVATE_HEADER(dir,file) <dir/QT_MAJOR.QT_MINOR.QT_MICRO/dir/private/file>
-
-#endif // QTPRIVATE_H

=== removed file 'qml.v0/cpp/update-moc.sh'
--- qml.v0/cpp/update-moc.sh	2014-08-26 19:38:51 +0000
+++ qml.v0/cpp/update-moc.sh	1970-01-01 00:00:00 +0000
@@ -1,19 +0,0 @@
-#!/bin/sh
-
-set -e
-cd `dirname $0`
-
-subdir=`basename $PWD`
-
-export QT_SELECT=5
-
-ALL=moc_all.cpp
-
-echo "// This file is automatically generated by cpp/update-moc.sh" > $ALL
-
-for file in `grep -l Q_''OBJECT *`; do
-	mocfile=`echo $file | awk -F. '{print("moc_"$1".cpp")}'`
-	mochack=`sed -n 's,^ *// MOC HACK: \(.*\),\1,p' $file`
-	moc $file | sed "$mochack" > $mocfile
-	echo "#include \"$subdir/$mocfile\"" >> $ALL
-done

=== removed directory 'qml.v0/cpptest'
=== removed file 'qml.v0/cpptest/cpptest.cpp'
--- qml.v0/cpptest/cpptest.cpp	2014-08-26 19:38:51 +0000
+++ qml.v0/cpptest/cpptest.cpp	1970-01-01 00:00:00 +0000
@@ -1,14 +0,0 @@
-#include <string.h>
-
-#include "cpptest.h"
-#include "testtype.h"
-
-TestType_ *newTestType()
-{
-	return new TestType();
-}
-
-int plainTestTypeN(PlainTestType_ *plain)
-{
-	return static_cast<PlainTestType *>(plain)->n;
-}

=== removed file 'qml.v0/cpptest/cpptest.go'
--- qml.v0/cpptest/cpptest.go	2014-08-26 19:38:51 +0000
+++ qml.v0/cpptest/cpptest.go	1970-01-01 00:00:00 +0000
@@ -1,30 +0,0 @@
-// Package cpptest is an internal test helper.
-package cpptest
-
-// #cgo CXXFLAGS: -std=c++0x -Wall -fno-strict-aliasing -I..
-// #cgo LDFLAGS: -lstdc++
-//
-// #cgo pkg-config: Qt5Core
-//
-// #include "cpptest.h"
-//
-import "C"
-
-import (
-	"unsafe"
-
-	"launchpad.net/ciborium/qml.v0"
-)
-
-func NewTestType(engine *qml.Engine) qml.Object {
-	var obj qml.Object
-	qml.RunMain(func() {
-		addr := C.newTestType()
-		obj = qml.CommonOf(addr, engine)
-	})
-	return obj
-}
-
-func PlainTestTypeN(obj qml.Object) int {
-	return int(C.plainTestTypeN(unsafe.Pointer(obj.Property("plainAddr").(uintptr))))
-}

=== removed file 'qml.v0/cpptest/cpptest.h'
--- qml.v0/cpptest/cpptest.h	2014-08-26 19:38:51 +0000
+++ qml.v0/cpptest/cpptest.h	1970-01-01 00:00:00 +0000
@@ -1,23 +0,0 @@
-#ifndef UONEAUTH_H
-#define UONEAUTH_H
-
-#include <stdint.h>
-#include <stddef.h>
-#include <stdlib.h>
-
-typedef void TestType_;
-typedef void PlainTestType_;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-TestType_ *newTestType();
-
-int plainTestTypeN(PlainTestType_ *plain);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // UONEAUTH_H

=== removed file 'qml.v0/cpptest/moc_testtype.cpp'
--- qml.v0/cpptest/moc_testtype.cpp	2014-08-26 19:38:51 +0000
+++ qml.v0/cpptest/moc_testtype.cpp	1970-01-01 00:00:00 +0000
@@ -1,202 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'testtype.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.2.1)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include "testtype.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'testtype.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.2.1. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-struct qt_meta_stringdata_TestType_t {
-    QByteArrayData data[10];
-    char stringdata[119];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    offsetof(qt_meta_stringdata_TestType_t, stringdata) + ofs \
-        - idx * sizeof(QByteArrayData) \
-    )
-static const qt_meta_stringdata_TestType_t qt_meta_stringdata_TestType = {
-    {
-QT_MOC_LITERAL(0, 0, 8),
-QT_MOC_LITERAL(1, 9, 15),
-QT_MOC_LITERAL(2, 25, 0),
-QT_MOC_LITERAL(3, 26, 13),
-QT_MOC_LITERAL(4, 40, 5),
-QT_MOC_LITERAL(5, 46, 15),
-QT_MOC_LITERAL(6, 62, 15),
-QT_MOC_LITERAL(7, 78, 20),
-QT_MOC_LITERAL(8, 99, 9),
-QT_MOC_LITERAL(9, 109, 8)
-    },
-    "TestType\0plainEmittedCpy\0\0PlainTestType\0"
-    "plain\0plainEmittedRef\0plainEmittedPtr\0"
-    "const PlainTestType*\0emitPlain\0voidAddr\0"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_TestType[] = {
-
- // content:
-       7,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       4,   14, // methods
-       1,   44, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       3,       // signalCount
-
- // signals: name, argc, parameters, tag, flags
-       1,    1,   34,    2, 0x06,
-       5,    1,   37,    2, 0x06,
-       6,    1,   40,    2, 0x06,
-
- // methods: name, argc, parameters, tag, flags
-       8,    0,   43,    2, 0x02,
-
- // signals: parameters
-    QMetaType::Void, 0x80000000 | 3,    4,
-    QMetaType::Void, 0x80000000 | 3,    4,
-    QMetaType::Void, 0x80000000 | 7,    4,
-
- // methods: parameters
-    QMetaType::Void,
-
- // properties: name, type, flags
-       9, QMetaType::VoidStar, 0x00095001,
-
-       0        // eod
-};
-
-void TestType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        TestType *_t = static_cast<TestType *>(_o);
-        switch (_id) {
-        case 0: _t->plainEmittedCpy((*reinterpret_cast< const PlainTestType(*)>(_a[1]))); break;
-        case 1: _t->plainEmittedRef((*reinterpret_cast< const PlainTestType(*)>(_a[1]))); break;
-        case 2: _t->plainEmittedPtr((*reinterpret_cast< const PlainTestType*(*)>(_a[1]))); break;
-        case 3: _t->emitPlain(); break;
-        default: ;
-        }
-    } else if (_c == QMetaObject::IndexOfMethod) {
-        int *result = reinterpret_cast<int *>(_a[0]);
-        void **func = reinterpret_cast<void **>(_a[1]);
-        {
-            typedef void (TestType::*_t)(const PlainTestType );
-            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestType::plainEmittedCpy)) {
-                *result = 0;
-            }
-        }
-        {
-            typedef void (TestType::*_t)(const PlainTestType & );
-            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestType::plainEmittedRef)) {
-                *result = 1;
-            }
-        }
-        {
-            typedef void (TestType::*_t)(const PlainTestType * );
-            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestType::plainEmittedPtr)) {
-                *result = 2;
-            }
-        }
-    }
-}
-
-const QMetaObject TestType::staticMetaObject = {
-    { &QObject::staticMetaObject, qt_meta_stringdata_TestType.data,
-      qt_meta_data_TestType,  qt_static_metacall, 0, 0}
-};
-
-
-const QMetaObject *TestType::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *TestType::qt_metacast(const char *_clname)
-{
-    if (!_clname) return 0;
-    if (!strcmp(_clname, qt_meta_stringdata_TestType.stringdata))
-        return static_cast<void*>(const_cast< TestType*>(this));
-    return QObject::qt_metacast(_clname);
-}
-
-int TestType::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QObject::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 4)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 4;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 4)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 4;
-    }
-#ifndef QT_NO_PROPERTIES
-      else if (_c == QMetaObject::ReadProperty) {
-        void *_v = _a[0];
-        switch (_id) {
-        case 0: *reinterpret_cast< void**>(_v) = getVoidAddr(); break;
-        }
-        _id -= 1;
-    } else if (_c == QMetaObject::WriteProperty) {
-        _id -= 1;
-    } else if (_c == QMetaObject::ResetProperty) {
-        _id -= 1;
-    } else if (_c == QMetaObject::QueryPropertyDesignable) {
-        _id -= 1;
-    } else if (_c == QMetaObject::QueryPropertyScriptable) {
-        _id -= 1;
-    } else if (_c == QMetaObject::QueryPropertyStored) {
-        _id -= 1;
-    } else if (_c == QMetaObject::QueryPropertyEditable) {
-        _id -= 1;
-    } else if (_c == QMetaObject::QueryPropertyUser) {
-        _id -= 1;
-    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
-        if (_id < 1)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 1;
-    }
-#endif // QT_NO_PROPERTIES
-    return _id;
-}
-
-// SIGNAL 0
-void TestType::plainEmittedCpy(const PlainTestType _t1)
-{
-    void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
-    QMetaObject::activate(this, &staticMetaObject, 0, _a);
-}
-
-// SIGNAL 1
-void TestType::plainEmittedRef(const PlainTestType & _t1)
-{
-    void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
-    QMetaObject::activate(this, &staticMetaObject, 1, _a);
-}
-
-// SIGNAL 2
-void TestType::plainEmittedPtr(const PlainTestType * _t1)
-{
-    void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
-    QMetaObject::activate(this, &staticMetaObject, 2, _a);
-}
-QT_END_MOC_NAMESPACE

=== removed file 'qml.v0/cpptest/testtype.h'
--- qml.v0/cpptest/testtype.h	2014-08-26 19:38:51 +0000
+++ qml.v0/cpptest/testtype.h	1970-01-01 00:00:00 +0000
@@ -1,45 +0,0 @@
-#ifndef TESTTYPE_H
-#define TESTTYPE_H
-
-#include <QObject>
-
-class PlainTestType {
-
-    public:
-
-    PlainTestType(int n) : n(n) {};
-
-    int n;
-};
-
-class TestType : public QObject
-{
-    Q_OBJECT
-
-    Q_PROPERTY(void *voidAddr READ getVoidAddr)
-
-    void *voidAddr;
-
-    public:
-
-    TestType(QObject *parent = 0) : QObject(parent), voidAddr((void*)42) {};
-
-    void *getVoidAddr() { return voidAddr; };
-
-    Q_INVOKABLE void emitPlain() {
-            PlainTestType plain = PlainTestType(42);
-            emit plainEmittedCpy(plain);
-            emit plainEmittedRef(plain);
-            emit plainEmittedPtr(&plain);
-    };
-
-    signals:
-
-    void plainEmittedCpy(const PlainTestType plain);
-    void plainEmittedRef(const PlainTestType &plain);
-    void plainEmittedPtr(const PlainTestType *plain);
-};
-
-#endif // TESTTYPE_H
-
-// vim:ts=4:sw=4:et

=== removed file 'qml.v0/cpptest/update-moc.sh'
--- qml.v0/cpptest/update-moc.sh	2014-08-26 19:38:51 +0000
+++ qml.v0/cpptest/update-moc.sh	1970-01-01 00:00:00 +0000
@@ -1,12 +0,0 @@
-#!/bin/sh
-
-set -e
-cd `dirname $0`
-
-export QT_SELECT=5
-
-for file in `grep -l Q_''OBJECT *`; do
-	mocfile=`echo $file | awk -F. '{print("moc_"$1".cpp")}'`
-	mochack=`sed -n 's,^ *// MOC HACK: \(.*\),\1,p' $file`
-	moc $file | sed "$mochack" > $mocfile
-done

=== removed file 'qml.v0/datatype.go'
--- qml.v0/datatype.go	2014-08-26 19:38:51 +0000
+++ qml.v0/datatype.go	1970-01-01 00:00:00 +0000
@@ -1,527 +0,0 @@
-package qml
-
-// #include <stdlib.h>
-// #include "capi.h"
-import "C"
-
-import (
-	"bytes"
-	"fmt"
-	"image/color"
-	"reflect"
-	"strings"
-	"unicode"
-	"unsafe"
-)
-
-var (
-	intIs64 bool
-	intDT   C.DataType
-
-	ptrSize = C.size_t(unsafe.Sizeof(uintptr(0)))
-
-	nilPtr     = unsafe.Pointer(uintptr(0))
-	nilCharPtr = (*C.char)(nilPtr)
-
-	typeString     = reflect.TypeOf("")
-	typeBool       = reflect.TypeOf(false)
-	typeInt        = reflect.TypeOf(int(0))
-	typeInt64      = reflect.TypeOf(int64(0))
-	typeInt32      = reflect.TypeOf(int32(0))
-	typeFloat64    = reflect.TypeOf(float64(0))
-	typeFloat32    = reflect.TypeOf(float32(0))
-	typeIface      = reflect.TypeOf(new(interface{})).Elem()
-	typeRGBA       = reflect.TypeOf(color.RGBA{})
-	typeObjSlice   = reflect.TypeOf([]Object(nil))
-	typeObject     = reflect.TypeOf([]Object(nil)).Elem()
-	typePainter    = reflect.TypeOf(&Painter{})
-	typeList       = reflect.TypeOf(&List{})
-	typeMap        = reflect.TypeOf(&Map{})
-	typeGenericMap = reflect.TypeOf(map[string]interface{}(nil))
-)
-
-func init() {
-	var i int = 1<<31 - 1
-	intIs64 = (i+1 > 0)
-	if intIs64 {
-		intDT = C.DTInt64
-	} else {
-		intDT = C.DTInt32
-	}
-}
-
-// packDataValue packs the provided Go value into a C.DataValue for
-// shiping into C++ land.
-//
-// For simple types (bool, int, etc) value is converted into a
-// native C++ value. For anything else, including cases when value
-// has a type that has an underlying simple type, the Go value itself
-// is encapsulated into a C++ wrapper so that field access and method
-// calls work.
-//
-// This must be run from the main GUI thread due to the cases where
-// calling wrapGoValue is necessary.
-func packDataValue(value interface{}, dvalue *C.DataValue, engine *Engine, owner valueOwner) {
-	datap := unsafe.Pointer(&dvalue.data)
-	if value == nil {
-		dvalue.dataType = C.DTInvalid
-		return
-	}
-	switch value := value.(type) {
-	case string:
-		dvalue.dataType = C.DTString
-		cstr, cstrlen := unsafeStringData(value)
-		*(**C.char)(datap) = cstr
-		dvalue.len = cstrlen
-	case bool:
-		dvalue.dataType = C.DTBool
-		*(*bool)(datap) = value
-	case int:
-		if value > 1<<31-1 {
-			dvalue.dataType = C.DTInt64
-			*(*int64)(datap) = int64(value)
-		} else {
-			dvalue.dataType = C.DTInt32
-			*(*int32)(datap) = int32(value)
-		}
-	case int64:
-		dvalue.dataType = C.DTInt64
-		*(*int64)(datap) = value
-	case int32:
-		dvalue.dataType = C.DTInt32
-		*(*int32)(datap) = value
-	case uint64:
-		dvalue.dataType = C.DTUint64
-		*(*uint64)(datap) = value
-	case uint32:
-		dvalue.dataType = C.DTUint32
-		*(*uint32)(datap) = value
-	case float64:
-		dvalue.dataType = C.DTFloat64
-		*(*float64)(datap) = value
-	case float32:
-		dvalue.dataType = C.DTFloat32
-		*(*float32)(datap) = value
-	case *Common:
-		dvalue.dataType = C.DTObject
-		*(*unsafe.Pointer)(datap) = value.addr
-	case color.RGBA:
-		dvalue.dataType = C.DTColor
-		*(*uint32)(datap) = uint32(value.A)<<24 | uint32(value.R)<<16 | uint32(value.G)<<8 | uint32(value.B)
-	default:
-		dvalue.dataType = C.DTObject
-		if obj, ok := value.(Object); ok {
-			*(*unsafe.Pointer)(datap) = obj.Common().addr
-		} else {
-			*(*unsafe.Pointer)(datap) = wrapGoValue(engine, value, owner)
-		}
-	}
-}
-
-// TODO Handle byte slices.
-
-// unpackDataValue converts a value shipped by C++ into a native Go value.
-//
-// HEADS UP: This is considered safe to be run out of the main GUI thread.
-//           If that changes, fix the call sites.
-func unpackDataValue(dvalue *C.DataValue, engine *Engine) interface{} {
-	datap := unsafe.Pointer(&dvalue.data)
-	switch dvalue.dataType {
-	case C.DTString:
-		s := C.GoStringN(*(**C.char)(datap), dvalue.len)
-		// TODO If we move all unpackDataValue calls to the GUI thread,
-		// can we get rid of this allocation somehow?
-		C.free(unsafe.Pointer(*(**C.char)(datap)))
-		return s
-	case C.DTBool:
-		return *(*bool)(datap)
-	case C.DTInt64:
-		return *(*int64)(datap)
-	case C.DTInt32:
-		return int(*(*int32)(datap))
-	case C.DTUint64:
-		return *(*uint64)(datap)
-	case C.DTUint32:
-		return *(*uint32)(datap)
-	case C.DTUintptr:
-		return *(*uintptr)(datap)
-	case C.DTFloat64:
-		return *(*float64)(datap)
-	case C.DTFloat32:
-		return *(*float32)(datap)
-	case C.DTColor:
-		var c uint32 = *(*uint32)(datap)
-		return color.RGBA{byte(c >> 16), byte(c >> 8), byte(c), byte(c >> 24)}
-	case C.DTGoAddr:
-		return (*(**valueFold)(datap)).gvalue
-	case C.DTInvalid:
-		return nil
-	case C.DTObject:
-		// TODO Would be good to preserve identity on the Go side. See ensureEngine as well.
-		obj := &Common{
-			engine: engine,
-			addr:   *(*unsafe.Pointer)(datap),
-		}
-		if len(converters) > 0 {
-			// TODO Embed the type name in DataValue to drop these calls.
-			typeName := obj.TypeName()
-			if typeName == "PlainObject" {
-				typeName = strings.TrimRight(obj.String("plainType"), "&*")
-				if strings.HasPrefix(typeName, "const ") {
-					typeName = typeName[6:]
-				}
-			}
-			if f, ok := converters[typeName]; ok {
-				return f(engine, obj)
-			}
-		}
-		return obj
-	case C.DTValueList, C.DTValueMap:
-		var dvlist []C.DataValue
-		var dvlisth = (*reflect.SliceHeader)(unsafe.Pointer(&dvlist))
-		dvlisth.Data = uintptr(*(*unsafe.Pointer)(datap))
-		dvlisth.Len = int(dvalue.len)
-		dvlisth.Cap = int(dvalue.len)
-		result := make([]interface{}, len(dvlist))
-		for i := range result {
-			result[i] = unpackDataValue(&dvlist[i], engine)
-		}
-		C.free(*(*unsafe.Pointer)(datap))
-		if dvalue.dataType == C.DTValueList {
-			return &List{result}
-		} else {
-			return &Map{result}
-		}
-	}
-	panic(fmt.Sprintf("unsupported data type: %d", dvalue.dataType))
-}
-
-func dataTypeOf(typ reflect.Type) C.DataType {
-	// Compare against the specific types rather than their kind.
-	// Custom types may have methods that must be supported.
-	switch typ {
-	case typeString:
-		return C.DTString
-	case typeBool:
-		return C.DTBool
-	case typeInt:
-		return intDT
-	case typeInt64:
-		return C.DTInt64
-	case typeInt32:
-		return C.DTInt32
-	case typeFloat32:
-		return C.DTFloat32
-	case typeFloat64:
-		return C.DTFloat64
-	case typeIface:
-		return C.DTAny
-	case typeRGBA:
-		return C.DTColor
-	case typeObjSlice:
-		return C.DTListProperty
-	}
-	return C.DTObject
-}
-
-var typeInfoSize = C.size_t(unsafe.Sizeof(C.GoTypeInfo{}))
-var memberInfoSize = C.size_t(unsafe.Sizeof(C.GoMemberInfo{}))
-
-var typeInfoCache = make(map[reflect.Type]*C.GoTypeInfo)
-
-func appendLoweredName(buf []byte, name string) []byte {
-	var last rune
-	var lasti int
-	for i, rune := range name {
-		if !unicode.IsUpper(rune) {
-			if lasti == 0 {
-				last = unicode.ToLower(last)
-			}
-			buf = append(buf, string(last)...)
-			buf = append(buf, name[i:]...)
-			return buf
-		}
-		if i > 0 {
-			buf = append(buf, string(unicode.ToLower(last))...)
-		}
-		lasti, last = i, rune
-	}
-	return append(buf, string(unicode.ToLower(last))...)
-}
-
-func typeInfo(v interface{}) *C.GoTypeInfo {
-	vt := reflect.TypeOf(v)
-	for vt.Kind() == reflect.Ptr {
-		vt = vt.Elem()
-	}
-
-	typeInfo := typeInfoCache[vt]
-	if typeInfo != nil {
-		return typeInfo
-	}
-
-	typeInfo = (*C.GoTypeInfo)(C.malloc(typeInfoSize))
-	typeInfo.typeName = C.CString(vt.Name())
-	typeInfo.metaObject = nilPtr
-	typeInfo.paint = (*C.GoMemberInfo)(nilPtr)
-
-	var setters map[string]int
-	var getters map[string]int
-
-	// TODO Only do that if it's a struct?
-	vtptr := reflect.PtrTo(vt)
-
-	if vt.Kind() != reflect.Struct {
-		panic(fmt.Sprintf("handling of %s (%#v) is incomplete; please report to the developers", vt, v))
-	}
-
-	numField := vt.NumField()
-	numMethod := vtptr.NumMethod()
-	privateFields := 0
-	privateMethods := 0
-
-	// struct { FooBar T; Baz T } => "fooBar\0baz\0"
-	namesLen := 0
-	for i := 0; i < numField; i++ {
-		field := vt.Field(i)
-		if field.PkgPath != "" {
-			privateFields++
-			continue
-		}
-		namesLen += len(field.Name) + 1
-	}
-	for i := 0; i < numMethod; i++ {
-		method := vtptr.Method(i)
-		if method.PkgPath != "" {
-			privateMethods++
-			continue
-		}
-		namesLen += len(method.Name) + 1
-
-		// Track setters and getters.
-		if len(method.Name) > 3 && method.Name[:3] == "Set" {
-			if method.Type.NumIn() == 2 {
-				if setters == nil {
-					setters = make(map[string]int)
-				}
-				setters[method.Name[3:]] = i
-			}
-		} else if method.Type.NumIn() == 1 && method.Type.NumOut() == 1 {
-			if getters == nil {
-				getters = make(map[string]int)
-			}
-			getters[method.Name] = i
-		}
-	}
-	names := make([]byte, 0, namesLen)
-	for i := 0; i < numField; i++ {
-		field := vt.Field(i)
-		if field.PkgPath != "" {
-			continue // not exported
-		}
-		names = appendLoweredName(names, field.Name)
-		names = append(names, 0)
-	}
-	for i := 0; i < numMethod; i++ {
-		method := vtptr.Method(i)
-		if method.PkgPath != "" {
-			continue // not exported
-		}
-		if _, ok := getters[method.Name]; !ok {
-			continue
-		}
-		if _, ok := setters[method.Name]; !ok {
-			delete(getters, method.Name)
-			continue
-		}
-		// This is a getter method
-		names = appendLoweredName(names, method.Name)
-		names = append(names, 0)
-	}
-	for i := 0; i < numMethod; i++ {
-		method := vtptr.Method(i)
-		if method.PkgPath != "" {
-			continue // not exported
-		}
-		if _, ok := getters[method.Name]; ok {
-			continue // getter already handled above
-		}
-		names = appendLoweredName(names, method.Name)
-		names = append(names, 0)
-	}
-	if len(names) != namesLen {
-		panic("pre-allocated buffer size was wrong")
-	}
-	typeInfo.memberNames = C.CString(string(names))
-
-	// Assemble information on members.
-	membersLen := numField - privateFields + numMethod - privateMethods
-	membersi := uintptr(0)
-	mnamesi := uintptr(0)
-	members := uintptr(C.malloc(memberInfoSize * C.size_t(membersLen)))
-	mnames := uintptr(unsafe.Pointer(typeInfo.memberNames))
-	for i := 0; i < numField; i++ {
-		field := vt.Field(i)
-		if field.PkgPath != "" {
-			continue // not exported
-		}
-		memberInfo := (*C.GoMemberInfo)(unsafe.Pointer(members + uintptr(memberInfoSize)*membersi))
-		memberInfo.memberName = (*C.char)(unsafe.Pointer(mnames + mnamesi))
-		memberInfo.memberType = dataTypeOf(field.Type)
-		memberInfo.reflectIndex = C.int(i)
-		memberInfo.reflectGetIndex = -1
-		memberInfo.reflectSetIndex = -1
-		memberInfo.addrOffset = C.int(field.Offset)
-		membersi += 1
-		mnamesi += uintptr(len(field.Name)) + 1
-		if methodIndex, ok := setters[field.Name]; ok {
-			memberInfo.reflectSetIndex = C.int(methodIndex)
-		}
-	}
-	for i := 0; i < numMethod; i++ {
-		method := vtptr.Method(i)
-		if method.PkgPath != "" {
-			continue // not exported
-		}
-		if _, ok := getters[method.Name]; !ok {
-			continue // not a getter
-		}
-		memberInfo := (*C.GoMemberInfo)(unsafe.Pointer(members + uintptr(memberInfoSize)*membersi))
-		memberInfo.memberName = (*C.char)(unsafe.Pointer(mnames + mnamesi))
-		memberInfo.memberType = dataTypeOf(method.Type.Out(0))
-		memberInfo.reflectIndex = -1
-		memberInfo.reflectGetIndex = C.int(getters[method.Name])
-		memberInfo.reflectSetIndex = C.int(setters[method.Name])
-		memberInfo.addrOffset = 0
-		membersi += 1
-		mnamesi += uintptr(len(method.Name)) + 1
-	}
-	for i := 0; i < numMethod; i++ {
-		method := vtptr.Method(i)
-		if method.PkgPath != "" {
-			continue // not exported
-		}
-		if _, ok := getters[method.Name]; ok {
-			continue // getter already handled above
-		}
-		memberInfo := (*C.GoMemberInfo)(unsafe.Pointer(members + uintptr(memberInfoSize)*membersi))
-		memberInfo.memberName = (*C.char)(unsafe.Pointer(mnames + mnamesi))
-		memberInfo.memberType = C.DTMethod
-		memberInfo.reflectIndex = C.int(i)
-		memberInfo.reflectGetIndex = -1
-		memberInfo.reflectSetIndex = -1
-		memberInfo.addrOffset = 0
-		signature, result := methodQtSignature(method)
-		// TODO The signature data might be embedded in the same array as the member names.
-		memberInfo.methodSignature = C.CString(signature)
-		memberInfo.resultSignature = C.CString(result)
-		// TODO Sort out methods with a variable number of arguments.
-		// It's called while bound, so drop the receiver.
-		memberInfo.numIn = C.int(method.Type.NumIn() - 1)
-		memberInfo.numOut = C.int(method.Type.NumOut())
-		membersi += 1
-		mnamesi += uintptr(len(method.Name)) + 1
-
-		if method.Name == "Paint" && memberInfo.numIn == 1 && memberInfo.numOut == 0 && method.Type.In(1) == typePainter {
-			typeInfo.paint = memberInfo
-		}
-	}
-	typeInfo.members = (*C.GoMemberInfo)(unsafe.Pointer(members))
-	typeInfo.membersLen = C.int(membersLen)
-
-	typeInfo.fields = typeInfo.members
-	typeInfo.fieldsLen = C.int(numField - privateFields + len(getters))
-	typeInfo.methods = (*C.GoMemberInfo)(unsafe.Pointer(members + uintptr(memberInfoSize)*uintptr(typeInfo.fieldsLen)))
-	typeInfo.methodsLen = C.int(numMethod - privateMethods - len(getters))
-
-	if int(membersi) != membersLen {
-		panic("used more space than allocated for member names")
-	}
-	if int(mnamesi) != namesLen {
-		panic("allocated buffer doesn't match used space")
-	}
-	if typeInfo.fieldsLen+typeInfo.methodsLen != typeInfo.membersLen {
-		panic("lengths are inconsistent")
-	}
-
-	typeInfoCache[vt] = typeInfo
-	return typeInfo
-}
-
-func methodQtSignature(method reflect.Method) (signature, result string) {
-	var buf bytes.Buffer
-	for i, rune := range method.Name {
-		if i == 0 {
-			buf.WriteRune(unicode.ToLower(rune))
-		} else {
-			buf.WriteString(method.Name[i:])
-			break
-		}
-	}
-	buf.WriteByte('(')
-	n := method.Type.NumIn()
-	for i := 1; i < n; i++ {
-		if i > 1 {
-			buf.WriteByte(',')
-		}
-		buf.WriteString("QVariant")
-	}
-	buf.WriteByte(')')
-	signature = buf.String()
-
-	switch method.Type.NumOut() {
-	case 0:
-		// keep it as ""
-	case 1:
-		result = "QVariant"
-	default:
-		result = "QVariantList"
-	}
-	return
-}
-
-func hashable(value interface{}) (hashable bool) {
-	defer func() { recover() }()
-	return value == value
-}
-
-// unsafeString returns a Go string backed by C data.
-//
-// If the C data is deallocated or moved, the string will be
-// invalid and will crash the program if used. As such, the
-// resulting string must only be used inside the implementation
-// of the qml package and while the life time of the C data
-// is guaranteed.
-func unsafeString(data *C.char, size C.int) string {
-	var s string
-	sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
-	sh.Data = uintptr(unsafe.Pointer(data))
-	sh.Len = int(size)
-	return s
-}
-
-// unsafeStringData returns a C string backed by Go data. The C
-// string is NOT null-terminated, so its length must be taken
-// into account.
-//
-// If the s Go string is garbage collected, the returned C data
-// will be invalid and will crash the program if used. As such,
-// the resulting data must only be used inside the implementation
-// of the qml package and while the life time of the Go string
-// is guaranteed.
-func unsafeStringData(s string) (*C.char, C.int) {
-	return *(**C.char)(unsafe.Pointer(&s)), C.int(len(s))
-}
-
-// unsafeBytesData returns a C string backed by Go data. The C
-// string is NOT null-terminated, so its length must be taken
-// into account.
-//
-// If the array backing the b Go slice is garbage collected, the
-// returned C data will be invalid and will crash the program if
-// used. As such, the resulting data must only be used inside the
-// implementation of the qml package and while the life time of
-// the Go array is guaranteed.
-func unsafeBytesData(b []byte) (*C.char, C.int) {
-	return *(**C.char)(unsafe.Pointer(&b)), C.int(len(b))
-}

=== removed file 'qml.v0/doc.go'
--- qml.v0/doc.go	2014-08-26 19:38:51 +0000
+++ qml.v0/doc.go	1970-01-01 00:00:00 +0000
@@ -1,166 +0,0 @@
-// Package qml offers graphical QML application support for the Go language.
-//
-// Attention
-//
-// This package is in an alpha stage, and still in heavy development. APIs may
-// change, and things may break.
-//
-// At this time contributors and developers that are interested in tracking the
-// development closely are encouraged to use it. If you'd prefer a more stable
-// release, please hold on a bit and subscribe to the mailing list for news. It's
-// in a pretty good state, so it shall not take too long.
-//
-// See http://github.com/go-qml/qml for details.
-//
-//
-// Introduction
-//
-// The qml package enables Go programs to display and manipulate graphical content
-// using Qt's QML framework. QML uses a declarative language to express structure
-// and style, and supports JavaScript for in-place manipulation of the described
-// content. When using the Go qml package, such QML content can also interact with
-// Go values, making use of its exported fields and methods, and even explicitly
-// creating new instances of registered Go types.
-//
-// A simple Go application that integrates with QML may perform the following steps
-// for offering a graphical interface:
-//
-//   * Initialize the qml package (see Init)
-//   * Create an engine for loading and running QML content (see NewEngine)
-//   * Make Go values and types available to QML (see Context.SetVar and RegisterType)
-//   * Load QML content (see Engine.LoadString and Engine.LoadFile)
-//   * Create a new window for the content (see Component.CreateWindow)
-//   * Show the window and wait for it to be closed (see Window.Show and Window.Wait)
-//
-// Some of these topics are covered below, and may also be observed in practice
-// in the following examples:
-//
-//   https://github.com/go-qml/qml/tree/master/examples
-//
-//
-// Handling QML objects in Go
-//
-// Any QML object may be manipulated by Go via the Object interface. That
-// interface is implemented both by dynamic QML values obtained from a running
-// engine, and by Go types in the qml package that represent QML values, such as
-// Window, Context, and Engine.
-//
-// For example, the following logic creates a window and prints its width
-// whenever it's made visible:
-//
-//    win := component.CreateWindow(nil)
-//    win.On("visibleChanged", func(visible bool) {
-//        if (visible) {
-//            fmt.Println("Width:", win.Int("width"))
-//        }
-//    })
-//
-// Information about the methods, properties, and signals that are available for QML
-// objects may be obtained in the Qt documentation. As a reference, the "visibleChanged"
-// signal and the "width" property used in the example above are described at:
-//
-//    http://qt-project.org/doc/qt-5.0/qtgui/qwindow.html
-//
-// When in doubt about what type is being manipulated, the Object.TypeName method
-// provides the type name of the underlying value.
-//
-//
-// Publishing Go values to QML
-//
-// The simplest way of making a Go value available to QML code is setting it
-// as a variable of the engine's root context, as in:
-//
-//    context := engine.Context()
-//    context.SetVar("person", &Person{Name: "Ale"})
-//
-// This logic would enable the following QML code to successfully run:
-//
-//    import QtQuick 2.0
-//    Item {
-//        Component.onCompleted: console.log("Name is", person.name)
-//    }
-//
-//
-// Publishing Go types to QML
-//
-// While registering an individual Go value as described above is a quick way to get
-// started, it is also fairly limited. For more flexibility, a Go type may be
-// registered so that QML code can natively create new instances in an arbitrary
-// position of the structure. This may be achieved via the RegisterType function, as
-// the following example demonstrates:
-//
-//    qml.RegisterTypes("GoExtensions", 1, 0, []qml.TypeSpec{{
-//        Init: func(p *Person, obj qml.Object) { p.Name = "<none>" },
-//    }})
-//
-// With this logic in place, QML code can create new instances of Person by itself:     
-//
-//    import QtQuick 2.0
-//    import GoExtensions 1.0
-//    Item{
-//        Person {
-//            id: person
-//            name: "Ale"
-//        }
-//        Component.onCompleted: console.log("Name is", person.name)
-//    }
-//
-//
-// Lowercasing of names
-// 
-// Independently from the mechanism used to publish a Go value to QML code, its methods
-// and fields are available to QML logic as methods and properties of the
-// respective QML object representing it. As required by QML, though, the Go
-// method and field names are lowercased according to the following scheme when
-// being accesed from QML:
-//
-//    value.Name      => value.name
-//    value.UPPERName => value.upperName
-//    value.UPPER     => value.upper
-//
-//
-// Setters and getters
-//
-// While QML code can directly read and write exported fields of Go values, as described
-// above, a Go type can also intercept writes to specific fields by declaring a setter
-// method according to common Go conventions. This is often useful for updating the
-// internal state or the visible content of a Go-defined type.
-//
-// For example:
-//
-//    type Person struct {
-//        Name string
-//    }
-//
-//    func (p *Person) SetName(name string) {
-//        fmt.Println("Old name is", p.Name)
-//        p.Name = name
-//        fmt.Println("New name is", p.Name)
-//    }
-//
-// In the example above, whenever QML code attempts to update the Person.Name field
-// via any means (direct assignment, object declarations, etc) the SetName method
-// is invoked with the provided value instead.
-//
-// A setter method may also be used in conjunction with a getter method rather
-// than a real type field. A method is only considered a getter in the presence
-// of the respective setter, and according to common Go conventions it must not
-// have the Get prefix.
-//
-// Inside QML logic, the getter and setter pair is seen as a single object property.
-//
-//
-// Painting
-//
-// Custom types implemented in Go may have displayable content by defining
-// a Paint method such as:
-//
-//    func (p *Person) Paint(painter *qml.Painter) {
-//        // ... OpenGL calls with the gopkg.in/qml.v0/gl package ...
-//    }
-//
-// A simple example is available at:
-//
-//   https://github.com/go-qml/qml/tree/master/examples/painting
-//
-package qml

=== removed file 'qml.v0/log.go'
--- qml.v0/log.go	2014-08-26 19:38:51 +0000
+++ qml.v0/log.go	1970-01-01 00:00:00 +0000
@@ -1,157 +0,0 @@
-package qml
-
-// #include "capi.h"
-//
-import "C"
-
-import (
-	"fmt"
-	"log"
-	"path/filepath"
-	"strings"
-)
-
-// SetLogger sets the target for messages logged by the qml package,
-// including console.log and related calls from within qml code.
-//
-// The logger value must implement either the StdLogger interface,
-// which is satisfied by the standard *log.Logger type, or the QmlLogger
-// interface, which offers more control over the logged message.
-//
-// If no logger is provided, the qml package will send messages to the
-// default log package logger. This behavior may also be restored by
-// providing a nil logger to this function.
-func SetLogger(logger interface{}) {
-	if logger == nil {
-		logHandler = defaultLogger{}
-		return
-	}
-	if qmll, ok := logger.(QmlLogger); ok {
-		logHandler = qmll
-		return
-	}
-	if stdl, ok := logger.(StdLogger); ok {
-		logHandler = wrappedStdLogger{stdl}
-		return
-	}
-	panic("unsupported logger interface")
-}
-
-// The QmlLogger interface may be implemented to better control how
-// log messages from the qml package are handled. Values that
-// implement either StdLogger or QmlLogger may be provided to the
-// SetLogger function.
-type QmlLogger interface {
-	// QmlOutput is called whenever a new message is available for logging.
-	// The message value must not be used after the method returns.
-	QmlOutput(message LogMessage) error
-}
-
-// The StdLogger interface is implemented by standard *log.Logger values.
-// Values that implement either StdLogger or QmlLogger may be provided
-// to the SetLogger function.
-type StdLogger interface {
-	// Output is called whenever a new message is available for logging.
-	// See the standard log.Logger type for more details.
-	Output(calldepth int, s string) error
-}
-
-// NOTE: LogMessage is an interface to avoid allocating and copying
-// several strings for each logged message.
-
-// LogMessage is implemented by values provided to QmlLogger.QmlOutput.
-type LogMessage interface {
-	Severity() LogSeverity
-	Text() string
-	File() string
-	Line() int
-
-	String() string // returns "file:line: text"
-
-	privateMarker()
-}
-
-type LogSeverity int
-
-const (
-	LogDebug LogSeverity = iota
-	LogWarning
-	LogCritical
-	LogFatal
-)
-
-var logHandler QmlLogger = defaultLogger{}
-
-type defaultLogger struct{}
-
-func (defaultLogger) QmlOutput(msg LogMessage) error {
-	log.Println(msg.String())
-	return nil
-}
-
-func init() {
-	// Install the C++ log handler that diverts calls to the hook below.
-	C.installLogHandler()
-}
-
-//export hookLogHandler
-func hookLogHandler(cmsg *C.LogMessage) {
-	// Workarund for QTBUG-35943
-	text := unsafeString(cmsg.text, cmsg.textLen)
-	if strings.HasPrefix(text, `"Qt Warning: Compose file:`) {
-		return
-	}
-	msg := logMessage{c: cmsg}
-	logHandler.QmlOutput(&msg)
-	msg.invalid = true
-}
-
-type wrappedStdLogger struct {
-	StdLogger
-}
-
-func (l wrappedStdLogger) QmlOutput(msg LogMessage) error {
-	return l.Output(0, msg.String())
-}
-
-type logMessage struct {
-	c *C.LogMessage
-
-	// invalid flags that cmsg points to unreliable memory,
-	// since the log hook has already returned.
-	invalid bool
-}
-
-func (m *logMessage) assertValid() {
-	if m.invalid {
-		panic("attempted to use log message outside of log hook")
-	}
-}
-
-func (m *logMessage) Severity() LogSeverity {
-	return LogSeverity(m.c.severity)
-}
-
-func (m *logMessage) Line() int {
-	m.assertValid()
-	return int(m.c.line)
-}
-
-func (m *logMessage) String() string {
-	m.assertValid()
-	file := unsafeString(m.c.file, m.c.fileLen)
-	text := unsafeString(m.c.text, m.c.textLen)
-	return fmt.Sprintf("%s:%d: %s", filepath.Base(file), m.c.line, text)
-}
-
-func (m *logMessage) File() string {
-	m.assertValid()
-	return C.GoStringN(m.c.file, m.c.fileLen)
-}
-
-func (m *logMessage) Text() string {
-	m.assertValid()
-	return C.GoStringN(m.c.text, m.c.line)
-}
-
-func (*logMessage) privateMarker() {}

=== removed file 'qml.v0/qml.go'
--- qml.v0/qml.go	2014-08-26 19:38:51 +0000
+++ qml.v0/qml.go	1970-01-01 00:00:00 +0000
@@ -1,1059 +0,0 @@
-package qml
-
-// #include <stdlib.h>
-//
-// #include "capi.h"
-//
-import "C"
-
-import (
-	"errors"
-	"fmt"
-	"image"
-	"image/color"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"reflect"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"unsafe"
-)
-
-// InitOptions holds options to initialize the qml package.
-type InitOptions struct {
-	// Reserved for coming options.
-}
-
-var initialized int32
-
-// Init initializes the qml package with the provided parameters.
-// If the options parameter is nil, default options suitable for a
-// normal graphic application will be used.
-//
-// Init must be called only once, and before any other functionality
-// from the qml package is used.
-func Init(options *InitOptions) {
-	if !atomic.CompareAndSwapInt32(&initialized, 0, 1) {
-		panic("qml.Init called more than once")
-	}
-
-	guiLoopReady.Lock()
-	go guiLoop()
-	guiLoopReady.Lock()
-}
-
-// Engine provides an environment for instantiating QML components.
-type Engine struct {
-	Common
-	values    map[interface{}]*valueFold
-	destroyed bool
-
-	imageProviders map[string]*func(providerId string, width, height int) image.Image
-}
-
-var engines = make(map[unsafe.Pointer]*Engine)
-
-// NewEngine returns a new QML engine.
-//
-// The Destory method must be called to finalize the engine and
-// release any resources used.
-func NewEngine() *Engine {
-	engine := &Engine{values: make(map[interface{}]*valueFold)}
-	RunMain(func() {
-		engine.addr = C.newEngine(nil)
-		engine.engine = engine
-		engine.imageProviders = make(map[string]*func(providerId string, width, height int) image.Image)
-		engines[engine.addr] = engine
-		stats.enginesAlive(+1)
-	})
-	return engine
-}
-
-func (e *Engine) assertValid() {
-	if e.destroyed {
-		panic("engine already destroyed")
-	}
-}
-
-// Destroy finalizes the engine and releases any resources used.
-// The engine must not be used after calling this method.
-//
-// It is safe to call Destroy more than once.
-func (e *Engine) Destroy() {
-	if !e.destroyed {
-		RunMain(func() {
-			if !e.destroyed {
-				e.destroyed = true
-				C.delObjectLater(e.addr)
-				if len(e.values) == 0 {
-					delete(engines, e.addr)
-				} else {
-					// The engine reference keeps those values alive.
-					// The last value destroyed will clear it.
-				}
-				stats.enginesAlive(-1)
-			}
-		})
-	}
-}
-
-// Load loads a new component with the provided location and with the
-// content read from r. The location informs the resource name for
-// logged messages, and its path is used to locate any other resources
-// referenced by the QML content.
-//
-// Once a component is loaded, component instances may be created from
-// the resulting object via its Create and CreateWindow methods.
-func (e *Engine) Load(location string, r io.Reader) (Object, error) {
-	data, err := ioutil.ReadAll(r)
-	if err != nil {
-		return nil, err
-	}
-	if colon, slash := strings.Index(location, ":"), strings.Index(location, "/"); colon == -1 || slash <= colon {
-		if filepath.IsAbs(location) {
-			location = "file:///" + filepath.ToSlash(location)
-		} else {
-			dir, err := os.Getwd()
-			if err != nil {
-				return nil, fmt.Errorf("cannot obtain absolute path: %v", err)
-			}
-			location = "file:///" + filepath.ToSlash(filepath.Join(dir, location))
-		}
-
-	}
-
-	cdata, cdatalen := unsafeBytesData(data)
-	cloc, cloclen := unsafeStringData(location)
-	comp := &Common{engine: e}
-	RunMain(func() {
-		// TODO The component's parent should probably be the engine.
-		comp.addr = C.newComponent(e.addr, nilPtr)
-		C.componentSetData(comp.addr, cdata, cdatalen, cloc, cloclen)
-		message := C.componentErrorString(comp.addr)
-		if message != nilCharPtr {
-			err = errors.New(strings.TrimRight(C.GoString(message), "\n"))
-			C.free(unsafe.Pointer(message))
-		}
-	})
-	if err != nil {
-		return nil, err
-	}
-	return comp, nil
-}
-
-// LoadFile loads a component from the provided QML file.
-// Resources referenced by the QML content will be resolved relative to its path.
-//
-// Once a component is loaded, component instances may be created from
-// the resulting object via its Create and CreateWindow methods.
-func (e *Engine) LoadFile(path string) (Object, error) {
-	// TODO Test this.
-	f, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-	return e.Load(path, f)
-}
-
-// LoadString loads a component from the provided QML string.
-// The location informs the resource name for logged messages, and its
-// path is used to locate any other resources referenced by the QML content.
-//
-// Once a component is loaded, component instances may be created from
-// the resulting object via its Create and CreateWindow methods.
-func (e *Engine) LoadString(location, qml string) (Object, error) {
-	return e.Load(location, strings.NewReader(qml))
-}
-
-// Context returns the engine's root context.
-func (e *Engine) Context() *Context {
-	e.assertValid()
-	var ctx Context
-	ctx.engine = e
-	RunMain(func() {
-		ctx.addr = C.engineRootContext(e.addr)
-	})
-	return &ctx
-}
-
-// TODO ObjectOf is probably still worth it, but turned out unnecessary
-//      for GL functionality. Test it properly before introducing it.
-
-// ObjectOf returns the QML Object representation of the provided Go value
-// within the e engine.
-//func (e *Engine) ObjectOf(value interface{}) Object {
-//	// TODO Would be good to preserve identity on the Go side. See unpackDataValue as well.
-//	return &Common{
-//		engine: e,
-//		addr:   wrapGoValue(e, value, cppOwner),
-//	}
-//}
-
-// Painter is provided to Paint methods on Go types that have displayable content.
-type Painter struct {
-	enigne *Engine
-	obj    Object
-}
-
-// Object returns the underlying object being painted.
-func (p *Painter) Object() Object {
-	return p.obj
-}
-
-// AddImageProvider registers f to be called when an image is requested by QML code
-// with the specified provider identifier. It is a runtime error to register the same
-// provider identifier multiple times.
-//
-// The imgId provided to f is the requested image source, with the "image:" scheme
-// and provider identifier removed. For example, with an image image source of
-// "image://myprovider/icons/home.ext", the respective imgId would be "icons/home.ext".
-//
-// If either the width or the height parameters provided to f are zero, no specific
-// size for the image was requested. If non-zero, the returned image should have the
-// the provided size, and will be resized if the returned image has a different size.
-//
-// See the documentation for more details on image providers:
-//
-//   http://qt-project.org/doc/qt-5.0/qtquick/qquickimageprovider.html
-//
-func (e *Engine) AddImageProvider(prvId string, f func(imgId string, width, height int) image.Image) {
-	if _, ok := e.imageProviders[prvId]; ok {
-		panic(fmt.Sprintf("engine already has an image provider with id %q", prvId))
-	}
-	e.imageProviders[prvId] = &f
-	cprvId, cprvIdLen := unsafeStringData(prvId)
-	RunMain(func() {
-		qprvId := C.newString(cprvId, cprvIdLen)
-		defer C.delString(qprvId)
-		C.engineAddImageProvider(e.addr, qprvId, unsafe.Pointer(&f))
-	})
-}
-
-//export hookRequestImage
-func hookRequestImage(imageFunc unsafe.Pointer, cid *C.char, cidLen, cwidth, cheight C.int) unsafe.Pointer {
-	f := *(*func(imgId string, width, height int) image.Image)(imageFunc)
-
-	id := unsafeString(cid, cidLen)
-	width := int(cwidth)
-	height := int(cheight)
-
-	img := f(id, width, height)
-
-	var cimage unsafe.Pointer
-
-	rect := img.Bounds()