embeddedapp.cpp

linux下的一款播放器

    window_signal_map[5].name     = "motion_notify_event";
    window_signal_map[5].callback = G_CALLBACK(playeripc_on_mouse_move);
    window_signal_map[5].siginfo  = &window->window_handlers.on_mouse_move;
    
    window_signal_map[6].mask     = HX_CALLBACK_ON_RBUTTON_DOWN;
    window_signal_map[6].name     = "button_press_event";
    window_signal_map[6].callback = G_CALLBACK(playeripc_on_rbutton_down);
    window_signal_map[6].siginfo  = &window->window_handlers.on_rbutton_down;
    
    window_signal_map[7].mask     = HX_CALLBACK_ON_RBUTTON_UP;
    window_signal_map[7].name     = "button_release_event";
    window_signal_map[7].callback = G_CALLBACK(playeripc_on_rbutton_up);
    window_signal_map[7].siginfo  = &window->window_handlers.on_rbutton_up;

    g_assert((sizeof(window_signal_map) / sizeof(*window_signal_map)) == 8);

    for(i = 0; i < sizeof(window_signal_map) / sizeof(*window_signal_map); i++)
    {
        if((window_signal_map[i].mask & window->attr.scriptcallbacks) &&
           !window_signal_map[i].siginfo->is_enabled && window->window)
        {
            /* Add callback */
            if(window_signal_map[0].callback)
            {
                if(!window_signal_map[i].siginfo->is_enabled)
                {
                    window_signal_map[i].siginfo->id =
                        g_signal_connect_swapped(G_OBJECT(window->window),
                                                 window_signal_map[i].name,
                                                 G_CALLBACK(window_signal_map[i].callback),
                                                 window);
                    
                    window_signal_map[i].siginfo->is_enabled = TRUE;
                }
            }
            else
            {
                g_warning("Unimplemented callback requested! (mask=0x%08x)\n",
                          window_signal_map[i].mask);
            }
        }

        if(!(window_signal_map[i].mask & window->attr.scriptcallbacks) &&
           window_signal_map[i].siginfo->is_enabled)
        {
            /* Remove callback */
            if(window->window)
            {
                g_signal_handler_disconnect(G_OBJECT(window->window),
                                            window_signal_map[i].siginfo->id);
            }
            
            window_signal_map[i].siginfo->id = 0;
            window_signal_map[i].siginfo->is_enabled = FALSE;
        }
    }    
}

