browserlist.cpp

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

        playlistCols[column] = newcol;
        token = strtok(NULL, "|");
        column++;
    }
    for (; column < 9; column++) 
        playlistCols[column] = kEmptyColumn;
}

void GTKMusicBrowser::UpdateColumnHeaders(void)
{
    gtk_clist_column_titles_show(GTK_CLIST(playlistList));

    for (int column = 0; column < 9; column++) 
    {
        string title;
        bool visible = true;

        switch (playlistCols[column]) 
        {
            case kArtistColumn:
                title = "Artist";
                break;
            case kAlbumColumn:
                title = "Album";
                break;
            case kCommentColumn:
                title = "Comment";
                break;
            case kGenreColumn:
                title = "Genre";
                break;
            case kLocationColumn:
                title = "Location";
                break;
            case kPositionColumn:
                title = "#";
                break;
            case kTitleColumn:
                title = "Title";
                break;
            case kTimeColumn:
                title = "Length"; 
                break;
            case kYearColumn:
                title = "Year";
                break;
            default:
                title = " ";
                visible = false;
                break;
        }
        gtk_clist_set_column_title(GTK_CLIST(playlistList), column, 
                                   title.c_str());
        gtk_clist_set_column_visibility(GTK_CLIST(playlistList), column, 
                                        visible);
    }
} 

void GTKMusicBrowser::UpdatePlaylistList(void)
{
    if (!playlistList || !m_plm)
        return;

    ParsePlaylistCols();

    gtk_clist_freeze(GTK_CLIST(playlistList));
    gtk_clist_clear(GTK_CLIST(playlistList));

    if (playlistColsChanged)
        UpdateColumnHeaders();

    uint32 iLoop = m_plm->CountItems();

    int32 totaltime = 0;
    int32 maxCDtime = 0;
    m_context->prefs->GetPrefInt32(kAudioCDLengthPref, &maxCDtime);

    int row = 0;

    for (uint32 i = 0; i < iLoop; i++) {
        PlaylistItem *item = m_plm->ItemAt(i);

        if (!item)
            continue;

        MetaData mdata = item->GetMetaData();
        char *iText[9];
        char position[40];
        char *title;
        char *artist;
        char *album;
        char *genre;
        char location[_MAX_PATH];
        uint32 loclength = _MAX_PATH;
        char *comment;
        char length[50];
        char year[10];
        string empty = " ";

        sprintf(position, "%d", i + 1);
        title = (char *)mdata.Title().c_str();
        artist = (char *)mdata.Artist().c_str();
        album = (char *)mdata.Album().c_str();
        genre = (char *)mdata.Genre().c_str();
        comment = (char *)mdata.Comment().c_str();
        
        URLToFilePath(item->URL().c_str(), location, &loclength);

        if (mdata.Year() == 0)
            sprintf(year, "Unknown");
        else
            sprintf(year, "%d", mdata.Year());

        if (mdata.Time() == 0)
            sprintf(length, "Unknown");
        else {
            int secs = mdata.Time();
            if (secs > 3600)
                sprintf(length, "%d:%02d:%02d", secs / 3600, (secs / 60) % 60,
                        secs % 60);
            else
                sprintf(length, "%d:%02d", (secs / 60) % 60, secs % 60);
        }

        for (int i = 0; i < 9; i++)
        {
            switch (playlistCols[i]) 
            {
            case kArtistColumn:
                iText[i] = artist;
                break;
            case kAlbumColumn:
                iText[i] = album;
                break;
            case kCommentColumn:
                iText[i] = comment;
                break;
            case kGenreColumn:
                iText[i] = genre;
                break;
            case kLocationColumn:
                iText[i] = location;
                break;
            case kPositionColumn:
                iText[i] = position;
                break;
            case kTitleColumn:
                iText[i] = title;
                break;
            case kTimeColumn:
                iText[i] = length;
                break;
            case kYearColumn:
                iText[i] = year;
                break;
            default:
                iText[i] = (char *)empty.c_str();
                break;
            }
        }

        totaltime = totaltime + mdata.Time();

        row = gtk_clist_append(GTK_CLIST(playlistList), iText);

        if (m_bCDMode) {
            if (totaltime > (int)maxCDtime)
                gtk_clist_set_row_style(GTK_CLIST(playlistList), row, redStyle);
            else
                gtk_clist_set_row_style(GTK_CLIST(playlistList), row, 
                                        greenStyle);
        }
        
        int *totTime = new int;
        *totTime = totaltime;

        gtk_clist_set_row_data_full(GTK_CLIST(playlistList), row, totTime,
                                    (GtkDestroyNotify)int_destroy);
    }

    if (iLoop == 0) {
        gtk_clist_set_column_width(GTK_CLIST(playlistList), 0, 10);
        gtk_clist_set_column_width(GTK_CLIST(playlistList), 1, 45);
        gtk_clist_set_column_width(GTK_CLIST(playlistList), 2, 45);
    }
    else
        gtk_clist_columns_autosize(GTK_CLIST(playlistList));

    gtk_clist_select_row(GTK_CLIST(playlistList), m_lastindex, 0);
    gtk_clist_moveto(GTK_CLIST(playlistList), m_lastindex, 0, 0.5, -1);
    ChangeCurrentPlayingIndex(m_playingindex, m_playingindex);
    gtk_clist_thaw(GTK_CLIST(playlistList));
}

