---

guiprinterautosetup.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005-2006 by Konrad Wilhelm Kleine
 *   konrad@plothe-kleine.de
 *
 *   This file contains the automatic printer setup implementation.
 *
 *   PLEASE NOTICE: If not stated otherwise, whenever we speak of 'printer
 *                  drivers' or simply 'drivers', we mean the PPD files
 *                  and not the actual drivers.
 *
 *   STATUS: File has been reviewed and commented
 *
 *   $Id: guiprinterautosetup.cpp,v 1.12 2006/04/23 16:06:22 hbci Exp $
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program 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 General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software Foundation,
 *   Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 ***************************************************************************/

// App includes
#include "guiprinterautosetup.h"
#include "printersetupdb.h"
#include "globals.h"
#include "globalsprintersetup.h"
using namespace LinuxPrinterSetup;

// Qt includes
#include <qfile.h>
#include <qdir.h>
#include <qlistbox.h>
#include <qtextstream.h>
#include <qmessagebox.h>
#include <qregexp.h>
#include <qdom.h>
#include <qapplication.h>
#include <qcheckbox.h>
#include <qlabel.h>
#include <qpushbutton.h>
#include <qcursor.h>
#include <qdialog.h>
#include <qpixmap.h>

// Other includes
#include <stdlib.h>
using namespace std;


GuiPrinterAutoSetup::GuiPrinterAutoSetup( QWidget * parent, const char * name )
    : GuiPrinterAutoSetupBase(parent,name)
{
  qDebug("Constructor GuiPrinterAutoSetup");

  m_domDoc                  = new PrinterSetupDb( LPS_DB_DOCUMENT_NAME );
  m_translationRecommended  = tr("recommended", "This will be a appended to any recommended printer");

  connect(pushButton_back, SIGNAL(clicked()), this, SIGNAL(back()));
}


GuiPrinterAutoSetup::~GuiPrinterAutoSetup()
{
  if ( m_domDoc )
    delete m_domDoc;

  qDebug("Destructor GuiPrinterAutoSetup finished");
}


void GuiPrinterAutoSetup::show()
{
  GuiPrinterAutoSetupBase::show();

  emit showSmallHelp("smallPrinterAutoSetup.html");
  QString errMsg;

  label_status->setPaletteBackgroundColor(Qt::yellow);
  label_status->setText(tr("Loading database..."));

  setCursor(Qt::WaitCursor);

  setCaption(tr("Automatic Printer Setup"));
  qApp->processEvents();

  listBox_printers->clear();
  listBox_drivers->clear();
  QString fileName = MP_DIR() + MONEYPENNY_DATA_DIR + LPS_DB_FILE;
  qDebug(QString("Now loading: ") + fileName);

  try
  {
    // Load the XML database
    QFile file( fileName );

    if ( !file.exists() || !file.open( IO_ReadOnly ) )
      throw QString("Could not open file for reading:") + " " + fileName;

    QString errMsg;
    int     errLine;
    int     errCol;
    bool    ok      = m_domDoc->setContent(&file, false, &errMsg, &errLine, &errCol);

    file.close();

    if ( !ok )
      throw LpsError(QString("An internal error in the XML file %1 at line %2 in column %3 occured."
                             "<br />The error message from the system was: %4").arg(
                       LPS_DB_FILE, QString::number(errLine),QString::number(errCol),errMsg));

    // Initiate the autodetection process
    on_pushButton_restart_clicked();
  }
  catch ( LpsError e )
  {
    label_status->setPaletteBackgroundColor( Qt::red );
    label_status->setText(e);
    enableWidgets(NoneFlag ^ HelpButtonFlag ^ BackButtonFlag);
  }
  unsetCursor();
}


