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.

Disconnect GObject signals properly to avoid crashes in case the underlying GObject is deleted after the the QObject wrapper.

Add signals to QGstElement.

Add basic support for getting bus messages.

Move to shared pointer architecture.

All classes now have protected contructors and static functions that act
as constructors returning a QSharedPointer holding the class instance.
All QObject parents where dropped as they don't make sense with this
architecture.

Add basic support for ghost pads.

Add simple constructor for QGstBin.

QGstElementFactory: add methods find() and exists() and constructor/destructor.

Note: The method exists() does not exist in the gstreamer bindings but it is
useful to have. It is a small wrapper around find() to automatically delete
the created QGstElementFactory if it was created successfully.

Install files.

Fix a bit the element state functions.

Add basic support for pads.

Add a simple echo example, which forwards audio from the mic to the speakers.

Add wrappers for gst_init().

Cleanup resources in the unit test.
(doesn't seem to make much difference though...)

Fix legal stuff.

Initial commit.