browsermenu.cpp

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

/*____________________________________________________________________________

        FreeAmp - The Free MP3 Player

        Portions Copyright (C) 1999-2000 EMusic.com

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with this program; if not, write to the Free Software
        Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

        $Id: browsermenu.cpp,v 1.27 2001/02/27 22:03:26 robert Exp $
____________________________________________________________________________*/

#include "config.h"

#include <sys/stat.h>
#include <unistd.h>

#include "gtkmusicbrowser.h"
#include "fileselector.h"
#include "gtkmessagedialog.h"
#include "player.h"
#include "help.h"

#include "../res/new_pic.xpm"
#include "../res/save_pic.xpm"
#include "../res/import_pic.xpm"
#include "../res/edit_pic.xpm"
#include "../res/add_track.xpm"
#include "../res/add_file.xpm"
#include "../res/up_pic.xpm"
#include "../res/down_pic.xpm"
#include "../res/trash_pic.xpm"


static void add_tool(GtkWidget *widget, GTKMusicBrowser *p)
{
    p->SetClickState(kContextPlaylist);
    FileSelector *filesel = new FileSelector("Add a Track");
    filesel->SetExtended();
    if (filesel->Run()) {
        char *returnpath = filesel->GetReturnPath();
        char *ext = p->GetContext()->player->GetExtension(returnpath);
        uint32 length = strlen(returnpath) + 10;
        char *tempurl = new char[length];
        if (IsntError(FilePathToURL(returnpath, tempurl, &length))) {
            if (ext && p->GetContext()->plm->IsSupportedPlaylistFormat(ext)) {
                string tobeloaded = tempurl;
                p->LoadPlaylist(tobeloaded);
            }
            else {
                char *filereturn = strdup_new(filesel->GetReturnPath());
                if (filereturn) {
                    char *temp;
                    char *first= strtok(filereturn, "\n");

                    while ((temp = strtok(NULL, "\n"))) {
                        if (ext)
                            delete [] ext;
                        ext = p->GetContext()->player->GetExtension(temp);
                        if (ext &&
                            p->GetContext()->player->IsSupportedExtension(ext)) 
                        {
                            p->AddTrackPlaylistEvent(temp);
                            p->m_lastindex++;
                        }
                    }
                    if (ext)
                        delete [] ext;
                    ext = p->GetContext()->player->GetExtension(first);
                    if (ext &&
                        p->GetContext()->player->IsSupportedExtension(ext))
                        p->AddTrackPlaylistEvent(first);
                }
                delete [] filereturn;
            }
        }
        delete [] tempurl;
        delete [] ext;
    }
    delete filesel;
}

static void move_up_tool(GtkWidget *widget, GTKMusicBrowser *p)
{
    p->MoveUpEvent();
    p->SetClickState(kContextPlaylist);
}

static void move_down_tool(GtkWidget *widget, GTKMusicBrowser *p)
{
    p->MoveDownEvent();
    p->SetClickState(kContextPlaylist);
}

static void import_tool(GtkWidget *w, GTKMusicBrowser *p)
{
    FileSelector *filesel = new FileSelector("Import a Track or Playlist into My Music");
    if (filesel->Run()) {
        FAContext *m_context = p->GetContext();
        char *returnpath = filesel->GetReturnPath();
        char *filereturn = strdup_new(returnpath);
        if (filereturn)
        {
            char *first = strtok(filereturn, "\n");
            while (first) {
                char *ext = m_context->player->GetExtension(first);
                uint32 length = strlen(first) + 10;
                char *tempurl = new char[length];

                if (IsntError(FilePathToURL(first, tempurl, &length))) 
                {
                    if (ext && m_context->plm->IsSupportedPlaylistFormat(ext))
                        p->ImportPlaylist(tempurl);
                    else if (ext && 
                             m_context->player->IsSupportedExtension(ext)) 
                    {
                        PlaylistItem *plist = new PlaylistItem(tempurl);
                        m_context->plm->RetrieveMetaDataNow(plist);

                        m_context->catalog->WriteMetaDataToDatabase(tempurl,
                                                          plist->GetMetaData());
                        m_context->catalog->AddSong(tempurl);

                        delete plist;
                    }
                }
                delete [] tempurl;
                delete ext;

                first = strtok(NULL, "\n");
            }
            delete [] filereturn;
        }
    }
    delete filesel;
}

static void remove_tool(GtkWidget *w, GTKMusicBrowser *p)
{
    p->DeleteEvent();
}

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

static void infoedit(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    edit_tool(w, p);
}

static void new_plist(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    p->SaveCurrentPlaylist();

    p->CreateNewEditor(NULL);
}

static void new_plist_tool(GtkWidget *w, GTKMusicBrowser *p)
{
    new_plist(p, 1, w);
}

static void open_list(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    p->SaveCurrentPlaylist();

    FileSelector *filesel = new FileSelector("Open a Playlist from Disk");
    if (filesel->Run())
        p->CreateNewEditor(filesel->GetReturnPath());
    delete filesel;
}