void GuiPrinterAutoSetup::on_pushButton_saveSettings_clicked()
{
  try
  {
    //----------------------------------------------------------------------
    // Try to get all information about the selected printer.
    //----------------------------------------------------------------------
    QString       manufacturer  = listBox_printers->selectedItem()->text().section(" / ", 0, 0);
    QString       product       = listBox_printers->selectedItem()->text().section(" / ", 1, 1);
    QString       driver        = listBox_drivers->selectedItem()->text().replace(m_translationRecommended, "recommended");
    QString       printer       = listBox_printers->selectedItem()->text();
    QDomNodeList  drivers       = m_printerMap[printer].drivers;
    QDomElement   driverElement;

    uint i = 0;
    while ( driverElement.isNull()   &&   (i < drivers.length()) )
    {
      QDomElement element = drivers.item(i).toElement();

      if ( element.attribute("nickName") == driver ) //we have found it
        driverElement = element;

      i++;
    }

    if ( driverElement.isNull() )
      throw LpsError(QString("The driver element was NULL."));

    QString nickName        = driverElement.attribute("nickName");
    QString pcFileName      = driverElement.attribute("pcFileName");
    QString languageVersion = driverElement.attribute("languageVersion");
    QString ppdFilePath     = driverElement.attribute("ppdFilePath");
    QString deviceUri;

    if ( m_printerMap[ listBox_printers->selectedItem()->text() ].connectionType == ParPortConnection )
      deviceUri = "parallel:/dev/lp0";
    else
      deviceUri = "usb:/dev/usb/lp0";

    //----------------------------------------------------------------------
    // Next: Setup the printer using a CUPS CLI-command
    //----------------------------------------------------------------------
    QDomElement modelEle = m_domDoc->getModel(manufacturer, "", product);

    QString printerName = "";

    if ( !modelEle.isNull() )
      printerName = modelEle.attribute("name");
    else
      printerName = LPS_PRINTER_NAME;

    installPrinter(this, printerName, deviceUri, ppdFilePath);

    //----------------------------------------------------------------------
    // Ask the user whether a testpage shall be printed
    //----------------------------------------------------------------------
    testPrintRequest(this, printerName);

    label_status->setText("<p>" + tr("Your printer has been set up successfully.") + "</p>");
    label_status->setPaletteBackgroundColor(Qt::green);

  }
  catch ( LpsNotice e )
  {
    label_status->setPaletteBackgroundColor(Qt::yellow);
    label_status->setText(e);
    qDebug(e.latin1());
  }
  catch ( LpsError e )
  {
    label_status->setPaletteBackgroundColor(Qt::red);
    label_status->setText(e);
    qDebug(e.latin1());
  }
  unsetCursor();
}


void GuiPrinterAutoSetup::on_pushButton_help_clicked()
{
  emit helpRequest("printerAutoSetup.html");
}


void GuiPrinterAutoSetup::on_listBox_drivers_highlighted(QListBoxItem * item)
{
  QListBoxItem * printerItem = listBox_printers->selectedItem();

  if ( !item || !printerItem )
    return;

  label_status->setText(  tr("Driver:") + " <b>" + item->text()+"</b><br>" +
                          tr("Printer:")+ " <b>" + printerItem->text()+"</b><br>" +
                          tr("Click \"Save Settings\", if you want to use these settings.")
                       );

  label_status->setPaletteBackgroundColor(Qt::yellow);
}


