static void geometry_start_element_callback (GMarkupParseContext *pcontext, const gchar *element_name, const gchar **attribute_names, const gchar **attribute_values, gpointer user_data, GError **error) { GeometryParseData *data = user_data; const gchar *attribute; if (!validate (geometry_valid_path_list, G_N_ELEMENTS (geometry_valid_path_list), element_name, data->element_stack, error)) { return; } if (g_strcmp0 (element_name, "bounds") == 0) { EekBounds bounds; attribute = get_attribute (attribute_names, attribute_values, "x"); if (attribute == NULL) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_MISSING_ATTRIBUTE, "no \"x\" attribute for \"bounds\""); return; } bounds.x = g_strtod (attribute, NULL); attribute = get_attribute (attribute_names, attribute_values, "y"); if (attribute == NULL) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_MISSING_ATTRIBUTE, "no \"y\" attribute for \"bounds\""); return; } bounds.y = g_strtod (attribute, NULL); attribute = get_attribute (attribute_names, attribute_values, "width"); if (attribute == NULL) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_MISSING_ATTRIBUTE, "no \"width\" attribute for \"bounds\""); return; } bounds.width = g_strtod (attribute, NULL); attribute = get_attribute (attribute_names, attribute_values, "height"); if (attribute == NULL) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_MISSING_ATTRIBUTE, "no \"height\" attribute for \"bounds\""); return; } bounds.height = g_strtod (attribute, NULL); if (g_strcmp0 (data->element_stack->data, "geometry") == 0) eek_element_set_bounds (EEK_ELEMENT(data->keyboard), &bounds); else if (g_strcmp0 (data->element_stack->data, "section") == 0) eek_element_set_bounds (EEK_ELEMENT(data->section), &bounds); else if (g_strcmp0 (data->element_stack->data, "key") == 0) eek_element_set_bounds (EEK_ELEMENT(data->key), &bounds); goto out; } if (g_strcmp0 (element_name, "section") == 0) { data->section = eek_keyboard_create_section (data->keyboard); attribute = get_attribute (attribute_names, attribute_values, "id"); if (attribute != NULL) eek_element_set_name (EEK_ELEMENT(data->section), attribute); attribute = get_attribute (attribute_names, attribute_values, "angle"); if (attribute != NULL) { gint angle; angle = strtol (attribute, NULL, 10); eek_section_set_angle (data->section, angle); } goto out; } if (g_strcmp0 (element_name, "row") == 0) { attribute = get_attribute (attribute_names, attribute_values, "orientation"); if (attribute != NULL) data->orientation = strtol (attribute, NULL, 10); eek_section_add_row (data->section, data->num_columns, data->orientation); data->num_rows++; goto out; } if (g_strcmp0 (element_name, "key") == 0) { guint keycode; attribute = get_attribute (attribute_names, attribute_values, "keycode"); if (attribute == NULL) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_MISSING_ATTRIBUTE, "no \"keycode\" attribute for \"key\""); return; } keycode = strtoul (attribute, NULL, 10); data->key = eek_section_create_key (data->section, keycode, data->num_columns, data->num_rows - 1); attribute = get_attribute (attribute_names, attribute_values, "name"); if (attribute != NULL) eek_element_set_name (EEK_ELEMENT(data->key), attribute); attribute = get_attribute (attribute_names, attribute_values, "oref"); if (attribute == NULL) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_MISSING_ATTRIBUTE, "no \"oref\" attribute for \"key\""); return; } g_hash_table_insert (data->key_oref_hash, data->key, g_strdup (attribute)); data->num_columns++; goto out; } if (g_strcmp0 (element_name, "outline") == 0) { attribute = get_attribute (attribute_names, attribute_values, "id"); if (attribute == NULL) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_MISSING_ATTRIBUTE, "no \"id\" attribute for \"outline\""); return; } data->oref = g_strdup (attribute); attribute = get_attribute (attribute_names, attribute_values, "corner-radius"); if (attribute != NULL) data->corner_radius = g_strtod (attribute, NULL); goto out; } if (g_strcmp0 (element_name, "point") == 0) { EekPoint *point; gdouble x, y; attribute = get_attribute (attribute_names, attribute_values, "x"); if (attribute == NULL) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_MISSING_ATTRIBUTE, "no \"x\" attribute for \"bounds\""); return; } x = g_strtod (attribute, NULL); attribute = get_attribute (attribute_names, attribute_values, "y"); if (attribute == NULL) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_MISSING_ATTRIBUTE, "no \"y\" attribute for \"bounds\""); return; } y = g_strtod (attribute, NULL); point = g_slice_new (EekPoint); point->x = x; point->y = y; data->points = g_slist_prepend (data->points, point); goto out; } out: data->element_stack = g_slist_prepend (data->element_stack, g_strdup (element_name)); }
static inline RenderFrame * render_frame_new (void) { return g_slice_new (RenderFrame); }
/** * fs_codec_list_from_keyfile * @filename: Name of the #GKeyFile to read the codecs parameters from * @error: location of a #GError, or NULL if no error occured * * Reads the content of a #GKeyFile of the following format into * a #GList of #FsCodec structures. * * * Example: * |[ * [audio/codec1] * clock-rate=8000 * * [audio/codec1:1] * clock-rate=16000 * * [audio/codec2] * one_param=QCIF * another_param=WOW * * [video/codec3] * wierd_param=42 * feedback:nack/pli=1 * feedback:tfrc= * ]| * * Return value: (element-type FsCodec) (transfer full): * The #GList of #FsCodec or %NULL if the keyfile was empty or an error occured. */ GList * fs_codec_list_from_keyfile (const gchar *filename, GError **error) { GKeyFile *keyfile = NULL; GList *codecs = NULL; GError *gerror = NULL; gchar **groups = NULL; gsize groups_count = 0; int i; g_return_val_if_fail (filename, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); keyfile = g_key_file_new (); if (!g_key_file_load_from_file (keyfile, filename, G_KEY_FILE_NONE, error)) { goto out; } groups = g_key_file_get_groups (keyfile, &groups_count); if (!groups) goto out; for (i=0; i < groups_count && groups[i]; i++) { FsCodec *codec; gchar **keys = NULL; gsize keys_count; int j; gchar *encoding_name = NULL; gchar *next_tok = NULL; FsMediaType media_type; keys = g_key_file_get_keys (keyfile, groups[i], &keys_count, &gerror); if (!keys || gerror) { if (gerror) GST_WARNING ("Unable to read parameters for %s: %s\n", groups[i], gerror->message); else GST_WARNING ("Unknown errors while reading parameters for %s", groups[i]); g_clear_error (&gerror); goto next_codec; } next_tok = strchr (groups[i], '/'); if (!next_tok) { GST_WARNING ("Invalid codec name: %s", groups[i]); goto next_codec; } if ((next_tok - groups[i]) == 5 /* strlen ("audio") */ && !g_ascii_strncasecmp ("audio", groups[i], 5)) { media_type = FS_MEDIA_TYPE_AUDIO; } else if ((next_tok - groups[i]) == 5 /* strlen ("video") */ && !g_ascii_strncasecmp ("video", groups[i], 5)) { media_type = FS_MEDIA_TYPE_VIDEO; } else { GST_WARNING ("Invalid media type in codec name name %s", groups[i]); goto next_codec; } encoding_name = next_tok + 1; next_tok = strchr (encoding_name, ':'); if (encoding_name[0] == 0 || next_tok - encoding_name == 1) goto next_codec; if (next_tok) encoding_name = g_strndup (encoding_name, next_tok - encoding_name); else encoding_name = g_strdup (encoding_name); codec = fs_codec_new (FS_CODEC_ID_ANY, encoding_name, media_type, 0); g_free (encoding_name); for (j = 0; j < keys_count && keys[j]; j++) { if (!g_ascii_strcasecmp ("clock-rate", keys[j])) { codec->clock_rate = g_key_file_get_integer (keyfile, groups[i], keys[j], &gerror); if (gerror) { codec->clock_rate = 0; goto keyerror; } } else if (!g_ascii_strcasecmp ("id", keys[j])) { codec->id = g_key_file_get_integer (keyfile, groups[i], keys[j], &gerror); if (gerror) { codec->id = FS_CODEC_ID_ANY; goto keyerror; } if (codec->id < 0) codec->id = FS_CODEC_ID_DISABLE; } else if (!g_ascii_strcasecmp ("channels", keys[j])) { codec->channels = g_key_file_get_integer (keyfile, groups[i], keys[j], &gerror); if (gerror) { codec->channels = 0; goto keyerror; } } else if (!g_ascii_strcasecmp ("trr-int", keys[j])) { codec->minimum_reporting_interval = g_key_file_get_integer (keyfile, groups[i], keys[j], &gerror); if (gerror) { codec->minimum_reporting_interval = G_MAXUINT; goto keyerror; } } else if (g_str_has_prefix (keys[j], "feedback:")) { gchar *type = keys[j] + strlen ("feedback:"); gchar *subtype = strchr (type, '/'); gchar *extra_params; extra_params = g_key_file_get_string (keyfile, groups[i], keys[j], &gerror); if (gerror) goto keyerror; /* Replace / with \0 and point to name (the next char) */ if (subtype) { *subtype=0; subtype++; } else { subtype = ""; } fs_codec_add_feedback_parameter (codec, type, subtype, extra_params); g_free (extra_params); } else { FsCodecParameter *param = g_slice_new (FsCodecParameter); param->name = g_strdup (keys[j]); param->value = g_key_file_get_string (keyfile, groups[i], keys[j], &gerror); if (gerror) { fs_codec_parameter_free (param); goto keyerror; } if (!param->name || !param->value) fs_codec_parameter_free (param); else codec->optional_params = g_list_append (codec->optional_params, param); } continue; keyerror: GST_WARNING ("Error reading key %s codec %s: %s", keys[j], groups[i], gerror->message); g_clear_error (&gerror); } codecs = g_list_append (codecs, codec); next_codec: g_strfreev (keys); } out: g_strfreev (groups); g_key_file_free (keyfile); return codecs; }
int main(int argc, char *argv[]) { wtap *wth = NULL; wtap_dumper *pdh = NULL; Buffer buf; int err; gchar *err_info; gint64 data_offset; const struct wtap_pkthdr *phdr; guint wrong_order_count = 0; gboolean write_output_regardless = TRUE; guint i; wtapng_section_t *shb_hdr; wtapng_iface_descriptions_t *idb_inf; GPtrArray *frames; FrameRecord_t *prevFrame = NULL; int opt; int file_count; char *infile; char *outfile; /* Process the options first */ while ((opt = getopt(argc, argv, "hn")) != -1) { switch (opt) { case 'n': write_output_regardless = FALSE; break; case 'h': usage(FALSE); exit(0); case '?': usage(TRUE); exit(1); } } /* Remaining args are file names */ file_count = argc - optind; if (file_count == 2) { infile = argv[optind]; outfile = argv[optind+1]; } else { usage(TRUE); exit(1); } init_open_routines(); /* Open infile */ wth = wtap_open_offline(infile, WTAP_TYPE_AUTO, &err, &err_info, TRUE); if (wth == NULL) { fprintf(stderr, "reordercap: Can't open %s: %s\n", infile, wtap_strerror(err)); switch (err) { case WTAP_ERR_UNSUPPORTED: case WTAP_ERR_UNSUPPORTED_ENCAP: case WTAP_ERR_BAD_FILE: fprintf(stderr, "(%s)\n", err_info); g_free(err_info); break; } exit(1); } DEBUG_PRINT("file_type_subtype is %u\n", wtap_file_type_subtype(wth)); shb_hdr = wtap_file_get_shb_info(wth); idb_inf = wtap_file_get_idb_info(wth); /* Open outfile (same filetype/encap as input file) */ pdh = wtap_dump_open_ng(outfile, wtap_file_type_subtype(wth), wtap_file_encap(wth), 65535, FALSE, shb_hdr, idb_inf, &err); g_free(idb_inf); if (pdh == NULL) { fprintf(stderr, "reordercap: Failed to open output file: (%s) - error %s\n", outfile, wtap_strerror(err)); g_free(shb_hdr); exit(1); } /* Allocate the array of frame pointers. */ frames = g_ptr_array_new(); /* Read each frame from infile */ while (wtap_read(wth, &err, &err_info, &data_offset)) { FrameRecord_t *newFrameRecord; phdr = wtap_phdr(wth); newFrameRecord = g_slice_new(FrameRecord_t); newFrameRecord->num = frames->len + 1; newFrameRecord->offset = data_offset; newFrameRecord->time = phdr->ts; if (prevFrame && frames_compare(&newFrameRecord, &prevFrame) < 0) { wrong_order_count++; } g_ptr_array_add(frames, newFrameRecord); prevFrame = newFrameRecord; } if (err != 0) { /* Print a message noting that the read failed somewhere along the line. */ fprintf(stderr, "reordercap: An error occurred while reading \"%s\": %s.\n", infile, wtap_strerror(err)); switch (err) { case WTAP_ERR_UNSUPPORTED: case WTAP_ERR_UNSUPPORTED_ENCAP: case WTAP_ERR_BAD_FILE: fprintf(stderr, "(%s)\n", err_info); g_free(err_info); break; } } printf("%u frames, %u out of order\n", frames->len, wrong_order_count); /* Sort the frames */ if (wrong_order_count > 0) { g_ptr_array_sort(frames, frames_compare); } /* Write out each sorted frame in turn */ buffer_init(&buf, 1500); for (i = 0; i < frames->len; i++) { FrameRecord_t *frame = (FrameRecord_t *)frames->pdata[i]; /* Avoid writing if already sorted and configured to */ if (write_output_regardless || (wrong_order_count > 0)) { frame_write(frame, wth, pdh, &buf, infile); } g_slice_free(FrameRecord_t, frame); } buffer_free(&buf); if (!write_output_regardless && (wrong_order_count == 0)) { printf("Not writing output file because input file is already in order!\n"); } /* Free the whole array */ g_ptr_array_free(frames, TRUE); /* Close outfile */ if (!wtap_dump_close(pdh, &err)) { fprintf(stderr, "reordercap: Error closing %s: %s\n", outfile, wtap_strerror(err)); g_free(shb_hdr); exit(1); } g_free(shb_hdr); /* Finally, close infile */ wtap_fdclose(wth); return 0; }
/* HOLDS: g_dataset_global_lock */ static inline gpointer g_data_set_internal (GData **datalist, GQuark key_id, gpointer data, GDestroyNotify destroy_func, GDataset *dataset) { register GData *list; list = G_DATALIST_GET_POINTER (datalist); if (!data) { register GData *prev; prev = NULL; while (list) { if (list->id == key_id) { gpointer ret_data = NULL; if (prev) prev->next = list->next; else { G_DATALIST_SET_POINTER (datalist, list->next); /* the dataset destruction *must* be done * prior to invocation of the data destroy function */ if (!list->next && dataset) g_dataset_destroy_internal (dataset); } /* the GData struct *must* already be unlinked * when invoking the destroy function. * we use (data==NULL && destroy_func!=NULL) as * a special hint combination to "steal" * data without destroy notification */ if (list->destroy_func && !destroy_func) { G_UNLOCK (g_dataset_global); list->destroy_func (list->data); G_LOCK (g_dataset_global); } else ret_data = list->data; g_slice_free (GData, list); return ret_data; } prev = list; list = list->next; } } else { while (list) { if (list->id == key_id) { if (!list->destroy_func) { list->data = data; list->destroy_func = destroy_func; } else { register GDestroyNotify dfunc; register gpointer ddata; dfunc = list->destroy_func; ddata = list->data; list->data = data; list->destroy_func = destroy_func; /* we need to have updated all structures prior to * invocation of the destroy function */ G_UNLOCK (g_dataset_global); dfunc (ddata); G_LOCK (g_dataset_global); } return NULL; } list = list->next; } list = g_slice_new (GData); list->next = G_DATALIST_GET_POINTER (datalist); list->id = key_id; list->data = data; list->destroy_func = destroy_func; G_DATALIST_SET_POINTER (datalist, list); } return NULL; }
static void inf_gtk_certificate_manager_certificate_func(InfXmppConnection* connection, gnutls_session_t session, InfCertificateChain* chain, gpointer user_data) { InfGtkCertificateManager* manager; InfGtkCertificateManagerPrivate* priv; InfGtkCertificateDialogFlags flags; gnutls_x509_crt_t presented_cert; gnutls_x509_crt_t known_cert; gchar* hostname; gboolean match_hostname; gboolean issuer_known; gnutls_x509_crt_t root_cert; int ret; unsigned int verify; GHashTable* table; gboolean cert_equal; time_t expiration_time; InfGtkCertificateManagerQuery* query; gchar* text; GtkWidget* vbox; GtkWidget* button; GtkWidget* image; GtkWidget* label; GError* error; manager = INF_GTK_CERTIFICATE_MANAGER(user_data); priv = INF_GTK_CERTIFICATE_MANAGER_PRIVATE(manager); g_object_get(G_OBJECT(connection), "remote-hostname", &hostname, NULL); presented_cert = inf_certificate_chain_get_own_certificate(chain); match_hostname = gnutls_x509_crt_check_hostname(presented_cert, hostname); /* First, validate the certificate */ ret = gnutls_certificate_verify_peers2(session, &verify); error = NULL; if(ret != GNUTLS_E_SUCCESS) inf_gnutls_set_error(&error, ret); /* Remove the GNUTLS_CERT_ISSUER_NOT_KNOWN flag from the verification * result, and if the certificate is still invalid, then set an error. */ if(error == NULL) { issuer_known = TRUE; if(verify & GNUTLS_CERT_SIGNER_NOT_FOUND) { issuer_known = FALSE; /* Re-validate the certificate for other failure reasons -- * unfortunately the gnutls_certificate_verify_peers2() call * does not tell us whether the certificate is otherwise invalid * if a signer is not found already. */ /* TODO: Here it would be good to use the verify flags from the * certificate credentials, but GnuTLS does not have API to * retrieve them. */ root_cert = inf_certificate_chain_get_root_certificate(chain); ret = gnutls_x509_crt_list_verify( inf_certificate_chain_get_raw(chain), inf_certificate_chain_get_n_certificates(chain), &root_cert, 1, NULL, 0, GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT, &verify ); if(ret != GNUTLS_E_SUCCESS) inf_gnutls_set_error(&error, ret); else if(verify & GNUTLS_CERT_INVALID) inf_gnutls_certificate_verification_set_error(&error, verify); } } /* Look up the host in our database of pinned certificates if we could not * fully verify the certificate, i.e. if either the issuer is not known or * the hostname of the connection does not match the certificate. */ table = NULL; if(error == NULL) { known_cert = NULL; if(!match_hostname || !issuer_known) { /* If we cannot load the known host file, then cancel the connection. * Otherwise it might happen that someone shows us a certificate that we * tell the user we don't know, if though actually for that host we expect * a different certificate. */ table = inf_gtk_certificate_manager_ref_known_hosts(manager, &error); if(table != NULL) known_cert = g_hash_table_lookup(table, hostname); } } /* Next, configure the flags for the dialog to be shown based on the * verification result, and on whether the pinned certificate matches * the one presented by the host or not. */ flags = 0; if(error == NULL) { if(known_cert != NULL) { cert_equal = inf_gtk_certificate_manager_compare_fingerprint( known_cert, presented_cert, &error ); if(error == NULL && cert_equal == FALSE) { if(!match_hostname) flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_HOSTNAME_MISMATCH; if(!issuer_known) flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_ISSUER_NOT_KNOWN; flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_UNEXPECTED; expiration_time = gnutls_x509_crt_get_expiration_time(known_cert); if(expiration_time != (time_t)(-1)) { expiration_time -= INF_GTK_CERTIFICATE_MANAGER_EXPIRATION_TOLERANCE; if(time(NULL) > expiration_time) { flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_OLD_EXPIRED; } } } } else { if(!match_hostname) flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_HOSTNAME_MISMATCH; if(!issuer_known) flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_ISSUER_NOT_KNOWN; } } /* Now proceed either by accepting the connection, rejecting it, or * bothering the user with an annoying dialog. */ if(error == NULL) { if(flags == 0) { if(match_hostname && issuer_known) { /* Remove the pinned entry if we now have a valid certificate for * this host. */ if(table != NULL && g_hash_table_remove(table, hostname) == TRUE) { inf_gtk_certificate_manager_write_known_hosts_with_warning( manager, table ); } } inf_xmpp_connection_certificate_verify_continue(connection); } else { query = g_slice_new(InfGtkCertificateManagerQuery); query->manager = manager; query->known_hosts = table; query->connection = connection; query->dialog = inf_gtk_certificate_dialog_new( priv->parent_window, 0, flags, hostname, chain ); query->certificate_chain = chain; table = NULL; g_object_ref(query->connection); inf_certificate_chain_ref(chain); g_signal_connect( G_OBJECT(connection), "notify::status", G_CALLBACK(inf_gtk_certificate_manager_notify_status_cb), query ); g_signal_connect( G_OBJECT(query->dialog), "response", G_CALLBACK(inf_gtk_certificate_manager_response_cb), query ); image = gtk_image_new_from_stock(GTK_STOCK_CANCEL, GTK_ICON_SIZE_BUTTON); gtk_widget_show(image); button = gtk_dialog_add_button( GTK_DIALOG(query->dialog), _("_Cancel connection"), GTK_RESPONSE_REJECT ); gtk_button_set_image(GTK_BUTTON(button), image); image = gtk_image_new_from_stock(GTK_STOCK_CONNECT, GTK_ICON_SIZE_BUTTON); gtk_widget_show(image); button = gtk_dialog_add_button( GTK_DIALOG(query->dialog), _("C_ontinue connection"), GTK_RESPONSE_ACCEPT ); gtk_button_set_image(GTK_BUTTON(button), image); text = g_strdup_printf( _("Do you want to continue the connection to host \"%s\"? If you " "choose to continue, this certificate will be trusted in the " "future when connecting to this host."), hostname ); label = gtk_label_new(text); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_label_set_line_wrap_mode(GTK_LABEL(label), PANGO_WRAP_WORD_CHAR); gtk_label_set_width_chars(GTK_LABEL(label), 60); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); gtk_widget_show(label); g_free(text); vbox = gtk_dialog_get_content_area(GTK_DIALOG(query->dialog)); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); priv->queries = g_slist_prepend(priv->queries, query); gtk_window_present(GTK_WINDOW(query->dialog)); } } else { inf_xmpp_connection_certificate_verify_cancel(connection, error); g_error_free(error); } if(table != NULL) g_hash_table_unref(table); g_free(hostname); }
/** * pango_script_iter_new: * @text: a UTF-8 string * @length: length of @text, or -1 if @text is nul-terminated. * * Create a new #PangoScriptIter, used to break a string of * Unicode into runs by text. No copy is made of @text, so * the caller needs to make sure it remains valid until * the iterator is freed with pango_script_iter_free(). * * Return value: the new script iterator, initialized * to point at the first range in the text, which should be * freed with pango_script_iter_free(). If the string is * empty, it will point at an empty range. * * Since: 1.4 **/ PangoScriptIter * pango_script_iter_new (const char *text, int length) { return _pango_script_iter_init (g_slice_new (PangoScriptIter), text, length); }
static Tcs3_diag *css_diag(Tcs3_destination dest, Tcs3_style style, GtkWidget *transient_win, gboolean grab) { Tcs3_diag *diag; GtkWidget *scrolwin, *table, *but, *vbox, *hbox, *vbox2; GList *tmplist = NULL; Tcs3_arr tmp; gint count=0; GtkTreeSelection *selection; GtkCellRenderer *renderer; GtkTreeViewColumn *column; diag = g_slice_new(Tcs3_diag); diag->win = window_full2(_("Cascading Style Sheet Builder"), GTK_WIN_POS_CENTER_ON_PARENT, 12, G_CALLBACK(cs3d_destroy_lcb), diag, TRUE, transient_win); gtk_window_set_role(GTK_WINDOW(diag->win), "css"); diag->dest = dest; diag->styletype = style; diag->grab = grab; diag->selected_row = -1; vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(diag->win),vbox); table = gtk_table_new(3, 6, TRUE); gtk_table_set_row_spacings(GTK_TABLE(table), 12); gtk_table_set_col_spacings(GTK_TABLE(table), 12); gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0); tmplist = NULL; if (diag->styletype == multistyle) { tmplist = glist_with_html_tags(0); diag->selector = combobox_with_popdown("", tmplist,1); dialog_mnemonic_label_in_table(_("_Selector(s):"), diag->selector, table, 0, 1, 0, 1); gtk_table_attach_defaults(GTK_TABLE(table), diag->selector, 1 ,5 , 0, 1); gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(diag->selector), 5); gtk_combo_box_set_add_tearoffs(GTK_COMBO_BOX(diag->selector), 1); diag->html5 = gtk_check_button_new_with_mnemonic("_html 5"); gtk_table_attach_defaults(GTK_TABLE(table), diag->html5, 5,6, 0,1); g_signal_connect(diag->html5, "clicked", G_CALLBACK(cs3d_html5_clicked_lcb), diag); g_list_free(tmplist); tmplist = NULL; } tmp = cs3_arr[count]; while (tmp.property) { tmplist = g_list_append(tmplist, tmp.property); count++; tmp = cs3_arr[count]; } diag->property = combobox_with_popdown("", tmplist,1); g_list_free(tmplist); tmplist = NULL; g_signal_connect(gtk_bin_get_child(GTK_BIN(diag->property)), "activate", G_CALLBACK(cs3d_prop_activate_lcb), diag); g_signal_connect(gtk_bin_get_child(GTK_BIN(diag->property)), "changed", G_CALLBACK(cs3d_prop_activate_lcb), diag); diag->value = combobox_with_popdown("", tmplist,1); dialog_mnemonic_label_in_table(_("_Property:"), diag->property, table, 0, 1, 1, 2); gtk_table_attach_defaults(GTK_TABLE(table), diag->property, 1, 5, 1, 2); gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(diag->property), 4); gtk_combo_box_set_add_tearoffs(GTK_COMBO_BOX(diag->property), 1); dialog_mnemonic_label_in_table(_("_Value:"), diag->value, table, 0, 1, 2, 3); gtk_table_attach_defaults(GTK_TABLE(table), diag->value, 1, 4, 2, 3); gtk_widget_realize(diag->win); diag->extra_but = color_but_new(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(diag->value))), diag->win); gtk_table_attach(GTK_TABLE(table), diag->extra_but, 4, 5, 2, 3, GTK_EXPAND, GTK_EXPAND, 0, 0); /* the list widget and the buttons are in a horizontal box */ hbox = gtk_hbox_new(FALSE, 12); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 18); diag->lstore = gtk_list_store_new(3, G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(diag->lstore),0,GTK_SORT_ASCENDING); diag->lview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(diag->lstore)); g_object_unref(G_OBJECT(diag->lstore)); if (diag->styletype == multistyle) { renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (_("Selector(s)"),renderer,"text", 0,NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(diag->lview), column); } renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (_("Property"),renderer,"text", 1,NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(diag->lview), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (_("Value"),renderer,"text", 2,NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(diag->lview), column); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(diag->lview)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); g_signal_connect(G_OBJECT(selection), "changed",G_CALLBACK(cs3d_selection_changed_cb),diag); scrolwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request(scrolwin, 400, 300); gtk_box_pack_start(GTK_BOX(hbox), scrolwin, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(scrolwin), diag->lview); /*if (diag->styletype == multistyle) { gchar *titles[] = {_("Selector"), _("Property"), _("Value"), NULL}; diag->clist = gtk_clist_new_with_titles(3, titles); } else { gchar *titles[] = {_("Property"), _("Value"), NULL}; diag->clist = gtk_clist_new_with_titles(2, titles); } gtk_clist_set_sort_column(GTK_CLIST(diag->clist), 0); gtk_clist_set_auto_sort(GTK_CLIST(diag->clist), TRUE); g_signal_connect(diag->clist, "select_row", G_CALLBACK(cs3d_select_row_lcb), diag); g_signal_connect(diag->clist, "unselect_row", G_CALLBACK(cs3d_unselect_row_lcb), diag); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolwin), diag->lview); */ vbox2 = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, FALSE, 0); but = gtk_button_new_with_mnemonic(_(" _Add ")); g_signal_connect(but, "clicked", G_CALLBACK(cs3d_add_clicked_lcb), diag); gtk_box_pack_start(GTK_BOX(vbox2), but, FALSE, FALSE, 0); but = gtk_button_new_with_mnemonic(_(" _Update ")); g_signal_connect(but, "clicked", G_CALLBACK(cs3d_update_clicked_lcb), diag); gtk_box_pack_start(GTK_BOX(vbox2), but, FALSE, FALSE, 0); but = gtk_button_new_with_mnemonic(_(" _Delete ")); g_signal_connect(but, "clicked", G_CALLBACK(cs3d_del_clicked_lcb), diag); gtk_box_pack_start(GTK_BOX(vbox2), but, FALSE, FALSE, 0); /* the ok and cancel button are in a horizontal box below */ hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 12); #if GTK_CHECK_VERSION(3,0,0) hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); #else hbox = gtk_hbutton_box_new(); #endif gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(hbox), 12); but = bf_stock_cancel_button(G_CALLBACK(cs3d_cancel_clicked_lcb), diag); gtk_box_pack_start(GTK_BOX(hbox), but, FALSE, FALSE, 0); but = bf_stock_ok_button(G_CALLBACK(cs3d_ok_clicked_lcb), diag); gtk_box_pack_start(GTK_BOX(hbox), but, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); gtk_widget_show_all(diag->win); cs3d_prop_activate_lcb(NULL, diag); if (diag->grab) { gtk_grab_add(diag->win); } return diag; }
/* * gst_registry_chunks_save_pad_template: * * Store pad_templates in binary chunks. * * Returns: %TRUE for success */ static gboolean gst_registry_chunks_save_pad_template (GList ** list, GstStaticPadTemplate * template) { GstRegistryChunkPadTemplate *pt; GstRegistryChunk *chk; pt = g_slice_new (GstRegistryChunkPadTemplate); chk = gst_registry_chunks_make_data (pt, sizeof (GstRegistryChunkPadTemplate)); pt->presence = template->presence; pt->direction = template->direction; /* pack pad template strings */ gst_registry_chunks_save_const_string (list, (gchar *) (template->static_caps.string)); gst_registry_chunks_save_const_string (list, template->name_template); *list = g_list_prepend (*list, chk); return TRUE; }
static void resource_available (GSSDPResourceBrowser *resource_browser, SoupMessageHeaders *headers) { GSSDPResourceBrowserPrivate *priv; const char *usn; const char *header; Resource *resource; gboolean was_cached; guint timeout; GList *locations; gboolean destroyLocations; GList *it1, *it2; char *canonical_usn; priv = gssdp_resource_browser_get_instance_private (resource_browser); usn = soup_message_headers_get_one (headers, "USN"); if (!usn) return; /* No USN specified */ /* Build list of locations */ locations = NULL; destroyLocations = TRUE; header = soup_message_headers_get_one (headers, "Location"); if (header) locations = g_list_append (locations, g_strdup (header)); header = soup_message_headers_get_one (headers, "AL"); if (header) { /* Parse AL header. The format is: * <uri1><uri2>... */ const char *start, *end; char *uri; start = header; while ((start = strchr (start, '<'))) { start += 1; if (!start || !*start) break; end = strchr (start, '>'); if (!end || !*end) break; uri = g_strndup (start, end - start); locations = g_list_append (locations, uri); start = end; } } if (!locations) return; /* No location specified */ if (priv->version > 0) { char *version; version = g_strrstr (usn, ":"); canonical_usn = g_strndup (usn, version - usn); } else { canonical_usn = g_strdup (usn); } /* Get from cache, if possible */ resource = g_hash_table_lookup (priv->resources, canonical_usn); /* Put usn into fresh resources, so this resource will not be * removed on cache refreshing. */ if (priv->fresh_resources != NULL) { g_hash_table_add (priv->fresh_resources, g_strdup (canonical_usn)); } /* If location does not match, expect that we missed bye bye packet */ if (resource) { for (it1 = locations, it2 = resource->locations; it1 && it2; it1 = it1->next, it2 = it2->next) { if (strcmp ((const char *) it1->data, (const char *) it2->data) != 0) { resource_unavailable (resource_browser, headers); /* Will be destroyed by resource_unavailable */ resource = NULL; break; } } } if (resource) { /* Remove old timeout */ g_source_destroy (resource->timeout_src); was_cached = TRUE; } else { /* Create new Resource data structure */ resource = g_slice_new (Resource); resource->resource_browser = resource_browser; resource->usn = g_strdup (usn); resource->locations = locations; destroyLocations = FALSE; /* Ownership passed to resource */ g_hash_table_insert (priv->resources, canonical_usn, resource); was_cached = FALSE; /* hash-table takes ownership of this */ canonical_usn = NULL; } g_free (canonical_usn); /* Calculate new timeout */ header = soup_message_headers_get_one (headers, "Cache-Control"); if (header) { GSList *list; int res; res = 0; for (list = soup_header_parse_list (header); list; list = list->next) { res = sscanf (list->data, "max-age = %d", &timeout); if (res == 1) break; } if (res != 1) { g_warning ("Invalid 'Cache-Control' header. Assuming " "default max-age of %d.\n" "Header was:\n%s", SSDP_DEFAULT_MAX_AGE, header); timeout = SSDP_DEFAULT_MAX_AGE; } soup_header_free_list (list); } else { const char *expires; expires = soup_message_headers_get_one (headers, "Expires"); if (expires) { SoupDate *soup_exp_time; time_t exp_time, cur_time; soup_exp_time = soup_date_new_from_string (expires); exp_time = soup_date_to_time_t (soup_exp_time); soup_date_free (soup_exp_time); cur_time = time (NULL); if (exp_time > cur_time) timeout = exp_time - cur_time; else { g_warning ("Invalid 'Expires' header. Assuming " "default max-age of %d.\n" "Header was:\n%s", SSDP_DEFAULT_MAX_AGE, expires); timeout = SSDP_DEFAULT_MAX_AGE; } } else { g_warning ("No 'Cache-Control' nor any 'Expires' " "header was specified. Assuming default " "max-age of %d.", SSDP_DEFAULT_MAX_AGE); timeout = SSDP_DEFAULT_MAX_AGE; } } resource->timeout_src = g_timeout_source_new_seconds (timeout); g_source_set_callback (resource->timeout_src, resource_expire, resource, NULL); g_source_attach (resource->timeout_src, g_main_context_get_thread_default ()); g_source_unref (resource->timeout_src); /* Only continue with signal emission if this resource was not * cached already */ if (!was_cached) { /* Emit signal */ g_signal_emit (resource_browser, signals[RESOURCE_AVAILABLE], 0, usn, locations); } /* Cleanup */ if (destroyLocations) g_list_free_full (locations, g_free); }
P2trCDT* p2tr_cdt_new (P2tCDT *cdt) { P2tTrianglePtrArray cdt_tris = p2t_cdt_get_triangles (cdt); GHashTable *point_map = g_hash_table_new (g_direct_hash, g_direct_equal); P2trCDT *rmesh = g_slice_new (P2trCDT); gint i, j; rmesh->mesh = p2tr_mesh_new (); rmesh->outline = p2tr_pslg_new (); /* First iteration over the CDT - create all the points */ for (i = 0; i < cdt_tris->len; i++) { P2tTriangle *cdt_tri = triangle_index (cdt_tris, i); for (j = 0; j < 3; j++) { P2tPoint *cdt_pt = p2t_triangle_get_point(cdt_tri, j); P2trPoint *new_pt = g_hash_table_lookup (point_map, cdt_pt); if (new_pt == NULL) { new_pt = p2tr_point_new2 (cdt_pt->x, cdt_pt->y); g_hash_table_insert (point_map, cdt_pt, new_pt); } } } /* Second iteration over the CDT - create all the edges and find the * outline */ for (i = 0; i < cdt_tris->len; i++) { P2tTriangle *cdt_tri = triangle_index (cdt_tris, i); for (j = 0; j < 3; j++) { P2tPoint *start = p2t_triangle_get_point (cdt_tri, j); P2tPoint *end = p2t_triangle_get_point (cdt_tri, (j + 1) % 3); int edge_index = p2t_triangle_edge_index (cdt_tri, start, end); P2trPoint *start_new = g_hash_table_lookup (point_map, start); P2trPoint *end_new = g_hash_table_lookup (point_map, end); if (! p2tr_point_has_edge_to (start_new, end_new)) { gboolean constrained = cdt_tri->constrained_edge[edge_index]; P2trEdge *edge = p2tr_mesh_new_edge (rmesh->mesh, start_new, end_new, constrained); /* If the edge is constrained, we should add it to the * outline */ if (constrained) p2tr_pslg_add_new_line(rmesh->outline, &start_new->c, &end_new->c); /* We only wanted to create the edge now. We will use it * later */ p2tr_edge_unref (edge); } } } /* Third iteration over the CDT - create all the triangles */ for (i = 0; i < cdt_tris->len; i++) { P2tTriangle *cdt_tri = triangle_index (cdt_tris, i); P2trPoint *pt1 = g_hash_table_lookup (point_map, p2t_triangle_get_point (cdt_tri, 0)); P2trPoint *pt2 = g_hash_table_lookup (point_map, p2t_triangle_get_point (cdt_tri, 1)); P2trPoint *pt3 = g_hash_table_lookup (point_map, p2t_triangle_get_point (cdt_tri, 2)); P2trTriangle *new_tri = p2tr_mesh_new_triangle (rmesh->mesh, p2tr_point_get_edge_to(pt1, pt2), p2tr_point_get_edge_to(pt2, pt3), p2tr_point_get_edge_to(pt3, pt1)); /* We won't do any usage of the triangle, so just unref it */ p2tr_triangle_unref (new_tri); } return rmesh; }
static GskbStrTable * make_collision_free_hash_table (gsize sizeof_entry_data, gsize alignof_entry_data, guint n_entries, const GskbStrTableEntry *entries, GskbStrTableType table_type, guint size, const guint32 *hashes) { GskbStrTable *table; table = g_slice_new (GskbStrTable); guint ent_size; guint8 *ht_entries; guint i; guint str_slab_size, str_slab_offset; align_data (sizeof (HashEntry), ALIGNOF_HASH_ENTRY, sizeof_entry_data, alignof_entry_data, &table->sizeof_entry, &table->entry_data_offset); ent_size = table->sizeof_entry; ht_entries = g_malloc (ent_size * size); table->table_size = size; table->type = table_type; table->table_data = ht_entries; table->sizeof_entry_data = sizeof_entry_data; table->is_global = FALSE; table->is_ptr = FALSE; /* mark all entries unfilled. */ for (i = 0; i < size; i++) { HashEntry *e; e = (HashEntry*)(ht_entries + ent_size * i); e->hash_code = 0; e->str_slab_offset = G_MAXUINT32; memset (e + 1, 0, sizeof_entry_data); } str_slab_size = 0; str_slab_offset = 0; if (table_type == GSKB_STR_TABLE_ABLZ) { for (i = 0; i < n_entries; i++) { guint len = strlen (entries[i].str); if (len < 3) str_slab_size += 1; else if (len < 65536) str_slab_size += 1 + (len - 3); else g_return_val_if_reached (NULL); } table->str_slab = g_malloc (str_slab_size); for (i = 0; i < n_entries; i++) { guint len = strlen (entries[i].str); guint index = hashes[i] % size; HashEntry *e; e = (HashEntry *) (ht_entries + ent_size * index); g_assert (e->str_slab_offset == G_MAXUINT32); e->str_slab_offset = str_slab_offset; e->hash_code = hashes[i]; memcpy ((char*)e + table->entry_data_offset, entries[i].entry_data, sizeof_entry_data); table->str_slab[str_slab_offset++] = len>>8; if (len > 3) { memcpy (table->str_slab + str_slab_offset, entries[i].str + 2, len - 3); str_slab_offset += len - 3; } } } else { for (i = 0; i < n_entries; i++)
static void gimp_action_view_conflict_confirm (GimpActionView *view, GtkAction *action, guint accel_key, GdkModifierType accel_mask, const gchar *accel_path) { GimpActionGroup *group; gchar *label; gchar *accel_string; ConfirmData *confirm_data; GtkWidget *dialog; GimpMessageBox *box; g_object_get (action, "action-group", &group, NULL); label = gimp_strip_uline (gtk_action_get_label (action)); accel_string = gtk_accelerator_get_label (accel_key, accel_mask); confirm_data = g_slice_new (ConfirmData); confirm_data->manager = view->manager; confirm_data->accel_path = g_strdup (accel_path); confirm_data->accel_key = accel_key; confirm_data->accel_mask = accel_mask; dialog = gimp_message_dialog_new (_("Conflicting Shortcuts"), GIMP_STOCK_WARNING, gtk_widget_get_toplevel (GTK_WIDGET (view)), 0, gimp_standard_help_func, NULL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Reassign shortcut"), GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_signal_connect (dialog, "response", G_CALLBACK (gimp_action_view_conflict_response), confirm_data); box = GIMP_MESSAGE_DIALOG (dialog)->box; gimp_message_box_set_primary_text (box, _("Shortcut \"%s\" is already taken " "by \"%s\" from the \"%s\" group."), accel_string, label, group->label); gimp_message_box_set_text (box, _("Reassigning the shortcut will cause it " "to be removed from \"%s\"."), label); g_free (label); g_free (accel_string); g_object_unref (group); gtk_widget_show (dialog); }
static mate_pdu* new_pdu(mate_cfg_pdu* cfg, guint32 framenum, field_info* proto, proto_tree* tree) { mate_pdu* pdu = (mate_pdu*)g_slice_new(mate_max_size); field_info* cfi; GPtrArray* ptrs; mate_range* range; mate_range* proto_range; tmp_pdu_data data; guint i,j; gint min_dist; field_info* range_fi; gint32 last_start; gint32 first_end; gint32 curr_end; int hfid; dbg_print (dbg_pdu,1,dbg_facility,"new_pdu: type=%s framenum=%i",cfg->name,framenum); pdu->id = ++(cfg->last_id); pdu->cfg = cfg; pdu->avpl = new_avpl(cfg->name); pdu->frame = framenum; pdu->next_in_frame = NULL; pdu->rel_time = rd->now; pdu->gop = NULL; pdu->next = NULL; pdu->time_in_gop = -1.0f; pdu->first = FALSE; pdu->is_start = FALSE; pdu->is_stop = FALSE; pdu->after_release = FALSE; data.ranges = g_ptr_array_new(); data.pdu = pdu; data.tree = tree; /* first we create the proto range */ proto_range = (mate_range *)g_malloc(sizeof(mate_range)); proto_range->start = proto->start; proto_range->end = proto->start + proto->length; g_ptr_array_add(data.ranges,proto_range); dbg_print(dbg_pdu,3,dbg_facility,"new_pdu: proto range %u-%u",proto_range->start,proto_range->end); last_start = proto_range->start; /* we move forward in the tranport */ for (i = cfg->transport_ranges->len; i--; ) { hfid = *((int*)g_ptr_array_index(cfg->transport_ranges,i)); ptrs = proto_get_finfo_ptr_array(tree, hfid); min_dist = 99999; range_fi = NULL; if (ptrs) { for (j=0; j < ptrs->len; j++) { cfi = (field_info*) g_ptr_array_index(ptrs,j); if (cfi->start < last_start && min_dist >= (last_start - cfi->start) ) { range_fi = cfi; min_dist = last_start - cfi->start; } } if ( range_fi ) { range = (mate_range *)g_malloc(sizeof(*range)); range->start = range_fi->start; range->end = range_fi->start + range_fi->length; g_ptr_array_add(data.ranges,range); last_start = range_fi->start; dbg_print(dbg_pdu,3,dbg_facility,"new_pdu: transport(%i) range %i-%i",hfid,range->start,range->end); } else { /* we missed a range */ dbg_print(dbg_pdu,6,dbg_facility,"new_pdu: transport(%i) missed",hfid); } } } if (cfg->payload_ranges) { first_end = proto_range->end; for (i = 0 ; i < cfg->payload_ranges->len; i++) { hfid = *((int*)g_ptr_array_index(cfg->payload_ranges,i)); ptrs = proto_get_finfo_ptr_array(tree, hfid); min_dist = 99999; range_fi = NULL; if (ptrs) { for (j=0; j < ptrs->len; j++) { cfi = (field_info*) g_ptr_array_index(ptrs,j); curr_end = cfi->start + cfi->length; if (curr_end > first_end && min_dist >= (curr_end - first_end) ) { range_fi = cfi; min_dist = curr_end - first_end; } } if ( range_fi ) { range = (mate_range *)g_malloc(sizeof(*range)); range->start = range_fi->start; range->end = range_fi->start + range_fi->length; g_ptr_array_add(data.ranges,range); dbg_print(dbg_pdu,3,dbg_facility,"new_pdu: payload(%i) range %i-%i",hfid,range->start,range->end); } else { /* we missed a range */ dbg_print(dbg_pdu,5,dbg_facility,"new_pdu: payload(%i) missed",hfid); } } } } g_hash_table_foreach(cfg->hfids_attr,get_pdu_fields,&data); apply_transforms(pdu->cfg->transforms,pdu->avpl); g_ptr_array_free(data.ranges,TRUE); return pdu; }
static struct g_geom * g_bsd_taste(struct g_class *mp, struct g_provider *pp, int flags) { struct g_geom *gp; struct g_consumer *cp; int error, i; struct g_bsd_softc *ms; u_int secsize; struct g_slicer *gsp; u_char hash[16]; MD5_CTX md5sum; struct uuid uuid; g_trace(G_T_TOPOLOGY, "bsd_taste(%s,%s)", mp->name, pp->name); g_topology_assert(); /* We don't implement transparent inserts. */ if (flags == G_TF_TRANSPARENT) return (NULL); /* * BSD labels are a subclass of the general "slicing" topology so * a lot of the work can be done by the common "slice" code. * Create a geom with space for MAXPARTITIONS providers, one consumer * and a softc structure for us. Specify the provider to attach * the consumer to and our "start" routine for special requests. * The provider is opened with mode (1,0,0) so we can do reads * from it. */ gp = g_slice_new(mp, MAXPARTITIONS, pp, &cp, &ms, sizeof(*ms), g_bsd_start); if (gp == NULL) return (NULL); /* Get the geom_slicer softc from the geom. */ gsp = gp->softc; /* * The do...while loop here allows us to have multiple escapes * using a simple "break". This improves code clarity without * ending up in deep nesting and without using goto or come from. */ do { /* * If the provider is an MBR we will only auto attach * to type 165 slices in the G_TF_NORMAL case. We will * attach to any other type. */ error = g_getattr("MBR::type", cp, &i); if (!error) { if (i != 165 && flags == G_TF_NORMAL) break; error = g_getattr("MBR::offset", cp, &ms->mbroffset); if (error) break; } /* Same thing if we are inside a PC98 */ error = g_getattr("PC98::type", cp, &i); if (!error) { if (i != 0xc494 && flags == G_TF_NORMAL) break; error = g_getattr("PC98::offset", cp, &ms->mbroffset); if (error) break; } /* Same thing if we are inside a GPT */ error = g_getattr("GPT::type", cp, &uuid); if (!error) { if (memcmp(&uuid, &freebsd_slice, sizeof(uuid)) != 0 && flags == G_TF_NORMAL) break; } /* Get sector size, we need it to read data. */ secsize = cp->provider->sectorsize; if (secsize < 512) break; /* First look for a label at the start of the second sector. */ error = g_bsd_try(gp, gsp, cp, secsize, ms, secsize); /* * If sector size is not 512 the label still can be at * offset 512, not at the start of the second sector. At least * it's true for labels created by the FreeBSD's bsdlabel(8). */ if (error && secsize != HISTORIC_LABEL_OFFSET) error = g_bsd_try(gp, gsp, cp, secsize, ms, HISTORIC_LABEL_OFFSET); /* Next, look for alpha labels */ if (error) error = g_bsd_try(gp, gsp, cp, secsize, ms, ALPHA_LABEL_OFFSET); /* If we didn't find a label, punt. */ if (error) break; /* * In order to avoid recursively attaching to the same * on-disk label (it's usually visible through the 'c' * partition) we calculate an MD5 and ask if other BSD's * below us love that label. If they do, we don't. */ MD5Init(&md5sum); MD5Update(&md5sum, ms->label, sizeof(ms->label)); MD5Final(ms->labelsum, &md5sum); error = g_getattr("BSD::labelsum", cp, &hash); if (!error && !bcmp(ms->labelsum, hash, sizeof(hash))) break; /* * Process the found disklabel, and modify our "slice" * instance to match it, if possible. */ error = g_bsd_modify(gp, ms->label); } while (0); /* Success or failure, we can close our provider now. */ g_access(cp, -1, 0, 0); /* If we have configured any providers, return the new geom. */ if (gsp->nprovider > 0) { g_slice_conf_hot(gp, 0, ms->labeloffset, LABELSIZE, G_SLICE_HOT_ALLOW, G_SLICE_HOT_DENY, G_SLICE_HOT_CALL); gsp->hot = g_bsd_hotwrite; return (gp); } /* * ...else push the "self-destruct" button, by spoiling our own * consumer. This triggers a call to g_slice_spoiled which will * dismantle what was setup. */ g_slice_spoiled(cp); return (NULL); }
static void device_added (MMBaseManager *manager, GUdevDevice *port, gboolean hotplugged, gboolean manual_scan) { MMDevice *device; const char *subsys, *name, *physdev_path, *physdev_subsys; gboolean is_candidate; GUdevDevice *physdev = NULL; g_return_if_fail (port != NULL); subsys = g_udev_device_get_subsystem (port); name = g_udev_device_get_name (port); /* ignore VTs */ if (strncmp (name, "tty", 3) == 0 && isdigit (name[3])) return; /* Ignore devices that aren't completely configured by udev yet. If * ModemManager is started in parallel with udev, explicitly requesting * devices may return devices for which not all udev rules have yet been * applied (a bug in udev/gudev). Since we often need those rules to match * the device to a specific ModemManager driver, we need to ensure that all * rules have been processed before handling a device. */ is_candidate = g_udev_device_get_property_as_boolean (port, "ID_MM_CANDIDATE"); if (!is_candidate) { /* This could mean that device changed, loosing its ID_MM_CANDIDATE * flags (such as Bluetooth RFCOMM devices upon disconnect. * Try to forget it. */ if (hotplugged && !manual_scan) device_removed (manager, port); return; } if (find_device_by_port (manager, port)) return; /* Find the port's physical device's sysfs path. This is the kernel device * that "owns" all the ports of the device, like the USB device or the PCI * device the provides each tty or network port. */ physdev = find_physical_device (port); if (!physdev) { /* Warn about it, but filter out some common ports that we know don't have * anything to do with mobile broadband. */ if ( strcmp (name, "console") && strcmp (name, "ptmx") && strcmp (name, "lo") && strcmp (name, "tty") && !strstr (name, "virbr")) mm_dbg ("(%s/%s): could not get port's parent device", subsys, name); goto out; } /* Is the device blacklisted? */ if (g_udev_device_get_property_as_boolean (physdev, "ID_MM_DEVICE_IGNORE")) { mm_dbg ("(%s/%s): port's parent device is blacklisted", subsys, name); goto out; } /* Is the device in the manual-only greylist? If so, return if this is an * automatic scan. */ if (!manual_scan && g_udev_device_get_property_as_boolean (physdev, "ID_MM_DEVICE_MANUAL_SCAN_ONLY")) { mm_dbg ("(%s/%s): port probed only in manual scan", subsys, name); goto out; } /* If the physdev is a 'platform' or 'pnp' device that's not whitelisted, ignore it */ physdev_subsys = g_udev_device_get_subsystem (physdev); if ( physdev_subsys && ( g_str_equal (physdev_subsys, "platform") || g_str_equal (physdev_subsys, "pnp")) && !g_udev_device_get_property_as_boolean (physdev, "ID_MM_PLATFORM_DRIVER_PROBE")) { mm_dbg ("(%s/%s): port's parent platform driver is not whitelisted", subsys, name); goto out; } physdev_path = g_udev_device_get_sysfs_path (physdev); if (!physdev_path) { mm_dbg ("(%s/%s): could not get port's parent device sysfs path", subsys, name); goto out; } /* See if we already created an object to handle ports in this device */ device = find_device_by_sysfs_path (manager, physdev_path); if (!device) { FindDeviceSupportContext *ctx; /* Keep the device listed in the Manager */ device = mm_device_new (physdev, hotplugged); g_hash_table_insert (manager->priv->devices, g_strdup (physdev_path), device); /* Launch device support check */ ctx = g_slice_new (FindDeviceSupportContext); ctx->self = g_object_ref (manager); ctx->device = g_object_ref (device); mm_plugin_manager_device_support_check ( manager->priv->plugin_manager, device, (GAsyncReadyCallback) device_support_check_ready, ctx); } /* Grab the port in the existing device. */ mm_device_grab_port (device, port); out: if (physdev) g_object_unref (physdev); }
/** * @fn int main (int argc, char **argv) * @brief Main program & Gtk thread. * * Create window and all widgets, then set there parameters to be the <br> * ROS params. */ int main (int argc, char **argv) { GtkBuilder *builder; GdkColor black = { 0, 0, 0, 0 }; GError *error = NULL; char glade_gui_file[FILENAME_MAX]; int start_zoom = 15; char *mapcachedir; OsmGpsMapPoint ccny_coord = { 40.818551, -73.948674 }; struct arg param; param.argc = argc; param.argv = argv; pthread_t rosThread; // **** init threads g_thread_init (NULL); gdk_threads_init (); gdk_threads_enter (); // **** init gtk gtk_init (&argc, &argv); // **** allocate data structure data = g_slice_new (AppData); // **** set the glade gui file & set icon directory std::string package_path = ros::package::getPath (ROS_PACKAGE_NAME); sprintf (glade_gui_file, "%s/gui/%s", package_path.c_str (), "gui.glade"); sprintf (data->icon_directory, "%s/gui/icon", package_path.c_str ()); std::string rosbag_path = ros::package::getPath("rosbag"); sprintf (data->rosbag_rec_path, "%s/bin/record", rosbag_path.c_str ()); data->current_page = 0; data->telemetry_opt_popup_state = false; data->gps_opt_popup_state = false; data->fullscreen = false; load_icon (); // **** Create new GtkBuilder object builder = gtk_builder_new (); // **** Load UI from file if (!gtk_builder_add_from_file (builder, glade_gui_file, &error)) { g_warning ("%s", error->message); g_free (error); exit (-1); } // **** Get main window pointer from UI data->window = GTK_WIDGET (gtk_builder_get_object (builder, "window1")); gtk_window_set_title (GTK_WINDOW (data->window), "CityFlyer Ground Station"); gtk_window_set_position (GTK_WINDOW (data->window), GTK_WIN_POS_CENTER); gtk_window_set_default_size (GTK_WINDOW (data->window), 1024, 576); // **** create ROS thread pthread_create (&rosThread, NULL, startROS, ¶m); // **** wait ros finish read params while (!data->ros_param_read) { ROS_DEBUG ("Waiting ROS params"); } // **** Get GtkNotebook objsect data->notebook = GTK_WIDGET (gtk_builder_get_object (builder, "notebook1")); // ##################################################################### // ##################################################################### // **** Tab 1: Telemetry // **** create altimeter widgets data->alt = gtk_altimeter_new (); g_object_set (GTK_ALTIMETER (data->alt), "grayscale-color", data->grayscale_color, "unit-is-feet", data->altimeter_unit_is_feet, "unit-step-value", data->altimeter_step_value, "radial-color", data->radial_color, NULL); // **** create compass widgets data->comp = gtk_compass_new (); g_object_set (GTK_COMPASS (data->comp), "grayscale-color", data->grayscale_color, "radial-color", data->radial_color, NULL); data->comp2 = gtk_compass_new (); g_object_set (GTK_COMPASS (data->comp2), "grayscale-color", data->grayscale_color, "radial-color", data->radial_color, NULL); data->gauge1 = gtk_gauge_new (); g_object_set (GTK_GAUGE (data->gauge1), "name", data->gauge1_name_f, NULL); g_object_set (GTK_GAUGE (data->gauge1), "grayscale-color", data->grayscale_color, "radial-color", data->radial_color, "start-value", data->gauge1_start_value, "end-value", data->gauge1_end_value, "initial-step", data->gauge1_initial_step, "sub-step", (gdouble) data->gauge1_sub_step, "drawing-step", data->gauge1_drawing_step, "color-strip-order", data->gauge1_color_strip_order, "green-strip-start", data->gauge1_green_strip_start, "yellow-strip-start", data->gauge1_yellow_strip_start, "red-strip-start", data->gauge1_red_strip_start, NULL); // **** create artificial horizon widgets data->arh = gtk_artificial_horizon_new (); g_object_set (GTK_ARTIFICIAL_HORIZON (data->arh), "grayscale-color", data->grayscale_color, "radial-color", data->radial_color, NULL); // **** create variometer widgets data->vario = gtk_variometer_new (); g_object_set (GTK_VARIOMETER (data->vario), "grayscale-color", data->grayscale_color, "unit-is-feet", data->variometer_unit_is_feet, "unit-step-value", data->variometer_step_value, "radial-color", data->radial_color, NULL); data->widget_table = GTK_WIDGET (gtk_builder_get_object (builder, "table_Widgets")); gtk_table_attach_defaults (GTK_TABLE (data->widget_table), data->alt, 0, 1, 0, 1); gtk_table_attach_defaults (GTK_TABLE (data->widget_table), data->arh, 1, 2, 0, 1); gtk_table_attach_defaults (GTK_TABLE (data->widget_table), data->comp, 2, 3, 0, 1); gtk_table_attach_defaults (GTK_TABLE (data->widget_table), data->vario, 0, 1, 1, 2); gtk_table_attach_defaults (GTK_TABLE (data->widget_table), data->comp2, 1, 2, 1, 2); gtk_table_attach_defaults (GTK_TABLE (data->widget_table), data->gauge1, 2, 3, 1, 2); gtk_widget_modify_bg (data->alt, GTK_STATE_NORMAL, &black); gtk_widget_modify_bg (data->comp, GTK_STATE_NORMAL, &black); gtk_widget_modify_bg (data->comp2, GTK_STATE_NORMAL, &black); gtk_widget_modify_bg (data->arh, GTK_STATE_NORMAL, &black); gtk_widget_modify_bg (data->gauge1, GTK_STATE_NORMAL, &black); gtk_widget_modify_bg (data->vario, GTK_STATE_NORMAL, &black); data->telemetry_option_popup = GTK_WIDGET (gtk_builder_get_object (builder, "hbox_TelemetryOption")); data->btn_open_telemetry_option_popup = GTK_WIDGET (gtk_builder_get_object (builder, "button_OpenTelemetryOptionPopup")); data->btn_close_telemetry_option_popup = GTK_WIDGET (gtk_builder_get_object (builder, "button_CloseTelemetryOptionPopup")); gtk_button_set_image (GTK_BUTTON (data->btn_open_telemetry_option_popup), gtk_image_new_from_pixbuf (gdk_pixbuf_scale_simple (data->leftarrow_icon_64, 24, 50, GDK_INTERP_HYPER))); gtk_button_set_image (GTK_BUTTON (data->btn_close_telemetry_option_popup), gtk_image_new_from_pixbuf (gdk_pixbuf_scale_simple (data->rightarrow_icon_64, 24, 50, GDK_INTERP_HYPER))); // ##################################################################### // ##################################################################### // **** Tab 2: Gps // Some GpsdViewer initialisation data->draw_path = false; data->map_provider = OSM_GPS_MAP_SOURCE_OPENSTREETMAP; data->map_zoom_max = 18; data->map_current_zoom = start_zoom; data->repo_uri = osm_gps_map_source_get_repo_uri (data->map_provider); data->friendly_name = osm_gps_map_source_get_friendly_name (data->map_provider); data->uav_track = osm_gps_map_track_new (); mapcachedir = osm_gps_map_get_default_cache_directory (); data->cachedir = g_build_filename (mapcachedir, data->friendly_name, NULL); g_free (mapcachedir); // Create the OsmGpsMap object data->map = (OsmGpsMap *) g_object_new (OSM_TYPE_GPS_MAP, "map-source", data->map_provider, "tile-cache", data->cachedir, "proxy-uri", g_getenv ("http_proxy"), NULL); //Set the starting coordinates and zoom level for the map osm_gps_map_set_zoom (data->map, start_zoom); osm_gps_map_set_center (data->map, ccny_coord.rlat, ccny_coord.rlon); data->osd = gpsd_viewer_osd_new (); g_object_set (GPSD_VIEWER_OSD (data->osd), "show-scale", true, "show-coordinates", true, "show-dpad", true, "show-zoom", true, "show-gps-in-dpad", true, "show-gps-in-zoom", false, "dpad-radius", 30, NULL); osm_gps_map_layer_add (OSM_GPS_MAP (data->map), OSM_GPS_MAP_LAYER (data->osd)); data->map_box = GTK_WIDGET (gtk_builder_get_object (builder, "hbox_map_box")); data->map_container = GTK_WIDGET (gtk_builder_get_object (builder, "hbox_map_container")); gtk_box_pack_start (GTK_BOX (data->map_box), GTK_WIDGET (data->map), TRUE, TRUE, 0); data->gpsd_option_popup = GTK_WIDGET (gtk_builder_get_object (builder, "hbox_GpsdOptionPopup")); data->btn_open_gpsd_option_popup = GTK_WIDGET (gtk_builder_get_object (builder, "button_OpenGpsdOptionPopup")); data->btn_close_gpsd_option_popup = GTK_WIDGET (gtk_builder_get_object (builder, "button_CloseGpsdOptionPopup")); gtk_button_set_image (GTK_BUTTON (data->btn_open_gpsd_option_popup), gtk_image_new_from_pixbuf (gdk_pixbuf_scale_simple (data->leftarrow_icon_64, 24, 50, GDK_INTERP_HYPER))); gtk_button_set_image (GTK_BUTTON (data->btn_close_gpsd_option_popup), gtk_image_new_from_pixbuf (gdk_pixbuf_scale_simple (data->rightarrow_icon_64, 24, 50, GDK_INTERP_HYPER))); // ##################################################################### // ##################################################################### // **** Tab 3: Rec data->recording = 0; data->rosbag_record_cmd = "rosbag record"; data->topicsList = GTK_LIST_STORE (gtk_builder_get_object (builder, "liststore_TopicList")); data->cmd_line_entry = GTK_WIDGET (gtk_builder_get_object (builder, "entry_CommandLine")); data->prefix_entry = GTK_WIDGET (gtk_builder_get_object (builder, "entry_Prefix")); data->info_textview = GTK_WIDGET (gtk_builder_get_object (builder, "textview_BagInfo")); data->update_btn = GTK_WIDGET (gtk_builder_get_object (builder, "button_UpdateTopicList")); data->box_MotorStatus = GTK_WIDGET (gtk_builder_get_object (builder, "hbox_MotorStatus")); data->box_Flying = GTK_WIDGET (gtk_builder_get_object (builder, "hbox_Flying")); data->box_Gps = GTK_WIDGET (gtk_builder_get_object (builder, "hbox_Gps")); data->flightMode_label = GTK_WIDGET (gtk_builder_get_object (builder, "label_FlightModeValue")); data->upTime_label = GTK_WIDGET (gtk_builder_get_object (builder, "label_UpTimeValue")); data->cpuLoad_label = GTK_WIDGET (gtk_builder_get_object (builder, "label_CpuLoadValue")); data->box_RecordStatus = GTK_WIDGET (gtk_builder_get_object (builder, "hbox_RecordStatus")); data->record_stop_btn = GTK_WIDGET (gtk_builder_get_object (builder, "button_RecordStop")); gtk_box_pack_end (GTK_BOX (data->box_MotorStatus), data->status_ok_icon_motor, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (data->box_MotorStatus), data->status_fail_icon_motor, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (data->box_Flying), data->status_ok_icon_flying, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (data->box_Flying), data->status_fail_icon_flying, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (data->box_Gps), data->status_ok_icon_gps, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (data->box_Gps), data->status_fail_icon_gps, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (data->box_RecordStatus), data->record_icon, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (data->box_RecordStatus), data->record_g_icon, TRUE, TRUE, 0); gtk_button_set_image (GTK_BUTTON (data->update_btn), gtk_image_new_from_pixbuf (gdk_pixbuf_scale_simple (data->refresh_icon_64, 24, 24, GDK_INTERP_HYPER))); gtk_button_set_image (GTK_BUTTON (data->record_stop_btn), gtk_image_new_from_pixbuf (gdk_pixbuf_scale_simple (data->record_icon_64, 40, 40, GDK_INTERP_HYPER))); // Connect signals gtk_builder_connect_signals (builder, data); // Destroy builder, since we don't need it anymore g_object_unref (G_OBJECT (builder)); // Show window. All other widgets are automatically shown by GtkBuilder gtk_widget_show_all (data->window); gtk_widget_hide(data->record_icon); gtk_widget_hide(data->status_ok_icon_motor); gtk_widget_hide(data->status_ok_icon_flying); gtk_widget_hide(data->status_ok_icon_gps); gtk_widget_hide_all(data->telemetry_option_popup); gtk_widget_hide_all(data->gpsd_option_popup); // **** allow ROS spinning data->widget_created = true; // **** udpate all widgets g_timeout_add (data->telemetry_refresh_rate, widgets_update, NULL); gtk_main (); gdk_threads_leave (); return 0; }
static server_item* server_item_new(liPlugin *p, const liPluginItem *p_item) { server_item *si = g_slice_new(server_item); si->p = p; si->p_item = p_item; return si; }
static void coroutine_fn mirror_iteration(MirrorBlockJob *s) { BlockDriverState *source = s->common.bs; int nb_sectors, sectors_per_chunk, nb_chunks; int64_t end, sector_num, next_chunk, next_sector, hbitmap_next_sector; MirrorOp *op; s->sector_num = hbitmap_iter_next(&s->hbi); if (s->sector_num < 0) { bdrv_dirty_iter_init(source, &s->hbi); s->sector_num = hbitmap_iter_next(&s->hbi); trace_mirror_restart_iter(s, bdrv_get_dirty_count(source)); assert(s->sector_num >= 0); } hbitmap_next_sector = s->sector_num; sector_num = s->sector_num; sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS; end = s->common.len >> BDRV_SECTOR_BITS; /* Extend the QEMUIOVector to include all adjacent blocks that will * be copied in this operation. * * We have to do this if we have no backing file yet in the destination, * and the cluster size is very large. Then we need to do COW ourselves. * The first time a cluster is copied, copy it entirely. Note that, * because both the granularity and the cluster size are powers of two, * the number of sectors to copy cannot exceed one cluster. * * We also want to extend the QEMUIOVector to include more adjacent * dirty blocks if possible, to limit the number of I/O operations and * run efficiently even with a small granularity. */ nb_chunks = 0; nb_sectors = 0; next_sector = sector_num; next_chunk = sector_num / sectors_per_chunk; /* Wait for I/O to this cluster (from a previous iteration) to be done. */ while (test_bit(next_chunk, s->in_flight_bitmap)) { trace_mirror_yield_in_flight(s, sector_num, s->in_flight); qemu_coroutine_yield(); } do { int added_sectors, added_chunks; if (!bdrv_get_dirty(source, next_sector) || test_bit(next_chunk, s->in_flight_bitmap)) { assert(nb_sectors > 0); break; } added_sectors = sectors_per_chunk; if (s->cow_bitmap && !test_bit(next_chunk, s->cow_bitmap)) { bdrv_round_to_clusters(s->target, next_sector, added_sectors, &next_sector, &added_sectors); /* On the first iteration, the rounding may make us copy * sectors before the first dirty one. */ if (next_sector < sector_num) { assert(nb_sectors == 0); sector_num = next_sector; next_chunk = next_sector / sectors_per_chunk; } } added_sectors = MIN(added_sectors, end - (sector_num + nb_sectors)); added_chunks = (added_sectors + sectors_per_chunk - 1) / sectors_per_chunk; /* When doing COW, it may happen that there is not enough space for * a full cluster. Wait if that is the case. */ while (nb_chunks == 0 && s->buf_free_count < added_chunks) { trace_mirror_yield_buf_busy(s, nb_chunks, s->in_flight); qemu_coroutine_yield(); } if (s->buf_free_count < nb_chunks + added_chunks) { trace_mirror_break_buf_busy(s, nb_chunks, s->in_flight); break; } /* We have enough free space to copy these sectors. */ bitmap_set(s->in_flight_bitmap, next_chunk, added_chunks); nb_sectors += added_sectors; nb_chunks += added_chunks; next_sector += added_sectors; next_chunk += added_chunks; } while (next_sector < end); /* Allocate a MirrorOp that is used as an AIO callback. */ op = g_slice_new(MirrorOp); op->s = s; op->sector_num = sector_num; op->nb_sectors = nb_sectors; /* Now make a QEMUIOVector taking enough granularity-sized chunks * from s->buf_free. */ qemu_iovec_init(&op->qiov, nb_chunks); next_sector = sector_num; while (nb_chunks-- > 0) { MirrorBuffer *buf = QSIMPLEQ_FIRST(&s->buf_free); QSIMPLEQ_REMOVE_HEAD(&s->buf_free, next); s->buf_free_count--; qemu_iovec_add(&op->qiov, buf, s->granularity); /* Advance the HBitmapIter in parallel, so that we do not examine * the same sector twice. */ if (next_sector > hbitmap_next_sector && bdrv_get_dirty(source, next_sector)) { hbitmap_next_sector = hbitmap_iter_next(&s->hbi); } next_sector += sectors_per_chunk; } bdrv_reset_dirty(source, sector_num, nb_sectors); /* Copy the dirty cluster. */ s->in_flight++; trace_mirror_one_iteration(s, sector_num, nb_sectors); bdrv_aio_readv(source, sector_num, &op->qiov, nb_sectors, mirror_read_complete, op); }
/* Memory management routines ***************************************/ GncGUID * guid_malloc (void) { return g_slice_new(GncGUID); }
static GHashTable *read_directory(FILE *f, int64_t *diroff, GHashTable *loop_detector, uint16_t endian) { int64_t off = *diroff; *diroff = 0; GHashTable *result = NULL; int64_t *key = NULL; int64_t nextdiroff = -1; int dircount = -1; // g_debug("diroff: %" PRId64, off); if (off <= 0) { g_warning("Bad offset"); goto FAIL; } // loop detection if (g_hash_table_lookup_extended(loop_detector, &off, NULL, NULL)) { // loop g_warning("Loop detected"); goto FAIL; } key = g_slice_new(int64_t); *key = off; g_hash_table_insert(loop_detector, key, NULL); // no loop, let's seek if (fseeko(f, off, SEEK_SET) != 0) { g_warning("Cannot seek to offset"); goto FAIL; } // read directory count dircount = read_uint16(f, endian); if (dircount == -1) { g_warning("Cannot read dircount"); goto FAIL; } // g_debug("dircount: %d", dircount); // initial checks passed, initialized the hashtable result = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, tiffdump_item_destroy); // read all directory entries for (int i = 0; i < dircount; i++) { int32_t tag = read_uint16(f, endian); int32_t type = read_uint16(f, endian); int64_t count = read_uint32(f, endian); if ((tag == -1) || (type == -1) || (count == -1)) { g_warning("Cannot read tag, type, and count"); goto FAIL; } // g_debug(" tag: %d, type: %d, count: %" PRId64, tag, type, count); // read in the value/offset uint8_t value[4]; if (fread(value, 1, 4, f) != 4) { g_warning("Cannot read value/offset"); goto FAIL; } uint32_t offset; memcpy(&offset, value, 4); if (endian == TIFF_BIGENDIAN) { offset = GUINT32_FROM_BE(offset); } else { offset = GUINT32_FROM_LE(offset); } // allocate the item struct _openslide_tiffdump_item *data = g_slice_new(struct _openslide_tiffdump_item); data->type = (TIFFDataType) type; data->count = count; // load the value switch (type) { case TIFF_BYTE: case TIFF_ASCII: case TIFF_SBYTE: case TIFF_UNDEFINED: data->value = read_tiff_tag_1(f, count, offset, value); break; case TIFF_SHORT: case TIFF_SSHORT: data->value = read_tiff_tag_2(f, count, offset, value, endian); break; case TIFF_LONG: case TIFF_SLONG: case TIFF_FLOAT: case TIFF_IFD: data->value = read_tiff_tag_4(f, count, offset, value, endian); break; case TIFF_RATIONAL: case TIFF_SRATIONAL: data->value = read_tiff_tag_4(f, count * 2, offset, value, endian); break; case TIFF_DOUBLE: data->value = read_tiff_tag_8(f, count, offset, endian); break; default: g_warning("Unknown type encountered: %d", type); goto FAIL; } if (data->value == NULL) { g_warning("Cannot read value"); goto FAIL; } // add this tag to the hashtable int *key = g_new(int, 1); *key = tag; g_hash_table_insert(result, key, data); } // read the next dir offset nextdiroff = read_uint32(f, endian); if (nextdiroff == -1) { g_warning("Cannot read next directory offset"); goto FAIL; } *diroff = nextdiroff; // success return result; FAIL: if (result != NULL) { g_hash_table_unref(result); } return NULL; }
static CoglBool _cogl_winsys_egl_onscreen_init (CoglOnscreen *onscreen, EGLConfig egl_config, CoglError **error) { CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen); CoglContext *context = framebuffer->context; CoglDisplay *display = context->display; CoglRenderer *renderer = display->renderer; CoglRendererEGL *egl_renderer = renderer->winsys; CoglXlibRenderer *xlib_renderer = _cogl_xlib_renderer_get_data (renderer); CoglOnscreenXlib *xlib_onscreen; CoglOnscreenEGL *egl_onscreen = onscreen->winsys; Window xwin; /* FIXME: We need to explicitly Select for ConfigureNotify events. * For foreign windows we need to be careful not to mess up any * existing event mask. * We need to document that for windows we create then toolkits * must be careful not to clear event mask bits that we select. */ /* XXX: Note we ignore the user's original width/height when * given a foreign X window. */ if (onscreen->foreign_xid) { Status status; CoglXlibTrapState state; XWindowAttributes attr; int xerror; xwin = onscreen->foreign_xid; _cogl_xlib_renderer_trap_errors (display->renderer, &state); status = XGetWindowAttributes (xlib_renderer->xdpy, xwin, &attr); xerror = _cogl_xlib_renderer_untrap_errors (display->renderer, &state); if (status == 0 || xerror) { char message[1000]; XGetErrorText (xlib_renderer->xdpy, xerror, message, sizeof (message)); _cogl_set_error (error, COGL_WINSYS_ERROR, COGL_WINSYS_ERROR_CREATE_ONSCREEN, "Unable to query geometry of foreign " "xid 0x%08lX: %s", xwin, message); return FALSE; } _cogl_framebuffer_winsys_update_size (framebuffer, attr.width, attr.height); /* Make sure the app selects for the events we require... */ onscreen->foreign_update_mask_callback (onscreen, COGL_ONSCREEN_X11_EVENT_MASK, onscreen-> foreign_update_mask_data); } else { int width; int height; CoglXlibTrapState state; XVisualInfo *xvisinfo; XSetWindowAttributes xattr; unsigned long mask; int xerror; width = cogl_framebuffer_get_width (framebuffer); height = cogl_framebuffer_get_height (framebuffer); _cogl_xlib_renderer_trap_errors (display->renderer, &state); xvisinfo = get_visual_info (display, egl_config); if (xvisinfo == NULL) { _cogl_set_error (error, COGL_WINSYS_ERROR, COGL_WINSYS_ERROR_CREATE_ONSCREEN, "Unable to retrieve the X11 visual of context's " "fbconfig"); return FALSE; } /* window attributes */ xattr.background_pixel = WhitePixel (xlib_renderer->xdpy, DefaultScreen (xlib_renderer->xdpy)); xattr.border_pixel = 0; /* XXX: is this an X resource that we are leaking‽... */ xattr.colormap = XCreateColormap (xlib_renderer->xdpy, DefaultRootWindow (xlib_renderer->xdpy), xvisinfo->visual, AllocNone); xattr.event_mask = COGL_ONSCREEN_X11_EVENT_MASK; mask = CWBorderPixel | CWColormap | CWEventMask; xwin = XCreateWindow (xlib_renderer->xdpy, DefaultRootWindow (xlib_renderer->xdpy), 0, 0, width, height, 0, xvisinfo->depth, InputOutput, xvisinfo->visual, mask, &xattr); XFree (xvisinfo); XSync (xlib_renderer->xdpy, False); xerror = _cogl_xlib_renderer_untrap_errors (display->renderer, &state); if (xerror) { char message[1000]; XGetErrorText (xlib_renderer->xdpy, xerror, message, sizeof (message)); _cogl_set_error (error, COGL_WINSYS_ERROR, COGL_WINSYS_ERROR_CREATE_ONSCREEN, "X error while creating Window for CoglOnscreen: %s", message); return FALSE; } } xlib_onscreen = g_slice_new (CoglOnscreenXlib); egl_onscreen->platform = xlib_onscreen; xlib_onscreen->xwin = xwin; xlib_onscreen->is_foreign_xwin = onscreen->foreign_xid ? TRUE : FALSE; egl_onscreen->egl_surface = eglCreateWindowSurface (egl_renderer->edpy, egl_config, (EGLNativeWindowType) xlib_onscreen->xwin, NULL); return TRUE; }
static void gfilter_load_args(GwyContainer *container, GFilterArgs *args) { GwyInventory *inventory; gchar *filename, *buffer; gsize size; guint i; inventory = gwy_grain_values(); *args = gfilter_defaults; gwy_container_gis_boolean_by_name(container, update_key, &args->update); gwy_container_gis_int32_by_name(container, expanded_key, &args->expanded); gwy_container_gis_enum_by_name(container, logical_key, &args->logical); for (i = 0; i < NQUANTITIES; i++) { RangeRecord *rr = args->ranges + i; gchar buf[sizeof(quantity_key) + 10]; g_snprintf(buf, sizeof(buf), "%s%u", quantity_key, i+1); gwy_container_gis_string_by_name(container, buf, (const guchar**)&rr->quantity); } args->ranges_history = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, range_record_free); filename = g_build_filename(gwy_get_user_dir(), "grain_filter", "ranges", NULL); if (g_file_get_contents(filename, &buffer, &size, NULL)) { gchar *p = buffer, *line; for (line = gwy_str_next_line(&p); line; line = gwy_str_next_line(&p)) { g_strstrip(line); if (*line) { GwyGrainValue *gvalue; RangeRecord *rr; gchar *s = line, *end; gdouble lower, upper; lower = g_ascii_strtod(s, &end); s = end; upper = g_ascii_strtod(s, &end); if (end == s) { g_warning("Invalid grain_filter range record: %s.", line); continue; } s = end; g_strstrip(s); if (!(gvalue = gwy_inventory_get_item(inventory, s))) { g_warning("Invalid grain_filter range record: %s.", line); continue; } rr = g_slice_new(RangeRecord); rr->lower = lower; rr->upper = upper; rr->quantity = gwy_resource_get_name(GWY_RESOURCE(gvalue)); g_hash_table_insert(args->ranges_history, (gpointer)rr->quantity, rr); } } g_free(buffer); } g_free(filename); gfilter_sanitize_args(args); }
MotoCommandTransaction *moto_command_transaction_new(void) { MotoCommandTransaction *self = g_slice_new(MotoCommandTransaction); moto_command_transaction_init(self); return self; }
static RutShapeModel * shape_model_new (RutContext *ctx, CoglBool shaped, float tex_width, float tex_height) { RutShapeModel *shape_model = g_slice_new (RutShapeModel); RutBuffer *buffer = rut_buffer_new (sizeof (CoglVertexP3) * 6); RutMesh *pick_mesh = rut_mesh_new_from_buffer_p3 (COGL_VERTICES_MODE_TRIANGLES, 6, buffer); CoglVertexP3 *pick_vertices = (CoglVertexP3 *)buffer->data; CoglMatrix matrix; float tex_aspect; float size_x; float size_y; float half_size_x; float half_size_y; float geom_size_x; float geom_size_y; float half_geom_size_x; float half_geom_size_y; rut_object_init (&shape_model->_parent, &rut_shape_model_type); shape_model->ref_count = 1; if (shaped) { /* In this case we are using a shape mask texture which is has a * square size and is padded with transparent pixels to provide * antialiasing. The shape mask is half the size of the texture * itself so we make the geometry twice as large to compensate. */ size_x = MIN (tex_width, tex_height); size_y = size_x; geom_size_x = size_x * 2.0; geom_size_y = geom_size_x; } else { size_x = tex_width; size_y = tex_height; geom_size_x = tex_width; geom_size_y = tex_height; } half_size_x = size_x / 2.0; half_size_y = size_y / 2.0; half_geom_size_x = geom_size_x / 2.0; half_geom_size_y = geom_size_y / 2.0; { int n_vertices; int i; VertexP2T2T2 vertices[] = { { -half_geom_size_x, -half_geom_size_y, 0, 0, 0, 0 }, { -half_geom_size_x, half_geom_size_y, 0, 1, 0, 1 }, { half_geom_size_x, half_geom_size_y, 1, 1, 1, 1 }, { -half_geom_size_x, -half_geom_size_y, 0, 0, 0, 0 }, { half_geom_size_x, half_geom_size_y, 1, 1, 1, 1 }, { half_geom_size_x, -half_geom_size_y, 1, 0, 1, 0 }, }; cogl_matrix_init_identity (&matrix); tex_aspect = (float)tex_width / (float)tex_height; if (shaped) { float s_scale, t_scale; float s0, t0; /* NB: The circle mask texture has a centered circle that is * half the width of the texture itself. We want the primary * texture to be mapped to this center circle. */ s_scale = 2; t_scale = 2; if (tex_aspect < 1) /* taller than it is wide */ t_scale *= tex_aspect; else /* wider than it is tall */ { float inverse_aspect = 1.0f / tex_aspect; s_scale *= inverse_aspect; } s0 = 0.5 - (s_scale / 2.0); t0 = 0.5 - (t_scale / 2.0); cogl_matrix_translate (&matrix, s0, t0, 0); cogl_matrix_scale (&matrix, s_scale, t_scale, 1); } n_vertices = sizeof (vertices) / sizeof (VertexP2T2T2); for (i = 0; i < n_vertices; i++) { float z = 0, w = 1; cogl_matrix_transform_point (&matrix, &vertices[i].s1, &vertices[i].t1, &z, &w); #ifdef MESA_CONST_ATTRIB_BUG_WORKAROUND vertices[i].Nx = 0; vertices[i].Ny = 0; vertices[i].Nz = 1; vertices[i].Tx = 1; vertices[i].Ty = 0; vertices[i].Tz = 0; #endif } shape_model->primitive = primitive_new_p2t2t2 (ctx->cogl_context, COGL_VERTICES_MODE_TRIANGLES, n_vertices, vertices); } shape_model->shape_texture = cogl_object_ref (ctx->circle_texture); pick_vertices[0].x = -half_size_x; pick_vertices[0].y = -half_size_y; pick_vertices[1].x = -half_size_x; pick_vertices[1].y = half_size_y; pick_vertices[2].x = half_size_x; pick_vertices[2].y = half_size_y; pick_vertices[3] = pick_vertices[0]; pick_vertices[4] = pick_vertices[2]; pick_vertices[5].x = half_size_x; pick_vertices[5].y = -half_size_y; shape_model->pick_mesh = pick_mesh; return shape_model; }
static AuthFileData* auth_file_load(liServer *srv, AuthFile *f) { GHashTable *users; gchar *contents; gchar *c; gchar *username, *password; GError *err = NULL; AuthFileData *data = NULL; if (!g_file_get_contents(f->path->str, &contents, NULL, &err)) { ERROR(srv, "failed to load auth file \"%s\": %s", f->path->str, err->message); g_error_free(err); return NULL; } users = g_hash_table_new((GHashFunc) g_str_hash, (GEqualFunc) g_str_equal); /* parse file */ for ( c = contents ; *c; ) { gboolean found_realm, found_newline; username = c; password = NULL; found_realm = FALSE; found_newline = FALSE; for ( ; '\0' != *c ; c++ ) { if ('\n' == *c || '\r' == *c) { *c = '\0'; found_newline = TRUE; } else if (':' == *c) { if (NULL == password) { password = c+1; *c = '\0'; } else { found_realm = TRUE; } } else if (found_newline) { break; } } if (!password) { /* missing delimiter for user:pass => bogus file */ ERROR(srv, "failed to parse auth file \"%s\", missing user:password delimiter", f->path->str); goto cleanup_fail; } /* file is of type htdigest (user:realm:pass) */ if (f->has_realm && !found_realm) { /* missing delimiter for realm:pass => bogus file */ ERROR(srv, "failed to parse auth file \"%s\", missing realm:password delimiter", f->path->str); goto cleanup_fail; } g_hash_table_insert(users, username, password); } data = g_slice_new(AuthFileData); data->refcount = 1; data->contents = contents; data->users = users; return data; cleanup_fail: g_hash_table_destroy(users); g_free(contents); return NULL; }
/* this is loosely based on update_places() from nautilus-places-sidebar.c */ static void panel_place_menu_item_append_local_gio (PanelPlaceMenuItem *place_item, GtkWidget *menu) { GList *l; GList *ll; GList *drives; GDrive *drive; GList *volumes; GVolume *volume; GList *mounts; GMount *mount; GSList *items; GSList *sl; PanelGioItem *item; GtkWidget *add_menu; items = NULL; /* first go through all connected drives */ drives = g_volume_monitor_get_connected_drives (place_item->priv->volume_monitor); for (l = drives; l != NULL; l = l->next) { drive = l->data; volumes = g_drive_get_volumes (drive); if (volumes != NULL) { for (ll = volumes; ll != NULL; ll = ll->next) { volume = ll->data; mount = g_volume_get_mount (volume); item = g_slice_new (PanelGioItem); if (mount != NULL) { item->type = PANEL_GIO_MOUNT; item->u.mount = mount; } else { /* Do show the unmounted volumes; this * is so the user can mount it (in case * automounting is off). * * Also, even if automounting is * enabled, this gives a visual cue * that the user should remember to * yank out the media if he just * unmounted it. */ item->type = PANEL_GIO_VOLUME; item->u.volume = g_object_ref (volume); } items = g_slist_prepend (items, item); g_object_unref (volume); } g_list_free (volumes); } else { if (g_drive_is_media_removable (drive) && !g_drive_is_media_check_automatic (drive)) { /* If the drive has no mountable volumes and we * cannot detect media change.. we display the * drive so the user can manually poll the * drive by clicking on it..." * * This is mainly for drives like floppies * where media detection doesn't work.. but * it's also for human beings who like to turn * off media detection in the OS to save * battery juice. */ item = g_slice_new (PanelGioItem); item->type = PANEL_GIO_DRIVE; item->u.drive = g_object_ref (drive); items = g_slist_prepend (items, item); } } g_object_unref (drive); } g_list_free (drives); /* add all volumes that is not associated with a drive */ volumes = g_volume_monitor_get_volumes (place_item->priv->volume_monitor); for (l = volumes; l != NULL; l = l->next) { volume = l->data; drive = g_volume_get_drive (volume); if (drive != NULL) { g_object_unref (volume); g_object_unref (drive); continue; } mount = g_volume_get_mount (volume); item = g_slice_new (PanelGioItem); if (mount != NULL) { item->type = PANEL_GIO_MOUNT; item->u.mount = mount; } else { /* see comment above in why we add an icon for an * unmounted mountable volume */ item->type = PANEL_GIO_VOLUME; item->u.volume = g_object_ref (volume); } items = g_slist_prepend (items, item); g_object_unref (volume); } g_list_free (volumes); /* add mounts that has no volume (/etc/mtab mounts, ftp, sftp,...) */ mounts = g_volume_monitor_get_mounts (place_item->priv->volume_monitor); for (l = mounts; l != NULL; l = l->next) { GFile *root; mount = l->data; volume = g_mount_get_volume (mount); if (volume != NULL) { g_object_unref (volume); g_object_unref (mount); continue; } root = g_mount_get_root (mount); if (!g_file_is_native (root)) { g_object_unref (root); g_object_unref (mount); continue; } g_object_unref (root); item = g_slice_new (PanelGioItem); item->type = PANEL_GIO_MOUNT; item->u.mount = mount; items = g_slist_prepend (items, item); } g_list_free (mounts); /* now that we have everything, add the items inline or in a submenu */ items = g_slist_reverse (items); if (g_slist_length (items) <= MAX_ITEMS_OR_SUBMENU) { add_menu = menu; } else { GtkWidget *item; item = gtk_image_menu_item_new (); setup_menu_item_with_icon (item, panel_menu_icon_get_size (), PANEL_ICON_REMOVABLE_MEDIA, NULL, NULL, _("Removable Media")); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); add_menu = create_empty_menu (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), add_menu); } for (sl = items; sl; sl = sl->next) { item = sl->data; switch (item->type) { case PANEL_GIO_DRIVE: panel_menu_item_append_drive (add_menu, item->u.drive); g_object_unref (item->u.drive); break; case PANEL_GIO_VOLUME: panel_menu_item_append_volume (add_menu, item->u.volume); g_object_unref (item->u.volume); break; case PANEL_GIO_MOUNT: panel_menu_item_append_mount (add_menu, item->u.mount); g_object_unref (item->u.mount); break; default: g_assert_not_reached (); } g_slice_free (PanelGioItem, item); } g_slist_free (items); }
static liAction* auth_generic_create(liServer *srv, liWorker *wrk, liPlugin* p, liValue *val, const char *actname, AuthBasicBackend basic_action, gboolean has_realm) { AuthFile *afd; liValue *method = NULL, *realm = NULL, *file = NULL; gint ttl = 10; GHashTableIter it; gpointer pkey, pvalue; if (!val || val->type != LI_VALUE_HASH) { ERROR(srv, "%s expects a hashtable with at least 3 elements: method, realm and file", actname); return NULL; } g_hash_table_iter_init(&it, val->data.hash); while (g_hash_table_iter_next(&it, &pkey, &pvalue)) { GString *key = pkey; liValue *value = pvalue; if (g_string_equal(key, &aon_method)) { if (value->type != LI_VALUE_STRING) { ERROR(srv, "auth option '%s' expects string as parameter", aon_method.str); return NULL; } method = value; } else if (g_string_equal(key, &aon_realm)) { if (value->type != LI_VALUE_STRING) { ERROR(srv, "auth option '%s' expects string as parameter", aon_realm.str); return NULL; } realm = value; } else if (g_string_equal(key, &aon_file)) { if (value->type != LI_VALUE_STRING) { ERROR(srv, "auth option '%s' expects string as parameter", aon_file.str); return NULL; } file = value; } else if (g_string_equal(key, &aon_ttl)) { if (value->type != LI_VALUE_NUMBER || value->data.number < 0) { ERROR(srv, "auth option '%s' expects non-negative number as parameter", aon_ttl.str); return NULL; } ttl = value->data.number; } } if (NULL == method || NULL == realm || NULL == file) { ERROR(srv, "%s expects a hashtable with 3 elements: method, realm and file", actname); return NULL; } if (!g_str_equal(method->data.string->str, "basic") && !g_str_equal(method->data.string->str, "digest")) { ERROR(srv, "%s: unknown method: %s", actname, method->data.string->str); return NULL; } if (g_str_equal(method->data.string->str, "digest")) { ERROR(srv, "%s: digest authentication not implemented yet", actname); return NULL; } /* load users from file */ afd = auth_file_new(wrk, file->data.string, has_realm, ttl); if (!afd) return FALSE; if (g_str_equal(method->data.string->str, "basic")) { AuthBasicData *bdata; bdata = g_slice_new(AuthBasicData); bdata->p = p; bdata->realm = li_value_extract_string(realm); bdata->backend = basic_action; bdata->data = afd; return li_action_new_function(auth_basic, NULL, auth_basic_free, bdata); } else { auth_file_free(afd); return NULL; /* li_action_new_function(NULL, NULL, auth_backend_plain_free, ad); */ } }
void mape_edit_view_reload(MapeEditView* edit_view) { GError* error = NULL; ThreadData* data; GtkTextBuffer* buffer; GtkTextIter begin; GtkTextIter end; if(edit_view->render_thread == NULL) { data = g_slice_new(ThreadData); buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(edit_view->view) ); gtk_text_buffer_get_start_iter(buffer, &begin); gtk_text_buffer_get_end_iter(buffer, &end); /* TODO: We need to ref view so that it is guaranteed to be alive in the * thread result handler */ data->view = edit_view; data->source = gtk_text_buffer_get_text(buffer, &begin, &end, TRUE); data->type = edit_view->type; data->file_path = g_strdup(edit_view->file_path); /* TODO: We need to ref these so noone can delete them while the thread * uses them. */ data->mat_map = edit_view->pre_view->mat_tex->mat_map, data->tex_map = edit_view->pre_view->mat_tex->tex_map, data->map_width = edit_view->map_width; data->map_height = edit_view->map_height; data->map_zoom = edit_view->map_zoom; data->start_time = g_get_monotonic_time(); if(edit_view->fixed_seed == TRUE) mape_random_seed(edit_view->random_seed); mape_statusbar_set_compile( edit_view->statusbar, "Rendering map..." ); edit_view->rerender = FALSE; edit_view->render_thread = g_thread_create( mape_edit_view_thread_entry, data, TRUE, &error ); if(edit_view->render_thread == NULL) { mape_statusbar_set_compile( edit_view->statusbar, error->message ); g_free(data->source); g_slice_free(ThreadData, data); g_error_free(error); } } else { /* Rerender when thread finished */ edit_view->rerender = TRUE; } }
jschema_builder *jschema_builder_create() { jschema_builder *builder = g_slice_new(jschema_builder); jschema_builder_init(builder); return builder; }