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