commonapp.cpp

linux下的一款播放器

            {
                g_hxcommon_app.package_data_dir = g_strdup(resolved_exec_path);
                g_hxcommon_app.package = g_strdup("share");
                found = TRUE;
            }
            g_free(resource_test_filename);
#ifdef _GNU_SOURCE
            /* allocated by canonicalize_file_name */
            free(resolved_exec_filename);
#endif
        }
    }
#endif /* G_OS_UNIX */

    if(!found)
    {
        gchar* resource_test_filename;

        resource_test_filename = g_strdup_printf("share/%s", test_file);
                                                 
        /* Try the working directory */
        if(g_file_test(resource_test_filename, G_FILE_TEST_EXISTS))
        {
            g_hxcommon_app.package_data_dir = g_strdup(".");
            g_hxcommon_app.package = g_strdup("share");
            found = TRUE;
        }
        g_free(resource_test_filename);
    }

    if(!found)
    {
        /* Try using the path passed to us in argv[0] */        
        gchar* exec_filename = g_strdup(resolved_argv0);
        gchar* exec_path = g_path_get_dirname(exec_filename);
        gchar* resource_test_filename =
            g_strdup_printf("%s/share/%s", exec_path, test_file);

        if(g_file_test(resource_test_filename, G_FILE_TEST_EXISTS))
        {
            g_hxcommon_app.package_data_dir = g_strdup(exec_path);
            g_hxcommon_app.package = g_strdup("share");
            found = TRUE;
        }
        g_free(exec_filename);
        g_free(resource_test_filename);
    }
    
    if(resolved_argv0)
    {
        g_free(resolved_argv0);
    }

    return found;
}

/* Control the status text at the bottom of the player widget */
static void
set_buffering_status_text(HXPlayer* player,
                          HXBufferingReason /* reason */,
                          guint percent)
{
    gchar* text;

    if (percent == 100)
    {
	// blank the display when we hit 100
	hx_player_set_status_text(player, NULL);
    }
    else
    {
    text = g_strdup_printf("Buffering (%d%%)", percent);
    hx_player_set_status_text(player, text);
    }
}

static void
set_contacting_status_text(HXPlayer* player,
                           const gchar* contacting_text)
{
    if(!contacting_text)
    {
        contacting_text = _("Contacting server...");
    }
    hx_player_set_status_text(player, contacting_text);
}

static void
unset_status_text(HXPlayer* player)
{
    hx_player_set_status_text(player, NULL);    
}

void
hxcommon_show_status_in_player_widget(HXPlayer* player)
{
    g_signal_connect(G_OBJECT(player),
		     "buffering",
		     G_CALLBACK(set_buffering_status_text),
		     NULL);    

    g_signal_connect(G_OBJECT(player),
		     "contacting",
		     G_CALLBACK(set_contacting_status_text),
		     NULL);    

    g_signal_connect(G_OBJECT(player),
		     "play",
		     G_CALLBACK(unset_status_text),
		     NULL);

    g_signal_connect(G_OBJECT(player),
		     "pause",
		     G_CALLBACK(unset_status_text),
		     NULL);

    g_signal_connect(G_OBJECT(player),
		     "stop",
		     G_CALLBACK(unset_status_text),
		     NULL);
}

