• Skip to content
  • Skip to link menu
Trinity API Reference
  • Trinity API Reference
  • tdeprint
 

tdeprint

  • tdeprint
kmmanager.cpp
1 /*
2  * This file is part of the KDE libraries
3  * Copyright (c) 2001 Michael Goffioul <tdeprint@swing.be>
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License version 2 as published by the Free Software Foundation.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public License
15  * along with this library; see the file COPYING.LIB. If not, write to
16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  * Boston, MA 02110-1301, USA.
18  **/
19 
20 #include "kmmanager.h"
21 #include "kmprinter.h"
22 #include "kmdbentry.h"
23 #include "kmfactory.h"
24 #include "kmvirtualmanager.h"
25 #include "kmspecialmanager.h"
26 #include "printerfilter.h"
27 #include "kprinter.h"
28 
29 #include <zlib.h>
30 #include <tqfile.h>
31 #include <kstandarddirs.h>
32 #include <tdeconfig.h>
33 #include <tdelocale.h>
34 #include <kdebug.h>
35 #include <tdeapplication.h>
36 #include <klibloader.h>
37 #include <unistd.h>
38 
39 KMManager::KMManager(TQObject *parent, const char *name)
40 : TQObject(parent,name)
41 {
42  m_printers.setAutoDelete(true);
43  m_fprinters.setAutoDelete(false);
44  m_hasmanagement = false;
45  m_printeroperationmask = 0;
46  m_serveroperationmask = 0;
47  m_printerfilter = new PrinterFilter(this);
48 
49  m_specialmgr = new KMSpecialManager(this);
50  TQ_CHECK_PTR(m_specialmgr);
51  m_virtualmgr = new KMVirtualManager(this);
52  TQ_CHECK_PTR(m_virtualmgr);
53 
54  // set default to true to not disturb code that
55  // hasn't been adapted yet. Otherwise, should be false
56  m_updatepossible = true;
57 }
58 
59 KMManager::~KMManager()
60 {
61 }
62 
63 KMManager* KMManager::self()
64 {
65  return KMFactory::self()->manager();
66 }
67 
68 bool KMManager::notImplemented()
69 {
70  setErrorMsg(i18n("This operation is not implemented."));
71  return false;
72 }
73 
74 bool KMManager::modifyPrinter(KMPrinter *oldp, KMPrinter *newp)
75 {
76  if (oldp->printerName() != newp->printerName())
77  {
78  // remove the old one, then create the new one. But before removing
79  // the old one, retrieve its driver so that the new printer has the
80  // same.
81  DrMain *driver = loadPrinterDriver(oldp, true);
82  newp->setDriver(driver);
83  if (!removePrinter(oldp))
84  return false;
85  }
86  return createPrinter(newp);
87 }
88 
89 bool KMManager::createPrinter(KMPrinter*)
90 {
91  return notImplemented();
92 }
93 
94 bool KMManager::removePrinter(KMPrinter*)
95 {
96  return notImplemented();
97 }
98 
99 bool KMManager::removePrinter(const TQString& name)
100 {
101  KMPrinter *p = findPrinter(name);
102  return (p ? removePrinter(p) : false);
103 }
104 
105 bool KMManager::enablePrinter(KMPrinter*, bool)
106 {
107  return notImplemented();
108 }
109 
110 bool KMManager::enablePrinter(const TQString& name, bool state)
111 {
112  KMPrinter *p = findPrinter(name);
113  return (p ? enablePrinter(p, state) : false);
114 }
115 
116 bool KMManager::startPrinter(KMPrinter*, bool)
117 {
118  return notImplemented();
119 }
120 
121 bool KMManager::startPrinter(const TQString& name, bool state)
122 {
123  KMPrinter *p = findPrinter(name);
124  return (p ? startPrinter(p, state) : false);
125 }
126 
127 bool KMManager::upPrinter(KMPrinter *p, bool state)
128 {
129  bool result = enablePrinter(p, state);
130  if (result)
131  result = startPrinter(p, state);
132  return result;
133 }
134 
135 bool KMManager::completePrinter(KMPrinter*)
136 {
137  notImplemented();
138  return true; // not false to allow instance config/creation
139 }
140 
141 bool KMManager::completePrinterShort(KMPrinter *p)
142 {
143  return completePrinter(p);
144 }
145 
146 bool KMManager::completePrinter(const TQString& name)
147 {
148  KMPrinter *p = findPrinter(name);
149  return (p ? completePrinter(p) : false);
150 }
151 
152 bool KMManager::setDefaultPrinter(KMPrinter*)
153 {
154  return notImplemented();
155 }
156 
157 bool KMManager::setDefaultPrinter(const TQString& name)
158 {
159  KMPrinter *p = findPrinter(name);
160  return (p ? setDefaultPrinter(p) : false);
161 }
162 
163 bool KMManager::testPrinter(KMPrinter *prt)
164 {
165  // standard Test mechanism
166  TQString testpage = testPage();
167  if (testpage.isEmpty())
168  {
169  setErrorMsg(i18n("Unable to locate test page."));
170  return false;
171  }
172  KPrinter pr;
173  bool prExist = (findPrinter(prt->printerName()) != 0), result(false);
174  pr.setPrinterName(prt->printerName());
175  pr.setSearchName(prt->name());
176  pr.setDocName("TDE Print Test");
177  // the printing mechanism may involve some needed operations on the
178  // printer, so temporary printers (created when testing) should be
179  // temporarily added to the printer list, then taken out.
180  if (!prExist)
181  m_printers.append(prt);
182  result = pr.printFiles(testpage, false, false);
183  if (!prExist)
184  m_printers.take(m_printers.count()-1);
185  return result;
186  // return notImplemented();
187 }
188 
189 KMPrinter* KMManager::findPrinter(const TQString& name)
190 {
191  TQPtrListIterator<KMPrinter> it(m_printers);
192  for (;it.current();++it)
193  if (it.current()->name() == name) return it.current();
194  //setErrorMsg(i18n("%1: printer not found.").arg(name));
195  return 0;
196 }
197 
198 KMPrinter* KMManager::softDefault() const
199 {
200  TQPtrListIterator<KMPrinter> it(m_printers);
201  for (;it.current();++it)
202  if (it.current()->isSoftDefault()) return it.current();
203  return 0;
204 }
205 
206 KMPrinter* KMManager::hardDefault() const
207 {
208  TQPtrListIterator<KMPrinter> it(m_printers);
209  for (; it.current();++it)
210  if (it.current()->isHardDefault())
211  return it.current();
212  return 0;
213 }
214 
215 KMPrinter* KMManager::defaultPrinter()
216 {
217  printerList(false);
218  KMPrinter *prt = softDefault();
219  if (!prt)
220  prt = hardDefault();
221  return prt;
222 }
223 
224 TQPtrList<KMPrinter>* KMManager::printerList(bool reload)
225 {
226  setErrorMsg(TQString::null);
227  //kdDebug(500) << "Getting printer list: " << reload << endl;
228 
229  if (reload || m_printers.count() == 0)
230  {
231  // reset filter
232  m_printerfilter->update();
233  m_fprinters.clear();
234 
235  // first discard all printers
236  discardAllPrinters(true);
237 
238  // make sure virtual printers will be reloaded if we don't have
239  // any printer (for example if settings are wrong)
240  if (m_printers.count() == 0)
241  m_virtualmgr->reset();
242 
243  // List real printers (in subclasses)
244  if ( m_updatepossible )
245  listPrinters();
246  // Listing of special printers has to be done before the instances
247  // because now special printers can also have instances
248  m_specialmgr->refresh();
249  // list virtual printers (and undiscard virtual printers if necessary)
250  if ( m_updatepossible )
251  m_virtualmgr->refresh();
252 
253  // remove discarded printers
254  for (uint i=0; i<m_printers.count(); i++)
255  {
256  KMPrinter *prt = m_printers.at(i);
257  if (prt->isDiscarded())
258  {
259  m_printers.remove(i);
260  i--;
261  }
262  else if (prt->isSpecial() || m_printerfilter->filter(prt))
263  m_fprinters.append(prt);
264  }
265 
266  // try to find the default printer from these situations:
267  // - it already exists from .lpoptions file
268  // - use the PRINTER variable
269  if (!softDefault())
270  {
271  KMPrinter *defprinter = findPrinter(TQString::fromLatin1(getenv("PRINTER")));
272  if (defprinter)
273  setSoftDefault(defprinter);
274  }
275  emit printerListUpdated();
276  }
277 
278  return &m_fprinters;
279 }
280 
281 TQPtrList<KMPrinter>* KMManager::printerListComplete(bool reload)
282 {
283  printerList(reload);
284  return &m_printers;
285 }
286 
287 void KMManager::listPrinters()
288 {
289  // do nothing
290 }
291 
292 void KMManager::addPrinter(KMPrinter *p)
293 {
294  if (p)
295  {
296  if (p->name().isEmpty())
297  // discard printer with empty name
298  delete p;
299  else
300  {
301  KMPrinter *other = findPrinter(p->name());
302  if (other)
303  {
304  other->copy(*p);
305  delete p;
306  }
307  else
308  {
309  p->setDiscarded(false);
310  m_printers.inSort(p);
311  }
312  }
313  }
314 }
315 
316 TQString KMManager::driverDbCreationProgram()
317 {
318  return TQString::null;
319 }
320 
321 TQString KMManager::driverDirectory()
322 {
323  return TQString::null;
324 }
325 
326 DrMain* KMManager::loadPrinterDriver(KMPrinter*, bool)
327 {
328  return NULL;
329 }
330 
331 DrMain* KMManager::loadDbDriver(KMDBEntry *entry)
332 {
333  return loadFileDriver(entry->file);
334 }
335 
336 DrMain* KMManager::loadFileDriver(const TQString&)
337 {
338  return NULL;
339 }
340 
341 DrMain* KMManager::loadDriver(KMPrinter *p, bool config)
342 {
343  if (p->isSpecial())
344  return m_specialmgr->loadDriver(p);
345  else
346  return loadPrinterDriver(p, config);
347 }
348 
349 bool KMManager::savePrinterDriver(KMPrinter*,DrMain*)
350 {
351  return notImplemented();
352 }
353 
354 bool KMManager::uncompressFile(const TQString& filename, TQString& destname)
355 {
356  TQFile f(filename);
357  bool result(true);
358  destname = TQString::null;
359  if (f.exists() && f.open(IO_ReadOnly))
360  {
361  char buf[1024] = {0};
362  f.readBlock(buf,2);
363  if ((uchar)(buf[0]) == 037 && (uchar)(buf[1]) == 0213)
364  {
365  f.close();
366  destname = locateLocal("tmp","tdeprint_") + TDEApplication::randomString(8);
367  f.setName(destname);
368 
369  if (f.open(IO_WriteOnly))
370  {
371  gzFile in = gzopen(filename.latin1(),"r");
372  int n(0);
373  while ((n=gzread(in,buf,1024)) > 0)
374  if (f.writeBlock(buf,n) != n)
375  break;
376  if (n != 0) result = false;
377  gzclose(in);
378  f.close();
379  }
380  }
381  }
382  return result;
383 }
384 
385 void KMManager::setHardDefault(KMPrinter *p)
386 {
387  TQPtrListIterator<KMPrinter> it(m_printers);
388  for (;it.current();++it)
389  it.current()->setHardDefault(false);
390  if (p) p->setHardDefault(true);
391 }
392 
393 void KMManager::setSoftDefault(KMPrinter *p)
394 {
395  TQPtrListIterator<KMPrinter> it(m_printers);
396  for (;it.current();++it)
397  {
398  it.current()->setSoftDefault(false);
399  it.current()->setOwnSoftDefault(false);
400  }
401  if (p)
402  {
403  p->setSoftDefault(true);
404  KMPrinter *pp = findPrinter(p->printerName());
405  if (pp)
406  pp->setOwnSoftDefault(true);
407  }
408 }
409 
410 bool KMManager::restartServer()
411 {
412  return notImplemented();
413 }
414 
415 bool KMManager::configureServer(TQWidget*)
416 {
417  return notImplemented();
418 }
419 
420 TQString KMManager::testPage()
421 {
422  TDEConfig *conf = KMFactory::self()->printConfig();
423  conf->setGroup("General");
424  TQString tpage = conf->readPathEntry("TestPage");
425  if (tpage.isEmpty())
426  tpage = locate("data","tdeprint/testprint.ps");
427  return tpage;
428 }
429 
430 void KMManager::discardAllPrinters(bool on)
431 {
432  TQPtrListIterator<KMPrinter> it(m_printers);
433  for (;it.current();++it)
434  if (!on || !it.current()->isSpecial())
435  it.current()->setDiscarded(on);
436 }
437 
438 bool KMManager::validateDbDriver(KMDBEntry*)
439 {
440  return true;
441 }
442 
443 bool KMManager::createSpecialPrinter(KMPrinter *p)
444 {
445  if (p && p->isSpecial())
446  {
447  KMPrinter *old = findPrinter(p->name());
448  if (old && !old->isSpecial())
449  {
450  setErrorMsg(i18n("Can't overwrite regular printer with special printer settings."));
451  return false;
452  }
453  // if the special printer already exists, it will be overwritten
454  addPrinter(p);
455  return m_specialmgr->savePrinters();
456  }
457  return false;
458 }
459 
460 bool KMManager::removeSpecialPrinter(KMPrinter *p)
461 {
462  if (p && p->isSpecial() && m_printers.findRef(p) != -1)
463  {
464  m_printers.removeRef(p);
465  return m_specialmgr->savePrinters();
466  }
467  return false;
468 }
469 
470 /* format of output:
471  Class0, URI0, Desc0, Printer0, Class1, URI1, Desc1, Printer1, ...
472 
473  Defaults to 3 parallel printers
474 */
475 TQStringList KMManager::detectLocalPrinters()
476 {
477  TQStringList list;
478  for (int i=0; i<3; i++)
479  list << TQString() << TQString::fromLatin1("parallel:/dev/lp%1").arg(i) << i18n("Parallel Port #%1").arg(i+1) << TQString();
480  return list;
481 }
482 
483 int KMManager::addPrinterWizard(TQWidget *parent)
484 {
485  KLibrary *lib = KLibLoader::self()->library("libtdeprint_management_module");
486  if (!lib)
487  setErrorMsg(i18n("Unable to load TDE print management library: %1").arg(KLibLoader::self()->lastErrorMessage()));
488  else
489  {
490  int (*func)(TQWidget*) = (int(*)(TQWidget*))lib->symbol("add_printer_wizard");
491  if (!func)
492  setErrorMsg(i18n("Unable to find wizard object in management library."));
493  else
494  return func(parent);
495  }
496  return (-1);
497 }
498 
499 bool KMManager::invokeOptionsDialog(TQWidget *parent)
500 {
501  KLibrary *lib = KLibLoader::self()->library("libtdeprint_management_module");
502  if (!lib)
503  setErrorMsg(i18n("Unable to load TDE print management library: %1").arg(KLibLoader::self()->lastErrorMessage()));
504  else
505  {
506  bool (*func)(TQWidget*) = (bool(*)(TQWidget*))lib->symbol("config_dialog");
507  if (!func)
508  setErrorMsg(i18n("Unable to find options dialog in management library."));
509  else
510  return func(parent);
511  }
512  return false;
513 }
514 
515 void KMManager::createPluginActions(TDEActionCollection*)
516 {
517 }
518 
519 void KMManager::validatePluginActions(TDEActionCollection*, KMPrinter*)
520 {
521 }
522 
523 void KMManager::enableFilter(bool on)
524 {
525  m_printerfilter->setEnabled(on);
526 }
527 
528 bool KMManager::isFilterEnabled() const
529 {
530  return m_printerfilter->isEnabled();
531 }
532 
533 TQString KMManager::stateInformation()
534 {
535  return i18n("No plugin information available");
536 }
537 
538 void KMManager::checkUpdatePossible()
539 {
540  m_updatepossible = false;
541  checkUpdatePossibleInternal();
542 }
543 
544 void KMManager::checkUpdatePossibleInternal()
545 {
546  setUpdatePossible( true );
547 }
548 
549 void KMManager::setUpdatePossible( bool value )
550 {
551  if ( value != m_updatepossible )
552  m_virtualmgr->reset();
553  m_updatepossible = value;
554  emit updatePossible( m_updatepossible );
555 }
556 
557 #include "kmmanager.moc"
KPrinter
This class is the main interface to access the TDE print framework.
Definition: kprinter.h:89
KPrinter::setPrinterName
void setPrinterName(const TQString &)
See TQPrinter::setPrinterName().
Definition: kprinter.cpp:873
KPrinter::printFiles
bool printFiles(const TQStringList &files, bool removeafter=false, bool startviewer=true)
Prints the files given in argument.
Definition: kprinter.cpp:358
KPrinter::setDocName
void setDocName(const TQString &)
See TQPrinter::setDocName().
Definition: kprinter.cpp:800
KPrinter::setSearchName
void setSearchName(const TQString &n)
Sets the search name of the KPrinter object.
Definition: kprinter.cpp:909

tdeprint

Skip menu "tdeprint"
  • Main Page
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Class Members
  • Related Pages

tdeprint

Skip menu "tdeprint"
  • arts
  • dcop
  • dnssd
  • interfaces
  •   kspeech
  •     interface
  •     library
  •   tdetexteditor
  • kate
  • kded
  • kdoctools
  • kimgio
  • kjs
  • libtdemid
  • libtdescreensaver
  • tdeabc
  • tdecmshell
  • tdecore
  • tdefx
  • tdehtml
  • tdeinit
  • tdeio
  •   bookmarks
  •   httpfilter
  •   kpasswdserver
  •   kssl
  •   tdefile
  •   tdeio
  •   tdeioexec
  • tdeioslave
  •   http
  • tdemdi
  •   tdemdi
  • tdenewstuff
  • tdeparts
  • tdeprint
  • tderandr
  • tderesources
  • tdespell2
  • tdesu
  • tdeui
  • tdeunittest
  • tdeutils
  • tdewallet
Generated for tdeprint by doxygen 1.9.1
This website is maintained by Timothy Pearson.