[glibmm] VariantType: Add more appropriate constructor and add Gtk::Stock-like types.

[Murray Cumming <murrayc src gnome org>]

commit d7a06965d38492cf558509121fb8c3a69f6820a5
Author: Murray Cumming <murrayc murrayc com>
Date:   Thu Jul 29 12:02:39 2010 +0200

    VariantType: Add more appropriate constructor and add Gtk::Stock-like types.
    
    * glib/src/varianttype.[hg|ccg]: Add a cobject constructor that always copies,
    and an operator= to match.
    Add VariantType* objects to match the G_VARIANT_TYPE_* defines in C.

 ChangeLog                |   10 ++++-
 glib/src/varianttype.ccg |   99 ++++++++++++++++++++++++++++++++++++++
 glib/src/varianttype.hg  |  119 ++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 227 insertions(+), 1 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index c67dc30..3e76a76 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,4 +1,12 @@
-2010-07-29  Murray Cumming  <murrayc murrayc-x61>
+2010-07-29  Murray Cumming  <murrayc murrayc com>
+
+	VariantType: Add more appropriate constructor and add Gtk::Stock-like types.
+
+	* glib/src/varianttype.[hg|ccg]: Add a cobject constructor that always copies, 
+	and an operator= to match.
+	Add VariantType* objects to match the G_VARIANT_TYPE_* defines in C.
+
+2010-07-29  Murray Cumming  <murrayc murrayc com>
 
 	Added VariantType
 
