← Back to branch summary

~ubuntu-branches/ubuntu/natty/mixxx/natty

« back to all changes in this revision

Viewing changes to src/engine/engineworkerscheduler.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2010-10-19 10:25:05 UTC
  • mfrom: (1.6.1 upstream) (1.1.11 experimental)
  • Revision ID: james.westby@ubuntu.com-20101019102505-kmq8cbo5qqwj3g29
Tags: 1.8.1-1ubuntu1
* Merge with Debian experimental, Ubuntu remaining changes:
  - Add libqtwebkit-dev to the Build-Depends field.
  - Depends on pulseaudio-utils.
  - Skip 91-desktop_file.patch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/engine/engineworkerscheduler.cpp
9
9
 
10
10
EngineWorkerScheduler::EngineWorkerScheduler(QObject* pParent)
11
11
        : QThreadPool(pParent) {
12
 
 
13
 
    connect(&m_readyMapper, SIGNAL(mapped(QObject*)),
14
 
            this, SLOT(workerReady(QObject*)));
15
 
    connect(&m_startedMapper, SIGNAL(mapped(QObject*)),
16
 
            this, SLOT(workerStarted(QObject*)));
17
 
    connect(&m_finishedMapper, SIGNAL(mapped(QObject*)),
18
 
            this, SLOT(workerFinished(QObject*)));
19
12
}
20
13
 
21
14
EngineWorkerScheduler::~EngineWorkerScheduler() {
23
16
}
24
17
 
25
18
void EngineWorkerScheduler::bindWorker(EngineWorker* pWorker) {
26
 
    m_readyMapper.setMapping(pWorker, pWorker);
27
 
    m_startedMapper.setMapping(pWorker, pWorker);
28
 
    m_finishedMapper.setMapping(pWorker, pWorker);
29
 
 
30
 
    connect(pWorker, SIGNAL(workReady()),
31
 
            &m_readyMapper, SLOT(map()));
32
 
    connect(pWorker, SIGNAL(workStarting()),
33
 
            &m_startedMapper, SLOT(map()));
34
 
    connect(pWorker, SIGNAL(workDone()),
35
 
            &m_finishedMapper, SLOT(map()));
36
 
}
37
 
 
38
 
void EngineWorkerScheduler::workerReady(QObject* pObject) {
39
 
    EngineWorker* pWorker = dynamic_cast<EngineWorker*>(pObject);
40
 
    Q_ASSERT(pWorker);
41
 
    QMutexLocker locker(&m_mutex);
42
 
    m_scheduledWorkers.insert(pWorker);
43
 
}
44
 
 
45
 
void EngineWorkerScheduler::workerStarted(QObject* pObject) {
46
 
    EngineWorker* pWorker = dynamic_cast<EngineWorker*>(pObject);
47
 
    Q_ASSERT(pWorker);
48
 
    QMutexLocker locker(&m_mutex);
49
 
    m_activeWorkers.insert(pWorker);
50
 
}
51
 
 
52
 
void EngineWorkerScheduler::workerFinished(QObject* pObject) {
53
 
    EngineWorker* pWorker = dynamic_cast<EngineWorker*>(pObject);
54
 
    Q_ASSERT(pWorker);
55
 
    QMutexLocker locker(&m_mutex);
56
 
    m_activeWorkers.remove(pWorker);
 
19
    connect(pWorker, SIGNAL(workReady(EngineWorker*)),
 
20
            this, SLOT(workerReady(EngineWorker*)),
 
21
            Qt::DirectConnection);
 
22
    connect(pWorker, SIGNAL(workStarting(EngineWorker*)),
 
23
            this, SLOT(workerStarted(EngineWorker*)),
 
24
            Qt::DirectConnection);
 
25
    connect(pWorker, SIGNAL(workDone(EngineWorker*)),
 
26
            this, SLOT(workerFinished(EngineWorker*)),
 
27
            Qt::DirectConnection);
 
28
}
 
29
 
 
30
void EngineWorkerScheduler::workerReady(EngineWorker* pWorker) {
 
31
    if (pWorker) {
 
32
        QMutexLocker locker(&m_mutex);
 
33
        m_scheduledWorkers.insert(pWorker);
 
34
    }
 
35
}
 
36
 
 
37
void EngineWorkerScheduler::workerStarted(EngineWorker* pWorker) {
 
38
}
 
39
 
 
40
void EngineWorkerScheduler::workerFinished(EngineWorker* pWorker) {
57
41
}
58
42
 
59
43