static void saveas_list(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    GTKMessageDialog oBox;
    string oMessage = string("What do you want to call this playlist?");

    if (oBox.Show(oMessage.c_str(), "Save This List to Disk?", kMessageOkCancel,
                  true, true)
                  == kMessageReturnOk) {

        char *temp = oBox.GetEntryText();
        if (!temp)
            return;

        for (unsigned int i = 0; i < strlen(temp); i++)
            if (temp[i] == '/')
                temp[i] = '_';

        char *fadir = FreeampDir(NULL);
        string name = string(fadir) + string("/") + string(temp) +
                      string(".m3u");
        p->m_currentListName = string(name);

        delete [] fadir;

        p->SaveCurrentPlaylist();
    }
}

static void save_list(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    if (p->m_currentListName.length() == 0) {
        saveas_list(p, action, w);
    }
    else
        p->SaveCurrentPlaylist();
}

static void save_list_tool(GtkWidget *w, GTKMusicBrowser *p)
{
    save_list(p, 1, w);
}

static void import_list(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    import_tool(w, p);
}

static void export_list(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    FileSelector *filesel = new FileSelector("Export This Playlist to Disk");
    if (filesel->Run())
        p->SaveCurrentPlaylist(filesel->GetReturnPath());
    delete filesel;
}

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

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

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

static void add_track_tool(GtkWidget *w, GTKMusicBrowser *p)
{
    add_track_mb(p, 0, w);
}

static void add_track(GTKMusicBrowser *p, guint action, GtkWidget *w)
{   
    FileSelector *filesel = new FileSelector("Add a Track");
    filesel->SetExtended();
    if (filesel->Run()) {
        char *filereturn = strdup_new(filesel->GetReturnPath());
        if (filereturn) {
            char *temp;
            char *first;
            first = strtok(filereturn, "\n");
            while ((temp = strtok(NULL, "\n"))) {
                p->AddTrackPlaylistEvent(temp);
                p->m_lastindex++;
            }
            p->AddTrackPlaylistEvent(first);
       }
       delete filereturn;
    }
    delete filesel;
}

bool GTKMusicBrowser::AskToDelete(string &url)
{
    bool retvalue = false;

    uint32 length = url.size() + 1;
    char *filename = new char[length];

    if (IsntError(URLToFilePath(url.c_str(), filename, &length))) {
        GTKMessageDialog oBox;
        string oMessage = string("Are you sure you want to delete ")
                          + string(filename) + string("?");

        if (oBox.Show(oMessage.c_str(), "Delete Confirmation", kMessageYesNo,
                      true, false, "Delete it Permantly From the Disk")
                      == kMessageReturnYes) {

            if (oBox.GetCheckStatus()) 
                unlink(filename);

            retvalue = true;
        }
    }

    delete [] filename;

    return retvalue;
}

static void delete_sel(GTKMusicBrowser *p, guint action, GtkWidget *w)
{
    string urlToDel;
 
    if (p->GetClickState() == kContextPlaylist) {
        set<uint32>::reverse_iterator i = p->m_plSelected.rbegin();
        for (; i != p->m_plSelected.rend(); i++) {
            urlToDel = p->GetContext()->plm->ItemAt(*i)->URL();

            if (p->AskToDelete(urlToDel)) 
                p->DeletePlaylistItem(*i);
        }
    }
    else if (p->GetClickState() == kContextBrowser) {
        vector<TreeData *> local_mbSelections(*(p->mbSelections));
        vector<TreeData *>::iterator i = local_mbSelections.begin();
        for (; i != local_mbSelections.end(); i++) {
            TreeNodeType type = (*i)->type;
            
            if (type == kTreePlaylist) 
                urlToDel = (*i)->playlistname;
            else if (type == kTreeTrack)
                urlToDel = (*i)->track->URL();
            else if (type == kTreeArtist) {
                ArtistList *list = (*i)->artist;
                vector<AlbumList *>::reverse_iterator j = 
                                                 list->m_albumList->rbegin();
                for (; j != list->m_albumList->rend(); j++) {
                    vector<PlaylistItem *>::reverse_iterator k = 
                                                    (*j)->m_trackList->rbegin();
                    for (; k != (*j)->m_trackList->rend(); k++) {
                        urlToDel = (*k)->URL();
                        if (p->AskToDelete(urlToDel))
                            p->GetContext()->catalog->RemoveSong(urlToDel.c_str());
                    }
                }
            }
            else if (type == kTreeAlbum) {
                AlbumList *list = (*i)->album;
                vector<PlaylistItem *>::reverse_iterator j = 
                                                   list->m_trackList->rbegin();
                for (; j != list->m_trackList->rend(); j++) {
                    urlToDel = (*j)->URL();
                    if (p->AskToDelete(urlToDel))
                        p->GetContext()->catalog->RemoveSong(urlToDel.c_str());
                }
            }
            else
                continue;

            if (p->AskToDelete(urlToDel) && 
                (type == kTreeTrack || type == kTreePlaylist)) {
                switch (type) {
                    case kTreePlaylist: {
                        p->GetContext()->catalog->RemovePlaylist(urlToDel.c_str());
                        break; }
                    case kTreeTrack: {
                        p->GetContext()->catalog->RemoveSong(urlToDel.c_str());
                        break; }
                    default:
                        break;
                }
            }
        }
    }