void GuiPrinterAutoSetup::on_listBox_printers_highlighted(QListBoxItem * item)
{
  if( !item ) // clicking into nirvana
    return;

  enableWidgets(AllFlags^DriversFlag);
  listBox_drivers->clear();

  QString manufacturer  = item->text().section(" / ", 0, 0);
  QString product       = item->text().section(" / ", 1, 1);

  qDebug("GuiPrinterAutoSetup::on_listBox_printers_highlighted:Searching drivers for: %s", product.latin1());


  //
  // Why did I use a reference below? -> To avoid doing the same thing more than one.
  //
  // If the user already clicked on the printer that is currently focused in the printer
  // list box, we've already queried the database to find associated printer drivers.
  // If this is the first time, the user clicked on the printer in the printer driver
  // list box, we have to query the database for the first time for the selected printer.
  // And we have to make sure that the returned information is stored for upcoming
  // selections of the same printer.
  //
  QDomNodeList & drivers = m_printerMap[ item->text() ].drivers;

  if ( drivers.length() <= 0 )
    drivers = m_domDoc->getDrivers(product); // matches products OR models

  for ( uint i=0; i<drivers.length(); i++ )
  {
    QDomElement driverElement = drivers.item(i).toElement();

    if ( !driverElement.isNull() )
    {
      //
      // Insert driver into driver list box and replace the "recommended" string
      // with a localized translation.
      //
      QString driverName = driverElement.attribute("nickName");

      qDebug ("GuiPrinterAutoSetup::on_listBox_printers_highlighted: Found driver %s", driverName.latin1());

      listBox_drivers->insertItem(driverName.replace("recommended",m_translationRecommended));

      //
      // If the last inserted item contained the "recommended" string, pre-select it.
      //
      uint count = listBox_drivers->count();
      if ( listBox_drivers->text(count - 1).contains(m_translationRecommended) )
      {
        listBox_drivers->setCurrentItem(count - 1);
        enableWidgets(AllFlags);
      }
    }
  }

  uint count = drivers.length();
  if ( count <= 0 )
  {
    label_status->setPaletteBackgroundColor( Qt::yellow );
    label_status->setText(  tr("No appropriate driver found for this device:") +
                            " <b>" + item->text() + "</b> <br>" +
                            tr("Please choose a different device!")
                         );
    enableWidgets(AllFlags ^ SaveSettingsButtonFlag ^ DriversFlag);
  }

  if( !listBox_drivers->selectedItem() && count > 0 )
  {
    listBox_drivers->setCurrentItem(0);
    enableWidgets(AllFlags);
  }
}


void GuiPrinterAutoSetup::on_pushButton_restart_clicked()
{
  enableWidgets(NoneFlag);

  listBox_printers->clear();
  listBox_drivers->clear();
  m_printerMap.clear();
  int nPrinters = 0;

  try
  {
    //
    // Never change the order of this function calls.
    // If you connected the same printer via usb AND parallel port, it's safer
    // to use the usb rather than the parallel port. The parallel port printer
    // is shown in the list, although it might have been disconnected unlike
    // the usb printer which will disappear from the list, the next time you
    // enter a new autodetection cycle.
    //
    nPrinters += findParPortPrinters();
    nPrinters += findUsbPrinters();
  }
  catch ( LpsError e )
  {
    label_status->setPaletteBackgroundColor(Qt::red);
    label_status->setText(e);
    enableWidgets(AllFlags ^ DriversFlag ^ SaveSettingsButtonFlag);
    return;
  }

  if ( nPrinters > 0 )
  {
    PrinterMap::Iterator it;

    for ( it = m_printerMap.begin(); it != m_printerMap.end(); ++it )
    {
      listBox_printers->insertItem( QString(it.key().latin1()) );
      qDebug(QString(it.key().latin1()));
    }

    //
    // If we found more than one printer/device, select the first from the list.
    //
    listBox_printers->setCurrentItem(0);
  }
  else
  {
    label_status->setPaletteBackgroundColor(Qt::yellow);

    label_status->setText(  "<p>"+
                            tr("No printers found! Make sure your printer is connected and switched on.") + "<br>" +
                            tr("If you use a parallel port printer, connect it to your computer before booting.") +
                            "<br>" +
                            tr("You can also try the <i>Show all devices</i>-checkbox. ") +
                            "</p>"
                         );

    enableWidgets(AllFlags ^ PrintersFlag ^ DriversFlag ^ SaveSettingsButtonFlag);
  }
}


void GuiPrinterAutoSetup::on_checkBox_showAllDevices_stateChanged( int state )
{
  if ( state == QButton::On )
  {
    QMessageBox::information( this,
                              LPS_APP_NAME,
                              tr("Please find out yourself, which of the devices in the list could be your printer.")  +
                              "<br>" +
                              tr("You should then switch to Manual Printer Setup.")
                            );
  }

  on_pushButton_restart_clicked();
}


