hxplayer.cpp

linux下的一款播放器

            XCloseDisplay(g_dpy);
            g_dpy = NULL;
        }
    }

    player->window->window = NULL;
    player->window->display = NULL;
#endif    
}

static void
hx_player_finalize(GObject* object)
{
    HXPlayerClass* klass;
    HXPlayer* player;
    klass = HX_PLAYER_GET_CLASS(object);

    player = HX_PLAYER(object);    

    g_free(player->group_title_buf);
    player->group_title_buf = NULL;

    g_free(player->title_buf);
    player->title_buf = NULL;

    g_free(player->last_opened_url_buf);
    player->last_opened_url_buf = NULL;

    g_players_list = g_list_remove(g_players_list, player);
    
    g_free(player->window);
    player->window = NULL;
}

static void
hx_player_set_property(GObject*      object,
                       guint         prop_id,
                       const GValue* value,
                       GParamSpec*   pspec)
{
    HXPlayer* player;
    
    player = HX_PLAYER(object);
    g_return_if_fail(player != NULL);
    
    switch(prop_id)
    {        
        case PROP_LOOP:
            player->loop = g_value_get_boolean(value);
            break;
            
        case PROP_LOOP_COUNT:
            player->loop_count = g_value_get_uint(value);
            break;
            
        case PROP_SHUFFLE:
            player->shuffle = g_value_get_boolean(value);
            break;

        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
            break; 
    }
}

static void
hx_player_get_property(GObject*    object,
                       guint       prop_id,
                       GValue*     value,
                       GParamSpec* pspec)
{
    HXPlayer* player;

    player = HX_PLAYER(object);
    g_return_if_fail(player != NULL);
    
    switch(prop_id)
    {        
        case PROP_LOOP_COUNT:
            g_value_set_uint(value, player->loop_count);
            break;
        
        case PROP_SHUFFLE:
            g_value_set_boolean(value, player->shuffle);
            break;

        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
            break; 
    }
}


static void
hx_player_realize(GtkWidget* widget)
{
    HXPlayer* player;
    GdkWindowAttr attributes;
    gint attributes_mask;
    
    player = HX_PLAYER(widget);

    g_return_if_fail(player != NULL);
    g_return_if_fail(HX_IS_PLAYER(player));

    // Create a window
    GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);

    attributes.x = widget->allocation.x;
    attributes.y = widget->allocation.y;
    attributes.width = widget->allocation.width;
    attributes.height = widget->allocation.height;
    attributes.wclass = GDK_INPUT_OUTPUT;
    attributes.window_type = GDK_WINDOW_CHILD;

    /* The core enables all events when it creates a window,
       so we will too. */
    attributes.event_mask = GDK_ALL_EVENTS_MASK;
    attributes.visual = gtk_widget_get_visual(widget);
    attributes.colormap = gtk_widget_get_colormap(widget);

    attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;


    widget->window = gdk_window_new(widget->parent->window, &attributes, attributes_mask);

#if defined(G_OS_UNIX)
    gdk_window_add_filter(widget->window,
                          hx_player_event_filter,
                          widget);
    
    widget->style = gtk_style_attach(widget->style, widget->window);

    gdk_window_set_user_data(widget->window, player);

    g_assert(g_dpy != NULL);    
    player->window->display = g_dpy;
    player->window->window = (void*)GDK_DRAWABLE_XID(widget->window);

#elif defined(G_OS_WIN32)
    player->window->window = (void*)GDK_WINDOW_HWND(widget->window);
#else
# error "Unsupported platform"
#endif

    gtk_widget_set_double_buffered(widget, FALSE);
}

static gboolean
hx_player_expose(GtkWidget*      widget,
                 GdkEventExpose* event)
{
    HXPlayer* player;
    
    player = HX_PLAYER(widget);
    
    g_return_val_if_fail(widget != NULL, FALSE); 
    g_return_val_if_fail(HX_IS_PLAYER(player), FALSE); 

    
    if (!hx_player_has_visual_content(player) && player->logo_pixmap)
    {
        /* Draw the logo */
        gdk_draw_drawable(widget->window,
                          widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
                          player->logo_pixmap,
                          event->area.x, event->area.y,
                          event->area.x, event->area.y,
                          event->area.width, event->area.height);
    }
    else
    {
        /* Otherwise, the expose event was passed onto
           the core by the event filter */
    }

    return FALSE; // propagate
}

static void
hx_player_size_allocate(GtkWidget*     widget,
                        GtkAllocation* allocation)
{
    HXPlayer* player;
    
    player = HX_PLAYER(widget);
    
    g_return_if_fail(widget != NULL);
    g_return_if_fail(HX_IS_PLAYER(player));
    g_return_if_fail(allocation != NULL);

    widget->allocation =* allocation;

        /* Update the HXxWindow -- used by the hxclientkit */
        player->window->width = allocation->width;
        player->window->height = allocation->height;

        ClientPlayerSetSize(player->player,
                            allocation->width,
                            allocation->height);
        

    if (GTK_WIDGET_REALIZED(widget))
    {
        player = HX_PLAYER(widget);

        gdk_window_move_resize(widget->window,
                               allocation->x, allocation->y,
                               allocation->width, allocation->height);
    }
}

static gboolean
hx_player_motion_notify_event(GtkWidget*      widget,
                              GdkEventMotion* /* event */)
{
    gint x, y;

    /* Acknowedge the motion event */
    gdk_window_get_pointer(widget->window, &x, &y, NULL);

    return FALSE;
}

/**
 * hx_player_set_logo_pixmap:
 * @player: a #HXPlayer
 * @pixmap: the pixmap to use
 *
 * Set the pixmap to be displayed in the widget's location
 * when video is not being played.
 *
 **/
void
hx_player_set_logo_pixmap(HXPlayer*  player,
                          GdkPixmap* pixmap)
{
    if(player->logo_pixmap)
    {
        g_object_unref(G_OBJECT(player->logo_pixmap));
    }

    player->logo_pixmap = pixmap;

    if(pixmap)
    {
        g_object_ref(G_OBJECT(player->logo_pixmap));
        
        gdk_drawable_get_size(GDK_DRAWABLE (pixmap),
                              &player->logo_width,
                              &player->logo_height);
    }
    else
    {
        player->logo_width = 0;
        player->logo_height = 0;
    }

    gtk_widget_queue_resize(GTK_WIDGET(player));
}

/**
 * hx_player_get_title:
 * @player: a #HXPlayer
 *
 * @returns: title of clip being played, or NULL if there
 * is no title
 *
 **/
G_CONST_RETURN gchar*
hx_player_get_title(HXPlayer* player)
{
    const char* szTitle;

    g_return_val_if_fail(player != NULL, NULL);
    
    g_free(player->title_buf);
    player->title_buf = NULL;
    
    szTitle = ClientPlayerGetTitle(player->player);

    if(szTitle)
    {
        if(g_utf8_validate(szTitle, -1, NULL))
        {
            player->title_buf = g_strdup(szTitle);
        }
        else
        {
            gsize in;
            gsize out;
        
            in = strlen(szTitle) + 1;
            out = 0;
            player->title_buf = g_convert(szTitle, in - 1, "UTF-8", "ISO-8859-1", &in, &out, NULL);
        }
    }

    return player->title_buf;
}

/**
 * hx_player_get_group_title:
 * @player: a #HXPlayer
 *
 * @returns: title of group with the given index, or NULL if there
 * is no title
 *
 **/
