Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegraphics@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1541 insertions, 0 deletions

diff --git a/libkscan/kscandevice.cpp b/libkscan/kscandevice.cpp
new file mode 100644
index 00000000..ca678eac
--- /dev/null
+++ b/libkscan/kscandevice.cpp
@@ -0,0 +1,1541 @@
+/* This file is part of the KDE Project
+   Copyright (C) 1999 Klaas Freitag <freitag@suse.de>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   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 <stdlib.h>
+#include <qwidget.h>
+#include <qobject.h>
+#include <qasciidict.h>
+#include <qcombobox.h>
+#include <qslider.h>
+#include <qcheckbox.h>
+#include <qlineedit.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qtooltip.h>
+#include <qimage.h>
+#include <qfileinfo.h>
+#include <qapplication.h>
+#include <kdebug.h>
+#include <klocale.h>
+#include <kglobal.h>
+#include <kconfig.h>
+#include <kstandarddirs.h>
+
+#include <unistd.h>
+#include "kgammatable.h"
+#include "kscandevice.h"
+#include "kscanslider.h"
+#include "kscanoption.h"
+#include "kscanoptset.h"
+#include "devselector.h"
+#include "imgscaninfo.h"
+
+#include <ksimpleconfig.h>
+
+#define MIN_PREVIEW_DPI 75
+#define UNDEF_SCANNERNAME I18N_NOOP( "undefined" )
+#define MAX_PROGRESS 100
+
+/* ---------------------------------------------------------------------------
+   Private class for KScanDevice
+   ------------------------------------------------------------------------- */
+class KScanDevice::KScanDevicePrivate
+
+{
+public:
+    KScanDevicePrivate()
+	: currScanResolutionX(0),
+	  currScanResolutionY(0)
+	{
+	    
+	}
+
+    int currScanResolutionX, currScanResolutionY;
+    
+};
+
+
+/* ---------------------------------------------------------------------------
+
+   ------------------------------------------------------------------------- */
+void KScanDevice::guiSetEnabled( const QCString& name, bool state )
+{
+    KScanOption *so = getExistingGuiElement( name );
+
+    if( so )
+    {
+	QWidget *w = so->widget();
+
+	if( w )
+	    w->setEnabled( state );
+    }
+}
+
+
+/* ---------------------------------------------------------------------------
+
+   ------------------------------------------------------------------------- */
+KScanOption *KScanDevice::getExistingGuiElement( const QCString& name )
+{
+    KScanOption *ret = 0L;
+
+    QCString alias = aliasName( name );
+
+    /* gui_elements is a QList<KScanOption> */
+    for( ret = gui_elements.first(); ret != 0; ret = gui_elements.next())
+    {
+       if( ret->getName() == alias ) break;
+    }
+
+    return( ret );
+}
+/* ---------------------------------------------------------------------------
+
+   ------------------------------------------------------------------------- */
+
+KScanOption *KScanDevice::getGuiElement( const QCString& name, QWidget *parent,
+					 const QString& desc,
+					 const QString& tooltip )
+{
+   if( name.isEmpty() ) return(0);
+   QWidget *w = 0;
+   KScanOption *so = 0;
+
+   QCString alias = aliasName( name );
+
+   /* Check if already exists */
+   so = getExistingGuiElement( name );
+
+   if( so ) return( so );
+
+   /* ...else create a new one */
+   so = new KScanOption( alias );
+
+   if( so->valid() && so->softwareSetable())
+   {
+      /** store new gui-elem in list of all gui-elements */
+      gui_elements.append( so );
+
+      w = so->createWidget( parent, desc, tooltip );
+      if( w )
+      {
+	 connect( so,   SIGNAL( optionChanged( KScanOption* ) ),
+		  this, SLOT(   slOptChanged( KScanOption* )));
+	 w->setEnabled( so->active() );
+      }
+      else
+      {
+	 kdDebug(29000) << "ERROR: No widget created for " << name << endl;
+      }
+   }
+   else
+   {
+      if( !so->valid())
+	 kdDebug(29000) << "getGuiElem: no option <" << alias << ">" << endl;
+      else
+      if( !so->softwareSetable())
+	 kdDebug(29000) << "getGuiElem: option <" << alias << "> is not software Setable" << endl;
+
+      delete so;
+      so = 0;
+   }
+
+   return( so );
+}
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+
+
+KScanDevice::KScanDevice( QObject *parent )
+   : QObject( parent )
+{
+    SANE_Status sane_stat = sane_init(NULL, NULL );
+
+    d = new KScanDevicePrivate();
+    
+    option_dic = new QAsciiDict<int>;
+    option_dic->setAutoDelete( true );
+    gui_elements.setAutoDelete( true );
+
+    scanner_initialised = false;  /* stays false until openDevice. */
+    scanStatus = SSTAT_SILENT;
+
+    data         = 0; /* temporary image data buffer while scanning */
+    sn           = 0; /* socket notifier for async scanning         */
+    img          = 0; /* temporary image to scan in                 */
+    storeOptions = 0; /* list of options to store during preview    */
+    overall_bytes = 0;
+    rest_bytes = 0;
+    pixel_x = 0;
+    pixel_y = 0;
+    scanner_name = 0L;
+
+    KConfig *konf = KGlobal::config ();
+    konf->setGroup( GROUP_STARTUP );
+    bool netaccess = konf->readBoolEntry( STARTUP_ONLY_LOCAL, false );
+    kdDebug(29000) << "Query for network scanners " << (netaccess ? "Not enabled" : "Enabled") << endl;
+    if( sane_stat == SANE_STATUS_GOOD )
+    {
+        sane_stat = sane_get_devices( &dev_list, netaccess ? SANE_TRUE : SANE_FALSE );
+
+        // NO network devices yet
+
+        // Store all available Scanner to Stringlist
+        for( int devno = 0; sane_stat == SANE_STATUS_GOOD &&
+	      dev_list[ devno ]; ++devno )
+        {
+	    if( dev_list[devno] )
+ 	    {
+	        scanner_avail.append( dev_list[devno]->name );
+		scannerDevices.insert( dev_list[devno]->name, dev_list[devno] );
+	    	kdDebug(29000) << "Found Scanner: " << dev_list[devno]->name << endl;
+            }
+        }
+#if 0
+        connect( this, SIGNAL(sigOptionsChanged()), SLOT(slReloadAll()));
+#endif
+	gammaTables = new KScanOptSet( "GammaTables" );
+     }
+     else
+     {
+        kdDebug(29000) << "ERROR: sane_init failed -> SANE installed ?" << endl;
+     }
+
+    connect( this, SIGNAL( sigScanFinished( KScanStat )), SLOT( slScanFinished( KScanStat )));
+
+}
+
+
+KScanDevice::~KScanDevice()
+{
+  if( storeOptions )  delete (storeOptions );
+  kdDebug(29000) << "Calling sane_exit to finish sane!" << endl;
+  sane_exit();
+  delete d;
+}
+
+
+KScanStat KScanDevice::openDevice( const QCString& backend )
+{
+   KScanStat    stat      = KSCAN_OK;
+   SANE_Status 	sane_stat = SANE_STATUS_GOOD;
+
+   if( backend.isEmpty() ) return KSCAN_ERR_PARAM;
+
+   // search for scanner
+   int indx = scanner_avail.find( backend );
+
+   if( indx < 0 ) {
+      stat = KSCAN_ERR_NO_DEVICE;
+   }
+
+   // if available, build lists of properties
+   if( stat == KSCAN_OK )
+   {
+      sane_stat = sane_open( backend, &scanner_handle );
+
+
+      if( sane_stat == SANE_STATUS_GOOD )
+      {
+	     // fill description dic with names and numbers
+	stat = find_options();
+	scanner_name = backend;
+
+      } else {
+	stat = KSCAN_ERR_OPEN_DEV;
+	scanner_name = UNDEF_SCANNERNAME;
+      }
+   }
+
+   if( stat == KSCAN_OK )
+      scanner_initialised = true;
+
+   return( stat );
+}
+
+void KScanDevice::slCloseDevice( )
+{
+   /* First of all, send a signal to close down the scanner dev. */
+   emit( sigCloseDevice( ));
+
+   kdDebug(29000) << "Saving scan settings" << endl;
+   slSaveScanConfigSet( DEFAULT_OPTIONSET, i18n("the default startup setup"));
+
+   /* After return, delete all related stuff */
+   scanner_name = UNDEF_SCANNERNAME;
+   if( scanner_handle )
+   {
+      if( scanStatus != SSTAT_SILENT )
+      {
+         kdDebug(29000) << "Scanner is still active, calling cancel !" << endl;
+         sane_cancel( scanner_handle );
+      }
+      sane_close( scanner_handle );
+      scanner_handle = 0;
+   }
+
+   gui_elements.clear();
+
+   option_dic->clear();
+   scanner_initialised = false;
+
+}
+
+
+QString KScanDevice::getScannerName(const QCString& name) const
+{
+  QString ret = i18n("No scanner selected");
+  SANE_Device *scanner = 0L;
+
+  if( scanner_name && scanner_initialised && name.isEmpty())
+  {
+     scanner = scannerDevices[ scanner_name ];
+  }
+  else if ( ! name.isEmpty() )
+  {
+     scanner = scannerDevices[ name ];
+     ret = QString::null;
+  }
+
+  if( scanner ) {
+     // ret.sprintf( "%s %s %s", scanner->vendor, scanner->model, scanner->type );
+     ret.sprintf( "%s %s", scanner->vendor, scanner->model );
+  }
+
+  kdDebug(29000) << "getScannerName returns <" << ret << ">" << endl;
+  return ( ret );
+}
+
+
+QSize KScanDevice::getMaxScanSize( void ) const
+{
+   QSize s;
+   double min, max, q;
+
+   KScanOption so_w( SANE_NAME_SCAN_BR_X );
+   so_w.getRange( &min, &max, &q );
+
+   s.setWidth( (int) max );
+
+   KScanOption so_h( SANE_NAME_SCAN_BR_Y );
+   so_h.getRange( &min, &max, &q );
+
+   s.setHeight( (int) max );
+
+   return( s );
+}
+
+
+KScanStat KScanDevice::find_options()
+{
+   KScanStat 	stat = KSCAN_OK;
+   SANE_Int 	n;
+   SANE_Int 	opt;
+   int 	   	*new_opt;
+
+  SANE_Option_Descriptor *d;
+
+  if( sane_control_option(scanner_handle, 0,SANE_ACTION_GET_VALUE, &n, &opt)
+      != SANE_STATUS_GOOD )
+     stat = KSCAN_ERR_CONTROL;
+
+  // printf("find_options(): Found %d options\n", n );
+
+  // resize the Array which hold the descriptions
+  if( stat == KSCAN_OK )
+  {
+
+     option_dic->clear();
+
+     for(int i = 1; i<n; i++)
+     {
+	d = (SANE_Option_Descriptor*)
+	   sane_get_option_descriptor( scanner_handle, i);
+
+	if( d )
+	{
+	   // logOptions( d );
+	   if(d->name )
+	   {
+	      // Die Option anhand des Namen in den Dict
+
+	      if( strlen( d->name ) > 0 )
+	      {
+		 new_opt = new int;
+		 *new_opt = i;
+		 kdDebug(29000) << "Inserting <" << d->name << "> as " << *new_opt << endl;
+		 /* create a new option in the set. */
+		 option_dic->insert ( (const char*)d->name, new_opt );
+		 option_list.append( (const char*) d->name );
+#if 0
+		 KScanOption *newOpt = new KScanOption( d->name );
+		 const QString qq = newOpt->get();
+		 qDebug( "INIT: <%s> = <%s>", d->name, qq );
+		 allOptionSet->insert( d->name, newOpt );
+#endif
+	      }
+	      else if( d->type == SANE_TYPE_GROUP )
+	      {
+	      	// qDebug( "######### Group found: %s ########", d->title );
+	      }
+	      else
+		 kdDebug(29000) << "Unable to detect option " << endl;
+	   }
+	}
+     }
+  }
+  return stat;
+}
+
+
+QStrList KScanDevice::getAllOptions()
+{
+   return( option_list );
+}
+
+QStrList KScanDevice::getCommonOptions()
+{
+   QStrList com_opt;
+
+   QCString s = option_list.first();
+
+   while( !s.isEmpty() )
+   {
+      KScanOption opt( s );
+      if( opt.commonOption() )
+	 com_opt.append( s );
+      s = option_list.next();
+   }
+   return( com_opt );
+}
+
+QStrList KScanDevice::getAdvancedOptions()
+{
+   QStrList com_opt;
+
+   QCString s = option_list.first();
+
+   while( !s.isEmpty() )
+   {
+     KScanOption opt( s );
+     if( !opt.commonOption() )
+       com_opt.append( s );
+     s = option_list.next();
+   }
+   return( com_opt );
+}
+
+KScanStat KScanDevice::apply( KScanOption *opt, bool isGammaTable )
+{
+   KScanStat   stat = KSCAN_OK;
+   if( !opt ) return( KSCAN_ERR_PARAM );
+   int sane_result = 0;
+
+   int         *num = (*option_dic)[ opt->getName() ];
+   SANE_Status sane_stat = SANE_STATUS_GOOD;
+   const QCString& oname = opt->getName();
+
+   if ( oname == "preview" || oname == "mode" ) {
+      sane_stat = sane_control_option( scanner_handle, *num,
+				       SANE_ACTION_SET_AUTO, 0,
+				       &sane_result );
+      /* No return here, please ! Carsten, does it still work than for you ? */
+   }
+
+
+   if( ! opt->initialised() || opt->getBuffer() == 0 )
+   {
+      kdDebug(29000) << "Attempt to set Zero buffer of " << oname << " -> skipping !" << endl;
+
+      if( opt->autoSetable() )
+      {
+	 kdDebug(29000) << "Setting option automatic !" << endl;
+	 sane_stat = sane_control_option( scanner_handle, *num,
+					  SANE_ACTION_SET_AUTO, 0,
+					  &sane_result );
+      }
+      else
+      {
+	 sane_stat = SANE_STATUS_INVAL;
+      }
+      stat = KSCAN_ERR_PARAM;
+   }
+   else
+   {
+      if( ! opt->active() )
+      {
+	 kdDebug(29000) << "Option " << oname << " is not active now!" << endl;
+	 stat = KSCAN_OPT_NOT_ACTIVE;
+      }
+      else if( ! opt->softwareSetable() )
+      {
+	 kdDebug(29000) << "Option " << oname << " is not software Setable!" << endl;
+	 stat = KSCAN_OPT_NOT_ACTIVE;
+      }
+      else
+      {
+
+	 sane_stat = sane_control_option( scanner_handle, *num,
+					  SANE_ACTION_SET_VALUE,
+					  opt->getBuffer(),
+					  &sane_result );
+      }
+   }
+
+   if( stat == KSCAN_OK )
+   {
+      if( sane_stat == SANE_STATUS_GOOD )
+      {
+	 kdDebug(29000) << "Applied <" << oname << "> successfully" << endl;
+
+	 if( sane_result & SANE_INFO_RELOAD_OPTIONS )
+	 {
+	    kdDebug(29000) << "* Setting status to reload options" << endl;
+	    stat = KSCAN_RELOAD;
+#if 0
+	    qDebug( "Emitting sigOptionChanged()" );
+	    emit( sigOptionsChanged() );
+#endif
+	 }
+
+#if 0
+	 if( sane_result & SANE_INFO_RELOAD_PARAMS )
+	    emit( sigScanParamsChanged() );
+#endif
+	 if( sane_result & SANE_INFO_INEXACT )
+	 {
+	    kdDebug(29000) << "Option <" << oname << "> was set inexact !" << endl;
+	 }
+
+	 /* if it is a gamma table, the gamma values must be stored */
+	 if( isGammaTable )
+	 {
+	    gammaTables->backupOption( *opt );
+	    kdDebug(29000) << "GammaTable stored: " << opt->getName() << endl;
+	 }
+      }
+      else
+      {
+	 kdDebug(29000) << "Status of sane is bad: " << sane_strstatus( sane_stat )
+			<< " for option " << oname << endl;
+
+      }
+   }
+   else
+   {
+      kdDebug(29000) << "Setting of <" << oname << "> failed -> kscanerror." << endl;
+   }
+
+   if( stat == KSCAN_OK )
+   {
+      slSetDirty( oname );
+   }
+
+   return( stat );
+}
+
+bool KScanDevice::optionExists( const QCString& name )
+{
+   if( name.isEmpty() ) return false;
+   int *i = 0L;
+
+   QCString altname = aliasName( name );
+
+   if( ! altname.isNull() )
+       i = (*option_dic)[ altname ];
+
+   if( !i )
+       return( false );
+   return( *i > -1 );
+}
+
+void KScanDevice::slSetDirty( const QCString& name )
+{
+   if( optionExists( name ) )
+   {
+      if( dirtyList.find( name ) == -1 )
+      {
+	 kdDebug(29000)<< "Setting dirty <" << name << ">" << endl;
+	 /* item not found */
+	 dirtyList.append( name );
+      }
+   }
+}
+
+
+/* This function tries to find name aliases which appear from backend to backend.
+ *  Example: Custom-Gamma is for epson backends 'gamma-correction' - not a really
+ *  cool thing :-|
+ *  Maybe this helps us out ?
+ */
+QCString KScanDevice::aliasName( const QCString& name )
+{
+    int *i = (*option_dic)[ name ];
+    QCString ret;
+
+    if( i ) return( name );
+    ret = name;
+
+    if( name == SANE_NAME_CUSTOM_GAMMA )
+    {
+	if((*option_dic)["gamma-correction"])
+	    ret = "gamma-correction";
+
+    }
+
+    if( ret != name )
+	kdDebug( 29000) << "Found alias for <" << name << "> which is <" << ret << ">" << endl;
+
+    return( ret );
+}
+
+
+
+/* Nothing to do yet. This Slot may get active to do same user Widget changes */
+void KScanDevice::slOptChanged( KScanOption *opt )
+{
+    kdDebug(29000) << "Slot Option Changed for Option " << opt->getName() << endl;
+    apply( opt );
+}
+
+/* This might result in a endless recursion ! */
+void KScanDevice::slReloadAllBut( KScanOption *not_opt )
+{
+        if( ! not_opt )
+        {
+            kdDebug(29000) << "ReloadAllBut called with invalid argument" << endl;
+            return;
+        }
+
+        /* Make sure its applied */
+	apply( not_opt );
+
+	kdDebug(29000) << "*** Reload of all except <" << not_opt->getName() << "> forced ! ***" << endl;
+
+	for( KScanOption *so = gui_elements.first(); so; so = gui_elements.next())
+	{
+	    if( so != not_opt )
+	    {
+	       kdDebug(29000) << "Reloading <" << so->getName() << ">" << endl;
+	 	so->slReload();
+	 	so->slRedrawWidget(so);
+	    }
+	}
+	kdDebug(29000) << "*** Reload of all finished ! ***" << endl;
+
+}
+
+
+/* This might result in a endless recursion ! */
+void KScanDevice::slReloadAll( )
+{
+	kdDebug(29000) << "*** Reload of all forced ! ***" << endl;
+
+	for( KScanOption *so = gui_elements.first(); so; so = gui_elements.next())
+	{
+	 	so->slReload();
+	 	so->slRedrawWidget(so);
+	}
+}
+
+
+void KScanDevice::slStopScanning( void )
+{
+    kdDebug(29000) << "Attempt to stop scanning" << endl;
+    if( scanStatus == SSTAT_IN_PROGRESS )
+    {
+	emit( sigScanFinished( KSCAN_CANCELLED ));
+    }
+    scanStatus = SSTAT_STOP_NOW;
+}
+
+
+const QString KScanDevice::previewFile()
+{
+   QString dir = (KGlobal::dirs())->saveLocation( "data", "ScanImages", true );
+   if( !dir.endsWith("/") )
+      dir += "/";
+
+   QString fname = dir + QString::fromLatin1(".previews/");
+   QString sname( getScannerName(shortScannerName()) );
+   sname.replace( '/', "_");
+
+   return fname+sname;
+}
+
+QImage KScanDevice::loadPreviewImage()
+{
+   const QString prevFile = previewFile();
+   kdDebug(29000) << "Loading preview from file " << prevFile << endl;
+
+   QImage image;
+   image.load( prevFile );
+
+   return image;
+}
+
+bool KScanDevice::savePreviewImage( const QImage &image )
+{
+   if( image.isNull() )
+	return false;
+
+   const QString prevFile = previewFile();
+   kdDebug(29000) << "Saving preview to file " << prevFile << endl;
+
+   return image.save( prevFile, "BMP" );
+}
+
+
+KScanStat KScanDevice::acquirePreview( bool forceGray, int dpi )
+{
+   if( ! scanner_handle )
+      return KSCAN_ERR_NO_DEVICE;
+
+   double min, max, q;
+
+   (void) forceGray;
+
+   if( storeOptions )
+      storeOptions->clear();
+   else
+      storeOptions = new KScanOptSet( "TempStore" );
+
+
+   /* set Preview = ON if exists */
+   if( optionExists( SANE_NAME_PREVIEW ) )
+   {
+      KScanOption prev( aliasName(SANE_NAME_PREVIEW) );
+
+      prev.set( true );
+      apply( &prev );
+
+      /* after having applied, save set to false to switch preview mode off after
+	 scanning */
+      prev.set( false );
+      storeOptions->backupOption( prev );
+   }
+
+   /* Gray-Preview only  done by widget ? */
+   if( optionExists( SANE_NAME_GRAY_PREVIEW ))
+   {
+     KScanOption *so = getExistingGuiElement( SANE_NAME_GRAY_PREVIEW );
+     if( so )
+     {
+       if( so->get() == "true" )
+       {
+	 /* Gray preview on */
+	 so->set( true );
+	 kdDebug(29000) << "Setting GrayPreview ON" << endl;
+       }
+       else
+       {
+	 so->set(false );
+	 kdDebug(29000) << "Setting GrayPreview OFF" << endl;
+       }
+     }
+     apply( so );
+   }
+
+
+   if( optionExists( SANE_NAME_SCAN_MODE ) )
+   {
+      KScanOption mode( SANE_NAME_SCAN_MODE );
+      const QString kk = mode.get();
+      kdDebug(29000) << "Mode is <" << kk << ">" << endl;
+      storeOptions->backupOption( mode );
+      /* apply if it has a widget, or apply always ? */
+      if( mode.widget() ) apply( &mode );
+   }
+
+   /** Scan Resolution should always exist. **/
+   KScanOption res ( SANE_NAME_SCAN_RESOLUTION );
+   const QString p = res.get();
+
+   kdDebug(29000) << "Scan Resolution pre Preview is " << p << endl;
+   storeOptions->backupOption( res );
+
+   int set_dpi = dpi;
+
+   if( dpi == 0 )
+   {
+       /* No resolution argument */
+       if( ! res.getRange( &min, &max, &q ) )
+       {
+	   if( ! res.getRangeFromList ( &min, &max, &q ) )
+	   {
+	       kdDebug(29000) << "Could not retrieve resolution range!" << endl;
+	       min = 75.0; // Hope that every scanner can 75
+	   }
+       }
+       kdDebug(29000) << "Minimum Range: " << min << ", Maximum Range: " << max << endl;
+
+      if( min > MIN_PREVIEW_DPI )
+	 set_dpi = (int) min;
+      else
+	 set_dpi = MIN_PREVIEW_DPI;
+   }
+
+   /* Set scan resolution for preview. */
+   if( !optionExists( SANE_NAME_SCAN_Y_RESOLUTION ) )
+      d->currScanResolutionY = 0;
+   else
+   {
+      KScanOption yres ( SANE_NAME_SCAN_Y_RESOLUTION );
+      /* if active ? */
+      storeOptions->backupOption( yres );
+      yres.set( set_dpi );
+      apply( &yres );
+      yres.get( &d->currScanResolutionY );
+
+      /* Resolution bind switch ? */
+      if( optionExists( SANE_NAME_RESOLUTION_BIND ) )
+      {
+	 KScanOption bind_so( SANE_NAME_RESOLUTION_BIND );
+	 /* Switch binding on if available */
+	 storeOptions->backupOption( bind_so );
+	 bind_so.set( true );
+	 apply( &bind_so );
+      }
+   }
+
+   res.set( set_dpi );
+   apply( &res );
+
+   /* Store the resulting preview for additional image information */
+   res.get( &d->currScanResolutionX );
+
+   if ( d->currScanResolutionY == 0 )
+      d->currScanResolutionY = d->currScanResolutionX;
+
+   /* Start scanning */
+   KScanStat stat = acquire_data( true );
+
+   /* Restauration of the previous values must take place in the scanfinished slot,
+    *  because scanning works asynchron now.
+    */
+
+   return( stat );
+}
+
+
+
+/**
+ * prepareScan tries to set as much as parameters as possible.
+ *
+ **/
+#define NOTIFIER(X) optionNotifyString(X)
+
+QString KScanDevice::optionNotifyString( int i ) const
+{
+    const QString sOff = "        |";
+    const QString sOn  = "   X    |";   
+    if( i > 0 )
+    {
+	return sOn;
+    }
+    return sOff;
+}
+
+
+void KScanDevice::prepareScan( void )
+{
+    QAsciiDictIterator<int> it( *option_dic ); // iterator for dict
+
+    kdDebug(29000) << "########################################################################################################" << endl;
+    kdDebug(29000) << "Scanner: " << scanner_name << endl;
+    kdDebug(29000) << "         " << getScannerName() << endl;
+    kdDebug(29000) << "----------------------------------+--------+--------+--------+--------+--------+--------+--------+" << endl;
+    kdDebug(29000) << " Option-Name                      |SOFT_SEL|HARD_SEL|SOFT_DET|EMULATED|AUTOMATI|INACTIVE|ADVANCED|" << endl;
+    kdDebug(29000) << "----------------------------------+--------+--------+--------+--------+--------+--------+--------+" << endl;
+
+    while ( it.current() )
+    {
+       // qDebug( "%s -> %d", it.currentKey().latin1(), *it.current() );
+       int descriptor = *it.current();
+
+       const SANE_Option_Descriptor *d = sane_get_option_descriptor( scanner_handle, descriptor );
+
+       if( d )
+       {
+	  int cap = d->cap;
+	  
+	  QString s = QString(it.currentKey()).leftJustify(32, ' ');
+	  kdDebug(29000) << " " << s << " |" <<
+		 NOTIFIER( ((cap) & SANE_CAP_SOFT_SELECT)) << 
+		 NOTIFIER( ((cap) & SANE_CAP_HARD_SELECT)) << 
+		 NOTIFIER( ((cap) & SANE_CAP_SOFT_DETECT)) << 
+		 NOTIFIER( ((cap) & SANE_CAP_EMULATED)   ) << 
+		 NOTIFIER( ((cap) & SANE_CAP_AUTOMATIC)  ) << 
+		 NOTIFIER( ((cap) & SANE_CAP_INACTIVE)   ) << 
+		 NOTIFIER( ((cap) & SANE_CAP_ADVANCED )  )    << endl;
+
+       }
+       ++it;
+    }
+    kdDebug(29000) << "----------------------------------+--------+--------+--------+--------+--------+--------+--------+" << endl;
+
+    KScanOption pso( SANE_NAME_PREVIEW );
+    const QString q = pso.get();
+
+    kdDebug(29000) << "Preview-Switch is at the moment: " << q << endl;
+
+
+}
+
+/** Starts scanning
+ *  depending on if a filename is given or not, the function tries to open
+ *  the file using the Qt-Image-IO or really scans the image.
+ **/
+KScanStat KScanDevice::acquire( const QString& filename )
+{
+    if( ! scanner_handle )
+       return KSCAN_ERR_NO_DEVICE;
+
+    KScanOption *so = 0;
+
+    if( filename.isEmpty() )
+    {
+ 	/* *real* scanning - apply all Options and go for it */
+ 	prepareScan();
+
+ 	for( so = gui_elements.first(); so; so = gui_elements.next() )
+ 	{
+ 	    if( so->active() )
+ 	    {
+ 	         kdDebug(29000) << "apply <" << so->getName() << ">" << endl;
+ 	         apply( so );
+ 	    }
+ 	    else
+ 	    {
+ 	        kdDebug(29000) << "Option <" << so->getName() << "> is not active !" << endl;
+ 	    }
+ 	}
+
+	/** Scan Resolution should always exist. **/
+	KScanOption res( SANE_NAME_SCAN_RESOLUTION );
+	res.get( &d->currScanResolutionX );
+        if ( !optionExists( SANE_NAME_SCAN_Y_RESOLUTION ) )
+           d->currScanResolutionY = d->currScanResolutionX;
+        else
+        {
+           KScanOption yres( SANE_NAME_SCAN_Y_RESOLUTION );
+           yres.get( &d->currScanResolutionY );
+        }
+
+	return( acquire_data( false ));
+    }
+    else
+    {
+   	/* a filename is in the parameter */
+	QFileInfo file( filename );
+	if( file.exists() )
+	{
+	     QImage i;
+	     ImgScanInfo info;
+	     if( i.load( filename ))
+	     {
+		info.setXResolution(i.dotsPerMeterX()); // TODO: *2.54/100
+		info.setYResolution(i.dotsPerMeterY()); // TODO: *2.54/100
+		info.setScannerName(filename);
+		emit( sigNewImage( &i, &info ));
+	     }
+	}
+    }
+
+    return KSCAN_OK;
+}
+
+
+/**
+ *  Creates a new QImage from the retrieved Image Options
+ **/
+KScanStat KScanDevice::createNewImage( SANE_Parameters *p )
+{
+  if( !p ) return( KSCAN_ERR_PARAM );
+  KScanStat       stat = KSCAN_OK;
+
+  if( img ) {
+     delete( img );
+     img = 0;
+  }
+
+  if( p->depth == 1 )  //  Lineart !!
+  {
+    img =  new QImage( p->pixels_per_line, p->lines, 8 );
+    if( img )
+    {
+      img->setNumColors( 2 );
+      img->setColor( 0, qRgb( 0,0,0));
+      img->setColor( 1, qRgb( 255,255,255) );
+    }
+  }
+  else if( p->depth == 8 )
+  {
+    // 8 bit rgb-Picture
+    if( p->format == SANE_FRAME_GRAY )
+    {
+      /* Grayscale */
+      img = new QImage( p->pixels_per_line, p->lines, 8 );
+      if( img )
+      {
+	img->setNumColors( 256 );
+
+	for(int i = 0; i<256; i++)
+	  img->setColor(i, qRgb(i,i,i));
+      }
+    }
+    else
+    {
+      /* true color image */
+      img =  new QImage( p->pixels_per_line, p->lines, 32 );
+      if( img )
+	img->setAlphaBuffer( false );
+    }
+  }
+  else
+  {
+    /* ERROR: NO OTHER DEPTHS supported */
+    kdDebug(29000) << "KScan supports only bit dephts 1 and 8 yet!" << endl;
+  }
+
+  if( ! img ) stat = KSCAN_ERR_MEMORY;
+  return( stat );
+}
+
+
+KScanStat KScanDevice::acquire_data( bool isPreview )
+{
+   SANE_Status	  sane_stat = SANE_STATUS_GOOD;
+   KScanStat       stat = KSCAN_OK;
+
+   scanningPreview = isPreview;
+
+   emit sigScanStart();
+
+   sane_stat = sane_start( scanner_handle );
+   if( sane_stat == SANE_STATUS_GOOD )
+   {
+      sane_stat = sane_get_parameters( scanner_handle, &sane_scan_param );
+
+      if( sane_stat == SANE_STATUS_GOOD )
+      {
+	 kdDebug(29000) << "--Pre-Loop" << endl;
+	 kdDebug(29000) << "format : " << sane_scan_param.format << endl;
+	 kdDebug(29000) << "last_frame : " << sane_scan_param.last_frame << endl;
+	 kdDebug(29000) << "lines : " << sane_scan_param.lines << endl;
+	 kdDebug(29000) << "depth : " << sane_scan_param.depth << endl;
+	 kdDebug(29000) << "pixels_per_line : " << sane_scan_param.pixels_per_line << endl;
+	 kdDebug(29000) << "bytes_per_line : " << sane_scan_param.bytes_per_line << endl;
+      }
+      else
+      {
+	 stat = KSCAN_ERR_OPEN_DEV;
+	 kdDebug(29000) << "sane-get-parameters-Error: " << sane_strstatus( sane_stat ) << endl;
+      }
+   }
+   else
+   {
+	 stat = KSCAN_ERR_OPEN_DEV;
+	 kdDebug(29000) << "sane-start-Error: " << sane_strstatus( sane_stat ) << endl;
+   }
+
+
+   if( sane_scan_param.pixels_per_line == 0 || sane_scan_param.lines < 1 )
+   {
+      kdDebug(29000) << "ERROR: Acquiring empty picture !" << endl;
+      stat = KSCAN_ERR_EMPTY_PIC;
+   }
+
+   /* Create new Image from SANE-Parameters */
+   if( stat == KSCAN_OK )
+   {
+      stat = createNewImage( &sane_scan_param );
+   }
+
+   if( stat == KSCAN_OK )
+   {
+      /* new buffer for scanning one line */
+      if(data) delete [] data;
+      data = new SANE_Byte[ sane_scan_param.bytes_per_line +4 ];
+      if( ! data ) stat = KSCAN_ERR_MEMORY;
+   }
+
+   /* Signal for a progress dialog */
+   emit( sigScanProgress( 0 ) );
+   emit( sigAcquireStart() );
+
+   if( stat == KSCAN_OK )
+   {
+      /* initiates Redraw of the Progress-Window */
+      qApp->processEvents();
+   }
+
+   if( stat == KSCAN_OK )
+   {
+      overall_bytes 	= 0;
+      scanStatus = SSTAT_IN_PROGRESS;
+      pixel_x 		    = 0;
+      pixel_y 		    = 0;
+      overall_bytes         = 0;
+      rest_bytes            = 0;
+
+      /* internal status to indicate Scanning in progress
+       *  this status might be changed by pressing Stop on a GUI-Dialog displayed during scan */
+      if( sane_set_io_mode( scanner_handle, SANE_TRUE ) == SANE_STATUS_GOOD )
+      {
+
+	 int fd = 0;
+	 if( sane_get_select_fd( scanner_handle, &fd ) == SANE_STATUS_GOOD )
+	 {
+	    sn = new QSocketNotifier( fd, QSocketNotifier::Read, this );
+	    QObject::connect( sn, SIGNAL(activated(int)),
+			      this, SLOT( doProcessABlock() ) );
+
+	 }
+      }
+      else
+      {
+	 do
+	 {
+	    doProcessABlock();
+	    if( scanStatus != SSTAT_SILENT )
+	    {
+	       sane_stat = sane_get_parameters( scanner_handle, &sane_scan_param );
+	       kdDebug(29000) << "--ProcessABlock-Loop" << endl;
+	       kdDebug(29000) << "format : " << sane_scan_param.format << endl;
+	       kdDebug(29000) << "last_frame : " << sane_scan_param.last_frame << endl;
+	       kdDebug(29000) << "lines : " << sane_scan_param.lines << endl;
+	       kdDebug(29000) << "depth : " << sane_scan_param.depth << endl;
+	       kdDebug(29000) << "pixels_per_line : " << sane_scan_param.pixels_per_line << endl;
+	       kdDebug(29000) << "bytes_per_line : " << sane_scan_param.bytes_per_line << endl;
+	    }
+	 } while ( scanStatus != SSTAT_SILENT );
+      }
+   }
+
+   if( stat != KSCAN_OK )
+   {
+      /* Scanning was disturbed in any way - end it */
+      kdDebug(29000) << "Scanning was disturbed - clean up" << endl;
+      emit( sigScanFinished( stat ));
+   }
+   return( stat );
+}
+
+void KScanDevice::loadOptionSet( KScanOptSet *optSet )
+{
+   if( !optSet )
+   {
+      return;
+   }
+
+   // kdDebug(29000) << "Loading Option set: " << optSet->optSetName() << endl;
+   QAsciiDictIterator<KScanOption> it(*optSet);
+
+   kdDebug(29000) << "Postinstalling " << optSet->count() << " options" << endl;
+   while( it.current() )
+   {
+      KScanOption *so = it.current();
+      if( ! so->initialised() )
+	 kdDebug(29000) << so->getName() << " is not initialised" << endl;
+
+      if( ! so->active() )
+	 kdDebug(29000) << so->getName() << " is not active" << endl;
+
+      if( so && so->active() && so->initialised())
+      {
+	 const QString qq = so->get();
+
+	 kdDebug(29000) << "Post-Scan-apply <" << it.currentKey() << ">: " << qq << endl;
+	 apply( so );
+      }
+      ++it;
+   }
+
+}
+
+
+void KScanDevice::slScanFinished( KScanStat status )
+{
+    // clean up
+    if( sn ) {
+	sn->setEnabled( false );
+	delete sn;
+	sn = 0;
+    }
+
+    emit( sigScanProgress( MAX_PROGRESS ));
+
+    kdDebug(29000) << "Slot ScanFinished hit with status " <<  status << endl;
+
+    if( data )
+    {
+	delete[] data;
+	data = 0;
+    }
+
+    if( status == KSCAN_OK && img )
+    {
+	ImgScanInfo info;
+	info.setXResolution(d->currScanResolutionX);
+	info.setYResolution(d->currScanResolutionY);
+	info.setScannerName(shortScannerName());
+
+	// put the resolution also into the image itself
+	img->setDotsPerMeterX(static_cast<int>(d->currScanResolutionX / 0.0254 + 0.5));
+	img->setDotsPerMeterY(static_cast<int>(d->currScanResolutionY / 0.0254 + 0.5));
+	kdDebug(29000) << "resolutionX:" << d->currScanResolutionX << " resolutionY:" << d->currScanResolutionY << endl;
+
+	if( scanningPreview )
+	{
+	    kdDebug(29000) << "Scanning a preview !" << endl;
+	    savePreviewImage(*img);
+	    emit( sigNewPreview( img, &info ));
+
+	    /* The old settings need to be redefined */
+	    loadOptionSet( storeOptions );
+	}
+	else
+	{
+	    emit( sigNewImage( img, &info ));
+	}
+    }
+
+
+    sane_cancel(scanner_handle);
+
+    /* This follows after sending the signal */
+    if( img )
+    {
+	delete img;
+	img = 0;
+    }
+
+    /* delete the socket notifier */
+    if( sn ) {
+	delete( sn );
+	sn = 0;
+    }
+
+}
+
+
+/* This function calls at least sane_read and converts the read data from the scanner
+ * to the qimage.
+ * The function needs:
+ * QImage img valid
+ * the data-buffer  set to a appropriate size
+ **/
+
+void KScanDevice::doProcessABlock( void )
+{
+  int 		  val,i;
+  QRgb      	  col, newCol;
+
+  SANE_Byte	  *rptr         = 0;
+  SANE_Int	  bytes_written = 0;
+  int		  chan          = 0;
+  SANE_Status     sane_stat     = SANE_STATUS_GOOD;
+  uchar	          eight_pix     = 0;
+  bool 	  goOn = true;
+
+  // int 	rest_bytes = 0;
+  while( goOn && data )
+  {
+     sane_stat =
+	sane_read( scanner_handle, data + rest_bytes, sane_scan_param.bytes_per_line, &bytes_written);
+     int	red = 0;
+     int       green = 0;
+     int       blue = 0;
+
+     if( sane_stat != SANE_STATUS_GOOD )
+     {
+	/** any other error **/
+	kdDebug(29000) << "sane_read returned with error <" << sane_strstatus( sane_stat ) << ">: " << bytes_written << " bytes left" << endl;
+	goOn = false;
+     }
+
+     if( goOn && bytes_written < 1 )
+     {
+	// qDebug( "No bytes written -> leaving out !" );
+	goOn = false;  /** No more data -> leave ! **/
+     }
+
+     if( goOn )
+     {
+	overall_bytes += bytes_written;
+	// qDebug( "Bytes read: %d, bytes written: %d", bytes_written, rest_bytes );
+
+	rptr = data; // + rest_bytes;
+
+	switch( sane_scan_param.format )
+	{
+	   case SANE_FRAME_RGB:
+	      if( sane_scan_param.lines < 1 ) break;
+	      bytes_written += rest_bytes; // die übergebliebenen Bytes dazu
+	      rest_bytes = bytes_written % 3;
+
+	      for( val = 0; val < ((bytes_written-rest_bytes) / 3); val++ )
+	      {
+		 red   = *rptr++;
+		 green = *rptr++;
+		 blue  = *rptr++;
+
+		 // kdDebug(29000) <<  "RGB: %d, %d, %d\n", red, green, blue" << endl;
+		 if( pixel_x  == sane_scan_param.pixels_per_line )
+		 { pixel_x = 0; pixel_y++; }
+		 if( pixel_y < img->height())
+		    img->setPixel( pixel_x, pixel_y, qRgb( red, green,blue ));
+
+		 pixel_x++;
+	      }
+	      /* copy the remaining bytes to the beginning of the block :-/ */
+	      for( val = 0; val < rest_bytes; val++ )
+	      {
+		 *(data+val) = *rptr++;
+	      }
+
+	      break;
+	   case SANE_FRAME_GRAY:
+	      for( val = 0; val < bytes_written ; val++ )
+	      {
+		 if( pixel_y >= sane_scan_param.lines ) break;
+		 if( sane_scan_param.depth == 8 )
+		 {
+		    if( pixel_x  == sane_scan_param.pixels_per_line ) { pixel_x = 0; pixel_y++; }
+		    img->setPixel( pixel_x, pixel_y, *rptr++ );
+		    pixel_x++;
+		 }
+		 else
+		 {  // Lineart
+		    /* Lineart needs to be converted to byte */
+		    eight_pix = *rptr++;
+		    for( i = 0; i < 8; i++ )
+		    {
+		       if( pixel_y < sane_scan_param.lines )
+		       {
+			  chan = (eight_pix & 0x80)> 0 ? 0:1;
+			  eight_pix = eight_pix << 1;
+			    	//qDebug( "Setting on %d, %d: %d", pixel_x, pixel_y, chan );
+			  img->setPixel( pixel_x, pixel_y, chan );
+			  pixel_x++;
+			  if( pixel_x  >= sane_scan_param.pixels_per_line )
+			  {
+			     pixel_x = 0; pixel_y++;
+			     break;
+			  }
+		       }
+		    }
+		 }
+	      }
+
+	      break;
+	   case SANE_FRAME_RED:
+	   case SANE_FRAME_GREEN:
+	   case SANE_FRAME_BLUE:
+	      kdDebug(29000) << "Scanning Single color Frame: " << bytes_written << " Bytes!" << endl;
+	      for( val = 0; val < bytes_written ; val++ )
+	      {
+		 if( pixel_x >= sane_scan_param.pixels_per_line )
+		 {
+		    pixel_y++; pixel_x = 0;
+		 }
+
+		 if( pixel_y < sane_scan_param.lines )
+		 {
+
+		    col = img->pixel( pixel_x, pixel_y );
+
+		    red   = qRed( col );
+		    green = qGreen( col );
+		    blue  = qBlue( col );
+		    chan  = *rptr++;
+
+		    switch( sane_scan_param.format )
+		    {
+		       case SANE_FRAME_RED :
+			  newCol = qRgba( chan, green, blue, 0xFF );
+			  break;
+		       case SANE_FRAME_GREEN :
+			  newCol = qRgba( red, chan, blue, 0xFF );
+			  break;
+		       case SANE_FRAME_BLUE :
+			  newCol = qRgba( red , green, chan, 0xFF );
+			  break;
+		       default:
+			  kdDebug(29000) << "Undefined format !" << endl;
+			  newCol = qRgba( 0xFF, 0xFF, 0xFF, 0xFF );
+			  break;
+		    }
+		    img->setPixel( pixel_x, pixel_y, newCol );
+		    pixel_x++;
+		 }
+	      }
+	      break;
+	   default:
+	      kdDebug(29000) << "Unexpected ERROR: No Format type" << endl;
+	      break;
+	} /* switch */
+
+
+	if( (sane_scan_param.lines > 0) && (sane_scan_param.lines * pixel_y> 0) )
+	{
+	   int progress =  (int)(((double)MAX_PROGRESS) / sane_scan_param.lines *
+				  pixel_y);
+	   if( progress < MAX_PROGRESS)
+	      emit( sigScanProgress( progress));
+	}
+
+	if( bytes_written == 0 || sane_stat == SANE_STATUS_EOF )
+	{
+	   kdDebug(29000) << "Down under sane_stat not OK" << endl;
+	   goOn = false;
+	}
+     }
+
+     if( goOn && scanStatus == SSTAT_STOP_NOW )
+     {
+	/* scanStatus is set to SSTAT_STOP_NOW due to hitting slStopScanning   */
+	/* Mostly that one is fired by the STOP-Button in the progress dialog. */
+
+	/* This is also hit after the normal finish of the scan. Most probably,
+	 * the QSocketnotifier fires for a few times after the scan has been
+	 * cancelled.  Does it matter ? To see it, just uncomment the qDebug msg.
+	 */
+	kdDebug(29000) << "Stopping the scan progress !" << endl;
+	goOn = false;
+	scanStatus = SSTAT_SILENT;
+	emit( sigScanFinished( KSCAN_OK ));
+     }
+
+  } /* while( 1 ) */
+
+
+  /** Comes here if scanning is finished or has an error **/
+  if( sane_stat == SANE_STATUS_EOF)
+  {
+     if ( sane_scan_param.last_frame)
+     {
+	/** Everythings okay, the picture is ready **/
+	kdDebug(29000) << "last frame reached - scan successful" << endl;
+	scanStatus = SSTAT_SILENT;
+	emit( sigScanFinished( KSCAN_OK ));
+     }
+     else
+     {
+	/** EOF und nicht letzter Frame -> Parameter neu belegen und neu starten **/
+	scanStatus = SSTAT_NEXT_FRAME;
+	kdDebug(29000) << "EOF, but another frame to scan" << endl;
+
+     }
+  }
+
+  if( sane_stat == SANE_STATUS_CANCELLED )
+  {
+     scanStatus = SSTAT_STOP_NOW;
+     kdDebug(29000) << "Scan was cancelled" << endl;
+
+     // stat = KSCAN_CANCELLED;
+     // emit( sigScanFinished( stat ));
+
+     /* hmmm - how could this happen ? */
+  }
+} /* end of fkt */
+
+
+void KScanDevice::slSaveScanConfigSet( const QString& setName, const QString& descr )
+{
+   if( setName.isEmpty() || setName.isNull()) return;
+
+   kdDebug(29000) << "Saving Scan Configuration" << setName << endl;
+
+   KScanOptSet optSet( DEFAULT_OPTIONSET );
+   getCurrentOptions( &optSet );
+
+   optSet.saveConfig( scanner_name , setName, descr );
+
+}
+
+
+void  KScanDevice::getCurrentOptions( KScanOptSet *optSet )
+{
+   if( ! optSet ) return;
+
+   for( KScanOption *so = gui_elements.first(); so; so = gui_elements.next())
+   {
+      kdDebug(29000) << "Storing <" << so->getName() << ">" << endl;
+      if( so && so->active())
+      {
+	 apply(so);
+	 optSet->backupOption( *so );
+      }
+
+      /* drop the thing from the dirty-list */
+      dirtyList.removeRef( so->getName());
+   }
+
+   QStrListIterator it( dirtyList );
+   while( it.current())
+   {
+      KScanOption so( it.current() );
+      optSet->backupOption( so );
+      ++it;
+   }
+}
+
+QString KScanDevice::getConfig( const QString& key, const QString& def ) const
+{
+    QString confFile = SCANNER_DB_FILE;
+
+    KSimpleConfig scanConfig( confFile, true );
+    scanConfig.setGroup( shortScannerName() );
+
+    return scanConfig.readEntry( key, def );
+}
+
+void KScanDevice::slStoreConfig( const QString& key, const QString& val )
+{
+    QString confFile = SCANNER_DB_FILE;
+    QString scannerName = shortScannerName();
+
+    if( scannerName.isEmpty() || scannerName == UNDEF_SCANNERNAME )
+    {
+        kdDebug(29000) << "Skipping config write, scanner name is empty!" << endl;
+    }
+    else
+    {
+        kdDebug(29000) << "Storing config " << key << " in Group " << scannerName << endl;
+
+        KSimpleConfig scanConfig( confFile );
+        scanConfig.setGroup( scannerName );
+        scanConfig.writeEntry( key, val );
+        scanConfig.sync();
+    }
+}
+
+
+bool KScanDevice::scanner_initialised = false;
+SANE_Handle KScanDevice::scanner_handle = 0L;
+SANE_Device const **KScanDevice::dev_list = 0L;
+QAsciiDict<int> *KScanDevice::option_dic = 0L;
+KScanOptSet *KScanDevice::gammaTables = 0L;
+
+
+#include "kscandevice.moc"