browsertree.cpp

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

    y = (int)event->y;

    if (!gtk_clist_get_selection_info(clist, x, y, &row, &column)) {
        gdk_threads_leave();
        Event *e = new BrowserMessageEvent(" ");
        p->AcceptEvent(e);
        delete e;
        gdk_threads_enter();
        return;
    }

    GtkCTreeNode *node = GTK_CTREE_NODE(g_list_nth(clist->row_list, row));
    TreeData *data = (TreeData *)gtk_ctree_node_get_row_data(ctree, node);

    Event *e;
    if (data) {
        gdk_threads_leave();
        switch (data->type) {
            case kTreeMyMusic:
            case kTreeAll:
            case kTreeUncat:
            case kTreePlaylistHead:
            case kTreePlaylist:
            case kTreeCDHead:
            case kTreeStreamsHead:
            case kTreeFavoriteStreamsHead:
                e = new BrowserMessageEvent(data->message);
                break;
            default:
                e = new BrowserMessageEvent(" ");
                break;
        }
        p->AcceptEvent(e);
        delete e;
        gdk_threads_enter();
    }
}

static void tree_source_destroy(gpointer data)
{
}

static void tree_drag_begin(GtkWidget *w, GdkDragContext *context,
                            GTKMusicBrowser *p)
{
    GtkCTree *ctree;
    GtkCList *clist;

    g_return_if_fail(w != NULL);
    g_return_if_fail(GTK_IS_CTREE(w));
    g_return_if_fail(context != NULL);

    ctree = GTK_CTREE(w);
    clist = GTK_CLIST(w);

    GtkCTreeNode *node = GTK_CTREE_NODE(g_list_nth(clist->row_list,
                                                   clist->click_cell.row));
    if (node)
        gtk_ctree_select(ctree, node);

    void *test = g_dataset_get_data(context, "tree-drag-source");
    if (!test)
        g_dataset_set_data_full(context, "tree-drag-source", p,
                                tree_source_destroy);
}

static void tree_drag_data_get(GtkWidget *w, GdkDragContext *context,
                               GtkSelectionData *selection_data, guint info,
                               guint time, GtkWidget *widget)
{
    if (selection_data->target == gdk_atom_intern("tree-drag", FALSE)) {
        GTKMusicBrowser *p = (GTKMusicBrowser *)g_dataset_get_data(context,
                                                            "tree-drag-source");
        vector<PlaylistItem *> *newlist = p->GetTreeSelection();
        gtk_selection_data_set(selection_data, selection_data->target,
                               0, (guchar *)&newlist, sizeof(vector<PlaylistItem *>*));
    }
}

static void tree_clicked(GtkWidget *widget, GdkEventButton *event,
                         GTKMusicBrowser *p)
{
    if (!event)
        return;

    g_return_if_fail(widget != NULL);
    g_return_if_fail(GTK_IS_CTREE(widget));
    g_return_if_fail(event != NULL);

    GtkCTree *ctree = GTK_CTREE(widget);
    GtkCList *clist = GTK_CLIST(widget);

    if (event->window != clist->clist_window)
        return;

    p->SetClickState(kContextBrowser);

    if (event->type == GDK_2BUTTON_PRESS) {
        vector<PlaylistItem *> *newlist = p->GetTreeSelection();
        p->AddTracksDoubleClick(newlist);
    }
    else {
        int row, column;

        if (!gtk_clist_get_selection_info(clist, (int)event->x, (int)event->y,
                                          &row, &column)) 
            return;

        GtkCTreeNode *node = GTK_CTREE_NODE(g_list_nth(clist->row_list, row));
        TreeData *data = (TreeData *)gtk_ctree_node_get_row_data(ctree, node);
        if (!data)
            return;

        p->SetTreeClick(data->type);

        if (event->button == 3) {
            gtk_clist_unselect_all(clist);
            gtk_ctree_select(ctree, node);
            p->TreeRightClick((int)event->x_root, (int)event->y_root,
                              event->time);
        }
    }
}

static void ctree_selected(GtkCTree *ctree, GtkCTreeNode *node, gint col,
                          GTKMusicBrowser *p)
{
    TreeData *data = (TreeData *)gtk_ctree_node_get_row_data(ctree, node);
    if (!data)
        return;

    bool found = false;
    vector<TreeData *>::iterator i = p->mbSelections->begin();
    for (; i != p->mbSelections->end(); i++) {
        if (*i == data) {
            found = true;
            break;
        }
    }

    if (!found)
        p->mbSelections->push_back(data);
}

static void ctree_unselected(GtkCTree *ctree, GtkCTreeNode *node, gint col,
                            GTKMusicBrowser *p)
{
    TreeData *data = (TreeData *)gtk_ctree_node_get_row_data(ctree, node);
    if (!data)
        return;

    vector<TreeData *>::iterator i = p->mbSelections->begin();
    for (; i != p->mbSelections->end(); i++) {
        if (*i == data) {
            p->mbSelections->erase(i);
            break;
        }
    }
}

void GTKMusicBrowser::stream_timer_func(void *arg)
{
    GTKMusicBrowser *ui = (GTKMusicBrowser*)arg;
    ui->StreamTimer();
}

void GTKMusicBrowser::StreamTimer(void)
{
#ifndef __QNX__
    Error  eRet;
    Http   streamDownload(m_context);
    string page;
    vector<FreeAmpStreamInfo> list;
    FreeAmpStreams            o;

    m_context->timerManager->SetTimer(stream_timer, 30);

    eRet = streamDownload.DownloadToString(streamURL, page);
    if (eRet != kError_NoErr) {
        cout << "Stream .xml download failed: " << ErrorString[eRet] << "\n";
        return;
    }

    eRet = o.ParseStreamXML(page, list);
   
    if (eRet != kError_NoErr) {
        string err;
        o.GetErrorString(err);
        cout << "Stream .xml parse error: " << err << "\n";
        return;
    }

    if (list.size() > 0) 
        HandleStreamList(list);
    else
       cout << "no streams.\n";
#endif
}

void GTKMusicBrowser::HandleStreamList(vector<FreeAmpStreamInfo> &list)
{
    gdk_threads_enter();
    gtk_clist_freeze(GTK_CLIST(musicBrowserTree));

    GtkCTreeRow *row = GTK_CTREE_ROW(streamTree);
    int expanded = row->expanded;
    GtkCTreeNode *sib = row->children;
    sib = GTK_CTREE_ROW(sib)->sibling;

    GtkCTreeNode *todelete = GTK_CTREE_ROW(sib)->sibling;

    while (todelete) {
        gtk_ctree_remove_node(musicBrowserTree, todelete);
        todelete = GTK_CTREE_ROW(sib)->sibling;
    }
    streamSpace = NULL;
   
    char *name[1];
    TreeData  *data;
    GtkCTreeNode *stream;

    vector<FreeAmpStreamInfo>::iterator i;

    for (i = list.begin(); i != list.end(); i++) {
        PlaylistItem *newitem = new PlaylistItem;
        MetaData metadata;

        newitem->SetURL(i->m_streamUrl);
        newitem->SetWebURL(i->m_webUrl);
        metadata.SetTitle(i->m_name);
        metadata.SetArtist(i->m_webUrl);
        metadata.SetComment(i->m_desc);
        newitem->SetMetaData(&metadata);

        char *tempname = new char[i->m_name.size() + 128];
        if (i->m_numUsers < 0)
            sprintf(tempname, "%s (%.2fkBps)", i->m_name.c_str(), 
                    (double)i->m_bitrate / 1000.0);
        else
            sprintf(tempname, "%s (%.2fkBps / %d out of %d listeners)",
                    i->m_name.c_str(), (double)i->m_bitrate / 1000.0, 
                    i->m_numUsers, i->m_maxUsers);
        name[0] = tempname;

        GtkCTreeNode *parent = StreamGetParentNode(i->m_treePath);

        stream = gtk_ctree_insert_node(musicBrowserTree, parent, NULL,
                                        name, 5, stream_pmap, stream_mask, 
                                        stream_pmap, stream_mask,
                                        true, false);
        data = NewTreeData(kTreeStream, NULL, NULL, NULL, newitem);
        gtk_ctree_node_set_row_data_full(musicBrowserTree, stream, data,
                                         (GtkDestroyNotify)kill_treedata);

        delete [] tempname;
    }
    gtk_clist_thaw(GTK_CLIST(musicBrowserTree));

    if (expanded)
        gtk_ctree_expand(musicBrowserTree, streamTree);

    gdk_threads_leave();
}

GtkCTreeNode *GTKMusicBrowser::StreamGetParentNode(string &treePath)
{
    GtkCTreeNode *parent = streamTree;
    char      *fullpath = strdup_new(treePath.c_str());
    char      *slash, *nextslash = NULL, *name[1]; 
    GdkPixmap *pixmap;
    GdkBitmap *mask;
    GtkStyle  *style = gtk_widget_get_style(musicBrowserWindow);
    TreeData  *data;

    slash = strchr(fullpath, '/');

    while (slash) {
        *slash = '\0';
        slash++;
        if (slash) {
            nextslash = strchr(slash, '/');
            if (nextslash)
                *nextslash = '\0';

            GtkCTreeNode *sib = GTK_CTREE_ROW(parent)->children;
            bool found = false;            

            while (sib) {   
                GtkCListRow *row = (GtkCListRow *)GTK_CTREE_ROW(sib);
                char *sibtext = GTK_CELL_PIXTEXT(row->cell[0])->text;
                if (!strcasecmp(slash, sibtext)) {
                    found = true;
                    parent = sib;
                    break;
                }
                sib = GTK_CTREE_ROW(sib)->sibling;
            }
            
            if (!found) {
                name[0] = slash;
                pixmap = gdk_pixmap_create_from_xpm_d(
                                              musicBrowserWindow->window,
                                              &mask,
                                              &style->bg[GTK_STATE_NORMAL],
                                              favorites_pix);
                parent = gtk_ctree_insert_node(musicBrowserTree, parent,
                                               NULL, name, 5, pixmap, mask,
                                               pixmap, mask, false, false);
                data = NewTreeData(kTreeStreamFolder);
                gtk_ctree_node_set_row_data_full(musicBrowserTree, parent, data,
                                         (GtkDestroyNotify)kill_treedata);

            }
                                                      
            slash = nextslash;
        }
    }
   
    delete [] fullpath;

    return parent;
}
    
void GTKMusicBrowser::FillStreams(void)
{
    GdkCursor *cursor;
    
    if (streamExpanded)
        return;

    cursor = gdk_cursor_new (GDK_WATCH);
    gdk_window_set_cursor (musicBrowserWindow->window, cursor);
    gdk_cursor_destroy (cursor);

    gdk_threads_leave();
    Event *e = new BrowserMessageEvent("Downloading streams information...");
    AcceptEvent(e);
    delete e;
    StreamTimer();
    e = new BrowserMessageEvent("Downloaded stream information.");
    AcceptEvent(e);
    delete e;
    gdk_threads_enter();

    gdk_window_set_cursor (musicBrowserWindow->window, NULL);

    //if (!stream_timer_started)