extensions/source/scanner/scanunx.cxx

   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 <scanner.hxx>
  21 #include <sanedlg.hxx>
  22 #include <osl/thread.hxx>
  23 #include <boost/shared_ptr.hpp>
  24
  25 #if OSL_DEBUG_LEVEL > 1
  26 #include <stdio.h>
  27 #endif
  28
  29 BitmapTransporter::BitmapTransporter()
  30 {
  31 #if OSL_DEBUG_LEVEL > 1
  32     fprintf( stderr, "BitmapTransporter\n" );
  33 #endif
  34 }
  35
  36 BitmapTransporter::~BitmapTransporter()
  37 {
  38 #if OSL_DEBUG_LEVEL > 1
  39     fprintf( stderr, "~BitmapTransporter\n" );
  40 #endif
  41 }
  42
  43 // -----------------------------------------------------------------------------
  44
  45 Any SAL_CALL BitmapTransporter::queryInterface( const Type& rType ) throw( RuntimeException )
  46 {
  47     const Any aRet( cppu::queryInterface( rType, static_cast< css::awt::XBitmap* >( this ) ) );
  48
  49     return( aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType ) );
  50 }
  51
  52 // -----------------------------------------------------------------------------
  53
  54 css::awt::Size BitmapTransporter::getSize() throw()
  55 {
  56     osl::MutexGuard aGuard( m_aProtector );
  57     int         nPreviousPos = m_aStream.Tell();
  58     css::awt::Size   aRet;
  59
  60     // ensure that there is at least a header
  61     m_aStream.Seek( STREAM_SEEK_TO_END );
  62     int nLen = m_aStream.Tell();
  63     if( nLen > 15 )
  64     {
  65         m_aStream.Seek( 4 );
  66         m_aStream >> aRet.Width >> aRet.Height;
  67     }
  68     else
  69         aRet.Width = aRet.Height = 0;
  70
  71     m_aStream.Seek( nPreviousPos );
  72
  73     return aRet;
  74 }
  75
  76 // -----------------------------------------------------------------------------
  77
  78 Sequence< sal_Int8 > BitmapTransporter::getDIB() throw()
  79 {
  80     osl::MutexGuard aGuard( m_aProtector );
  81     int         nPreviousPos = m_aStream.Tell();
  82
  83     // create return value
  84     m_aStream.Seek( STREAM_SEEK_TO_END );
  85     int nBytes = m_aStream.Tell();
  86     m_aStream.Seek( 0 );
  87
  88     Sequence< sal_Int8 > aValue( nBytes );
  89     m_aStream.Read( aValue.getArray(), nBytes );
  90     m_aStream.Seek( nPreviousPos );
  91
  92     return aValue;
  93 }
  94
  95 // --------------
  96 // - SaneHolder -
  97 // --------------
  98
  99 struct SaneHolder
 100 {
 101     Sane                m_aSane;
 102     Reference< css::awt::XBitmap > m_xBitmap;
 103     osl::Mutex          m_aProtector;
 104     ScanError           m_nError;
 105     bool                m_bBusy;
 106
 107     SaneHolder() : m_nError(ScanError_ScanErrorNone), m_bBusy(false) {}
 108 };
 109
 110 namespace
 111 {
 112     typedef std::vector< boost::shared_ptr<SaneHolder> > sanevec;
 113     class allSanes
 114     {
 115     private:
 116         int mnRefCount;
 117     public:
 118         sanevec m_aSanes;
 119         allSanes() : mnRefCount(0) {}
 120         void acquire();
 121         void release();
 122     };
 123
 124     void allSanes::acquire()
 125     {
 126         ++mnRefCount;
 127     }
 128
 129     void allSanes::release()
 130     {
 131         // was unused, now because of i99835: "Scanning interface not SANE API
 132         // compliant" destroy all SaneHolder to get Sane Dtor called
 133         --mnRefCount;
 134         if (!mnRefCount)
 135             m_aSanes.clear();
 136     }
 137
 138     struct theSaneProtector : public rtl::Static<osl::Mutex, theSaneProtector> {};
 139     struct theSanes : public rtl::Static<allSanes, theSanes> {};
 140 }
 141
 142 // -----------------
 143 // - ScannerThread -
 144 // -----------------
 145
 146 class ScannerThread : public osl::Thread
 147 {
 148     boost::shared_ptr<SaneHolder>               m_pHolder;
 149     Reference< com::sun::star::lang::XEventListener > m_xListener;
 150     ScannerManager*                             m_pManager; // just for the disposing call
 151
 152 public:
 153     virtual void run();
 154     virtual void onTerminated() { delete this; }
 155 public:
 156     ScannerThread( boost::shared_ptr<SaneHolder> pHolder,
 157                    const Reference< com::sun::star::lang::XEventListener >& listener,
 158                    ScannerManager* pManager );
 159     virtual ~ScannerThread();
 160 };
 161
 162 // -----------------------------------------------------------------------------
 163
 164 ScannerThread::ScannerThread(
 165                              boost::shared_ptr<SaneHolder> pHolder,
 166                              const Reference< com::sun::star::lang::XEventListener >& listener,
 167                              ScannerManager* pManager )
 168         : m_pHolder( pHolder ), m_xListener( listener ), m_pManager( pManager )
 169 {
 170 #if OSL_DEBUG_LEVEL > 1
 171     fprintf( stderr, "ScannerThread\n" );
 172 #endif
 173 }
 174
 175 ScannerThread::~ScannerThread()
 176 {
 177 #if OSL_DEBUG_LEVEL > 1
 178     fprintf( stderr, "~ScannerThread\n" );
 179 #endif
 180 }
 181
 182 void ScannerThread::run()
 183 {
 184     osl::MutexGuard         aGuard( m_pHolder->m_aProtector );
 185     BitmapTransporter*  pTransporter = new BitmapTransporter;
 186     Reference< XInterface >   aIf( static_cast< OWeakObject* >( pTransporter ) );
 187
 188     m_pHolder->m_xBitmap = Reference< css::awt::XBitmap >( aIf, UNO_QUERY );
 189
 190     m_pHolder->m_bBusy = true;
 191     if( m_pHolder->m_aSane.IsOpen() )
 192     {
 193         int nOption = m_pHolder->m_aSane.GetOptionByName( "preview" );
 194         if( nOption != -1 )
 195             m_pHolder->m_aSane.SetOptionValue( nOption, (sal_Bool)sal_False );
 196
 197         m_pHolder->m_nError =
 198             m_pHolder->m_aSane.Start( *pTransporter ) ?
 199             ScanError_ScanErrorNone : ScanError_ScanCanceled;
 200     }
 201     else
 202         m_pHolder->m_nError = ScanError_ScannerNotAvailable;
 203
 204
 205     Reference< XInterface > xXInterface( static_cast< OWeakObject* >( m_pManager ) );
 206     m_xListener->disposing( com::sun::star::lang::EventObject(xXInterface) );
 207     m_pHolder->m_bBusy = false;
 208 }
 209
 210 // ------------------
 211 // - ScannerManager -
 212 // ------------------
 213
 214 void ScannerManager::AcquireData()
 215 {
 216     osl::MutexGuard aGuard( theSaneProtector::get() );
 217     theSanes::get().acquire();
 218 }
 219
 220 void ScannerManager::ReleaseData()
 221 {
 222     osl::MutexGuard aGuard( theSaneProtector::get() );
 223     theSanes::get().release();
 224 }
 225
 226 // -----------------------------------------------------------------------------
 227
 228 css::awt::Size ScannerManager::getSize() throw()
 229 {
 230     css::awt::Size aRet;
 231     aRet.Width = aRet.Height = 0;
 232     return aRet;
 233 }
 234
 235 // -----------------------------------------------------------------------------
 236
 237 Sequence< sal_Int8 > ScannerManager::getDIB() throw()
 238 {
 239     return Sequence< sal_Int8 >();
 240 }
 241
 242 // -----------------------------------------------------------------------------
 243
 244 Sequence< ScannerContext > ScannerManager::getAvailableScanners() throw()
 245 {
 246     osl::MutexGuard aGuard( theSaneProtector::get() );
 247     sanevec &rSanes = theSanes::get().m_aSanes;
 248
 249     if( rSanes.empty() )
 250     {
 251         boost::shared_ptr<SaneHolder> pSaneHolder(new SaneHolder);
 252         if( Sane::IsSane() )
 253             rSanes.push_back( pSaneHolder );
 254     }
 255
 256     if( Sane::IsSane() )
 257     {
 258         Sequence< ScannerContext > aRet(1);
 259         aRet.getArray()[0].ScannerName      = OUString("SANE");
 260         aRet.getArray()[0].InternalData     = 0;
 261         return aRet;
 262     }
 263
 264     return Sequence< ScannerContext >();
 265 }
 266
 267 // -----------------------------------------------------------------------------
 268
 269 sal_Bool ScannerManager::configureScannerAndScan( ScannerContext& scanner_context,
 270                                                   const Reference< com::sun::star::lang::XEventListener >& listener ) throw( ScannerException )
 271 {
 272     bool bRet;
 273     bool bScan;
 274     {
 275         osl::MutexGuard aGuard( theSaneProtector::get() );
 276         sanevec &rSanes = theSanes::get().m_aSanes;
 277
 278 #if OSL_DEBUG_LEVEL > 1
 279         fprintf( stderr, "ScannerManager::configureScanner\n" );
 280 #endif
 281
 282         if( scanner_context.InternalData < 0 || (sal_uLong)scanner_context.InternalData >= rSanes.size() )
 283             throw ScannerException(
 284                 OUString("Scanner does not exist"),
 285                 Reference< XScannerManager >( this ),
 286                 ScanError_InvalidContext
 287             );
 288
 289         boost::shared_ptr<SaneHolder> pHolder = rSanes[scanner_context.InternalData];
 290         if( pHolder->m_bBusy )
 291             throw ScannerException(
 292                 OUString("Scanner is busy"),
 293                 Reference< XScannerManager >( this ),
 294                 ScanError_ScanInProgress
 295             );
 296
 297         pHolder->m_bBusy = true;
 298         SaneDlg aDlg( NULL, pHolder->m_aSane, listener.is() );
 299         bRet = aDlg.Execute();
 300         bScan = aDlg.getDoScan();
 301         pHolder->m_bBusy = false;
 302     }
 303     if ( bScan )
 304         startScan( scanner_context, listener );
 305
 306     return bRet;
 307 }
 308
 309 // -----------------------------------------------------------------------------
 310
 311 void ScannerManager::startScan( const ScannerContext& scanner_context,
 312                                 const Reference< com::sun::star::lang::XEventListener >& listener ) throw( ScannerException )
 313 {
 314     osl::MutexGuard aGuard( theSaneProtector::get() );
 315     sanevec &rSanes = theSanes::get().m_aSanes;
 316
 317 #if OSL_DEBUG_LEVEL > 1
 318     fprintf( stderr, "ScannerManager::startScan\n" );
 319 #endif
 320
 321     if( scanner_context.InternalData < 0 || (sal_uLong)scanner_context.InternalData >= rSanes.size() )
 322         throw ScannerException(
 323             OUString("Scanner does not exist"),
 324             Reference< XScannerManager >( this ),
 325             ScanError_InvalidContext
 326             );
 327     boost::shared_ptr<SaneHolder> pHolder = rSanes[scanner_context.InternalData];
 328     if( pHolder->m_bBusy )
 329         throw ScannerException(
 330             OUString("Scanner is busy"),
 331             Reference< XScannerManager >( this ),
 332             ScanError_ScanInProgress
 333             );
 334     pHolder->m_bBusy = true;
 335
 336     ScannerThread* pThread = new ScannerThread( pHolder, listener, this );
 337     pThread->create();
 338 }
 339
 340 // -----------------------------------------------------------------------------
 341
 342 ScanError ScannerManager::getError( const ScannerContext& scanner_context ) throw( ScannerException )
 343 {
 344     osl::MutexGuard aGuard( theSaneProtector::get() );
 345     sanevec &rSanes = theSanes::get().m_aSanes;
 346
 347     if( scanner_context.InternalData < 0 || (sal_uLong)scanner_context.InternalData >= rSanes.size() )
 348         throw ScannerException(
 349             OUString("Scanner does not exist"),
 350             Reference< XScannerManager >( this ),
 351             ScanError_InvalidContext
 352             );
 353
 354     boost::shared_ptr<SaneHolder> pHolder = rSanes[scanner_context.InternalData];
 355
 356     return pHolder->m_nError;
 357 }
 358
 359 // -----------------------------------------------------------------------------
 360
 361 Reference< css::awt::XBitmap > ScannerManager::getBitmap( const ScannerContext& scanner_context ) throw( ScannerException )
 362 {
 363     osl::MutexGuard aGuard( theSaneProtector::get() );
 364     sanevec &rSanes = theSanes::get().m_aSanes;
 365
 366     if( scanner_context.InternalData < 0 || (sal_uLong)scanner_context.InternalData >= rSanes.size() )
 367         throw ScannerException(
 368             OUString("Scanner does not exist"),
 369             Reference< XScannerManager >( this ),
 370             ScanError_InvalidContext
 371             );
 372     boost::shared_ptr<SaneHolder> pHolder = rSanes[scanner_context.InternalData];
 373
 374     osl::MutexGuard aProtGuard( pHolder->m_aProtector );
 375
 376     Reference< css::awt::XBitmap > xRet( pHolder->m_xBitmap );
 377     pHolder->m_xBitmap = Reference< css::awt::XBitmap >();
 378
 379     return xRet;
 380 }
 381
 382 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */