kmmanager.cpp00001
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"
|