static void
_update_entry(GHashTable *entry)
{
Elm_Object_Item *glit;
GVariant *val;
val = g_hash_table_lookup(entry, "_item_all");
if (val) {
glit = (Elm_Object_Item *)GINT_TO_POINTER(g_variant_get_int32(val));
elm_genlist_item_update(glit);
}
val = g_hash_table_lookup(entry, "_item_missed");
if (val) {
glit = (Elm_Object_Item *)GINT_TO_POINTER(g_variant_get_int32(val));
elm_genlist_item_update(glit);
}
val = g_hash_table_lookup(entry, "_item_in");
if (val) {
glit = (Elm_Object_Item *)GINT_TO_POINTER(g_variant_get_int32(val));
elm_genlist_item_update(glit);
}
val = g_hash_table_lookup(entry, "_item_out");
if (val) {
glit = (Elm_Object_Item *)GINT_TO_POINTER(g_variant_get_int32(val));
elm_genlist_item_update(glit);
}
}
static gdouble
_tp_variant_convert_double (GVariant *variant,
gboolean *valid)
{
*valid = TRUE;
switch (g_variant_classify (variant))
{
case G_VARIANT_CLASS_DOUBLE:
return g_variant_get_double (variant);
case G_VARIANT_CLASS_BYTE:
return g_variant_get_byte (variant);
case G_VARIANT_CLASS_UINT32:
return g_variant_get_uint32 (variant);
case G_VARIANT_CLASS_INT32:
return g_variant_get_int32 (variant);
case G_VARIANT_CLASS_INT64:
return g_variant_get_int64 (variant);
case G_VARIANT_CLASS_UINT64:
return g_variant_get_uint64 (variant);
default:
break;
}
*valid = FALSE;
return 0.0;
}
void
ibus_rime_load_settings(IBusConfig* config)
{
//g_debug("ibus_rime_load_settings");
GVariant* value;
value = ibus_config_get_value(config, "engine/Rime", "embed_preedit_text");
if (!value) {
value = ibus_config_get_value(config, "general", "embed_preedit_text");
}
if (value && g_variant_classify(value) == G_VARIANT_CLASS_BOOLEAN) {
g_ibus_rime_settings.embed_preedit_text = g_variant_get_boolean(value);
}
value = ibus_config_get_value(config, "engine/Rime", "lookup_table_orientation");
if (!value) {
value = ibus_config_get_value(config, "panel", "lookup_table_orientation");
}
if (value && g_variant_classify(value) == G_VARIANT_CLASS_INT32) {
g_ibus_rime_settings.lookup_table_orientation = g_variant_get_int32(value);
}
value = ibus_config_get_value(config, "engine/Rime", "color_scheme");
if (value && g_variant_classify(value) == G_VARIANT_CLASS_STRING) {
ibus_rime_select_color_scheme(g_variant_get_string(value, NULL));
}
}
static void
font_size_action_ativated (GSimpleAction *action,
GVariant *parameter,
gpointer userdata)
{
VteTerminal *vtterm = window_get_term_widget (GTK_WINDOW (userdata));
const gint modifier = g_variant_get_int32 (parameter);
const PangoFontDescription *fontd = vte_terminal_get_font (vtterm);
gint old_size = pango_font_description_get_size (fontd);
if (default_font_size == 0)
default_font_size = old_size;
PangoFontDescription *new_fontd;
gint new_size;
switch (modifier) {
case 0:
old_size = default_font_size;
/* fall-through */
case 1:
case -1:
new_size = old_size + modifier * PANGO_SCALE;
new_fontd = pango_font_description_copy_static (fontd);
pango_font_description_set_size (new_fontd, new_size);
vte_terminal_set_font (vtterm, new_fontd);
break;
default:
g_printerr ("%s: invalid modifier '%i'", __func__, modifier);
return;
}
pango_font_description_free (new_fontd);
}
gint
go_conf_load_int (GOConfNode *node, gchar const *key, gint minima, gint maxima, gint default_val)
{
gint res = -1;
GVariant *val = NULL;
if (node) {
if (key && !strchr (key, '/') && !strchr (key, '.'))
val = go_conf_get (node, key, G_VARIANT_TYPE_INT32);
else if (node->key)
val = go_conf_get (node, node->key, G_VARIANT_TYPE_INT32);
}
if (val == NULL) {
GOConfNode *real_node = go_conf_get_node (node, key);
val = real_node? go_conf_get (real_node, real_node->key, G_VARIANT_TYPE_INT32): NULL;
go_conf_free_node (real_node);
}
if (val != NULL) {
res = g_variant_get_int32 (val);
g_variant_unref (val);
if (res < minima || maxima < res) {
g_warning ("Invalid value '%d' for %s. If should be >= %d and <= %d",
res, key, minima, maxima);
val = NULL;
}
} else {
d (g_warning ("Using default value '%d'", default_val));
return default_val;
}
return res;
}
static void
ibus_config_value_changed (IBusConfig *config,
const gchar *section,
const gchar *name,
GVariant *value,
gpointer user_data)
{
IBusHangulEngine *hangul = (IBusHangulEngine *) user_data;
if (strcmp(section, "engine/Hangul") == 0) {
if (strcmp(name, "HangulKeyboard") == 0) {
const gchar *str = g_variant_get_string(value, NULL);
g_string_assign (hangul_keyboard, str);
hangul_ic_select_keyboard (hangul->context, hangul_keyboard->str);
} else if (strcmp(name, "HanjaKeys") == 0) {
const gchar* str = g_variant_get_string(value, NULL);
hanja_key_list_set_from_string(&hanja_keys, str);
} else if (strcmp(name, "WordCommit") == 0) {
word_commit = g_variant_get_boolean (value);
} else if (strcmp (name, "AutoReorder") == 0) {
auto_reorder = g_variant_get_boolean (value);
}
} else if (strcmp(section, "panel") == 0) {
if (strcmp(name, "lookup_table_orientation") == 0) {
lookup_table_orientation = g_variant_get_int32(value);
}
}
}
static void
load_choice (GVariant *values,
GtkComboBox *combo,
const gchar *name,
gint defval)
{
GVariant *value;
gint ivalue, index;
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo),
renderer, "text", 0, NULL);
ivalue = defval;
value = g_variant_lookup_value (values, name, G_VARIANT_TYPE_INT32);
if (value != NULL) {
ivalue = g_variant_get_int32 (value);
g_variant_unref (value);
}
index = get_combo_box_index_by_value (GTK_COMBO_BOX (combo), ivalue);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), index);
}
GstState gstd_pipeline_get_state(GDBusProxy *pipeline_proxy)
{
GError *error = NULL;
GVariant *variant = NULL;
GstState state = GST_STATE_NULL;
variant = g_dbus_proxy_call_sync(pipeline_proxy,
"PipelineGetState",
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (error) {
g_printerr("g_dbus_proxy_new_for_bus_sync failed: %s\n", error->message);
return GST_STATE_NULL;
}
if (!g_strcmp0(g_variant_get_type_string(variant), "(i)")) {
GVariant * temp_variant = g_variant_get_child_value(variant, 0);
state = g_variant_get_int32(temp_variant);
g_variant_unref(temp_variant);
}
g_variant_unref(variant);
return state;
}
static gint64
_tp_variant_convert_int64 (GVariant *variant,
gboolean *valid)
{
guint64 u;
*valid = TRUE;
switch (g_variant_classify (variant))
{
case G_VARIANT_CLASS_BYTE:
return g_variant_get_byte (variant);
case G_VARIANT_CLASS_UINT32:
return g_variant_get_uint32 (variant);
case G_VARIANT_CLASS_INT32:
return g_variant_get_int32 (variant);
case G_VARIANT_CLASS_INT64:
return g_variant_get_int64 (variant);
case G_VARIANT_CLASS_UINT64:
u = g_variant_get_uint64 (variant);
if (G_LIKELY (u <= G_MAXINT64))
return u;
break;
default:
break;
}
*valid = FALSE;
return 0;
}
/**
* json_gvariant_serialize:
* @variant: A #GVariant to convert
*
* Converts @variant to a JSON tree.
*
* Return value: (transfer full): A #JsonNode representing the root of the
* JSON data structure obtained from @variant
*
* Since: 0.14
*/
JsonNode *
json_gvariant_serialize (GVariant *variant)
{
JsonNode *json_node = NULL;
GVariantClass class;
g_return_val_if_fail (variant != NULL, NULL);
class = g_variant_classify (variant);
if (! g_variant_is_container (variant))
{
json_node = json_node_new (JSON_NODE_VALUE);
switch (class)
{
case G_VARIANT_CLASS_BOOLEAN:
json_node_set_boolean (json_node, g_variant_get_boolean (variant));
break;
case G_VARIANT_CLASS_BYTE:
json_node_set_int (json_node, g_variant_get_byte (variant));
break;
case G_VARIANT_CLASS_INT16:
json_node_set_int (json_node, g_variant_get_int16 (variant));
break;
case G_VARIANT_CLASS_UINT16:
json_node_set_int (json_node, g_variant_get_uint16 (variant));
break;
case G_VARIANT_CLASS_INT32:
json_node_set_int (json_node, g_variant_get_int32 (variant));
break;
case G_VARIANT_CLASS_UINT32:
json_node_set_int (json_node, g_variant_get_uint32 (variant));
break;
case G_VARIANT_CLASS_INT64:
json_node_set_int (json_node, g_variant_get_int64 (variant));
break;
case G_VARIANT_CLASS_UINT64:
json_node_set_int (json_node, g_variant_get_uint64 (variant));
break;
case G_VARIANT_CLASS_HANDLE:
json_node_set_int (json_node, g_variant_get_handle (variant));
break;
case G_VARIANT_CLASS_DOUBLE:
json_node_set_double (json_node, g_variant_get_double (variant));
break;
case G_VARIANT_CLASS_STRING:
case G_VARIANT_CLASS_OBJECT_PATH:
case G_VARIANT_CLASS_SIGNATURE:
json_node_set_string (json_node, g_variant_get_string (variant, NULL));
break;
default:
break;
}
}
void
ibus_rime_config_value_changed_cb(IBusConfig* config,
const gchar* section,
const gchar* name,
GVariant* value,
gpointer unused)
{
//g_debug("ibus_rime_config_value_changed_cb [%s/%s]", section, name);
if (!strcmp("general", section)) {
if (!strcmp("embed_preedit_text", name) &&
value && g_variant_classify(value) == G_VARIANT_CLASS_BOOLEAN) {
g_ibus_rime_settings.embed_preedit_text = g_variant_get_boolean(value);
return;
}
}
else if (!strcmp("panel", section)) {
if (!strcmp("lookup_table_orientation", name) &&
value && g_variant_classify(value) == G_VARIANT_CLASS_INT32) {
g_ibus_rime_settings.lookup_table_orientation = g_variant_get_int32(value);
return;
}
}
else if (!strcmp("engine/Rime", section)) {
if (!strcmp("embed_preedit_text", name) &&
value && g_variant_classify(value) == G_VARIANT_CLASS_BOOLEAN) {
GVariant* overridden = ibus_config_get_value(config, "engine/Rime", "embed_preedit_text");
if (!overridden) {
g_ibus_rime_settings.embed_preedit_text = g_variant_get_boolean(value);
}
return;
}
if (!strcmp("lookup_table_orientation", name) &&
value && g_variant_classify(value) == G_VARIANT_CLASS_INT32) {
GVariant* overridden = ibus_config_get_value(config, "engine/Rime", "lookup_table_orientation");
if (!overridden) {
g_ibus_rime_settings.lookup_table_orientation = g_variant_get_int32(value);
}
return;
}
if (!strcmp("color_scheme", name) &&
value && g_variant_classify(value) == G_VARIANT_CLASS_STRING) {
ibus_rime_select_color_scheme(g_variant_get_string(value, NULL));
return;
}
}
}
static Eina_Bool
gl_state_get(void *data, Evas_Object * obj, const char *part)
{
(void) obj;
(void) part;
GHashTable *entry = (GHashTable *) data;
GVariant *tmp = g_hash_table_lookup(entry, "Direction");
if (tmp && g_variant_get_int32(tmp))
return (EINA_TRUE);
return (EINA_FALSE);
}
/* --- genlist callbacks --- */
static char *
gl_text_get(void *data, Evas_Object * obj, const char *part)
{
(void) obj;
GHashTable *entry = (GHashTable *) data;
GVariant *val;
g_debug("gl_text_get: %s", part);
if (!strcmp(part, "elm.text")) {
val = g_hash_table_lookup(entry, "Name");
if (val) {
return g_variant_dup_string(val, NULL);
}
return strdup("");
}
if (!strcmp(part, "elm.text.sub")) {
val = g_hash_table_lookup(entry, "Peer");
if (val) {
return g_variant_dup_string(val, NULL);
}
return strdup(CONTACT_PHONE_UNDEFINED_STRING);
}
if (!strcmp(part, "elm.text.2")) {
val = g_hash_table_lookup(entry, "Timestamp");
if (val) {
return common_utils_timestamp_to_date
(g_variant_get_int32(val));
}
}
if (!strcmp(part, "elm.text.sub.2")) {
val = g_hash_table_lookup(entry, "Duration");
if (val) {
float duration = strtof(g_variant_get_string(val, NULL), NULL);
int h = duration / 3600;
int m = duration / 60 - h * 60;
int s = duration - h * 3600 - m * 60;
char durstr[10];
if (h > 0) {
snprintf(durstr, 10, "%02d:%02d:%02d", h, m, s);
}
else {
snprintf(durstr, 10, "%02d:%02d", m, s);
}
return strdup(durstr);
}
return strdup("00:00");
}
return strdup("");
}
static gboolean
check_single_value_range(GVariant *value,
GVariant *range_min,
GVariant *range_max)
{
if (range_min) {
if (!g_variant_is_of_type(range_min, G_VARIANT_TYPE_INT32) ||
g_variant_get_int32(range_min) > g_variant_get_int32(value)) {
return FALSE;
}
}
if (range_max) {
if (!g_variant_is_of_type(range_max, G_VARIANT_TYPE_INT32) ||
g_variant_get_int32(range_max) < g_variant_get_int32(value)) {
return FALSE;
}
}
return TRUE;
}
static GError *
_stmt_apply_GV_parameter_simple(sqlite3_stmt *stmt, int pos, GVariant *p)
{
int rc;
gsize slen = 0;
const gchar *s;
switch (*((gchar*)g_variant_get_type(p))) {
case 'b':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_boolean(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 'i':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_int32(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 'n':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_int16(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 'q':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_uint16(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 's':
s = g_variant_get_string(p, &slen);
rc = sqlite3_bind_text(stmt, pos, s, slen, NULL);
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 't':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_uint64(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 'u':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_uint32(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 'x':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_int64(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 'y':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_byte(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
/* XXX TODO manage the G_VARIANT_UNIT associtaed to NULL'd fields */
default:
return NEWERROR(CODE_BAD_REQUEST, "Unexpected parameter at position %d ('%s')",
pos, (gchar*)g_variant_get_type(p));
}
(void) rc;
}
static void
fwupd_remote_set_from_variant_iter (FwupdRemote *self, GVariantIter *iter)
{
FwupdRemotePrivate *priv = GET_PRIVATE (self);
GVariant *value;
const gchar *key;
g_autoptr(GVariantIter) iter2 = g_variant_iter_copy (iter);
g_autoptr(GVariantIter) iter3 = g_variant_iter_copy (iter);
/* three passes, as we have to construct Id -> Url -> * */
while (g_variant_iter_loop (iter, "{sv}", &key, &value)) {
if (g_strcmp0 (key, FWUPD_RESULT_KEY_REMOTE_ID) == 0)
fwupd_remote_set_id (self, g_variant_get_string (value, NULL));
if (g_strcmp0 (key, "Type") == 0)
fwupd_remote_set_kind (self, g_variant_get_uint32 (value));
if (g_strcmp0 (key, "Keyring") == 0)
fwupd_remote_set_keyring_kind (self, g_variant_get_uint32 (value));
}
while (g_variant_iter_loop (iter2, "{sv}", &key, &value)) {
if (g_strcmp0 (key, FWUPD_RESULT_KEY_URI) == 0)
fwupd_remote_set_metadata_uri (self, g_variant_get_string (value, NULL));
if (g_strcmp0 (key, "FilenameCache") == 0)
fwupd_remote_set_filename_cache (self, g_variant_get_string (value, NULL));
if (g_strcmp0 (key, "FilenameSource") == 0)
fwupd_remote_set_filename_source (self, g_variant_get_string (value, NULL));
if (g_strcmp0 (key, "ReportUri") == 0)
fwupd_remote_set_report_uri (self, g_variant_get_string (value, NULL));
}
while (g_variant_iter_loop (iter3, "{sv}", &key, &value)) {
if (g_strcmp0 (key, "Username") == 0) {
fwupd_remote_set_username (self, g_variant_get_string (value, NULL));
} else if (g_strcmp0 (key, "Password") == 0) {
fwupd_remote_set_password (self, g_variant_get_string (value, NULL));
} else if (g_strcmp0 (key, "Title") == 0) {
fwupd_remote_set_title (self, g_variant_get_string (value, NULL));
} else if (g_strcmp0 (key, "Agreement") == 0) {
fwupd_remote_set_agreement (self, g_variant_get_string (value, NULL));
} else if (g_strcmp0 (key, FWUPD_RESULT_KEY_CHECKSUM) == 0) {
fwupd_remote_set_checksum (self, g_variant_get_string (value, NULL));
} else if (g_strcmp0 (key, "Enabled") == 0) {
priv->enabled = g_variant_get_boolean (value);
} else if (g_strcmp0 (key, "ApprovalRequired") == 0) {
priv->approval_required = g_variant_get_boolean (value);
} else if (g_strcmp0 (key, "Priority") == 0) {
priv->priority = g_variant_get_int32 (value);
} else if (g_strcmp0 (key, "ModificationTime") == 0) {
priv->mtime = g_variant_get_uint64 (value);
} else if (g_strcmp0 (key, "FirmwareBaseUri") == 0) {
fwupd_remote_set_firmware_base_uri (self, g_variant_get_string (value, NULL));
}
}
}
void
prop_set_from_gvariant(GVariant *v, prop_t *p)
{
const GVariantType *T = g_variant_get_type(v);
if(g_variant_type_equal(T, G_VARIANT_TYPE_BOOLEAN)) {
prop_set_int(p, g_variant_get_boolean(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_BYTE)) {
prop_set_int(p, g_variant_get_byte(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_INT16)) {
prop_set_int(p, g_variant_get_int16(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_UINT16)) {
prop_set_int(p, g_variant_get_uint16(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_INT32)) {
prop_set_int(p, g_variant_get_int32(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_UINT32)) {
prop_set_int(p, g_variant_get_uint32(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_INT64)) {
int64_t val = g_variant_get_int64(v);
if(val <= INT_MAX)
prop_set_int(p, val);
else
prop_set_float(p, val);
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_UINT64)) {
uint64_t val = g_variant_get_uint64(v);
if(val <= INT_MAX)
prop_set_int(p, val);
else
prop_set_float(p, val);
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_STRING) ||
g_variant_type_equal(T, G_VARIANT_TYPE_OBJECT_PATH) ||
g_variant_type_equal(T, G_VARIANT_TYPE_SIGNATURE)) {
const gchar *val = g_variant_get_string(v, NULL);
prop_set_string(p, val);
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_VARDICT)) {
prop_void_childs(p);
prop_set_from_vardict(v, p);
} else if(g_variant_type_is_array(T)) {
int num = g_variant_n_children(v);
prop_destroy_childs(p);
for(int i = 0; i < num; i++) {
prop_set_from_gvariant(g_variant_get_child_value(v, i),
prop_create(p, NULL));
}
} else {
fprintf(stderr,
"%s(): can't deal with type %s\n",
__FUNCTION__, g_variant_get_type_string(v));
}
}
QVariant gvariantToQVariant(GVariant *value)
{
GVariantClass c = g_variant_classify(value);
if(c == G_VARIANT_CLASS_BOOLEAN)
return QVariant((bool) g_variant_get_boolean(value));
else if(c == G_VARIANT_CLASS_BYTE)
return QVariant((char) g_variant_get_byte(value));
else if(c == G_VARIANT_CLASS_INT16)
return QVariant((int) g_variant_get_int16(value));
else if(c == G_VARIANT_CLASS_UINT16)
return QVariant((unsigned int) g_variant_get_uint16(value));
else if(c == G_VARIANT_CLASS_INT32)
return QVariant((int) g_variant_get_int32(value));
else if(c == G_VARIANT_CLASS_UINT32)
return QVariant((unsigned int) g_variant_get_uint32(value));
else if(c == G_VARIANT_CLASS_INT64)
return QVariant((long long) g_variant_get_int64(value));
else if(c == G_VARIANT_CLASS_UINT64)
return QVariant((unsigned long long) g_variant_get_uint64(value));
else if(c == G_VARIANT_CLASS_DOUBLE)
return QVariant(g_variant_get_double(value));
else if(c == G_VARIANT_CLASS_STRING)
return QVariant(g_variant_get_string(value, NULL));
else if(c == G_VARIANT_CLASS_ARRAY)
{
gsize dictsize = g_variant_n_children(value);
QVariantList list;
for (int i=0;i<dictsize;i++)
{
GVariant *childvariant = g_variant_get_child_value(value,i);
GVariant *innervariant = g_variant_get_variant(childvariant);
list.append(gvariantToQVariant(innervariant));
}
return list;
}
else
return QVariant::Invalid;
}
static void
set_tab_state (GSimpleAction *action,
GVariant *state,
gpointer user_data)
{
PnlTabStrip *self = user_data;
PnlTabStripPrivate *priv = pnl_tab_strip_get_instance_private (self);
PnlTab *tab = NULL;
const GList *iter;
GList *list;
gint stateval;
g_assert (G_IS_SIMPLE_ACTION (action));
g_assert (PNL_IS_TAB_STRIP (self));
g_assert (state != NULL);
g_assert (g_variant_is_of_type (state, G_VARIANT_TYPE_INT32));
g_simple_action_set_state (action, state);
stateval = g_variant_get_int32 (state);
list = gtk_container_get_children (GTK_CONTAINER (priv->stack));
for (iter = list; iter != NULL; iter = iter->next)
{
GtkWidget *child = iter->data;
gint position = 0;
gtk_container_child_get (GTK_CONTAINER (priv->stack), GTK_WIDGET (child),
"position", &position,
NULL);
if (position == stateval)
{
tab = g_object_get_data (G_OBJECT (child), "PNL_TAB");
gtk_stack_set_visible_child (priv->stack, child);
break;
}
}
/*
* When clicking an active toggle button, we get the state callback but then
* the toggle button disables the checked state. So ensure it stays on by
* manually setting the state.
*/
if (PNL_IS_TAB (tab))
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tab), TRUE);
g_list_free (list);
}
static void
ide_workbench_actions_opacity (GSimpleAction *action,
GVariant *variant,
gpointer user_data)
{
IdeWorkbench *workbench = user_data;
gdouble opacity;
g_assert (IDE_IS_WORKBENCH (workbench));
g_assert (g_variant_is_of_type (variant, G_VARIANT_TYPE_INT32));
opacity = CLAMP (g_variant_get_int32 (variant), 10, 100) / 100.0;
gtk_widget_set_opacity (GTK_WIDGET (workbench), opacity);
}
void
nautilus_toolbar_reset_menus (NautilusToolbar *self)
{
NautilusWindowSlot *slot;
NautilusView *view;
GActionGroup *view_action_group;
GVariant *variant;
GVariantIter iter;
gboolean show_sort_trash, show_sort_search, show_sort_access, show_sort_modification, enable_sort;
const gchar *hint;
/* Allow actions from the current view to be activated through
* the view menu and action menu of the toolbar */
slot = nautilus_window_get_active_slot (self->priv->window);
view = nautilus_window_slot_get_current_view (slot);
view_action_group = nautilus_view_get_action_group (view);
gtk_widget_insert_action_group (GTK_WIDGET (self),
"view",
G_ACTION_GROUP (view_action_group));
gtk_widget_set_visible (self->priv->visible_columns,
g_action_group_has_action (view_action_group, "visible-columns"));
enable_sort = g_action_group_get_action_enabled (view_action_group, "sort");
show_sort_trash = show_sort_search = show_sort_modification = show_sort_access = FALSE;
gtk_widget_set_visible (self->priv->sort_menu, enable_sort);
if (enable_sort) {
variant = g_action_group_get_action_state_hint (view_action_group, "sort");
g_variant_iter_init (&iter, variant);
while (g_variant_iter_next (&iter, "&s", &hint)) {
if (g_strcmp0 (hint, "trash-time") == 0)
show_sort_trash = TRUE;
if (g_strcmp0 (hint, "search-relevance") == 0)
show_sort_search = TRUE;
}
g_variant_unref (variant);
}
gtk_widget_set_visible (self->priv->sort_trash_time, show_sort_trash);
gtk_widget_set_visible (self->priv->sort_search_relevance, show_sort_search);
variant = g_action_group_get_action_state (view_action_group, "zoom-to-level");
gtk_adjustment_set_value (self->priv->zoom_adjustment,
g_variant_get_int32 (variant));
g_variant_unref (variant);
}
std::string StringFromVariant(GVariant* variant)
{
std::stringstream ss;
const GVariantType* info_hint_type = g_variant_get_type(variant);
if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_BOOLEAN))
{
ss << g_variant_get_int16(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_INT16))
{
ss << g_variant_get_int16(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_UINT16))
{
ss << g_variant_get_uint16(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_INT32))
{
ss << g_variant_get_int32(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_UINT32))
{
ss << g_variant_get_uint32(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_INT64))
{
ss << g_variant_get_int64(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_UINT64))
{
ss << g_variant_get_uint64(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_DOUBLE))
{
ss << g_variant_get_double(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_STRING))
{
std::string str = g_variant_get_string(variant, NULL);
ss << str;
}
else
{
ss << "unknown value";
}
return ss.str();
}
void*
common_utils_pointer_from_variant(GVariant* val)
{
gint i;
if (sizeof(gint) == sizeof(gint64)) {
i = g_variant_get_int64(val);
}
else if (sizeof(gint) == sizeof(gint32)) {
i = g_variant_get_int32(val);
}
else {
i = g_variant_get_int16(val);
}
return GINT_TO_POINTER(i);
}
static gboolean
variant_as_uint64 (GVariant *v, GVariantClass v_class, guint64 *as_uint)
{
gint64 i64;
switch (v_class)
{
case G_VARIANT_CLASS_BYTE:
*as_uint = (gint64) g_variant_get_byte (v);
return TRUE;
case G_VARIANT_CLASS_UINT16:
*as_uint = g_variant_get_uint16 (v);
return TRUE;
case G_VARIANT_CLASS_UINT32:
*as_uint = g_variant_get_uint32 (v);
return TRUE;
case G_VARIANT_CLASS_UINT64:
*as_uint = g_variant_get_uint64 (v);
return FALSE;
case G_VARIANT_CLASS_INT16:
i64 = g_variant_get_int16 (v);
if (i64 > 0)
{
*as_uint = i64;
return TRUE;
}
return FALSE;
case G_VARIANT_CLASS_INT32:
i64 = g_variant_get_int32 (v);
if (i64 > 0)
{
*as_uint = i64;
return TRUE;
}
return FALSE;
case G_VARIANT_CLASS_INT64:
i64 = g_variant_get_int64 (v);
if (i64 > 0)
{
*as_uint = i64;
return TRUE;
}
return FALSE;
default:
return FALSE;
}
}
static gboolean
g_settings_get_mapping_int (GValue *value,
GVariant *variant)
{
const GVariantType *type;
gint64 l;
type = g_variant_get_type (variant);
if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16))
l = g_variant_get_int16 (variant);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
l = g_variant_get_int32 (variant);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64))
l = g_variant_get_int64 (variant);
else
return FALSE;
if (G_VALUE_HOLDS_INT (value))
{
g_value_set_int (value, l);
return (G_MININT32 <= l && l <= G_MAXINT32);
}
else if (G_VALUE_HOLDS_UINT (value))
{
g_value_set_uint (value, l);
return (0 <= l && l <= G_MAXUINT32);
}
else if (G_VALUE_HOLDS_INT64 (value))
{
g_value_set_int64 (value, l);
return (G_MININT64 <= l && l <= G_MAXINT64);
}
else if (G_VALUE_HOLDS_UINT64 (value))
{
g_value_set_uint64 (value, l);
return (0 <= l && l <= G_MAXUINT64);
}
else if (G_VALUE_HOLDS_DOUBLE (value))
{
g_value_set_double (value, l);
return TRUE;
}
return FALSE;
}
/**
* defkey_cb
* @widget: widget
* @data: callback data
*
* Description:
* handles message from the default key buttons
**/
static void
defkey_cb (GtkWidget * widget, gpointer data)
{
gint i;
for (i = 0; i < N_KEYS; ++i) {
GVariant *variant;
char buffer[64];
g_snprintf (buffer, sizeof (buffer), KEY_CONTROL_KEY, i);
g_settings_reset (settings, buffer);
variant = g_settings_get_default_value (settings, buffer);
properties.keys[i] = g_variant_get_int32 (variant);
g_variant_unref (variant);
}
keyboard_set (properties.keys);
}
static void
on_activate_priority (GSimpleAction *action, GVariant *parameter, gpointer data)
{
GsmApplication *app = (GsmApplication *) data;
g_action_change_state (G_ACTION (action), parameter);
const gint32 priority = g_variant_get_int32 (parameter);
switch (priority) {
case 32:
procdialog_create_renice_dialog (app);
break;
default:
renice (app, priority);
break;
}
}
static void
on_activate_send_signal (GSimpleAction *, GVariant *parameter, gpointer data)
{
GsmApplication *app = (GsmApplication *) data;
/* no confirmation */
gint32 signal = g_variant_get_int32(parameter);
switch (signal) {
case SIGCONT:
kill_process (app, signal);
break;
case SIGSTOP:
case SIGTERM:
case SIGKILL:
kill_process_with_confirmation (app, signal);
break;
}
}
NS_IMETHODIMP
nsGSettingsCollection::GetInt(const nsACString& aKey,
PRInt32* aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
if (!KeyExists(aKey))
return NS_ERROR_INVALID_ARG;
GVariant *value = g_settings_get_value(mSettings,
PromiseFlatCString(aKey).get());
if (!g_variant_is_of_type(value, G_VARIANT_TYPE_INT32)) {
g_variant_unref(value);
return NS_ERROR_FAILURE;
}
*aResult = g_variant_get_int32(value);
g_variant_unref(value);
return NS_OK;
}
static int init(struct sr_input *in, GHashTable *options)
{
struct context *inc;
int num_channels;
char channelname[8];
const char *format;
int fmt_index;
num_channels = g_variant_get_int32(g_hash_table_lookup(options, "numchannels"));
if (num_channels < 1) {
sr_err("Invalid value for numchannels: must be at least 1.");
return SR_ERR_ARG;
}
format = g_variant_get_string(g_hash_table_lookup(options, "format"), NULL);
if ((fmt_index = parse_format_string(format)) == -1) {
GString *formats = g_string_sized_new(200);
for (unsigned int i = 0; i < ARRAY_SIZE(sample_formats); i++)
g_string_append_printf(formats, "%s ", sample_formats[i].fmt_name);
sr_err("Invalid format '%s': must be one of: %s.",
format, formats->str);
g_string_free(formats, TRUE);
return SR_ERR_ARG;
}
in->sdi = g_malloc0(sizeof(struct sr_dev_inst));
in->priv = inc = g_malloc0(sizeof(struct context));
for (int i = 0; i < num_channels; i++) {
snprintf(channelname, 8, "CH%d", i + 1);
sr_channel_new(in->sdi, i, SR_CHANNEL_ANALOG, TRUE, channelname);
}
inc->samplerate = g_variant_get_uint64(g_hash_table_lookup(options, "samplerate"));
inc->samplesize = sample_formats[fmt_index].encoding.unitsize * num_channels;
init_context(inc, &sample_formats[fmt_index], in->sdi->channels);
return SR_OK;
}