static void
hookup_player_ipc_callbacks(HXEmbeddedWindow* window, HXPlayer* player)
{
    struct
    {
        guint mask;
        HXPlayerCallbackInfo* cbinfo;
    } player_callback_map[6];

    struct
    {
        guint mask;
        gchar* name;
        GCallback callback;
        GObject* target;
        HXPlayerSigInfo* siginfo;
    } player_signal_map[13];    

    /* player signals */    
    guint i;
    HXPlayerSigInfo* siginfo;

    GObject* player_target = NULL;
    GObject* title_observer_target = NULL;
    GObject* author_observer_target = NULL;
    GObject* copyright_observer_target = NULL;    

    g_return_if_fail(player);
    g_return_if_fail(window->title_observer);
    g_return_if_fail(window->author_observer);
    g_return_if_fail(window->copyright_observer);
    
    player_target             = G_OBJECT(player);
    title_observer_target     = G_OBJECT(window->title_observer);
    author_observer_target    = G_OBJECT(window->author_observer);
    copyright_observer_target = G_OBJECT(window->copyright_observer);
    
    player_signal_map[0].mask = HX_CALLBACK_ON_BUFFERING;
    player_signal_map[0].name = "buffering";
    player_signal_map[0].callback = G_CALLBACK(playeripc_on_buffering);
    player_signal_map[0].target = player_target;
    player_signal_map[0].siginfo = &window->player_handlers.on_buffering;

    player_signal_map[1].mask = HX_CALLBACK_ON_CONTACTING;
    player_signal_map[1].name = "contacting";
    player_signal_map[1].callback = G_CALLBACK(playeripc_on_contacting);
    player_signal_map[1].target = player_target;
    player_signal_map[1].siginfo = &window->player_handlers.on_contacting;

    player_signal_map[2].mask = HX_CALLBACK_ON_ERROR_MESSAGE;
    player_signal_map[2].name = "hxerror";
    player_signal_map[2].callback = G_CALLBACK(playeripc_on_error_message);
    player_signal_map[2].target = player_target;
    player_signal_map[2].siginfo = &window->player_handlers.on_error_message;

    player_signal_map[3].mask = HX_CALLBACK_ON_GOTO_URL;
    player_signal_map[3].name = "goto_url";
    player_signal_map[3].callback = G_CALLBACK(playeripc_on_goto_url);
    player_signal_map[3].target = player_target;
    player_signal_map[3].siginfo = &window->player_handlers.on_goto_url;

    player_signal_map[4].mask = HX_CALLBACK_ON_MUTE_CHANGE;
    player_signal_map[4].name = "mute_changed";
    player_signal_map[4].callback = G_CALLBACK(playeripc_on_mute_change);
    player_signal_map[4].target = player_target;
    player_signal_map[4].siginfo = &window->player_handlers.on_mute_change;

    player_signal_map[5].mask = HX_CALLBACK_ON_PLAY_STATE_CHANGE;
    player_signal_map[5].name = "content_state_changed";
    player_signal_map[5].callback = G_CALLBACK(playeripc_on_play_state_change);
    player_signal_map[5].target = player_target;
    player_signal_map[5].siginfo = &window->player_handlers.on_play_state_change;

    player_signal_map[6].mask = HX_CALLBACK_ON_STATE_CHANGE;
    player_signal_map[6].name = "content_state_changed";
    player_signal_map[6].callback = G_CALLBACK(playeripc_on_state_change);
    player_signal_map[6].target = player_target;
    player_signal_map[6].siginfo = &window->player_handlers.on_state_change;
        
    player_signal_map[7].mask = HX_CALLBACK_ON_VOLUME_CHANGE;
    player_signal_map[7].name = "volume_changed";
    player_signal_map[7].callback = G_CALLBACK(playeripc_on_volume_change);
    player_signal_map[7].target = player_target;
    player_signal_map[7].siginfo = &window->player_handlers.on_volume_change;

    player_signal_map[8].mask = HX_CALLBACK_ON_SHOW_STATUS;
    player_signal_map[8].name = "status_changed";
    player_signal_map[8].callback = G_CALLBACK(playeripc_on_show_status);
    player_signal_map[8].target = player_target;
    player_signal_map[8].siginfo = &window->player_handlers.on_show_status;

    player_signal_map[9].mask = HX_CALLBACK_ON_PREFETCH_COMPLETE;
    player_signal_map[9].name = "buffering";
    player_signal_map[9].callback = G_CALLBACK(playeripc_on_prefetch_complete);
    player_signal_map[9].target = player_target;
    player_signal_map[9].siginfo = &window->player_handlers.on_prefetch_complete;

    player_signal_map[10].mask = HX_CALLBACK_ON_TITLE_CHANGE;
    player_signal_map[10].name = "statistic_modified";
    player_signal_map[10].callback = G_CALLBACK(playeripc_on_title_change);
    player_signal_map[10].target = title_observer_target;
    player_signal_map[10].siginfo = &window->player_handlers.on_title_change;

    player_signal_map[11].mask = HX_CALLBACK_ON_AUTHOR_CHANGE;
    player_signal_map[11].name = "statistic_modified";
    player_signal_map[11].callback = G_CALLBACK(playeripc_on_author_change);
    player_signal_map[11].target = author_observer_target;
    player_signal_map[11].siginfo = &window->player_handlers.on_author_change;

    player_signal_map[12].mask = HX_CALLBACK_ON_COPYRIGHT_CHANGE;
    player_signal_map[12].name = "statistic_modified";
    player_signal_map[12].callback = G_CALLBACK(playeripc_on_copyright_change);
    player_signal_map[12].target = copyright_observer_target;
    player_signal_map[12].siginfo = &window->player_handlers.on_copyright_change;

    g_assert((sizeof(player_signal_map) / sizeof(*player_signal_map)) == 13);
    
    for(i = 0; i < sizeof(player_signal_map) / sizeof(*player_signal_map); i++)
    {
        if((player_signal_map[i].mask & window->attr.scriptcallbacks) &&
            !player_signal_map[i].siginfo->is_enabled && window->window)
        {
            /* Add callbacks */
            if(player_signal_map[i].callback)
            {
                if(!player_signal_map[i].siginfo->is_enabled)
                {
                    g_assert(player_signal_map[i].target != NULL);

                    siginfo = player_signal_map[i].siginfo;                    
                    siginfo->id =
                        g_signal_connect_swapped(G_OBJECT(player_signal_map[i].target),
                                                 player_signal_map[i].name,
                                                 G_CALLBACK(player_signal_map[i].callback),
                                                 window);

                    siginfo->target = player_signal_map[i].target;
                    player_signal_map[i].siginfo->is_enabled = TRUE;
                }
            }
            else
            {
                g_warning("Unimplemented callback requested! (mask=0x%08x)\n",
                          player_signal_map[i].mask);
            }
        }
        else if(!(player_signal_map[i].mask & window->attr.scriptcallbacks) &&
                player_signal_map[i].siginfo->is_enabled)
        {
            /* Remove callbacks */
            siginfo = player_signal_map[i].siginfo;
            g_signal_handler_disconnect(G_OBJECT(siginfo->target),
                                        siginfo->id);

            siginfo->target = NULL;
            siginfo->id = 0;
            siginfo->is_enabled = FALSE;
        }        
    }            

    /* OnPosLength and OnPositionChanged are a special case, as we need
       to create a polling timer for them. */
    gboolean start_pos_length_timer = FALSE;

    if(window->attr.scriptcallbacks & HX_CALLBACK_ON_POS_LENGTH)
    {
        window->player_handlers.on_pos_length.is_enabled = TRUE;
        start_pos_length_timer = TRUE;
    }
    else
    {
        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 = TRUE;
        start_pos_length_timer = TRUE;
    }
    else
    {
        window->player_handlers.on_position_change.is_enabled = FALSE;
    }

    if(start_pos_length_timer && !window->pos_len_callback_timer_is_running)
    {
        HXContentStateType state;
        
        state = hx_player_get_content_state(player);
        if(state == HX_CONTENT_STATE_PLAYING)
        {
            /* We're playing and want a timer, and one does not already
               exist. Start one. */
            gtk_timeout_add(POS_LEN_CALLBACK_INTERVAL,
                            hxembedded_window_call_pos_len_callbacks,
                            window);
            
            window->pos_len_callback_timer_is_running = TRUE;
        }
    }

    /* other player callbacks (non-signal based) */    
    player_callback_map[0].mask = HX_CALLBACK_ON_CLIP_CLOSED;
    player_callback_map[0].cbinfo = &window->player_handlers.on_clip_closed;

    player_callback_map[1].mask = HX_CALLBACK_ON_CLIP_OPENED;
    player_callback_map[1].cbinfo = &window->player_handlers.on_clip_opened;

    player_callback_map[2].mask = HX_CALLBACK_ON_POST_SEEK;
    player_callback_map[2].cbinfo = &window->player_handlers.on_post_seek;

    player_callback_map[3].mask = HX_CALLBACK_ON_PRE_SEEK;
    player_callback_map[3].cbinfo = &window->player_handlers.on_pre_seek;

    player_callback_map[4].mask = HX_CALLBACK_ON_PRESENTATION_CLOSED;
    player_callback_map[4].cbinfo = &window->player_handlers.on_presentation_closed;

    player_callback_map[5].mask = HX_CALLBACK_ON_PRESENTATION_OPENED;
    player_callback_map[5].cbinfo = &window->player_handlers.on_presentation_opened;

    g_assert((sizeof(player_callback_map) / sizeof(*player_callback_map)) == 6);
    
    for(i = 0; i < sizeof(player_callback_map) / sizeof(*player_callback_map); i++)
    {
        if(player_callback_map[i].mask & window->attr.scriptcallbacks)
        {
            /* Add callbacks */
            player_callback_map[i].cbinfo->is_enabled = TRUE;
        }
        else
        {
            player_callback_map[i].cbinfo->is_enabled = FALSE;
        }        
    }

}

