embeddedapp.cpp

linux下的一款播放器

        // Work around this fact by hacking in a preference into the
        // client's preference area manually.
        
        GIOChannel* chan;
        const gchar* home;
        gchar* filename;
        GError* error = NULL;
        gchar* hxplayerrc_text = NULL;
        const gchar* helix_section = "[helix]\n";
        gchar* pos;
        gsize bytes_written;
        gsize total_length;
        gsize part_1_length;
        gsize part_2_length;
    
        home = g_get_home_dir();
        g_return_if_fail(home != NULL);
    
        filename = g_strdup_printf("%s/%s", home, HXPLAYER_RC);

        chan = g_io_channel_new_file(filename, "r", &error);
        if(error)
        {
            if(error->code == G_FILE_ERROR_NOENT)
            {
                /* No hxplayerrc -- create a basic one. */
                hxplayerrc_text = g_strdup(helix_section);
            }

            g_error_free(error);
            error = NULL;
        }

        if(!error)
        {
            /* Read in the contents of the hxplayerrc */
            status = g_io_channel_read_to_end(chan,
                                              &hxplayerrc_text,
                                              &total_length,
                                              &error);
        }

        if(!error)
        {
            g_io_channel_shutdown(chan, TRUE, &error);

            pos = strstr(hxplayerrc_text, helix_section);
            pos += strlen(helix_section);
            
            part_1_length = pos - hxplayerrc_text;
            part_2_length = total_length - part_1_length;

            if(pos)
            {
                chan = g_io_channel_new_file(filename, "w", &error);
                if(!error)
                {
                    bytes_written = 0;
                    status = g_io_channel_write_chars(chan,
                                                      hxplayerrc_text,
                                                      part_1_length,
                                                      &bytes_written,
                                                      &error);
                    if(!error)
                    {
                        g_assert(bytes_written == part_1_length);
                    }
                }

            }

            if(!error)
            {
                const gchar suppress_pref[] = "SuppressUnsupportedBrowserWarning=1\n";
                gsize len = sizeof(suppress_pref) - 1;
                
                bytes_written = 0;
                status = g_io_channel_write_chars(chan,
                                                  suppress_pref,
                                                  len,
                                                  &bytes_written,
                                                  &error);
                if(!error)
                {
                    g_assert(bytes_written == len);
                }
                
            }

            if(!error)
            {
                bytes_written = 0;
                status = g_io_channel_write_chars(chan,
                                                  pos,
                                                  part_2_length,
                                                  &bytes_written,
                                                  &error);
                if(!error)
                {
                    g_assert(bytes_written == part_2_length);
                }
            }

            if(!error)
            {
                g_io_channel_shutdown(chan, TRUE, &error);
            }

            if(error)
            {
                g_warning(error->message);                
                g_error_free(error);
                error = NULL;
            }
        }
        
        g_free(filename);                    
    }
    
    g_free(info);
}

void
hxembedded_window_show_unsupported_browser_dialog(HXEmbeddedWindow* window)
{
    GtkWidget* dialog;
    GdkWindow* browser_window;
    gchar* dialog_title;
    gchar* filename;
    GladeXML* xml;
    HXUnsupportedBrowserDialog* info;
    GtkWidget* show_warning_in_future_checkbox;

    filename = hxcommon_locate_file("unsupportedbrowser.glade");
    g_return_if_fail(filename != NULL);
    
    xml = glade_xml_new (filename, NULL, NULL);
    g_free(filename);
    g_return_if_fail(xml != NULL);

    dialog = glade_xml_get_widget (xml, "hxplayer_unsupported_browser_warning_dialog");
    show_warning_in_future_checkbox = glade_xml_get_widget(xml, "hubd_show_warning_in_the_future");
                                                           
    g_assert(dialog && show_warning_in_future_checkbox);

    info = g_new0(HXUnsupportedBrowserDialog, 1);
    info->show_warning_in_future_checkbox = show_warning_in_future_checkbox;
    info->xml = xml;
    info->window = window;
    
    dialog_title = g_strdup_printf(_("%s Embedded Player Warning"), APP_NAME_LONG);
    gtk_window_set_title(GTK_WINDOW(dialog), dialog_title);
    g_free(dialog_title);
    
    browser_window = hxembedded_window_get_browser_window(window);
                
    if(browser_window)
    {
        g_signal_connect (G_OBJECT (dialog), "realize",
                          G_CALLBACK (hxcommon_embedded_transient_parent_realized),
                          browser_window);
    }
    
    g_signal_connect_swapped(G_OBJECT(dialog), "response",
                             G_CALLBACK(gtk_widget_destroy), dialog);
    
    g_signal_connect_swapped(G_OBJECT(dialog), "destroy",
                             G_CALLBACK(hubd_show_unsupported_browser_warning_dialog_closed), info);
    
        
    gtk_widget_show(GTK_WIDGET(dialog));
}

gboolean
hew_ff(gpointer data)
{
    guint length;
    guint adjustment;
    guint position;

    HXEmbeddedWindow* window = (HXEmbeddedWindow*)data;
    HXPlayer* player = hxembedded_window_get_player(window);

    length = hx_player_get_length(player);
    position = hx_player_get_position(player);
    adjustment = length / 100;

    position += adjustment;
    if(position > length)
    {
        position = length;
    }

    hx_player_set_position(player, position);

    return TRUE; // don't remove
}

