browsertree.cpp

FreeAMP(MP3播放)程序源代码-用来研究MP3解码

    //    m_context->timerManager->StartTimer(&stream_timer, stream_timer_func, 
    //                                        1, this);
    stream_timer_started = true;
    streamExpanded = true;
}

void GTKMusicBrowser::FillRelatable(bool force)
{
    if (relatableExpanded && !force)
        return;

    StreamList listoStreams;
    m_context->aps->APSGetStreams(&listoStreams);

    if (relatableSpace)
        gtk_ctree_remove_node(musicBrowserTree, relatableSpace);
    relatableSpace = NULL;

    GtkCTreeRow *row = GTK_CTREE_ROW(relatableTree);
    int expanded = row->expanded;

    if (force) {
        GtkCTreeNode *todelete = row->children;

        while (todelete) {
            gtk_ctree_remove_node(musicBrowserTree, todelete);
            todelete = row->children;
        }
    }

    relatableExpanded = true;

    char *name[1];
    GdkPixmap *pixmap;
    GdkBitmap *mask;
    GtkStyle *style = gtk_widget_get_style(musicBrowserWindow);
    TreeData *data;
    GtkCTreeNode *stream;
    
    gtk_clist_freeze(GTK_CLIST(musicBrowserTree));

    StreamList::iterator i = listoStreams.begin();
    for (; i != listoStreams.end(); i++) {
        PlaylistItem *newitem = new PlaylistItem;
        MetaData metadata;

        newitem->SetURL((*i).second);
        metadata.SetTitle((*i).first);
        newitem->SetMetaData(&metadata);

        name[0] = (char *)((*i).first.c_str());

        pixmap = gdk_pixmap_create_from_xpm_d(musicBrowserWindow->window, &mask,
                                              &style->bg[GTK_STATE_NORMAL],
                                              streams_pix);
        stream = gtk_ctree_insert_node(musicBrowserTree, relatableTree, NULL,
                                       name, 5, pixmap, mask, pixmap, mask,
                                       true, false);
        data = NewTreeData(kTreeStream, NULL, NULL, NULL, newitem);
        gtk_ctree_node_set_row_data_full(musicBrowserTree, stream, data,
                                         (GtkDestroyNotify)kill_treedata);
    }
    if (expanded)
        gtk_ctree_expand(musicBrowserTree, relatableTree);

    gtk_clist_thaw(GTK_CLIST(musicBrowserTree));
}

void GTKMusicBrowser::CloseStreams(void)
{
    if (!streamExpanded)
        return;

    //streamExpanded = false;
}

static void ctree_expand(GtkWidget *widget, GList *list, GTKMusicBrowser *p)
{
    GtkCTree *ctree = GTK_CTREE(widget);

    GtkCTreeNode *node = (GtkCTreeNode *)list;
    TreeData *data = (TreeData *)gtk_ctree_node_get_row_data(ctree, node);

    if (data) {
        switch (data->type) {
            case kTreeStreamsHead: {
                p->FillStreams();
                break; }
            case kTreeRelatableHead: {
                p->FillRelatable();
                break; }
            default:
                break;
        }
    }
}

static void ctree_collapse(GtkWidget *widget, GList *list, GTKMusicBrowser *p)
{
    GtkCTree *ctree = GTK_CTREE(widget);

    GtkCTreeNode *node = (GtkCTreeNode *)list;
    TreeData *data = (TreeData *)gtk_ctree_node_get_row_data(ctree, node);

    if (data) {
        switch (data->type) {
            case kTreeStreamsHead: {
                p->CloseStreams();
                break; }
            default:
                break;
        }
    }
}

void GTKMusicBrowser::TreeRightClick(int x, int y, uint32 time)
{
    GtkItemFactory *itemfact = NULL;

    switch ((*(mbSelections->begin()))->type) {
        case kTreeCD:
        case kTreeCDHead:
            itemfact = cdPopup;
            break;
        case kTreeStream:
            itemfact = streamPopup;
            break;
        case kTreeFavStream:
            itemfact = favPopup;
            break;
        case kTreeTrack:
	case kTreeArtist:
	case kTreeAlbum:
            itemfact = trackPopup;
            break;
        case kTreePlaylist:
            itemfact = playlistCatPopup;
            break;
        case kTreeMyMusic:
        case kTreeAll:
        case kTreeUncat:
            itemfact = otherPopup;
            break;
        case kTreeStreamsHead:
        case kTreeFavoriteStreamsHead:
            itemfact = genstreamPopup;
            break;
        case kTreeRelatableHead:
            itemfact = relatablePopup;
        default:
            break;
    }

    if (!itemfact)
        return;

    gtk_item_factory_popup(itemfact, x, y, 3, time);
}

static void refresh_pop(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    p->FillRelatable(true);
}

static void add_pop(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    vector<PlaylistItem *> *newlist = p->GetTreeSelection();
    p->AddTracksPlaylistEvent(newlist, true, false, true);
}

static void add_play_pop(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    vector<PlaylistItem *> *newlist = p->GetTreeSelection();
    p->AddTracksPlaylistEvent(newlist, true, true, false);
}

static void remove_pop(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    p->DeleteEvent();
}
    
static void add_stream_pop(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    p->AddNewStream();
}

static void update_stream(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    gdk_threads_leave();
    p->StreamTimer();
    gdk_threads_enter();
}

static void add_fav_pop(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    p->AddStreamToFavs();
}

static void visit_website_pop(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    p->VisitWebsite();
}

static void eject_cd_pop(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    p->EjectCD();
}

static void edit_info_pop(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    p->PopUpInfoEditor();
}

static void update_cd_pop(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    p->UpdateCD();
}

void GTKMusicBrowser::CreateTreePopups(void)
{
    GtkItemFactoryEntry relatable_items[] = {
     {"/Refresh Recommendations", NULL, (GtkItemFactoryCallback)refresh_pop, 0, 0}
    };
    int nrstream_items = sizeof(relatable_items) / sizeof(relatable_items[0]);

    relatablePopup = gtk_item_factory_new(GTK_TYPE_MENU, "<relatable_popup>",
                                          NULL);
    gtk_item_factory_create_items(relatablePopup, nrstream_items,
                                  relatable_items, (void*)this);

    GtkItemFactoryEntry genstream_items[] = {
     {"/Add New Stream", NULL,    (GtkItemFactoryCallback)add_stream_pop, 0, 0},
     {"/Update Streams", NULL,    (GtkItemFactoryCallback)update_stream,  0, 0}
    };
    int ngenstream_items = sizeof(genstream_items) / sizeof(genstream_items[0]);

    genstreamPopup = gtk_item_factory_new(GTK_TYPE_MENU, "<genstream_popup>",
                                          NULL);
    gtk_item_factory_create_items(genstreamPopup, ngenstream_items, 
                                  genstream_items, (void*)this);

    GtkItemFactoryEntry stream_items[] = {
     {"/Add to Playlist",NULL,    (GtkItemFactoryCallback)add_pop,       0, 0 },
     {"/Add and Play Now",NULL,   (GtkItemFactoryCallback)add_play_pop,  0, 0 },
     {"/sep1",         NULL,      0,                        0, "<Separator>" },
     {"/Add To Favorites", NULL,  (GtkItemFactoryCallback)add_fav_pop,   0, 0 },
     {"/Visit Website", NULL,     (GtkItemFactoryCallback)visit_website_pop,0, 0 }
    };
    int nstream_items = sizeof(stream_items) / sizeof(stream_items[0]);

    streamPopup = gtk_item_factory_new(GTK_TYPE_MENU, "<stream_popup>",
                                       NULL);
    gtk_item_factory_create_items(streamPopup, nstream_items, stream_items,
                                  (void*)this);

    GtkItemFactoryEntry fav_items[] = {
     {"/Add to Playlist",NULL,    (GtkItemFactoryCallback)add_pop,       0, 0 },
     {"/Add and Play Now",NULL,   (GtkItemFactoryCallback)add_play_pop,  0, 0 },
     {"/sep1",         NULL,      0,                        0, "<Separator>" },
     {"/Remove",       NULL,      (GtkItemFactoryCallback)remove_pop,    0, 0 }
    };
    int nfav_items = sizeof(fav_items) / sizeof(fav_items[0]);
    
    favPopup = gtk_item_factory_new(GTK_TYPE_MENU, "<fav_popup>", NULL);
    gtk_item_factory_create_items(favPopup, nfav_items, fav_items, (void*)this);

    GtkItemFactoryEntry cd_items[] = {
     {"/Add to Playlist",NULL,  (GtkItemFactoryCallback)add_pop,  0, 0 },
     {"/Add and Play Now",NULL, (GtkItemFactoryCallback)add_play_pop,   0, 0 },
     {"/sep1",         NULL,    0,                        0, "<Separator>" },
     {"/Eject CD",     NULL,    (GtkItemFactoryCallback)eject_cd_pop,0, 0 },
     {"/sep2",         NULL,    0,                        0, "<Separator>" },
     {"/Update CD Info", NULL,  (GtkItemFactoryCallback)update_cd_pop, 0, 0 }
    };
    int ncd_items = sizeof(cd_items) / sizeof(cd_items[0]);

    cdPopup = gtk_item_factory_new(GTK_TYPE_MENU, "<cd_popup>", NULL);
    gtk_item_factory_create_items(cdPopup, ncd_items, cd_items, (void*)this);

    GtkItemFactoryEntry plist_items[] = {
     {"/Add to Playlist",NULL,  (GtkItemFactoryCallback)add_pop,  0, 0 },
     {"/Add and Play Now",NULL, (GtkItemFactoryCallback)add_play_pop,   0, 0 },
     {"/sep1",         NULL,    0,                        0, "<Separator>" },
     {"/Remove",       NULL,    (GtkItemFactoryCallback)remove_pop,     0, 0 },
     {"/sep2",         NULL,    0,                        0, "<Separator>" },
     {"/Edit",         NULL,    (GtkItemFactoryCallback)edit_info_pop,0, 0 }
    };
    int nplist_items = sizeof(plist_items) / sizeof(plist_items[0]);

    playlistCatPopup = gtk_item_factory_new(GTK_TYPE_MENU, "<plist_popup>", 
                                            NULL);
    gtk_item_factory_create_items(playlistCatPopup, nplist_items, plist_items, 
                                  (void*)this);
    
    GtkItemFactoryEntry track_items[] = {
     {"/Add to Playlist",NULL,  (GtkItemFactoryCallback)add_pop,  0, 0 },
     {"/Add and Play Now",NULL, (GtkItemFactoryCallback)add_play_pop,   0, 0 },
     {"/sep1",         NULL,    0,                        0, "<Separator>" },
     {"/Remove",       NULL,    (GtkItemFactoryCallback)remove_pop,     0, 0 },
     {"/sep2",         NULL,    0,                        0, "<Separator>" },
     {"/Edit Info", NULL,       (GtkItemFactoryCallback)edit_info_pop,0, 0 }
    };
    int ntrack_items = sizeof(track_items) / sizeof(track_items[0]);

    trackPopup = gtk_item_factory_new(GTK_TYPE_MENU, "<track_popup>", 
                                            NULL);
    gtk_item_factory_create_items(trackPopup, ntrack_items, track_items, 
                                  (void*)this);

    GtkItemFactoryEntry other_items[] = {
     {"/Add to Playlist",NULL,  (GtkItemFactoryCallback)add_pop,  0, 0 },
     {"/Add and Play Now",NULL, (GtkItemFactoryCallback)add_play_pop,   0, 0 },
    };
    int nother_items = sizeof(other_items) / sizeof(other_items[0]);

    otherPopup = gtk_item_factory_new(GTK_TYPE_MENU, "<other_popup>",      
                                            NULL);
    gtk_item_factory_create_items(otherPopup, nother_items, other_items,      
                                  (void*)this);
}

void GTKMusicBrowser::CreateTree(void)
{
    GtkTargetEntry tree_target_table = {"tree-drag", 0, 1};

    musicBrowserTree = GTK_CTREE(gtk_ctree_new(1, 0));
    gtk_widget_add_events(GTK_WIDGET(musicBrowserTree),
                          GDK_POINTER_MOTION_MASK | GDK_LEAVE_NOTIFY_MASK);
    gtk_container_add(GTK_CONTAINER(musicBrowserWindow),
                      GTK_WIDGET(musicBrowserTree));
    gtk_signal_connect_after(GTK_OBJECT(musicBrowserTree), "button_press_event",
                             GTK_SIGNAL_FUNC(tree_clicked), this);
    gtk_signal_connect(GTK_OBJECT(musicBrowserTree),"motion_notify_event",
                       GTK_SIGNAL_FUNC(tree_status), this);
    gtk_signal_connect(GTK_OBJECT(musicBrowserTree), "leave_notify_event",
                       GTK_SIGNAL_FUNC(tree_status_clear), this);
    gtk_drag_source_set(GTK_WIDGET(musicBrowserTree), GDK_BUTTON1_MASK,
                        &tree_target_table, 1, GDK_ACTION_MOVE);
    gtk_signal_connect(GTK_OBJECT(musicBrowserTree), "drag_data_get",
                       GTK_SIGNAL_FUNC(tree_drag_data_get), this);
    gtk_signal_connect(GTK_OBJECT(musicBrowserTree), "drag_begin",
                       GTK_SIGNAL_FUNC(tree_drag_begin), this);
    gtk_signal_connect(GTK_OBJECT(musicBrowser