embeddedapp.cpp

linux下的一款播放器

        player = window->console->audio_player;
    }
    
    return player;
    
}

static gint
hxembedded_window_popup_menu(HXEmbeddedWindow* window,
                              GdkEvent* event,
                              GtkWidget* /* widget */)
{
    GdkEventButton *event_button;

    if(!window->enable_context_menu)
    {
        return FALSE;
    }
        
    if (event->type == GDK_BUTTON_PRESS)
    {
        event_button = (GdkEventButton *) event;
        if (event_button->button == 3)
	{
            g_assert(window->image_window != NULL);
            hx_context_menu_popup(window->image_window->context_menu, &event->button);
            return TRUE;
	}
    }
    
    return FALSE; // propagate
}

static HXPlayer*
hxembedded_window_get_player(HXEmbeddedWindow* window)
{
    HXPlayer* player = hxembedded_window_get_player_no_create(window);

    if(!player)
    {
        GtkWidget* widget = hx_player_new();
        player = HX_PLAYER(widget);

        g_signal_connect_swapped(G_OBJECT(player),
                                 "button_press_event",
                                 G_CALLBACK(hxembedded_window_popup_menu),
                                 window);    

        g_signal_connect_swapped(G_OBJECT(player),
                                 "hxerror",
                                 G_CALLBACK(hepw_hxerror),
                                 window);
    
        g_signal_connect_swapped(G_OBJECT(player),
                                 "request_upgrade",
                                 G_CALLBACK(hepw_request_upgrade),
                                 window);

        g_signal_connect_swapped(G_OBJECT(player),
                                 "request_authentication",
                                 G_CALLBACK(hepw_request_authentication),
                                 window);

        g_signal_connect_swapped(G_OBJECT(player),
                                 "has_feature",
                                 G_CALLBACK(hxcommon_player_has_feature),
                                 player);    

        g_signal_connect_swapped(G_OBJECT(player),
                                 "play",
                                 G_CALLBACK(hepw_play_buffer_contact),
                                 window);
    
        g_signal_connect_swapped(G_OBJECT(player),
                                 "buffering",
                                 G_CALLBACK(hepw_play_buffer_contact),
                                 window);

        g_signal_connect_swapped(G_OBJECT(player),
                                 "contacting",
                                 G_CALLBACK(hepw_play_buffer_contact),
                                 window);
    
        g_signal_connect_swapped(G_OBJECT(player),
                                 "pause",
                                 G_CALLBACK(hepw_pause),
                                 window);

        g_signal_connect_swapped(G_OBJECT(player),
                                 "stop",
                                 G_CALLBACK(hepw_stop),
                                 window);    

        g_signal_connect_swapped(G_OBJECT(player),
                                 "mute_changed",
                                 G_CALLBACK(hepw_mute_changed),
                                 window);    

        g_signal_connect_swapped(G_OBJECT(player),
                                 "volume_changed",
                                 G_CALLBACK(hepw_volume_changed),
                                 window);    

        g_signal_connect_swapped(G_OBJECT(player),
                                 "goto_url",
                                 G_CALLBACK(hepw_goto_url),
                                 window);    
    
        g_signal_connect_swapped(G_OBJECT(player),
                                 "open_window",
                                 G_CALLBACK(hepw_open_window),
                                 window);    

        g_signal_connect_swapped(G_OBJECT(player),
                                 "start_seeking",
                                 G_CALLBACK(hepw_start_seeking),
                                 window);    

        g_signal_connect_swapped(G_OBJECT(player),
                                 "stop_seeking",
                                 G_CALLBACK(hepw_stop_seeking),
                                 window);    

        hxcommon_show_status_in_player_widget(HX_PLAYER(player));

        if(window->image_window)
        {
            window->image_window->player = player;
            window->console->image_window_player = player;
        }
        else
        {
            window->console->audio_player = player;
        }

        hxembedded_console_adopt_player(window->console);
    }

    return player;
}