void GuiPrinterAutoSetup::on_pushButton_driverDetails_clicked()
{
  try
  {
    showPrinterDriverDetails(  listBox_drivers->selectedItem()->text().replace(m_translationRecommended, "recommended")  );
  }
  catch (LpsError e)
  {
    label_status->setText(e);
    label_status->setPaletteBackgroundColor(Qt::yellow);
  }
}


void GuiPrinterAutoSetup::on_pushButton_manualSetup_clicked()
{
  emit raiseWidget(PRINTER_MANUALSETUP_WIDGET);
}


int GuiPrinterAutoSetup::findUsbPrinters()
{
  //
  //
  QFile usbDevicesFile( LPS_USB_DEVICE_PATH );

  if ( !usbDevicesFile.exists() || !usbDevicesFile.open(IO_ReadOnly) )
  {
    throw LpsError(tr( "Could not open device file for reading. Filename: ") + usbDevicesFile.name());
  }

  QTextStream stream( &usbDevicesFile );
  int         nPrintersFound          = 0;
  int         status                  = 0; 
  int         statusManufacturerDone  = 1; 
  int         statusProductDone       = 2; 
  int         statusAllDone           = 3; 
  QString     manufacturerName        = QString::null;
  QString     product                 = QString::null;

  //
  // Read until we have reached the end of the file
  //
  while ( !stream.atEnd() )
  {
    //
    // Extract the file line by line and parse each, until
    // we have found all needed information (status==statusAllDone).
    //
    QString line = stream.readLine();

    //
    // a new printer device is expected soon
    //
    if ( line == "" )
    {
      status = 0;
    }
    else if ( line.startsWith("S:  Manufacturer=") )
    {
      manufacturerName = line.remove("S:  Manufacturer=");
      status          |= statusManufacturerDone;
    }
    else if ( line.startsWith("S:  Product=") )
    {
      product = line.remove("S:  Product=");
      status |= statusProductDone;
    }

    if ( status == statusAllDone )
    {
      fixManufacturer(manufacturerName);

      qDebug("GuiPrinterAutoSetup::findUsbPrinters: Found printer: %s %s", manufacturerName.latin1(), product.latin1());

      QDomNodeList drivers;

      //
      // A device has to meet at least one of the following three criteria
      // before it is inserted into the printers list box:
      //
      // 1. The user wants to see all connected devices (checkBox_showAllDevices is checked)
      // 2. We found the manufacturer of the device in our printer driver DB
      // 3. We found the product of the device somewhere in the DB
      //
      if (  checkBox_showAllDevices->isChecked() ||
            m_domDoc->manufacturerExists(manufacturerName) ||
            (drivers=m_domDoc->getDrivers(product)).length()
         )
      {
        status = 0;

        PrinterDevice device;

        device.nativeManufacturer = manufacturerName;
        device.connectionType     = UsbConnection;
        device.drivers            = drivers;
        device.nativeProduct      = product;

        m_printerMap[ manufacturerName +" / "+ product ] = device;

        nPrintersFound++;
      }//end if checkBox....
    } //end if status == statusAllDone
  }// end while

  return nPrintersFound;
}


