playlistitem.cpp

来自「Amarok是一款在LINUX或其他类UNIX操作系统中运行的音频播放器软件。 」· C++ 代码 · 共 1,153 行 · 第 1/3 页

/***************************************************************************
                        playlistitem.cpp  -  description
                           -------------------
  begin                : Die Dez 3 2002
  copyright            : (C) 2002 by Mark Kretschmann
  email                : [e-mail]
  copyright            : (C) 2005 by Alexandre Oliveira
  email                : [e-mail]
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#define DEBUG_PREFIX "PlaylistItem"

#include <config.h>
#include "amarok.h"
#include "amarokconfig.h"
#include "collectiondb.h"
#include "debug.h"
#include "enginecontroller.h"
#include "playlist.h"
#include "sliderwidget.h"
#include "starmanager.h"

#include <qcursor.h>
#include <qheader.h>
#include <qimage.h>
#include <qmutex.h>
#include <qpainter.h>
#include <qpen.h>
#include <qpixmap.h>
#include <qrect.h>

#include <kdeversion.h>
#include <kfilemetainfo.h>
#include <kglobal.h>
#include <kiconeffect.h>
#include <kstandarddirs.h>
#include <kstringhandler.h>

#include "playlistitem.h"

double  PlaylistItem::glowIntensity;
QColor  PlaylistItem::glowText = Qt::white;
QColor  PlaylistItem::glowBase = Qt::white;
bool    PlaylistItem::s_pixmapChanged = false;


PlaylistItem::PlaylistItem( QListView *listview, QListViewItem *item )
        : KListViewItem( listview, item )
        , m_album( 0 )
{
    KListViewItem::setVisible( false );
}

PlaylistItem::PlaylistItem( const MetaBundle &bundle, QListViewItem *lvi, bool enabled )
        : MetaBundle( bundle ), KListViewItem( lvi->listView(), lvi->itemAbove() )
        , m_album( 0 )
        , m_deleteAfterEdit( false )
        , m_isBeingRenamed( false )
        , m_isNew( true )
{
    setDragEnabled( true );

    Playlist::instance()->m_urlIndex.add( this );
    if( !uniqueId().isEmpty() )
        Playlist::instance()->addToUniqueMap( uniqueId(), this );


    refAlbum();

    incrementCounts();
    incrementLengths();

    filter( listView()->m_filter );

    listView()->countChanged();
    setAllCriteriaEnabled( enabled );
}

PlaylistItem::~PlaylistItem()
{
    if( isEmpty() ) //constructed with the generic constructor, for PlaylistLoader's marker item
        return;

    decrementCounts();
    decrementLengths();

    derefAlbum();

    listView()->countChanged();

    if( listView()->m_hoveredRating == this )
        listView()->m_hoveredRating = 0;

    Playlist::instance()->removeFromUniqueMap( uniqueId(), this );
    Playlist::instance()->m_urlIndex.remove(this);


}


/////////////////////////////////////////////////////////////////////////////////////
// PUBLIC METHODS
/////////////////////////////////////////////////////////////////////////////////////


void PlaylistItem::setText( int column, const QString &text )
{
    if( column == Rating )
        setExactText( column, QString::number( int( text.toFloat() * 2 ) ) );
    else
        setExactText( column, text );
}

QString PlaylistItem::text( int column ) const
{
    if( column == Title && listView()->header()->sectionSize( Filename ) ) //don't show the filename twice
        return exactText( column );
    else switch ( column )
    {
        case Artist:
        case Composer:
        case Album:
        case Genre:
        case Comment:
            return exactText( column ); //HACK
        case Rating:
            return isEditing( column ) ? exactText( column ) : prettyText( column );
        default:
        {
            if( column != Title && isEditing( column ) )
                return editingText();
            else
                return prettyText( column );
        }
    }
}

void PlaylistItem::aboutToChange( const QValueList<int> &columns )
{
    bool totals = false, ref = false, length = false, url = false;
    for( int i = 0, n = columns.count(); i < n; ++i )
        switch( columns[i] )
        {
	    case Length: length = true; break;
            case Artist: case Album: ref = true; //note, no breaks
            case Track: case Rating: case Score: case LastPlayed:
                totals = true; break;
            case Filename: case Directory: url = true; break;
        }
    if ( length )
        decrementLengths();
    if( totals )
        decrementTotals();
    if( ref )
        derefAlbum();
    if ( url )
        Playlist::instance()->m_urlIndex.remove(this);
}

void PlaylistItem::reactToChanges( const QValueList<int> &columns )
{
    MetaBundle::reactToChanges(columns);
    bool totals = false, ref = false, length = false, url = false;
    for( int i = 0, n = columns.count(); i < n; ++i )
      {
        if( columns[i] == Mood )
          moodbar().reset();
	if ( !length && columns[i] == Length ) {
	    length = true;
	    incrementLengths();
	    listView()->countChanged();
	}
        switch( columns[i] )
        {
            case Artist: case Album: ref = true; //note, no breaks
            case Track: case Rating: case Score: case LastPlayed:
                totals = true; break;
            case Filename: case Directory: url = true;
        }
        updateColumn( columns[i] );
      }
    if ( url )
        Playlist::instance()->m_urlIndex.add(this);
    if( ref )
        refAlbum();
    if( totals )
        incrementTotals();
}

void PlaylistItem::filter( const QString &expression )
{
    setVisible( matchesExpression( expression, listView()->visibleColumns() ) );
}

bool PlaylistItem::isCurrent() const
{
    return this == listView()->currentTrack();
}

bool PlaylistItem::isQueued() const
{
    return queuePosition() != -1;
}

int PlaylistItem::queuePosition() const
{
    return listView()->m_nextTracks.findRef( this );
}

void PlaylistItem::setEnabled()
{
    m_enabled = m_filestatusEnabled && m_dynamicEnabled;
    setDropEnabled( m_enabled ); // this forbids items to be dropped into a history queue.

    update();
}

void PlaylistItem::setDynamicEnabled( bool enabled )
{
    m_dynamicEnabled = enabled;
    setEnabled();
}

void PlaylistItem::setFilestatusEnabled( bool enabled )
{
    m_filestatusEnabled = enabled;
    checkExists();
    setEnabled();
}

void PlaylistItem::setAllCriteriaEnabled( bool enabled )
{
    m_filestatusEnabled = enabled;
    m_dynamicEnabled = enabled;
    checkExists();
    setEnabled();
}

void PlaylistItem::setSelected( bool selected )
{
    if( isEmpty() )
        return;

    if( isVisible() )
    {
        const bool prevSelected = isSelected();
        KListViewItem::setSelected( selected );
        if( prevSelected && !isSelected() )
        {
            listView()->m_selCount--;
            listView()->m_selLength -= length();
            listView()->countChanged();
        }
        else if( !prevSelected && isSelected() )
        {
            listView()->m_selCount++;
            listView()->m_selLength += length();
            listView()->countChanged();
        }
    }
}

void PlaylistItem::setVisible( bool visible )
{
    if( isEmpty() )
        return;

    if( !visible && isSelected() )
    {
        listView()->m_selCount--;
        listView()->m_selLength -= length();
        KListViewItem::setSelected( false );
        listView()->countChanged();
    }

    const bool prevVisible = isVisible();
    KListViewItem::setVisible( visible );
    if( prevVisible && !isVisible() )
    {
        listView()->m_visCount--;
        listView()->m_visLength -= length();
        listView()->countChanged();
        decrementTotals();
    }
    else if( !prevVisible && isVisible() )
    {
        listView()->m_visCount++;
        listView()->m_visLength += length();
        listView()->countChanged();
        incrementTotals();
    }
}

void PlaylistItem::setEditing( int column )
{
    switch( column )
    {
        case Title:
        case Artist:
        case Composer:
        case Album:
        case Genre:
        case Comment:
            setExactText( column, editingText() );
            break;
        case Year:       m_year       = -1; break;
        case DiscNumber: m_discNumber = -1; break;
        case Track:      m_track      = -1; break;
        case Bpm:        m_bpm        = -1; break;
        case Length:     m_length     = -1; break;
        case Bitrate:    m_bitrate    = -1; break;
        case SampleRate: m_sampleRate = -1; break;
        case Score:      m_score      = -1; break;
        case Rating:     m_rating     = -1; break;
        case PlayCount:  m_playCount  = -1; break;
        case LastPlayed: m_lastPlay   =  1; break;
        default: warning() << "Tried to set the text of an immutable or nonexistent column!" << endl;
    }

    update();
}

bool PlaylistItem::isEditing( int column ) const
{
    switch( column )
    {
        case Title:
        case Artist:
        case Composer:
        case Album:
        case Genre:
        case Comment: //FIXME fix this hack!
            return exactText( column ) == editingText();
        case Year:       return m_year       == -1;
        case DiscNumber: return m_discNumber == -1;
        case Track:      return m_track      == -1;
        case Bpm:        return m_bpm        == -1;
        case Length:     return m_length     == -1;
        case Bitrate:    return m_bitrate    == -1;
        case SampleRate: return m_sampleRate == -1;
        case Score:      return m_score      == -1;
        case Rating:     return m_rating     == -1;
        case PlayCount:  return m_playCount  == -1;
        case LastPlayed: return m_lastPlay   ==  1;
        default: return false;
    }
}

bool PlaylistItem::anyEditing() const
{
    for( int i = 0; i < NUM_COLUMNS; i++ )
    {
        if( isEditing( i ) )
            return true;
    }
    return false;
}

int PlaylistItem::ratingAtPoint( int x ) //static
{
    Playlist* const pl = Playlist::instance();
    x -= pl->header()->sectionPos( Rating );
    return kClamp( ( x - 1 ) / ( StarManager::instance()->getGreyStar()->width() + pl->itemMargin() ) + 1, 1, 5 ) * 2;
}

int PlaylistItem::ratingColumnWidth() //static
{
    return StarManager::instance()->getGreyStar()->width() * 5 + Playlist::instance()->itemMargin() * 6;
}

void PlaylistItem::update() const
{
    listView()->repaintItem( this );
}

void PlaylistItem::updateColumn( int column ) const