00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
#include "kmjobmanager.h"
00021
#include "kmjob.h"
00022
#include "kmthreadjob.h"
00023
#include "kmfactory.h"
00024
00025
#include <kaction.h>
00026
#include <kdebug.h>
00027
#include <kconfig.h>
00028
00029 KMJobManager::KMJobManager(
QObject *parent,
const char *name)
00030 :
QObject(parent,name)
00031 {
00032 m_jobs.setAutoDelete(
true);
00033 m_threadjob =
new KMThreadJob(
this,
"ThreadJob");
00034 m_filter.setAutoDelete(
true);
00035 }
00036
00037 KMJobManager::~KMJobManager()
00038 {
00039 }
00040
00041 KMJobManager* KMJobManager::self()
00042 {
00043
return KMFactory::self()->jobManager();
00044 }
00045
00046
void KMJobManager::discardAllJobs()
00047 {
00048
QPtrListIterator<KMJob> it(m_jobs);
00049
for (;it.current();++it)
00050 it.current()->setDiscarded(
true);
00051 }
00052
00053
void KMJobManager::removeDiscardedJobs()
00054 {
00055
for (uint i=0;i<m_jobs.count();i++)
00056
if (m_jobs.at(i)->isDiscarded())
00057 {
00058 m_jobs.remove(i);
00059 i--;
00060 }
00061 }
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072 KMJob* KMJobManager::findJob(
const QString& uri)
00073 {
00074
QPtrListIterator<KMJob> it(m_jobs);
00075
for (;it.current();++it)
00076
if (it.current()->uri() == uri)
00077
return it.current();
00078
return 0;
00079 }
00080
00081
void KMJobManager::addJob(KMJob *job)
00082 {
00083
00084
if (!job->uri().isEmpty() && !job->printer().isEmpty())
00085 {
00086 KMJob *aJob = findJob(job->uri());
00087
if (aJob)
00088 {
00089 aJob->copy(*job);
00090
delete job;
00091 }
00092
else
00093 {
00094 job->setDiscarded(
false);
00095 m_jobs.append(job);
00096 }
00097 }
00098
else
00099
delete job;
00100 }
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
bool KMJobManager::sendCommand(
const QString& uri,
int action,
const QString& arg)
00116 {
00117 KMJob *job = findJob(uri);
00118
if (job)
00119 {
00120
QPtrList<KMJob> l;
00121 l.setAutoDelete(
false);
00122 l.append(job);
00123
return sendCommand(l,action,arg);
00124 }
00125
return false;
00126 }
00127
00128
bool KMJobManager::sendCommand(
const QPtrList<KMJob>& jobs,
int action,
const QString& args)
00129 {
00130
00131
QPtrList<KMJob> csystem, cthread;
00132 csystem.setAutoDelete(
false);
00133 cthread.setAutoDelete(
false);
00134
QPtrListIterator<KMJob> it(jobs);
00135
for (;it.current();++it)
00136
if (it.current()->type() == KMJob::Threaded) cthread.append(it.current());
00137
else csystem.append(it.current());
00138
00139
00140
if (cthread.count() > 0 && !sendCommandThreadJob(cthread, action, args))
00141
return false;
00142
if (csystem.count() > 0 && !sendCommandSystemJob(csystem, action, args))
00143
return false;
00144
return true;
00145 }
00146
00147
bool KMJobManager::sendCommandSystemJob(
const QPtrList<KMJob>&,
int,
const QString&)
00148 {
00149
return false;
00150 }
00151
00152
bool KMJobManager::sendCommandThreadJob(
const QPtrList<KMJob>& jobs,
int action,
const QString&)
00153 {
00154
if (action != KMJob::Remove)
00155
return false;
00156
00157
QPtrListIterator<KMJob> it(jobs);
00158
bool result(
true);
00159
for (;it.current() && result; ++it)
00160 result = m_threadjob->removeJob(it.current()->id());
00161
return result;
00162 }
00163
00164
bool KMJobManager::listJobs(
const QString&, KMJobManager::JobType,
int)
00165 {
00166
return true;
00167 }
00168
00169
const QPtrList<KMJob>& KMJobManager::jobList(
bool reload)
00170 {
00171
if (reload || m_jobs.count() == 0)
00172 {
00173 discardAllJobs();
00174
QDictIterator<JobFilter> it(m_filter);
00175
int joblimit = limit();
00176
bool threadjobs_updated =
false;
00177
for (; it.current(); ++it)
00178 {
00179
if ( it.current()->m_isspecial )
00180 {
00181
if ( !threadjobs_updated )
00182 {
00183 threadJob()->updateManager(
this );
00184 threadjobs_updated =
true;
00185 }
00186 }
00187
else
00188 {
00189
if (it.current()->m_type[ActiveJobs] > 0)
00190 listJobs(it.currentKey(), ActiveJobs, joblimit);
00191
if (it.current()->m_type[CompletedJobs] > 0)
00192 listJobs(it.currentKey(), CompletedJobs, joblimit);
00193 }
00194 }
00195 m_threadjob->updateManager(
this);
00196 removeDiscardedJobs();
00197 }
00198
return m_jobs;
00199 }
00200
00201
int KMJobManager::actions()
00202 {
00203
return 0;
00204 }
00205
00206
QValueList<KAction*> KMJobManager::createPluginActions(KActionCollection*)
00207 {
00208
return QValueList<KAction*>();
00209 }
00210
00211
void KMJobManager::validatePluginActions(KActionCollection*,
const QPtrList<KMJob>&)
00212 {
00213 }
00214
00215
void KMJobManager::addPrinter(
const QString& pr, KMJobManager::JobType type,
bool isSpecial)
00216 {
00217
struct JobFilter *jf = m_filter.find(pr);
00218
if (!jf)
00219 {
00220 jf =
new JobFilter;
00221 m_filter.insert(pr, jf);
00222 }
00223 jf->m_type[type]++;
00224 jf->m_isspecial = isSpecial;
00225 }
00226
00227
void KMJobManager::removePrinter(
const QString& pr, KMJobManager::JobType type)
00228 {
00229
struct JobFilter *jf = m_filter.find(pr);
00230
if (jf)
00231 {
00232 jf->m_type[type] = QMAX(0, jf->m_type[type]-1);
00233
if (!jf->m_type[0] && !jf->m_type[1])
00234 m_filter.remove(pr);
00235 }
00236 }
00237
00238
bool KMJobManager::doPluginAction(
int,
const QPtrList<KMJob>&)
00239 {
00240
return true;
00241 }
00242
00243
void KMJobManager::setLimit(
int val)
00244 {
00245 KConfig *conf = KMFactory::self()->printConfig();
00246 conf->setGroup(
"Jobs");
00247 conf->writeEntry(
"Limit", val);
00248 }
00249
00250
int KMJobManager::limit()
00251 {
00252 KConfig *conf = KMFactory::self()->printConfig();
00253 conf->setGroup(
"Jobs");
00254
return conf->readNumEntry(
"Limit", 0);
00255 }
00256
00257
#include "kmjobmanager.moc"