int
main(int argc, char *argv[]) 
{
    HXCommandLineOptions cmd;
    int i;
    gchar* version_error;
    gboolean result;

    memset(&g_hxcommon_app, 0, sizeof(g_hxcommon_app));

#ifdef G_OS_UNIX
    char* hxplayer_x_init_threads;

    /* Possible values are: normal, delayed, none */
    hxplayer_x_init_threads = getenv("HXPLAYER_X_INIT_THREADS");
    if(!hxplayer_x_init_threads)
    {
        hxplayer_x_init_threads = "after";
    }
#endif

#ifdef ENABLE_NLS
    /* Initialize gettext */
    setlocale (LC_ALL, "");
    bindtextdomain (PACKAGE, LOCALEDIR);

#ifdef HAVE_BIND_TEXTDOMAIN_CODESET
    bind_textdomain_codeset(PACKAGE, "UTF-8");
#endif

    textdomain (PACKAGE);
#endif
    
#ifdef G_OS_UNIX
    if(strcmp(hxplayer_x_init_threads, "before") == 0)
    {
        Status status;
        status = XInitThreads();
        if(!status)
        {
            g_warning("X libraries appear to have been compiled without multithreaded support.");
        }
    }
#endif        

    /* Check the gtk version */
    version_error = gtk_check_version(GTK_MAJOR_VERSION,
                                      0,  /* GTK_MINOR_VERSION */
                                      0); /* GTK_MICRO_VERSION */
    if(version_error)
    {
        g_error("%s (expecting >= %d.%d.%d, using %d.%d.%d)",
                version_error,
                GTK_MAJOR_VERSION,
                0, /* GTK_MINOR_VERSION */
                0, /* GTK_MICRO_VERSION */
                gtk_major_version,
                gtk_minor_version,
                gtk_micro_version);
    }
    
    /* If we're running in embedded mode, close all
       open FD's we inherit, other than the command_fd,
       and std[in|out|err]. Inspired by bash. Also see fcloseall
       in glibc, though there are some fd's we want to keep open. */

    cmd.run_embedded = FALSE;

    /* Parse command line options */
    parse_command_line(&cmd, &argc, &argv);

#ifdef G_OS_UNIX
    int fd_table_size;
    if(cmd.run_embedded)
    {
	fd_table_size = getdtablesize ();
	if (fd_table_size > 1024)
	{
	    /* clamp to a reasonable value */
	    fd_table_size = 1024;
	}

        /* Start at 3 to skip stdout, stdin, stderr */
	for (i = 3; i < fd_table_size; i++)
	{
	    if((i != cmd.command_fd) && (i != cmd.callbacks_fd))
	    {
		close (i);
	    }
	}
    }
#endif
    
    winutils_screensaver_init();

    // This is a glib2.2 function
    // g_set_application_name(APP_NAME_FULL);

    if(!locate_resources(argv[0]))
    {
        g_error("Could not find resources\n");
    }
    
#ifdef USE_GNOME
    gnome_program_init("helixplayer", TARVER_STRING_VERSION,
		       LIBGNOME_MODULE,
		       argc, argv,
 		       // GNOME_PARAM_POPT_TABLE, options,
 		       GNOME_PARAM_HUMAN_READABLE_NAME, "Media Player",
 		       // GNOME_PROGRAM_STANDARD_PROPERTIES,
                       GNOME_PARAM_APP_PREFIX, PREFIX,
                       GNOME_PARAM_APP_SYSCONFDIR, SYSCONFDIR,
                       // GNOME_PARAM_APP_DATADIR, DATADIR,
                       GNOME_PARAM_APP_DATADIR, g_hxapp.package_data_dir,
                       GNOME_PARAM_APP_LIBDIR, LIBDIR
		       );
#endif

    if (!gtk_init_check(&argc, &argv))
    {
        /* g_error will call abort */
	g_error("Unable to open display");
    }    

#ifdef G_OS_UNIX
    if(strcmp(hxplayer_x_init_threads, "after") == 0)
    {
        Status status;
        status = XInitThreads();
        if(!status)
        {
            g_warning("X libraries appear to have been compiled without multithreaded support.");
        }
    }
#endif        

    glade_init();

    if(argc > 1)
    {
        cmd.location = strdup(argv[1]);
        if(argc > 2)
        {
            printf(_("Ignoring unknown options: "));
            for(i = 0; i < argc; i++)
            {
                printf("%s ", argv[optind++]);
            }
            printf("\n");
        }
    }

    g_hxcommon_app.is_embedded = cmd.run_embedded;
    g_hxcommon_app.save_preferences = TRUE;

    HXMainWindow* main_window = NULL;
    
    if(cmd.run_embedded)
    {
#ifdef HELIX_FEATURE_EMBEDDED_PLAYER
        // Use this if you're debugging a forked process
#if 0
#warning "Don't check in with loop active"
        printf("Attach to %d\n", getpid());
        int c = 0; 
        while(c == 0)
        {
        }
#endif
	if(!hxembedded_init(&cmd))
	{
	    return EXIT_FAILURE;
	}	
#endif /* HELIX_FEATURE_EMBEDDED_PLAYER */
    }
    else
    {
        gchar* url = NULL;
        
        if(cmd.location)
        {
            
            if(strstr(cmd.location, "://"))
            {
                url = g_strdup(cmd.location);
            }
            else
            {
                if(g_path_is_absolute(cmd.location))
                {
                    url = g_strdup_printf("file://%s", cmd.location);
                }
                else
                {
                    url = g_strdup_printf("file://%s/%s",
                                          g_get_current_dir(),
                                          cmd.location);
                }
            }
        }
        
        if (!cmd.open_in_new_player)
        {
            /* Attempt to open in an existing player first */
            const gchar* location = (url)? url: "";

            result = hxremote_launch_player (location);
            if(result)
            {
                exit(EXIT_SUCCESS);
            }
            /* else fall through and open up a new player */
        }
        
        main_window = hxwindow_new();
	if(!main_window)
	{
	    return EXIT_FAILURE;
	}

        if(cmd.location)
        {
            if(cmd.quit_on_done)
            {
                hxwindow_set_quit_on_done(main_window, TRUE);
            }
            if(cmd.fullscreen)
            {
                hxwindow_fullscreen(main_window);
            }

            hxwindow_open(main_window, url);
        }
        
        g_free(url);

        /* Get the web browser preference */
        GValue value;
        const gchar* value_str;

        memset(&value, 0, sizeof(value));
        
        result = hxwindow_get_property(main_window, "WebBrowserPath", &value);
        if(result)
        {
            value_str = g_value_get_string(&value);
            g_hxcommon_app.web_browser_command = g_strdup(value_str);
        }
    }

    gtk_main();

    if(cmd.run_embedded)
    {
#ifdef HELIX_FEATURE_EMBEDDED_PLAYER
        hxembedded_destroy();
#endif
    }
    
    g_free(g_hxcommon_app.package_data_dir);
    g_free(g_hxcommon_app.package);

    if(g_hxcommon_app.restart_on_quit)
    {
        return EXIT_RESTART_PLAYER;
    }
    else
    {
        return EXIT_SUCCESS;
    }
}