HXContentStateType
hxembedded_window_get_content_state(HXEmbeddedWindow* window)
{
    HXPlayer* player;
            
    player = hxembedded_window_get_player(window);
    g_return_val_if_fail(player != NULL, HX_CONTENT_STATE_NOT_LOADED);
        
    return hx_player_get_content_state (HX_PLAYER(player));
}

void
hxembedded_window_unset_console(HXEmbeddedWindow* window)
{
    if(!window->console)
    {
        /* No console to unset */
        return;
    }
    
    /* This window currently has a console set. Remove it... */
    window->console->windows_list = 
        g_list_remove(window->console->windows_list, window);
    if(g_list_length(window->console->windows_list) == 0)
    {
        /* Remove this console */
        g_hxembedded_app.consoles_list = 
            g_list_remove(g_hxembedded_app.consoles_list, window->console);
        if(strcasecmp(window->console->name, "_master") == 0)
        {
            g_hxembedded_app.master_console = NULL;
        }
        g_free(window->console);

        if(g_list_length(g_hxembedded_app.consoles_list) == 0)
        {
            /* XXXRGG: We might want to quit here. The mozilla plugin should be
               able to restart the embedded player when it needs a console again.
               Requires some thought & testing, though, so keep running for now. */
            
            printf("All consoles have been closed\n");
        }
    }
    else 
    {
        /* Rebuild console */
        hxembedded_console_build_players_from_windows(window->console);
    }
    window->console = NULL;    
}

void
hxembedded_window_set_console(HXEmbeddedWindow* window, const gchar* console_name)
{
    GList* iter = NULL;
    HXEmbeddedConsole* console = NULL;

    if(window->attr.console)
    {
        if(window->console && strcmp(window->attr.console, console_name) == 0)
        {
            /* Console name is the same -- no change needed */
            return;
        }
    }
    
    if(window->console)
    {
        hxembedded_window_unset_console(window);
    }

    if(window->attr.console != console_name)
    {
        if(window->attr.console)
        {
            g_free(window->attr.console);
        }
        window->attr.console = g_strdup(console_name);
    }
    
    if(strcasecmp(window->attr.console, "_unique") != 0)
    {
        /* See if there's already a console with the same name */
        iter = g_hxembedded_app.consoles_list;
        while(iter)
        {
            console = (HXEmbeddedConsole*)iter->data;
            if(strcmp(window->attr.console, console->name) == 0)
            {
                break;
            }
            iter = g_list_next(iter);
        }
    }

    if(!iter)
    {
        /* No existing console with this name. Create a new one. */
        console = g_new0(HXEmbeddedConsole, 1);
        g_hxembedded_app.consoles_list =
            g_list_append(g_hxembedded_app.consoles_list, console);

        console->name = g_strdup(console_name);

        if(strcasecmp(window->attr.console, "_master") == 0)
        {
            g_hxembedded_app.master_console = console;
        }
    }

    window->console = console;
    
    console->windows_list = 
        g_list_append(console->windows_list, window);
        
    hxembedded_console_build_players_from_windows(window->console);
}

gint
hxembedded_window_attach(HXEmbeddedWindowAttributes* attr)
{
    HXEmbeddedWindow* window = NULL;
    
    window = g_new0(HXEmbeddedWindow, 1);

    /* Initialize */
    window->enable_original_size = TRUE;
    window->enable_context_menu = TRUE;
    window->enable_error_events = FALSE; // Pop up error dialogs by default
    window->enable_seek = TRUE;

    /* We're taking ownership of all strings allocated within the attr struct */
    memcpy(&window->attr, attr, sizeof(*attr));
    
    window->id = g_hxembedded_app.next_window_id;
    g_hxembedded_app.next_window_id++;

    hxembedded_window_set_console(window, attr->console);
    
    /* Some pages embed an audio player by using an ImageWindow with
       height 0. We won't get a SetWindow for this window (in Mozilla,
       anyway), so handle creating this player here. */

    if((window->attr.controls & HX_CONTROLS_IMAGE_WINDOW) &&
       (window->attr.height == 0 || window->attr.width == 0))
    {
        /* Audio-only player */
        window->is_window_set = TRUE;
        create_controls_image_window(window);
    }
    
    return window->id;
}