void
hxembedded_window_hookup_ipc_callbacks(HXEmbeddedWindow* window)
{
    HXPlayer* player;
    
    hookup_window_ipc_callbacks(window);

    player = hxembedded_window_get_player_no_create(window);

    if(player &&
       window->title_observer  &&
       window->author_observer &&
       window->copyright_observer)
    {
        hookup_player_ipc_callbacks(window, player);
    }
}

GdkWindow*
hxembedded_window_get_browser_window(HXEmbeddedWindow* window)
{
    GdkWindow* browser_window = NULL;
    GdkWindow* win_iter;
    GdkAtom net_wm_window_type, net_wm_window_type_normal;
    gint i;
    gboolean result;
    
    net_wm_window_type = gdk_atom_intern("_NET_WM_WINDOW_TYPE", FALSE);
    net_wm_window_type_normal = gdk_atom_intern("_NET_WM_WINDOW_TYPE_NORMAL", FALSE);

    win_iter = window->window->window;

    while(win_iter && !browser_window)
    {        
        GdkAtom type;
        gint format;
        gint length;
        GdkAtom* atoms = NULL;
        GdkWindow* next = NULL;

        XID xid = GDK_WINDOW_XID(win_iter);
        
        result = gdk_property_get(win_iter,
                                  net_wm_window_type,
                                  0,
                                  0,
                                  G_MAXLONG - 3,
                                  FALSE,
                                  &type,
                                  &format,
                                  &length,
                                  (guchar**)&atoms);
        if(result)
        {
            for(i = 0; i < length; i++)
            {
                if(atoms[i] == net_wm_window_type_normal)
                {
                    browser_window = win_iter;
                }
            }
        }

        g_free(atoms);
        
        if(!browser_window)
        {

            // This is not returning the parent correctly, even after calling
            // gdk_window_foreign_new . Use the X api instead.

            // parent = gdk_window_get_parent(win_iter);

            Window root, parent;
            Window *children = NULL;
            guint nchildren;

            result = XQueryTree (GDK_DISPLAY(), xid, &root, &parent, &children, &nchildren);
            if(result)
            {
                if(children)
                {
                    XFree (children);
                }

                next = gdk_window_foreign_new(parent);
            }

            g_object_unref(win_iter);
        }

        win_iter = next;
    }

    return browser_window;
}

void
hubd_show_unsupported_browser_warning_dialog_closed(HXUnsupportedBrowserDialog* info)
{
    gboolean show_warning_in_future;
    GIOStatus status;
        
    g_return_if_fail(info != NULL);

    show_warning_in_future = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(info->show_warning_in_future_checkbox));

    if(!show_warning_in_future)
    {
        // HACK! The embedded player currently can't write preferences.