void GTKMusicBrowser::ChangeCurrentPlayingIndex(uint32 oldindex,
                                                uint32 newindex)
{
    if (oldindex != kInvalidIndex)
        gtk_clist_set_row_style(GTK_CLIST(playlistList), oldindex, normStyle);
    gtk_clist_set_row_style(GTK_CLIST(playlistList), newindex, boldStyle);
    gtk_clist_columns_autosize(GTK_CLIST(playlistList));
}

void list_keypress(GtkWidget *w, GdkEventKey *ev, GTKMusicBrowser *p)
{
    if (ev->keyval == GDK_Delete)
        p->DeleteEvent();
}

static void playlist_row_move_internal(GtkWidget *widget, int source, int dest,
                                       GTKMusicBrowser *p)
{
    p->MoveItemEvent(source, dest);
    p->SetClickState(kContextPlaylist);
}

static void set_current_index_internal(GtkWidget *widget, int row, int column,
                                       GdkEventButton *button,
                                       GTKMusicBrowser *p)
{
    p->m_lastindex = row;
    p->m_plSelected.insert(row);
    if (button && button->type == GDK_2BUTTON_PRESS)
        p->PlayEvent();
    p->SetClickState(kContextPlaylist);
}

static void unset_current_index_internal(GtkWidget *widget, int row, int column,
                                         GdkEventButton *button,
                                         GTKMusicBrowser *p)
{
    p->m_plSelected.erase(row);
}

static gboolean list_drag_drop_internal(GtkWidget *widget,
                                        GdkDragContext *context,
                                        gint x, gint y, guint time,
                                        GTKMusicBrowser *p)
{
    GList *list = context->targets;
    GdkAtom atom = gdk_atom_intern("gtk-clist-drag-reorder", FALSE);
    GdkAtom tree = gdk_atom_intern("tree-drag", FALSE);
    GdkAtom plain = gdk_atom_intern("text/plain", FALSE);
    GdkAtom html = gdk_atom_intern("text/html", FALSE);
    while (list) {
        if (((int)atom == GPOINTER_TO_INT(list->data)) ||
            ((int)tree == GPOINTER_TO_INT(list->data)) ||
            ((int)plain == GPOINTER_TO_INT(list->data)) ||
            ((int)html == GPOINTER_TO_INT(list->data))) {
            gtk_drag_get_data(widget, context, GPOINTER_TO_INT(list->data), 
                              time);
            return TRUE;
        }
        list = list->next;
    }
    return FALSE;
}

static void drag_dest_info_destroy(gpointer data)
{
    GtkCListDestInfo *info = (GtkCListDestInfo *)data;
    free(info);
}

#define ROW_TOP_YPIXEL(clist, row) (((clist)->row_height * (row)) + \
                                    ((row) + 1) + (clist)->voffset)
#define ROW_FROM_YPIXEL(clist, y)  (((y) - (clist)->voffset) / \
                                    ((clist)->row_height + 1))
#define GTK_CLIST_CLASS_FW(_widget_) GTK_CLIST_CLASS (((GtkObject*) (_widget_))->klass)