void
hxembedded_window_ff_start(HXEmbeddedWindow* window)
{
    HXPlayer* player = hxembedded_window_get_player(window);

    hx_player_start_seeking(player);
    window->ff_button->timer_id =
        gtk_timeout_add(FF_RW_UPDATE_PERIOD,
                        hew_ff,
                        window);     
}

void
hxembedded_window_ff_stop(HXEmbeddedWindow* window)
{
    HXPlayer* player = hxembedded_window_get_player(window);

    gtk_timeout_remove(window->ff_button->timer_id);
    window->ff_button->timer_id = 0;

    hx_player_stop_seeking(player);    
}

gboolean
hew_ff_start(HXEmbeddedWindow* window, GdkEventButton* event)
{
    if(event->button == 1 && event->type == GDK_BUTTON_PRESS)
    {
        hxembedded_window_ff_start(window);
    }
    return FALSE; // propagate
}

gboolean
hew_ff_stop(HXEmbeddedWindow* window, GdkEventButton* event)
{
    if(event->button == 1 && event->type == GDK_BUTTON_RELEASE)
    {
        hxembedded_window_ff_stop(window);
    }
    return FALSE; // propagate
}

gboolean
hew_rewind(gpointer data)
{
    guint length;
    guint adjustment;
    guint position;

    HXEmbeddedWindow* window = (HXEmbeddedWindow*)data;
    HXPlayer* player = hxembedded_window_get_player(window);

    length = hx_player_get_length(player);
    position = hx_player_get_position(player);
    adjustment = length / 100;

    if(position < adjustment)
    {
        position = 0;
    }
    else
    {
        position -= adjustment;
    }
 
    hx_player_set_position(player, position);

    return TRUE; // don't remove
}

void
hxembedded_window_rewind_start(HXEmbeddedWindow* window)
{
    HXPlayer* player = hxembedded_window_get_player(window);

    hx_player_start_seeking(player);
    window->rewind_button->timer_id =
        gtk_timeout_add(FF_RW_UPDATE_PERIOD,
                        hew_rewind,
                        window);     
}

void
hxembedded_window_rewind_stop(HXEmbeddedWindow* window)
{
    HXPlayer* player = hxembedded_window_get_player(window);

    gtk_timeout_remove(window->rewind_button->timer_id);
    window->rewind_button->timer_id = 0;

    hx_player_stop_seeking(player);    
}

gboolean
hew_rewind_start(HXEmbeddedWindow* window, GdkEventButton* event)
{
    if(event->button == 1 && event->type == GDK_BUTTON_PRESS)
    {
        hxembedded_window_rewind_start(window);
    }
    return FALSE; // propagate
}

gboolean
hew_rewind_stop(HXEmbeddedWindow* window, GdkEventButton* event)
{
    if(event->button == 1 && event->type == GDK_BUTTON_RELEASE)
    {
        hxembedded_window_rewind_stop(window);
    }
    return FALSE; // propagate
}

void
hew_mute(GtkWidget* widget)
{
    HXEmbeddedWindow* window = hxembedded_window_get_window(widget);

    gboolean new_mute = TRUE;

    new_mute = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(window->mute_ctrl->button));

    hxembedded_window_mute(window, new_mute);
}

void
hxembedded_window_mute(HXEmbeddedWindow* window, gboolean new_mute)
{
    HXPlayer* player;
    gboolean mute;

    player = hxembedded_window_get_player(window);
    mute = hx_player_is_muted(HX_PLAYER(player));

    if(mute != new_mute)
    {
        /* Toggle mute */
        hx_player_set_mute(HX_PLAYER(player), new_mute);
    }    
}

void
hew_volume_changed(GtkWidget* widget)
{
    HXEmbeddedWindow* window = hxembedded_window_get_window(widget);

    hxembedded_window_volume_changed(window);
}

void
hxembedded_window_volume_changed(HXEmbeddedWindow* window)
{
    guint new_vol, vol;
    HXPlayer* player;

    g_return_if_fail(window->volume_slider != NULL); 
    g_return_if_fail(window->volume_slider->scale != NULL);

    player = hxembedded_window_get_player(window);

    new_vol = (guint)gtk_range_get_value(GTK_RANGE(window->volume_slider->scale));
    
    vol = hx_player_get_volume(player);
    if(vol != new_vol)
    {
        hx_player_set_volume(HX_PLAYER(player), new_vol);
    }
}

void
hxembedded_window_home(HXEmbeddedWindow*)
{
    /* Display the helix player webpage */    
    hxcommon_url_show("https://player.helixcommunity.org");
}

/* Common code for creating an embedded button with pixmap */
static GtkWidget*
create_controls_button(HXEmbeddedWindow* window, const gchar* pixmap_filename, GtkWidget** image_ptr, GtkWidget** alignment_ptr)
{
    GtkWidget* button;
    gchar* filename;

    *alignment_ptr = gtk_alignment_new(0.5, 0.5, 0, 0);    
    
    button = gtk_button_new();

    gtk_container_add(GTK_CONTAINER(*alignment_ptr), button);

    if(pixmap_filename)
    {
        filename = hxcommon_locate_file(pixmap_filename);        

        if(filename)
        {
            GtkWidget* image = NULL;
            
            image = gtk_image_new_from_file(filename);
            if(image)
            {
                gtk_container_add(GTK_CONTAINER(button), image);
                gtk_widget_set_size_request(image, 16, 16);

                if(image_ptr)
                {
                    *image_ptr = image;