static void
gupnp_didl_lite_create_class_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GUPnPDIDLLiteCreateClass *create_class;
create_class = GUPNP_DIDL_LITE_CREATE_CLASS (object);
switch (property_id) {
case PROP_XML_NODE:
g_value_set_pointer
(value,
gupnp_didl_lite_create_class_get_xml_node
(create_class));
break;
case PROP_CONTENT:
g_value_set_string
(value,
gupnp_didl_lite_create_class_get_content
(create_class));
break;
case PROP_INCLUDE_DERIVED:
g_value_set_boolean
(value,
gupnp_didl_lite_create_class_get_include_derived
(create_class));
break;
case PROP_FRIENDLY_NAME:
g_value_set_string
(value,
gupnp_didl_lite_create_class_get_friendly_name
(create_class));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
packet_list_get_value(GtkTreeModel *tree_model, GtkTreeIter *iter, gint column,
GValue *value)
{
PacketListRecord *record;
PacketList *packet_list;
GType type;
g_return_if_fail(PACKETLIST_IS_LIST(tree_model));
g_return_if_fail(iter != NULL);
packet_list = PACKET_LIST(tree_model);
/* Note: We use one extra column to store the entire PacketListRecord */
g_return_if_fail(column < packet_list->n_columns);
record = (PacketListRecord*) iter->user_data;
g_return_if_fail(PACKET_LIST_RECORD_INDEX_VALID(packet_list->physical_rows, record->physical_pos));
g_return_if_fail(PACKET_LIST_RECORD_INDEX_VALID(packet_list->visible_rows, record->visible_pos));
type = packet_list->column_types[column];
g_value_init(value, type);
/* XXX Probably the switch should be on column or
* should we allways return the pointer and read the data as required??
* If we use FOREGROUND_COLOR_COL etc we'll need a couple of "internal" columns
*/
switch(type){
case G_TYPE_POINTER:
g_value_set_pointer(value, record);
break;
case G_TYPE_STRING:
g_return_if_fail(record->fdata->col_text);
g_value_set_string(value, record->fdata->col_text[column]);
break;
default:
g_warning (G_STRLOC ": Unsupported type (%s) retrieved.", g_type_name (value->g_type));
break;
}
}
static void
gimp_operation_histogram_sink_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GimpOperationHistogramSink *sink = GIMP_OPERATION_HISTOGRAM_SINK (object);
switch (prop_id)
{
case PROP_AUX:
break;
case PROP_HISTOGRAM:
g_value_set_pointer (value, sink->histogram);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
message_queue_source_closure_callback (gpointer message,
gpointer user_data)
{
GClosure *closure = user_data;
GValue param_value = G_VALUE_INIT;
GValue result_value = G_VALUE_INIT;
gboolean retval;
/* The invoked function is responsible for freeing @message. */
g_value_init (&result_value, G_TYPE_BOOLEAN);
g_value_init (¶m_value, G_TYPE_POINTER);
g_value_set_pointer (¶m_value, message);
g_closure_invoke (closure, &result_value, 1, ¶m_value, NULL);
retval = g_value_get_boolean (&result_value);
g_value_unset (¶m_value);
g_value_unset (&result_value);
return retval;
}
static void
gupnp_white_list_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GUPnPWhiteList *list;
list = GUPNP_WHITE_LIST (object);
switch (property_id) {
case PROP_ENABLED:
g_value_set_boolean (value, list->priv->enabled);
break;
case PROP_ENTRIES:
g_value_set_pointer (value, list->priv->entries);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void gebr_gui_help_edit_window_get_property(GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GebrGuiHelpEditWindowPrivate * priv = GEBR_GUI_HELP_EDIT_WINDOW_GET_PRIVATE(object);
switch (prop_id) {
case PROP_HELP_EDIT_WIDGET:
g_value_set_pointer(value, priv->help_edit_widget);
break;
case PROP_AUTO_SAVE:
g_value_set_boolean(value, priv->auto_save);
break;
case PROP_HAS_MENU_BAR:
g_value_set_boolean(value, priv->has_menu_bar);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
gst_auto_convert_get_property (GObject * object,
guint prop_id, GValue * value, GParamSpec * pspec)
{
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (object);
switch (prop_id) {
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
case PROP_FACTORIES:
GST_AUTOCONVERT_LOCK (autoconvert);
g_value_set_pointer (value, &autoconvert->factories);
GST_AUTOCONVERT_UNLOCK (autoconvert);
break;
case PROP_INITIAL_IDENTITY:
GST_AUTOCONVERT_LOCK (autoconvert);
g_value_set_boolean (value, autoconvert->initial_identity);
GST_AUTOCONVERT_UNLOCK (autoconvert);
break;
}
}
static void
_vte_table_extract_string(GValueArray **array,
struct _vte_table_arginfo *arginfo)
{
GValue value = {0,};
gunichar *ptr;
guint i;
ptr = g_new(gunichar, arginfo->length + 1);
for (i = 0; i < arginfo->length; i++) {
ptr[i] = arginfo->start[i] & ~VTE_ISO2022_ENCODED_WIDTH_MASK;
}
ptr[i] = '\0';
g_value_init(&value, G_TYPE_POINTER);
g_value_set_pointer(&value, ptr);
if (G_UNLIKELY (*array == NULL)) {
*array = g_value_array_new(1);
}
g_value_array_append(*array, &value);
g_value_unset(&value);
}
static void
hippo_canvas_chat_preview_get_property(GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
HippoCanvasChatPreview *chat_preview;
chat_preview = HIPPO_CANVAS_CHAT_PREVIEW (object);
switch (prop_id) {
case PROP_ACTIONS:
g_value_set_object(value, (GObject*) chat_preview->actions);
break;
case PROP_BLOCK:
g_value_set_pointer(value, (GObject*) chat_preview->block);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GeglSampler *self = GEGL_SAMPLER (object);
switch (property_id)
{
case PROP_BUFFER:
g_value_set_object (value, self->buffer);
break;
case PROP_FORMAT:
g_value_set_pointer (value, (void*)self->format);
break;
default:
break;
}
}
static void
g_win32_output_stream_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GWin32OutputStream *win32_stream;
win32_stream = G_WIN32_OUTPUT_STREAM (object);
switch (prop_id)
{
case PROP_HANDLE:
g_value_set_pointer (value, win32_stream->priv->handle);
break;
case PROP_CLOSE_HANDLE:
g_value_set_boolean (value, win32_stream->priv->close_handle);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void async_callback_job_destructor(void *data_ptr)
{
async_call_data* data = data_ptr;
GList* cur_elt = data->extra;
while(cur_elt) {
GList * type_type_elt = cur_elt;
cur_elt = g_list_next(cur_elt);
//GList * type_elt = cur_elt;
cur_elt = g_list_next(cur_elt);
GList * data_elt = cur_elt;
cur_elt = g_list_next(cur_elt);
switch(GPOINTER_TO_INT(type_type_elt->data)) {
case LUA_ASYNC_TYPEID_WITH_FREE:
case LUA_ASYNC_TYPENAME_WITH_FREE:
{
GList *destructor_elt = cur_elt;
cur_elt = g_list_next(cur_elt);
GValue to_free = G_VALUE_INIT;
g_value_init(&to_free,G_TYPE_POINTER);
g_value_set_pointer(&to_free,data_elt->data);
g_closure_invoke(destructor_elt->data,NULL,1,&to_free,NULL);
g_closure_unref (destructor_elt->data);
}
break;
case LUA_ASYNC_TYPEID:
case LUA_ASYNC_TYPENAME:
break;
case LUA_ASYNC_DONE:
default:
// should never happen
printf("%d\n",GPOINTER_TO_INT(type_type_elt->data));
g_assert(false);
break;
}
}
g_list_free(data->extra);
free(data);
}
/*
* GObject property getter.
*/
static void
handle_map_entry_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
HandleMapEntry *self = HANDLE_MAP_ENTRY (object);
switch (property_id) {
case PROP_PHANDLE:
g_value_set_uint (value, (guint)self->phandle);
break;
case PROP_VHANDLE:
g_value_set_uint (value, (guint)self->vhandle);
break;
case PROP_CONTEXT:
g_value_set_pointer (value, &self->context);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
wnck_action_menu_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
WnckActionMenu *menu;
g_return_if_fail (WNCK_IS_ACTION_MENU (object));
menu = WNCK_ACTION_MENU (object);
switch (prop_id)
{
case PROP_WINDOW:
g_value_set_pointer (value, menu->priv->window);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
custom_list_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
gint column,
GValue *value)
{
CustomRecord *record;
CustomList *custom_list;
g_return_if_fail (CUSTOM_IS_LIST (tree_model));
g_return_if_fail (iter != NULL);
g_return_if_fail (column < CUSTOM_LIST(tree_model)->n_columns);
g_value_init (value, CUSTOM_LIST(tree_model)->column_types[column]);
custom_list = CUSTOM_LIST(tree_model);
record = (CustomRecord*) iter->user_data;
g_return_if_fail ( record != NULL );
if(record->pos >= custom_list->num_rows)
g_return_if_reached();
switch(column)
{
case CUSTOM_LIST_COL_RECORD:
g_value_set_pointer(value, record);
break;
case CUSTOM_LIST_COL_NAME:
g_value_set_string(value, record->name);
break;
case CUSTOM_LIST_COL_YEAR_BORN:
g_value_set_uint(value, record->year_born);
break;
}
}
static void
get_property (GObject *gobject,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GeglTileBackend *backend = GEGL_TILE_BACKEND (gobject);
switch (property_id)
{
case PROP_TILE_WIDTH:
g_value_set_int (value, backend->priv->tile_width);
break;
case PROP_TILE_HEIGHT:
g_value_set_int (value, backend->priv->tile_height);
break;
case PROP_TILE_SIZE:
g_value_set_int (value, backend->priv->tile_size);
break;
case PROP_PX_SIZE:
g_value_set_int (value, backend->priv->px_size);
break;
case PROP_FORMAT:
g_value_set_pointer (value, (void*)backend->priv->format);
break;
case PROP_FLUSH_ON_DESTROY:
g_value_set_boolean (value, backend->priv->flush_on_destroy);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, property_id, pspec);
break;
}
}
/*
* The getter.
*/
static void gqq_config_getter(GObject *object, guint property_id,
GValue *value, GParamSpec *pspec)
{
if(object == NULL || value == NULL || property_id < 0){
return;
}
g_debug("GQQConfig getter: %s (%s, %d)", pspec -> name, __FILE__, __LINE__);
GQQConfig *obj = G_TYPE_CHECK_INSTANCE_CAST(
object, gqq_config_get_type(), GQQConfig);
GQQConfigPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE(
obj, gqq_config_get_type(), GQQConfigPriv);
switch (property_id)
{
case GQQ_CONFIG_PROPERTY_INFO:
g_value_set_pointer(value, priv -> info);
break;
case GQQ_CONFIG_PROPERTY_PASSWD:
g_value_set_static_string(value, priv -> passwd -> str);
break;
case GQQ_CONFIG_PROPERTY_STATUS:
g_value_set_static_string(value, priv -> status -> str);
break;
case GQQ_CONFIG_PROPERTY_UIN:
g_value_set_static_string(value, priv -> qqnum -> str);
break;
case GQQ_CONFIG_PROPERTY_REMPW:
g_value_set_int(value, priv->rempw);
break;
case GQQ_CONFIG_PROPERTY_MUTE:
g_value_set_int(value, priv->mute);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
break;
}
}
static int bio_method_write(BIO *bio, const char *data, int size)
{
ErDtlsConnection *self = ER_DTLS_CONNECTION(bio->ptr);
LOG_LOG(self, "BIO: writing %d", size);
if (self->priv->send_closure) {
GValue values[3] = { G_VALUE_INIT };
g_value_init(&values[0], ER_TYPE_DTLS_CONNECTION);
g_value_set_object(&values[0], self);
g_value_init(&values[1], G_TYPE_POINTER);
g_value_set_pointer(&values[1], (gpointer) data);
g_value_init(&values[2], G_TYPE_INT);
g_value_set_int(&values[2], size);
g_closure_invoke(self->priv->send_closure, NULL, 3, values, NULL);
}
return size;
}
static void
shm_reader_get_property (GObject *object, guint property_id,
GValue *value, GParamSpec *pspec)
{
ShmReaderPrivate *priv = SHM_READER (object)->priv;
switch (property_id)
{
case PROP_CONTEXT:
if (priv->context != NULL)
g_main_context_ref (priv->context);
g_value_set_pointer (value, priv->context);
break;
case PROP_SOCKET_PATH:
g_value_set_string (value, priv->socket_path);
break;
case PROP_CONNECTED:
g_value_set_boolean (value, priv->connected);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
pseudo_tcp_socket_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
PseudoTcpSocket *self = PSEUDO_TCP_SOCKET (object);
switch (property_id) {
case PROP_CONVERSATION:
g_value_set_uint (value, self->priv->conv);
break;
case PROP_CALLBACKS:
g_value_set_pointer (value, (gpointer) &self->priv->callbacks);
break;
case PROP_STATE:
g_value_set_uint (value, self->priv->state);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
hippo_block_netflix_movie_get_property(GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
HippoBlockNetflixMovie *block_netflix = HIPPO_BLOCK_NETFLIX_MOVIE(object);
switch (prop_id) {
case PROP_DESCRIPTION:
g_value_set_string(value, block_netflix->description);
break;
case PROP_IMAGE_URL:
g_value_set_string(value, block_netflix->image_url);
break;
case PROP_QUEUE:
g_value_set_pointer(value, block_netflix->queue);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
hio_server_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
HioServer *hio_server;
hio_server = HIO_SERVER(object);
switch (prop_id) {
case PROP_PORT:
g_value_set_uint(value, hio_server->port);
break;
case PROP_MAIN_CONTEXT:
g_value_set_pointer(value, hio_server->main_context);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gda_tree_manager_get_property (GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec)
{
GdaTreeManager *manager;
manager = GDA_TREE_MANAGER (object);
if (manager->priv) {
switch (param_id) {
case PROP_RECURS:
g_value_set_boolean (value, manager->priv->recursive);
break;
case PROP_FUNC:
g_value_set_pointer (value, manager->priv->update_func);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
}
static void
gda_report_engine_get_property (GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec)
{
GdaReportEngine *eng;
eng = GDA_REPORT_ENGINE (object);
if (eng->priv) {
switch (param_id) {
case PROP_SPEC_NODE:
g_value_set_pointer (value, eng->priv->spec);
break;
case PROP_OUTPUT_DIR:
g_value_set_string (value, eng->priv->output_dir);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
}
static void
date_time_list_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
switch (property_id) {
case PROP_USE_24_HOUR_FORMAT:
g_value_set_boolean (
value,
e_date_time_list_get_use_24_hour_format (
E_DATE_TIME_LIST (object)));
return;
case PROP_TIMEZONE:
g_value_set_pointer (
value, e_date_time_list_get_timezone (
E_DATE_TIME_LIST (object)));
return;
}
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
static void
gnome_vfs_ace_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GnomeVFSACEPrivate *priv;
priv = GNOME_VFS_ACE (object)->priv;
switch (prop_id) {
case PROP_KIND:
g_value_set_uint (value, priv->kind);
break;
case PROP_ID:
g_value_set_string (value, priv->id);
break;
case PROP_PERMS:
g_value_set_pointer (value, priv->perm_set.perms);
break;
case PROP_INHERIT:
g_value_set_boolean (value, priv->inherit);
break;
case PROP_NEGATIVE:
g_value_set_boolean (value, priv->negative);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
/**
* ppg_task_render_set_property:
* @object: (in): A #GObject.
* @prop_id: (in): The property identifier.
* @value: (out): The given property.
* @pspec: (in): A #ParamSpec.
*
* Get a given #GObject property.
*/
static void
ppg_task_render_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
PpgTaskRender *render = PPG_TASK_RENDER(object);
switch (prop_id) {
case PROP_X:
g_value_set_double(value, render->priv->x);
break;
case PROP_Y:
g_value_set_double(value, render->priv->y);
break;
case PROP_WIDTH:
g_value_set_double(value, render->priv->width);
break;
case PROP_HEIGHT:
g_value_set_double(value, render->priv->height);
break;
case PROP_SEQUENCE:
g_value_set_int(value, render->priv->sequence);
break;
case PROP_SURFACE:
g_value_set_pointer(value, render->priv->surface);
break;
case PROP_BEGIN_TIME:
g_value_set_double(value, render->priv->begin_time);
break;
case PROP_END_TIME:
g_value_set_double(value, render->priv->end_time);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
}
}
/**
* GObject property getter.
*/
static void
tpm2_command_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
Tpm2Command *self = TPM2_COMMAND (object);
g_debug ("tpm2_command_get_property: 0x%" PRIxPTR, (uintptr_t)self);
switch (property_id) {
case PROP_ATTRIBUTES:
g_value_set_uint (value, self->attributes.val);
break;
case PROP_BUFFER:
g_value_set_pointer (value, self->buffer);
break;
case PROP_SESSION:
g_value_set_object (value, self->connection);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
void g_sql_result_get_property(GObject *object, guint property_id,GValue *value, GParamSpec *pspec)
{
GSQLResult * mobj = (GSQLResult*) object;
g_return_if_fail(IS_G_SQL_RESULT(mobj));
switch (property_id)
{
case G_SQL_RESULT_PROPERTY_TYPE:
g_value_set_gtype(value, mobj->connector_type);
break;
case G_SQL_RESULT_PROPERTY_TYPE_INSTANCE:
g_value_set_object(value, mobj->connector);
break;
case G_SQL_RESULT_PROPERTY_RESULT:
g_value_set_pointer(value, mobj->result);
break;
case G_SQL_RESULT_PROPERTY_FIELDS:
g_value_set_int(value,mobj->fields);
break;
default:
g_warn_if_reached();
break;
}
}
static void
gupnp_service_info_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GUPnPServiceInfo *info;
info = GUPNP_SERVICE_INFO (object);
switch (property_id) {
case PROP_CONTEXT:
g_value_set_object (value,
info->priv->context);
break;
case PROP_LOCATION:
g_value_set_string (value,
info->priv->location);
break;
case PROP_UDN:
g_value_set_string (value,
info->priv->udn);
break;
case PROP_SERVICE_TYPE:
g_value_set_string (value,
gupnp_service_info_get_service_type (info));
break;
case PROP_URL_BASE:
g_value_set_pointer (value,
info->priv->url_base);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