G_CONST_RETURN gchar*
hx_player_get_group_title(HXPlayer* player,
                          guint     group)
{
    UInt32 buf_desired = 0;
    UInt32 buf_used;
    gchar* buf;
    bool result;

    g_return_val_if_fail(player != NULL, NULL);
    g_return_val_if_fail(HX_IS_PLAYER(player), NULL);
    
    g_free(player->group_title_buf);
    player->group_title_buf = NULL;        

    /* Get the size */
    ClientPlayerGetGroupTitle(player->player, group, NULL, 0, &buf_desired);

    if(buf_desired == 0)
    {
        return NULL;
    }
    
    buf = (gchar*)g_try_malloc(buf_desired + 1);
    g_return_val_if_fail(buf, NULL);
    
    /* Get the data */
    result = ClientPlayerGetGroupTitle(player->player, group, buf, buf_desired, &buf_used);
    if(!result)
    {
        return NULL;
    }

    g_assert(buf_used == buf_desired);

    buf[buf_used] = '\0';

    if(g_utf8_validate(buf, -1, NULL))
    {
        player->group_title_buf = buf;
    }
    else
    {
        /* Convert to utf-8 */
        gsize in;
        gsize out;

        in = strlen(buf) + 1;
        out = 0;
        player->group_title_buf = g_convert(buf, in - 1, "UTF-8", "ISO-8859-1", &in, &out, NULL);

        g_free(buf);
    }
    
    return player->group_title_buf;
}

gboolean
hx_player_get_statistic(HXPlayer*    player,
                        const gchar* key,
                        GValue*      value)
{        
    UInt32 buf_used;
    UInt32 buf_desired = 0;
    int value_type;
    gint int_value;
    gchar* str_value;
    bool result = FALSE;
    gsize in;
    gsize out;
    gchar *utf8_val;

    g_return_val_if_fail(player != NULL, FALSE);
    g_return_val_if_fail(HX_IS_PLAYER(player), FALSE);
    g_return_val_if_fail(key != NULL, FALSE);
    g_return_val_if_fail(value != NULL, FALSE);

    /* Get the size */
    ClientPlayerGetStatistic(player->player, key, NULL, 0, &value_type, &buf_desired);

    if(buf_desired == 0)
    {
        return FALSE;
    }
    
    /* Get the data */
    switch(value_type)
    {
        case kValueType32BitSignedInt:
            result = ClientPlayerGetStatistic(player->player, key, (unsigned char*)&int_value, sizeof(int_value), &value_type, &buf_used);
            if(!result)
            {
                break;
            }
            g_assert(buf_used == buf_desired);
            g_value_init(value, G_TYPE_INT);
            g_value_set_int(value, int_value);
            break;
        case kValueTypeString:
            str_value = (gchar*)g_try_malloc(buf_desired + 1);
            g_return_val_if_fail(str_value != FALSE, FALSE);
            
            result = ClientPlayerGetStatistic(player->player, key, (unsigned char*)str_value, buf_desired, &value_type, &buf_used);
            if(!result)
            {
                break;
            }
            g_assert(buf_used == buf_desired);
            str_value[buf_used] = '\0';

            if(g_utf8_validate(str_value, -1, NULL))
            {
                utf8_val = str_value;
            }
            else
            {
                in = buf_used + 1;
                out = 0;
                utf8_val = g_convert(str_value, buf_used, "UTF-8", "ISO-8859-1", &in, &out, NULL);
                g_assert(utf8_val);
                g_free(str_value);
            }
            
            g_value_init(value, G_TYPE_STRING);
            g_value_set_string_take_ownership(value, utf8_val);
            break;
            
        default:
            g_assert_not_reached();
            break;
    }
    
    return result;
}

#ifdef G_OS_UNIX
static GdkFilterReturn
hx_player_event_filter(GdkXEvent* gxevent,
                       GdkEvent*  /* event */,
                       gpointer   /* widget */)
{
    ClientEngineProcessXEvent((XEvent*)gxevent);
    return GDK_FILTER_CONTINUE;
}

static gboolean
hx_player_pump(gpointer /* unused */)
{
    ClientEngineProcessXEvent(NULL);    

    /* Process any events in the display queue */
    
    if(g_dpy)
    {
        XEvent xevent;
        int x_event_available;

        memset(&xevent, 0, sizeof(xevent));
            
        do