File indexing completed on 2024-05-05 04:48:29

 /****************************************************************************************
  * Copyright (c) 2008 Daniel Jones <danielcjones@gmail.com>                             *
  * Copyright (c) 2009 Leo Franchi <lfranchi@kde.org>                                    *
  * Copyright (c) 2010,2011 Ralf Engels <ralf-engels@gmx.de>                                  *
  *                                                                                      *
  * 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) version 3 or        *
  * any later version accepted by the membership of KDE e.V. (or its successor approved  *
  * by the membership of KDE e.V.), which shall act as a proxy defined in Section 14 of  *
  * version 3 of the license.                                                            *
  *                                                                                      *
  * 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, see <http://www.gnu.org/licenses/>.                           *
  ****************************************************************************************/
 
 #define DEBUG_PREFIX "Bias"
 
 #include "Bias.h"
 
 #include "core/support/Debug.h"
 #include "dynamic/BiasFactory.h"
 #include "dynamic/DynamicModel.h"
 #include "dynamic/biases/SearchQueryBias.h"
 
 #include <KLocalizedString>
 
 #include <QPainter>
 #include <QBuffer>
 #include <QXmlStreamReader>
 #include <QXmlStreamWriter>
 
 // -------- AbstractBias -------------
 
 Dynamic::AbstractBias::AbstractBias()
 { }
 
 Dynamic::AbstractBias::~AbstractBias()
 {
     // debug() << "destroying bias" << this;
 }
 
 void
 Dynamic::AbstractBias::fromXml( QXmlStreamReader *reader )
 {
     reader->skipCurrentElement();
 }
 
 
 void
 Dynamic::AbstractBias::toXml( QXmlStreamWriter *writer ) const
 {
     Q_UNUSED( writer );
 }
 
 Dynamic::BiasPtr
 Dynamic::AbstractBias::clone() const
 {
     QByteArray bytes;
     QBuffer buffer( &bytes, nullptr );
     buffer.open( QIODevice::ReadWrite );
 
     // write the bias
     QXmlStreamWriter xmlWriter( &buffer );
     xmlWriter.writeStartElement( name() );
     toXml( &xmlWriter );
     xmlWriter.writeEndElement();
 
     // and read a new list
     buffer.seek( 0 );
     QXmlStreamReader xmlReader( &buffer );
     while( !xmlReader.isStartElement() )
         xmlReader.readNext();
     return Dynamic::BiasFactory::fromXml( &xmlReader );
 }
 
 QString
 Dynamic::AbstractBias::sName()
 {
     return QStringLiteral( "abstractBias" );
 }
 
 QString
 Dynamic::AbstractBias::name() const
 {
     return Dynamic::AbstractBias::sName();
 }
 
 QWidget*
 Dynamic::AbstractBias::widget( QWidget* parent )
 {
     Q_UNUSED( parent );
     return nullptr;
 }
 
 void
 Dynamic::AbstractBias::paintOperator( QPainter* painter, const QRect& rect, Dynamic::AbstractBias* bias )
 {
     Q_UNUSED( painter );
     Q_UNUSED( rect );
     Q_UNUSED( bias );
 }
 
 void
 Dynamic::AbstractBias::invalidate()
 { }
 
 void
 Dynamic::AbstractBias::replace( const Dynamic::BiasPtr &newBias )
 {
     Q_EMIT replaced( BiasPtr(const_cast<Dynamic::AbstractBias*>(this)), newBias );
 }
 
 // -------- RandomBias ------
 
 Dynamic::RandomBias::RandomBias()
 { }
 
 Dynamic::RandomBias::~RandomBias()
 { }
 
 QString
 Dynamic::RandomBias::sName()
 {
     return QStringLiteral( "randomBias" );
 }
 
 QString
 Dynamic::RandomBias::name() const
 {
     return Dynamic::RandomBias::sName();
 }
 
 QString
 Dynamic::RandomBias::toString() const
 {
     return i18nc("Random bias representation", "Random tracks");
 }
 
 QWidget*
 Dynamic::RandomBias::widget( QWidget* parent )
 {
     Q_UNUSED( parent );
     return nullptr;
 }
 
 Dynamic::TrackSet
 Dynamic::RandomBias::matchingTracks( const Meta::TrackList& playlist,
                                      int contextCount, int finalCount,
                                      const Dynamic::TrackCollectionPtr &universe ) const
 {
     Q_UNUSED( playlist );
     Q_UNUSED( contextCount );
     Q_UNUSED( finalCount );
     return Dynamic::TrackSet( universe, true );
 }
 
 bool
 Dynamic::RandomBias::trackMatches( int position,
                                    const Meta::TrackList& playlist,
                                    int contextCount ) const
 {
     Q_UNUSED( position );
     Q_UNUSED( playlist );
     Q_UNUSED( contextCount );
     return true;
 }
 
 // -------- AndBias ------
 
 Dynamic::AndBias::AndBias()
 { }
 
 Dynamic::AndBias::~AndBias()
 { }
 
 void
 Dynamic::AndBias::fromXml( QXmlStreamReader *reader )
 {
     while (!reader->atEnd()) {
         reader->readNext();
 
         if( reader->isStartElement() )
         {
             Dynamic::BiasPtr bias( Dynamic::BiasFactory::fromXml( reader ) );
             if( bias )
             {
                 appendBias( bias );
             }
             else
             {
                 warning()<<"Unexpected xml start element"<<reader->name()<<"in input";
                 reader->skipCurrentElement();
             }
         }
         else if( reader->isEndElement() )
         {
             break;
         }
     }
 }
 
 void
 Dynamic::AndBias::toXml( QXmlStreamWriter *writer ) const
 {
     foreach( Dynamic::BiasPtr bias, m_biases )
     {
         writer->writeStartElement( bias->name() );
         bias->toXml( writer );
         writer->writeEndElement();
     }
 }
 
 QString
 Dynamic::AndBias::sName()
 {
     return QStringLiteral( "andBias" );
 }
 
 QString
 Dynamic::AndBias::name() const
 {
     return Dynamic::AndBias::sName();
 }
 
 QString
 Dynamic::AndBias::toString() const
 {
     return i18nc("And bias representation", "Match all");
 }
 
 
 QWidget*
 Dynamic::AndBias::widget( QWidget* parent )
 {
     Q_UNUSED( parent );
     return nullptr;
 }
 
 void
 Dynamic::AndBias::paintOperator( QPainter* painter, const QRect& rect, Dynamic::AbstractBias* bias )
 {
     if( m_biases.indexOf( Dynamic::BiasPtr(bias) ) > 0 )
     {
         painter->drawText( rect.adjusted(2, 0, -2, 0),
                            Qt::AlignRight,
                            i18nc("Prefix for AndBias. Shown in front of a bias in the dynamic playlist view", "and" ) );
     }
 }
 
 Dynamic::TrackSet
 Dynamic::AndBias::matchingTracks( const Meta::TrackList& playlist,
                                   int contextCount, int finalCount,
                                   const Dynamic::TrackCollectionPtr &universe ) const
 {
     DEBUG_BLOCK;
 debug() << "universe:" << universe.data();
 
     m_tracks = Dynamic::TrackSet( universe, true );
     m_outstandingMatches = 0;
 
     foreach( Dynamic::BiasPtr bias, m_biases )
     {
         Dynamic::TrackSet tracks = bias->matchingTracks( playlist, contextCount, finalCount, universe );
         if( tracks.isOutstanding() )
             m_outstandingMatches++;
         else
             m_tracks.intersect( tracks );
 
         //    debug() << "AndBias::matchingTracks" << bias->name() << "tracks:"<<tracks.trackCount() << "outstanding?" << tracks.isOutstanding() << "numOUt:" << m_outstandingMatches;
 
         if( m_tracks.isEmpty() )
             break;
     }
 
     // debug() << "AndBias::matchingTracks end: tracks:"<<m_tracks.trackCount() << "outstanding?" << m_tracks.isOutstanding() << "numOUt:" << m_outstandingMatches;
 
     if( m_outstandingMatches > 0 )
         return Dynamic::TrackSet();
     else
         return m_tracks;
 }
 
 bool
 Dynamic::AndBias::trackMatches( int position,
                                 const Meta::TrackList& playlist,
                                 int contextCount ) const
 {
     foreach( Dynamic::BiasPtr bias, m_biases )
     {
         if( !bias->trackMatches( position, playlist, contextCount ) )
             return false;
     }
     return true;
 }
 
 void
 Dynamic::AndBias::invalidate()
 {
     foreach( Dynamic::BiasPtr bias, m_biases )
     {
         bias->invalidate();
     }
     m_tracks = TrackSet();
 }
 
 void
 Dynamic::AndBias::appendBias(const BiasPtr &bias )
 {
     bool newInModel = DynamicModel::instance()->index( bias ).isValid();
     if (newInModel) {
         warning() << "Argh, the old bias "<<bias->toString()<<"is still in a model";
         return;
     }
 
     BiasPtr thisPtr( this );
     bool inModel = DynamicModel::instance()->index( thisPtr ).isValid();
     if( inModel )
         DynamicModel::instance()->beginInsertBias( thisPtr, m_biases.count() );
     m_biases.append( bias );
     if( inModel )
         DynamicModel::instance()->endInsertBias();
 
     connect( bias.data(), &Dynamic::AbstractBias::resultReady,
              this, &AndBias::resultReceived );
     connect( bias.data(), &Dynamic::AbstractBias::replaced,
              this, &AndBias::biasReplaced );
     connect( bias.data(), &Dynamic::AbstractBias::changed,
              this, &AndBias::biasChanged );
     Q_EMIT biasAppended( bias );
 
     // creating a shared pointer and destructing it just afterwards would
     // also destruct this object.
     // so we give the object creating this bias a chance to increment the refcount
     Q_EMIT changed( thisPtr );
 }
 
 void
 Dynamic::AndBias::moveBias( int from, int to )
 {
     if( from == to )
         return;
     if( from < 0 || from >= m_biases.count() )
         return;
     if( to < 0 || to >= m_biases.count() )
         return;
 
     BiasPtr thisPtr( this );
     bool inModel = DynamicModel::instance()->index( thisPtr ).isValid();
     if( inModel )
         DynamicModel::instance()->beginMoveBias( thisPtr, from, to );
     m_biases.insert( to, m_biases.takeAt( from ) );
     if( inModel )
         DynamicModel::instance()->endMoveBias();
 
     Q_EMIT biasMoved( from, to );
     Q_EMIT changed( BiasPtr( this ) );
 }
 
 
 void
 Dynamic::AndBias::resultReceived( const Dynamic::TrackSet &tracks )
 {
     m_tracks.intersect( tracks );
     --m_outstandingMatches;
 
     if( m_outstandingMatches < 0 )
         warning() << "Received more results than expected.";
     else if( m_outstandingMatches == 0 )
         Q_EMIT resultReady( m_tracks );
 }
 
 void
 Dynamic::AndBias::biasReplaced( const Dynamic::BiasPtr &oldBias, const Dynamic::BiasPtr &newBias )
 {
     DEBUG_BLOCK;
     BiasPtr thisPtr( this );
     int index = m_biases.indexOf( oldBias );
     Q_ASSERT( index >= 0 );
 
     disconnect( oldBias.data(), nullptr, this, nullptr );
     bool inModel = DynamicModel::instance()->index( thisPtr ).isValid();
     if( inModel )
         DynamicModel::instance()->beginRemoveBias( thisPtr, index );
     m_biases.removeAt( index );
     if( inModel )
         DynamicModel::instance()->endRemoveBias();
     Q_EMIT biasRemoved( index );
 
     if( newBias )
     {
         connect( newBias.data(), &Dynamic::AbstractBias::resultReady,
                  this, &AndBias::resultReceived );
         connect( newBias.data(), &Dynamic::AbstractBias::replaced,
                  this, &AndBias::biasReplaced );
         connect( newBias.data(), &Dynamic::AbstractBias::changed,
                  this, &AndBias::changed );
 
         if( inModel )
             DynamicModel::instance()->beginInsertBias( thisPtr, index );
         m_biases.insert( index, newBias );
         if( inModel )
             DynamicModel::instance()->endInsertBias();
 
         // we don't have an bias inserted signal
         Q_EMIT biasAppended( newBias );
         Q_EMIT biasMoved( m_biases.count()-1, index );
     }
 
     Q_EMIT changed( thisPtr );
 }
 
 void
 Dynamic::AndBias::biasChanged( const Dynamic::BiasPtr &bias )
 {
     BiasPtr thisPtr( this );
     Q_EMIT changed( thisPtr );
     bool inModel = DynamicModel::instance()->index( thisPtr ).isValid();
     if( inModel )
         DynamicModel::instance()->biasChanged( bias );
 }
 
 // -------- OrBias ------
 
 Dynamic::OrBias::OrBias()
     : AndBias()
 { }
 
 QString
 Dynamic::OrBias::sName()
 {
     return QStringLiteral( "orBias" );
 }
 
 QString
 Dynamic::OrBias::name() const
 {
     return Dynamic::OrBias::sName();
 }
 
 void
 Dynamic::OrBias::paintOperator( QPainter* painter, const QRect& rect, Dynamic::AbstractBias* bias )
 {
     if( m_biases.indexOf( Dynamic::BiasPtr(bias) ) > 0 )
     {
         painter->drawText( rect.adjusted(2, 0, -2, 0),
                            Qt::AlignRight,
                            i18nc("Prefix for OrBias. Shown in front of a bias in the dynamic playlist view", "or" ) );
     }
 }
 
 
 QString
 Dynamic::OrBias::toString() const
 {
     return i18nc("Or bias representation", "Match any");
 }
 
 Dynamic::TrackSet
 Dynamic::OrBias::matchingTracks( const Meta::TrackList& playlist,
                                  int contextCount, int finalCount,
                                  const Dynamic::TrackCollectionPtr &universe ) const
 {
     m_tracks = Dynamic::TrackSet( universe, false );
     m_outstandingMatches = 0;
 
     foreach( Dynamic::BiasPtr bias, m_biases )
     {
         Dynamic::TrackSet tracks = bias->matchingTracks( playlist, contextCount, finalCount, universe );
         if( tracks.isOutstanding() )
             m_outstandingMatches++;
         else
             m_tracks.unite( tracks );
 
         if( m_tracks.isFull() )
             break;
     }
 
     if( m_outstandingMatches > 0 )
         return Dynamic::TrackSet();
     else
         return m_tracks;
 }
 
 bool
 Dynamic::OrBias::trackMatches( int position,
                                const Meta::TrackList& playlist,
                                int contextCount ) const
 {
     foreach( Dynamic::BiasPtr bias, m_biases )
     {
         if( bias->trackMatches( position, playlist, contextCount ) )
             return true;
     }
     return false;
 }
 
 void
 Dynamic::OrBias::resultReceived( const Dynamic::TrackSet &tracks )
 {
     m_tracks.unite( tracks );
     --m_outstandingMatches;
 
     if( m_outstandingMatches < 0 )
         warning() << "Received more results than expected.";
     else if( m_outstandingMatches == 0 )
         Q_EMIT resultReady( m_tracks );
 }