Add a GStreamer element that provides a video sink that draws directly on QWidget.
Note that this element is built as an external GStreamer plugin and it is independent from the bindings.

Move tests/* to tests/auto/*

Add a version check for GStreamer.

Sync the FindG* cmake modules from phonon.

Rearrange the signal/closure code to make it a bit more readable.

Add option (enabled by default) to omit the sender from a slot's arguments. In most cases, it is unneeded.

Header "Closure" was removed in a previous commit (because Closure is not meant to be public API). Fix CMakeLists.txt.

Add wrapper for GstXOverlay and fix codegen to be able to use more gstreamer includes, other than <gst/gst.h> (required for including gst/interfaces/*)

Fix outdated docs.

Define GST_DISABLE_DEPRECATED to get rid of the stupid libxml2 dependency and raise GStreamer version requirement to 0.10.30.

Remove methods that are deprecated as of GStreamer 0.10.30.

Obey the API docs and throw a QGlib::Error from QGst::init() when it fails.

Add cmake target to generate API docs and write some basic API docs where needed.

Add an asynchronous bus message dispatcher that emits the "message" signal,
like the one provided by the gst_bus_add_signal_watch() method, but which works
purely with the Qt event loop and doesn't require a Glib one.

Add subclasses to QGst::Message so that it is possible to create and parse the various types of messages.

This commit also adds two helper template structures:
QGlib::Private::CanConvertTo and QGlib::Private::CanConvertFrom.
These are used to abstract away the conversion check from RefPointer::dynamicCast()
and the conversion sanity checks from ValueBase::set() and ValueBase::get().
This is required to make the Message subclasses work properly with these
functions, since they are not real Gst classes and do not have registered GTypes.
Each Message subclass gets a specialization for these structures which lets
RefPointer::dynamicCast() check the message type to determine whether to allow
the cast and ValueBase::set() to treat the subclass as if it was a Message.
ValueBase::get() will fail to compile if used with one of those subclasses
and this is done in purpose, since a Value can never contain one of these
(it will contain a Message, which has a GType!) and get() is not supposed to
allow upcasts, like dynamicCast() does.

So, to sum up, this trick allows you to do:

  QGst::MessagePtr msg = getSomeMessage();
  QGst::EosMessagePtr eosMsg = msg.dynamicCast<QGst::EosMessage>(); //checks if msg->type() == QGst::MessageEos

and

  QGlib::Value v;
  v.init<QGst::Message>();
  QGst::EosMessagePtr eosMsg = getSomeEosMessage();
  value.set(eosMsg); //will not fail, it will treat EosMessage as a Message

but not

  QGlib::Value v = getSomeValue();
  QGst::EosMessagePtr eosMsg = v.get<QGst::EosMessagePtr>(); //compilation error

Update README with information on:
* Building static QtGstreamer.
* CMake and qmake integration for using QtGstreamer from external projects.
* Correct header #include style.

Improve the build system; add new features and examples:
* Add ability to build QtGstreamer as a static library by passing -DSTATIC_QTGSTREAMER=1 to cmake.
* Add a FindQtGstreamer.cmake script, which is installed as QtGstreamerConfig.cmake
  together with a generated QtGstreamerTargets.cmake script, that can be used to
  find QtGstreamer from external cmake-based projects. Both shared and static versions
  of QtGstreamer are supported.
* Add an uninstall target, copied from the KDE4 scripts.
* Rewrite the CMakeLists.txt of the examples so that they can also be built standalone
  and serve as examples of how to use QtGstreamer from external projects.
* Add qmake project files for the examples, to act as examples for people using qmake.

Fix RefPointer::staticCast() to behave like static_cast(), not like reinterpret_cast().

Rename QGst::deinit() to QGst::cleanup(). deinit is not a good name.

Add wrapper for the GstURIHandler interface.

Add a const SharedStructure Caps::structure(uint index) const method.

Add a Structure(const GstStructure*) constructor and make the equivalent Value constructor take a pointer too instead of a reference,
to make the API more uniform between those two classes. Also make some of their constructors explicit, to avoid nasty bugs.

Improve the CMakeLists.txt files.
* Cleanup the g++ flags and enable -std=c++0x only if g++ is recent enough to support it.
* Enable testing with ctest.
* Make the qgst_test() macro syntax easier.

Update the README.
* Declare the project ready for simple uses.
* Add some information regarding compilers and C++0x usage.
* Document the makeWritable() method for refcounted wrappers.

Add wrappers for the simple gst_parse_* methods.

Add wrapper for GError.

Add a new "player" example: a simple command-line audio player.

In the future it will probably be expanded to handle video as well.
Although it is technically possible to do that now, I would like to
use the VideoWidget class that I plan to write for QtGstreamer.

Add ValueImpl specialization for Caps, Message and MiniObject.

Add Pipeline::bus() method.

s/runtime_error/logic_error/ in the exceptions that ValueBase throws and all the exceptions used in the signals & closures system.
These errors are really programmer errors, not something that can happen unexpectedly at runtime, so logic_error fits better.

Fix stupid mistakes. Signal::d should have been a QSharedDataPointer, not a QSharedPointer,
and Signal::Private::query() should actually cache its results.

Remove QGlib::String again. It sucks.

From now on the following policy will apply:
- Any methods that need to take a string argument will take a const char*.
This is because native gstreamer functions also take a const char* and in most
cases the programmer just passes an ascii string literal, so there is no need
to copy it in some string class and then let gstreamer copy it again. QString
is out of the question in this case, since it copies and converts to utf16, only
to let the wrapper function copy it again and convert it back to ascii. In case
the programmer needs to pass a QString to such a function, he should first convert
it to utf8 with QString::toUtf8(). This will be documented later.
- Any methods that need to return a string should return a QString.
This is because: 1) we need to make sure that the programmer won't do anything stupid
with the string, such as not free it or hold a reference to a free()-ed string, so
we can't return char* like the C functions do. 2) Usually these strings are used
for display or comparison, so the programmer needs to have an encoding-safe way
to do that and this is what QString offers. Returning a QByteArray and forcing the
programmer to convert it to unicode is not a good option.

Change PluginFeature::load() to return void and internally change m_object if needed.
It makes no sense to return a new object.

Add missing gst_object_ref_sink() in Pad::create().

Change RefCountedObject::object() to be a template that automatically casts to the requested pointer type.
This is to avoid the overhead of using gstreamer's GST_FOO() macros that internally make a type check too.

Rename all the "newClass" pseudo-constructors to "create".

Since these are static methods, you need to type the class name anyway,
so there is no need to type it again after "new". Plain "new" would have
been ideal, but unfortunately it is a keyword.
For consistency, the Caps constructors have been renamed too, although
they did not follow the "newClass" pattern.

Add wrapper for GstBus.

Add typedefs for GstClockTime and GstClockTimeDiff.

Add structs Fourcc, Fraction, IntRange, DoubleRange and FractionRange.

Initial implementation of the GObject signal wrapper system.
* Implement classes Signal and SignalHandler that wrap the basic functionality of
  the g_signal* methods, including signal connection and emission and using both
  variadic and non-variadic template versions for the connect() and emit() methods.
* Refactor the Closure system and add non-variadic versions of the templates for
  compilers that do not support C++0x variadic templates.
* Make the ValueBase::get / ValueBase::set methods throw exceptions instead of
  asserting. This helps showing nicer error messages from the signal system when
  these methods are called from there and allows in some non-fatal cases to
  continue execution.

Implement a QSharedDataPointer-like method for ensuring that caps and miniobjects are writable when needed.

The trick is to get the pointer to the underlying object using an object() method that has a const and
a non-const version. The non-const one calls makeWritable() internally, which makes a copy of the
object if needed, so any non-const method trying to access the underlying object is guaranteed that
it is writable. This is very similar to Qt's implicit sharing mechanism and what QSharedDataPointer does.

Make RefPointer::operator->() return an object pointer with the same const-ness as the RefPointer, so that it actually makes sense to use const RefPointers.

QGst::StructureBase: Replace the peekGstStructure() methods with operator GstStructure* to keep consistency with QGlib::ValueBase

valuetest: Add a Value <-> GValue cast test and use GetType() for all the type checks.

Refactor the Type and Value systems, cleanup code, add useful macros, documentation, etc..
* Add struct GetTypeImpl and its specializations in type.h.
* Make GetType() an inline function that uses GetTypeImpl internally.
* Add basic documentation for Type, GetType and their associated macros.
* Add QGLIB_STATIC_ASSERT() macro to allow specifying a nice assertion message when using C++0x.
* Add macros for defining ValueImpl specializations.
* Remove the ValueBase::getFoo / ValueBase::setFoo methods.
* Place all basic ValueImpl specializations in value.h, remove the valueimpl headers.
* Remove VALUE_ASSERT and use a type check inside ValueBase::get/set.
* Remove ValueImpl specialization for pointers. Allow only void* (Type::Pointer) and const char* (Type::String).
* Register Type, ValueBase, Value, SharedValue, StructureBase and SharedStructure with the type system.
* Attempt to fix the mess with the included headers. Try to include all used headers instead of relying on indirect inclusion from global.h.
* Remove the peekGValue() methods from ValueBase and replace them with operator GValue*().
* Minor fixes here and there...

(Long commit, sorry...)

Add methods in RefPointer to allow casting RefPointers of derived classes to RefPointers of their base classes.
This allows for example to implicitly cast a QGst::ElementPtr to a QGst::ObjectPtr without using staticCast()
or dynamicCast(). The use of a static assertion and boost's type traits ensures that you cannot cast
in the opposite direction (i.e. ObjectPtr to ElementPtr).

Add overloaded String::operator==() methods to fix a build failure in some tests.

Introduce a new String class, based on QByteArray, to avoid the overhead
of converting to/from UTF-16 when not necessary by using QString.
This class also introduces replacements for the gcharPtrToQString()
and qstringToGCharPtr() helper methods, so that it's easier to wrap
strings in the bindings.

Add wrapper for GstMessage.

Properly fix the reference counting bug I had with adding elements to bins.
Apparently GstBin adds a new reference to the elements that are added in it,
except if they are floating, in which case it takes the floating reference.

Add wrapper for GstGhostPad.

Port the 'echo' example to the new bindings to make it work again.

Add global init/deinit functions.

Add basic wrapper for GstPipeline (just the method to create a new pipeline for now).

Add wrapper for the GstChildProxy interface and use it in Bin.

Improve the Object properties api. Use QString and export the methods that get/return a Value object.

Add wrapper class for GstBin.
Still missing the iterator methods, though.

Add wrapper class for GstElementFactory.

Add a new qstringToGcharPtr() macro that converts a QString to a const gchar * and use it where appropriate.
This macro makes sure that empty strings become NULL instead of "" (i.e. empty string),
as most (if not all) gstreamer methods use NULL to represent an empty string.

Add wrapper class for GstPluginFeature.

Add a README file with various information, mostly targeted to people that want to contribute.

Add initial wrappers for GstPad and GstElement. Not all methods are yet there.

Support mixed type registrations and enum definitions in codegen, needed for enums.h.

Remove the headers from the tests and put the class declarations in the cpp files.

Add wrapper class for GstCaps.

Add wrapper class for GstMiniObject.

Improve enum assertions generation.
Make it possible to use enums that are not part of some class and make use
of the class name in the gst-style output if the enum belongs to a class.

Add wrapper class for GstStructure.

Add forward declarations for the gstreamer wrapper classes that will be implemented next.

Improve the Value API:
* Add constructor and assignment operator to allow copying a SharedValue to a Value.
* Add QDebug stream operator and remove the dumpContents() method.
* Rename peekNativeObject() to peekGValue().
* Add template init() method.
* Other minor fixes.

Add the most useful methods to the GstObject wrapper class.

Add protected constructors/destructor to all wrapper classes, so that they can only be used with RefPointer.

Make use of the code generator.
Changes include:
* Buildsystem changes to call the code generator.
* Register classes and enums with QGLIB_REGISTER_TYPE.
* QGLIB_GTYPE_WRAPPER becomes QGLIB_WRAPPER and no longer defines
  the member type() method.
* Use GetType<T>() instead of T::type() in GetType<RefPointer<T>>.
* Rename some of the enums in Type::FundamentalType so that they match
  the coding style that the code generator expects.
* Other minor compile fixes.

Initial commit of the QtGstreamer helper code generator.

This is a code generator that will parse QtGstreamer's
header files and will produce some extra code:
 * For each QGLIB_REGISTER_TYPE() macro, it will provide its
   QGLIB_REGISTER_TYPE_IMPLEMENTATION() counterpart.
 * For each defined enum, it will generate BOOST_STATIC_ASSERTs
   that will ensure that the values of the enums are exactly
   the same as in Gstreamer. This will help catch enum errors at
   compile time, since all Gstreamer's enums need to be redefined
   in the bindings to avoid exporting the Gstreamer API/ABI.

Move the GetType<>() helper template to global.h and improve the macros a bit.

Add the missing find_package(Boost REQUIRED).

Initial commit of the new code.

This mostly acts as a proof of concept for the following implemented features:
 - Generic GValue C++ wrapper.
 - Better support for setting/getting GObject properties.
 - Connection of arbitrary class member functions to GObject signals knowing
   only the signal name as a string, with conversion to/from GValue at compile
   time (using templates) and with actual type checking at runtime.

This is not yet meant to be a replacement for the old code, but it will
slowly evolve into that.

Delete old code. Re-writing everything from scratch now.

Remove extra underscore from header guards to suspend krazy warnings.

Use peekNativeObject() to get the native object pointer instead of using m_object and making every class friend with each other.

Add functions for getting the native object in GstObject and GstMiniObject.
These are useful for combining QtGstreamer with native gstreamer API.

Add a wrapper class for GstMessage.
Currently supporting only Info/Warning/Error messages.

Add a wrapper class for GstMiniObject.

Implement support for dynamic casting between QGstObject subclasses.

This adds a new qtgstreamer_cast() template function that takes into account the internal
GType of the object it is casting and appropriately returns NULL if the cast cannot be done.
For example, casting a QGstElement to a QGstPad will fail, but casting a QGstPipeline to
QGstElement and back to QGstPipeline will succeed.

Remove QGstElement::currentState() and fix the testcase to work without it.
This method is completely wrong in concept it seems...

Implement QGstElement::getState() and fix the currentState() convenience method to use getState()
so that it correctly blocks and waits for the state change to happen.

QGstStructure: Implement getName, hasName, setName methods.

Implement the methods: QGstPad::getCaps, QGstPad::setBlocked, QGstElement::syncStateWithParent, QGstCaps::getSize.

Rename class QGValue to QGstValue.

This is because we are making GStreamer bindings, not GObject ones
and QGValue already has much gstreamer-specific functionality.

Populate QGValue with functions to handle the most useful types, including most GstValue types.

Implement a wrapper for the GstXOverlay interface.

Install qgstdefinitions.h.

Add basic support for GstCaps.

The api is not as convenient as the C api, because it needs to be usable
without including gstreamer headers and linking to gstreamer, so we can't
expect the user to give us the GType of the caps fields. So, the only way
of constructing QGstCaps for now is the one seen in QtGstreamerTest::capsTest().

Move all the forward declarations and typedefs in a separate header to keep the other headers clean.

Add a QGValue class, a wrapper for GValue.

This class is similar to QVariant and thus I wrote some conversion methods
from/to QVariant, but they will only work with basic types at the moment.
I also changed QGstObject::property and setProperty to use QGValue.

When destroying a QGstElement, set its state to Null if the underlying GstElement is going to be deleted.
This is to allow the GstElement to cleanup without requiring the user to set the state explicitly to Null.

Implement QGstBin::getByName()

Implement QGstElement::releaseRequestPad()

Implement QGstPad::direction()

Qualify signal arguments with the full namespace to make it possible to connect properly.