extensions/source/scanner/scanwin.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 <com/sun/star/uno/Reference.hxx>
  21 #include <com/sun/star/frame/XFrame.hpp>
  22 #include <com/sun/star/frame/Desktop.hpp>
  23
  24 #include "twain32shim.hxx"
  25
  26 #include <comphelper/processfactory.hxx>
  27 #include <comphelper/scopeguard.hxx>
  28 #include <config_folders.h>
  29 #include <o3tl/char16_t2wchar_t.hxx>
  30 #include <osl/conditn.hxx>
  31 #include <osl/file.hxx>
  32 #include <osl/mutex.hxx>
  33 #include <rtl/bootstrap.hxx>
  34 #include <salhelper/thread.hxx>
  35 #include <toolkit/helper/vclunohelper.hxx>
  36 #include <tools/stream.hxx>
  37 #include <tools/helpers.hxx>
  38 #include <vcl/svapp.hxx>
  39 #include <vcl/window.hxx>
  40 #include "scanner.hxx"
  41
  42 namespace
  43 {
  44
  45 enum TwainState
  46 {
  47     TWAIN_STATE_NONE = 0,
  48     TWAIN_STATE_SCANNING = 1,
  49     TWAIN_STATE_DONE = 2,
  50     TWAIN_STATE_CANCELED = 3
  51 };
  52
  53 struct HANDLEDeleter
  54 {
  55     using pointer = HANDLE;
  56     void operator()(HANDLE h) { CloseHandle(h); }
  57 };
  58
  59 using ScopedHANDLE = std::unique_ptr<HANDLE, HANDLEDeleter>;
  60
  61 class Twain
  62 {
  63 public:
  64     Twain();
  65     ~Twain();
  66
  67     bool SelectSource(ScannerManager& rMgr, const VclPtr<vcl::Window>& xTopWindow);
  68     bool PerformTransfer(ScannerManager& rMgr,
  69                          const css::uno::Reference<css::lang::XEventListener>& rxListener,
  70                          const VclPtr<vcl::Window>& xTopWindow);
  71     void WaitReadyForNextTask();
  72
  73     TwainState GetState() const { return meState; }
  74
  75 private:
  76     friend class ShimListenerThread;
  77     class ShimListenerThread : public salhelper::Thread
  78     {
  79     public:
  80         ShimListenerThread(const VclPtr<vcl::Window>& xTopWindow);
  81         ~ShimListenerThread() override;
  82         void execute() override;
  83         const OUString& getError() { return msErrorReported; }
  84
  85         // These methods are executed outside of own thread
  86         bool WaitInitialization();
  87         bool WaitRequestResult();
  88         void DontNotify() { mbDontNotify = true; }
  89         void RequestDestroy();
  90         bool RequestSelectSource();
  91         bool RequestInitXfer();
  92
  93     private:
  94         VclPtr<vcl::Window> mxTopWindow; // the window that we made modal
  95         bool mbDontNotify = false;
  96         HWND mhWndShim = nullptr; // shim main window handle
  97         OUString msErrorReported;
  98         osl::Condition mcInitCompleted; // initially not set
  99         bool mbInitSucceeded = false;
 100         osl::Condition mcGotRequestResult;
 101         bool mbRequestResult = false;
 102
 103         void SendShimRequest(WPARAM nRequest);
 104         bool SendShimRequestWithResult(WPARAM nRequest);
 105         void NotificationHdl(WPARAM nEvent, LPARAM lParam);
 106         void NotifyOwner(WPARAM nEvent);
 107         void NotifyXFerOwner(LPARAM nHandle);
 108     };
 109     css::uno::Reference<css::lang::XEventListener> mxListener;
 110     css::uno::Reference<css::scanner::XScannerManager> mxMgr;
 111     ScannerManager* mpCurMgr = nullptr;
 112     TwainState meState = TWAIN_STATE_NONE;
 113     rtl::Reference<ShimListenerThread> mpThread;
 114     osl::Mutex maMutex;
 115
 116     DECL_LINK(ImpNotifyHdl, void*, void);
 117     DECL_LINK(ImpNotifyXferHdl, void*, void);
 118     void Notify(WPARAM nEvent); // called by shim communication thread to notify me
 119     void NotifyXFer(LPARAM nHandle); // called by shim communication thread to notify me
 120
 121     bool InitializeNewShim(ScannerManager& rMgr, const VclPtr<vcl::Window>& xTopWindow);
 122
 123     void Reset(); // cleanup thread and manager
 124 };
 125
 126 static Twain aTwain;
 127
 128 Twain::ShimListenerThread::ShimListenerThread(const VclPtr<vcl::Window>& xTopWindow)
 129     : salhelper::Thread("TWAINShimListenerThread")
 130     , mxTopWindow(xTopWindow)
 131 {
 132     if (mxTopWindow)
 133     {
 134         mxTopWindow->IncModalCount(); // the operation is modal to the frame
 135     }
 136 }
 137
 138 Twain::ShimListenerThread::~ShimListenerThread()
 139 {
 140     if (mxTopWindow)
 141     {
 142         mxTopWindow->DecModalCount(); // unblock the frame
 143     }
 144 }
 145
 146 bool Twain::ShimListenerThread::WaitInitialization()
 147 {
 148     mcInitCompleted.wait();
 149     return mbInitSucceeded;
 150 }
 151
 152 bool Twain::ShimListenerThread::WaitRequestResult()
 153 {
 154     mcGotRequestResult.wait();
 155     return mbRequestResult;
 156 }
 157
 158 void Twain::ShimListenerThread::SendShimRequest(WPARAM nRequest)
 159 {
 160     if (mhWndShim)
 161         PostMessageW(mhWndShim, WM_TWAIN_REQUEST, nRequest, 0);
 162 }
 163
 164 bool Twain::ShimListenerThread::SendShimRequestWithResult(WPARAM nRequest)
 165 {
 166     mcGotRequestResult.reset();
 167     mbRequestResult = false;
 168     SendShimRequest(nRequest);
 169     return WaitRequestResult();
 170 }
 171
 172 void Twain::ShimListenerThread::RequestDestroy() { SendShimRequest(TWAIN_REQUEST_QUIT); }
 173
 174 bool Twain::ShimListenerThread::RequestSelectSource()
 175 {
 176     assert(mbInitSucceeded);
 177     return SendShimRequestWithResult(TWAIN_REQUEST_SELECTSOURCE);
 178 }
 179
 180 bool Twain::ShimListenerThread::RequestInitXfer()
 181 {
 182     assert(mbInitSucceeded);
 183     return SendShimRequestWithResult(TWAIN_REQUEST_INITXFER);
 184 }
 185
 186 void Twain::ShimListenerThread::NotifyOwner(WPARAM nEvent)
 187 {
 188     if (!mbDontNotify)
 189         aTwain.Notify(nEvent);
 190 }
 191
 192 void Twain::ShimListenerThread::NotifyXFerOwner(LPARAM nHandle)
 193 {
 194     if (!mbDontNotify)
 195         aTwain.NotifyXFer(nHandle);
 196 }
 197
 198 // May only be called from the own thread, so no threading issues modifying self
 199 void Twain::ShimListenerThread::NotificationHdl(WPARAM nEvent, LPARAM lParam)
 200 {
 201     switch (nEvent)
 202     {
 203         case TWAIN_EVENT_NOTIFYHWND: // shim reported its main HWND for communications
 204             if (!mcInitCompleted.check()) // only if not yet initialized!
 205             {
 206                 // Owner is still waiting mcInitCompleted in its Twain::InitializeNewShim,
 207                 // holding its access mutex
 208                 mhWndShim = reinterpret_cast<HWND>(lParam);
 209
 210                 mbInitSucceeded = lParam != 0;
 211                 mcInitCompleted.set();
 212             }
 213             break;
 214         case TWAIN_EVENT_SCANNING:
 215             NotifyOwner(nEvent);
 216             break;
 217         case TWAIN_EVENT_XFER:
 218             NotifyXFerOwner(lParam);
 219             break;
 220         case TWAIN_EVENT_REQUESTRESULT:
 221             mbRequestResult = lParam;
 222             mcGotRequestResult.set();
 223             break;
 224             // We don't handle TWAIN_EVENT_QUIT notification from shim, because we send it ourselves
 225             // in the end of execute()
 226     }
 227 }
 228
 229 // Spawn a separate 32-bit process to use TWAIN on Windows, and listen for its notifications
 230 void Twain::ShimListenerThread::execute()
 231 {
 232     MSG msg;
 233     // Initialize thread message queue before launching shim process
 234     PeekMessageW(&msg, nullptr, 0, 0, PM_NOREMOVE);
 235
 236     try
 237     {
 238         ScopedHANDLE hShimProcess;
 239         {
 240             // Determine twain32shim executable URL:
 241             OUString shimURL("$BRAND_BASE_DIR/" LIBO_BIN_FOLDER "/twain32shim.exe");
 242             rtl::Bootstrap::expandMacros(shimURL);
 243
 244             OUString sCmdLine;
 245             if (osl::FileBase::getSystemPathFromFileURL(shimURL, sCmdLine) != osl::FileBase::E_None)
 246                 throw std::exception("getSystemPathFromFileURL failed!");
 247
 248             HANDLE hDup;
 249             if (!DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(),
 250                                  &hDup, SYNCHRONIZE | THREAD_QUERY_LIMITED_INFORMATION, TRUE, 0))
 251                 ThrowLastError("DuplicateHandle");
 252             // we will not need our copy as soon as shim has its own inherited one
 253             ScopedHANDLE hScopedDup(hDup);
 254             DWORD nDup = reinterpret_cast<DWORD>(hDup);
 255             if (reinterpret_cast<HANDLE>(nDup) != hDup)
 256                 throw std::exception("HANDLE does not fit to 32 bit - cannot pass to shim!");
 257
 258             // Send this thread handle as the first parameter
 259             sCmdLine = "\"" + sCmdLine + "\" " + OUString::number(nDup);
 260
 261             // We need a WinAPI HANDLE of the process to be able to wait on it and detect the process
 262             // termination; so use WinAPI to start the process, not osl_executeProcess.
 263
 264             STARTUPINFOW si{ sizeof(si) }; // null-initialize all but cb
 265             PROCESS_INFORMATION pi;
 266
 267             if (!CreateProcessW(nullptr, const_cast<LPWSTR>(o3tl::toW(sCmdLine.getStr())), nullptr,
 268                                 nullptr, TRUE, CREATE_NO_WINDOW, nullptr, nullptr, &si, &pi))
 269                 ThrowLastError("CreateProcessW");
 270
 271             CloseHandle(pi.hThread);
 272             hShimProcess.reset(pi.hProcess);
 273         }
 274         HANDLE h = hShimProcess.get();
 275         while (true)
 276         {
 277             DWORD nWaitResult = MsgWaitForMultipleObjects(1, &h, FALSE, INFINITE, QS_POSTMESSAGE);
 278             // Process any messages in queue before checking if we need to break, to not loose
 279             // possible pending notifications
 280             while (PeekMessageW(&msg, nullptr, 0, 0, PM_REMOVE))
 281             {
 282                 // process it here
 283                 if (msg.message == WM_TWAIN_EVENT)
 284                 {
 285                     NotificationHdl(msg.wParam, msg.lParam);
 286                 }
 287             }
 288             if (nWaitResult == WAIT_OBJECT_0)
 289             {
 290                 // shim process exited - return
 291                 break;
 292             }
 293             if (nWaitResult == WAIT_FAILED)
 294             {
 295                 // Some Win32 error - report and return
 296                 ThrowLastError("MsgWaitForMultipleObjects");
 297             }
 298         }
 299     }
 300     catch (const std::exception& e)
 301     {
 302         msErrorReported = OUString(e.what(), strlen(e.what()), RTL_TEXTENCODING_UTF8);
 303         // allow owner to resume (in case the condition isn't set yet)
 304         mcInitCompleted.set(); // let mbInitSucceeded keep its (maybe false) value!
 305     }
 306     // allow owner to resume (in case the conditions isn't set yet)
 307     mcGotRequestResult.set();
 308     NotifyOwner(TWAIN_EVENT_QUIT);
 309 }
 310
 311 Twain::Twain() {}
 312
 313 Twain::~Twain()
 314 {
 315     osl::MutexGuard aGuard(maMutex);
 316     if (mpThread)
 317     {
 318         mpThread->DontNotify();
 319         mpThread->RequestDestroy();
 320         mpThread->join();
 321         mpThread.clear();
 322     }
 323 }
 324
 325 void Twain::Reset()
 326 {
 327     mpThread->join();
 328     if (!mpThread->getError().isEmpty())
 329         SAL_WARN("extensions.scanner", mpThread->getError());
 330     mpThread.clear();
 331     mpCurMgr = nullptr;
 332     mxMgr.clear();
 333 }
 334
 335 bool Twain::InitializeNewShim(ScannerManager& rMgr, const VclPtr<vcl::Window>& xTopWindow)
 336 {
 337     osl::MutexGuard aGuard(maMutex);
 338     if (mpThread)
 339         return false; // Have a shim for another task already!
 340
 341     // hold reference to ScannerManager, to prevent premature death
 342     mxMgr.set(static_cast<OWeakObject*>(mpCurMgr = &rMgr),
 343               css::uno::UNO_QUERY);
 344
 345     mpThread.set(new ShimListenerThread(xTopWindow));
 346     mpThread->launch();
 347     const bool bSuccess = mpThread->WaitInitialization();
 348     if (!bSuccess)
 349         Reset();
 350
 351     return bSuccess;
 352 }
 353
 354 void Twain::Notify(WPARAM nEvent)
 355 {
 356     Application::PostUserEvent(LINK(this, Twain, ImpNotifyHdl), reinterpret_cast<void*>(nEvent));
 357 }
 358
 359 void Twain::NotifyXFer(LPARAM nHandle)
 360 {
 361     Application::PostUserEvent(LINK(this, Twain, ImpNotifyXferHdl),
 362                                reinterpret_cast<void*>(nHandle));
 363 }
 364
 365 bool Twain::SelectSource(ScannerManager& rMgr, const VclPtr<vcl::Window>& xTopWindow)
 366 {
 367     osl::MutexGuard aGuard(maMutex);
 368     bool bRet = false;
 369
 370     if (InitializeNewShim(rMgr, xTopWindow))
 371     {
 372         meState = TWAIN_STATE_NONE;
 373         bRet = mpThread->RequestSelectSource();
 374     }
 375
 376     return bRet;
 377 }
 378
 379 bool Twain::PerformTransfer(ScannerManager& rMgr,
 380                             const css::uno::Reference<css::lang::XEventListener>& rxListener,
 381                             const VclPtr<vcl::Window>& xTopWindow)
 382 {
 383     osl::MutexGuard aGuard(maMutex);
 384     bool bRet = false;
 385
 386     if (InitializeNewShim(rMgr, xTopWindow))
 387     {
 388         mxListener = rxListener;
 389         meState = TWAIN_STATE_NONE;
 390         bRet = mpThread->RequestInitXfer();
 391     }
 392
 393     return bRet;
 394 }
 395
 396 void Twain::WaitReadyForNextTask()
 397 {
 398     while ([&]() {
 399         osl::MutexGuard aGuard(maMutex);
 400         return bool(mpThread);
 401     }())
 402     {
 403         Application::Reschedule(true);
 404     }
 405 }
 406
 407 IMPL_LINK(Twain, ImpNotifyHdl, void*, pParam, void)
 408 {
 409     osl::MutexGuard aGuard(maMutex);
 410     WPARAM nEvent = reinterpret_cast<WPARAM>(pParam);
 411     switch (nEvent)
 412     {
 413         case TWAIN_EVENT_SCANNING:
 414             meState = TWAIN_STATE_SCANNING;
 415             break;
 416
 417         case TWAIN_EVENT_QUIT:
 418         {
 419             if (meState != TWAIN_STATE_DONE)
 420                 meState = TWAIN_STATE_CANCELED;
 421
 422             css::lang::EventObject event(mxMgr); // mxMgr will be cleared below
 423
 424             if (mpThread)
 425                 Reset();
 426
 427             if (mxListener.is())
 428             {
 429                 mxListener->disposing(event);
 430                 mxListener.clear();
 431             }
 432         }
 433         break;
 434
 435         default:
 436             break;
 437     }
 438 }
 439
 440 IMPL_LINK(Twain, ImpNotifyXferHdl, void*, pParam, void)
 441 {
 442     osl::MutexGuard aGuard(maMutex);
 443     if (mpThread)
 444     {
 445         mpCurMgr->SetData(pParam);
 446         meState = pParam ? TWAIN_STATE_DONE : TWAIN_STATE_CANCELED;
 447
 448         css::lang::EventObject event(mxMgr); // mxMgr will be cleared below
 449
 450         Reset();
 451
 452         if (mxListener.is())
 453             mxListener->disposing(css::lang::EventObject(mxMgr));
 454     }
 455
 456     mxListener.clear();
 457 }
 458
 459 VclPtr<vcl::Window> ImplGetActiveFrameWindow()
 460 {
 461     try
 462     {
 463         // query desktop instance
 464         css::uno::Reference<css::frame::XDesktop2> xDesktop
 465             = css::frame::Desktop::create(comphelper::getProcessComponentContext());
 466         if (css::uno::Reference<css::frame::XFrame> xActiveFrame = xDesktop->getActiveFrame())
 467             return VCLUnoHelper::GetWindow(xActiveFrame->getComponentWindow());
 468     }
 469     catch (const css::uno::Exception&)
 470     {
 471     }
 472     SAL_WARN("extensions.scanner", "ImplGetActiveFrame: Could not determine active frame!");
 473     return nullptr;
 474 }
 475
 476 } // namespace
 477
 478 void ScannerManager::AcquireData() {}
 479
 480 void ScannerManager::ReleaseData()
 481 {
 482     if (mpData)
 483     {
 484         CloseHandle(static_cast<HANDLE>(mpData));
 485         mpData = nullptr;
 486     }
 487 }
 488
 489 css::awt::Size ScannerManager::getSize()
 490 {
 491     css::awt::Size aRet;
 492
 493     if (mpData)
 494     {
 495         HANDLE hMap = static_cast<HANDLE>(mpData);
 496         // map full size
 497         const sal_Int8* pMap = static_cast<sal_Int8*>(MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0));
 498         if (pMap)
 499         {
 500             const BITMAPINFOHEADER* pBIH = reinterpret_cast<const BITMAPINFOHEADER*>(pMap + 4);
 501             aRet.Width = pBIH->biWidth;
 502             aRet.Height = pBIH->biHeight;
 503
 504             UnmapViewOfFile(pMap);
 505         }
 506     }
 507
 508     return aRet;
 509 }
 510
 511 css::uno::Sequence<sal_Int8> ScannerManager::getDIB()
 512 {
 513     css::uno::Sequence<sal_Int8> aRet;
 514
 515     if (mpData)
 516     {
 517         HANDLE hMap = static_cast<HANDLE>(mpData);
 518         // map full size
 519         const sal_Int8* pMap = static_cast<sal_Int8*>(MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0));
 520         if (pMap)
 521         {
 522             DWORD nDIBSize;
 523             memcpy(&nDIBSize, pMap, 4); // size of the following DIB
 524
 525             const BITMAPINFOHEADER* pBIH = reinterpret_cast<const BITMAPINFOHEADER*>(pMap + 4);
 526
 527             sal_uInt32 nColEntries = 0;
 528
 529             switch (pBIH->biBitCount)
 530             {
 531                 case 1:
 532                 case 4:
 533                 case 8:
 534                     nColEntries = pBIH->biClrUsed ? pBIH->biClrUsed : (1 << pBIH->biBitCount);
 535                     break;
 536
 537                 case 24:
 538                     nColEntries = pBIH->biClrUsed ? pBIH->biClrUsed : 0;
 539                     break;
 540
 541                 case 16:
 542                 case 32:
 543                     nColEntries = pBIH->biClrUsed;
 544                     if (pBIH->biCompression == BI_BITFIELDS)
 545                         nColEntries += 3;
 546                     break;
 547             }
 548
 549             aRet = css::uno::Sequence<sal_Int8>(sizeof(BITMAPFILEHEADER) + nDIBSize);
 550
 551             sal_Int8* pBuf = aRet.getArray();
 552             SvMemoryStream* pMemStm
 553                 = new SvMemoryStream(pBuf, sizeof(BITMAPFILEHEADER), StreamMode::WRITE);
 554
 555             pMemStm->WriteChar('B').WriteChar('M').WriteUInt32(0).WriteUInt32(0);
 556             pMemStm->WriteUInt32(sizeof(BITMAPFILEHEADER) + pBIH->biSize
 557                                  + (nColEntries * sizeof(RGBQUAD)));
 558
 559             delete pMemStm;
 560             memcpy(pBuf + sizeof(BITMAPFILEHEADER), pBIH, nDIBSize);
 561
 562             UnmapViewOfFile(pMap);
 563         }
 564
 565         ReleaseData();
 566     }
 567
 568     return aRet;
 569 }
 570
 571 css::uno::Sequence<ScannerContext> SAL_CALL ScannerManager::getAvailableScanners()
 572 {
 573     osl::MutexGuard aGuard(maProtector);
 574     css::uno::Sequence<ScannerContext> aRet(1);
 575
 576     aRet.getArray()[0].ScannerName = "TWAIN";
 577     aRet.getArray()[0].InternalData = 0;
 578
 579     return aRet;
 580 }
 581
 582 sal_Bool SAL_CALL ScannerManager::configureScannerAndScan(
 583     ScannerContext& rContext, const css::uno::Reference<css::lang::XEventListener>& rxListener)
 584 {
 585     osl::MutexGuard aGuard(maProtector);
 586     css::uno::Reference<XScannerManager> xThis(this);
 587
 588     if (rContext.InternalData != 0 || rContext.ScannerName != "TWAIN")
 589         throw ScannerException("Scanner does not exist", xThis, ScanError_InvalidContext);
 590
 591     ReleaseData();
 592
 593     VclPtr<vcl::Window> xTopWindow = ImplGetActiveFrameWindow();
 594     if (xTopWindow)
 595         xTopWindow->IncModalCount(); // to avoid changes between the two operations that each
 596                                      // block the window
 597     comphelper::ScopeGuard aModalGuard([xTopWindow]() {
 598         if (xTopWindow)
 599             xTopWindow->DecModalCount();
 600     });
 601
 602     const bool bSelected = aTwain.SelectSource(*this, xTopWindow);
 603     if (bSelected)
 604     {
 605         aTwain.WaitReadyForNextTask();
 606         aTwain.PerformTransfer(*this, rxListener, xTopWindow);
 607     }
 608     return bSelected;
 609 }
 610
 611 void SAL_CALL
 612 ScannerManager::startScan(const ScannerContext& rContext,
 613                           const css::uno::Reference<css::lang::XEventListener>& rxListener)
 614 {
 615     osl::MutexGuard aGuard(maProtector);
 616     css::uno::Reference<XScannerManager> xThis(this);
 617
 618     if (rContext.InternalData != 0 || rContext.ScannerName != "TWAIN")
 619         throw ScannerException("Scanner does not exist", xThis, ScanError_InvalidContext);
 620
 621     ReleaseData();
 622     aTwain.PerformTransfer(*this, rxListener, ImplGetActiveFrameWindow());
 623 }
 624
 625 ScanError SAL_CALL ScannerManager::getError(const ScannerContext& rContext)
 626 {
 627     osl::MutexGuard aGuard(maProtector);
 628     css::uno::Reference<XScannerManager> xThis(this);
 629
 630     if (rContext.InternalData != 0 || rContext.ScannerName != "TWAIN")
 631         throw ScannerException("Scanner does not exist", xThis, ScanError_InvalidContext);
 632
 633     return ((aTwain.GetState() == TWAIN_STATE_CANCELED) ? ScanError_ScanCanceled
 634                                                         : ScanError_ScanErrorNone);
 635 }
 636
 637 css::uno::Reference<css::awt::XBitmap>
 638     SAL_CALL ScannerManager::getBitmap(const ScannerContext& /*rContext*/)
 639 {
 640     osl::MutexGuard aGuard(maProtector);
 641     return css::uno::Reference<css::awt::XBitmap>(this);
 642 }
 643
 644 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */