00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
#include "kmmanager.h"
00021
#include "kmprinter.h"
00022
#include "kmdbentry.h"
00023
#include "kmfactory.h"
00024
#include "kmvirtualmanager.h"
00025
#include "kmspecialmanager.h"
00026
#include "printerfilter.h"
00027
#include "kprinter.h"
00028
00029
#include <zlib.h>
00030
#include <qfile.h>
00031
#include <kstandarddirs.h>
00032
#include <kconfig.h>
00033
#include <klocale.h>
00034
#include <kdebug.h>
00035
#include <kapplication.h>
00036
#include <klibloader.h>
00037
#include <unistd.h>
00038
00039 KMManager::KMManager(
QObject *parent,
const char *name)
00040 :
QObject(parent,name)
00041 {
00042 m_printers.setAutoDelete(
true);
00043 m_fprinters.setAutoDelete(
false);
00044 m_hasmanagement =
false;
00045 m_printeroperationmask = 0;
00046 m_serveroperationmask = 0;
00047 m_printerfilter =
new PrinterFilter(
this);
00048
00049 m_specialmgr =
new KMSpecialManager(
this);
00050 Q_CHECK_PTR(m_specialmgr);
00051 m_virtualmgr =
new KMVirtualManager(
this);
00052 Q_CHECK_PTR(m_virtualmgr);
00053
00054
00055
00056 m_updatepossible =
true;
00057 }
00058
00059 KMManager::~KMManager()
00060 {
00061 }
00062
00063 KMManager* KMManager::self()
00064 {
00065
return KMFactory::self()->manager();
00066 }
00067
00068
bool KMManager::notImplemented()
00069 {
00070 setErrorMsg(i18n(
"This operation is not implemented."));
00071
return false;
00072 }
00073
00074
bool KMManager::modifyPrinter(KMPrinter *oldp, KMPrinter *newp)
00075 {
00076
if (oldp->printerName() != newp->printerName())
00077 {
00078
00079
00080
00081 DrMain *driver = loadPrinterDriver(oldp,
true);
00082 newp->setDriver(driver);
00083
if (!removePrinter(oldp))
00084
return false;
00085 }
00086
return createPrinter(newp);
00087 }
00088
00089
bool KMManager::createPrinter(KMPrinter*)
00090 {
00091
return notImplemented();
00092 }
00093
00094
bool KMManager::removePrinter(KMPrinter*)
00095 {
00096
return notImplemented();
00097 }
00098
00099
bool KMManager::removePrinter(
const QString& name)
00100 {
00101 KMPrinter *p = findPrinter(name);
00102
return (p ? removePrinter(p) : false);
00103 }
00104
00105
bool KMManager::enablePrinter(KMPrinter*,
bool)
00106 {
00107
return notImplemented();
00108 }
00109
00110
bool KMManager::enablePrinter(
const QString& name,
bool state)
00111 {
00112 KMPrinter *p = findPrinter(name);
00113
return (p ? enablePrinter(p, state) : false);
00114 }
00115
00116
bool KMManager::startPrinter(KMPrinter*,
bool)
00117 {
00118
return notImplemented();
00119 }
00120
00121
bool KMManager::startPrinter(
const QString& name,
bool state)
00122 {
00123 KMPrinter *p = findPrinter(name);
00124
return (p ? startPrinter(p, state) : false);
00125 }
00126
00127
bool KMManager::upPrinter(KMPrinter *p,
bool state)
00128 {
00129
bool result = enablePrinter(p, state);
00130
if (result)
00131 result = startPrinter(p, state);
00132
return result;
00133 }
00134
00135
bool KMManager::completePrinter(KMPrinter*)
00136 {
00137 notImplemented();
00138
return true;
00139 }
00140
00141
bool KMManager::completePrinterShort(KMPrinter *p)
00142 {
00143
return completePrinter(p);
00144 }
00145
00146
bool KMManager::completePrinter(
const QString& name)
00147 {
00148 KMPrinter *p = findPrinter(name);
00149
return (p ? completePrinter(p) : false);
00150 }
00151
00152
bool KMManager::setDefaultPrinter(KMPrinter*)
00153 {
00154
return notImplemented();
00155 }
00156
00157
bool KMManager::setDefaultPrinter(
const QString& name)
00158 {
00159 KMPrinter *p = findPrinter(name);
00160
return (p ? setDefaultPrinter(p) : false);
00161 }
00162
00163
bool KMManager::testPrinter(KMPrinter *prt)
00164 {
00165
00166
QString testpage = testPage();
00167
if (testpage.isEmpty())
00168 {
00169 setErrorMsg(i18n(
"Unable to locate test page."));
00170
return false;
00171 }
00172
KPrinter pr;
00173
bool prExist = (findPrinter(prt->printerName()) != 0), result(
false);
00174 pr.
setPrinterName(prt->printerName());
00175 pr.
setSearchName(prt->name());
00176 pr.
setDocName(
"KDE Print Test");
00177
00178
00179
00180
if (!prExist)
00181 m_printers.append(prt);
00182 result = pr.
printFiles(testpage,
false,
false);
00183
if (!prExist)
00184 m_printers.take(m_printers.count()-1);
00185
return result;
00186
00187 }
00188
00189 KMPrinter* KMManager::findPrinter(
const QString& name)
00190 {
00191
QPtrListIterator<KMPrinter> it(m_printers);
00192
for (;it.current();++it)
00193
if (it.current()->name() == name)
return it.current();
00194
00195
return 0;
00196 }
00197
00198 KMPrinter* KMManager::softDefault()
const
00199
{
00200
QPtrListIterator<KMPrinter> it(m_printers);
00201
for (;it.current();++it)
00202
if (it.current()->isSoftDefault())
return it.current();
00203
return 0;
00204 }
00205
00206 KMPrinter* KMManager::hardDefault()
const
00207
{
00208
QPtrListIterator<KMPrinter> it(m_printers);
00209
for (; it.current();++it)
00210
if (it.current()->isHardDefault())
00211
return it.current();
00212
return 0;
00213 }
00214
00215 KMPrinter* KMManager::defaultPrinter()
00216 {
00217 printerList(
false);
00218 KMPrinter *prt = softDefault();
00219
if (!prt)
00220 prt = hardDefault();
00221
return prt;
00222 }
00223
00224
QPtrList<KMPrinter>* KMManager::printerList(
bool reload)
00225 {
00226 setErrorMsg(QString::null);
00227
00228
00229
if (reload || m_printers.count() == 0)
00230 {
00231
00232 m_printerfilter->update();
00233 m_fprinters.clear();
00234
00235
00236 discardAllPrinters(
true);
00237
00238
00239
00240
if (m_printers.count() == 0)
00241 m_virtualmgr->reset();
00242
00243
00244
if ( m_updatepossible )
00245 listPrinters();
00246
00247
00248 m_specialmgr->refresh();
00249
00250
if ( m_updatepossible )
00251 m_virtualmgr->refresh();
00252
00253
00254
for (uint i=0; i<m_printers.count(); i++)
00255 {
00256 KMPrinter *prt = m_printers.at(i);
00257
if (prt->isDiscarded())
00258 {
00259 m_printers.remove(i);
00260 i--;
00261 }
00262
else if (prt->isSpecial() || m_printerfilter->filter(prt))
00263 m_fprinters.append(prt);
00264 }
00265
00266
00267
00268
00269
if (!softDefault())
00270 {
00271 KMPrinter *defprinter = findPrinter(QString::fromLatin1(getenv(
"PRINTER")));
00272
if (defprinter)
00273 setSoftDefault(defprinter);
00274 }
00275 }
00276
00277
return &m_fprinters;
00278 }
00279
00280
QPtrList<KMPrinter>* KMManager::printerListComplete(
bool reload)
00281 {
00282 printerList(reload);
00283
return &m_printers;
00284 }
00285
00286
void KMManager::listPrinters()
00287 {
00288
00289 }
00290
00291
void KMManager::addPrinter(KMPrinter *p)
00292 {
00293
if (p)
00294 {
00295
if (p->name().isEmpty())
00296
00297
delete p;
00298
else
00299 {
00300 KMPrinter *other = findPrinter(p->name());
00301
if (other)
00302 {
00303 other->copy(*p);
00304
delete p;
00305 }
00306
else
00307 {
00308 p->setDiscarded(
false);
00309 m_printers.inSort(p);
00310 }
00311 }
00312 }
00313 }
00314
00315
QString KMManager::driverDbCreationProgram()
00316 {
00317
return QString::null;
00318 }
00319
00320
QString KMManager::driverDirectory()
00321 {
00322
return QString::null;
00323 }
00324
00325 DrMain* KMManager::loadPrinterDriver(KMPrinter*,
bool)
00326 {
00327
return NULL;
00328 }
00329
00330 DrMain* KMManager::loadDbDriver(KMDBEntry *entry)
00331 {
00332
return loadFileDriver(entry->file);
00333 }
00334
00335 DrMain* KMManager::loadFileDriver(
const QString&)
00336 {
00337
return NULL;
00338 }
00339
00340 DrMain* KMManager::loadDriver(KMPrinter *p,
bool config)
00341 {
00342
if (p->isSpecial())
00343
return m_specialmgr->loadDriver(p);
00344
else
00345
return loadPrinterDriver(p, config);
00346 }
00347
00348
bool KMManager::savePrinterDriver(KMPrinter*,DrMain*)
00349 {
00350
return notImplemented();
00351 }
00352
00353
bool KMManager::uncompressFile(
const QString& filename,
QString& destname)
00354 {
00355
QFile f(filename);
00356
bool result(
true);
00357 destname = QString::null;
00358
if (f.exists() && f.open(IO_ReadOnly))
00359 {
00360
char buf[1024] = {0};
00361 f.readBlock(buf,2);
00362
if ((uchar)(buf[0]) == 037 && (uchar)(buf[1]) == 0213)
00363 {
00364 f.close();
00365 destname = locateLocal(
"tmp",
"kdeprint_") + KApplication::randomString(8);
00366 f.setName(destname);
00367
00368
if (f.open(IO_WriteOnly))
00369 {
00370 gzFile in = gzopen(filename.latin1(),
"r");
00371
int n(0);
00372
while ((n=gzread(in,buf,1024)) > 0)
00373
if (f.writeBlock(buf,n) != n)
00374
break;
00375
if (n != 0) result =
false;
00376 gzclose(in);
00377 f.close();
00378 }
00379 }
00380 }
00381
return result;
00382 }
00383
00384
void KMManager::setHardDefault(KMPrinter *p)
00385 {
00386
QPtrListIterator<KMPrinter> it(m_printers);
00387
for (;it.current();++it)
00388 it.current()->setHardDefault(
false);
00389
if (p) p->setHardDefault(
true);
00390 }
00391
00392
void KMManager::setSoftDefault(KMPrinter *p)
00393 {
00394
QPtrListIterator<KMPrinter> it(m_printers);
00395
for (;it.current();++it)
00396 {
00397 it.current()->setSoftDefault(
false);
00398 it.current()->setOwnSoftDefault(
false);
00399 }
00400
if (p)
00401 {
00402 p->setSoftDefault(
true);
00403 KMPrinter *pp = findPrinter(p->printerName());
00404
if (pp)
00405 pp->setOwnSoftDefault(
true);
00406 }
00407 }
00408
00409
bool KMManager::restartServer()
00410 {
00411
return notImplemented();
00412 }
00413
00414
bool KMManager::configureServer(
QWidget*)
00415 {
00416
return notImplemented();
00417 }
00418
00419
QString KMManager::testPage()
00420 {
00421 KConfig *conf = KMFactory::self()->printConfig();
00422 conf->setGroup(
"General");
00423
QString tpage = conf->readPathEntry(
"TestPage");
00424
if (tpage.isEmpty())
00425 tpage = locate(
"data",
"kdeprint/testprint.ps");
00426
return tpage;
00427 }
00428
00429
void KMManager::discardAllPrinters(
bool on)
00430 {
00431
QPtrListIterator<KMPrinter> it(m_printers);
00432
for (;it.current();++it)
00433
if (!on || !it.current()->isSpecial())
00434 it.current()->setDiscarded(on);
00435 }
00436
00437
bool KMManager::validateDbDriver(KMDBEntry*)
00438 {
00439
return true;
00440 }
00441
00442
bool KMManager::createSpecialPrinter(KMPrinter *p)
00443 {
00444
if (p && p->isSpecial())
00445 {
00446 KMPrinter *old = findPrinter(p->name());
00447
if (old && !old->isSpecial())
00448 {
00449 setErrorMsg(i18n(
"Can't overwrite regular printer with special printer settings."));
00450
return false;
00451 }
00452
00453 addPrinter(p);
00454
return m_specialmgr->savePrinters();
00455 }
00456
return false;
00457 }
00458
00459
bool KMManager::removeSpecialPrinter(KMPrinter *p)
00460 {
00461
if (p && p->isSpecial() && m_printers.findRef(p) != -1)
00462 {
00463 m_printers.removeRef(p);
00464
return m_specialmgr->savePrinters();
00465 }
00466
return false;
00467 }
00468
00469
00470
00471
00472
00473
00474
QStringList KMManager::detectLocalPrinters()
00475 {
00476
QStringList list;
00477
for (
int i=0; i<3; i++)
00478 list << QString::null << QString::fromLatin1(
"parallel:/dev/lp%1").arg(i) << i18n(
"Parallel Port #%1").arg(i+1) << QString::null;
00479
return list;
00480 }
00481
00482
int KMManager::addPrinterWizard(
QWidget *parent)
00483 {
00484 KLibrary *lib = KLibLoader::self()->library(
"libkdeprint_management_module");
00485
if (!lib)
00486 setErrorMsg(i18n(
"Unable to load KDE print management library: %1").arg(KLibLoader::self()->lastErrorMessage()));
00487
else
00488 {
00489 int (*func)(
QWidget*) = (int(*)(
QWidget*))lib->symbol(
"add_printer_wizard");
00490
if (!func)
00491 setErrorMsg(i18n(
"Unable to find wizard object in management library."));
00492
else
00493
return func(parent);
00494 }
00495
return (-1);
00496 }
00497
00498
bool KMManager::invokeOptionsDialog(
QWidget *parent)
00499 {
00500 KLibrary *lib = KLibLoader::self()->library(
"libkdeprint_management_module");
00501
if (!lib)
00502 setErrorMsg(i18n(
"Unable to load KDE print management library: %1").arg(KLibLoader::self()->lastErrorMessage()));
00503
else
00504 {
00505 bool (*func)(
QWidget*) = (bool(*)(
QWidget*))lib->symbol(
"config_dialog");
00506
if (!func)
00507 setErrorMsg(i18n(
"Unable to find options dialog in management library."));
00508
else
00509
return func(parent);
00510 }
00511
return false;
00512 }
00513
00514
void KMManager::createPluginActions(KActionCollection*)
00515 {
00516 }
00517
00518
void KMManager::validatePluginActions(KActionCollection*, KMPrinter*)
00519 {
00520 }
00521
00522
void KMManager::enableFilter(
bool on)
00523 {
00524 m_printerfilter->setEnabled(on);
00525 }
00526
00527
bool KMManager::isFilterEnabled()
const
00528
{
00529
return m_printerfilter->isEnabled();
00530 }
00531
00532
QString KMManager::stateInformation()
00533 {
00534
return i18n(
"No plugin information available");
00535 }
00536
00537
void KMManager::checkUpdatePossible()
00538 {
00539 m_updatepossible =
false;
00540 checkUpdatePossibleInternal();
00541 }
00542
00543
void KMManager::checkUpdatePossibleInternal()
00544 {
00545 setUpdatePossible(
true );
00546 }
00547
00548
void KMManager::setUpdatePossible(
bool value )
00549 {
00550
if ( value != m_updatepossible )
00551 m_virtualmgr->reset();
00552 m_updatepossible = value;
00553 emit updatePossible( m_updatepossible );
00554 }
00555
00556
#include "kmmanager.moc"