int GuiPrinterAutoSetup::findParPortPrinters()
{
  int nPrintersFound = 0;

  QDir deviceDir(LPS_PARPORT_DEVICE_DIR); // typically, this point to /proc/sys/dev/parport/

  if ( !deviceDir.exists() || !deviceDir.isReadable() )
    throw LpsError(QString("The following directory could not be found or is not readable: ") + deviceDir.absPath());

  deviceDir.setFilter( QDir::Dirs );
  QStringList subdirs = deviceDir.entryList();

  // Run through all directories that are in /proc/sys/dev/parport/ and search for parportX directories
  for ( QStringList::Iterator subDirIt = subdirs.begin();
        subDirIt != subdirs.end();
        ++subDirIt
      )
  {
    if ( subDirIt!=NULL )
    {
      QString dirName = *subDirIt;

      // Filter parport dirs
      if ( dirName!="." && dirName!=".." && dirName.contains("parport") ) //this is a parportX dir,
                                                                          //enter it and search for an autoprobe file
      {
        QString absPath = deviceDir.absPath() + "/" + dirName;

        QDir dirEntry( absPath );

        if ( !dirEntry.exists() || !dirEntry.isReadable() )
          throw LpsError(QString("The following directory could not be found or is not readable: ") + dirEntry.absPath());

        dirEntry.setFilter( QDir::Files );
        QStringList files = dirEntry.entryList();

        QFile deviceFile(absPath + "/autoprobe");

        if ( !deviceFile.exists() || !deviceFile.open(IO_ReadOnly) )
          throw  LpsError(QString("Could not open device file for reading: ") + deviceFile.name());

        QTextStream stream( &deviceFile );

        int     status                  = 0; 
        int     statusManufacturerDone  = 1; 
        int     statusModelDone         = 2; 
        int     statusAllDone           = 3; 

        QString manufacturer            = "";
        QString model                   = "";

        //
        // Read the autoprobe file from the beginning to the end
        //
        while ( !stream.atEnd() )
        {
          //
          // Extract the file line by line and parse each, until
          // we have found all needed information (status==statusAllDone).
          //
          QString line = stream.readLine();

          if ( line.startsWith("MANUFACTURER:") )
          {
            manufacturer = line.remove("MANUFACTURER:").remove(";");
            status      |= statusManufacturerDone;
          }
          else if ( line.startsWith("MODEL:") )
          {
            model   = line.remove("MODEL:").remove(";");
            status |= statusModelDone;
          }
          if ( status == statusAllDone )
          {
            fixManufacturer(manufacturer);

            qDebug("GuiPrinterAutoSetup::findParPortPrinters: Found printer: %s %s", manufacturer.latin1(), model.latin1());

            QDomNodeList drivers;

            //
            // A device has to meet at least one of the following three criteria
            // before it is inserted into the printers list box:
            //
            // 1. The user wants to see all connected devices (checkBox_showAllDevices is checked)
            // 2. We found the manufacturer of the device in our printer driver DB
            // 3. We found the product of the device somewhere in the DB
            //
            if (  checkBox_showAllDevices->isChecked() ||
                  m_domDoc->manufacturerExists(manufacturer) ||
                  (drivers=m_domDoc->getDrivers(model)).length()
               )
            {
                status                    = 0;

                PrinterDevice device;

                device.nativeManufacturer = manufacturer;
                device.connectionType     = ParPortConnection;
                device.nativeProduct      = model;
                device.drivers            = drivers;

                m_printerMap[manufacturer +" / "+ model] = device;

                nPrintersFound++;
            }
          }//end if status == allDone
        }//end while !stream atEnd

        deviceFile.close();
      } //end if dirname contains parport
    }//end if subir != Null
  }//end for

  return nPrintersFound;
}


void GuiPrinterAutoSetup::enableWidgets( int wf )
{
  // list boxes
  listBox_drivers->setEnabled(          wf & DriversFlag            );
  listBox_printers->setEnabled(         wf & PrintersFlag           );

  // labels
  label_drivers->setEnabled(            wf & DriversFlag            );
  label_printers->setEnabled(           wf & PrintersFlag           );

  // push buttons
  pushButton_driverDetails->setEnabled( wf & DriversFlag            );
  pushButton_help->setEnabled(          wf & HelpButtonFlag         );
  pushButton_back->setEnabled(          wf & BackButtonFlag         );
  pushButton_restart->setEnabled(       wf & RestartButtonFlag      );
  pushButton_manualSetup->setEnabled(   wf & ManualSetupButtonFlag  );
  pushButton_saveSettings->setEnabled(  wf & SaveSettingsButtonFlag );
}


void GuiPrinterAutoSetup::fixManufacturer( QString & manufacturer )
{
  if ( manufacturer == "Hewlett-Packard" )
    manufacturer = "HP";
}

To get more information, please visit our project site hosted at
To support this project, please click on this image: