static void skypeweb_got_info(SkypeWebAccount *sa, JsonNode *node, gpointer user_data) { gchar *username = user_data; PurpleNotifyUserInfo *user_info; JsonObject *userobj; PurpleBuddy *buddy; SkypeWebBuddy *sbuddy; const gchar *new_avatar; if (node == NULL || json_node_get_node_type(node) != JSON_NODE_OBJECT) return; userobj = json_node_get_object(node); user_info = purple_notify_user_info_new(); #define _SKYPE_USER_INFO(prop, key) if (prop && json_object_has_member(userobj, (prop)) && !json_object_get_null_member(userobj, (prop))) \ purple_notify_user_info_add_pair_html(user_info, _(key), json_object_get_string_member(userobj, (prop))); _SKYPE_USER_INFO("firstname", "First Name"); _SKYPE_USER_INFO("lastname", "Last Name"); _SKYPE_USER_INFO("birthday", "Birthday"); //_SKYPE_USER_INFO("gender", "Gender"); if (json_object_has_member(userobj, "gender") && !json_object_get_null_member(userobj, "gender")) { const gchar *gender = json_object_get_string_member(userobj, "gender"); const gchar *gender_output; if (*gender == '1') { gender_output = _("Male"); } else if (*gender == '2') { gender_output = _("Female"); } else { gender_output = _("Unknown"); } purple_notify_user_info_add_pair_html(user_info, _("Gender"), gender_output); } _SKYPE_USER_INFO("language", "Language"); _SKYPE_USER_INFO("country", "Country"); _SKYPE_USER_INFO("province", "Province"); _SKYPE_USER_INFO("city", "City"); _SKYPE_USER_INFO("homepage", "Homepage"); _SKYPE_USER_INFO("about", "About"); _SKYPE_USER_INFO("jobtitle", "Job Title"); _SKYPE_USER_INFO("phoneMobile", "Phone - Mobile"); _SKYPE_USER_INFO("phoneHome", "Phone - Home"); _SKYPE_USER_INFO("phoneOffice", "Phone - Office"); //_SKYPE_USER_INFO("mood", "Mood"); //_SKYPE_USER_INFO("richMood", "Mood"); //_SKYPE_USER_INFO("avatarUrl", "Avatar"); buddy = purple_find_buddy(sa->account, username); if (buddy) { sbuddy = purple_buddy_get_protocol_data(buddy); if (sbuddy == NULL) { sbuddy = g_new0(SkypeWebBuddy, 1); purple_buddy_set_protocol_data(buddy, sbuddy); sbuddy->skypename = g_strdup(username); sbuddy->sa = sa; } new_avatar = json_object_get_string_member(userobj, "avatarUrl"); if (new_avatar && (!sbuddy->avatar_url || !g_str_equal(sbuddy->avatar_url, new_avatar))) { g_free(sbuddy->avatar_url); sbuddy->avatar_url = g_strdup(new_avatar); skypeweb_get_icon(buddy); } g_free(sbuddy->mood); sbuddy->mood = g_strdup(json_object_get_string_member(userobj, "mood")); } purple_notify_userinfo(sa->pc, username, user_info, NULL, NULL); g_free(username); }
gboolean cairo_dock_manage_themes (GtkWidget *pWidget, gboolean bSafeMode) { GString *sCommand = g_string_new (""); GHashTable *hThemeTable = NULL; gchar *cInitConfFile = cairo_dock_edit_themes (&hThemeTable, bSafeMode); if (cInitConfFile != NULL) { GError *erreur = NULL; gboolean bNeedSave = cairo_dock_theme_need_save (); //\___________________ On recupere les donnees de l'IHM apres modification par l'utilisateur. GKeyFile *pKeyFile = g_key_file_new (); g_key_file_load_from_file (pKeyFile, cInitConfFile, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, &erreur); g_remove (cInitConfFile); g_free (cInitConfFile); if (erreur != NULL) { cd_warning ("Attention : %s", erreur->message); g_error_free (erreur); return FALSE; } //\___________________ On charge le nouveau theme choisi. gchar *cNewThemeName = g_key_file_get_string (pKeyFile, "Themes", "chosen theme", &erreur); if (erreur != NULL) { cd_warning ("Attention : %s", erreur->message); g_error_free (erreur); erreur = NULL; } if (cNewThemeName != NULL && *cNewThemeName == '\0') { g_free (cNewThemeName); cNewThemeName = NULL; } if (cNewThemeName != NULL) { if (bNeedSave) { int iAnswer = cairo_dock_ask_general_question_and_wait (_("You made some modifications in the current theme.\nYou will loose them if you don't save before choosing a new theme. Continue anyway ?")); if (iAnswer != GTK_RESPONSE_YES) { g_hash_table_destroy (hThemeTable); return TRUE; } else cairo_dock_mark_theme_as_modified (FALSE); } gchar *cNewThemePath = g_hash_table_lookup (hThemeTable, cNewThemeName); //\___________________ On charge les parametres de comportement. if (g_pMainDock == NULL || g_key_file_get_boolean (pKeyFile, "Themes", "use theme behaviour", NULL)) { g_string_printf (sCommand, "/bin/cp '%s'/%s '%s'", cNewThemePath, CAIRO_DOCK_CONF_FILE, g_cCurrentThemePath); cd_message ("%s", sCommand->str); system (sCommand->str); } else { gchar *cNewConfFilePath = g_strdup_printf ("%s/%s", cNewThemePath, CAIRO_DOCK_CONF_FILE); cairo_dock_replace_keys_by_identifier (g_cConfFile, cNewConfFilePath, '+'); g_free (cNewConfFilePath); } //\___________________ On charge les icones. g_string_printf (sCommand, "find '%s' -mindepth 1 ! -name '*.desktop' ! -name 'container-*' -delete", g_cCurrentLaunchersPath); cd_message ("%s", sCommand->str); system (sCommand->str); g_string_printf (sCommand, "find '%s/%s' -mindepth 1 ! -name '*.desktop' -exec /bin/cp -p '{}' '%s' \\;", cNewThemePath, CAIRO_DOCK_LAUNCHERS_DIR, g_cCurrentLaunchersPath); cd_message ("%s", sCommand->str); system (sCommand->str); //\___________________ On charge les lanceurs si necessaire, en effacant ceux existants. if (g_pMainDock == NULL || g_key_file_get_boolean (pKeyFile, "Themes", "use theme launchers", NULL)) { g_string_printf (sCommand, "rm -f '%s'/*.desktop", g_cCurrentLaunchersPath); cd_message ("%s", sCommand->str); system (sCommand->str); g_string_printf (sCommand, "cp '%s/%s'/*.desktop '%s'", cNewThemePath, CAIRO_DOCK_LAUNCHERS_DIR, g_cCurrentLaunchersPath); cd_message ("%s", sCommand->str); system (sCommand->str); } //\___________________ On remplace tous les autres fichiers par les nouveaux. g_string_printf (sCommand, "find '%s' -mindepth 1 -maxdepth 1 ! -name '*.conf' -type f -exec rm -rf '{}' \\;", g_cCurrentThemePath); // efface tous les fichiers du theme mais sans toucher aux lanceurs et aux plug-ins. cd_message ("%s", sCommand->str); system (sCommand->str); /// A FAIRE : fusionner les fichiers de conf des plug-ins si deja presents. g_string_printf (sCommand, "find '%s'/* -prune ! -name '*.conf' ! -name %s -exec /bin/cp -r '{}' '%s' \\;", cNewThemePath, CAIRO_DOCK_LAUNCHERS_DIR, g_cCurrentThemePath); // copie tous les fichiers du nouveau theme sauf les lanceurs et le .conf, dans le repertoire du theme courant. Ecrase les fichiers de memes noms. cd_message ("%s", sCommand->str); system (sCommand->str); //\___________________ On charge le theme courant. cairo_dock_load_theme (g_cCurrentThemePath); g_free (cNewThemeName); g_hash_table_destroy (hThemeTable); return FALSE; } g_free (cNewThemeName); //\___________________ On sauvegarde le theme actuel cNewThemeName = g_key_file_get_string (pKeyFile, "Save", "theme name", &erreur); if (erreur != NULL) { cd_warning ("Attention : %s", erreur->message); g_error_free (erreur); erreur = NULL; } if (cNewThemeName != NULL && *cNewThemeName == '\0') { g_free (cNewThemeName); cNewThemeName = NULL; } cd_message ("cNewThemeName : %s", cNewThemeName); if (cNewThemeName != NULL) { cd_message ("on sauvegarde dans %s", cNewThemeName); gboolean bThemeSaved = FALSE; gchar *cNewThemePath = g_hash_table_lookup (hThemeTable, cNewThemeName); if (cNewThemePath != NULL) // on ecrase un theme existant. { cd_message (" theme existant"); if (strncmp (cNewThemePath, CAIRO_DOCK_SHARE_THEMES_DIR, strlen (CAIRO_DOCK_SHARE_THEMES_DIR)) == 0) // c'est un theme pre-installe. { cd_warning ("You can't overwrite a pre-installed theme"); } else { gchar *question = g_strdup_printf (_("Are you sure you want to overwrite theme %s ?"), cNewThemeName); GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW (pWidget), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, question); g_free (question); int answer = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); if (answer == GTK_RESPONSE_YES) { gchar *cNewConfFilePath = g_strdup_printf ("%s/%s", cNewThemePath, CAIRO_DOCK_CONF_FILE); if (g_key_file_get_boolean (pKeyFile, "Save", "save current behaviour", NULL)) { g_string_printf (sCommand, "/bin/cp '%s' '%s'", g_cConfFile, cNewConfFilePath); cd_message ("%s", sCommand->str); system (sCommand->str); } else { cairo_dock_replace_keys_by_identifier (cNewConfFilePath, g_cConfFile, '+'); } g_free (cNewConfFilePath); if (g_key_file_get_boolean (pKeyFile, "Save", "save current launchers", NULL)) { g_string_printf (sCommand, "rm -f '%s/%s'/*", cNewThemePath, CAIRO_DOCK_LAUNCHERS_DIR); cd_message ("%s", sCommand->str); system (sCommand->str); g_string_printf (sCommand, "cp '%s'/* '%s/%s'", g_cCurrentLaunchersPath, cNewThemePath, CAIRO_DOCK_LAUNCHERS_DIR); cd_message ("%s", sCommand->str); system (sCommand->str); } g_string_printf (sCommand, "find '%s' -mindepth 1 -maxdepth 1 ! -name '*.conf' ! -name '%s' -exec /bin/cp -r '{}' '%s' \\;", g_cCurrentThemePath, CAIRO_DOCK_LAUNCHERS_DIR, cNewThemePath); cd_message ("%s", sCommand->str); system (sCommand->str); bThemeSaved = TRUE; } } } else { cNewThemePath = g_strdup_printf ("%s/%s/%s", g_cCairoDockDataDir, CAIRO_DOCK_THEMES_DIR, cNewThemeName); cd_message (" nouveau theme (%s)", cNewThemePath); if (g_mkdir (cNewThemePath, 7*8*8+7*8+5) != 0) bThemeSaved = FALSE; else { g_string_printf (sCommand, "cp -r '%s'/* '%s'", g_cCurrentThemePath, cNewThemePath); cd_message ("%s", sCommand->str); system (sCommand->str); g_free (cNewThemePath); bThemeSaved = TRUE; } } if (bThemeSaved) cairo_dock_mark_theme_as_modified (FALSE); } //\___________________ On efface les themes qui ne sont plus desires. gsize length = 0; gchar ** cThemesList = g_key_file_get_string_list (pKeyFile, "Delete", "wanted themes", &length, &erreur); if (erreur != NULL) { cd_warning ("Attention : %s", erreur->message); g_error_free (erreur); erreur = NULL; } else if (cThemesList != NULL) { gchar *cThemesDir = g_strdup_printf ("%s/%s", g_cCairoDockDataDir, CAIRO_DOCK_THEMES_DIR); GHashTable *hUserThemeTable = cairo_dock_list_themes (cThemesDir, NULL, &erreur); g_free (cThemesDir); if (erreur != NULL) { cd_warning ("Attention : %s", erreur->message); g_error_free (erreur); erreur = NULL; } else { if (cNewThemeName != NULL) g_hash_table_remove (hUserThemeTable, cNewThemeName); // pour ne pas effacer le theme qu'on vient d'enregistrer. gpointer data[2] = {cThemesList, pWidget}; g_hash_table_foreach (hUserThemeTable, (GHFunc) _cairo_dock_delete_one_theme, data); } g_hash_table_destroy (hUserThemeTable); } g_strfreev (cThemesList); g_free (cNewThemeName); g_key_file_free (pKeyFile); } g_string_free (sCommand, TRUE); g_hash_table_destroy (hThemeTable); return FALSE; }
/* called when the "save" button is pressed. */ static void save_clicked_cb (GtkWidget *widget, DialogData *data) { GList *scan; CommentData *cdata; const char *text; char *comment_text; struct tm tm = {0}; GtkTextIter start_iter, end_iter; gboolean save_changed; save_changed = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->save_changed_checkbutton)); cdata = comment_data_new (); /* Place */ text = gtk_entry_get_text (GTK_ENTRY (data->place_entry)); if (text != NULL) cdata->place = g_strdup (text); /* Comment */ gtk_text_buffer_get_bounds (data->note_text_buffer, &start_iter, &end_iter); comment_text = gtk_text_buffer_get_text (data->note_text_buffer, &start_iter, &end_iter, FALSE); if (comment_text != NULL) cdata->comment = comment_text; /**/ if (save_changed && (data->original_cdata != NULL)) { CommentData *o_cdata = data->original_cdata; /* NULL-ify equal fields. */ if (text_field_cmp (cdata->place, o_cdata->place) == 0) { g_free (cdata->place); cdata->place = NULL; } if (cdata->time == o_cdata->time) cdata->time = -1; if (text_field_cmp (cdata->comment, o_cdata->comment) == 0) { g_free (cdata->comment); cdata->comment = NULL; } } /* Save */ for (scan = data->file_list; scan; scan = scan->next) { const char *filename = scan->data; int option; /* Date */ cdata->time = -1; option = gtk_option_menu_get_history (GTK_OPTION_MENU (data->date_optionmenu)); if (option == NO_DATE) cdata->time = 0; else if (option == NO_CHANGE) cdata->time = -1; else { time_t t; struct tm *tm_date; t = get_requested_time (data, filename); tm_date = localtime (&t); tm.tm_year = tm_date->tm_year; tm.tm_mon = tm_date->tm_mon; tm.tm_mday = tm_date->tm_mday; tm.tm_hour = tm_date->tm_hour; tm.tm_min = tm_date->tm_min; tm.tm_sec = tm_date->tm_sec; tm.tm_isdst = tm_date->tm_isdst; cdata->time = mktime (&tm); if (cdata->time <= 0) cdata->time = 0; } /**/ if (save_changed) comments_save_comment_non_null (filename, cdata); else comments_save_comment (filename, cdata); all_windows_notify_update_metadata (filename); } gth_window_update_current_image_metadata (data->window); comment_data_free (cdata); /**/ dlg_comment_close (data->dialog); }
static void help_about_action_cb(GtkAction *action, WordListWindow *window) { const gchar *name = N_("uim-dict"); #if GTK_CHECK_VERSION(2, 6, 0) GdkPixbuf *pixbuf, *transparent; const gchar *filename = UIM_PIXMAPSDIR "/uim-dict.png"; const gchar *authors[] = { "Masahito Omote <*****@*****.**>", "Takuro Ashie", "Etsushi Kato", NULL }; const gchar *copyright = N_( "Copyright (C) 2003-2004 Masahito Omote\n" "Copyright (C) 2004-2013 uim Project\n" "All rights reserved."); transparent = NULL; pixbuf = gdk_pixbuf_new_from_file(filename, NULL); if (pixbuf) { transparent = gdk_pixbuf_add_alpha(pixbuf, TRUE, 0xff, 0xff, 0xff); g_object_unref(pixbuf); } #if !GTK_CHECK_VERSION(2, 18, 0) gtk_about_dialog_set_url_hook (activate_url, NULL, NULL); #endif gtk_show_about_dialog (GTK_WINDOW(window), "name", name, "version", VERSION, "copyright", copyright, "website", "https://github.com/uim/uim", "authors", authors, "logo", transparent, NULL); g_object_unref(transparent); #else GtkWidget *about_dialog, *label1; const gchar *copyright = N_( "Copyright 2003-2004 Masahito Omote <[email protected]>\n" "Copyright 2004-2013 uim Project https://github.com/uim/uim\n" "All rights reserved."); gchar *about_name = g_strdup_printf("<span size=\"20000\">%s %s </span>\n\n<span size=\"14000\">%s </span>\n", _(name), VERSION, _(copyright)); about_dialog = gtk_dialog_new_with_buttons(_("About uim-dict"), NULL, GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); gtk_container_set_border_width(GTK_CONTAINER(about_dialog), 8); label1 = gtk_label_new(NULL); gtk_widget_show(label1); gtk_label_set_markup(GTK_LABEL(label1), about_name); g_free(about_name); gtk_box_pack_start( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(about_dialog))), label1, FALSE, FALSE, 0); gtk_window_set_transient_for(GTK_WINDOW(about_dialog), GTK_WINDOW(window)); gtk_window_set_position(GTK_WINDOW(about_dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_dialog_run(GTK_DIALOG(about_dialog)); gtk_widget_destroy(about_dialog); #endif }
/** * rb_uri_resolve_symlink: * @uri: the URI to process * @error: returns error information * * Attempts to resolve symlinks in @uri and return a canonical URI for the file * it identifies. * * Return value: resolved URI, or NULL on error */ char * rb_uri_resolve_symlink (const char *uri, GError **error) { GFile *file = NULL; GFileInfo *file_info = NULL; int link_count = 0; char *result = NULL; const char *attr = G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET; GError *l_error = NULL; file = g_file_new_for_uri (uri); while (link_count < MAX_LINK_LEVEL) { GFile *parent; GFile *new_file; const char *target; /* look for a symlink target */ file_info = g_file_query_info (file, attr, G_FILE_QUERY_INFO_NONE, NULL, &l_error); if (l_error != NULL) { /* argh */ result = g_file_get_uri (file); rb_debug ("error querying %s: %s", result, l_error->message); g_free (result); result = NULL; break; } else if (g_file_info_has_attribute (file_info, attr) == FALSE) { /* no symlink, so return the path */ result = g_file_get_uri (file); if (link_count > 0) { rb_debug ("resolved symlinks: %s -> %s", uri, result); } break; } /* resolve it and try again */ new_file = NULL; parent = g_file_get_parent (file); if (parent == NULL) { /* dang */ break; } target = g_file_info_get_attribute_byte_string (file_info, attr); new_file = g_file_resolve_relative_path (parent, target); g_object_unref (parent); g_object_unref (file_info); file_info = NULL; g_object_unref (file); file = new_file; if (file == NULL) { /* dang */ break; } link_count++; } if (file != NULL) { g_object_unref (file); } if (file_info != NULL) { g_object_unref (file_info); } if (result == NULL && error == NULL) { rb_debug ("too many symlinks while resolving %s", uri); l_error = g_error_new (G_IO_ERROR, G_IO_ERROR_TOO_MANY_LINKS, _("Too many symlinks")); } if (l_error != NULL) { g_propagate_error (error, l_error); } return result; }
/* * public: */ void gui_start(Config *config, Cache *cache) { gboolean start_app = FALSE; gboolean database_is_valid = FALSE; gboolean account_is_initialized = FALSE; GtkWidget *dialog = NULL; GError *err = NULL; g_assert(config != NULL); g_assert(cache != NULL); g_debug("Starting GUI..."); #ifdef G_OS_WIN32 gchar *path; /* load windows theme */ g_debug("Parsing MS-Windows theme file"); path = g_build_filename(pathbuilder_get_share_directory(), G_DIR_SEPARATOR_S, "themes", G_DIR_SEPARATOR_S, "MS-Windows", G_DIR_SEPARATOR_S, "gtk-2.0", G_DIR_SEPARATOR_S, "gtkrc", NULL); g_debug("filename: %s", path); gtk_rc_parse(path); g_free(path); #endif /* check if configuration is empty */ if(!(start_app = settings_config_has_account(config))) { /* configuration is empty => start wizard */ g_debug("Configuration doesn't contain at least one account, starting wizard"); if((start_app = wizard_start(config))) { _gui_save_config(config); } } if(start_app) { /* initialize database */ g_debug("Initializing database..."); switch(database_init(&err)) { case DATABASE_INIT_FAILURE: dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("Couldn't initialize %s, database seems to be damaged."), APPLICATION_NAME); break; case DATABASE_INIT_APPLICATION_OUTDATED: dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("Couldn't initialize database, please upgrade %s."), APPLICATION_NAME); break; case DATABASE_INIT_FIRST_INITIALIZATION: case DATABASE_INIT_SUCCESS: case DATABASE_INIT_DATABASE_UPGRADED: database_is_valid = TRUE; break; default: g_warning("Invalid database result code."); break; } /* display failure messages */ if(err) { g_warning("%s", err->message); g_error_free(err); err = NULL; } if(database_is_valid) { /* initialize first account (if neccessary) */ g_debug("Testing account initialization status..."); if(!(account_is_initialized = _gui_check_account_initialization(config))) { g_debug("Starting account initialization"); if((account_is_initialized = _gui_initialize_account(config))) { g_debug("account has been initialized successfully => updating configuration"); _gui_enable_account_initialization(config); _gui_save_config(config); } else { dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, _("Account initialization failed, please try again later.")); } } /* open mainwindow */ if(account_is_initialized) { g_debug("Opening mainwindow"); mainwindow_start(config, cache); } } /* show warning dialog */ if(dialog) { gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); } } }
//gboolean //gst_gl_context_create (GstGLContext * context, GstGLContext * other_context, GError ** error) static gpointer gst_gl_context_create_thread (GstGLContext * context) { GstGLContextClass *context_class; GstGLWindowClass *window_class; GstGLDisplay *display; GstGLFuncs *gl; gint gl_major = 0, gl_minor = 0; gboolean ret = FALSE; GstGLAPI compiled_api, user_api; gchar *api_string; gchar *compiled_api_s; gchar *user_api_string; const gchar *user_choice, *extensions; GError **error; GstGLContext *other_context; g_mutex_lock (&context->priv->render_lock); error = context->priv->error; other_context = context->priv->other_context; context_class = GST_GL_CONTEXT_GET_CLASS (context); window_class = GST_GL_WINDOW_GET_CLASS (context->window); if (window_class->open) { if (!window_class->open (context->window, error)) goto failure; } display = context->priv->display; gl = context->gl_vtable; compiled_api = _compiled_api (); user_choice = g_getenv ("GST_GL_API"); user_api = gst_gl_api_from_string (user_choice); user_api_string = gst_gl_api_to_string (user_api); compiled_api_s = gst_gl_api_to_string (compiled_api); if ((user_api & compiled_api) == GST_GL_API_NONE) { g_set_error (error, GST_GL_CONTEXT_ERROR, GST_GL_CONTEXT_ERROR_WRONG_API, "Cannot create context with the user requested api (%s). " "We have support for (%s)", user_api_string, compiled_api_s); g_free (user_api_string); g_free (compiled_api_s); goto failure; } if (context_class->choose_format && !context_class->choose_format (context, error)) { g_assert (error == NULL || *error != NULL); g_free (compiled_api_s); g_free (user_api_string); goto failure; } GST_INFO ("Attempting to create opengl context. user chosen api(s) (%s), " "compiled api support (%s)", user_api_string, compiled_api_s); if (!context_class->create_context (context, compiled_api & user_api, other_context, error)) { g_assert (error == NULL || *error != NULL); g_free (compiled_api_s); g_free (user_api_string); goto failure; } GST_INFO ("created context"); if (!context_class->activate (context, TRUE)) { g_set_error (error, GST_GL_CONTEXT_ERROR, GST_GL_CONTEXT_ERROR_RESOURCE_UNAVAILABLE, "Failed to activate the GL Context"); g_free (compiled_api_s); g_free (user_api_string); goto failure; } display->gl_api = gst_gl_context_get_gl_api (context); g_assert (display->gl_api != GST_GL_API_NONE && display->gl_api != GST_GL_API_ANY); api_string = gst_gl_api_to_string (display->gl_api); GST_INFO ("available GL APIs: %s", api_string); if (((compiled_api & display->gl_api) & user_api) == GST_GL_API_NONE) { g_set_error (error, GST_GL_CONTEXT_ERROR, GST_GL_CONTEXT_ERROR_WRONG_API, "failed to create context, context " "could not provide correct api. user (%s), compiled (%s), context (%s)", user_api_string, compiled_api_s, api_string); g_free (api_string); g_free (compiled_api_s); g_free (user_api_string); goto failure; } g_free (api_string); g_free (compiled_api_s); g_free (user_api_string); gl->GetError = gst_gl_context_get_proc_address (context, "glGetError"); gl->GetString = gst_gl_context_get_proc_address (context, "glGetString"); gl->GetStringi = gst_gl_context_get_proc_address (context, "glGetStringi"); gl->GetIntegerv = gst_gl_context_get_proc_address (context, "glGetIntegerv"); if (!gl->GetError || !gl->GetString) { g_set_error (error, GST_GL_CONTEXT_ERROR, GST_GL_CONTEXT_ERROR_FAILED, "could not GetProcAddress core opengl functions"); goto failure; } /* gl api specific code */ if (!ret && USING_OPENGL (display)) ret = _create_context_opengl (context, &gl_major, &gl_minor, error); if (!ret && USING_GLES2 (display)) ret = _create_context_gles2 (context, &gl_major, &gl_minor, error); if (!ret) goto failure; /* GL core contexts and GLES3 */ if (gl->GetIntegerv && gl->GetStringi) { extensions = _build_extension_string (context); } else { extensions = (const gchar *) gl->GetString (GL_EXTENSIONS); } _gst_gl_feature_check_ext_functions (context, gl_major, gl_minor, extensions); context->priv->alive = TRUE; g_cond_signal (&context->priv->create_cond); // g_mutex_unlock (&context->priv->render_lock); gst_gl_window_send_message_async (context->window, (GstGLWindowCB) _unlock_create_thread, context, NULL); gst_gl_window_run (context->window); GST_INFO ("loop exited\n"); g_mutex_lock (&context->priv->render_lock); context->priv->alive = FALSE; context_class->activate (context, FALSE); context_class->destroy_context (context); /* User supplied callback */ if (context->window->close) context->window->close (context->window->close_data); /* window specific shutdown */ if (window_class->close) { window_class->close (context->window); } g_cond_signal (&context->priv->destroy_cond); g_mutex_unlock (&context->priv->render_lock); return NULL; failure: { g_cond_signal (&context->priv->create_cond); g_mutex_unlock (&context->priv->render_lock); return NULL; } }
void cut_shutdown(void) { g_free(tmp_directory); }
void gegl_random_free (GeglRandom *rand) { g_free (rand); }
static gboolean gst_rtp_g722_depay_setcaps (GstRTPBaseDepayload * depayload, GstCaps * caps) { GstStructure *structure; GstRtpG722Depay *rtpg722depay; gint clock_rate, payload, samplerate; gint channels; GstCaps *srccaps; gboolean res; #if 0 const gchar *channel_order; const GstRTPChannelOrder *order; #endif rtpg722depay = GST_RTP_G722_DEPAY (depayload); structure = gst_caps_get_structure (caps, 0); payload = 96; gst_structure_get_int (structure, "payload", &payload); switch (payload) { case GST_RTP_PAYLOAD_G722: channels = 1; clock_rate = 8000; samplerate = 16000; break; default: /* no fixed mapping, we need clock-rate */ channels = 0; clock_rate = 0; samplerate = 0; break; } /* caps can overwrite defaults */ clock_rate = gst_rtp_g722_depay_parse_int (structure, "clock-rate", clock_rate); if (clock_rate == 0) goto no_clockrate; if (clock_rate == 8000) samplerate = 16000; if (samplerate == 0) samplerate = clock_rate; channels = gst_rtp_g722_depay_parse_int (structure, "encoding-params", channels); if (channels == 0) { channels = gst_rtp_g722_depay_parse_int (structure, "channels", channels); if (channels == 0) { /* channels defaults to 1 otherwise */ channels = 1; } } depayload->clock_rate = clock_rate; rtpg722depay->rate = samplerate; rtpg722depay->channels = channels; srccaps = gst_caps_new_simple ("audio/G722", "rate", G_TYPE_INT, samplerate, "channels", G_TYPE_INT, channels, NULL); /* FIXME: Do something with the channel order */ #if 0 /* add channel positions */ channel_order = gst_structure_get_string (structure, "channel-order"); order = gst_rtp_channels_get_by_order (channels, channel_order); if (order) { gst_audio_set_channel_positions (gst_caps_get_structure (srccaps, 0), order->pos); } else { GstAudioChannelPosition *pos; GST_ELEMENT_WARNING (rtpg722depay, STREAM, DECODE, (NULL), ("Unknown channel order '%s' for %d channels", GST_STR_NULL (channel_order), channels)); /* create default NONE layout */ pos = gst_rtp_channels_create_default (channels); gst_audio_set_channel_positions (gst_caps_get_structure (srccaps, 0), pos); g_free (pos); } #endif res = gst_pad_set_caps (depayload->srcpad, srccaps); gst_caps_unref (srccaps); return res; /* ERRORS */ no_clockrate: { GST_ERROR_OBJECT (depayload, "no clock-rate specified"); return FALSE; } }
static void show_access_point_info (NMAccessPoint *ap) { guint32 flags, wpa_flags, rsn_flags, freq, bitrate; guint8 strength; const GByteArray *ssid; const char *hwaddr; NM80211Mode mode; char *freq_str, *ssid_str, *bitrate_str, *strength_str, *wpa_flags_str, *rsn_flags_str; GString *security_str; /* Get AP properties */ flags = nm_access_point_get_flags (ap); wpa_flags = nm_access_point_get_wpa_flags (ap); rsn_flags = nm_access_point_get_rsn_flags (ap); ssid = nm_access_point_get_ssid (ap); hwaddr = nm_access_point_get_hw_address (ap); freq = nm_access_point_get_frequency (ap); mode = nm_access_point_get_mode (ap); bitrate = nm_access_point_get_max_bitrate (ap); strength = nm_access_point_get_strength (ap); /* Convert to strings */ ssid_str = nm_utils_ssid_to_utf8 (ssid); freq_str = g_strdup_printf ("%u MHz", freq); bitrate_str = g_strdup_printf ("%u MB/s", bitrate/1000); strength_str = g_strdup_printf ("%u", strength); wpa_flags_str = ap_wpa_rsn_flags_to_string (wpa_flags); rsn_flags_str = ap_wpa_rsn_flags_to_string (rsn_flags); security_str = g_string_new (NULL); if ( !(flags & NM_802_11_AP_FLAGS_PRIVACY) && (wpa_flags != NM_802_11_AP_SEC_NONE) && (rsn_flags != NM_802_11_AP_SEC_NONE)) g_string_append (security_str, "Encrypted: "); if ( (flags & NM_802_11_AP_FLAGS_PRIVACY) && (wpa_flags == NM_802_11_AP_SEC_NONE) && (rsn_flags == NM_802_11_AP_SEC_NONE)) g_string_append (security_str, "WEP "); if (wpa_flags != NM_802_11_AP_SEC_NONE) g_string_append (security_str, "WPA "); if (rsn_flags != NM_802_11_AP_SEC_NONE) g_string_append (security_str, "WPA2 "); if ( (wpa_flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X) || (rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X)) g_string_append (security_str, "Enterprise "); if (security_str->len > 0) g_string_truncate (security_str, security_str->len-1); /* Chop off last space */ printf ("SSID: %s\n", ssid_str); printf ("BSSID: %s\n", hwaddr); printf ("Mode: %s\n", mode == NM_802_11_MODE_ADHOC ? "Ad-Hoc" : mode == NM_802_11_MODE_INFRA ? "Infrastructure" : "Unknown"); printf ("Freq: %s\n", freq_str); printf ("Bitrate: %s\n", bitrate_str); printf ("Strength: %s\n", strength_str); printf ("Security: %s\n", security_str->str); printf ("WPA flags: %s\n", wpa_flags_str); printf ("RSN flags: %s\n", rsn_flags_str); printf ("D-Bus path: %s\n\n", nm_object_get_path (NM_OBJECT (ap))); g_free (ssid_str); g_free (freq_str); g_free (bitrate_str); g_free (strength_str); g_free (wpa_flags_str); g_free (rsn_flags_str); g_string_free (security_str, TRUE); }
void virtio_blk_free_request(VirtIOBlockReq *req) { if (req) { g_free(req); } }
static int virtio_blk_handle_scsi_req(VirtIOBlockReq *req) { int status = VIRTIO_BLK_S_OK; struct virtio_scsi_inhdr *scsi = NULL; VirtIODevice *vdev = VIRTIO_DEVICE(req->dev); VirtQueueElement *elem = &req->elem; VirtIOBlock *blk = req->dev; #ifdef __linux__ int i; VirtIOBlockIoctlReq *ioctl_req; BlockAIOCB *acb; #endif /* * We require at least one output segment each for the virtio_blk_outhdr * and the SCSI command block. * * We also at least require the virtio_blk_inhdr, the virtio_scsi_inhdr * and the sense buffer pointer in the input segments. */ if (elem->out_num < 2 || elem->in_num < 3) { status = VIRTIO_BLK_S_IOERR; goto fail; } /* * The scsi inhdr is placed in the second-to-last input segment, just * before the regular inhdr. */ scsi = (void *)elem->in_sg[elem->in_num - 2].iov_base; if (!blk->conf.scsi) { status = VIRTIO_BLK_S_UNSUPP; goto fail; } /* * No support for bidirection commands yet. */ if (elem->out_num > 2 && elem->in_num > 3) { status = VIRTIO_BLK_S_UNSUPP; goto fail; } #ifdef __linux__ ioctl_req = g_new0(VirtIOBlockIoctlReq, 1); ioctl_req->req = req; ioctl_req->hdr.interface_id = 'S'; ioctl_req->hdr.cmd_len = elem->out_sg[1].iov_len; ioctl_req->hdr.cmdp = elem->out_sg[1].iov_base; ioctl_req->hdr.dxfer_len = 0; if (elem->out_num > 2) { /* * If there are more than the minimally required 2 output segments * there is write payload starting from the third iovec. */ ioctl_req->hdr.dxfer_direction = SG_DXFER_TO_DEV; ioctl_req->hdr.iovec_count = elem->out_num - 2; for (i = 0; i < ioctl_req->hdr.iovec_count; i++) { ioctl_req->hdr.dxfer_len += elem->out_sg[i + 2].iov_len; } ioctl_req->hdr.dxferp = elem->out_sg + 2; } else if (elem->in_num > 3) { /* * If we have more than 3 input segments the guest wants to actually * read data. */ ioctl_req->hdr.dxfer_direction = SG_DXFER_FROM_DEV; ioctl_req->hdr.iovec_count = elem->in_num - 3; for (i = 0; i < ioctl_req->hdr.iovec_count; i++) { ioctl_req->hdr.dxfer_len += elem->in_sg[i].iov_len; } ioctl_req->hdr.dxferp = elem->in_sg; } else { /* * Some SCSI commands don't actually transfer any data. */ ioctl_req->hdr.dxfer_direction = SG_DXFER_NONE; } ioctl_req->hdr.sbp = elem->in_sg[elem->in_num - 3].iov_base; ioctl_req->hdr.mx_sb_len = elem->in_sg[elem->in_num - 3].iov_len; acb = blk_aio_ioctl(blk->blk, SG_IO, &ioctl_req->hdr, virtio_blk_ioctl_complete, ioctl_req); if (!acb) { g_free(ioctl_req); status = VIRTIO_BLK_S_UNSUPP; goto fail; } return -EINPROGRESS; #else abort(); #endif fail: /* Just put anything nonzero so that the ioctl fails in the guest. */ if (scsi) { virtio_stl_p(vdev, &scsi->errors, 255); } return status; }
/* PowerPC Mac99 hardware initialisation */ static void ppc_core99_init(MachineState *machine) { ram_addr_t ram_size = machine->ram_size; const char *cpu_model = machine->cpu_model; const char *kernel_filename = machine->kernel_filename; const char *kernel_cmdline = machine->kernel_cmdline; const char *initrd_filename = machine->initrd_filename; const char *boot_device = machine->boot_order; PowerPCCPU *cpu = NULL; CPUPPCState *env = NULL; char *filename; qemu_irq *pic, **openpic_irqs; MemoryRegion *isa = g_new(MemoryRegion, 1); MemoryRegion *unin_memory = g_new(MemoryRegion, 1); MemoryRegion *unin2_memory = g_new(MemoryRegion, 1); int linux_boot, i, j, k; MemoryRegion *ram = g_new(MemoryRegion, 1), *bios = g_new(MemoryRegion, 1); hwaddr kernel_base, initrd_base, cmdline_base = 0; long kernel_size, initrd_size; PCIBus *pci_bus; PCIDevice *macio; MACIOIDEState *macio_ide; BusState *adb_bus; MacIONVRAMState *nvr; int bios_size; MemoryRegion *pic_mem, *escc_mem; MemoryRegion *escc_bar = g_new(MemoryRegion, 1); int ppc_boot_device; DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS]; void *fw_cfg; int machine_arch; SysBusDevice *s; DeviceState *dev; int *token = g_new(int, 1); hwaddr nvram_addr = 0xFFF04000; uint64_t tbfreq; linux_boot = (kernel_filename != NULL); /* init CPUs */ if (cpu_model == NULL) #ifdef TARGET_PPC64 cpu_model = "970fx"; #else cpu_model = "G4"; #endif for (i = 0; i < smp_cpus; i++) { cpu = cpu_ppc_init(cpu_model); if (cpu == NULL) { fprintf(stderr, "Unable to find PowerPC CPU definition\n"); exit(1); } env = &cpu->env; /* Set time-base frequency to 100 Mhz */ cpu_ppc_tb_init(env, TBFREQ); qemu_register_reset(ppc_core99_reset, cpu); } /* allocate RAM */ memory_region_allocate_system_memory(ram, NULL, "ppc_core99.ram", ram_size); memory_region_add_subregion(get_system_memory(), 0, ram); /* allocate and load BIOS */ memory_region_init_ram(bios, NULL, "ppc_core99.bios", BIOS_SIZE, &error_abort); vmstate_register_ram_global(bios); if (bios_name == NULL) bios_name = PROM_FILENAME; filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); memory_region_set_readonly(bios, true); memory_region_add_subregion(get_system_memory(), PROM_ADDR, bios); /* Load OpenBIOS (ELF) */ if (filename) { bios_size = load_elf(filename, NULL, NULL, NULL, NULL, NULL, 1, ELF_MACHINE, 0); g_free(filename); } else { bios_size = -1; } if (bios_size < 0 || bios_size > BIOS_SIZE) { hw_error("qemu: could not load PowerPC bios '%s'\n", bios_name); exit(1); } if (linux_boot) { uint64_t lowaddr = 0; int bswap_needed; #ifdef BSWAP_NEEDED bswap_needed = 1; #else bswap_needed = 0; #endif kernel_base = KERNEL_LOAD_ADDR; kernel_size = load_elf(kernel_filename, translate_kernel_address, NULL, NULL, &lowaddr, NULL, 1, ELF_MACHINE, 0); if (kernel_size < 0) kernel_size = load_aout(kernel_filename, kernel_base, ram_size - kernel_base, bswap_needed, TARGET_PAGE_SIZE); if (kernel_size < 0) kernel_size = load_image_targphys(kernel_filename, kernel_base, ram_size - kernel_base); if (kernel_size < 0) { hw_error("qemu: could not load kernel '%s'\n", kernel_filename); exit(1); } /* load initrd */ if (initrd_filename) { initrd_base = round_page(kernel_base + kernel_size + KERNEL_GAP); initrd_size = load_image_targphys(initrd_filename, initrd_base, ram_size - initrd_base); if (initrd_size < 0) { hw_error("qemu: could not load initial ram disk '%s'\n", initrd_filename); exit(1); } cmdline_base = round_page(initrd_base + initrd_size); } else { initrd_base = 0; initrd_size = 0; cmdline_base = round_page(kernel_base + kernel_size + KERNEL_GAP); } ppc_boot_device = 'm'; } else { kernel_base = 0; kernel_size = 0; initrd_base = 0; initrd_size = 0; ppc_boot_device = '\0'; /* We consider that NewWorld PowerMac never have any floppy drive * For now, OHW cannot boot from the network. */ for (i = 0; boot_device[i] != '\0'; i++) { if (boot_device[i] >= 'c' && boot_device[i] <= 'f') { ppc_boot_device = boot_device[i]; break; } } if (ppc_boot_device == '\0') { fprintf(stderr, "No valid boot device for Mac99 machine\n"); exit(1); } } /* Register 8 MB of ISA IO space */ memory_region_init_alias(isa, NULL, "isa_mmio", get_system_io(), 0, 0x00800000); memory_region_add_subregion(get_system_memory(), 0xf2000000, isa); /* UniN init: XXX should be a real device */ memory_region_init_io(unin_memory, NULL, &unin_ops, token, "unin", 0x1000); memory_region_add_subregion(get_system_memory(), 0xf8000000, unin_memory); memory_region_init_io(unin2_memory, NULL, &unin_ops, token, "unin", 0x1000); memory_region_add_subregion(get_system_memory(), 0xf3000000, unin2_memory); openpic_irqs = g_malloc0(smp_cpus * sizeof(qemu_irq *)); openpic_irqs[0] = g_malloc0(smp_cpus * sizeof(qemu_irq) * OPENPIC_OUTPUT_NB); for (i = 0; i < smp_cpus; i++) { /* Mac99 IRQ connection between OpenPIC outputs pins * and PowerPC input pins */ switch (PPC_INPUT(env)) { case PPC_FLAGS_INPUT_6xx: openpic_irqs[i] = openpic_irqs[0] + (i * OPENPIC_OUTPUT_NB); openpic_irqs[i][OPENPIC_OUTPUT_INT] = ((qemu_irq *)env->irq_inputs)[PPC6xx_INPUT_INT]; openpic_irqs[i][OPENPIC_OUTPUT_CINT] = ((qemu_irq *)env->irq_inputs)[PPC6xx_INPUT_INT]; openpic_irqs[i][OPENPIC_OUTPUT_MCK] = ((qemu_irq *)env->irq_inputs)[PPC6xx_INPUT_MCP]; /* Not connected ? */ openpic_irqs[i][OPENPIC_OUTPUT_DEBUG] = NULL; /* Check this */ openpic_irqs[i][OPENPIC_OUTPUT_RESET] = ((qemu_irq *)env->irq_inputs)[PPC6xx_INPUT_HRESET]; break; #if defined(TARGET_PPC64) case PPC_FLAGS_INPUT_970: openpic_irqs[i] = openpic_irqs[0] + (i * OPENPIC_OUTPUT_NB); openpic_irqs[i][OPENPIC_OUTPUT_INT] = ((qemu_irq *)env->irq_inputs)[PPC970_INPUT_INT]; openpic_irqs[i][OPENPIC_OUTPUT_CINT] = ((qemu_irq *)env->irq_inputs)[PPC970_INPUT_INT]; openpic_irqs[i][OPENPIC_OUTPUT_MCK] = ((qemu_irq *)env->irq_inputs)[PPC970_INPUT_MCP]; /* Not connected ? */ openpic_irqs[i][OPENPIC_OUTPUT_DEBUG] = NULL; /* Check this */ openpic_irqs[i][OPENPIC_OUTPUT_RESET] = ((qemu_irq *)env->irq_inputs)[PPC970_INPUT_HRESET]; break; #endif /* defined(TARGET_PPC64) */ default: hw_error("Bus model not supported on mac99 machine\n"); exit(1); } } pic = g_new0(qemu_irq, 64); dev = qdev_create(NULL, TYPE_OPENPIC); qdev_prop_set_uint32(dev, "model", OPENPIC_MODEL_RAVEN); qdev_init_nofail(dev); s = SYS_BUS_DEVICE(dev); pic_mem = s->mmio[0].memory; k = 0; for (i = 0; i < smp_cpus; i++) { for (j = 0; j < OPENPIC_OUTPUT_NB; j++) { sysbus_connect_irq(s, k++, openpic_irqs[i][j]); } } for (i = 0; i < 64; i++) { pic[i] = qdev_get_gpio_in(dev, i); } if (PPC_INPUT(env) == PPC_FLAGS_INPUT_970) { /* 970 gets a U3 bus */ pci_bus = pci_pmac_u3_init(pic, get_system_memory(), get_system_io()); machine_arch = ARCH_MAC99_U3; machine->usb |= defaults_enabled(); } else { pci_bus = pci_pmac_init(pic, get_system_memory(), get_system_io()); machine_arch = ARCH_MAC99; } /* Timebase Frequency */ if (kvm_enabled()) { tbfreq = kvmppc_get_tbfreq(); } else { tbfreq = TBFREQ; } /* init basic PC hardware */ escc_mem = escc_init(0, pic[0x25], pic[0x24], serial_hds[0], serial_hds[1], ESCC_CLOCK, 4); memory_region_init_alias(escc_bar, NULL, "escc-bar", escc_mem, 0, memory_region_size(escc_mem)); macio = pci_create(pci_bus, -1, TYPE_NEWWORLD_MACIO); dev = DEVICE(macio); qdev_connect_gpio_out(dev, 0, pic[0x19]); /* CUDA */ qdev_connect_gpio_out(dev, 1, pic[0x0d]); /* IDE */ qdev_connect_gpio_out(dev, 2, pic[0x02]); /* IDE DMA */ qdev_connect_gpio_out(dev, 3, pic[0x0e]); /* IDE */ qdev_connect_gpio_out(dev, 4, pic[0x03]); /* IDE DMA */ qdev_prop_set_uint64(dev, "frequency", tbfreq); macio_init(macio, pic_mem, escc_bar); /* We only emulate 2 out of 3 IDE controllers for now */ ide_drive_get(hd, ARRAY_SIZE(hd)); macio_ide = MACIO_IDE(object_resolve_path_component(OBJECT(macio), "ide[0]")); macio_ide_init_drives(macio_ide, hd); macio_ide = MACIO_IDE(object_resolve_path_component(OBJECT(macio), "ide[1]")); macio_ide_init_drives(macio_ide, &hd[MAX_IDE_DEVS]); dev = DEVICE(object_resolve_path_component(OBJECT(macio), "cuda")); adb_bus = qdev_get_child_bus(dev, "adb.0"); dev = qdev_create(adb_bus, TYPE_ADB_KEYBOARD); qdev_init_nofail(dev); dev = qdev_create(adb_bus, TYPE_ADB_MOUSE); qdev_init_nofail(dev); if (machine->usb) { pci_create_simple(pci_bus, -1, "pci-ohci"); /* U3 needs to use USB for input because Linux doesn't support via-cuda on PPC64 */ if (machine_arch == ARCH_MAC99_U3) { usbdevice_create("keyboard"); usbdevice_create("mouse"); } } pci_vga_init(pci_bus); if (graphic_depth != 15 && graphic_depth != 32 && graphic_depth != 8) { graphic_depth = 15; } for (i = 0; i < nb_nics; i++) { pci_nic_init_nofail(&nd_table[i], pci_bus, "ne2k_pci", NULL); } /* The NewWorld NVRAM is not located in the MacIO device */ #ifdef CONFIG_KVM if (kvm_enabled() && getpagesize() > 4096) { /* We can't combine read-write and read-only in a single page, so move the NVRAM out of ROM again for KVM */ nvram_addr = 0xFFE00000; } #endif dev = qdev_create(NULL, TYPE_MACIO_NVRAM); qdev_prop_set_uint32(dev, "size", 0x2000); qdev_prop_set_uint32(dev, "it_shift", 1); qdev_init_nofail(dev); sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, nvram_addr); nvr = MACIO_NVRAM(dev); pmac_format_nvram_partition(nvr, 0x2000); /* No PCI init: the BIOS will do it */ fw_cfg = fw_cfg_init_mem(CFG_ADDR, CFG_ADDR + 2); fw_cfg_add_i16(fw_cfg, FW_CFG_MAX_CPUS, (uint16_t)max_cpus); fw_cfg_add_i32(fw_cfg, FW_CFG_ID, 1); fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size); fw_cfg_add_i16(fw_cfg, FW_CFG_MACHINE_ID, machine_arch); fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, kernel_base); fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size); if (kernel_cmdline) { fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, cmdline_base); pstrcpy_targphys("cmdline", cmdline_base, TARGET_PAGE_SIZE, kernel_cmdline); } else { fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_CMDLINE, 0); } fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, initrd_base); fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, initrd_size); fw_cfg_add_i16(fw_cfg, FW_CFG_BOOT_DEVICE, ppc_boot_device); fw_cfg_add_i16(fw_cfg, FW_CFG_PPC_WIDTH, graphic_width); fw_cfg_add_i16(fw_cfg, FW_CFG_PPC_HEIGHT, graphic_height); fw_cfg_add_i16(fw_cfg, FW_CFG_PPC_DEPTH, graphic_depth); fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_IS_KVM, kvm_enabled()); if (kvm_enabled()) { #ifdef CONFIG_KVM uint8_t *hypercall; hypercall = g_malloc(16); kvmppc_get_hypercall(env, hypercall, 16); fw_cfg_add_bytes(fw_cfg, FW_CFG_PPC_KVM_HC, hypercall, 16); fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_KVM_PID, getpid()); #endif } fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_TBFREQ, tbfreq); /* Mac OS X requires a "known good" clock-frequency value; pass it one. */ fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_CLOCKFREQ, CLOCKFREQ); fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_BUSFREQ, BUSFREQ); fw_cfg_add_i32(fw_cfg, FW_CFG_PPC_NVRAM_ADDR, nvram_addr); qemu_register_boot_set(fw_cfg_boot_set, fw_cfg); }
/** * e_text_to_html_full: * @input: a NUL-terminated input buffer * @flags: some combination of the E_TEXT_TO_HTML_* flags defined * in e-html-utils.h * @color: color for citation highlighting * * This takes a buffer of text as input and produces a buffer of * "equivalent" HTML, subject to certain transformation rules. * * The set of possible flags is: * * - E_TEXT_TO_HTML_PRE: wrap the output HTML in <PRE> and * </PRE> Should only be used if @input is the entire * buffer to be converted. If e_text_to_html is being called with * small pieces of data, you should wrap the entire result in * <PRE> yourself. * * - E_TEXT_TO_HTML_CONVERT_NL: convert "\n" to "<BR>n" on * output. (Should not be used with E_TEXT_TO_HTML_PRE, since * that would result in double-newlines.) * * - E_TEXT_TO_HTML_CONVERT_SPACES: convert a block of N spaces * into N-1 non-breaking spaces and one normal space. A space * at the start of the buffer is always converted to a * non-breaking space, regardless of the following character, * which probably means you don't want to use this flag on * pieces of data that aren't delimited by at least line breaks. * * If E_TEXT_TO_HTML_CONVERT_NL and E_TEXT_TO_HTML_CONVERT_SPACES * are both defined, then TABs will also be converted to spaces. * * - E_TEXT_TO_HTML_CONVERT_URLS: wrap <a href="..."> </a> * around strings that look like URLs. * * - E_TEXT_TO_HTML_CONVERT_ADDRESSES: wrap <a href="mailto:..."> * </a> around strings that look like mail addresses. * * - E_TEXT_TO_HTML_MARK_CITATION: wrap <font color="..."> * </font> around citations (lines beginning with "> ", etc). * * - E_TEXT_TO_HTML_ESCAPE_8BIT: flatten everything to US-ASCII * * - E_TEXT_TO_HTML_CITE: quote the text with "> " at the start of each * line. * * Returns: a newly-allocated string containing HTML **/ gchar * e_text_to_html_full (const gchar *input, guint flags, guint32 color) { const guchar *cur, *next, *linestart; gchar *buffer = NULL; gchar *out = NULL; gint buffer_size = 0, col; gboolean colored = FALSE, saw_citation = FALSE; /* Allocate a translation buffer. */ buffer_size = strlen (input) * 2 + 5; buffer = g_malloc (buffer_size); out = buffer; if (flags & E_TEXT_TO_HTML_PRE) out += sprintf (out, "<PRE>"); col = 0; for (cur = linestart = (const guchar *) input; cur && *cur; cur = next) { gunichar u; if (flags & E_TEXT_TO_HTML_MARK_CITATION && col == 0) { saw_citation = is_citation (cur, saw_citation); if (saw_citation) { if (!colored) { gchar font[25]; g_snprintf (font, 25, "<FONT COLOR=\"#%06x\">", color); out = check_size (&buffer, &buffer_size, out, 25); out += sprintf (out, "%s", font); colored = TRUE; } } else if (colored) { const gchar *no_font = "</FONT>"; out = check_size (&buffer, &buffer_size, out, 9); out += sprintf (out, "%s", no_font); colored = FALSE; } /* Display mbox-mangled ">From" as "From" */ if (*cur == '>' && !saw_citation) cur++; } else if (flags & E_TEXT_TO_HTML_CITE && col == 0) { out = check_size (&buffer, &buffer_size, out, 5); out += sprintf (out, "> "); } u = g_utf8_get_char ((gchar *) cur); if (g_unichar_isalpha (u) && (flags & E_TEXT_TO_HTML_CONVERT_URLS)) { gchar *tmpurl = NULL, *refurl = NULL, *dispurl = NULL; if (!g_ascii_strncasecmp ((gchar *)cur, "http://", 7) || !g_ascii_strncasecmp ((gchar *)cur, "https://", 8) || !g_ascii_strncasecmp ((gchar *)cur, "ftp://", 6) || !g_ascii_strncasecmp ((gchar *)cur, "nntp://", 7) || !g_ascii_strncasecmp ((gchar *)cur, "mailto:", 7) || !g_ascii_strncasecmp ((gchar *)cur, "news:", 5) || !g_ascii_strncasecmp ((gchar *)cur, "file:", 5) || !g_ascii_strncasecmp ((gchar *)cur, "callto:", 7) || !g_ascii_strncasecmp ((gchar *)cur, "h323:", 5) || !g_ascii_strncasecmp ((gchar *)cur, "sip:", 4) || !g_ascii_strncasecmp ((gchar *)cur, "webcal:", 7)) { tmpurl = url_extract (&cur, TRUE); if (tmpurl) { refurl = e_text_to_html (tmpurl, 0); dispurl = g_strdup (refurl); } } else if (!g_ascii_strncasecmp ((gchar *)cur, "www.", 4) && is_url_char (*(cur + 4))) { tmpurl = url_extract (&cur, FALSE); if (tmpurl) { dispurl = e_text_to_html (tmpurl, 0); refurl = g_strdup_printf ("http://%s", dispurl); } } if (tmpurl) { out = check_size (&buffer, &buffer_size, out, strlen (refurl) + strlen (dispurl) + 15); out += sprintf (out, "<a href=\"%s\">%s</a>", refurl, dispurl); col += strlen (tmpurl); g_free (tmpurl); g_free (refurl); g_free (dispurl); } if (!*cur) break; u = g_utf8_get_char ((gchar *) cur); } if (u == '@' && (flags & E_TEXT_TO_HTML_CONVERT_ADDRESSES)) { gchar *addr, *dispaddr, *outaddr; addr = email_address_extract (&cur, &out, linestart); if (addr) { dispaddr = e_text_to_html (addr, 0); outaddr = g_strdup_printf ("<a href=\"mailto:%s\">%s</a>", addr, dispaddr); out = check_size (&buffer, &buffer_size, out, strlen (outaddr)); out += sprintf (out, "%s", outaddr); col += strlen (addr); g_free (addr); g_free (dispaddr); g_free (outaddr); if (!*cur) break; u = g_utf8_get_char ((gchar *) cur); } } if (!g_unichar_validate (u)) { /* Sigh. Someone sent undeclared 8-bit data. * Assume it's iso-8859-1. */ u = *cur; next = cur + 1; } else next = (const guchar *) g_utf8_next_char (cur); out = check_size (&buffer, &buffer_size, out, 10); switch (u) { case '<': strcpy (out, "<"); out += 4; col++; break; case '>': strcpy (out, ">"); out += 4; col++; break; case '&': strcpy (out, "&"); out += 5; col++; break; case '"': strcpy (out, """); out += 6; col++; break; case '\n': if (flags & E_TEXT_TO_HTML_CONVERT_NL) { strcpy (out, "<br>"); out += 4; } *out++ = *cur; linestart = cur; col = 0; break; case '\t': if (flags & (E_TEXT_TO_HTML_CONVERT_SPACES | E_TEXT_TO_HTML_CONVERT_NL)) { do { out = check_size (&buffer, &buffer_size, out, 7); strcpy (out, " "); out += 6; col++; } while (col % 8); break; } /* otherwise, FALL THROUGH */ case ' ': if (flags & E_TEXT_TO_HTML_CONVERT_SPACES) { if (cur == (const guchar *) input || *(cur + 1) == ' ' || *(cur + 1) == '\t' || *(cur - 1) == '\n') { strcpy (out, " "); out += 6; col++; break; } } /* otherwise, FALL THROUGH */ default: if ((u >= 0x20 && u < 0x80) || (u == '\r' || u == '\t')) { /* Default case, just copy. */ *out++ = u; } else { if (flags & E_TEXT_TO_HTML_ESCAPE_8BIT) *out++ = '?'; else out += g_snprintf(out, 9, "&#%d;", u); } col++; break; } } out = check_size (&buffer, &buffer_size, out, 7); if (flags & E_TEXT_TO_HTML_PRE) strcpy (out, "</PRE>"); else *out = '\0'; return buffer; }
static void bp_vis_pcm_handoff (GstElement *sink, GstBuffer *buffer, GstPad *pad, gpointer userdata) { BansheePlayer *player = (BansheePlayer*)userdata; GstStructure *structure; gint channels, wanted_size; gfloat *data; BansheePlayerVisDataCallback vis_data_cb; g_return_if_fail (IS_BANSHEE_PLAYER (player)); vis_data_cb = player->vis_data_cb; if (vis_data_cb == NULL) { return; } if (player->vis_thawing) { // Flush our buffers out. gst_adapter_clear (player->vis_buffer); memset (player->vis_fft_sample_buffer, 0, sizeof(gfloat) * SLICE_SIZE); player->vis_thawing = FALSE; } structure = gst_caps_get_structure (gst_buffer_get_caps (buffer), 0); gst_structure_get_int (structure, "channels", &channels); wanted_size = channels * SLICE_SIZE * sizeof (gfloat); gst_adapter_push (player->vis_buffer, gst_buffer_copy (buffer)); while ((data = (gfloat *)gst_adapter_peek (player->vis_buffer, wanted_size)) != NULL) { gfloat *deinterlaced = g_malloc (wanted_size); gfloat *specbuf = g_new (gfloat, SLICE_SIZE * 2); gint i, j; memcpy (specbuf, player->vis_fft_sample_buffer, SLICE_SIZE * sizeof(gfloat)); for (i = 0; i < SLICE_SIZE; i++) { gfloat avg = 0.0f; for (j = 0; j < channels; j++) { gfloat sample = data[i * channels + j]; deinterlaced[j * SLICE_SIZE + i] = sample; avg += sample; } avg /= channels; specbuf[i + SLICE_SIZE] = avg; } memcpy (player->vis_fft_sample_buffer, &specbuf[SLICE_SIZE], SLICE_SIZE * sizeof(gfloat)); gst_fft_f32_window (player->vis_fft, specbuf, GST_FFT_WINDOW_HAMMING); gst_fft_f32_fft (player->vis_fft, specbuf, player->vis_fft_buffer); for (i = 0; i < SLICE_SIZE; i++) { gfloat val; GstFFTF32Complex cplx = player->vis_fft_buffer[i]; val = cplx.r * cplx.r + cplx.i * cplx.i; val /= SLICE_SIZE * SLICE_SIZE; val = 10.0f * log10f(val); val = (val + 60.0f) / 60.0f; if (val < 0.0f) val = 0.0f; specbuf[i] = val; } vis_data_cb (player, channels, SLICE_SIZE, deinterlaced, SLICE_SIZE, specbuf); g_free (deinterlaced); g_free (specbuf); gst_adapter_flush (player->vis_buffer, wanted_size); } }
static gboolean impl_CalFactory_get_cal (EGdbusCalFactory *object, GDBusMethodInvocation *invocation, const gchar * const *in_source_type, EDataCalFactory *factory) { EDataCal *calendar; EBackend *backend; EDataCalFactoryPrivate *priv = factory->priv; GDBusConnection *connection; ESource *source; gchar *uri; gchar *path = NULL; const gchar *sender; GList *list; GError *error = NULL; gchar *source_xml = NULL; guint type = 0; sender = g_dbus_method_invocation_get_sender (invocation); connection = g_dbus_method_invocation_get_connection (invocation); if (!e_gdbus_cal_factory_decode_get_cal (in_source_type, &source_xml, &type)) { error = g_error_new ( E_DATA_CAL_ERROR, NoSuchCal, _("Invalid call")); g_dbus_method_invocation_return_gerror (invocation, error); g_error_free (error); return TRUE; } source = e_source_new_from_standalone_xml (source_xml); g_free (source_xml); if (!source) { error = g_error_new ( E_DATA_CAL_ERROR, NoSuchCal, _("Invalid source")); g_dbus_method_invocation_return_gerror (invocation, error); g_error_free (error); return TRUE; } uri = e_source_get_uri (source); if (uri == NULL || *uri == '\0') { g_object_unref (source); g_free (uri); error = g_error_new ( E_DATA_CAL_ERROR, NoSuchCal, _("Empty URI")); g_dbus_method_invocation_return_gerror (invocation, error); g_error_free (error); return TRUE; } backend = e_data_cal_factory_get_backend (factory, source, uri, type); if (backend == NULL) { error = g_error_new ( E_DATA_CAL_ERROR, NoSuchCal, _("Invalid source")); g_dbus_method_invocation_return_gerror (invocation, error); g_error_free (error); return TRUE; } g_mutex_lock (priv->calendars_lock); e_dbus_server_hold (E_DBUS_SERVER (factory)); path = construct_cal_factory_path (); calendar = e_data_cal_new (E_CAL_BACKEND (backend)); g_hash_table_insert (priv->calendars, g_strdup (path), calendar); e_cal_backend_add_client (E_CAL_BACKEND (backend), calendar); e_data_cal_register_gdbus_object (calendar, connection, path, &error); g_object_weak_ref ( G_OBJECT (calendar), (GWeakNotify) calendar_freed_cb, factory); /* Update the hash of open connections. */ g_mutex_lock (priv->connections_lock); list = g_hash_table_lookup (priv->connections, sender); list = g_list_prepend (list, calendar); g_hash_table_insert (priv->connections, g_strdup (sender), list); g_mutex_unlock (priv->connections_lock); g_mutex_unlock (priv->calendars_lock); g_object_unref (source); g_free (uri); e_gdbus_cal_factory_complete_get_cal ( object, invocation, path, error); if (error) g_error_free (error); g_free (path); return TRUE; }
static void cdisplay_lcms_profile_get_info (cmsHPROFILE profile, gchar **name, gchar **info) { if (profile) { cmsUInt32Number descSize; gchar *descData; descSize = cmsGetProfileInfoASCII (profile, cmsInfoDescription, "en", "US", NULL, 0); if (descSize > 0) { descData = g_new (gchar, descSize + 1); descSize = cmsGetProfileInfoASCII (profile, cmsInfoDescription, "en", "US", descData, descSize); if (descSize > 0) *name = descData; else g_free (descData); } if (! *name) { descSize = cmsGetProfileInfoASCII (profile, cmsInfoModel, "en", "US", NULL, 0); if (descSize > 0) { descData = g_new (gchar, descSize + 1); descSize = cmsGetProfileInfoASCII(profile, cmsInfoModel, "en", "US", descData, descSize); if (descSize > 0) *name = descData; else g_free (descData); } } if (*name && ! g_utf8_validate (*name, -1, NULL)) { g_free (*name); *name = g_strdup (_("(invalid UTF-8 string)")); } if (! *name) { /* a color profile without a name */ *name = g_strdup (_("(unnamed profile)")); } descSize = cmsGetProfileInfoASCII (profile, cmsInfoManufacturer, "en", "US", NULL, 0); if (descSize > 0) { descData = g_new (gchar, descSize + 1); descSize = cmsGetProfileInfoASCII (profile, cmsInfoManufacturer, "en", "US", descData, descSize); if (descSize > 0) *info = descData; else g_free (descData); } if (*info && ! g_utf8_validate (*info, -1, NULL)) { g_free (*info); *info = NULL; } } else { *name = g_strdup (_("None")); *info = NULL; } }
/* * helpers: */ static gboolean _gui_get_first_account(Config *config, gchar **username, gchar **key, gchar **secret) { Section *section; Section *child; Value *value; gint count; gint result = 0; gboolean success = FALSE; g_debug("Getting account data from configuration..."); *username = NULL; *key = NULL; *secret = NULL; /* get root section from configuration */ section = config_get_root(config); /* find "Accounts" section */ if((section = section_find_first_child(section, "Twitter")) && (section = section_find_first_child(section, "Accounts"))) { count = section_n_children(section); /* set account data */ for(gint i = 0; i < count && !success; ++i) { child = section_nth_child(section, i); if(!g_ascii_strcasecmp(section_get_name(child), "Account")) { ++result; if((value = section_find_first_value(child, "username")) && VALUE_IS_STRING(value)) { *username = g_strdup(value_get_string(value)); g_debug("Found username: \"%s\"", *username); } if((value = section_find_first_value(child, "oauth_access_key")) && VALUE_IS_STRING(value)) { *key = g_strdup(value_get_string(value)); g_debug("Found username: \"%s\"", *key); } if((value = section_find_first_value(child, "oauth_access_secret")) && VALUE_IS_STRING(value)) { *secret = g_strdup(value_get_string(value)); g_debug("Found username: \"%s\"", *secret); } } if(*username && *key && *secret) { success = TRUE; } } } if(!success) { g_free(*username); g_free(*key); g_free(*secret); } return success; }
static cmsHPROFILE cdisplay_lcms_get_display_profile (CdisplayLcms *lcms) { GimpColorConfig *config; cmsHPROFILE profile = NULL; config = gimp_color_display_get_config (GIMP_COLOR_DISPLAY (lcms)); #if defined GDK_WINDOWING_X11 if (config->display_profile_from_gdk) { GdkScreen *screen; GdkAtom type = GDK_NONE; gint format = 0; gint nitems = 0; gint monitor = 0; gchar *atom_name; guchar *data = NULL; screen = cdisplay_lcms_get_screen (lcms, &monitor); if (monitor > 0) atom_name = g_strdup_printf ("_ICC_PROFILE_%d", monitor); else atom_name = g_strdup ("_ICC_PROFILE"); if (gdk_property_get (gdk_screen_get_root_window (screen), gdk_atom_intern (atom_name, FALSE), GDK_NONE, 0, 64 * 1024 * 1024, FALSE, &type, &format, &nitems, &data) && nitems > 0) { profile = cmsOpenProfileFromMem (data, nitems); g_free (data); } g_free (atom_name); } #elif defined GDK_WINDOWING_QUARTZ if (config->display_profile_from_gdk) { CMProfileRef prof = NULL; gint monitor = 0; cdisplay_lcms_get_screen (lcms, &monitor); CMGetProfileByAVID (monitor, &prof); if (prof) { CFDataRef data; data = CMProfileCopyICCData (NULL, prof); CMCloseProfile (prof); if (data) { UInt8 *buffer = g_malloc (CFDataGetLength (data)); /* We cannot use CFDataGetBytesPtr(), because that returns * a const pointer where cmsOpenProfileFromMem wants a * non-const pointer. */ CFDataGetBytes (data, CFRangeMake (0, CFDataGetLength (data)), buffer); profile = cmsOpenProfileFromMem (buffer, CFDataGetLength (data)); g_free (buffer); CFRelease (data); } } } #elif defined G_OS_WIN32 if (config->display_profile_from_gdk) { HDC hdc = GetDC (NULL); if (hdc) { gchar *path; gint32 len = 0; GetICMProfile (hdc, &len, NULL); path = g_new (gchar, len); if (GetICMProfile (hdc, &len, path)) profile = cmsOpenProfileFromFile (path, "r"); g_free (path); ReleaseDC (NULL, hdc); } } #endif if (! profile && config->display_profile) profile = cmsOpenProfileFromFile (config->display_profile, "r"); return profile; }
static void append_element (GtkWidgetPath *path, const char *selector) { static const struct { const char *name; GtkStateFlags state_flag; } pseudo_classes[] = { { "active", GTK_STATE_FLAG_ACTIVE }, { "hover", GTK_STATE_FLAG_PRELIGHT }, { "selected", GTK_STATE_FLAG_SELECTED }, { "disabled", GTK_STATE_FLAG_INSENSITIVE }, { "indeterminate", GTK_STATE_FLAG_INCONSISTENT }, { "focus", GTK_STATE_FLAG_FOCUSED }, { "backdrop", GTK_STATE_FLAG_BACKDROP }, { "dir(ltr)", GTK_STATE_FLAG_DIR_LTR }, { "dir(rtl)", GTK_STATE_FLAG_DIR_RTL }, { "link", GTK_STATE_FLAG_LINK }, { "visited", GTK_STATE_FLAG_VISITED }, { "checked", GTK_STATE_FLAG_CHECKED }, { "drop(active)", GTK_STATE_FLAG_DROP_ACTIVE } }; const char *next; char *name; char type; guint i; next = strpbrk (selector, "#.:"); if (next == NULL) next = selector + strlen (selector); name = g_strndup (selector, next - selector); if (g_ascii_isupper (selector[0])) { GType gtype; gtype = g_type_from_name (name); if (gtype == G_TYPE_INVALID) { g_critical ("Unknown type name `%s'", name); g_free (name); return; } gtk_widget_path_append_type (path, gtype); } else { /* Omit type, we're using name */ gtk_widget_path_append_type (path, G_TYPE_NONE); gtk_widget_path_iter_set_object_name (path, -1, name); } g_free (name); while (*next != '\0') { type = *next; selector = next + 1; next = strpbrk (selector, "#.:"); if (next == NULL) next = selector + strlen (selector); name = g_strndup (selector, next - selector); switch (type) { case '#': gtk_widget_path_iter_set_name (path, -1, name); break; case '.': gtk_widget_path_iter_add_class (path, -1, name); break; case ':': for (i = 0; i < G_N_ELEMENTS (pseudo_classes); i++) { if (g_str_equal (pseudo_classes[i].name, name)) { gtk_widget_path_iter_set_state (path, -1, gtk_widget_path_iter_get_state (path, -1) | pseudo_classes[i].state_flag); break; } } if (i == G_N_ELEMENTS (pseudo_classes)) g_critical ("Unknown pseudo-class :%s", name); break; default: g_assert_not_reached (); break; } g_free (name); } }
G_MODULE_EXPORT gboolean tracker_extract_get_metadata (TrackerExtractInfo *info) { TrackerConfig *config; GTime creation_date; GError *error = NULL; TrackerSparqlBuilder *metadata, *preupdate; const gchar *graph; TrackerXmpData *xd = NULL; PDFData pd = { 0 }; /* actual data */ PDFData md = { 0 }; /* for merging */ PopplerDocument *document; gchar *xml = NULL; gchar *content, *uri; guint n_bytes; GPtrArray *keywords; GString *where; guint i; GFile *file; gchar *filename; int fd; gchar *contents = NULL; gsize len; struct stat st; metadata = tracker_extract_info_get_metadata_builder (info); preupdate = tracker_extract_info_get_preupdate_builder (info); graph = tracker_extract_info_get_graph (info); file = tracker_extract_info_get_file (info); filename = g_file_get_path (file); fd = tracker_file_open_fd (filename); if (fd == -1) { g_warning ("Could not open pdf file '%s': %s\n", filename, g_strerror (errno)); g_free (filename); return FALSE; } if (fstat (fd, &st) == -1) { g_warning ("Could not fstat pdf file '%s': %s\n", filename, g_strerror (errno)); close (fd); g_free (filename); return FALSE; } if (st.st_size == 0) { contents = NULL; len = 0; } else { contents = (gchar *) mmap (NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); if (contents == NULL || contents == MAP_FAILED) { g_warning ("Could not mmap pdf file '%s': %s\n", filename, g_strerror (errno)); close (fd); g_free (filename); return FALSE; } len = st.st_size; } g_free (filename); uri = g_file_get_uri (file); document = poppler_document_new_from_data (contents, len, NULL, &error); if (error) { if (error->code == POPPLER_ERROR_ENCRYPTED) { tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nfo:PaginatedTextDocument"); tracker_sparql_builder_predicate (metadata, "nfo:isContentEncrypted"); tracker_sparql_builder_object_boolean (metadata, TRUE); g_error_free (error); g_free (uri); close (fd); return TRUE; } else { g_warning ("Couldn't create PopplerDocument from uri:'%s', %s", uri, error->message ? error->message : "no error given"); g_error_free (error); g_free (uri); close (fd); return FALSE; } } if (!document) { g_warning ("Could not create PopplerDocument from uri:'%s', " "NULL returned without an error", uri); g_free (uri); close (fd); return FALSE; } tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nfo:PaginatedTextDocument"); g_object_get (document, "title", &pd.title, "author", &pd.author, "subject", &pd.subject, "keywords", &pd.keywords, "creation-date", &creation_date, "metadata", &xml, NULL); if (creation_date > 0) { pd.creation_date = tracker_date_to_string ((time_t) creation_date); } keywords = g_ptr_array_new (); if (xml && (xd = tracker_xmp_new (xml, strlen (xml), uri)) != NULL) { /* The casts here are well understood and known */ md.title = (gchar *) tracker_coalesce_strip (4, pd.title, xd->title, xd->title2, xd->pdf_title); md.subject = (gchar *) tracker_coalesce_strip (2, pd.subject, xd->subject); md.date = (gchar *) tracker_coalesce_strip (3, pd.creation_date, xd->date, xd->time_original); md.author = (gchar *) tracker_coalesce_strip (2, pd.author, xd->creator); write_pdf_data (md, metadata, keywords); if (xd->keywords) { tracker_keywords_parse (keywords, xd->keywords); } if (xd->pdf_keywords) { tracker_keywords_parse (keywords, xd->pdf_keywords); } if (xd->publisher) { tracker_sparql_builder_predicate (metadata, "nco:publisher"); tracker_sparql_builder_object_blank_open (metadata); tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nco:Contact"); tracker_sparql_builder_predicate (metadata, "nco:fullname"); tracker_sparql_builder_object_unvalidated (metadata, xd->publisher); tracker_sparql_builder_object_blank_close (metadata); } if (xd->type) { tracker_sparql_builder_predicate (metadata, "dc:type"); tracker_sparql_builder_object_unvalidated (metadata, xd->type); } if (xd->format) { tracker_sparql_builder_predicate (metadata, "dc:format"); tracker_sparql_builder_object_unvalidated (metadata, xd->format); } if (xd->identifier) { tracker_sparql_builder_predicate (metadata, "dc:identifier"); tracker_sparql_builder_object_unvalidated (metadata, xd->identifier); } if (xd->source) { tracker_sparql_builder_predicate (metadata, "dc:source"); tracker_sparql_builder_object_unvalidated (metadata, xd->source); } if (xd->language) { tracker_sparql_builder_predicate (metadata, "dc:language"); tracker_sparql_builder_object_unvalidated (metadata, xd->language); } if (xd->relation) { tracker_sparql_builder_predicate (metadata, "dc:relation"); tracker_sparql_builder_object_unvalidated (metadata, xd->relation); } if (xd->coverage) { tracker_sparql_builder_predicate (metadata, "dc:coverage"); tracker_sparql_builder_object_unvalidated (metadata, xd->coverage); } if (xd->license) { tracker_sparql_builder_predicate (metadata, "nie:license"); tracker_sparql_builder_object_unvalidated (metadata, xd->license); } if (xd->make || xd->model) { gchar *equip_uri; equip_uri = tracker_sparql_escape_uri_printf ("urn:equipment:%s:%s:", xd->make ? xd->make : "", xd->model ? xd->model : ""); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, equip_uri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nfo:Equipment"); if (xd->make) { tracker_sparql_builder_predicate (preupdate, "nfo:manufacturer"); tracker_sparql_builder_object_unvalidated (preupdate, xd->make); } if (xd->model) { tracker_sparql_builder_predicate (preupdate, "nfo:model"); tracker_sparql_builder_object_unvalidated (preupdate, xd->model); } if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); tracker_sparql_builder_predicate (metadata, "nfo:equipment"); tracker_sparql_builder_object_iri (metadata, equip_uri); g_free (equip_uri); } if (xd->orientation) { tracker_sparql_builder_predicate (metadata, "nfo:orientation"); tracker_sparql_builder_object (metadata, xd->orientation); } if (xd->rights) { tracker_sparql_builder_predicate (metadata, "nie:copyright"); tracker_sparql_builder_object_unvalidated (metadata, xd->rights); } if (xd->white_balance) { tracker_sparql_builder_predicate (metadata, "nmm:whiteBalance"); tracker_sparql_builder_object (metadata, xd->white_balance); } if (xd->fnumber) { gdouble value; value = g_strtod (xd->fnumber, NULL); tracker_sparql_builder_predicate (metadata, "nmm:fnumber"); tracker_sparql_builder_object_double (metadata, value); } if (xd->flash) { tracker_sparql_builder_predicate (metadata, "nmm:flash"); tracker_sparql_builder_object (metadata, xd->flash); } if (xd->focal_length) { gdouble value; value = g_strtod (xd->focal_length, NULL); tracker_sparql_builder_predicate (metadata, "nmm:focalLength"); tracker_sparql_builder_object_double (metadata, value); } /* Question: Shouldn't xd->Artist be merged with md.author instead? */ if (xd->artist || xd->contributor) { const gchar *artist; artist = tracker_coalesce_strip (2, xd->artist, xd->contributor); tracker_sparql_builder_predicate (metadata, "nco:contributor"); tracker_sparql_builder_object_blank_open (metadata); tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nco:Contact"); tracker_sparql_builder_predicate (metadata, "nco:fullname"); tracker_sparql_builder_object_unvalidated (metadata, artist); tracker_sparql_builder_object_blank_close (metadata); } if (xd->exposure_time) { gdouble value; value = g_strtod (xd->exposure_time, NULL); tracker_sparql_builder_predicate (metadata, "nmm:exposureTime"); tracker_sparql_builder_object_double (metadata, value); } if (xd->iso_speed_ratings) { gdouble value; value = g_strtod (xd->iso_speed_ratings, NULL); tracker_sparql_builder_predicate (metadata, "nmm:isoSpeed"); tracker_sparql_builder_object_double (metadata, value); } if (xd->description) { tracker_sparql_builder_predicate (metadata, "nie:description"); tracker_sparql_builder_object_unvalidated (metadata, xd->description); } if (xd->metering_mode) { tracker_sparql_builder_predicate (metadata, "nmm:meteringMode"); tracker_sparql_builder_object (metadata, xd->metering_mode); } if (xd->address || xd->state || xd->country || xd->city || xd->gps_altitude || xd->gps_latitude || xd-> gps_longitude) { tracker_sparql_builder_predicate (metadata, "slo:location"); tracker_sparql_builder_object_blank_open (metadata); /* GeoLocation */ tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "slo:GeoLocation"); if (xd->address || xd->state || xd->country || xd->city) { gchar *addruri; addruri = tracker_sparql_get_uuid_urn (); tracker_sparql_builder_predicate (metadata, "slo:postalAddress"); tracker_sparql_builder_object_iri (metadata, addruri); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, addruri); g_free (addruri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nco:PostalAddress"); if (xd->address) { tracker_sparql_builder_predicate (preupdate, "nco:streetAddress"); tracker_sparql_builder_object_unvalidated (preupdate, xd->address); } if (xd->state) { tracker_sparql_builder_predicate (preupdate, "nco:region"); tracker_sparql_builder_object_unvalidated (preupdate, xd->state); } if (xd->city) { tracker_sparql_builder_predicate (preupdate, "nco:locality"); tracker_sparql_builder_object_unvalidated (preupdate, xd->city); } if (xd->country) { tracker_sparql_builder_predicate (preupdate, "nco:country"); tracker_sparql_builder_object_unvalidated (preupdate, xd->country); } if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); } if (xd->gps_altitude) { tracker_sparql_builder_predicate (metadata, "slo:altitude"); tracker_sparql_builder_object_unvalidated (metadata, xd->gps_altitude); } if (xd->gps_latitude) { tracker_sparql_builder_predicate (metadata, "slo:latitude"); tracker_sparql_builder_object_unvalidated (metadata, xd->gps_latitude); } if (xd->gps_longitude) { tracker_sparql_builder_predicate (metadata, "slo:longitude"); tracker_sparql_builder_object_unvalidated (metadata, xd->gps_longitude); } tracker_sparql_builder_object_blank_close (metadata); /* GeoLocation */ } if (xd->regions) { tracker_xmp_apply_regions (preupdate, metadata, graph, xd); } tracker_xmp_free (xd); } else { /* So if we are here we have NO XMP data and we just * write what we know from Poppler. */ write_pdf_data (pd, metadata, keywords); } where = g_string_new (""); for (i = 0; i < keywords->len; i++) { gchar *p, *escaped, *var; p = g_ptr_array_index (keywords, i); escaped = tracker_sparql_escape_string (p); var = g_strdup_printf ("tag%d", i + 1); /* ensure tag with specified label exists */ tracker_sparql_builder_append (preupdate, "INSERT { "); if (graph) { tracker_sparql_builder_append (preupdate, "GRAPH <"); tracker_sparql_builder_append (preupdate, graph); tracker_sparql_builder_append (preupdate, "> { "); } tracker_sparql_builder_append (preupdate, "_:tag a nao:Tag ; nao:prefLabel \""); tracker_sparql_builder_append (preupdate, escaped); tracker_sparql_builder_append (preupdate, "\""); if (graph) { tracker_sparql_builder_append (preupdate, " } "); } tracker_sparql_builder_append (preupdate, " }\n"); tracker_sparql_builder_append (preupdate, "WHERE { FILTER (NOT EXISTS { " "?tag a nao:Tag ; nao:prefLabel \""); tracker_sparql_builder_append (preupdate, escaped); tracker_sparql_builder_append (preupdate, "\" }) }\n"); /* associate file with tag */ tracker_sparql_builder_predicate (metadata, "nao:hasTag"); tracker_sparql_builder_object_variable (metadata, var); g_string_append_printf (where, "?%s a nao:Tag ; nao:prefLabel \"%s\" .\n", var, escaped); g_free (var); g_free (escaped); g_free (p); } g_ptr_array_free (keywords, TRUE); tracker_extract_info_set_where_clause (info, where->str); g_string_free (where, TRUE); tracker_sparql_builder_predicate (metadata, "nfo:pageCount"); tracker_sparql_builder_object_int64 (metadata, poppler_document_get_n_pages (document)); config = tracker_main_get_config (); n_bytes = tracker_config_get_max_bytes (config); content = extract_content (document, n_bytes); if (content) { tracker_sparql_builder_predicate (metadata, "nie:plainTextContent"); tracker_sparql_builder_object_unvalidated (metadata, content); g_free (content); } read_outline (document, metadata); g_free (xml); g_free (pd.keywords); g_free (pd.title); g_free (pd.subject); g_free (pd.creation_date); g_free (pd.author); g_free (pd.date); g_free (uri); g_object_unref (document); if (contents) { munmap (contents, len); } close (fd); return TRUE; }
/** * rb_sanitize_uri_for_filesystem: * @uri: a URI to sanitize * * Removes characters from @uri that are not allowed by the filesystem * on which it would be stored. At present, this only supports MS DOS * filesystems. * * Return value: sanitized copy of @uri, must be freed by caller. */ char * rb_sanitize_uri_for_filesystem (const char *uri) { char *mountpoint = NULL; char *filesystem; char *sane_uri = NULL; filesystem = rb_uri_get_filesystem_type (uri, &mountpoint); if (!filesystem) return g_strdup (uri); if (!strcmp (filesystem, "fat") || !strcmp (filesystem, "vfat") || !strcmp (filesystem, "msdos")) { char *hostname = NULL; GError *error = NULL; char *full_path; char *fat_path; full_path = g_filename_from_uri (uri, &hostname, &error); if (error) { g_error_free (error); g_free (filesystem); g_free (full_path); g_free (mountpoint); return g_strdup (uri); } /* if we got a mount point, don't sanitize it. the mountpoint must be * valid for the filesystem that contains it, but it may not be valid for * the filesystem it contains. for example, a vfat filesystem mounted * at "/media/Pl1:". */ fat_path = full_path; if (mountpoint != NULL) { char *mount_path; mount_path = g_filename_from_uri (mountpoint, NULL, &error); if (error) { rb_debug ("can't convert mountpoint %s to a path: %s", mountpoint, error->message); g_error_free (error); } else if (g_str_has_prefix (full_path, mount_path)) { fat_path = full_path + strlen (mount_path); } else { rb_debug ("path %s doesn't begin with mount path %s somehow", full_path, mount_path); } g_free (mount_path); } else { rb_debug ("couldn't get mount point for %s", uri); } rb_debug ("sanitizing path %s", fat_path); rb_sanitize_path_for_msdos_filesystem (fat_path); /* create a new uri from this */ sane_uri = g_filename_to_uri (full_path, hostname, &error); rb_debug ("sanitized URI: %s", sane_uri); g_free (hostname); g_free (full_path); if (error) { g_error_free (error); g_free (filesystem); g_free (mountpoint); return g_strdup (uri); } } /* add workarounds for other filesystems limitations here */ g_free (filesystem); g_free (mountpoint); return sane_uri ? sane_uri : g_strdup (uri); }
static void update_device_list (GtkTreeIter *parent) { GtkUIManager *uimanager; GtkTreeIter iter; gboolean cont; guint num_devices; GList *actions, *l; num_devices = 0; uimanager = GTK_UI_MANAGER (gtk_builder_get_object (xml, "bluetooth-applet-ui-manager")); if (parent == NULL) { /* No default adapter? Remove everything */ actions = gtk_action_group_list_actions (devices_action_group); g_list_foreach (actions, (GFunc) remove_action_item, uimanager); g_list_free (actions); goto done; } /* Get a list of actions, and we'll remove the ones with a * device in the list. We remove the submenu items first */ actions = gtk_action_group_list_actions (devices_action_group); for (l = actions; l != NULL; l = l->next) { if (bluetooth_verify_address (gtk_action_get_name (l->data)) == FALSE) l->data = NULL; } actions = g_list_remove_all (actions, NULL); cont = gtk_tree_model_iter_children (devices_model, &iter, parent); while (cont) { GHashTable *services; DBusGProxy *proxy; char *alias, *address, **uuids, *name; gboolean is_connected; BluetoothType type; GtkAction *action, *status, *oper; gtk_tree_model_get (devices_model, &iter, BLUETOOTH_COLUMN_PROXY, &proxy, BLUETOOTH_COLUMN_ADDRESS, &address, BLUETOOTH_COLUMN_SERVICES, &services, BLUETOOTH_COLUMN_ALIAS, &alias, BLUETOOTH_COLUMN_UUIDS, &uuids, BLUETOOTH_COLUMN_TYPE, &type, -1); if (device_has_submenu ((const char **) uuids, services, type) == FALSE || address == NULL || proxy == NULL || alias == NULL) { if (proxy != NULL) g_object_unref (proxy); if (services != NULL) g_hash_table_unref (services); g_strfreev (uuids); g_free (alias); g_free (address); cont = gtk_tree_model_iter_next (devices_model, &iter); continue; } action = gtk_action_group_get_action (devices_action_group, address); oper = NULL; status = NULL; if (action) { char *action_name; actions = g_list_remove (actions, action); action_name = g_strdup_printf ("%s-status", address); status = gtk_action_group_get_action (devices_action_group, action_name); g_free (action_name); action_name = g_strdup_printf ("%s-action", address); oper = gtk_action_group_get_action (devices_action_group, action_name); g_free (action_name); } /* If one service is connected, then we're connected */ is_connected = FALSE; if (services != NULL) { GList *list, *l; list = g_hash_table_get_values (services); for (l = list; l != NULL; l = l->next) { BluetoothStatus val = GPOINTER_TO_INT (l->data); if (val == BLUETOOTH_STATUS_CONNECTED || val == BLUETOOTH_STATUS_PLAYING) { is_connected = TRUE; break; } } g_list_free (list); } name = escape_label_for_action (alias); if (action == NULL) { guint menu_merge_id; char *action_path; /* The menu item with descendants */ action = gtk_action_new (address, name, NULL, NULL); gtk_action_group_add_action (devices_action_group, action); g_object_unref (action); menu_merge_id = gtk_ui_manager_new_merge_id (uimanager); gtk_ui_manager_add_ui (uimanager, menu_merge_id, "/bluetooth-applet-popup/devices-placeholder", address, address, GTK_UI_MANAGER_MENU, FALSE); g_object_set_data_full (G_OBJECT (action), "merge-id", GUINT_TO_POINTER (menu_merge_id), NULL); /* The status menu item */ status = add_menu_item (address, "status", is_connected ? _("Connected") : _("Disconnected"), uimanager, menu_merge_id, NULL); gtk_action_set_sensitive (status, FALSE); if (services != NULL) { action_path = g_strdup_printf ("/bluetooth-applet-popup/devices-placeholder/%s/%s-status", address, address); action_set_bold (uimanager, status, action_path); g_free (action_path); } else { gtk_action_set_visible (status, FALSE); } /* The connect button */ oper = add_menu_item (address, "action", is_connected ? _("Disconnect") : _("Connect"), uimanager, menu_merge_id, G_CALLBACK (on_connect_activate)); if (services == NULL) gtk_action_set_visible (oper, FALSE); add_separator_item (address, "connect-sep", uimanager, menu_merge_id); /* The Send to... button */ if (device_has_uuid ((const char **) uuids, "OBEXObjectPush") != FALSE) { add_menu_item (address, "sendto", _("Send files..."), uimanager, menu_merge_id, G_CALLBACK (sendto_callback)); g_object_set_data_full (G_OBJECT (action), "alias", g_strdup (alias), g_free); } if (device_has_uuid ((const char **) uuids, "OBEXFileTransfer") != FALSE) { add_menu_item (address, "browse", _("Browse files..."), uimanager, menu_merge_id, G_CALLBACK (browse_callback)); } add_separator_item (address, "files-sep", uimanager, menu_merge_id); if (type == BLUETOOTH_TYPE_KEYBOARD && program_available (KEYBOARD_PREFS)) { add_menu_item (address, "keyboard", _("Open Keyboard Preferences..."), uimanager, menu_merge_id, G_CALLBACK (keyboard_callback)); } if (type == BLUETOOTH_TYPE_MOUSE && program_available (MOUSE_PREFS)) { add_menu_item (address, "mouse", _("Open Mouse Preferences..."), uimanager, menu_merge_id, G_CALLBACK (mouse_callback)); } if ((type == BLUETOOTH_TYPE_HEADSET || type == BLUETOOTH_TYPE_HEADPHONES || type == BLUETOOTH_TYPE_OTHER_AUDIO) && program_available (SOUND_PREFS)) { add_menu_item (address, "sound", _("Open Sound Preferences..."), uimanager, menu_merge_id, G_CALLBACK (sound_callback)); } } else { gtk_action_set_label (action, name); gtk_action_set_visible (status, services != NULL); gtk_action_set_visible (oper, services != NULL); if (services != NULL) { set_device_status_label (address, is_connected ? CONNECTED : DISCONNECTED); gtk_action_set_label (oper, is_connected ? _("Disconnect") : _("Connect")); } } g_free (name); if (oper != NULL) { g_object_set_data_full (G_OBJECT (oper), "connected", GINT_TO_POINTER (is_connected ? CONNECTED : DISCONNECTED), NULL); g_object_set_data_full (G_OBJECT (oper), "device-path", g_strdup (dbus_g_proxy_get_path (proxy)), g_free); } /* And now for the trick of the day */ if (is_connected != FALSE) { char *path; path = g_strdup_printf ("/bluetooth-applet-popup/devices-placeholder/%s", address); action_set_bold (uimanager, action, path); g_free (path); } num_devices++; if (proxy != NULL) g_object_unref (proxy); if (services != NULL) g_hash_table_unref (services); g_strfreev (uuids); g_free (alias); g_free (address); cont = gtk_tree_model_iter_next (devices_model, &iter); } /* Remove the left-over devices */ g_list_foreach (actions, (GFunc) remove_action_item, uimanager); g_list_free (actions); done: gtk_ui_manager_ensure_update (uimanager); gtk_action_set_visible (GTK_ACTION (gtk_builder_get_object (xml, "devices-label")), num_devices > 0); }
static void _uri_handle_recurse (GFile *dir, GCancellable *cancel, GHashTable *handled, RBUriRecurseFunc func, gpointer user_data) { GFileEnumerator *files; GFileInfo *info; GError *error = NULL; GFileType file_type; const char *file_id; gboolean file_handled; const char *attributes = G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_TYPE "," G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN "," G_FILE_ATTRIBUTE_ID_FILE "," G_FILE_ATTRIBUTE_ACCESS_CAN_READ; files = g_file_enumerate_children (dir, attributes, G_FILE_QUERY_INFO_NONE, cancel, &error); if (error != NULL) { char *where; /* handle the case where we're given a single file to process */ if (error->code == G_IO_ERROR_NOT_DIRECTORY) { g_clear_error (&error); info = g_file_query_info (dir, attributes, G_FILE_QUERY_INFO_NONE, cancel, &error); if (error == NULL) { if (_should_process (info)) { (func) (dir, FALSE, user_data); } g_object_unref (info); return; } } where = g_file_get_uri (dir); rb_debug ("error enumerating %s: %s", where, error->message); g_free (where); g_error_free (error); return; } while (1) { GFile *child; gboolean is_dir; gboolean ret; ret = TRUE; info = g_file_enumerator_next_file (files, cancel, &error); if (error != NULL) { rb_debug ("error enumerating files: %s", error->message); break; } else if (info == NULL) { break; } if (_should_process (info) == FALSE) { g_object_unref (info); continue; } /* already handled? */ file_id = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_ID_FILE); if (file_id == NULL) { /* have to hope for the best, I guess */ file_handled = FALSE; } else if (g_hash_table_lookup (handled, file_id) != NULL) { file_handled = TRUE; } else { file_handled = FALSE; g_hash_table_insert (handled, g_strdup (file_id), GINT_TO_POINTER (1)); } /* type? */ file_type = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE); switch (file_type) { case G_FILE_TYPE_DIRECTORY: case G_FILE_TYPE_MOUNTABLE: is_dir = TRUE; break; default: is_dir = FALSE; break; } if (file_handled == FALSE) { child = g_file_get_child (dir, g_file_info_get_name (info)); ret = (func) (child, is_dir, user_data); if (is_dir) { _uri_handle_recurse (child, cancel, handled, func, user_data); } g_object_unref (child); } g_object_unref (info); if (ret == FALSE) break; } g_object_unref (files); }
static gboolean gst_identity_sink_event (GstBaseTransform * trans, GstEvent * event) { GstIdentity *identity; gboolean ret = TRUE; identity = GST_IDENTITY (trans); if (!identity->silent) { const GstStructure *s; const gchar *tstr; gchar *sstr; GST_OBJECT_LOCK (identity); g_free (identity->last_message); tstr = gst_event_type_get_name (GST_EVENT_TYPE (event)); if ((s = gst_event_get_structure (event))) sstr = gst_structure_to_string (s); else sstr = g_strdup (""); identity->last_message = g_strdup_printf ("event ******* (%s:%s) E (type: %s (%d), %s) %p", GST_DEBUG_PAD_NAME (trans->sinkpad), tstr, GST_EVENT_TYPE (event), sstr, event); g_free (sstr); GST_OBJECT_UNLOCK (identity); gst_identity_notify_last_message (identity); } if (identity->single_segment && (GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT)) { if (!trans->have_segment) { GstEvent *news; GstSegment segment; gst_event_copy_segment (event, &segment); gst_event_copy_segment (event, &trans->segment); trans->have_segment = TRUE; /* This is the first segment, send out a (0, -1) segment */ gst_segment_init (&segment, segment.format); news = gst_event_new_segment (&segment); gst_pad_event_default (trans->sinkpad, GST_OBJECT_CAST (trans), news); } else { /* need to track segment for proper running time */ gst_event_copy_segment (event, &trans->segment); } } if (GST_EVENT_TYPE (event) == GST_EVENT_GAP && trans->have_segment && trans->segment.format == GST_FORMAT_TIME) { GstClockTime start, dur; gst_event_parse_gap (event, &start, &dur); if (GST_CLOCK_TIME_IS_VALID (start)) { start = gst_segment_to_running_time (&trans->segment, GST_FORMAT_TIME, start); gst_identity_do_sync (identity, start); /* also transform GAP timestamp similar to buffer timestamps */ if (identity->single_segment) { gst_event_unref (event); event = gst_event_new_gap (start, dur); } } } /* Reset previous timestamp, duration and offsets on SEGMENT * to prevent false warnings when checking for perfect streams */ if (GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT) { identity->prev_timestamp = identity->prev_duration = GST_CLOCK_TIME_NONE; identity->prev_offset = identity->prev_offset_end = GST_BUFFER_OFFSET_NONE; } if (identity->single_segment && GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT) { /* eat up segments */ gst_event_unref (event); ret = TRUE; } else { if (GST_EVENT_TYPE (event) == GST_EVENT_FLUSH_START) { GST_OBJECT_LOCK (identity); if (identity->clock_id) { GST_DEBUG_OBJECT (identity, "unlock clock wait"); gst_clock_id_unschedule (identity->clock_id); } GST_OBJECT_UNLOCK (identity); } ret = GST_BASE_TRANSFORM_CLASS (parent_class)->sink_event (trans, event); } return ret; }
gchar *cairo_dock_edit_themes (GHashTable **hThemeTable, gboolean bSafeMode) { //\___________________ On recupere la liste des themes existant (pre-installes et utilisateur). GError *erreur = NULL; gchar *cThemesDir = CAIRO_DOCK_SHARE_THEMES_DIR; *hThemeTable = cairo_dock_list_themes (cThemesDir, NULL, &erreur); if (erreur != NULL) { cd_warning ("Attention : %s", erreur->message); g_error_free (erreur); erreur = NULL; } g_hash_table_insert (*hThemeTable, g_strdup (""), g_strdup ("")); cThemesDir = g_strdup_printf ("%s/%s", g_cCairoDockDataDir, CAIRO_DOCK_THEMES_DIR); *hThemeTable = cairo_dock_list_themes (cThemesDir, *hThemeTable, &erreur); if (erreur != NULL) { cd_warning ("Attention : %s", erreur->message); g_error_free (erreur); erreur = NULL; } GHashTable *hUserThemeTable = cairo_dock_list_themes (cThemesDir, NULL, NULL); g_free (cThemesDir); gchar *cUserThemeNames = cairo_dock_write_table_content (hUserThemeTable, (GHFunc) cairo_dock_write_one_name, TRUE, FALSE); //\___________________ On cree un fichier de conf temporaire. const gchar *cTmpDir = g_get_tmp_dir (); gchar *cTmpConfFile = g_strdup_printf ("%s/cairo-dock-init", cTmpDir); gchar *cCommand = g_strdup_printf ("cp %s/%s %s", CAIRO_DOCK_SHARE_DATA_DIR, CAIRO_DOCK_THEME_CONF_FILE, cTmpConfFile); system (cCommand); g_free (cCommand); //\___________________ On met a jour ce fichier de conf. GKeyFile *pKeyFile = g_key_file_new (); g_key_file_load_from_file (pKeyFile, cTmpConfFile, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, &erreur); if (erreur != NULL) { cd_warning ("Attention : %s", erreur->message); g_error_free (erreur); return NULL; } cairo_dock_update_conf_file_with_themes (pKeyFile, cTmpConfFile, *hThemeTable, "Themes", "chosen theme"); cairo_dock_update_conf_file_with_hash_table (pKeyFile, cTmpConfFile, hUserThemeTable, "Delete", "wanted themes", NULL, (GHFunc) cairo_dock_write_one_name, TRUE, FALSE); cairo_dock_update_conf_file_with_hash_table (pKeyFile, cTmpConfFile, hUserThemeTable, "Save", "theme name", NULL, (GHFunc) cairo_dock_write_one_name, TRUE, FALSE); g_hash_table_destroy (hUserThemeTable); g_key_file_set_string (pKeyFile, "Delete", "wanted themes", cUserThemeNames); // sThemeNames g_free (cUserThemeNames); cairo_dock_write_keys_to_file (pKeyFile, cTmpConfFile); g_key_file_free (pKeyFile); //\___________________ On laisse l'utilisateur l'editer. gchar *cPresentedGroup = (cairo_dock_theme_need_save () ? "Save" : NULL); const gchar *cTitle = (bSafeMode ? _("< Safe Mode >") : _("Manage Themes")); CairoDialog *pDialog = NULL; if (bSafeMode) { pDialog = cairo_dock_show_general_message (_("You are running Cairo-Dock in safe mode.\nWhy ? Probably because a plug-in has messed into your dock,\n or maybe your theme has got corrupted.\nSo, no plug-in will be available, and you can now save your current theme if you want\n before you start using the dock.\nTry with your current theme, if it works, it means a plug-in is wrong.\nOtherwise, try with another theme.\nSave a config that is working, and restart the dock in normal mode.\nThen, activate plug-ins one by one to guess which one is wrong."), 0.); } gboolean bChoiceOK = cairo_dock_edit_conf_file (NULL, cTmpConfFile, cTitle, CAIRO_DOCK_THEME_PANEL_WIDTH, CAIRO_DOCK_THEME_PANEL_HEIGHT, 0, cPresentedGroup, NULL, NULL, NULL, NULL); if (! bChoiceOK) { g_remove (cTmpConfFile); g_free (cTmpConfFile); cTmpConfFile = NULL; } if (bSafeMode) cairo_dock_dialog_unreference (pDialog); return cTmpConfFile; }
/* This function does th emain work of creating and configuring the worker thread. the majority of this code is taken from NFlick the n800 Flickr photo browser by MDK (see: README) */ void fluttr_viewer_go (FluttrViewer *viewer, FluttrPhoto *photo) { FluttrViewerPrivate *priv; FluttrSettings *settings = fluttr_settings_get_default (); NFlickWorker *worker; NFlickWorkerStatus status; gint width = CLUTTER_STAGE_WIDTH (); gint height = CLUTTER_STAGE_HEIGHT(); gchar *token = NULL; gchar *photoid = NULL; g_return_if_fail (FLUTTR_IS_VIEWER (viewer)); priv = FLUTTR_VIEWER_GET_PRIVATE(viewer); if (priv->worker) nflick_worker_request_abort (priv->worker); fluttr_spinner_spin (FLUTTR_SPINNER (priv->spinner), TRUE); clutter_actor_set_opacity (priv->spinner, 255); g_object_get (G_OBJECT (settings), "token", &token, NULL); g_object_get (G_OBJECT (photo), "photoid", &photoid, NULL); worker = (NFlickWorker *)nflick_show_worker_new (photoid, width, height, token); /* Check if the worker is in the right state */ g_object_get (G_OBJECT (worker), "status", &status, NULL); if (status != NFLICK_WORKER_STATUS_IDLE) { g_warning ("Bad worker status"); return; } g_object_ref (worker); priv->worker = worker; /* Get the initial message */ gchar *msg = NULL; g_object_get (G_OBJECT (priv->worker), "message", &msg, NULL); if (msg != NULL) { /* FIXME Escape markup */ //g_print ("%s", msg); } /* Set the callback functions */ nflick_worker_set_custom_data (worker, viewer); nflick_worker_set_aborted_idle (worker, (NFlickWorkerIdleFunc) on_thread_abort_idle); nflick_worker_set_error_idle (worker, (NFlickWorkerIdleFunc) on_thread_error_idle); nflick_worker_set_ok_idle (worker, (NFlickWorkerIdleFunc) on_thread_ok_idle); nflick_worker_set_msg_change_idle (worker, (NFlickWorkerIdleFunc) on_thread_msg_change_idle); nflick_worker_start (priv->worker); /* Free */ g_free (msg); }
void dlg_comment_update (GtkWidget *dlg) { DialogData *data; CommentData *cdata; GList *scan; char *first_image; g_return_if_fail (dlg != NULL); data = g_object_get_data (G_OBJECT (dlg), "dialog_data"); g_return_if_fail (data != NULL); /**/ free_dialog_data (data); data->file_list = gth_window_get_file_list_selection (data->window); if (data->file_list == NULL) { gtk_widget_set_sensitive (data->ok_button, FALSE); gtk_widget_set_sensitive (data->comment_main_box, FALSE); return; } else gtk_widget_set_sensitive (data->comment_main_box, TRUE); /* Set widgets data. */ gtk_option_menu_set_history (GTK_OPTION_MENU (data->date_optionmenu), NO_DATE); gtk_text_buffer_set_text (data->note_text_buffer, "", -1); gtk_entry_set_text (GTK_ENTRY (data->place_entry), ""); data->several_images = g_list_length (data->file_list) > 1; if (data->several_images) { gtk_widget_set_sensitive (data->save_changed_checkbutton, TRUE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->save_changed_checkbutton), TRUE); } else { gtk_widget_set_sensitive (data->save_changed_checkbutton, FALSE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->save_changed_checkbutton), FALSE); } /* Does at least one image have exif data? */ data->have_exif_data = FALSE; for (scan = data->file_list; scan; scan = scan->next) if (have_exif_time (scan->data)) { data->have_exif_data = TRUE; break; } first_image = data->file_list->data; data->original_cdata = cdata = comments_load_comment (first_image, TRUE); if (cdata != NULL) { comment_data_free_keywords (cdata); /* NULL-ify a field if it is not the same in all comments. */ for (scan = data->file_list->next; scan; scan = scan->next) { CommentData *scan_cdata; scan_cdata = comments_load_comment (scan->data, TRUE); /* If there is no comment then all fields must be * considered to differ. */ if ((scan_cdata == NULL) || strcmp_null_tolerant (cdata->place, scan_cdata->place) != 0) { g_free (cdata->place); cdata->place = NULL; } if ((scan_cdata == NULL) || cdata->time != scan_cdata->time) cdata->time = 0; if ((scan_cdata == NULL) || strcmp_null_tolerant (cdata->comment, scan_cdata->comment) != 0) { g_free (cdata->comment); cdata->comment = NULL; } if (scan_cdata == NULL) break; comment_data_free (scan_cdata); } } gtk_widget_set_sensitive (get_exif_date_option_item (data), data->have_exif_data); gtk_widget_set_sensitive (data->date_dateedit, FALSE); if (cdata != NULL) { if (cdata->comment != NULL) { GtkTextIter iter; gtk_text_buffer_set_text (data->note_text_buffer, cdata->comment, strlen (cdata->comment)); gtk_text_buffer_get_iter_at_line (data->note_text_buffer, &iter, 0); gtk_text_buffer_place_cursor (data->note_text_buffer, &iter); } /**/ if (cdata->place != NULL) gtk_entry_set_text (GTK_ENTRY (data->place_entry), cdata->place); /**/ if (cdata->time > 0) { gtk_option_menu_set_history (GTK_OPTION_MENU (data->date_optionmenu), FOLLOWING_DATE); gnome_date_edit_set_time (GNOME_DATE_EDIT (data->date_dateedit), cdata->time); gtk_widget_set_sensitive (data->date_dateedit, TRUE); } else { if (data->several_images) gtk_option_menu_set_history (GTK_OPTION_MENU (data->date_optionmenu), NO_CHANGE); else gtk_option_menu_set_history (GTK_OPTION_MENU (data->date_optionmenu), NO_DATE); gnome_date_edit_set_time (GNOME_DATE_EDIT (data->date_dateedit), get_file_ctime (first_image)); } } else { time_t ctime = get_file_ctime (first_image); gtk_option_menu_set_history (GTK_OPTION_MENU (data->date_optionmenu), NO_DATE); gnome_date_edit_set_time (GNOME_DATE_EDIT (data->date_dateedit), ctime); } }
void skypeweb_search_users_text_cb(SkypeWebAccount *sa, JsonNode *node, gpointer user_data) { JsonArray *resultsarray = NULL; gint index, length; GString *userids; gchar *search_term = user_data; PurpleNotifySearchResults *results; PurpleNotifySearchColumn *column; resultsarray = json_node_get_array(node); length = json_array_get_length(resultsarray); if (length == 0) { gchar *primary_text = g_strdup_printf("Your search for the user \"%s\" returned no results", search_term); purple_notify_warning(sa->pc, "No users found", primary_text, ""); g_free(primary_text); g_free(search_term); return; } userids = g_string_new(""); resultsarray = json_node_get_array(node); for(index = 0; index < length; index++) { JsonObject *result = json_array_get_object_element(resultsarray, index); g_string_append_printf(userids, "%s,", json_object_get_string_member(result, "skypewebid")); } results = purple_notify_searchresults_new(); if (results == NULL) { g_free(search_term); return; } /* columns: Friend ID, Name, Network */ column = purple_notify_searchresults_column_new(_("Skype Name")); purple_notify_searchresults_column_add(results, column); column = purple_notify_searchresults_column_new(_("Display Name")); purple_notify_searchresults_column_add(results, column); column = purple_notify_searchresults_column_new(_("City")); purple_notify_searchresults_column_add(results, column); column = purple_notify_searchresults_column_new(_("Country")); purple_notify_searchresults_column_add(results, column); purple_notify_searchresults_button_add(results, PURPLE_NOTIFY_BUTTON_ADD, skypeweb_search_results_add_buddy); for(index = 0; index < length; index++) { JsonObject *contact = json_array_get_object_element(resultsarray, index); JsonObject *contactcards = json_object_get_object_member(contact, "ContactCards"); JsonObject *skypecontact = json_object_get_object_member(contactcards, "Skype"); JsonObject *currentlocation = json_object_get_object_member(contactcards, "CurrentLocation"); /* the row in the search results table */ /* prepend to it backwards then reverse to speed up adds */ GList *row = NULL; row = g_list_prepend(row, g_strdup(json_object_get_string_member(skypecontact, "SkypeName"))); row = g_list_prepend(row, g_strdup(json_object_get_string_member(skypecontact, "DisplayName"))); row = g_list_prepend(row, g_strdup(json_object_get_string_member(currentlocation, "City"))); row = g_list_prepend(row, g_strdup(json_object_get_string_member(currentlocation, "Country"))); row = g_list_reverse(row); purple_notify_searchresults_row_add(results, row); } purple_notify_searchresults(sa->pc, NULL, search_term, NULL, results, NULL, NULL); }