void
hxembedded_window_add_ipc_callbacks(HXEmbeddedWindow* window, HXCallbackFlags flags)
{
    if(window->attr.name != NULL)
    {
        window->attr.scriptcallbacks = (HXCallbackFlags)(window->attr.scriptcallbacks | flags);
        hxembedded_window_hookup_ipc_callbacks(window);
    }
}

void
hxembedded_window_remove_ipc_callbacks(HXEmbeddedWindow* window, HXCallbackFlags flags)
{
    window->attr.scriptcallbacks = (HXCallbackFlags)(window->attr.scriptcallbacks & ~flags);
    hxembedded_window_hookup_ipc_callbacks(window);
}


static gboolean
hxembedded_window_call_pos_len_callbacks(gpointer data)
{
    guint pos;
    guint len;
    HXContentStateType state;
    
    HXEmbeddedWindow* window = (HXEmbeddedWindow*)data;
    HXPlayer* player = hxembedded_window_get_player(window);
    
    /* See if this callback is still active */
    if(!(window->attr.scriptcallbacks & HX_CALLBACK_ON_POS_LENGTH))
    {
        window->player_handlers.on_pos_length.is_enabled = FALSE;
    }

    if(!(window->attr.scriptcallbacks & HX_CALLBACK_ON_POSITION_CHANGE))
    {
        window->player_handlers.on_position_change.is_enabled = FALSE;
    }

    if(!(window->player_handlers.on_position_change.is_enabled ||
         window->player_handlers.on_pos_length.is_enabled))
    {
        /* no timer required */
        return FALSE;
    }

    state = hx_player_get_content_state(player);
    if(state != HX_CONTENT_STATE_PLAYING)
    {
        /* no timer required */
        return FALSE;
    }
    
    /* call callbacks */
    pos = hx_player_get_position(player);
    len = hx_player_get_length(player);

    if(window->player_handlers.on_pos_length.is_enabled)
    {
        playeripc_on_pos_length(window, pos, len);
    }
    if(window->player_handlers.on_position_change.is_enabled)
    {
        playeripc_on_position_change(window, pos, len);
    }

    /* Keep timer callback */
    return TRUE;
}

static void
hookup_window_ipc_callbacks(HXEmbeddedWindow* window)
{
    struct
    {
        guint mask;
        gchar* name;
        GCallback callback;
        HXWindowSigInfo* siginfo;
    } window_signal_map[8];

    guint i;

    /* window signals */
    window_signal_map[0].mask     = HX_CALLBACK_ON_KEY_DOWN;
    window_signal_map[0].name     = "key_press_event";
    window_signal_map[0].callback = G_CALLBACK(playeripc_on_key_down);
    window_signal_map[0].siginfo  = &window->window_handlers.on_key_down;

    window_signal_map[1].mask     = HX_CALLBACK_ON_KEY_PRESS;
    window_signal_map[1].name     = "key_press_event";
    window_signal_map[1].callback = G_CALLBACK(playeripc_on_key_press);
    window_signal_map[1].siginfo  = &window->window_handlers.on_key_press;

    window_signal_map[2].mask     = HX_CALLBACK_ON_KEY_UP;
    window_signal_map[2].name     = "key_release_event";
    window_signal_map[2].callback = G_CALLBACK(playeripc_on_key_up);
    window_signal_map[2].siginfo  = &window->window_handlers.on_key_up;

    window_signal_map[3].mask     = HX_CALLBACK_ON_LBUTTON_DOWN;
    window_signal_map[3].name     = "button_press_event";
    window_signal_map[3].callback = G_CALLBACK(playeripc_on_lbutton_down);
    window_signal_map[3].siginfo  = &window->window_handlers.on_lbutton_down;
    
    window_signal_map[4].mask     = HX_CALLBACK_ON_LBUTTON_UP;
    window_signal_map[4].name     = "button_release_event";
    window_signal_map[4].callback = G_CALLBACK(playeripc_on_lbutton_up);
    window_signal_map[4].siginfo  = &window->window_handlers.on_lbutton_up;

    window_signal_map[5].mask     = HX_CALLBACK_ON_MOUSE_MOVE;