GdkPixmap*
hxcommon_get_logo_pixmap(GtkWidget* widget,
                         GdkWindow* win)
{
    GdkPixmap *pixmap = NULL;
    gchar *filename;
    GdkPixbuf *pixbuf = NULL;
    gint width, height;
    
    /* Set the splash pixmap */
    filename = hxcommon_locate_file("logo.png");
    if(filename)
    {
        pixbuf = gdk_pixbuf_new_from_file(filename, NULL);
        g_free(filename);
    }

    if(pixbuf)
    {
        width = gdk_pixbuf_get_width(pixbuf);
        height = gdk_pixbuf_get_height(pixbuf);

        pixmap = gdk_pixmap_new(GDK_DRAWABLE(win),
                                width,
                                height,
                                -1);

        g_return_val_if_fail(pixmap != NULL, FALSE);

//         This is a gtk2.2 function. See below for the 2.0 version
//         gdk_draw_pixbuf(GDK_DRAWABLE(pixmap),
//                         widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
//                         pixbuf,
//                         0, 0, // src
//                         0, 0, // dest
//                         width, height,		    
//                         GDK_RGB_DITHER_NORMAL,
//                         0, 0  // dither
//                         );

        gdk_pixbuf_render_to_drawable(pixbuf,
                        GDK_DRAWABLE(pixmap),
                        widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
                        0, 0, // src
                        0, 0, // dest
                        width, height,		    
                        GDK_RGB_DITHER_NORMAL,
                        0, 0  // dither
                        );
    }

    return pixmap;
}


gchar*
hxcommon_get_rel_app_path(const gchar* path)
{
    const char* libs_path = getenv("HELIX_LIBS");
    if (libs_path)
    {
	if (path)
	{
	    return g_strdup_printf("%s/%s", libs_path, path);
	}
	return g_strdup(libs_path);
    }
    return g_strdup(path);
}

G_CONST_RETURN gchar*
hxcommon_get_distcode_language(void)
{
    static const struct
    {
        gchar* gettext_lang;
        gchar* distcode_lang;
    } lang_map[] =
    {
        { "C",     "EN" },
        { "en",    "EN" },
        { "de",    "DE" },
        { "es",    "ES" },
        { "fr",    "FR" },
        { "it",    "IT" },
        { "ja",    "JA" },
        { "ko",    "KO" },
        { "pt_BR", "PT" },
        { "zh_CN", "CN" },
        { "zh_TW", "TW" }
    };

    guint i;
    const gchar* lang = hxcommon_get_gettext_language();
    gchar* distcode_lang = NULL;

    if(lang)
    {
        for(i = 0; i < sizeof(lang_map) / sizeof(*lang_map); i++)
        {
            if(strncmp(lang, lang_map[i].gettext_lang, strlen(lang_map[i].gettext_lang)) == 0)
            {
                distcode_lang = lang_map[i].distcode_lang;
                break;
            }
        }
    }
    else
    {
        distcode_lang = "EN";
    }

    if(!distcode_lang)
    {
        distcode_lang = "XX";
    }
    
    return distcode_lang;
}


G_CONST_RETURN gchar*
hxcommon_get_gettext_language(void)
{
    const gchar *lang;

    // Priority LANGUAGE > LC_ALL > LC_MESSAGE > LANG > NULL
    lang = getenv ("LANGUAGE");
    if (lang == NULL || lang[0] == '\0')
    {
        lang = getenv ("LC_ALL");
        if (lang == NULL || lang[0] == '\0')
        {
            lang = getenv ("LC_MESSAGES");
            if (lang == NULL || lang[0] == '\0')
            {
                lang = getenv ("LANG");
                if (lang == NULL || lang[0] == '\0')
                    lang = NULL;
            }
        }
    }

    return lang;
}