static void gimp_plug_in_procedure_execute_async (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, GValueArray *args, GimpObject *display) { GimpPlugInProcedure *plug_in_procedure = GIMP_PLUG_IN_PROCEDURE (procedure); GValueArray *return_vals; return_vals = gimp_plug_in_manager_call_run (gimp->plug_in_manager, context, progress, plug_in_procedure, args, FALSE, display); if (return_vals) { gimp_plug_in_procedure_handle_return_values (plug_in_procedure, gimp, progress, return_vals); g_value_array_free (return_vals); } }
static void about_set_authors (GladeXML *xml, GtkWidget *w, const char *name, const char *value) { char **authors; GValueArray *authors_array; int i; authors = g_strsplit (value, "\n", 0); authors_array = g_value_array_new (0); for (i = 0; authors[i] != NULL; i++) { GValue value = { 0 }; g_value_init (&value, G_TYPE_STRING); g_value_set_static_string (&value, authors[i]); authors_array = g_value_array_append (authors_array, &value); } g_object_set (G_OBJECT (w), "authors", authors_array, NULL); g_value_array_free (authors_array); g_strfreev (authors); }
static void do_echo (SoupMessage *msg, GValueArray *params) { int i; const char *val; GValueArray *in, *out; if (!soup_value_array_get_nth (params, 0, G_TYPE_VALUE_ARRAY, &in)) { type_error (msg, G_TYPE_VALUE_ARRAY, params, 0); return; } out = g_value_array_new (in->n_values); for (i = 0; i < in->n_values; i++) { if (!soup_value_array_get_nth (in, i, G_TYPE_STRING, &val)) { type_error (msg, G_TYPE_STRING, in, i); return; } soup_value_array_append (out, G_TYPE_STRING, val); } soup_xmlrpc_set_response (msg, G_TYPE_VALUE_ARRAY, out); g_value_array_free (out); }
static void gst_audio_mixer_filter_probe_feature (GstAudioMixerFilterFunc filter_func, GstElementFactory * factory, GList ** p_collection, gboolean first, gpointer user_data) { GstElement *element; GST_DEBUG ("probing %s ...", gst_element_factory_get_longname (factory)); /* create element */ element = gst_element_factory_create (factory, NULL); if (element == NULL) { GST_DEBUG ("could not create element from factory"); return; } GST_DEBUG ("created element %s (%p)", GST_ELEMENT_NAME (element), element); if (GST_IS_PROPERTY_PROBE (element)) { GstPropertyProbe *probe; const GParamSpec *devspec; probe = GST_PROPERTY_PROBE (element); GST_DEBUG ("probing available devices ..."); if ((devspec = gst_property_probe_get_property (probe, "device"))) { GValueArray *array; if ((array = gst_property_probe_probe_and_get_values (probe, devspec))) { guint n; GST_DEBUG ("there are %d available devices", array->n_values); /* set all devices and test for mixer */ for (n = 0; n < array->n_values; n++) { GValue *device; /* set this device */ device = g_value_array_get_nth (array, n); g_object_set_property (G_OBJECT (element), "device", device); GST_DEBUG ("trying device %s ..", g_value_get_string (device)); if (gst_audio_mixer_filter_check_element (element)) { gst_audio_mixer_filter_do_filter (filter_func, factory, &element, p_collection, user_data); if (first && *p_collection != NULL) { GST_DEBUG ("Stopping after first found mixer, as requested"); break; } } } g_value_array_free (array); } } } else { GST_DEBUG ("element does not support the property probe interface"); if (gst_audio_mixer_filter_check_element (element)) { gst_audio_mixer_filter_do_filter (filter_func, factory, &element, p_collection, user_data); } } if (element) { gst_element_set_state (element, GST_STATE_NULL); gst_object_unref (element); } }
static GPtrArray * read_ip6_addresses (GKeyFile *file, const char *setting_name, const char *key) { GPtrArray *addresses; struct in6_addr addr, gw; guint32 prefix; int i = 0; addresses = g_ptr_array_sized_new (3); /* Look for individual addresses */ while (i++ < 1000) { char *tmp, *key_name, *str_prefix, *str_gw; int ret; GValueArray *values; GByteArray *address; GByteArray *gateway; GValue value = { 0 }; key_name = g_strdup_printf ("%s%d", key, i); tmp = g_key_file_get_string (file, setting_name, key_name, NULL); g_free (key_name); if (!tmp) break; /* all done */ /* convert the string array into IPv6 addresses */ values = g_value_array_new (2); /* NMIP6Address has 2 items */ /* Split the address and prefix */ str_prefix = split_prefix (tmp); /* address */ ret = inet_pton (AF_INET6, tmp, &addr); if (ret <= 0) { g_warning ("%s: ignoring invalid IPv6 %s element '%s'", __func__, key_name, tmp); g_value_array_free (values); goto next; } address = g_byte_array_new (); g_byte_array_append (address, (guint8 *) addr.s6_addr, 16); g_value_init (&value, DBUS_TYPE_G_UCHAR_ARRAY); g_value_take_boxed (&value, address); g_value_array_append (values, &value); g_value_unset (&value); /* prefix */ prefix = 0; if (str_prefix) { if (!get_one_int (str_prefix, 128, key_name, &prefix)) { g_value_array_free (values); goto next; } } else { /* Missing prefix defaults to /64 */ prefix = 64; } g_value_init (&value, G_TYPE_UINT); g_value_set_uint (&value, prefix); g_value_array_append (values, &value); g_value_unset (&value); /* Gateway (optional) */ str_gw = split_gw (str_prefix); if (str_gw) { ret = inet_pton (AF_INET6, str_gw, &gw); if (ret <= 0) { g_warning ("%s: ignoring invalid IPv6 %s gateway '%s'", __func__, key_name, tmp); g_value_array_free (values); goto next; } if (!IN6_IS_ADDR_UNSPECIFIED (&gw)) { gateway = g_byte_array_new (); g_byte_array_append (gateway, (guint8 *) gw.s6_addr, 16); g_value_init (&value, DBUS_TYPE_G_UCHAR_ARRAY); g_value_take_boxed (&value, gateway); g_value_array_append (values, &value); g_value_unset (&value); } } g_ptr_array_add (addresses, values); next: g_free (tmp); } if (addresses->len < 1) { g_ptr_array_free (addresses, TRUE); addresses = NULL; } return addresses; }
static void gimp_help_call (Gimp *gimp, const gchar *procedure_name, const gchar *help_domain, const gchar *help_locales, const gchar *help_id) { GimpProcedure *procedure; /* Special case the help browser */ if (! strcmp (procedure_name, "extension-gimp-help-browser-temp")) { GValueArray *return_vals; return_vals = gimp_pdb_execute_procedure_by_name (gimp->pdb, gimp_get_user_context (gimp), NULL, procedure_name, G_TYPE_STRING, help_domain, G_TYPE_STRING, help_locales, G_TYPE_STRING, help_id, G_TYPE_NONE); g_value_array_free (return_vals); return; } /* Check if a help parser is already running */ procedure = gimp_pdb_lookup_procedure (gimp->pdb, "extension-gimp-help-temp"); if (! procedure) { GValueArray *args = NULL; gint n_domains = 0; gchar **help_domains = NULL; gchar **help_uris = NULL; procedure = gimp_pdb_lookup_procedure (gimp->pdb, "extension-gimp-help"); if (! procedure) /* FIXME: error msg */ return; n_domains = gimp_plug_in_manager_get_help_domains (gimp->plug_in_manager, &help_domains, &help_uris); args = gimp_procedure_get_arguments (procedure); gimp_value_array_truncate (args, 4); g_value_set_int (&args->values[0], n_domains); gimp_value_take_stringarray (&args->values[1], help_domains, n_domains); g_value_set_int (&args->values[2], n_domains); gimp_value_take_stringarray (&args->values[3], help_uris, n_domains); gimp_procedure_execute_async (procedure, gimp, gimp_get_user_context (gimp), NULL, args, NULL); g_value_array_free (args); } /* Check if the help parser started properly */ procedure = gimp_pdb_lookup_procedure (gimp->pdb, "extension-gimp-help-temp"); if (procedure) { GValueArray *return_vals; #ifdef GIMP_HELP_DEBUG g_printerr ("Calling help via %s: %s %s %s\n", procedure_name, help_domain ? help_domain : "(null)", help_locales ? help_locales : "(null)", help_id ? help_id : "(null)"); #endif return_vals = gimp_pdb_execute_procedure_by_name (gimp->pdb, gimp_get_user_context (gimp), NULL, "extension-gimp-help-temp", G_TYPE_STRING, procedure_name, G_TYPE_STRING, help_domain, G_TYPE_STRING, help_locales, G_TYPE_STRING, help_id, G_TYPE_NONE); g_value_array_free (return_vals); } }
int main (int argc, char **argv) { DBusGConnection *bus; DBusGProxy *remote_object; DBusGProxy *remote_object_introspectable; GError *error = NULL; char **reply_list; char **reply_ptr; GValueArray *hello_reply_struct; GHashTable *hello_reply_dict; char *introspect_data; guint i; g_type_init (); { GLogLevelFlags fatal_mask; fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK); fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL; g_log_set_always_fatal (fatal_mask); } bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error); if (!bus) lose_gerror ("Couldn't connect to session bus", error); remote_object = dbus_g_proxy_new_for_name (bus, "org.designfu.SampleService", "/SomeObject", "org.designfu.SampleInterface"); if (!dbus_g_proxy_call (remote_object, "HelloWorld", &error, G_TYPE_STRING, "Hello from example-client.c!", G_TYPE_INVALID, G_TYPE_STRV, &reply_list, G_TYPE_INVALID)) lose_gerror ("Failed to complete HelloWorld", error); if (!dbus_g_proxy_call (remote_object, "GetTuple", &error, G_TYPE_INVALID, G_TYPE_VALUE_ARRAY, &hello_reply_struct, G_TYPE_INVALID)) lose_gerror ("Failed to complete GetTuple", error); if (!dbus_g_proxy_call (remote_object, "GetDict", &error, G_TYPE_INVALID, DBUS_TYPE_G_STRING_STRING_HASHTABLE, &hello_reply_dict, G_TYPE_INVALID)) lose_gerror ("Failed to complete GetDict", error); printf ("reply_list: "); for (reply_ptr = reply_list; *reply_ptr; reply_ptr++) printf ("\"%s\" ", *reply_ptr); printf ("\n"); g_strfreev (reply_list); for (i = 0; i < hello_reply_struct->n_values; i++) { GValue strval = { 0, }; g_value_init (&strval, G_TYPE_STRING); if (!g_value_transform (g_value_array_get_nth (hello_reply_struct, i), &strval)) g_value_set_static_string (&strval, "(couldn't transform to string)"); g_print ("%s: %s\n", g_type_name (G_VALUE_TYPE (g_value_array_get_nth (hello_reply_struct, i))), g_value_get_string (&strval)); } g_value_array_free (hello_reply_struct); printf ("\n"); g_hash_table_foreach (hello_reply_dict, print_hash_value, NULL); g_hash_table_destroy (hello_reply_dict); remote_object_introspectable = dbus_g_proxy_new_for_name (bus, "org.designfu.SampleService", "/SomeObject", "org.freedesktop.DBus.Introspectable"); if (!dbus_g_proxy_call (remote_object_introspectable, "Introspect", &error, G_TYPE_INVALID, G_TYPE_STRING, &introspect_data, G_TYPE_INVALID)) lose_gerror ("Failed to complete Introspect", error); printf ("%s", introspect_data); g_free (introspect_data); g_object_unref (G_OBJECT (remote_object_introspectable)); g_object_unref (G_OBJECT (remote_object)); exit(0); }
void sipe_backend_media_relays_free(struct sipe_backend_media_relays *media_relays) { g_value_array_free((GValueArray *)media_relays); }
//! mengambil combo box pilihan id static GtkWidget *modifGetPilihanId(GtkWidget *bagian){ gboolean status = FALSE; GtkWidget *dialog , *content_area; GtkWidget *label1; GtkWidget *table; dialog = gtk_dialog_new(); table = gtk_table_new(1, 1, FALSE); // content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); char *str = "<b>Id</b>"; label1 = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label1), str); gtk_table_attach(GTK_TABLE(table), label1, 0, 1, 0, 1, GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5); //! isinya combobox GtkListStore *store; GtkTreeIter iter; GtkCellRenderer *cell; store = gtk_list_store_new ( 1, G_TYPE_STRING ); GValueArray* has = databaseGetDatasFromDb("select id from isi ", NULL , &status); gint i; for(i=0;i<has->n_values;i++){ GValue *ii = g_value_array_get_nth (has ,i ); gchar *tmp = g_strdup_printf ("%i", g_value_get_int(ii) ); gtk_list_store_append( store, &iter); gtk_list_store_set( store, &iter, 0, tmp, -1 ); //! free g_free(tmp); } // GtkWidget* bagian = gtk_combo_box_new_with_model( GTK_TREE_MODEL( store ) ); // bagian = gtk_combo_box_new_with_model( GTK_TREE_MODEL( store ) ); gtk_combo_box_set_model ( (GtkComboBox *) bagian,(GtkTreeModel *)store); gtk_combo_box_set_active( (GtkComboBox *) bagian,0); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( bagian ), cell, TRUE ); gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( bagian ), cell, "text", 0, NULL ); gtk_combo_box_set_row_span_column(bagian,0); gtk_table_attach(GTK_TABLE(table), bagian , 1, 2 , 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_SHRINK, 5, 5); gtk_window_set_default_size(GTK_WINDOW(dialog), 250, 100); gtk_container_add (GTK_CONTAINER (content_area), table ); modifAddButton(dialog,GTK_RESPONSE_CANCEL); gchar *tmp = g_strdup_printf ("Pilih Id - %s", globalGetAppName()); gtk_window_set_title(GTK_WINDOW(dialog), tmp); gtk_dialog_set_has_separator(dialog,TRUE); // data = bagian; gtk_dialog_set_has_separator(dialog,TRUE); gtk_window_set_modal( GTK_WINDOW( dialog ), TRUE ); gtk_window_set_transient_for( GTK_WINDOW( dialog ),GTK_WINDOW( globalGetParent() ) ); //! free g_value_array_free (has); g_object_unref( G_OBJECT( store ) ); return dialog; }
static void change_background(PanelApplet * widget, PanelAppletBackgroundType type, GdkColor * color, GdkPixmap * pixmap, void *data) { static GdkPixmap *keep = NULL; long xid = 0; GValueArray *val = g_value_array_new(4); if (type == PANEL_NO_BACKGROUND) { GtkStyle *style = gtk_widget_get_style(GTK_WIDGET(widget)); if (style->bg_pixmap[GTK_STATE_NORMAL]) { pixmap = style->bg_pixmap[GTK_STATE_NORMAL]; type = PANEL_PIXMAP_BACKGROUND; } else { color = &style->bg[GTK_STATE_NORMAL]; if (color != NULL) { type = PANEL_COLOR_BACKGROUND; } } } if (type == PANEL_COLOR_BACKGROUND && color != NULL) { g_value_array_append(val, NULL); g_value_init(g_value_array_get_nth(val, 0), G_TYPE_UINT); g_value_set_uint(g_value_array_get_nth(val, 0), color->pixel); g_value_array_append(val, NULL); g_value_init(g_value_array_get_nth(val, 1), G_TYPE_UINT); g_value_set_uint(g_value_array_get_nth(val, 1), color->red); g_value_array_append(val, NULL); g_value_init(g_value_array_get_nth(val, 2), G_TYPE_UINT); g_value_set_uint(g_value_array_get_nth(val, 2), color->green); g_value_array_append(val, NULL); g_value_init(g_value_array_get_nth(val, 3), G_TYPE_UINT); g_value_set_uint(g_value_array_get_nth(val, 3), color->blue); } else { int i; for (i = 0; i < 4; i++) { g_value_array_prepend(val, NULL); g_value_init(g_value_array_get_nth(val, 0), G_TYPE_UINT); g_value_set_uint(g_value_array_get_nth(val, 0), 0); } } if (type == PANEL_PIXMAP_BACKGROUND) { if (keep != NULL) { gdk_pixmap_unref(keep); keep = pixmap; } if (pixmap != NULL) { gdk_pixmap_ref(pixmap); } xid = GDK_PIXMAP_XID(pixmap); } if (g_applet->support != NULL && workrave_is_running()) { dbus_g_proxy_begin_call(g_applet->support, "SetBackground", dbus_callback, NULL, NULL, G_TYPE_UINT, type, G_TYPE_VALUE_ARRAY, val, G_TYPE_UINT, xid, G_TYPE_INVALID); } g_value_array_free(val); }
static gboolean get_video_recv_info (KmsRembLocal * rl, guint64 * bitrate, guint * fraction_lost, guint64 * packets_rcv_interval) { GValueArray *arr = NULL; GValue *val; guint i; gboolean ret = FALSE; if (!KMS_REMB_BASE (rl)->rtpsess) { GST_WARNING ("Session object does not exist"); return ret; } g_object_get (KMS_REMB_BASE (rl)->rtpsess, "sources", &arr, NULL); if (arr == NULL) { GST_WARNING ("Sources array not found"); return ret; } for (i = 0; i < arr->n_values; i++) { GObject *source; guint ssrc; GstStructure *s; val = g_value_array_get_nth (arr, i); source = g_value_get_object (val); g_object_get (source, "ssrc", &ssrc, "stats", &s, NULL); GST_TRACE_OBJECT (source, "source ssrc: %u", ssrc); GST_TRACE_OBJECT (KMS_REMB_BASE (rl)->rtpsess, "stats: %" GST_PTR_FORMAT, s); if (ssrc == rl->remote_ssrc) { GstClockTime current_time; guint64 octets_received, packets_received; if (!gst_structure_get_uint64 (s, "bitrate", bitrate)) { break; } if (!gst_structure_get_uint64 (s, "octets-received", &octets_received)) { break; } if (!gst_structure_get_uint (s, "sent-rb-fractionlost", fraction_lost)) { break; } if (!gst_structure_get_uint64 (s, "packets-received", &packets_received)) { break; } current_time = kms_utils_get_time_nsecs (); if (rl->last_time != 0) { GstClockTime elapsed = current_time - rl->last_time; guint64 bytes_handled = octets_received - rl->last_octets_received; *bitrate = gst_util_uint64_scale (bytes_handled, 8 * GST_SECOND, elapsed); GST_TRACE_OBJECT (KMS_REMB_BASE (rl)->rtpsess, "Elapsed %" G_GUINT64_FORMAT " bytes %" G_GUINT64_FORMAT ", rate %" G_GUINT64_FORMAT, elapsed, bytes_handled, *bitrate); } rl->last_time = current_time; rl->last_octets_received = octets_received; *packets_rcv_interval = packets_received - rl->last_packets_received; rl->last_packets_received = packets_received; ret = TRUE; } gst_structure_free (s); if (ret) { break; } } g_value_array_free (arr); return ret; }
GimpPDBStatusType file_save (GimpImage *image, GimpContext *context, GimpProgress *progress, const gchar *uri, GimpPlugInProcedure *file_proc, GimpRunMode run_mode, gboolean save_a_copy, GError **error) { GimpDrawable *drawable; GValueArray *return_vals; GimpPDBStatusType status; gchar *filename; gint32 image_ID; gint32 drawable_ID; g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_PDB_CALLING_ERROR); g_return_val_if_fail (GIMP_IS_CONTEXT (context), GIMP_PDB_CALLING_ERROR); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), GIMP_PDB_CALLING_ERROR); g_return_val_if_fail (uri != NULL, GIMP_PDB_CALLING_ERROR); g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (file_proc), GIMP_PDB_CALLING_ERROR); g_return_val_if_fail (error == NULL || *error == NULL, GIMP_PDB_CALLING_ERROR); drawable = gimp_image_get_active_drawable (image); if (! drawable) return GIMP_PDB_EXECUTION_ERROR; filename = file_utils_filename_from_uri (uri); if (filename) { /* check if we are saving to a file */ if (g_file_test (filename, G_FILE_TEST_EXISTS)) { if (! g_file_test (filename, G_FILE_TEST_IS_REGULAR)) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, "%s", _("Not a regular file")); status = GIMP_PDB_EXECUTION_ERROR; goto out; } if (g_access (filename, W_OK) != 0) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_ACCES, "%s", g_strerror (errno)); status = GIMP_PDB_EXECUTION_ERROR; goto out; } } } else { filename = g_strdup (uri); } /* ref the image, so it can't get deleted during save */ g_object_ref (image); image_ID = gimp_image_get_ID (image); drawable_ID = gimp_item_get_ID (GIMP_ITEM (drawable)); return_vals = gimp_pdb_execute_procedure_by_name (image->gimp->pdb, context, progress, error, GIMP_OBJECT (file_proc)->name, GIMP_TYPE_INT32, run_mode, GIMP_TYPE_IMAGE_ID, image_ID, GIMP_TYPE_DRAWABLE_ID, drawable_ID, G_TYPE_STRING, filename, G_TYPE_STRING, uri, G_TYPE_NONE); status = g_value_get_enum (&return_vals->values[0]); g_value_array_free (return_vals); if (status == GIMP_PDB_SUCCESS) { GimpDocumentList *documents; GimpImagefile *imagefile; if (save_a_copy) { /* remember the "save-a-copy" filename for the next invocation */ g_object_set_data_full (G_OBJECT (image), "gimp-image-save-a-copy", g_strdup (uri), (GDestroyNotify) g_free); } else { /* reset the "save-a-copy" filename when the image URI changes */ if (strcmp (uri, gimp_image_get_uri (image))) g_object_set_data (G_OBJECT (image), "gimp-image-save-a-copy", NULL); gimp_image_set_uri (image, uri); gimp_image_set_save_proc (image, file_proc); gimp_image_clean_all (image); } gimp_image_saved (image, uri); documents = GIMP_DOCUMENT_LIST (image->gimp->documents); imagefile = gimp_document_list_add_uri (documents, uri, file_proc->mime_type); /* only save a thumbnail if we are saving as XCF, see bug #25272 */ if (GIMP_PROCEDURE (file_proc)->proc_type == GIMP_INTERNAL) gimp_imagefile_save_thumbnail (imagefile, file_proc->mime_type, image); } else if (status != GIMP_PDB_CANCEL) { if (error && *error == NULL) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("%s plug-in could not save image"), gimp_plug_in_procedure_get_label (file_proc)); } } gimp_image_flush (image); g_object_unref (image); out: g_free (filename); return status; }
static int pyg_value_array_from_pyobject(GValue *value, PyObject *obj, const GParamSpecValueArray *pspec) { int len; GValueArray *value_array; int i; len = PySequence_Length(obj); if (len == -1) { PyErr_Clear(); return -1; } if (pspec && pspec->fixed_n_elements > 0 && len != pspec->fixed_n_elements) return -1; value_array = g_value_array_new(len); for (i = 0; i < len; ++i) { PyObject *item = PySequence_GetItem(obj, i); GType type; GValue item_value = { 0, }; int status; if (! item) { PyErr_Clear(); g_value_array_free(value_array); return -1; } if (pspec && pspec->element_spec) type = G_PARAM_SPEC_VALUE_TYPE(pspec->element_spec); else if (item == Py_None) type = G_TYPE_POINTER; /* store None as NULL */ else { type = pyg_type_from_object((PyObject*)Py_TYPE(item)); if (! type) { PyErr_Clear(); g_value_array_free(value_array); Py_DECREF(item); return -1; } } g_value_init(&item_value, type); status = (pspec && pspec->element_spec) ? pyg_param_gvalue_from_pyobject(&item_value, item, pspec->element_spec) : pyg_value_from_pyobject(&item_value, item); Py_DECREF(item); if (status == -1) { g_value_array_free(value_array); g_value_unset(&item_value); return -1; } g_value_array_append(value_array, &item_value); g_value_unset(&item_value); } g_value_take_boxed(value, value_array); return 0; }
static void gst_video_parse_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstVideoParse *vp = GST_VIDEO_PARSE (object); switch (prop_id) { case PROP_FORMAT: g_object_set (G_OBJECT (vp->rawvideoparse), "format", g_value_get_enum (value), NULL); break; case PROP_WIDTH: g_object_set (G_OBJECT (vp->rawvideoparse), "width", g_value_get_int (value), NULL); break; case PROP_HEIGHT: g_object_set (G_OBJECT (vp->rawvideoparse), "height", g_value_get_int (value), NULL); break; case PROP_FRAMERATE: g_object_set (G_OBJECT (vp->rawvideoparse), "framerate", gst_value_get_fraction_numerator (value), gst_value_get_fraction_denominator (value), NULL); break; case PROP_PAR: g_object_set (G_OBJECT (vp->rawvideoparse), "pixel-aspect-ratio", gst_value_get_fraction_numerator (value), gst_value_get_fraction_denominator (value), NULL); break; case PROP_INTERLACED: g_object_set (G_OBJECT (vp->rawvideoparse), "interlaced", g_value_get_boolean (value), NULL); break; case PROP_TOP_FIELD_FIRST: g_object_set (G_OBJECT (vp->rawvideoparse), "top-field-first", g_value_get_boolean (value), NULL); break; case PROP_STRIDES:{ GValueArray *valarray = gst_video_parse_int_valarray_from_string (g_value_get_string (value)); if (valarray != NULL) { g_object_set (G_OBJECT (vp->rawvideoparse), "plane-strides", valarray, NULL); g_value_array_free (valarray); } else { GST_WARNING_OBJECT (vp, "failed to deserialize given strides"); } break; } case PROP_OFFSETS:{ GValueArray *valarray = gst_video_parse_int_valarray_from_string (g_value_get_string (value)); if (valarray != NULL) { g_object_set (G_OBJECT (vp->rawvideoparse), "plane-offsets", valarray, NULL); g_value_array_free (valarray); } else { GST_WARNING_OBJECT (vp, "failed to deserialize given offsets"); } break; } case PROP_FRAMESIZE: g_object_set (G_OBJECT (vp->rawvideoparse), "frame-stride", g_value_get_uint (value), NULL); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static GPtrArray * read_ip6_routes (GKeyFile *file, const char *setting_name, const char *key) { GPtrArray *routes; struct in6_addr addr; guint32 prefix, metric; int i = 0; routes = g_ptr_array_sized_new (3); /* Look for individual routes */ while (i++ < 1000) { gchar **tmp; char *key_name, *str_prefix; gsize length = 0; int ret; GValueArray *values; GByteArray *address; GValue value = { 0 }; key_name = g_strdup_printf ("%s%d", key, i); tmp = g_key_file_get_string_list (file, setting_name, key_name, &length, NULL); g_free (key_name); if (!tmp || !length) break; /* all done */ if (length != 3) { g_warning ("%s: ignoring invalid IPv6 address item '%s'", __func__, key_name); goto next; } /* convert the string array into IPv6 routes */ values = g_value_array_new (4); /* NMIP6Route has 4 items */ /* Split the route and prefix */ str_prefix = split_prefix (tmp[0]); /* destination address */ ret = inet_pton (AF_INET6, tmp[0], &addr); if (ret <= 0) { g_warning ("%s: ignoring invalid IPv6 %s element '%s'", __func__, key_name, tmp[0]); g_value_array_free (values); goto next; } address = g_byte_array_new (); g_byte_array_append (address, (guint8 *) addr.s6_addr, 16); g_value_init (&value, DBUS_TYPE_G_UCHAR_ARRAY); g_value_take_boxed (&value, address); g_value_array_append (values, &value); g_value_unset (&value); /* prefix */ prefix = 0; if (str_prefix) { if (!get_one_int (str_prefix, 128, key_name, &prefix)) { g_value_array_free (values); goto next; } } else { /* default to 64 if unspecified */ prefix = 64; } g_value_init (&value, G_TYPE_UINT); g_value_set_uint (&value, prefix); g_value_array_append (values, &value); g_value_unset (&value); /* next hop address */ ret = inet_pton (AF_INET6, tmp[1], &addr); if (ret <= 0) { g_warning ("%s: ignoring invalid IPv6 %s element '%s'", __func__, key_name, tmp[1]); g_value_array_free (values); goto next; } address = g_byte_array_new (); g_byte_array_append (address, (guint8 *) addr.s6_addr, 16); g_value_init (&value, DBUS_TYPE_G_UCHAR_ARRAY); g_value_take_boxed (&value, address); g_value_array_append (values, &value); g_value_unset (&value); /* metric */ metric = 0; if (!get_one_int (tmp[2], G_MAXUINT32, key_name, &metric)) { g_value_array_free (values); goto next; } g_value_init (&value, G_TYPE_UINT); g_value_set_uint (&value, metric); g_value_array_append (values, &value); g_value_unset (&value); g_ptr_array_add (routes, values); next: g_strfreev (tmp); } if (routes->len < 1) { g_ptr_array_free (routes, TRUE); routes = NULL; } return routes; }
static void free_one_ip6_route (gpointer data, gpointer user_data) { g_value_array_free ((GValueArray *) data); }
static gpointer build_ip6_address_or_route (const char *address_str, guint32 plen, const char *gateway_str, guint32 metric, gboolean route) { GValueArray *result; struct in6_addr addr; GByteArray *address; GByteArray *gateway; GValue value = { 0, }; int err; g_return_val_if_fail (address_str, NULL); result = g_value_array_new (3); /* add address */ err = inet_pton (AF_INET6, address_str, &addr); if (err <= 0) { g_warning ("%s: ignoring invalid IPv6 address '%s'", __func__, address_str); g_value_array_free (result); return NULL; } address = g_byte_array_new (); g_byte_array_append (address, (guint8 *) addr.s6_addr, 16); g_value_init (&value, DBUS_TYPE_G_UCHAR_ARRAY); g_value_take_boxed (&value, address); g_value_array_append (result, &value); g_value_unset (&value); /* add prefix length */ g_value_init (&value, G_TYPE_UINT); g_value_set_uint (&value, plen); g_value_array_append (result, &value); g_value_unset (&value); /* add gateway */ if (gateway_str) { err = inet_pton (AF_INET6, gateway_str, &addr); if (err <= 0) { g_warning ("%s: ignoring invalid IPv6 gateway '%s'", __func__, gateway_str); g_value_array_free (result); return NULL; } } else memset (&addr, 0, 16); gateway = g_byte_array_new (); g_byte_array_append (gateway, (guint8 *) addr.s6_addr, 16); g_value_init (&value, DBUS_TYPE_G_UCHAR_ARRAY); g_value_take_boxed (&value, gateway); g_value_array_append (result, &value); g_value_unset (&value); /* add metric (for routing) */ if (route) { g_value_init (&value, G_TYPE_UINT); g_value_set_uint (&value, metric); g_value_array_append (result, &value); g_value_unset (&value); } return result; }
/** * file_open_thumbnail: * @gimp: * @context: * @progress: * @uri: the URI of the image file * @size: requested size of the thumbnail * @mime_type: return location for image MIME type * @image_width: return location for image width * @image_height: return location for image height * @type: return location for image type (set to -1 if unknown) * @num_layers: return location for number of layers * (set to -1 if the number of layers is not known) * @error: * * Attempts to load a thumbnail by using a registered thumbnail loader. * * Return value: the thumbnail image */ GimpImage * file_open_thumbnail (Gimp *gimp, GimpContext *context, GimpProgress *progress, const gchar *uri, gint size, const gchar **mime_type, gint *image_width, gint *image_height, GimpImageType *type, gint *num_layers, GError **error) { GimpPlugInProcedure *file_proc; GimpProcedure *procedure; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL); g_return_val_if_fail (mime_type != NULL, NULL); g_return_val_if_fail (image_width != NULL, NULL); g_return_val_if_fail (image_height != NULL, NULL); g_return_val_if_fail (type != NULL, NULL); g_return_val_if_fail (num_layers != NULL, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); *image_width = 0; *image_height = 0; *type = -1; *num_layers = -1; file_proc = file_procedure_find (gimp->plug_in_manager->load_procs, uri, NULL); if (! file_proc || ! file_proc->thumb_loader) return NULL; procedure = gimp_pdb_lookup_procedure (gimp->pdb, file_proc->thumb_loader); if (procedure && procedure->num_args >= 2 && procedure->num_values >= 1) { GimpPDBStatusType status; GValueArray *return_vals; gchar *filename; GimpImage *image = NULL; filename = file_utils_filename_from_uri (uri); if (! filename) filename = g_strdup (uri); return_vals = gimp_pdb_execute_procedure_by_name (gimp->pdb, context, progress, error, gimp_object_get_name (procedure), G_TYPE_STRING, filename, GIMP_TYPE_INT32, size, G_TYPE_NONE); g_free (filename); status = g_value_get_enum (&return_vals->values[0]); if (status == GIMP_PDB_SUCCESS && GIMP_VALUE_HOLDS_IMAGE_ID (&return_vals->values[1])) { image = gimp_value_get_image (&return_vals->values[1], gimp); if (return_vals->n_values >= 3 && G_VALUE_HOLDS_INT (&return_vals->values[2]) && G_VALUE_HOLDS_INT (&return_vals->values[3])) { *image_width = MAX (0, g_value_get_int (&return_vals->values[2])); *image_height = MAX (0, g_value_get_int (&return_vals->values[3])); if (return_vals->n_values >= 5 && G_VALUE_HOLDS_INT (&return_vals->values[4])) { gint value = g_value_get_int (&return_vals->values[4]); if (gimp_enum_get_value (GIMP_TYPE_IMAGE_TYPE, value, NULL, NULL, NULL, NULL)) { *type = value; } } if (return_vals->n_values >= 6 && G_VALUE_HOLDS_INT (&return_vals->values[5])) { *num_layers = MAX (0, g_value_get_int (&return_vals->values[5])); } } if (image) { file_open_sanitize_image (image, FALSE); *mime_type = file_proc->mime_type; #ifdef GIMP_UNSTABLE g_printerr ("opened thumbnail at %d x %d\n", gimp_image_get_width (image), gimp_image_get_height (image)); #endif } } g_value_array_free (return_vals); return image; } return NULL; }
static void get_stream_information(TPMediaPlayer * mp) { USERDATA(mp); CM(ud); #if (CLUTTER_GST_MAJOR_VERSION < 1) GstElement * pipeline=clutter_gst_video_texture_get_playbin(CLUTTER_GST_VIDEO_TEXTURE(cm)); #else GstElement *pipeline=clutter_gst_video_texture_get_pipeline(CLUTTER_GST_VIDEO_TEXTURE(cm)); #endif if (!pipeline) return; //......................................................................... // Use stream info to get the type of each stream #if (CLUTTER_GST_MAJOR_VERSION < 1) GValueArray * info_array=NULL; g_object_get(G_OBJECT(pipeline),"stream-info-value-array",&info_array,NULL); if (info_array) { // Each entry in the array is information for a single stream guint i; for (i=0;i<info_array->n_values;++i) { GValue * info_value=g_value_array_get_nth(info_array,i); if (G_VALUE_HOLDS(info_value,G_TYPE_OBJECT)) { GObject * stream_info=g_value_get_object(info_value); if (stream_info) { gint type = -1; g_object_get(stream_info,"type",&type,NULL); switch (type) { case 1: ud->media_type|=TP_MEDIA_TYPE_AUDIO; break; case 2: ud->media_type|=TP_MEDIA_TYPE_VIDEO; break; } #if 0 // This lets you get the enum value associated with the stream type GParamSpec *pspec; GEnumValue *value; pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(stream_info),"type"); value = g_enum_get_value(G_PARAM_SPEC_ENUM(pspec)->enum_class,type); g_debug(" STREAM TYPE IS %d %s",type,value->value_nick); #endif } } } g_value_array_free(info_array); } #else gint n_audio, n_video; g_object_get(G_OBJECT(pipeline), "n-video", &n_video, NULL); g_object_get(G_OBJECT(pipeline), "n-audio", &n_audio, NULL); if(n_video) ud->media_type|=TP_MEDIA_TYPE_VIDEO; if(n_audio) ud->media_type|=TP_MEDIA_TYPE_AUDIO; #endif //......................................................................... // If there is a video stream, we get the video sink and try to find the // video size if (ud->media_type&TP_MEDIA_TYPE_VIDEO) { GstElement * video_sink=NULL; g_object_get(G_OBJECT(pipeline),"video-sink",&video_sink,NULL); if (video_sink) { GstPad * pad=gst_element_get_static_pad(video_sink,"sink"); if (pad) { // Get its video width and height gint width; gint height; if (gst_video_get_size(pad,&width,&height)) { ud->video_width=width; ud->video_height=height; } gst_object_unref(GST_OBJECT(pad)); } gst_object_unref(GST_OBJECT(video_sink)); } } #if 1 if ( ud->media_type & TP_MEDIA_TYPE_AUDIO ) { GstElement * audio_sink= gst_element_factory_make( "autoaudiosink", "TPAudioSink" ); if(!audio_sink) { g_debug("Failed to create autoaudiosink"); } else { g_object_set(G_OBJECT(pipeline),"audio-sink",audio_sink,NULL); } } #endif }
GimpImage * file_open_image (Gimp *gimp, GimpContext *context, GimpProgress *progress, const gchar *uri, const gchar *entered_filename, gboolean as_new, GimpPlugInProcedure *file_proc, GimpRunMode run_mode, GimpPDBStatusType *status, const gchar **mime_type, GError **error) { GValueArray *return_vals; gchar *filename; GimpImage *image = NULL; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL); g_return_val_if_fail (status != NULL, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); *status = GIMP_PDB_EXECUTION_ERROR; if (! file_proc) file_proc = file_procedure_find (gimp->plug_in_manager->load_procs, uri, error); if (! file_proc) return NULL; filename = file_utils_filename_from_uri (uri); if (filename) { /* check if we are opening a file */ if (g_file_test (filename, G_FILE_TEST_EXISTS)) { if (! g_file_test (filename, G_FILE_TEST_IS_REGULAR)) { g_free (filename); g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("Not a regular file")); return NULL; } if (g_access (filename, R_OK) != 0) { g_free (filename); g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_ACCES, g_strerror (errno)); return NULL; } } } else { filename = g_strdup (uri); } return_vals = gimp_pdb_execute_procedure_by_name (gimp->pdb, context, progress, error, gimp_object_get_name (file_proc), GIMP_TYPE_INT32, run_mode, G_TYPE_STRING, filename, G_TYPE_STRING, entered_filename, G_TYPE_NONE); g_free (filename); *status = g_value_get_enum (&return_vals->values[0]); if (*status == GIMP_PDB_SUCCESS) { image = gimp_value_get_image (&return_vals->values[1], gimp); if (image) { file_open_sanitize_image (image, as_new); /* Only set the load procedure if it hasn't already been set. */ if (! gimp_image_get_load_proc (image)) gimp_image_set_load_proc (image, file_proc); file_proc = gimp_image_get_load_proc (image); if (mime_type) *mime_type = file_proc->mime_type; } else { if (error && ! *error) g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("%s plug-in returned SUCCESS but did not " "return an image"), gimp_plug_in_procedure_get_label (file_proc)); *status = GIMP_PDB_EXECUTION_ERROR; } } else if (*status != GIMP_PDB_CANCEL) { if (error && ! *error) g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("%s plug-In could not open image"), gimp_plug_in_procedure_get_label (file_proc)); } g_value_array_free (return_vals); if (image) { file_open_handle_color_profile (image, context, progress, run_mode); if (file_open_file_proc_is_import (file_proc)) { /* Remember the import source */ gimp_image_set_imported_uri (image, uri); /* We shall treat this file as an Untitled file */ gimp_image_set_uri (image, NULL); } } return image; }
/* run automatically started extensions */ static void gimp_plug_in_manager_run_extensions (GimpPlugInManager *manager, GimpContext *context, GimpInitStatusFunc status_callback) { Gimp *gimp = manager->gimp; GSList *list; GList *extensions = NULL; gint n_extensions; /* build list of automatically started extensions */ for (list = manager->plug_in_procedures; list; list = list->next) { GimpPlugInProcedure *proc = list->data; if (proc->prog && GIMP_PROCEDURE (proc)->proc_type == GIMP_EXTENSION && GIMP_PROCEDURE (proc)->num_args == 0) { extensions = g_list_prepend (extensions, proc); } } extensions = g_list_reverse (extensions); n_extensions = g_list_length (extensions); /* run the available extensions */ if (extensions) { GList *list; gint nth; status_callback (_("Starting Extensions"), "", 0.0); for (list = extensions, nth = 0; list; list = g_list_next (list), nth++) { GimpPlugInProcedure *proc = list->data; GValueArray *args; GError *error = NULL; if (gimp->be_verbose) g_print ("Starting extension: '%s'\n", gimp_object_get_name (proc)); status_callback (NULL, gimp_object_get_name (proc), (gdouble) nth / (gdouble) n_extensions); args = g_value_array_new (0); gimp_procedure_execute_async (GIMP_PROCEDURE (proc), gimp, context, NULL, args, NULL, &error); g_value_array_free (args); if (error) { gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message); g_clear_error (&error); } } g_list_free (extensions); status_callback (NULL, "", 1.0); } }
static void _parse_and_forward_one(IdleParser *parser, gchar **tokens, IdleParserMessageCode code, const gchar *format) { IdleParserPrivate *priv = IDLE_PARSER_GET_PRIVATE(parser); GValueArray *args = g_value_array_new(3); GSList *link_ = priv->handlers[code]; IdleParserHandlerResult result = IDLE_PARSER_HANDLER_RESULT_NOT_HANDLED; gboolean success = TRUE; gchar **iter = tokens; /* We keep a ref to each unique handle in a message so that we can unref them after calling all handlers */ TpHandleSet *contact_reffed = tp_handle_set_new(tp_base_connection_get_handles(TP_BASE_CONNECTION(priv->conn), TP_HANDLE_TYPE_CONTACT)); TpHandleSet *room_reffed = tp_handle_set_new(tp_base_connection_get_handles(TP_BASE_CONNECTION(priv->conn), TP_HANDLE_TYPE_ROOM)); IDLE_DEBUG("message code %u", code); while ((*format != '\0') && success && (*iter != NULL)) { GValue val = {0}; if (*format == 'v') { format++; while (*iter != NULL) { if (!_parse_atom(parser, args, *format, iter[0], contact_reffed, room_reffed)) { success = FALSE; break; } iter += 2; } } else if ((*format == ':') || (*format == '.')) { /* Assume the happy case of the trailing parameter starting after the : * in the trailing string as the RFC intended */ const gchar *trailing = iter[1] + 1; /* Some IRC proxies *cough* bip *cough* omit the : in the trailing * parameter if that parameter is just one word, to cope with that check * if there are no more tokens after the current one and if so, accept a * trailing string without the : prefix. */ if (iter[0][0] != ':') { if (iter[2] == NULL) { trailing = iter[1]; } else { success = FALSE; break; } } /* * because of the way things are tokenized, if there is a * space immediately after the the ':', the current token will only be * ":", so we check that the trailing string is non-NULL rather than * checking iter[0][1] (since iter[0] is a NULL-terminated token string * whereas trailing is a pointer into the full message string */ if (trailing[0] == '\0') { success = FALSE; break; } g_value_init(&val, G_TYPE_STRING); g_value_set_string(&val, trailing); g_value_array_append(args, &val); g_value_unset(&val); IDLE_DEBUG("set string \"%s\"", trailing); } else { if (!_parse_atom(parser, args, *format, iter[0], contact_reffed, room_reffed)) { success = FALSE; break; } } format++; iter += 2; } if (!success && (*format != '.')) { IDLE_DEBUG("failed to parse \"%s\"", tokens[1]); goto cleanup; } if (*format && (*format != '.')) { IDLE_DEBUG("missing args in message \"%s\"", tokens[1]); goto cleanup; } IDLE_DEBUG("successfully parsed"); while (link_) { MessageHandlerClosure *closure = link_->data; result = closure->handler(parser, code, args, closure->user_data); if (result == IDLE_PARSER_HANDLER_RESULT_NOT_HANDLED) { link_ = link_->next; } else if (result == IDLE_PARSER_HANDLER_RESULT_HANDLED) { break; } else if (result == IDLE_PARSER_HANDLER_RESULT_NO_MORE_PLEASE) { GSList *tmp = link_->next; g_free(closure); priv->handlers[code] = g_slist_remove_link(priv->handlers[code], link_); link_ = tmp; } else { g_assert_not_reached(); } } cleanup: g_value_array_free(args); tp_handle_set_destroy(contact_reffed); tp_handle_set_destroy(room_reffed); }
//! edit gboolean modifEdi(GtkWidget* parent , gpointer data){ gboolean status = FALSE; gint id = GPOINTER_TO_INT(data); gint result = GTK_RESPONSE_OK; if(data == NULL){ GtkWidget *comboId = gtk_combo_box_new (); GtkWidget *dialog = modifGetPilihanId(comboId); gtk_widget_show_all(dialog); result = gtk_dialog_run (dialog); // block id = globalConStrToInt(gtk_combo_box_get_active_text(comboId)); gtk_widget_destroy(dialog); } if(result==GTK_RESPONSE_OK){ modifStruct_ *modif = struct_new(modifStruct_); gchar *title = g_strdup_printf ("Edit Data dengan id %d", id); GtkWidget *dialog = modifGetDialogWithStruct(parent , modif , title); //! mengambil data dari database GValueArray* varr = g_value_array_new (-1); GValue a = {0}; g_assert (!G_VALUE_HOLDS_STRING (&a)); g_value_init (&a, G_TYPE_INT); g_value_set_int (&a, id ); varr = g_value_array_append(varr,&a); gchar *sql = g_strdup_printf ("%s and isi.id=?", globalGetDefCom() ); GValueArray *hasil = databaseGetDatasFromDb( sql , varr , &status); modifSetItemToWidget(modif,hasil); //! show gtk_widget_show_all(dialog); result = gtk_dialog_run (dialog); // block if (result==GTK_RESPONSE_OK){ //! sekarang kita akan masuk pada database //! mengambil data char *filename; char* jamchar = globalPutZeroToWkt(gtk_spin_button_get_value_as_int(modif->jam)); char* mntchar = globalPutZeroToWkt(gtk_spin_button_get_value_as_int(modif->mnt)); gchar *jamMnt = g_strdup_printf ("%s:%s", jamchar,mntchar); gchar * hari = gtk_combo_box_get_active_text ( modif->hari); gchar * bagian = gtk_combo_box_get_active_text ( modif->bagian ); gint total = gtk_spin_button_get_value_as_int (modif->total); filename = fuGetNameFile( gtk_button_get_label(modif->filePilih)); //! update database gint idHari = databaseGetIdHari(hari); GValueArray* varr = g_value_array_new (-1); GValue a = {0}; g_assert (!G_VALUE_HOLDS_STRING (&a)); g_value_init (&a, G_TYPE_INT); g_value_set_int (&a, idHari); //! 1 varr = g_value_array_append(varr,&a); g_value_set_int (&a, total); //! 2 varr = g_value_array_append(varr,&a); g_value_unset (&a); g_value_init (&a, G_TYPE_STRING); g_value_set_string (&a, jamMnt); //! 3 varr = g_value_array_append(varr,&a); g_value_set_string (&a, bagian); //! 4 varr = g_value_array_append(varr,&a); g_value_set_string (&a, filename); //! 5 varr = g_value_array_append(varr,&a); g_value_unset (&a); g_value_init (&a, G_TYPE_INT); g_value_set_int (&a, id); //! 6 varr = g_value_array_append(varr,&a); GValueArray *hasil = databaseGetDatasFromDb("update isi set dal=? , X=?,jam=?,bagian=?,alarm=? where id = ?" , varr,&status); //! free g_value_array_free (varr); g_value_array_free (hasil); //! aslinya harus di cek kembali status = TRUE; } else{ } //! free all g_value_array_free (varr); g_value_array_free (hasil); gtk_widget_destroy(dialog); } return TRUE; }
GParameter * jingle_get_params(JabberStream *js, const gchar *relay_ip, guint relay_udp, guint relay_tcp, guint relay_ssltcp, const gchar *relay_username, const gchar *relay_password, guint *num) { /* don't set a STUN server if one is set globally in prefs, in that case this will be handled in media.c */ gboolean has_account_stun = js->stun_ip && !purple_network_get_stun_ip(); guint num_params = has_account_stun ? (relay_ip ? 3 : 2) : (relay_ip ? 1 : 0); GParameter *params = NULL; int next_index = 0; if (num_params > 0) { params = g_new0(GParameter, num_params); if (has_account_stun) { purple_debug_info("jabber", "setting param stun-ip for stream using Google auto-config: %s\n", js->stun_ip); params[next_index].name = "stun-ip"; g_value_init(¶ms[next_index].value, G_TYPE_STRING); g_value_set_string(¶ms[next_index].value, js->stun_ip); purple_debug_info("jabber", "setting param stun-port for stream using Google auto-config: %d\n", js->stun_port); next_index++; params[next_index].name = "stun-port"; g_value_init(¶ms[next_index].value, G_TYPE_UINT); g_value_set_uint(¶ms[next_index].value, js->stun_port); next_index++; } if (relay_ip) { GValueArray *relay_info = g_value_array_new(0); if (relay_udp) { relay_info = jingle_create_relay_info(relay_ip, relay_udp, relay_username, relay_password, "udp", relay_info); } if (relay_tcp) { relay_info = jingle_create_relay_info(relay_ip, relay_tcp, relay_username, relay_password, "tcp", relay_info); } if (relay_ssltcp) { relay_info = jingle_create_relay_info(relay_ip, relay_ssltcp, relay_username, relay_password, "tls", relay_info); } params[next_index].name = "relay-info"; g_value_init(¶ms[next_index].value, G_TYPE_VALUE_ARRAY); g_value_set_boxed(¶ms[next_index].value, relay_info); g_value_array_free(relay_info); } } *num = num_params; return params; }
static void batch_run_cmd (Gimp *gimp, const gchar *proc_name, GimpProcedure *procedure, GimpRunMode run_mode, const gchar *cmd) { GValueArray *args; GValueArray *return_vals; GError *error = NULL; gint i = 0; args = gimp_procedure_get_arguments (procedure); if (procedure->num_args > i && GIMP_IS_PARAM_SPEC_INT32 (procedure->args[i])) g_value_set_int (&args->values[i++], run_mode); if (procedure->num_args > i && GIMP_IS_PARAM_SPEC_STRING (procedure->args[i])) g_value_set_static_string (&args->values[i++], cmd); return_vals = gimp_pdb_execute_procedure_by_name_args (gimp->pdb, gimp_get_user_context (gimp), NULL, &error, proc_name, args); switch (g_value_get_enum (&return_vals->values[0])) { case GIMP_PDB_EXECUTION_ERROR: if (error) { g_printerr ("batch command experienced an execution error: %s\n", error->message); } else { g_printerr ("batch command experienced an execution error\n"); } break; case GIMP_PDB_CALLING_ERROR: if (error) { g_printerr ("batch command experienced a calling error: %s\n", error->message); } else { g_printerr ("batch command experienced a calling error\n"); } break; case GIMP_PDB_SUCCESS: g_printerr ("batch command executed successfully\n"); break; } g_value_array_free (return_vals); g_value_array_free (args); if (error) g_error_free (error); return; }
static void mame_gui_prefs_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { MameGuiPrefs *prefs; GValueArray *va = NULL; /* Don't free this - the calling function must take the responsibility to do so */ prefs = MAME_GUI_PREFS (object); if ((prop_id < NUM_PROPERTIES) && (prop_id >= PROP_DIR_ARTWORK)) { GMAMEUI_DEBUG ("Setting the directory value at %d with value %s", (prop_id - PROP_DIR_ARTWORK), g_value_get_string (value)); /* We are processing a directory property */ prefs->priv->directories[prop_id - PROP_DIR_ARTWORK] = g_strdup (g_value_get_string (value)); /* Note we use prop_id - PROP_DIR_ARTWORK since PDA is the first of the directory properties */ return; } switch (prop_id) { case PROP_UI_WIDTH: prefs->priv->ui_width = g_value_get_int (value); break; case PROP_UI_HEIGHT: prefs->priv->ui_height = g_value_get_int (value); break; case PROP_SHOW_TOOLBAR: prefs->priv->show_toolbar = g_value_get_boolean (value); break; case PROP_SHOW_STATUSBAR: prefs->priv->show_statusbar = g_value_get_boolean (value); break; case PROP_SHOW_FILTERLIST: prefs->priv->show_filterlist = g_value_get_boolean (value); break; case PROP_SHOW_SCREENSHOT: prefs->priv->show_screenshot = g_value_get_boolean (value); break; case PROP_XPOS_FILTERS: prefs->priv->xpos_filters = g_value_get_int (value); break; case PROP_XPOS_GAMELIST: prefs->priv->xpos_gamelist = g_value_get_int (value); break; case PROP_GAMECHECK: prefs->priv->GameCheck = g_value_get_boolean (value); break; case PROP_VERSIONCHECK: prefs->priv->VersionCheck = g_value_get_boolean (value); break; case PROP_USEXMAMEOPTIONS: prefs->priv->use_xmame_options = g_value_get_boolean (value); break; case PROP_PREFERCUSTOMICONS: prefs->priv->prefercustomicons = g_value_get_boolean (value); /* Emit the signal (so gamelist view can be changed */ g_signal_emit (G_OBJECT (prefs), signals[GUI_PREFS_PREFERCUSTOMICONS_TOGGLED], 0, prefs->priv->theprefix); case PROP_USEJOYINGUI: prefs->priv->gui_joy = g_value_get_boolean (value); break; case PROP_JOYSTICKNAME: prefs->priv->joystick_name = g_strdup (g_value_get_string (value)); break; case PROP_THEPREFIX: prefs->priv->theprefix = g_value_get_boolean (value); /* Emit the signal (so gamelist view can be changed */ g_signal_emit (G_OBJECT (prefs), signals[GUI_PREFS_THEPREFIX_TOGGLED], 0, prefs->priv->theprefix); break; case PROP_CURRENT_ROM: prefs->priv->current_rom_name = g_strdup (g_value_get_string (value)); break; case PROP_CURRENT_EXECUTABLE: prefs->priv->current_executable_name = g_strdup (g_value_get_string (value)); break; case PROP_EXECUTABLE_PATHS: va = g_value_get_boxed (value); if (prefs->priv->executable_paths) g_value_array_free (prefs->priv->executable_paths); prefs->priv->executable_paths = va != NULL ? g_value_array_copy (va) : NULL; break; case PROP_ROM_PATHS: va = g_value_get_boxed (value); if (prefs->priv->rom_paths) g_value_array_free (prefs->priv->rom_paths); prefs->priv->rom_paths = va != NULL ? g_value_array_copy (va) : NULL; break; case PROP_SAMPLE_PATHS: va = g_value_get_boxed (value); if (prefs->priv->sample_paths) g_value_array_free (prefs->priv->sample_paths); prefs->priv->sample_paths = va != NULL ? g_value_array_copy (va) : NULL; break; case PROP_CURRENT_ROMFILTER: prefs->priv->current_rom_filter = g_value_get_int (value); break; case PROP_CURRENT_MODE: prefs->priv->current_mode = g_value_get_int (value); break; case PROP_PREVIOUS_MODE: prefs->priv->previous_mode = g_value_get_int (value); break; case PROP_COLS_SHOWN: va = g_value_get_boxed (value); if (prefs->priv->cols_shown) g_value_array_free (prefs->priv->cols_shown); prefs->priv->cols_shown = va != NULL ? g_value_array_copy (va) : NULL; /* Emit the signal (so gamelist view can be changed */ g_signal_emit (G_OBJECT (prefs), signals[GUI_PREFS_COL_TOGGLED], 0, prefs->priv->cols_shown); break; case PROP_COLS_WIDTH: va = g_value_get_boxed (value); if (prefs->priv->cols_width) g_value_array_free (prefs->priv->cols_width); prefs->priv->cols_width = va != NULL ? g_value_array_copy (va) : NULL; break; case PROP_SORT_COL: prefs->priv->sort_col = g_value_get_int (value); break; case PROP_SORT_COL_DIR: prefs->priv->sort_col_direction = g_value_get_int (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } /* As long as the notify::<property> callback is set, the handler will then manage saving the key file */ }
static gboolean gimp_help_browser (Gimp *gimp) { static gboolean busy = FALSE; GimpProcedure *procedure; if (busy) return TRUE; busy = TRUE; /* Check if a help browser is already running */ procedure = gimp_pdb_lookup_procedure (gimp->pdb, "extension-gimp-help-browser-temp"); if (! procedure) { GValueArray *args = NULL; gint n_domains = 0; gchar **help_domains = NULL; gchar **help_uris = NULL; procedure = gimp_pdb_lookup_procedure (gimp->pdb, "extension-gimp-help-browser"); if (! procedure) { gimp_help_browser_error (gimp, _("Help browser not found"), _("Could not find GIMP help browser."), _("The GIMP help browser plug-in appears " "to be missing from your installation.")); busy = FALSE; return FALSE; } n_domains = gimp_plug_in_manager_get_help_domains (gimp->plug_in_manager, &help_domains, &help_uris); args = gimp_procedure_get_arguments (procedure); gimp_value_array_truncate (args, 5); g_value_set_int (&args->values[0], GIMP_RUN_INTERACTIVE); g_value_set_int (&args->values[1], n_domains); gimp_value_take_stringarray (&args->values[2], help_domains, n_domains); g_value_set_int (&args->values[3], n_domains); gimp_value_take_stringarray (&args->values[4], help_uris, n_domains); gimp_procedure_execute_async (procedure, gimp, gimp_get_user_context (gimp), NULL, args, NULL); g_value_array_free (args); } /* Check if the help browser started properly */ procedure = gimp_pdb_lookup_procedure (gimp->pdb, "extension-gimp-help-browser-temp"); if (! procedure) { gimp_help_browser_error (gimp, _("Help browser doesn't start"), _("Could not start the GIMP help browser plug-in."), NULL); busy = FALSE; return FALSE; } busy = FALSE; return TRUE; }
GList * lgm_device_enum_devices (const gchar * source_name, LgmDeviceType type) { GstElement *source; GstPropertyProbe *probe; GValueArray *va; const gchar *prop_name; GList *list = NULL; guint i = 0; source = gst_element_factory_make (source_name, "source"); if (!source || !GST_IS_PROPERTY_PROBE (source)) goto finish; gst_element_set_state (source, GST_STATE_READY); gst_element_get_state (source, NULL, NULL, 5 * GST_SECOND); probe = GST_PROPERTY_PROBE (source); prop_name = lgm_device_get_property_name_for_source (source_name); va = gst_property_probe_probe_and_get_values_name (probe, prop_name); gst_element_set_state (source, GST_STATE_NULL); gst_element_get_state (source, NULL, NULL, 5 * GST_SECOND); gst_object_unref (source); if (!va) goto finish; for (i = 0; i < va->n_values; ++i) { GValue *v = g_value_array_get_nth (va, i); GValue valstr = { 0, }; LgmDevice *device; gchar *name; g_value_init (&valstr, G_TYPE_STRING); if (!g_value_transform (v, &valstr)) continue; /* Skip blackmagic on avfvideosrc as we only properly support them * through decklinkvideosrc. */ if (!g_strcmp0 (source_name, "avfvideosrc")) if (!g_strcmp0 (g_value_get_string (&valstr), "Blackmagic")) continue; /* Use the pattern "Blackmagic%d" for device name when decklinkvideosrc */ if (!g_strcmp0 (source_name, "decklinkvideosrc")) name = g_strdup_printf ("Blackmagic%s", g_value_get_string (&valstr)); else name = g_value_dup_string (&valstr); device = lgm_device_new (source_name, name, type); g_value_unset (&valstr); g_free (name); lgm_device_fill_formats (device, prop_name); list = g_list_append (list, device); } g_value_array_free (va); finish: { return list; } }
/** * up_wakeups_get_data_sync: * @wakeups: a #UpWakeups instance. * @cancellable: a #GCancellable or %NULL * @error: a #GError, or %NULL. * * Gets the wakeups data from the daemon. * * Return value: an array of %UpWakeupItem's * * Since: 0.9.1 **/ GPtrArray * up_wakeups_get_data_sync (UpWakeups *wakeups, GCancellable *cancellable, GError **error) { GError *error_local = NULL; GType g_type_gvalue_array; GPtrArray *gvalue_ptr_array = NULL; GValueArray *gva; GValue *gv; guint i; UpWakeupItem *item; GPtrArray *array = NULL; gboolean ret; g_return_val_if_fail (UP_IS_WAKEUPS (wakeups), NULL); g_return_val_if_fail (wakeups->priv->proxy != NULL, NULL); g_type_gvalue_array = dbus_g_type_get_collection ("GPtrArray", dbus_g_type_get_struct("GValueArray", G_TYPE_BOOLEAN, G_TYPE_UINT, G_TYPE_DOUBLE, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID)); /* get compound data */ ret = dbus_g_proxy_call (wakeups->priv->proxy, "GetData", &error_local, G_TYPE_INVALID, g_type_gvalue_array, &gvalue_ptr_array, G_TYPE_INVALID); if (!ret) { g_warning ("GetData on failed: %s", error_local->message); g_set_error (error, 1, 0, "%s", error_local->message); g_error_free (error_local); goto out; } /* no data */ if (gvalue_ptr_array->len == 0) goto out; /* convert */ array = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); for (i=0; i<gvalue_ptr_array->len; i++) { gva = (GValueArray *) g_ptr_array_index (gvalue_ptr_array, i); item = up_wakeup_item_new (); /* 0 */ gv = g_value_array_get_nth (gva, 0); up_wakeup_item_set_is_userspace (item, g_value_get_boolean (gv)); g_value_unset (gv); /* 1 */ gv = g_value_array_get_nth (gva, 1); up_wakeup_item_set_id (item, g_value_get_uint (gv)); g_value_unset (gv); /* 2 */ gv = g_value_array_get_nth (gva, 2); up_wakeup_item_set_value (item, g_value_get_double (gv)); g_value_unset (gv); /* 3 */ gv = g_value_array_get_nth (gva, 3); up_wakeup_item_set_cmdline (item, g_value_get_string (gv)); g_value_unset (gv); /* 4 */ gv = g_value_array_get_nth (gva, 4); up_wakeup_item_set_details (item, g_value_get_string (gv)); g_value_unset (gv); /* add */ g_ptr_array_add (array, item); g_value_array_free (gva); } out: if (gvalue_ptr_array != NULL) g_ptr_array_unref (gvalue_ptr_array); return array; }
static gpointer build_ip6_address_or_route (const char *key_name, const char *address_str, guint32 plen, const char *gateway_str, const char *metric_str, gboolean route) { GValueArray *result; struct in6_addr addr; GByteArray *address; GByteArray *gateway; guint32 metric = 0; GValue value = G_VALUE_INIT; int err; g_return_val_if_fail (address_str, NULL); result = g_value_array_new (3); /* add address */ err = inet_pton (AF_INET6, address_str, &addr); if (err <= 0) { g_warning ("%s: ignoring invalid IPv6 address '%s'", __func__, address_str); goto error_out; } address = g_byte_array_new (); g_byte_array_append (address, (guint8 *) addr.s6_addr, 16); g_value_init (&value, DBUS_TYPE_G_UCHAR_ARRAY); g_value_take_boxed (&value, address); g_value_array_append (result, &value); g_value_unset (&value); /* add prefix length */ g_value_init (&value, G_TYPE_UINT); g_value_set_uint (&value, plen); g_value_array_append (result, &value); g_value_unset (&value); /* add gateway */ if (gateway_str && gateway_str[0]) { err = inet_pton (AF_INET6, gateway_str, &addr); if (err <= 0) { /* Try workaround for routes written by broken keyfile writer. * Due to bug bgo#719851, an older version of writer would have * written "a:b:c:d::/plen,metric" if the gateway was ::, instead * of "a:b:c:d::/plen,,metric" or "a:b:c:d::/plen,::,metric" * Try workaround by interepeting gateway_str as metric to accept such * invalid routes. This broken syntax should not be not officially * supported. **/ if (route && !metric_str && get_one_int (gateway_str, G_MAXUINT32, NULL, &metric)) addr = in6addr_any; else { g_warning ("%s: ignoring invalid IPv6 gateway '%s'", __func__, gateway_str); goto error_out; } } } else addr = in6addr_any; /* parse metric, default to 0 */ if (metric_str) { if (!get_one_int (metric_str, G_MAXUINT32, key_name, &metric)) goto error_out; } gateway = g_byte_array_new (); g_byte_array_append (gateway, (guint8 *) addr.s6_addr, 16); g_value_init (&value, DBUS_TYPE_G_UCHAR_ARRAY); g_value_take_boxed (&value, gateway); g_value_array_append (result, &value); g_value_unset (&value); /* add metric (for routing) */ if (route) { g_value_init (&value, G_TYPE_UINT); g_value_set_uint (&value, metric); g_value_array_append (result, &value); g_value_unset (&value); } return result; error_out: g_value_array_free (result); return NULL; }