summaryrefslogtreecommitdiffstats
path: root/tdeprint/management/kmjobviewer.cpp
diff options
context:
space:
mode:
authorTimothy Pearson <kb9vqf@pearsoncomputing.net>2011-11-06 15:56:40 -0600
committerTimothy Pearson <kb9vqf@pearsoncomputing.net>2011-11-06 15:56:40 -0600
commite16866e072f94410321d70daedbcb855ea878cac (patch)
treeee3f52eabde7da1a0e6ca845fb9c2813cf1558cf /tdeprint/management/kmjobviewer.cpp
parenta58c20c1a7593631a1b50213c805507ebc16adaf (diff)
downloadtdelibs-e16866e072f94410321d70daedbcb855ea878cac.tar.gz
tdelibs-e16866e072f94410321d70daedbcb855ea878cac.zip
Actually move the kde files that were renamed in the last commit
Diffstat (limited to 'tdeprint/management/kmjobviewer.cpp')
-rw-r--r--tdeprint/management/kmjobviewer.cpp742
1 files changed, 742 insertions, 0 deletions
diff --git a/tdeprint/management/kmjobviewer.cpp b/tdeprint/management/kmjobviewer.cpp
new file mode 100644
index 000000000..7f168faed
--- /dev/null
+++ b/tdeprint/management/kmjobviewer.cpp
@@ -0,0 +1,742 @@
+/*
+ * This file is part of the KDE libraries
+ * Copyright (c) 2001 Michael Goffioul <tdeprint@swing.be>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License version 2 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ **/
+
+#include "kmjobviewer.h"
+#include "kmjobmanager.h"
+#include "kmfactory.h"
+#include "kmjob.h"
+#include "kmprinter.h"
+#include "kmmanager.h"
+#include "kmuimanager.h"
+#include "jobitem.h"
+#include "kmtimer.h"
+#include "kmconfigjobs.h"
+#include "kmconfigpage.h"
+#include "kprinter.h"
+
+#include <klistview.h>
+#include <kstatusbar.h>
+#include <tqpopupmenu.h>
+#include <kmessagebox.h>
+#include <klocale.h>
+#include <kpopupmenu.h>
+#include <kaction.h>
+#include <kstdaction.h>
+#include <kiconloader.h>
+#include <kapplication.h>
+#include <kcursor.h>
+#include <kmenubar.h>
+#include <kdebug.h>
+#include <kwin.h>
+#include <kio/netaccess.h>
+#include <tqtimer.h>
+#include <tqlayout.h>
+#include <stdlib.h>
+#include <tqlineedit.h>
+#include <kdialogbase.h>
+#include <tqcheckbox.h>
+#include <kurldrag.h>
+#include <kconfig.h>
+
+#undef m_manager
+#define m_manager KMFactory::self()->jobManager()
+
+class KJobListView : public KListView
+{
+public:
+ KJobListView( TQWidget *parent = 0, const char *name = 0 );
+
+protected:
+ bool acceptDrag( TQDropEvent* ) const;
+};
+
+KJobListView::KJobListView( TQWidget *parent, const char *name )
+ : KListView( parent, name )
+{
+ setAcceptDrops( true );
+ setDropVisualizer( false );
+}
+
+bool KJobListView::acceptDrag( TQDropEvent *e ) const
+{
+ if ( KURLDrag::canDecode( e ) )
+ return true;
+ else
+ return KListView::acceptDrag( e );
+}
+
+KMJobViewer::KMJobViewer(TQWidget *parent, const char *name)
+: KMainWindow(parent,name)
+{
+ m_view = 0;
+ m_pop = 0;
+ m_jobs.setAutoDelete(false);
+ m_items.setAutoDelete(false);
+ m_printers.setAutoDelete(false);
+ m_type = KMJobManager::ActiveJobs;
+ m_stickybox = 0;
+ m_standalone = ( parent == NULL );
+
+ setToolBarsMovable(false);
+ init();
+
+ if (m_standalone)
+ {
+ setCaption(i18n("No Printer"));
+ KConfig *conf = KMFactory::self()->printConfig();
+ TQSize defSize( 550, 250 );
+ conf->setGroup( "Jobs" );
+ resize( conf->readSizeEntry( "Size", &defSize ) );
+ }
+}
+
+KMJobViewer::~KMJobViewer()
+{
+ if (m_standalone)
+ {
+ kdDebug( 500 ) << "Destroying stand-alone job viewer window" << endl;
+ KConfig *conf = KMFactory::self()->printConfig();
+ conf->setGroup( "Jobs" );
+ conf->writeEntry( "Size", size() );
+ emit viewerDestroyed(this);
+ }
+ removeFromManager();
+}
+
+void KMJobViewer::setPrinter(KMPrinter *p)
+{
+ setPrinter((p ? p->printerName() : TQString::null));
+}
+
+void KMJobViewer::setPrinter(const TQString& prname)
+{
+ // We need to trigger a refresh even if the printer
+ // has not changed, some jobs may have been canceled
+ // outside tdeprint. We can't return simply if
+ // prname == m_prname.
+ if (m_prname != prname)
+ {
+ removeFromManager();
+ m_prname = prname;
+ addToManager();
+ m_view->setAcceptDrops( prname != i18n( "All Printers" ) );
+ }
+ triggerRefresh();
+}
+
+void KMJobViewer::updateCaption()
+{
+ if (!m_standalone)
+ return;
+
+ TQString pixname("fileprint");
+ if (!m_prname.isEmpty())
+ {
+ setCaption(i18n("Print Jobs for %1").arg(m_prname));
+ KMPrinter *prt = KMManager::self()->findPrinter(m_prname);
+ if (prt)
+ pixname = prt->pixmap();
+ }
+ else
+ {
+ setCaption(i18n("No Printer"));
+ }
+ KWin::setIcons(winId(), DesktopIcon(pixname), SmallIcon(pixname));
+}
+
+void KMJobViewer::updateStatusBar()
+{
+ if (!m_standalone)
+ return;
+
+ int limit = m_manager->limit();
+ if (limit == 0)
+ statusBar()->changeItem(i18n("Max.: %1").arg(i18n("Unlimited")), 0);
+ else
+ statusBar()->changeItem(i18n("Max.: %1").arg(limit), 0);
+}
+
+void KMJobViewer::addToManager()
+{
+ if (m_prname == i18n("All Printers"))
+ {
+ loadPrinters();
+ TQPtrListIterator<KMPrinter> it(m_printers);
+ for (; it.current(); ++it)
+ m_manager->addPrinter(it.current()->printerName(), (KMJobManager::JobType)m_type, it.current()->isSpecial());
+ }
+ else if (!m_prname.isEmpty())
+ {
+ KMPrinter *prt = KMManager::self()->findPrinter( m_prname );
+ bool isSpecial = ( prt ? prt->isSpecial() : false );
+ m_manager->addPrinter(m_prname, (KMJobManager::JobType)m_type, isSpecial);
+ }
+}
+
+void KMJobViewer::removeFromManager()
+{
+ if (m_prname == i18n("All Printers"))
+ {
+ TQPtrListIterator<KMPrinter> it(m_printers);
+ for (; it.current(); ++it)
+ m_manager->removePrinter(it.current()->printerName(), (KMJobManager::JobType)m_type);
+ }
+ else if (!m_prname.isEmpty())
+ {
+ m_manager->removePrinter(m_prname, (KMJobManager::JobType)m_type);
+ }
+}
+
+void KMJobViewer::refresh(bool reload)
+{
+ m_jobs.clear();
+ TQPtrListIterator<KMJob> it(m_manager->jobList(reload));
+ bool all = (m_prname == i18n("All Printers")), active = (m_type == KMJobManager::ActiveJobs);
+ for (; it.current(); ++it)
+ if ((all || it.current()->printer() == m_prname)
+ && ((it.current()->state() >= KMJob::Cancelled && !active)
+ || (it.current()->state() < KMJob::Cancelled && active))
+ && (m_username.isEmpty() || m_username == it.current()->owner()))
+ m_jobs.append(it.current());
+ updateJobs();
+
+
+ // update the caption and icon (doesn't do anything if it has a parent widget)
+ updateCaption();
+
+ updateStatusBar();
+
+ // do it last as this signal can cause this view to be destroyed. No
+ // code can be executed safely after that
+ emit jobsShown(this, (m_jobs.count() != 0));
+}
+
+void KMJobViewer::init()
+{
+ if (!m_view)
+ {
+ m_view = new KJobListView(this);
+ m_view->addColumn(i18n("Job ID"));
+ m_view->addColumn(i18n("Owner"));
+ m_view->addColumn(i18n("Name"), 150);
+ m_view->addColumn(i18n("Status", "State"));
+ m_view->addColumn(i18n("Size (KB)"));
+ m_view->addColumn(i18n("Page(s)"));
+ m_view->setColumnAlignment(5,Qt::AlignRight|Qt::AlignVCenter);
+ connect( m_view, TQT_SIGNAL( dropped( TQDropEvent*, TQListViewItem* ) ), TQT_SLOT( slotDropped( TQDropEvent*, TQListViewItem* ) ) );
+ //m_view->addColumn(i18n("Printer"));
+ //m_view->setColumnAlignment(6,Qt::AlignRight|Qt::AlignVCenter);
+ KMFactory::self()->uiManager()->setupJobViewer(m_view);
+ m_view->setFrameStyle(TQFrame::WinPanel|TQFrame::Sunken);
+ m_view->setLineWidth(1);
+ m_view->setSorting(0);
+ m_view->setAllColumnsShowFocus(true);
+ m_view->setSelectionMode(TQListView::Extended);
+ connect(m_view,TQT_SIGNAL(selectionChanged()),TQT_SLOT(slotSelectionChanged()));
+ connect(m_view,TQT_SIGNAL(rightButtonPressed(TQListViewItem*,const TQPoint&,int)),TQT_SLOT(slotRightClicked(TQListViewItem*,const TQPoint&,int)));
+ setCentralWidget(m_view);
+ }
+
+ initActions();
+}
+
+void KMJobViewer::initActions()
+{
+ // job actions
+ KAction *hact = new KAction(i18n("&Hold"),"stop",0,TQT_TQOBJECT(this),TQT_SLOT(slotHold()),actionCollection(),"job_hold");
+ KAction *ract = new KAction(i18n("&Resume"),"run",0,TQT_TQOBJECT(this),TQT_SLOT(slotResume()),actionCollection(),"job_resume");
+ KAction *dact = new KAction(i18n("Remo&ve"),"edittrash",Qt::Key_Delete,TQT_TQOBJECT(this),TQT_SLOT(slotRemove()),actionCollection(),"job_remove");
+ KAction *sact = new KAction(i18n("Res&tart"),"redo",0,TQT_TQOBJECT(this),TQT_SLOT(slotRestart()),actionCollection(),"job_restart");
+ KActionMenu *mact = new KActionMenu(i18n("&Move to Printer"),"fileprint",actionCollection(),"job_move");
+ mact->setDelayed(false);
+ connect(mact->popupMenu(),TQT_SIGNAL(activated(int)),TQT_SLOT(slotMove(int)));
+ connect(mact->popupMenu(),TQT_SIGNAL(aboutToShow()),KMTimer::self(),TQT_SLOT(hold()));
+ connect(mact->popupMenu(),TQT_SIGNAL(aboutToHide()),KMTimer::self(),TQT_SLOT(release()));
+ connect(mact->popupMenu(),TQT_SIGNAL(aboutToShow()),TQT_SLOT(slotShowMoveMenu()));
+ KToggleAction *tact = new KToggleAction(i18n("&Toggle Completed Jobs"),"history",0,actionCollection(),"view_completed");
+ tact->setEnabled(m_manager->actions() & KMJob::ShowCompleted);
+ connect(tact,TQT_SIGNAL(toggled(bool)),TQT_SLOT(slotShowCompleted(bool)));
+ KToggleAction *uact = new KToggleAction(i18n("Show Only User Jobs"), "personal", 0, actionCollection(), "view_user_jobs");
+ uact->setCheckedState(KGuiItem(i18n("Hide Only User Jobs"),"personal"));
+ connect(uact, TQT_SIGNAL(toggled(bool)), TQT_SLOT(slotUserOnly(bool)));
+ m_userfield = new TQLineEdit(0);
+ m_userfield->setText(getenv("USER"));
+ connect(m_userfield, TQT_SIGNAL(returnPressed()), TQT_SLOT(slotUserChanged()));
+ connect(uact, TQT_SIGNAL(toggled(bool)), m_userfield, TQT_SLOT(setEnabled(bool)));
+ m_userfield->setEnabled(false);
+ m_userfield->tqsetSizePolicy(TQSizePolicy(TQSizePolicy::Fixed, TQSizePolicy::Fixed));
+ KWidgetAction *ufact = new KWidgetAction(m_userfield, i18n("User Name"), 0, 0, 0, actionCollection(), "view_username");
+
+ if (!m_pop)
+ {
+ m_pop = new TQPopupMenu(this);
+ connect(m_pop,TQT_SIGNAL(aboutToShow()),KMTimer::self(),TQT_SLOT(hold()));
+ connect(m_pop,TQT_SIGNAL(aboutToHide()),KMTimer::self(),TQT_SLOT(release()));
+ hact->plug(m_pop);
+ ract->plug(m_pop);
+ m_pop->insertSeparator();
+ dact->plug(m_pop);
+ mact->plug(m_pop);
+ m_pop->insertSeparator();
+ sact->plug(m_pop);
+ }
+
+ // Filter actions
+ KActionMenu *fact = new KActionMenu(i18n("&Select Printer"), "tdeprint_printer", actionCollection(), "filter_modify");
+ fact->setDelayed(false);
+ connect(fact->popupMenu(),TQT_SIGNAL(activated(int)),TQT_SLOT(slotPrinterSelected(int)));
+ connect(fact->popupMenu(),TQT_SIGNAL(aboutToShow()),KMTimer::self(),TQT_SLOT(hold()));
+ connect(fact->popupMenu(),TQT_SIGNAL(aboutToHide()),KMTimer::self(),TQT_SLOT(release()));
+ connect(fact->popupMenu(),TQT_SIGNAL(aboutToShow()),TQT_SLOT(slotShowPrinterMenu()));
+
+ if (!m_standalone)
+ {
+ KToolBar *toolbar = toolBar();
+ hact->plug(toolbar);
+ ract->plug(toolbar);
+ toolbar->insertSeparator();
+ dact->plug(toolbar);
+ mact->plug(toolbar);
+ toolbar->insertSeparator();
+ sact->plug(toolbar);
+ toolbar->insertSeparator();
+ tact->plug(toolbar);
+ uact->plug(toolbar);
+ ufact->plug(toolbar);
+ }
+ else
+ {// stand-alone application
+ KStdAction::quit(TQT_TQOBJECT(kapp),TQT_SLOT(quit()),actionCollection());
+ KStdAction::close(TQT_TQOBJECT(this),TQT_SLOT(slotClose()),actionCollection());
+ KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(slotConfigure()), actionCollection());
+
+ // refresh action
+ new KAction(i18n("Refresh"),"reload",0,TQT_TQOBJECT(this),TQT_SLOT(slotRefresh()),actionCollection(),"refresh");
+
+ // create status bar
+ KStatusBar *statusbar = statusBar();
+ m_stickybox = new TQCheckBox( i18n( "Keep window permanent" ), statusbar );
+ statusbar->addWidget( m_stickybox, 1, false );
+ statusbar->insertItem(" " + i18n("Max.: %1").arg(i18n("Unlimited"))+ " ", 0, 0, true);
+ statusbar->setItemFixed(0);
+ updateStatusBar();
+
+ createGUI();
+ }
+
+ loadPluginActions();
+ slotSelectionChanged();
+}
+
+void KMJobViewer::buildPrinterMenu(TQPopupMenu *menu, bool use_all, bool use_specials)
+{
+ loadPrinters();
+ menu->clear();
+
+ TQPtrListIterator<KMPrinter> it(m_printers);
+ int i(0);
+ if (use_all)
+ {
+ menu->insertItem(SmallIcon("fileprint"), i18n("All Printers"), i++);
+ menu->insertSeparator();
+ }
+ for (; it.current(); ++it, i++)
+ {
+ if ( !it.current()->instanceName().isEmpty() ||
+ ( it.current()->isSpecial() && !use_specials ) )
+ continue;
+ menu->insertItem(SmallIcon(it.current()->pixmap()), it.current()->printerName(), i);
+ }
+}
+
+void KMJobViewer::slotShowMoveMenu()
+{
+ TQPopupMenu *menu = static_cast<KActionMenu*>(actionCollection()->action("job_move"))->popupMenu();
+ buildPrinterMenu(menu, false, false);
+}
+
+void KMJobViewer::slotShowPrinterMenu()
+{
+ TQPopupMenu *menu = static_cast<KActionMenu*>(actionCollection()->action("filter_modify"))->popupMenu();
+ buildPrinterMenu(menu, true, true);
+}
+
+void KMJobViewer::updateJobs()
+{
+ TQPtrListIterator<JobItem> jit(m_items);
+ for (;jit.current();++jit)
+ jit.current()->setDiscarded(true);
+
+ TQPtrListIterator<KMJob> it(m_jobs);
+ for (;it.current();++it)
+ {
+ KMJob *j(it.current());
+ JobItem *item = findItem(j->uri());
+ if (item)
+ {
+ item->setDiscarded(false);
+ item->init(j);
+ }
+ else
+ m_items.append(new JobItem(m_view,j));
+ }
+
+ for (uint i=0; i<m_items.count(); i++)
+ if (m_items.tqat(i)->isDiscarded())
+ {
+ delete m_items.take(i);
+ i--;
+ }
+
+ slotSelectionChanged();
+}
+
+JobItem* KMJobViewer::findItem(const TQString& uri)
+{
+ TQPtrListIterator<JobItem> it(m_items);
+ for (;it.current();++it)
+ if (it.current()->jobUri() == uri) return it.current();
+ return 0;
+}
+
+void KMJobViewer::slotSelectionChanged()
+{
+ int acts = m_manager->actions();
+ int state(-1);
+ int thread(0);
+ bool completed(true), remote(false);
+
+ TQPtrListIterator<JobItem> it(m_items);
+ TQPtrList<KMJob> joblist;
+
+ joblist.setAutoDelete(false);
+ for (;it.current();++it)
+ {
+ if (it.current()->isSelected())
+ {
+ // check if threaded job. "thread" value will be:
+ // 0 -> no jobs
+ // 1 -> only thread jobs
+ // 2 -> only system jobs
+ // 3 -> thread and system jobs
+ if (it.current()->job()->type() == KMJob::Threaded) thread |= 0x1;
+ else thread |= 0x2;
+
+ if (state == -1) state = it.current()->job()->state();
+ else if (state != 0 && state != it.current()->job()->state()) state = 0;
+
+ completed = (completed && it.current()->job()->isCompleted());
+ joblist.append(it.current()->job());
+ if (it.current()->job()->isRemote())
+ remote = true;
+ }
+ }
+ if (thread != 2)
+ joblist.clear();
+
+ actionCollection()->action("job_remove")->setEnabled((thread == 1) || (/*!remote &&*/ !completed && (state >= 0) && (acts & KMJob::Remove)));
+ actionCollection()->action("job_hold")->setEnabled(/*!remote &&*/ !completed && (thread == 2) && (state > 0) && (state != KMJob::Held) && (acts & KMJob::Hold));
+ actionCollection()->action("job_resume")->setEnabled(/*!remote &&*/ !completed && (thread == 2) && (state > 0) && (state == KMJob::Held) && (acts & KMJob::Resume));
+ actionCollection()->action("job_move")->setEnabled(!remote && !completed && (thread == 2) && (state >= 0) && (acts & KMJob::Move));
+ actionCollection()->action("job_restart")->setEnabled(!remote && (thread == 2) && (state >= 0) && (completed) && (acts & KMJob::Restart));
+
+ m_manager->validatePluginActions(actionCollection(), joblist);
+}
+
+void KMJobViewer::jobSelection(TQPtrList<KMJob>& l)
+{
+ l.setAutoDelete(false);
+ TQPtrListIterator<JobItem> it(m_items);
+ for (;it.current();++it)
+ if (it.current()->isSelected())
+ l.append(it.current()->job());
+}
+
+void KMJobViewer::send(int cmd, const TQString& name, const TQString& arg)
+{
+ KMTimer::self()->hold();
+
+ TQPtrList<KMJob> l;
+ jobSelection(l);
+ if (!m_manager->sendCommand(l,cmd,arg))
+ {
+ KMessageBox::error(this,"<qt>"+i18n("Unable to perform action \"%1\" on selected jobs. Error received from manager:").arg(name)+"<p>"+KMManager::self()->errorMsg()+"</p></qt>");
+ // error reported, clean it
+ KMManager::self()->setErrorMsg(TQString::null);
+ }
+
+ triggerRefresh();
+
+ KMTimer::self()->release();
+}
+
+void KMJobViewer::slotHold()
+{
+ send(KMJob::Hold,i18n("Hold"));
+}
+
+void KMJobViewer::slotResume()
+{
+ send(KMJob::Resume,i18n("Resume"));
+}
+
+void KMJobViewer::slotRemove()
+{
+ send(KMJob::Remove,i18n("Remove"));
+}
+
+void KMJobViewer::slotRestart()
+{
+ send(KMJob::Restart,i18n("Restart"));
+}
+
+void KMJobViewer::slotMove(int prID)
+{
+ if (prID >= 0 && prID < (int)(m_printers.count()))
+ {
+ KMPrinter *p = m_printers.tqat(prID);
+ send(KMJob::Move,i18n("Move to %1").arg(p->printerName()),p->printerName());
+ }
+}
+
+void KMJobViewer::slotRightClicked(TQListViewItem*,const TQPoint& p,int)
+{
+ if (m_pop) m_pop->popup(p);
+}
+
+void KMJobViewer::loadPrinters()
+{
+ m_printers.clear();
+
+ // retrieve printer list without reloading it (faster)
+ TQPtrListIterator<KMPrinter> it(*(KMFactory::self()->manager()->printerList(false)));
+ for (;it.current();++it)
+ {
+ // keep only real printers (no instance, no implicit) and special printers
+ if ((it.current()->isPrinter() || it.current()->isClass(false) ||
+ ( it.current()->isSpecial() && it.current()->isValid() ) )
+ && (it.current()->name() == it.current()->printerName()))
+ m_printers.append(it.current());
+ }
+}
+
+void KMJobViewer::slotPrinterSelected(int prID)
+{
+ if (prID >= 0 && prID < (int)(m_printers.count()+1))
+ {
+ TQString prname = (prID == 0 ? i18n("All Printers") : m_printers.tqat(prID-1)->printerName());
+ emit printerChanged(this, prname);
+ }
+}
+
+void KMJobViewer::slotRefresh()
+{
+ triggerRefresh();
+}
+
+void KMJobViewer::triggerRefresh()
+{
+ // parent widget -> embedded in KControl and needs
+ // to update itself. Otherwise, it's standalone
+ // kjobviewer and we need to synchronize all possible
+ // opened windows -> do the job on higher level.
+ if (!m_standalone)
+ refresh(true);
+ else
+ emit refreshClicked();
+}
+
+void KMJobViewer::slotShowCompleted(bool on)
+{
+ removeFromManager();
+ m_type = (on ? KMJobManager::CompletedJobs : KMJobManager::ActiveJobs);
+ addToManager();
+ triggerRefresh();
+}
+
+void KMJobViewer::slotClose()
+{
+ delete this;
+}
+
+void KMJobViewer::loadPluginActions()
+{
+ int mpopindex(7), toolbarindex(!m_standalone?7:8), menuindex(7);
+ TQMenuData *menu(0);
+
+ if (m_standalone)
+ {
+ // standalone window, insert actions into main menubar
+ KAction *act = actionCollection()->action("job_restart");
+ for (int i=0;i<act->containerCount();i++)
+ {
+ if (menuBar()->findItem(act->itemId(i), &menu))
+ {
+ menuindex = mpopindex = menu->indexOf(act->itemId(i))+1;
+ break;
+ }
+ }
+ }
+
+ TQValueList<KAction*> acts = m_manager->createPluginActions(actionCollection());
+ for (TQValueListIterator<KAction*> it=acts.begin(); it!=acts.end(); ++it)
+ {
+ // connect the action to this
+ connect((*it), TQT_SIGNAL(activated(int)), TQT_SLOT(pluginActionActivated(int)));
+
+ // should add it to the toolbar and menubar
+ (*it)->plug(toolBar(), toolbarindex++);
+ if (m_pop)
+ (*it)->plug(m_pop, mpopindex++);
+ if (menu)
+ (*it)->plug(static_cast<TQPopupMenu*>(menu), menuindex++);
+ }
+}
+
+void KMJobViewer::removePluginActions()
+{
+ TQValueList<KAction*> acts = actionCollection()->actions("plugin");
+ for (TQValueListIterator<KAction*> it=acts.begin(); it!=acts.end(); ++it)
+ {
+ (*it)->unplugAll();
+ delete (*it);
+ }
+}
+
+/*
+void KMJobViewer::aboutToReload()
+{
+ if (m_view)
+ {
+ m_view->clear();
+ m_items.clear();
+ }
+ m_jobs.clear();
+}
+*/
+
+void KMJobViewer::reload()
+{
+ removePluginActions();
+ loadPluginActions();
+ // re-add the current printer to the job manager: the job
+ // manager has been destroyed, so the new one doesn't know
+ // which printer it has to list
+ addToManager();
+ // no refresh needed: view has been cleared before reloading
+ // and the actual refresh will be triggered either by the KControl
+ // module, or by KJobViewerApp using timer.
+
+ // reload the columns needed: remove the old one
+ for (int c=m_view->columns()-1; c>5; c--)
+ m_view->removeColumn(c);
+ KMFactory::self()->uiManager()->setupJobViewer(m_view);
+
+ // update the "History" action state
+ actionCollection()->action("view_completed")->setEnabled(m_manager->actions() & KMJob::ShowCompleted);
+ static_cast<KToggleAction*>(actionCollection()->action("view_completed"))->setChecked(false);
+}
+
+void KMJobViewer::closeEvent(TQCloseEvent *e)
+{
+ if (m_standalone && !kapp->sessionSaving())
+ {
+ hide();
+ e->ignore();
+ }
+ else
+ e->accept();
+}
+
+void KMJobViewer::pluginActionActivated(int ID)
+{
+ KMTimer::self()->hold();
+
+ TQPtrList<KMJob> joblist;
+ jobSelection(joblist);
+ if (!m_manager->doPluginAction(ID, joblist))
+ KMessageBox::error(this, "<qt>"+i18n("Operation failed.")+"<p>"+KMManager::self()->errorMsg()+"</p></qt>");
+
+ triggerRefresh();
+ KMTimer::self()->release();
+}
+
+void KMJobViewer::slotUserOnly(bool on)
+{
+ m_username = (on ? m_userfield->text() : TQString::null);
+ refresh(false);
+}
+
+void KMJobViewer::slotUserChanged()
+{
+ if (m_userfield->isEnabled())
+ {
+ m_username = m_userfield->text();
+ refresh(false);
+ }
+}
+
+void KMJobViewer::slotConfigure()
+{
+ KMTimer::self()->hold();
+
+ KDialogBase dlg(this, 0, true, i18n("Print Job Settings"), KDialogBase::Ok|KDialogBase::Cancel);
+ KMConfigJobs *w = new KMConfigJobs(&dlg);
+ dlg.setMainWidget(w);
+ dlg.resize(300, 10);
+ KConfig *conf = KMFactory::self()->printConfig();
+ w->loadConfig(conf);
+ if (dlg.exec())
+ {
+ w->saveConfig(conf);
+ updateStatusBar();
+ refresh(true);
+ }
+
+ KMTimer::self()->release();
+}
+
+bool KMJobViewer::isSticky() const
+{
+ return ( m_stickybox ? m_stickybox->isChecked() : false );
+}
+
+void KMJobViewer::slotDropped( TQDropEvent *e, TQListViewItem* )
+{
+ TQStringList files;
+ TQString target;
+
+ KURL::List uris;
+ KURLDrag::decode( e, uris );
+ for ( KURL::List::ConstIterator it = uris.begin();
+ it != uris.end(); ++it)
+ {
+ if ( KIO::NetAccess::download( *it, target, 0 ) )
+ files << target;
+ }
+
+ if ( files.count() > 0 )
+ {
+ KPrinter prt;
+ if ( prt.autoConfigure( m_prname, this ) )
+ prt.printFiles( files, false, false );
+ }
+}
+
+#include "kmjobviewer.moc"