diff --git a/glib/src/varianttype.ccg b/glib/src/varianttype.ccg
new file mode 100644
index 0000000..7422284
--- /dev/null
+++ b/glib/src/varianttype.ccg
@@ -0,0 +1,99 @@
+/* Copyright 2010 The glibmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/varianttype.h>
+#include <glibmm/utility.h>
+#include <glib/gvarianttype.h>
+
+namespace Glib
+{
+
+VariantType::VariantType(const GVariantType* castitem)
+{
+  if(castitem)
+    gobject_ = g_variant_type_copy(castitem);
+  else
+    gobject_ = 0;
+}
+
+VariantType& VariantType::operator=(const GVariantType* castitem)
+{
+  if(gobject_)
+  {
+    g_variant_type_free (gobject_);
+  }
+  
+  if(castitem)
+    gobject_ = g_variant_type_copy(castitem);
+  else
+    gobject_ = 0;
+    
+  return *this;
+}
+
+
+const VariantType VariantTypeBool(G_VARIANT_TYPE_BOOLEAN);
+
+const VariantType VariantTypeByte(G_VARIANT_TYPE_BYTE);
+
+const VariantType VariantTypeInt16(G_VARIANT_TYPE_INT16);
+
+const VariantType VariantTypeUint16(G_VARIANT_TYPE_UINT16);
+
+const VariantType VariantTypeInt32(G_VARIANT_TYPE_INT32);
+
+const VariantType VariantTypeUint32(G_VARIANT_TYPE_UINT32);
+
+const VariantType VariantTypeInt64(G_VARIANT_TYPE_INT64);
+
+const VariantType VariantTypeUint64(G_VARIANT_TYPE_UINT64);
+
+const VariantType VariantTypeDouble(G_VARIANT_TYPE_DOUBLE);
+
+const VariantType VariantTypeString(G_VARIANT_TYPE_STRING);
+
+const VariantType VariantTypeObjectPath(G_VARIANT_TYPE_OBJECT_PATH);
+
+const VariantType VariantTypeSignature(G_VARIANT_TYPE_SIGNATURE);
+
+const VariantType VariantTypeVariant(G_VARIANT_TYPE_VARIANT);
+
+const VariantType VariantTypeHandle(G_VARIANT_TYPE_HANDLE);
+
+const VariantType VariantTypeUnit(G_VARIANT_TYPE_UNIT);
+
+const VariantType VariantTypeAny(G_VARIANT_TYPE_ANY);
+
+const VariantType VariantTypeBasic(G_VARIANT_TYPE_BASIC);
+
+const VariantType VariantTypeMaybe(G_VARIANT_TYPE_MAYBE);
+
+const VariantType VariantTypeArray(G_VARIANT_TYPE_ARRAY);
+
+const VariantType VariantTypeTuple(G_VARIANT_TYPE_TUPLE);
+
+const VariantType VariantTypeDictEntry(G_VARIANT_TYPE_DICT_ENTRY);
+
+const VariantType VariantTypeDictionary(G_VARIANT_TYPE_DICTIONARY);
+
+const VariantType VariantTypeStringArray(G_VARIANT_TYPE_STRING_ARRAY);
+
+const VariantType VariantTypeByteString(G_VARIANT_TYPE_BYTESTRING);
+
+const VariantType VariantTypeByteStringArray(G_VARIANT_TYPE_STRING_ARRAY);
+
+}
diff --git a/glib/src/varianttype.hg b/glib/src/varianttype.hg
new file mode 100644
index 0000000..d07ba13
--- /dev/null
+++ b/glib/src/varianttype.hg
@@ -0,0 +1,119 @@
+/* Copyright 2010 The glibmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+_DEFS(glibmm,glib)
+
+#include <glibmmconfig.h>
+#include <glibmm/ustring.h>
+
+namespace Glib
+{
+
+/** TODO
+ * @newin{2,26}
+ * @ingroup glibmmVariant
+ */
+class VariantType
+{
+  _CLASS_OPAQUE_COPYABLE(VariantType, GVariantType, NONE, g_variant_type_copy, g_variant_type_free)
+  _IGNORE(g_variant_type_copy, g_variant_type_free)
+public:
+
+  /** Copy the C item into a new VariantType instance.
+   */
+  explicit VariantType(const GVariantType* castitem);
+  
+  VariantType& operator=(const GVariantType* castitem);
+  
+  //TODO: Use something instead of gsize?
+  _WRAP_METHOD(gsize _get_string_length() const, g_variant_type_get_string_length)
+  _WRAP_METHOD(Glib::ustring get_string() const, g_variant_type_peek_string)
+  _IGNORE(g_variant_type_dup_string)
+
+  _WRAP_METHOD(bool is_definite() const, g_variant_type_is_definite)
+  _WRAP_METHOD(bool is_container() const, g_variant_type_is_container)
+  _WRAP_METHOD(bool is_basic() const, g_variant_type_is_basic)
+  _WRAP_METHOD(bool is_maybe() const, g_variant_type_is_maybe)
+  _WRAP_METHOD(bool is_array() const, g_variant_type_is_array)
+  _WRAP_METHOD(bool is_tuple() const, g_variant_type_is_tuple)
+  _WRAP_METHOD(bool is_dict_entry() const, g_variant_type_is_dict_entry)
+  _WRAP_METHOD(bool is_variant() const, g_variant_type_is_variant)
+
+/* subtypes */
+  _WRAP_METHOD(bool is_subtype_of(const VariantType& supertype) const, g_variant_type_is_subtype_of)
+  
+  _WRAP_METHOD(VariantType element() const, g_variant_type_element)
+  _WRAP_METHOD(VariantType first() const, g_variant_type_first)
+  _WRAP_METHOD(VariantType next () const, g_variant_type_next)
+  _WRAP_METHOD(gsize n_items() const, g_variant_type_n_items)
+  _WRAP_METHOD(VariantType key() const, g_variant_type_key)
+  _WRAP_METHOD(VariantType value() const, g_variant_type_value)
+};
+
+extern const VariantType VariantTypeBool;
+
+extern const VariantType VariantTypeByte;
+
+extern const VariantType VariantTypeInt16;
+
+extern const VariantType VariantTypeUint16;
+
+extern const VariantType VariantTypeInt32;
+
+extern const VariantType VariantTypeUint32;
+
+extern const VariantType VariantTypeInt64;
+
+extern const VariantType VariantTypeUint64;
+
+extern const VariantType VariantTypeDouble;
+
+extern const VariantType VariantTypeString;
+
+extern const VariantType VariantTypeObjectPath;
+
+extern const VariantType VariantTypeSignature;
+
+extern const VariantType VariantTypeVariant;
+
+extern const VariantType VariantTypeHandle;
+
+extern const VariantType VariantTypeUnit;
+
+extern const VariantType VariantTypeAny;
+
+extern const VariantType VariantTypeBasic;
+
+extern const VariantType VariantTypeMaybe;
+
+extern const VariantType VariantTypeArray;
+
+extern const VariantType VariantTypeTuple;
+
+extern const VariantType VariantTypeDictEntry;
+
+extern const VariantType VariantTypeDictionary;
+
+extern const VariantType VariantTypeStringArray;
+
+extern const VariantType VariantTypeByteString;
+
+extern const VariantType VariantTypeByteStringArray;
+
+
+
+} // namespace Glib