re-implement ibus in c language.

1 files changed, 221 insertions, 0 deletions

diff --git a/src/ibusconfigprivate.h b/src/ibusconfigprivate.h
new file mode 100644
index 0000000..0bd3b8e
--- /dev/null
+++ b/src/ibusconfigprivate.h
@@ -0,0 +1,221 @@
+/* vim:set et sts=4: */
+/* ibus - The Input Bus
+ * Copyright (C) 2008-2009 Huang Peng <shawn.p.huang@gmail.com>
+ *
+ * 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 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __IBUS_CONFIG_PRIVATE_H_
+#define __IBUS_CONFIG_PRIVATE_H_
+
+static void
+_from_dbus_value (IBusMessageIter   *iter,
+                  GValue            *value)
+{
+    g_assert (iter != NULL);
+    g_assert (value != NULL);
+
+    gint type;
+    IBusMessageIter sub_iter;
+
+    type = ibus_message_iter_get_arg_type (iter);
+    if (type == IBUS_TYPE_VARIANT) {
+        ibus_message_iter_recurse (iter, IBUS_TYPE_VARIANT, &sub_iter);
+        ibus_message_iter_next (iter);
+        iter = &sub_iter;
+        type = ibus_message_iter_get_arg_type (iter);
+    }
+
+    switch (type) {
+    case G_TYPE_STRING:
+        {
+            gchar *v;
+            g_value_init (value, G_TYPE_STRING);
+            ibus_message_iter_get_basic (iter, &v);
+            g_value_set_string (value, v);
+        }
+        break;
+    case G_TYPE_INT:
+        {
+            gint v;
+            g_value_init (value, G_TYPE_INT);
+            ibus_message_iter_get_basic (iter, &v);
+            g_value_set_int (value, v);
+        }
+        break;
+    case G_TYPE_UINT:
+        {
+            guint v;
+            g_value_init (value, G_TYPE_UINT);
+            ibus_message_iter_get_basic (iter, &v);
+            g_value_set_uint (value, v);
+        }
+        break;
+    case G_TYPE_BOOLEAN:
+        {
+            gboolean v;
+            g_value_init (value, G_TYPE_BOOLEAN);
+            ibus_message_iter_get_basic (iter, &v);
+            g_value_set_boolean (value, v);
+        }
+        break;
+    case G_TYPE_DOUBLE:
+        {
+            gdouble v;
+            g_value_init (value, G_TYPE_DOUBLE);
+            ibus_message_iter_get_basic (iter, &v);
+            g_value_set_double (value, v);
+        }
+        break;
+    default:
+        if (type == IBUS_TYPE_ARRAY) {
+            GValue v = { 0 };
+            IBusMessageIter sub_iter;
+            gint sub_type;
+            GValueArray *array;
+
+
+            sub_type = ibus_message_iter_get_element_type (iter);
+            g_assert (sub_type == G_TYPE_STRING ||
+                      sub_type == G_TYPE_INT ||
+                      sub_type == G_TYPE_UINT ||
+                      sub_type == G_TYPE_BOOLEAN ||
+                      sub_type == G_TYPE_DOUBLE ||
+                      sub_type == IBUS_TYPE_VARIANT);
+
+            g_value_init (value, G_TYPE_VALUE_ARRAY);
+            array = g_value_array_new (0);
+            ibus_message_iter_recurse (iter, IBUS_TYPE_ARRAY, &sub_iter);
+            while (ibus_message_iter_get_arg_type (&sub_iter) != G_TYPE_INVALID) {
+                _from_dbus_value (&sub_iter, &v);
+                g_value_array_append (array, &v);
+                g_value_unset (&v);
+            }
+            g_value_take_boxed (value, array);
+            ibus_message_iter_next (iter);
+            break;
+        }
+
+        g_debug ("type=%s", g_type_name (type));
+
+        g_assert_not_reached();
+    }
+}
+
+static void
+_to_dbus_value (IBusMessageIter *iter,
+                const GValue    *value)
+{
+    IBusMessageIter sub_iter;
+    gboolean retval;
+
+
+    switch (G_VALUE_TYPE (value)) {
+    case G_TYPE_STRING:
+        {
+            retval = ibus_message_iter_open_container (iter, IBUS_TYPE_VARIANT, "s", &sub_iter);
+            g_assert (retval);
+
+            const gchar *v = g_value_get_string (value);
+            ibus_message_iter_append (&sub_iter,
+                                      G_TYPE_STRING,
+                                      &v);
+            ibus_message_iter_close_container (iter, &sub_iter);
+        }
+        break;
+    case G_TYPE_INT:
+        {
+            retval = ibus_message_iter_open_container (iter, IBUS_TYPE_VARIANT, "i", &sub_iter);
+            g_assert (retval);
+
+            gint v = g_value_get_int (value);
+            ibus_message_iter_append (&sub_iter,
+                                      G_TYPE_INT,
+                                      &v);
+            ibus_message_iter_close_container (iter, &sub_iter);
+        }
+        break;
+    case G_TYPE_UINT:
+        {
+            retval = ibus_message_iter_open_container (iter, IBUS_TYPE_VARIANT, "u", &sub_iter);
+            g_assert (retval);
+
+            guint v = g_value_get_uint (value);
+            ibus_message_iter_append (&sub_iter,
+                                      G_TYPE_UINT,
+                                      &v);
+            ibus_message_iter_close_container (iter, &sub_iter);
+        }
+        break;
+    case G_TYPE_BOOLEAN:
+        {
+            retval = ibus_message_iter_open_container (iter, IBUS_TYPE_VARIANT, "b", &sub_iter);
+            g_assert (retval);
+
+            gboolean v = g_value_get_boolean (value);
+            ibus_message_iter_append (&sub_iter,
+                                      G_TYPE_BOOLEAN,
+                                      &v);
+            ibus_message_iter_close_container (iter, &sub_iter);
+        }
+        break;
+    case G_TYPE_DOUBLE:
+        {
+            retval = ibus_message_iter_open_container (iter, IBUS_TYPE_VARIANT, "d", &sub_iter);
+            g_assert (retval);
+
+            gdouble v = g_value_get_double (value);
+            ibus_message_iter_append (&sub_iter,
+                                      G_TYPE_DOUBLE,
+                                      &v);
+            ibus_message_iter_close_container (iter, &sub_iter);
+        }
+        break;
+    default:
+        if (G_TYPE_VALUE_ARRAY == G_VALUE_TYPE (value)) {
+            IBusMessageIter sub_sub_iter;
+            GType type = G_TYPE_INVALID;
+            gint i;
+
+            retval = ibus_message_iter_open_container (iter, IBUS_TYPE_VARIANT, "av", &sub_iter);
+            g_assert (retval);
+
+            GValueArray *array = (GValueArray *)g_value_get_boxed (value);
+            ibus_message_iter_open_container (&sub_iter,
+                                              IBUS_TYPE_ARRAY,
+                                              "v",
+                                              &sub_sub_iter);
+            if (array->n_values > 0) {
+                type = G_VALUE_TYPE (&array->values[0]);
+                g_assert (type == G_TYPE_STRING ||
+                          type == G_TYPE_INT ||
+                          type == G_TYPE_UINT ||
+                          type == G_TYPE_BOOLEAN ||
+                          type == G_TYPE_DOUBLE);
+            }
+            for (i = 0; i < array->n_values; i++) {
+                g_assert (type == G_VALUE_TYPE (&array->values[i]));
+                _to_dbus_value (&sub_sub_iter, &array->values[i]);
+            }
+            ibus_message_iter_close_container (&sub_iter, &sub_sub_iter);
+            ibus_message_iter_close_container (iter, &sub_iter);
+            break;
+        }
+        g_assert_not_reached();
+    }
+
+}
+#endif
+