LCOV - code coverage report
Current view: top level - extensions/source/scanner - sane.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 494 0.0 %
Date: 2014-04-14 Functions: 0 27 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <cstdarg>
      21             : #include <math.h>
      22             : #include <osl/file.h>
      23             : #include <tools/stream.hxx>
      24             : #include <sane.hxx>
      25             : #include <dlfcn.h>
      26             : #include <stdio.h>
      27             : #include <unistd.h>
      28             : #include <sys/time.h>
      29             : #include <sys/types.h>
      30             : #include <sal/config.h>
      31             : #include <sal/macros.h>
      32             : #include <boost/scoped_array.hpp>
      33             : 
      34             : #if (OSL_DEBUG_LEVEL > 1) || defined DBG_UTIL
      35             : #include <stdarg.h>
      36             : #define dump_state( a, b, c, d ) fprintf( stderr, a, b, c, d );
      37             : #else
      38             : #define dump_state( a, b, c, d ) ;
      39             : #endif
      40           0 : inline void dbg_msg( const char* pString, ... )
      41             : {
      42             : #if (OSL_DEBUG_LEVEL > 1) || defined DBG_UTIL
      43             :     va_list ap;
      44             :     va_start( ap, pString );
      45             :     vfprintf( stderr, pString, ap );
      46             :     va_end( ap );
      47             : #else
      48             :     (void)pString;
      49             : #endif
      50           0 : }
      51             : 
      52             : #define FAIL_SHUTDOWN_STATE( x, y, z ) \
      53             :     if( x != SANE_STATUS_GOOD )                             \
      54             :     {                                                       \
      55             :         dump_state( "%s returned error %d (%s)\n",          \
      56             :                  y, x, p_strstatus( x ) );                  \
      57             :         DeInit();                                           \
      58             :         return z;                                           \
      59             :     }
      60             : 
      61             : #define FAIL_STATE( x, y, z ) \
      62             :     if( x != SANE_STATUS_GOOD )                             \
      63             :     {                                                       \
      64             :         dump_state( "%s returned error %d (%s)\n",          \
      65             :                  y, x, p_strstatus( x ) );                  \
      66             :         return z;                                           \
      67             :     }
      68             : 
      69             : #define DUMP_STATE( x, y ) \
      70             :     if( x != SANE_STATUS_GOOD )                             \
      71             :     {                                                       \
      72             :         dump_state( "%s returned error %d (%s)\n",          \
      73             :                  y, x, p_strstatus( x ) );                  \
      74             :     }
      75             : 
      76             : int             Sane::nRefCount = 0;
      77             : oslModule       Sane::pSaneLib = 0;
      78             : SANE_Int        Sane::nVersion = 0;
      79             : SANE_Device**   Sane::ppDevices = 0;
      80             : int             Sane::nDevices = 0;
      81             : 
      82             : SANE_Status     (*Sane::p_init)( SANE_Int*,
      83             :                                  SANE_Auth_Callback ) = 0;
      84             : void            (*Sane::p_exit)() = 0;
      85             : SANE_Status     (*Sane::p_get_devices)( const SANE_Device***,
      86             :                                         SANE_Bool ) = 0;
      87             : SANE_Status     (*Sane::p_open)( SANE_String_Const, SANE_Handle ) = 0;
      88             : void            (*Sane::p_close)( SANE_Handle ) = 0;
      89             : const SANE_Option_Descriptor* (*Sane::p_get_option_descriptor)(
      90             :     SANE_Handle, SANE_Int ) = 0;
      91             : SANE_Status     (*Sane::p_control_option)( SANE_Handle, SANE_Int,
      92             :                                            SANE_Action, void*,
      93             :                                            SANE_Int* ) = 0;
      94             : SANE_Status     (*Sane::p_get_parameters)( SANE_Handle,
      95             :                                            SANE_Parameters* ) = 0;
      96             : SANE_Status     (*Sane::p_start)( SANE_Handle ) = 0;
      97             : SANE_Status     (*Sane::p_read)( SANE_Handle, SANE_Byte*, SANE_Int,
      98             :                                  SANE_Int* ) = 0;
      99             : void            (*Sane::p_cancel)( SANE_Handle ) = 0;
     100             : SANE_Status     (*Sane::p_set_io_mode)( SANE_Handle, SANE_Bool ) = 0;
     101             : SANE_Status     (*Sane::p_get_select_fd)( SANE_Handle, SANE_Int* ) = 0;
     102             : SANE_String_Const (*Sane::p_strstatus)( SANE_Status ) = 0;
     103             : 
     104             : static sal_Bool bSaneSymbolLoadFailed = sal_False;
     105             : 
     106           0 : inline oslGenericFunction Sane::LoadSymbol( const char* pSymbolname )
     107             : {
     108           0 :     oslGenericFunction pFunction = osl_getAsciiFunctionSymbol( pSaneLib, pSymbolname );
     109           0 :     if( ! pFunction )
     110             :     {
     111             :         fprintf( stderr, "Could not load symbol %s\n",
     112           0 :                  pSymbolname );
     113           0 :         bSaneSymbolLoadFailed = sal_True;
     114             :     }
     115           0 :     return pFunction;
     116             : }
     117             : 
     118           0 : SANE_Status Sane::ControlOption( int nOption, SANE_Action nAction,
     119             :                                  void* pData )
     120             : {
     121           0 :     SANE_Int    nInfo = 0;
     122             : 
     123             :     SANE_Status nStatus = p_control_option( maHandle, (SANE_Int)nOption,
     124           0 :                                 nAction, pData, &nInfo );
     125             :     DUMP_STATE( nStatus, "sane_control_option" );
     126             : #if OSL_DEBUG_LEVEL > 1
     127             :     if( nStatus != SANE_STATUS_GOOD )
     128             :     {
     129             :         const char* pAction = "Unknown";
     130             :         switch( nAction )
     131             :         {
     132             :             case SANE_ACTION_GET_VALUE:
     133             :                 pAction = "SANE_ACTION_GET_VALUE";break;
     134             :             case SANE_ACTION_SET_VALUE:
     135             :                 pAction = "SANE_ACTION_SET_VALUE";break;
     136             :             case SANE_ACTION_SET_AUTO:
     137             :                 pAction = "SANE_ACTION_SET_AUTO";break;
     138             :         }
     139             :         dbg_msg( "Option: \"%s\" action: %s\n",
     140             :                  OUStringToOString(GetOptionName(nOption), osl_getThreadTextEncoding()).getStr(),
     141             :                  pAction );
     142             :     }
     143             : #endif
     144           0 :     if( nInfo &  SANE_INFO_RELOAD_OPTIONS )
     145           0 :         ReloadOptions();
     146           0 :     return nStatus;
     147             : }
     148             : 
     149           0 : Sane::Sane() :
     150             :         mppOptions( 0 ),
     151             :         mnOptions( 0 ),
     152             :         mnDevice( -1 ),
     153           0 :         maHandle( 0 )
     154             : {
     155           0 :     if( ! nRefCount || ! pSaneLib )
     156           0 :         Init();
     157           0 :     nRefCount++;
     158           0 : };
     159             : 
     160           0 : Sane::~Sane()
     161             : {
     162           0 :     if( IsOpen() )
     163           0 :         Close();
     164           0 :     nRefCount--;
     165           0 :     if( ! nRefCount && pSaneLib )
     166           0 :         DeInit();
     167           0 : }
     168             : 
     169           0 : void Sane::Init()
     170             : {
     171           0 :     OUString sSaneLibName( "libsane" SAL_DLLEXTENSION  );
     172           0 :     pSaneLib = osl_loadModule( sSaneLibName.pData, SAL_LOADMODULE_LAZY );
     173           0 :     if( ! pSaneLib )
     174             :     {
     175           0 :         sSaneLibName = "libsane" SAL_DLLEXTENSION ".1";
     176           0 :         pSaneLib = osl_loadModule( sSaneLibName.pData, SAL_LOADMODULE_LAZY );
     177             :     }
     178             :     // try reasonable places that might not be in the library search path
     179           0 :     if( ! pSaneLib )
     180             :     {
     181           0 :         OUString sSaneLibSystemPath( "/usr/local/lib/libsane" SAL_DLLEXTENSION  );
     182           0 :         osl_getFileURLFromSystemPath( sSaneLibSystemPath.pData, &sSaneLibName.pData );
     183           0 :         pSaneLib = osl_loadModule( sSaneLibName.pData, SAL_LOADMODULE_LAZY );
     184             :     }
     185             : 
     186           0 :     if( pSaneLib )
     187             :     {
     188           0 :         bSaneSymbolLoadFailed = sal_False;
     189             :         p_init = (SANE_Status(*)(SANE_Int*, SANE_Auth_Callback ))
     190           0 :             LoadSymbol( "sane_init" );
     191             :         p_exit = (void(*)())
     192           0 :             LoadSymbol( "sane_exit" );
     193             :         p_get_devices = (SANE_Status(*)(const SANE_Device***,
     194             :                                         SANE_Bool ))
     195           0 :             LoadSymbol( "sane_get_devices" );
     196             :         p_open = (SANE_Status(*)(SANE_String_Const, SANE_Handle ))
     197           0 :             LoadSymbol( "sane_open" );
     198             :         p_close = (void(*)(SANE_Handle))
     199           0 :             LoadSymbol( "sane_close" );
     200             :         p_get_option_descriptor = (const SANE_Option_Descriptor*(*)(SANE_Handle,
     201             :                                                               SANE_Int))
     202           0 :             LoadSymbol( "sane_get_option_descriptor" );
     203             :         p_control_option = (SANE_Status(*)(SANE_Handle, SANE_Int,
     204             :                                            SANE_Action, void*, SANE_Int*))
     205           0 :             LoadSymbol( "sane_control_option" );
     206             :         p_get_parameters = (SANE_Status(*)(SANE_Handle,SANE_Parameters*))
     207           0 :             LoadSymbol( "sane_get_parameters" );
     208             :         p_start = (SANE_Status(*)(SANE_Handle))
     209           0 :             LoadSymbol( "sane_start" );
     210             :         p_read = (SANE_Status(*)(SANE_Handle, SANE_Byte*,
     211             :                                  SANE_Int, SANE_Int* ))
     212           0 :             LoadSymbol( "sane_read" );
     213             :         p_cancel = (void(*)(SANE_Handle))
     214           0 :             LoadSymbol( "sane_cancel" );
     215             :         p_set_io_mode = (SANE_Status(*)(SANE_Handle, SANE_Bool))
     216           0 :             LoadSymbol( "sane_set_io_mode" );
     217             :         p_get_select_fd = (SANE_Status(*)(SANE_Handle, SANE_Int*))
     218           0 :             LoadSymbol( "sane_get_select_fd" );
     219             :         p_strstatus = (SANE_String_Const(*)(SANE_Status))
     220           0 :             LoadSymbol( "sane_strstatus" );
     221           0 :         if( bSaneSymbolLoadFailed )
     222           0 :             DeInit();
     223             :         else
     224             :         {
     225           0 :             SANE_Status nStatus = p_init( &nVersion, 0 );
     226           0 :             FAIL_SHUTDOWN_STATE( nStatus, "sane_init", );
     227             :             nStatus = p_get_devices( (const SANE_Device***)&ppDevices,
     228           0 :                                      SANE_FALSE );
     229           0 :             FAIL_SHUTDOWN_STATE( nStatus, "sane_get_devices", );
     230           0 :             for( nDevices = 0 ; ppDevices[ nDevices ]; nDevices++ ) ;
     231             :         }
     232           0 :     }
     233             : #if (OSL_DEBUG_LEVEL > 1) || defined DBG_UTIL
     234             :     else
     235             :         fprintf( stderr, "libsane%s could not be opened: %s\n", SAL_DLLEXTENSION,
     236             :                  dlerror() );
     237             : #endif
     238             : }
     239             : 
     240           0 : void Sane::DeInit()
     241             : {
     242           0 :     if( pSaneLib )
     243             :     {
     244           0 :         p_exit();
     245           0 :         osl_unloadModule( pSaneLib );
     246           0 :         pSaneLib = 0;
     247             :     }
     248           0 : }
     249             : 
     250           0 : void Sane::ReloadDevices()
     251             : {
     252           0 :     if( IsOpen() )
     253           0 :         Close();
     254           0 :     DeInit();
     255           0 :     Init();
     256           0 : }
     257             : 
     258           0 : void Sane::ReloadOptions()
     259             : {
     260           0 :     if( ! IsOpen() )
     261           0 :         return;
     262             : 
     263           0 :     const SANE_Option_Descriptor* pZero = p_get_option_descriptor( maHandle, 0 );
     264             :     SANE_Word pOptions[2];
     265             :     SANE_Status nStatus = p_control_option( maHandle, 0, SANE_ACTION_GET_VALUE,
     266           0 :                                             (void*)pOptions, NULL );
     267           0 :     if( nStatus != SANE_STATUS_GOOD )
     268           0 :         fprintf( stderr, "Error: sane driver returned %s while reading number of options !\n", p_strstatus( nStatus ) );
     269             : 
     270           0 :     mnOptions = pOptions[ 0 ];
     271           0 :     if( (size_t)pZero->size > sizeof( SANE_Word ) )
     272           0 :         fprintf( stderr, "driver returned numer of options with larger size tha SANE_Word !!!\n" );
     273           0 :     if( mppOptions )
     274           0 :         delete [] mppOptions;
     275           0 :     mppOptions = new const SANE_Option_Descriptor*[ mnOptions ];
     276           0 :     mppOptions[ 0 ] = pZero;
     277           0 :     for( int i = 1; i < mnOptions; i++ )
     278           0 :         mppOptions[ i ] =  (SANE_Option_Descriptor*)
     279           0 :             p_get_option_descriptor( maHandle, i );
     280             : 
     281           0 :     CheckConsistency( NULL, sal_True );
     282             : 
     283           0 :     maReloadOptionsLink.Call( this );
     284             : }
     285             : 
     286           0 : sal_Bool Sane::Open( const char* name )
     287             : {
     288           0 :     SANE_Status nStatus = p_open( (SANE_String_Const)name, &maHandle );
     289           0 :     FAIL_STATE( nStatus, "sane_open", sal_False );
     290             : 
     291           0 :     ReloadOptions();
     292             : 
     293           0 :     if( mnDevice == -1 )
     294             :     {
     295           0 :         OString aDevice( name );
     296           0 :         for( int i = 0; i < nDevices; i++ )
     297             :         {
     298           0 :             if( aDevice.equals( ppDevices[i]->name ) )
     299             :             {
     300           0 :                 mnDevice = i;
     301           0 :                 break;
     302             :             }
     303           0 :         }
     304             :     }
     305             : 
     306           0 :     return sal_True;
     307             : }
     308             : 
     309           0 : sal_Bool Sane::Open( int n )
     310             : {
     311           0 :     if( n >= 0 && n < nDevices )
     312             :     {
     313           0 :         mnDevice = n;
     314           0 :         return Open( (char*)ppDevices[n]->name );
     315             :     }
     316           0 :     return sal_False;
     317             : }
     318             : 
     319           0 : void Sane::Close()
     320             : {
     321           0 :     if( maHandle )
     322             :     {
     323           0 :         p_close( maHandle );
     324           0 :         delete [] mppOptions;
     325           0 :         mppOptions = 0;
     326           0 :         maHandle = 0;
     327           0 :         mnDevice = -1;
     328             :     }
     329           0 : }
     330             : 
     331           0 : int Sane::GetOptionByName( const char* rName )
     332             : {
     333             :     int i;
     334           0 :     OString aOption( rName );
     335           0 :     for( i = 0; i < mnOptions; i++ )
     336             :     {
     337           0 :         if( mppOptions[i]->name && aOption.equals( mppOptions[i]->name ) )
     338           0 :             return i;
     339             :     }
     340           0 :     return -1;
     341             : }
     342             : 
     343           0 : sal_Bool Sane::GetOptionValue( int n, sal_Bool& rRet )
     344             : {
     345           0 :     if( ! maHandle  ||  mppOptions[n]->type != SANE_TYPE_BOOL )
     346           0 :         return sal_False;
     347             :     SANE_Word nRet;
     348           0 :     SANE_Status nStatus = ControlOption( n, SANE_ACTION_GET_VALUE, &nRet );
     349           0 :     if( nStatus != SANE_STATUS_GOOD )
     350           0 :         return sal_False;
     351             : 
     352           0 :     rRet = nRet;
     353           0 :     return sal_True;
     354             : }
     355             : 
     356           0 : sal_Bool Sane::GetOptionValue( int n, OString& rRet )
     357             : {
     358           0 :     sal_Bool bSuccess = sal_False;
     359           0 :     if( ! maHandle  ||  mppOptions[n]->type != SANE_TYPE_STRING )
     360           0 :         return sal_False;
     361           0 :     boost::scoped_array<char> pRet(new char[mppOptions[n]->size+1]);
     362           0 :     SANE_Status nStatus = ControlOption( n, SANE_ACTION_GET_VALUE, pRet.get() );
     363           0 :     if( nStatus == SANE_STATUS_GOOD )
     364             :     {
     365           0 :         bSuccess = sal_True;
     366           0 :         rRet = pRet.get();
     367             :     }
     368           0 :     return bSuccess;
     369             : }
     370             : 
     371           0 : sal_Bool Sane::GetOptionValue( int n, double& rRet, int nElement )
     372             : {
     373           0 :     sal_Bool bSuccess = sal_False;
     374             : 
     375           0 :     if( ! maHandle  ||  ( mppOptions[n]->type != SANE_TYPE_INT &&
     376           0 :                           mppOptions[n]->type != SANE_TYPE_FIXED ) )
     377           0 :         return sal_False;
     378             : 
     379           0 :     boost::scoped_array<SANE_Word> pRet(new SANE_Word[mppOptions[n]->size/sizeof(SANE_Word)]);
     380           0 :     SANE_Status nStatus = ControlOption( n, SANE_ACTION_GET_VALUE, pRet.get() );
     381           0 :     if( nStatus == SANE_STATUS_GOOD )
     382             :     {
     383           0 :         bSuccess = sal_True;
     384           0 :         if( mppOptions[n]->type == SANE_TYPE_INT )
     385           0 :             rRet = (double)pRet[ nElement ];
     386             :         else
     387           0 :             rRet = SANE_UNFIX( pRet[nElement] );
     388             :     }
     389           0 :     return bSuccess;
     390             : }
     391             : 
     392           0 : sal_Bool Sane::GetOptionValue( int n, double* pSet )
     393             : {
     394           0 :     if( ! maHandle  || ! ( mppOptions[n]->type == SANE_TYPE_FIXED ||
     395           0 :                            mppOptions[n]->type == SANE_TYPE_INT ) )
     396           0 :         return sal_False;
     397             : 
     398           0 :     boost::scoped_array<SANE_Word> pFixedSet(new SANE_Word[mppOptions[n]->size/sizeof(SANE_Word)]);
     399           0 :     SANE_Status nStatus = ControlOption( n, SANE_ACTION_GET_VALUE, pFixedSet.get() );
     400           0 :     if( nStatus != SANE_STATUS_GOOD )
     401           0 :         return sal_False;
     402           0 :     for( size_t i = 0; i <mppOptions[n]->size/sizeof(SANE_Word); i++ )
     403             :     {
     404           0 :         if( mppOptions[n]->type == SANE_TYPE_FIXED )
     405           0 :             pSet[i] = SANE_UNFIX( pFixedSet[i] );
     406             :         else
     407           0 :             pSet[i] = (double) pFixedSet[i];
     408             :     }
     409           0 :     return sal_True;
     410             : }
     411             : 
     412           0 : sal_Bool Sane::SetOptionValue( int n, sal_Bool bSet )
     413             : {
     414           0 :     if( ! maHandle  ||  mppOptions[n]->type != SANE_TYPE_BOOL )
     415           0 :         return sal_False;
     416           0 :     SANE_Word nRet = bSet ? SANE_TRUE : SANE_FALSE;
     417           0 :     SANE_Status nStatus = ControlOption( n, SANE_ACTION_SET_VALUE, &nRet );
     418           0 :     if( nStatus != SANE_STATUS_GOOD )
     419           0 :         return sal_False;
     420           0 :     return sal_True;
     421             : }
     422             : 
     423           0 : sal_Bool Sane::SetOptionValue( int n, const OUString& rSet )
     424             : {
     425           0 :     if( ! maHandle  ||  mppOptions[n]->type != SANE_TYPE_STRING )
     426           0 :         return sal_False;
     427           0 :     OString aSet(OUStringToOString(rSet, osl_getThreadTextEncoding()));
     428           0 :     SANE_Status nStatus = ControlOption( n, SANE_ACTION_SET_VALUE, (void*)aSet.getStr() );
     429           0 :     if( nStatus != SANE_STATUS_GOOD )
     430           0 :         return sal_False;
     431           0 :     return sal_True;
     432             : }
     433             : 
     434           0 : sal_Bool Sane::SetOptionValue( int n, double fSet, int nElement )
     435             : {
     436           0 :     sal_Bool bSuccess = sal_False;
     437             : 
     438           0 :     if( ! maHandle  ||  ( mppOptions[n]->type != SANE_TYPE_INT &&
     439           0 :                           mppOptions[n]->type != SANE_TYPE_FIXED ) )
     440           0 :         return sal_False;
     441             : 
     442             :     SANE_Status nStatus;
     443           0 :     if( mppOptions[n]->size/sizeof(SANE_Word) > 1 )
     444             :     {
     445           0 :         boost::scoped_array<SANE_Word> pSet(new SANE_Word[mppOptions[n]->size/sizeof(SANE_Word)]);
     446           0 :         nStatus = ControlOption( n, SANE_ACTION_GET_VALUE, pSet.get() );
     447           0 :         if( nStatus == SANE_STATUS_GOOD )
     448             :         {
     449           0 :             pSet[nElement] = mppOptions[n]->type == SANE_TYPE_INT ?
     450           0 :                 (SANE_Word)fSet : SANE_FIX( fSet );
     451           0 :             nStatus = ControlOption(  n, SANE_ACTION_SET_VALUE, pSet.get() );
     452           0 :         }
     453             :     }
     454             :     else
     455             :     {
     456             :         SANE_Word nSetTo =
     457           0 :             mppOptions[n]->type == SANE_TYPE_INT ?
     458           0 :             (SANE_Word)fSet : SANE_FIX( fSet );
     459             : 
     460           0 :         nStatus = ControlOption( n, SANE_ACTION_SET_VALUE, &nSetTo );
     461           0 :         if( nStatus == SANE_STATUS_GOOD )
     462           0 :             bSuccess = sal_True;
     463             :     }
     464           0 :     return bSuccess;
     465             : }
     466             : 
     467           0 : sal_Bool Sane::SetOptionValue( int n, double* pSet )
     468             : {
     469           0 :     if( ! maHandle  ||  ( mppOptions[n]->type != SANE_TYPE_INT &&
     470           0 :                           mppOptions[n]->type != SANE_TYPE_FIXED ) )
     471           0 :         return sal_False;
     472           0 :     boost::scoped_array<SANE_Word> pFixedSet(new SANE_Word[mppOptions[n]->size/sizeof(SANE_Word)]);
     473           0 :     for( size_t i = 0; i < mppOptions[n]->size/sizeof(SANE_Word); i++ )
     474             :     {
     475           0 :         if( mppOptions[n]->type == SANE_TYPE_FIXED )
     476           0 :             pFixedSet[i] = SANE_FIX( pSet[i] );
     477             :         else
     478           0 :             pFixedSet[i] = (SANE_Word)pSet[i];
     479             :     }
     480           0 :     SANE_Status nStatus = ControlOption( n, SANE_ACTION_SET_VALUE, pFixedSet.get() );
     481           0 :     if( nStatus != SANE_STATUS_GOOD )
     482           0 :         return sal_False;
     483           0 :     return sal_True;
     484             : }
     485             : 
     486             : enum FrameStyleType {
     487             :     FrameStyle_BW, FrameStyle_Gray, FrameStyle_RGB, FrameStyle_Separated
     488             : };
     489             : 
     490             : #define BYTE_BUFFER_SIZE 32768
     491             : 
     492           0 : static inline sal_uInt8 _ReadValue( FILE* fp, int depth )
     493             : {
     494           0 :     if( depth == 16 )
     495             :     {
     496             :         sal_uInt16 nWord;
     497             :         // data always come in native byte order !
     498             :         // 16 bits is not really supported by backends as of now
     499             :         // e.g. UMAX Astra 1200S delivers 16 bit but in BIGENDIAN
     500             :         // against SANE documentation (xscanimage gets the same result
     501             :         // as we do
     502           0 :         size_t items_read = fread( &nWord, 1, 2, fp );
     503             : 
     504           0 :         if (items_read != 2)
     505             :         {
     506             :              SAL_WARN( "extensions.scanner", "short read, abandoning" );
     507           0 :              return 0;
     508             :         }
     509             : 
     510           0 :         return (sal_uInt8)( nWord / 256 );
     511             :     }
     512             :     sal_uInt8 nByte;
     513           0 :     size_t items_read = fread( &nByte, 1, 1, fp );
     514           0 :     if (items_read != 1)
     515             :     {
     516             :         SAL_WARN( "extensions.scanner", "short read, abandoning" );
     517           0 :         return 0;
     518             :     }
     519           0 :     return nByte;
     520             : }
     521             : 
     522           0 : sal_Bool Sane::CheckConsistency( const char* pMes, sal_Bool bInit )
     523             : {
     524             :     static const SANE_Option_Descriptor** pDescArray = NULL;
     525             :     static const SANE_Option_Descriptor*  pZero = NULL;
     526             : 
     527           0 :     if( bInit )
     528             :     {
     529           0 :         pDescArray = mppOptions;
     530           0 :         if( mppOptions )
     531           0 :             pZero = mppOptions[0];
     532           0 :         return sal_True;
     533             :     }
     534             : 
     535           0 :     sal_Bool bConsistent = sal_True;
     536             : 
     537           0 :     if( pDescArray != mppOptions )
     538           0 :         bConsistent = sal_False;
     539           0 :     if( pZero != mppOptions[0] )
     540           0 :         bConsistent = sal_False;
     541             : 
     542           0 :     if( ! bConsistent )
     543           0 :         dbg_msg( "Sane is not consistent. (%s)\n", pMes );
     544             : 
     545           0 :     return bConsistent;
     546             : }
     547             : 
     548           0 : sal_Bool Sane::Start( BitmapTransporter& rBitmap )
     549             : {
     550           0 :     int nStream = 0, nLine = 0, i = 0;
     551             :     SANE_Parameters aParams;
     552           0 :     FrameStyleType eType = FrameStyle_Gray;
     553           0 :     sal_Bool bSuccess = sal_True;
     554           0 :     sal_Bool bWidthSet = sal_False;
     555             : 
     556           0 :     if( ! maHandle )
     557           0 :         return sal_False;
     558             : 
     559           0 :     int nWidthMM    = 0;
     560           0 :     int nHeightMM   = 0;
     561           0 :     double fTLx, fTLy, fBRx, fBRy, fResl = 0.0;
     562             :     int nOption;
     563           0 :     if( ( nOption = GetOptionByName( "tl-x" ) ) != -1   &&
     564           0 :         GetOptionValue( nOption, fTLx, 0 )              &&
     565           0 :         GetOptionUnit( nOption ) == SANE_UNIT_MM )
     566             :     {
     567           0 :         if( ( nOption = GetOptionByName( "br-x" ) ) != -1   &&
     568           0 :             GetOptionValue( nOption, fBRx, 0 )              &&
     569           0 :             GetOptionUnit( nOption ) == SANE_UNIT_MM )
     570             :         {
     571           0 :             nWidthMM = (int)fabs(fBRx - fTLx);
     572             :         }
     573             :     }
     574           0 :     if( ( nOption = GetOptionByName( "tl-y" ) ) != -1   &&
     575           0 :         GetOptionValue( nOption, fTLy, 0 )              &&
     576           0 :         GetOptionUnit( nOption ) == SANE_UNIT_MM )
     577             :     {
     578           0 :         if( ( nOption = GetOptionByName( "br-y" ) ) != -1   &&
     579           0 :             GetOptionValue( nOption, fBRy, 0 )              &&
     580           0 :             GetOptionUnit( nOption ) == SANE_UNIT_MM )
     581             :         {
     582           0 :             nHeightMM = (int)fabs(fBRy - fTLy);
     583             :         }
     584             :     }
     585           0 :     if( ( nOption = GetOptionByName( "resolution" ) ) != -1 )
     586           0 :         GetOptionValue( nOption, fResl );
     587             : 
     588           0 :     sal_uInt8* pBuffer = NULL;
     589             : 
     590           0 :     SANE_Status nStatus = SANE_STATUS_GOOD;
     591             : 
     592           0 :     rBitmap.lock();
     593           0 :     SvMemoryStream& aConverter = rBitmap.getStream();
     594           0 :     aConverter.Seek( 0 );
     595           0 :     aConverter.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
     596             : 
     597             :     // write bitmap stream header
     598           0 :     aConverter.WriteChar( 'B' ).WriteChar( 'M' );
     599           0 :     aConverter.WriteUInt32( (sal_uInt32) 0 );
     600           0 :     aConverter.WriteUInt32( (sal_uInt32) 0 );
     601           0 :     aConverter.WriteUInt32( (sal_uInt32) 60 );
     602             : 
     603             :     // write BITMAPINFOHEADER
     604           0 :     aConverter.WriteUInt32( (sal_uInt32)40 );
     605           0 :     aConverter.WriteUInt32( (sal_uInt32)0 ); // fill in width later
     606           0 :     aConverter.WriteUInt32( (sal_uInt32)0 ); // fill in height later
     607           0 :     aConverter.WriteUInt16( (sal_uInt16)1 );
     608             :     // create header for 24 bits
     609             :     // correct later if necessary
     610           0 :     aConverter.WriteUInt16( (sal_uInt16)24 );
     611           0 :     aConverter.WriteUInt32( (sal_uInt32)0 );
     612           0 :     aConverter.WriteUInt32( (sal_uInt32)0 );
     613           0 :     aConverter.WriteUInt32( (sal_uInt32)0 );
     614           0 :     aConverter.WriteUInt32( (sal_uInt32)0 );
     615           0 :     aConverter.WriteUInt32( (sal_uInt32)0 );
     616           0 :     aConverter.WriteUInt32( (sal_uInt32)0 );
     617             : 
     618           0 :     for( nStream=0; nStream < 3 && bSuccess ; nStream++ )
     619             :     {
     620           0 :         nStatus = p_start( maHandle );
     621             :         DUMP_STATE( nStatus, "sane_start" );
     622           0 :         CheckConsistency( "sane_start" );
     623           0 :         if( nStatus == SANE_STATUS_GOOD )
     624             :         {
     625           0 :             nStatus = p_get_parameters( maHandle, &aParams );
     626             :             DUMP_STATE( nStatus, "sane_get_parameters" );
     627           0 :             CheckConsistency( "sane_get_parameters" );
     628           0 :             if (nStatus != SANE_STATUS_GOOD || aParams.bytes_per_line == 0)
     629             :             {
     630           0 :                 bSuccess = sal_False;
     631           0 :                 break;
     632             :             }
     633             : #if (OSL_DEBUG_LEVEL > 1) || defined DBG_UTIL
     634             :             const char* ppFormats[] = { "SANE_FRAME_GRAY", "SANE_FRAME_RGB",
     635             :                                   "SANE_FRAME_RED", "SANE_FRAME_GREEN",
     636             :                                   "SANE_FRAME_BLUE", "Unknown !!!" };
     637             :             fprintf( stderr, "Parameters for frame %d:\n", nStream );
     638             :             if( aParams.format < 0 || aParams.format > 4 )
     639             :                 aParams.format = (SANE_Frame)5;
     640             :             fprintf( stderr, "format:           %s\n", ppFormats[ (int)aParams.format ] );
     641             :             fprintf( stderr, "last_frame:       %s\n", aParams.last_frame ? "TRUE" : "FALSE" );
     642             :             fprintf( stderr, "depth:            %d\n", (int)aParams.depth );
     643             :             fprintf( stderr, "pixels_per_line:  %d\n", (int)aParams.pixels_per_line );
     644             :             fprintf( stderr, "bytes_per_line:   %d\n", (int)aParams.bytes_per_line );
     645             : #endif
     646           0 :             if( ! pBuffer )
     647             :             {
     648           0 :                 pBuffer = new sal_uInt8[ BYTE_BUFFER_SIZE < 4*aParams.bytes_per_line ? 4*aParams.bytes_per_line : BYTE_BUFFER_SIZE ];
     649             :             }
     650             : 
     651           0 :             if( aParams.last_frame )
     652           0 :                 nStream=3;
     653             : 
     654           0 :             switch( aParams.format )
     655             :             {
     656             :                 case SANE_FRAME_GRAY:
     657           0 :                     eType = FrameStyle_Gray;
     658           0 :                     if( aParams.depth == 1 )
     659           0 :                         eType = FrameStyle_BW;
     660           0 :                     break;
     661             :                 case SANE_FRAME_RGB:
     662           0 :                     eType = FrameStyle_RGB;
     663           0 :                     break;
     664             :                 case SANE_FRAME_RED:
     665             :                 case SANE_FRAME_GREEN:
     666             :                 case SANE_FRAME_BLUE:
     667           0 :                     eType = FrameStyle_Separated;
     668           0 :                     break;
     669             :                 default:
     670           0 :                     fprintf( stderr, "Warning: unknown frame style !!!\n" );
     671             :             }
     672             : 
     673           0 :             sal_Bool bSynchronousRead = sal_True;
     674             : 
     675             :             // should be fail safe, but ... ??
     676           0 :             nStatus = p_set_io_mode( maHandle, SANE_FALSE );
     677           0 :             CheckConsistency( "sane_set_io_mode" );
     678           0 :             if( nStatus != SANE_STATUS_GOOD )
     679             :             {
     680           0 :                 bSynchronousRead = sal_False;
     681           0 :                 nStatus = p_set_io_mode( maHandle, SANE_TRUE );
     682           0 :                 CheckConsistency( "sane_set_io_mode" );
     683             : #if (OSL_DEBUG_LEVEL > 1) || defined DBG_UTIL
     684             :                 if( nStatus != SANE_STATUS_GOOD )
     685             :                     // what ?!?
     686             :                     fprintf( stderr, "Sane::Start: driver is confused\n" );
     687             : #endif
     688             :             }
     689             : 
     690           0 :             SANE_Int nLen=0;
     691           0 :             SANE_Int fd = 0;
     692             : 
     693           0 :             if( ! bSynchronousRead )
     694             :             {
     695           0 :                 nStatus = p_get_select_fd( maHandle, &fd );
     696             :                 DUMP_STATE( nStatus, "sane_get_select_fd" );
     697           0 :                 CheckConsistency( "sane_get_select_fd" );
     698           0 :                 if( nStatus != SANE_STATUS_GOOD )
     699           0 :                     bSynchronousRead = sal_True;
     700             :             }
     701           0 :             FILE* pFrame = tmpfile();
     702           0 :             if( ! pFrame )
     703             :             {
     704           0 :                 bSuccess = sal_False;
     705           0 :                 break;
     706             :             }
     707           0 :             do {
     708           0 :                 if( ! bSynchronousRead )
     709             :                 {
     710             :                     fd_set fdset;
     711             :                     struct timeval tv;
     712             : 
     713           0 :                     FD_ZERO( &fdset );
     714           0 :                     FD_SET( (int)fd, &fdset );
     715           0 :                     tv.tv_sec = 5;
     716           0 :                     tv.tv_usec = 0;
     717           0 :                     if( select( fd+1, &fdset, NULL, NULL, &tv ) == 0 )
     718           0 :                         fprintf( stderr, "Timout on sane_read descriptor\n" );
     719             :                 }
     720           0 :                 nLen = 0;
     721           0 :                 nStatus = p_read( maHandle, pBuffer, BYTE_BUFFER_SIZE, &nLen );
     722           0 :                 CheckConsistency( "sane_read" );
     723           0 :                 if( nLen && ( nStatus == SANE_STATUS_GOOD ||
     724             :                               nStatus == SANE_STATUS_EOF ) )
     725             :                 {
     726           0 :                     bSuccess = (static_cast<size_t>(nLen) == fwrite( pBuffer, 1, nLen, pFrame ));
     727           0 :                     if (!bSuccess)
     728           0 :                         break;
     729             :                 }
     730             :                 else
     731             :                     DUMP_STATE( nStatus, "sane_read" );
     732             :             } while( nStatus == SANE_STATUS_GOOD );
     733           0 :             if (nStatus != SANE_STATUS_EOF || !bSuccess)
     734             :             {
     735           0 :                 fclose( pFrame );
     736           0 :                 bSuccess = sal_False;
     737           0 :                 break;
     738             :             }
     739             : 
     740           0 :             int nFrameLength = ftell( pFrame );
     741           0 :             fseek( pFrame, 0, SEEK_SET );
     742           0 :             sal_uInt32 nWidth = (sal_uInt32) aParams.pixels_per_line;
     743           0 :             sal_uInt32 nHeight = (sal_uInt32) (nFrameLength / aParams.bytes_per_line);
     744           0 :             if( ! bWidthSet )
     745             :             {
     746           0 :                 if( ! fResl )
     747           0 :                     fResl = 300; // if all else fails that's a good guess
     748           0 :                 if( ! nWidthMM )
     749           0 :                     nWidthMM = (int)(((double)nWidth / fResl) * 25.4);
     750           0 :                 if( ! nHeightMM )
     751           0 :                     nHeightMM = (int)(((double)nHeight / fResl) * 25.4);
     752             : #if OSL_DEBUG_LEVEL > 1
     753             :                 fprintf( stderr, "set dimensions to (%d, %d) Pixel, (%d, %d) mm, resolution is %lg\n", (int)nWidth, (int)nHeight, (int)nWidthMM, (int)nHeightMM, fResl );
     754             : #endif
     755             : 
     756           0 :                 aConverter.Seek( 18 );
     757           0 :                 aConverter.WriteUInt32( (sal_uInt32)nWidth );
     758           0 :                 aConverter.WriteUInt32( (sal_uInt32)nHeight );
     759           0 :                 aConverter.Seek( 38 );
     760           0 :                 aConverter.WriteUInt32( (sal_uInt32)(1000*nWidth/nWidthMM) );
     761           0 :                 aConverter.WriteUInt32( (sal_uInt32)(1000*nHeight/nHeightMM) );
     762           0 :                 bWidthSet = sal_True;
     763             :             }
     764           0 :             aConverter.Seek(60);
     765             : 
     766           0 :             if( eType == FrameStyle_BW )
     767             :             {
     768           0 :                 aConverter.Seek( 10 );
     769           0 :                 aConverter.WriteUInt32( (sal_uInt32)64 );
     770           0 :                 aConverter.Seek( 28 );
     771           0 :                 aConverter.WriteUInt16( (sal_uInt16) 1 );
     772           0 :                 aConverter.Seek( 54 );
     773             :                 // write color table
     774           0 :                 aConverter.WriteUInt16( (sal_uInt16)0xffff );
     775           0 :                 aConverter.WriteUChar( (sal_uInt8)0xff );
     776           0 :                 aConverter.WriteUChar( (sal_uInt8)0 );
     777           0 :                 aConverter.WriteUInt32( (sal_uInt32)0 );
     778           0 :                 aConverter.Seek( 64 );
     779             :             }
     780           0 :             else if( eType == FrameStyle_Gray )
     781             :             {
     782           0 :                  aConverter.Seek( 10 );
     783           0 :                  aConverter.WriteUInt32( (sal_uInt32)1084 );
     784           0 :                 aConverter.Seek( 28 );
     785           0 :                 aConverter.WriteUInt16( (sal_uInt16) 8 );
     786           0 :                 aConverter.Seek( 54 );
     787             :                 // write color table
     788           0 :                 for( nLine = 0; nLine < 256; nLine++ )
     789             :                 {
     790           0 :                     aConverter.WriteUChar( (sal_uInt8)nLine );
     791           0 :                     aConverter.WriteUChar( (sal_uInt8)nLine );
     792           0 :                     aConverter.WriteUChar( (sal_uInt8)nLine );
     793           0 :                     aConverter.WriteUChar( (sal_uInt8)0 );
     794             :                 }
     795           0 :                 aConverter.Seek( 1084 );
     796             :             }
     797             : 
     798           0 :             for (nLine = nHeight-1; nLine >= 0; --nLine)
     799             :             {
     800           0 :                 fseek( pFrame, nLine * aParams.bytes_per_line, SEEK_SET );
     801           0 :                 if( eType == FrameStyle_BW ||
     802           0 :                     ( eType == FrameStyle_Gray && aParams.depth == 8 )
     803             :                     )
     804             :                 {
     805           0 :                     SANE_Int items_read = fread( pBuffer, 1, aParams.bytes_per_line, pFrame );
     806           0 :                     if (items_read != aParams.bytes_per_line)
     807             :                     {
     808             :                         SAL_WARN( "extensions.scanner", "short read, padding with zeros" );
     809           0 :                         memset(pBuffer + items_read, 0, aParams.bytes_per_line - items_read);
     810             :                     }
     811           0 :                     aConverter.Write( pBuffer, aParams.bytes_per_line );
     812             :                 }
     813           0 :                 else if( eType == FrameStyle_Gray )
     814             :                 {
     815           0 :                     for( i = 0; i < (aParams.pixels_per_line); i++ )
     816             :                     {
     817           0 :                         sal_uInt8 nGray = _ReadValue( pFrame, aParams.depth );
     818           0 :                         aConverter.WriteUChar( nGray );
     819             :                     }
     820             :                 }
     821           0 :                 else if( eType == FrameStyle_RGB )
     822             :                 {
     823           0 :                     for( i = 0; i < (aParams.pixels_per_line); i++ )
     824             :                     {
     825             :                         sal_uInt8 nRed, nGreen, nBlue;
     826           0 :                         nRed    = _ReadValue( pFrame, aParams.depth );
     827           0 :                         nGreen  = _ReadValue( pFrame, aParams.depth );
     828           0 :                         nBlue   = _ReadValue( pFrame, aParams.depth );
     829           0 :                         aConverter.WriteUChar( nBlue );
     830           0 :                         aConverter.WriteUChar( nGreen );
     831           0 :                         aConverter.WriteUChar( nRed );
     832             :                     }
     833             :                 }
     834           0 :                 else if( eType == FrameStyle_Separated )
     835             :                 {
     836           0 :                     for( i = 0; i < (aParams.pixels_per_line); i++ )
     837             :                     {
     838           0 :                         sal_uInt8 nValue = _ReadValue( pFrame, aParams.depth );
     839           0 :                         switch( aParams.format )
     840             :                         {
     841             :                             case SANE_FRAME_RED:
     842           0 :                                 aConverter.SeekRel( 2 );
     843           0 :                                 aConverter.WriteUChar( nValue );
     844           0 :                                 break;
     845             :                             case SANE_FRAME_GREEN:
     846           0 :                                 aConverter.SeekRel( 1 );
     847           0 :                                 aConverter.WriteUChar( nValue );
     848           0 :                                 aConverter.SeekRel( 1 );
     849           0 :                                 break;
     850             :                             case SANE_FRAME_BLUE:
     851           0 :                                 aConverter.WriteUChar( nValue );
     852           0 :                                 aConverter.SeekRel( 2 );
     853           0 :                                 break;
     854             :                             case SANE_FRAME_GRAY:
     855             :                             case SANE_FRAME_RGB:
     856           0 :                                 break;
     857             :                         }
     858             :                     }
     859             :                 }
     860           0 :                  int nGap = aConverter.Tell() & 3;
     861           0 :                  if( nGap )
     862           0 :                      aConverter.SeekRel( 4-nGap );
     863             :             }
     864           0 :             fclose( pFrame ); // deletes tmpfile
     865           0 :             if( eType != FrameStyle_Separated )
     866           0 :                 break;
     867             :         }
     868             :         else
     869           0 :             bSuccess = sal_False;
     870             :     }
     871             :     // get stream length
     872           0 :     aConverter.Seek( STREAM_SEEK_TO_END );
     873           0 :     int nPos = aConverter.Tell();
     874             : 
     875           0 :     aConverter.Seek( 2 );
     876           0 :     aConverter.WriteUInt32( (sal_uInt32) nPos+1 );
     877           0 :     aConverter.Seek( 0 );
     878             : 
     879           0 :     rBitmap.unlock();
     880             : 
     881           0 :     if( bSuccess )
     882             :     {
     883             :         // only cancel a successful operation
     884             :         // sane disrupts memory else
     885           0 :         p_cancel( maHandle );
     886           0 :         CheckConsistency( "sane_cancel" );
     887             :     }
     888           0 :     if( pBuffer )
     889           0 :         delete [] pBuffer;
     890             : 
     891           0 :     ReloadOptions();
     892             : 
     893             : 
     894           0 :     dbg_msg( "Sane::Start returns with %s\n", bSuccess ? "TRUE" : "FALSE" );
     895             : 
     896           0 :     return bSuccess;
     897             : }
     898             : 
     899           0 : int Sane::GetRange( int n, double*& rpDouble )
     900             : {
     901           0 :     if( mppOptions[n]->constraint_type != SANE_CONSTRAINT_RANGE &&
     902           0 :         mppOptions[n]->constraint_type != SANE_CONSTRAINT_WORD_LIST )
     903             :     {
     904           0 :         return -1;
     905             :     }
     906             : 
     907           0 :     rpDouble = 0;
     908             :     int nItems, i;
     909           0 :     sal_Bool bIsFixed = mppOptions[n]->type == SANE_TYPE_FIXED ? sal_True : sal_False;
     910             : 
     911           0 :     dbg_msg( "Sane::GetRange of option %s ", mppOptions[n]->name );
     912           0 :     if(mppOptions[n]->constraint_type == SANE_CONSTRAINT_RANGE )
     913             :     {
     914             :         double fMin, fMax, fQuant;
     915           0 :         if( bIsFixed )
     916             :         {
     917           0 :             fMin = SANE_UNFIX( mppOptions[n]->constraint.range->min );
     918           0 :             fMax = SANE_UNFIX( mppOptions[n]->constraint.range->max );
     919           0 :             fQuant = SANE_UNFIX( mppOptions[n]->constraint.range->quant );
     920             :         }
     921             :         else
     922             :         {
     923           0 :             fMin = (double)mppOptions[n]->constraint.range->min;
     924           0 :             fMax = (double)mppOptions[n]->constraint.range->max;
     925           0 :             fQuant = (double)mppOptions[n]->constraint.range->quant;
     926             :         }
     927           0 :         if( fQuant != 0.0 )
     928             :         {
     929             :             dbg_msg( "quantum range [ %lg ; %lg ; %lg ]\n",
     930           0 :                      fMin, fQuant, fMax );
     931           0 :             nItems = (int)((fMax - fMin)/fQuant)+1;
     932           0 :             rpDouble = new double[ nItems ];
     933           0 :             double fValue = fMin;
     934           0 :             for( i = 0; i < nItems; i++, fValue += fQuant )
     935           0 :                 rpDouble[i] = fValue;
     936           0 :             rpDouble[ nItems-1 ] = fMax;
     937           0 :             return nItems;
     938             :         }
     939             :         else
     940             :         {
     941             :             dbg_msg( "normal range [ %lg %lg ]\n",
     942           0 :                      fMin, fMax );
     943           0 :             rpDouble = new double[2];
     944           0 :             rpDouble[0] = fMin;
     945           0 :             rpDouble[1] = fMax;
     946           0 :             return 0;
     947             :         }
     948             :     }
     949             :     else
     950             :     {
     951           0 :         nItems = mppOptions[n]->constraint.word_list[0];
     952           0 :         rpDouble = new double[nItems];
     953           0 :         for( i=0; i<nItems; i++ )
     954             :         {
     955           0 :             rpDouble[i] = bIsFixed ?
     956           0 :                 SANE_UNFIX( mppOptions[n]->constraint.word_list[i+1] ) :
     957           0 :                 (double)mppOptions[n]->constraint.word_list[i+1];
     958             :         }
     959             :         dbg_msg( "wordlist [ %lg ... %lg ]\n",
     960           0 :                  rpDouble[ 0 ], rpDouble[ nItems-1 ] );
     961           0 :         return nItems;
     962             :     }
     963             : }
     964             : 
     965             : static const char *ppUnits[] = {
     966             :     "",
     967             :     "[Pixel]",
     968             :     "[Bit]",
     969             :     "[mm]",
     970             :     "[DPI]",
     971             :     "[%]",
     972             :     "[usec]"
     973             : };
     974             : 
     975           0 : OUString Sane::GetOptionUnitName( int n )
     976             : {
     977           0 :     OUString aText;
     978           0 :     SANE_Unit nUnit = mppOptions[n]->unit;
     979           0 :     size_t nUnitAsSize = (size_t)nUnit;
     980           0 :     if (nUnitAsSize >= SAL_N_ELEMENTS( ppUnits ))
     981           0 :         aText = "[unknown units]";
     982             :     else
     983           0 :         aText = OUString( ppUnits[ nUnit ], strlen(ppUnits[ nUnit ]), osl_getThreadTextEncoding() );
     984           0 :     return aText;
     985             : }
     986             : 
     987           0 : sal_Bool Sane::ActivateButtonOption( int n )
     988             : {
     989           0 :     SANE_Status nStatus = ControlOption( n, SANE_ACTION_SET_VALUE, NULL );
     990           0 :     if( nStatus != SANE_STATUS_GOOD )
     991           0 :         return sal_False;
     992           0 :     return sal_True;
     993             : }
     994             : 
     995             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10