static gint COLUMN_FROM_XPIXEL (GtkCList * clist, gint x)
{
  gint i, cx;

  for (i = 0; i < clist->columns; i++)
    if (clist->column[i].visible)
      {
        cx = clist->column[i].area.x + clist->hoffset;

        if (x >= (cx - 4) &&
            x <= (cx + clist->column[i].area.width + 3))
          return i;
      }

  return -1;
}

static void drag_dest_cell (GtkCList *clist, gint x, gint y,
                     GtkCListDestInfo *dest_info)
{
    GtkWidget *widget;

    widget = GTK_WIDGET (clist);
    dest_info->insert_pos = GTK_CLIST_DRAG_NONE;

    y -= (GTK_CONTAINER (clist)->border_width +
          widget->style->klass->ythickness + clist->column_title_area.height);

    dest_info->cell.row = ROW_FROM_YPIXEL (clist, y);
    if (dest_info->cell.row >= clist->rows) {
        dest_info->cell.row = clist->rows - 1;
        y = ROW_TOP_YPIXEL (clist, dest_info->cell.row) + clist->row_height;
    }
    if (dest_info->cell.row < 0) {
        dest_info->cell.column = -1;
        dest_info->cell.row = 0;
        dest_info->insert_pos = GTK_CLIST_DRAG_AFTER;
        return;
    }

    x -= GTK_CONTAINER (widget)->border_width +
         widget->style->klass->xthickness;
    dest_info->cell.column = COLUMN_FROM_XPIXEL (clist, x);

    if (dest_info->cell.row >= 0) {
        gint y_delta;
        gint h = 0;

        y_delta = y - ROW_TOP_YPIXEL (clist, dest_info->cell.row);

        if (GTK_CLIST_DRAW_DRAG_RECT(clist)) {
            dest_info->insert_pos = GTK_CLIST_DRAG_INTO;
            h = clist->row_height / 4;
        }
        else if (GTK_CLIST_DRAW_DRAG_LINE(clist)) {
            dest_info->insert_pos = GTK_CLIST_DRAG_BEFORE;
            h = clist->row_height / 2;
        }

        if (GTK_CLIST_DRAW_DRAG_LINE(clist)) {
            if (y_delta < h)
                dest_info->insert_pos = GTK_CLIST_DRAG_BEFORE;
            else if (clist->row_height - y_delta < h)
                dest_info->insert_pos = GTK_CLIST_DRAG_AFTER;
        }
    }
}

static void list_drag_rec_internal(GtkWidget *widget, GdkDragContext *context,
                                   gint x, gint y, GtkSelectionData *data,
                                   guint info, guint time, GTKMusicBrowser *p)
{
    if (widget == gtk_drag_get_source_widget(context))
        return;
    if (info == TARGET_TREE) {
        if (data->length == sizeof(vector<PlaylistItem *> *)) {
            vector<PlaylistItem *> *newlist;
            newlist = *((vector<PlaylistItem *>**)(data->data));
            if (newlist) {
                GtkCListDestInfo dest_info;

                drag_dest_cell(GTK_CLIST(widget), x, y, &dest_info);
                if (dest_info.insert_pos == GTK_CLIST_DRAG_AFTER)
                    dest_info.cell.row++;

                p->m_lastindex = dest_info.cell.row;
                p->AddTracksPlaylistEvent(newlist);
 
                p->SetClickState(kContextPlaylist);

                g_dataset_remove_data(context, "gtk-clist-drag-dest"); 
                gtk_drag_finish(context, TRUE, FALSE, time);

                delete newlist;
            }
        }
    }
    else if (info == TARGET_STRING || info == TARGET_URL) {
        if (data->data) {
            vector<PlaylistItem *> *itemList = new vector<PlaylistItem *>;
            vector<string> oFileList;
            char *filereturn = strdup_new((char *)(data->data));
            char *temp = strtok(filereturn, "\n");
            do {
                char *realname = strchr(temp, ':');
                realname++;
                if (realname && *realname) {
                    uint32 length = strlen(realname);
                    if (realname[length - 1] == '\r')
                        realname[length - 1] = '\0';
                    oFileList.push_back(string(realname));
                }
            }
            while ((temp = strtok(NULL, "\n")));