runtime/nepomuk/services/queryservice/folder.cpp

   1 /*
   2    Copyright (c) 2008 Sebastian Trueg <trueg@kde.org>
   3
   4    This library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Library General Public
   6    License version 2 as published by the Free Software Foundation.
   7
   8    This library is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11    Library General Public License for more details.
  12
  13    You should have received a copy of the GNU Library General Public License
  14    along with this library; see the file COPYING.LIB.  If not, write to
  15    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  16    Boston, MA 02110-1301, USA.
  17 */
  18
  19 #include "folder.h"
  20 #include "folderconnection.h"
  21 #include "queryservice.h"
  22 #include "qurlhash.h"
  23
  24 #include <Soprano/Model>
  25
  26 #include <KDebug>
  27
  28
  29 Nepomuk::Search::Folder::Folder( const Query& query, QObject* parent )
  30     : QObject( parent ),
  31       m_query( query ),
  32       m_initialListingDone( false ),
  33       m_storageChanged( false )
  34 {
  35     m_updateTimer.setSingleShot( true );
  36     m_updateTimer.setInterval( 2000 );
  37
  38     m_searchCore = new SearchCore( this );
  39
  40     connect( m_searchCore, SIGNAL( newResult( const Nepomuk::Search::Result& ) ),
  41              this, SLOT( slotSearchNewResult( const Nepomuk::Search::Result& ) ) );
  42     connect( m_searchCore, SIGNAL( scoreChanged( const Nepomuk::Search::Result& ) ),
  43              this, SLOT( slotSearchScoreChanged( const Nepomuk::Search::Result& ) ) );
  44     connect( m_searchCore, SIGNAL( finished() ),
  45              this, SLOT( slotSearchFinished() ) );
  46     connect( QueryService::instance()->mainModel(), SIGNAL( statementsAdded() ),
  47              this, SLOT( slotStorageChanged() ) );
  48     connect( QueryService::instance()->mainModel(), SIGNAL( statementsRemoved() ),
  49              this, SLOT( slotStorageChanged() ) );
  50     connect( &m_updateTimer, SIGNAL( timeout() ),
  51              this, SLOT( slotUpdateTimeout() ) );
  52 }
  53
  54
  55 Nepomuk::Search::Folder::~Folder()
  56 {
  57 }
  58
  59
  60 void Nepomuk::Search::Folder::update()
  61 {
  62     if ( !m_searchCore->isActive() ) {
  63         // run the search and forward signals to all connections that requested it
  64         m_searchCore->query( m_query );
  65     }
  66 }
  67
  68
  69 QList<Nepomuk::Search::Result> Nepomuk::Search::Folder::entries() const
  70 {
  71     return m_results.values();
  72 }
  73
  74
  75 bool Nepomuk::Search::Folder::initialListingDone() const
  76 {
  77     return m_initialListingDone;
  78 }
  79
  80
  81 void Nepomuk::Search::Folder::slotSearchNewResult( const Nepomuk::Search::Result& result )
  82 {
  83     if ( m_initialListingDone ) {
  84         m_newResults.insert( result.resourceUri(), result );
  85         if ( !m_results.contains( result.resourceUri() ) ) {
  86             emit newEntries( QList<Result>() << result );
  87         }
  88     }
  89     else {
  90         m_results.insert( result.resourceUri(), result );
  91         emit newEntries( QList<Result>() << result );
  92     }
  93 }
  94
  95
  96 void Nepomuk::Search::Folder::slotSearchScoreChanged( const Nepomuk::Search::Result& )
  97 {
  98     if ( m_initialListingDone ) {
  99 #warning FIXME: handle scoreChanged
 100     }
 101     else {
 102
 103     }
 104 }
 105
 106
 107 void Nepomuk::Search::Folder::slotSearchFinished()
 108 {
 109     if ( m_initialListingDone ) {
 110         // inform about removed items
 111         foreach( const Result& result, m_results ) {
 112             if ( !m_newResults.contains( result.resourceUri() ) ) {
 113                 emit entriesRemoved( QList<QUrl>() << result.resourceUri() );
 114             }
 115         }
 116
 117         // reset
 118         m_results = m_newResults;
 119         m_newResults.clear();
 120     }
 121     else {
 122         m_initialListingDone = true;
 123         emit finishedListing();
 124     }
 125
 126     // make sure we do not update again right away
 127     m_updateTimer.start();
 128 }
 129
 130
 131 void Nepomuk::Search::Folder::slotStorageChanged()
 132 {
 133     if ( !m_updateTimer.isActive() && !m_searchCore->isActive() ) {
 134         update();
 135     }
 136     else {
 137         m_storageChanged = true;
 138     }
 139 }
 140
 141
 142 // if there was a change in the nepomuk store we update
 143 void Nepomuk::Search::Folder::slotUpdateTimeout()
 144 {
 145     if ( m_storageChanged && !m_searchCore->isActive() ) {
 146         m_storageChanged = false;
 147         update();
 148     }
 149 }
 150
 151
 152 void Nepomuk::Search::Folder::addConnection( FolderConnection* conn )
 153 {
 154     Q_ASSERT( conn != 0 );
 155     Q_ASSERT( !m_connections.contains( conn ) );
 156
 157     m_connections.append( conn );
 158 }
 159
 160
 161 void Nepomuk::Search::Folder::removeConnection( FolderConnection* conn )
 162 {
 163     Q_ASSERT( conn != 0 );
 164     Q_ASSERT( m_connections.contains( conn ) );
 165
 166     m_connections.removeAll( conn );
 167
 168     if ( m_connections.isEmpty() ) {
 169         kDebug() << "Folder unused. Deleting.";
 170         deleteLater();
 171     }
 172 }
 173
 174
 175 QList<Nepomuk::Search::FolderConnection*> Nepomuk::Search::Folder::openConnections() const
 176 {
 177     return m_connections;
 178 }
 179
 180 #include "folder.moc"