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             sal_uIntPtr nDup = reinterpret_cast<sal_uIntPtr>(hDup);
 257             if constexpr (sizeof(sal_uIntPtr) > 4)
 258                 if (nDup > 0xFFFFFFFF)
 259                     throw std::exception("HANDLE does not fit to 32 bit - cannot pass to shim!");
 260
 261             // Send this thread handle as the first parameter
 262             sCmdLine = "\"" + sCmdLine + "\" " + OUString::number(nDup);
 263
 264             // We need a WinAPI HANDLE of the process to be able to wait on it and detect the process
 265             // termination; so use WinAPI to start the process, not osl_executeProcess.
 266
 267             STARTUPINFOW si{};
 268             si.cb = sizeof(si);
 269             PROCESS_INFORMATION pi;
 270
 271             if (!CreateProcessW(nullptr, const_cast<LPWSTR>(o3tl::toW(sCmdLine.getStr())), nullptr,
 272                                 nullptr, TRUE, CREATE_NO_WINDOW, nullptr, nullptr, &si, &pi))
 273                 ThrowLastError("CreateProcessW");
 274
 275             CloseHandle(pi.hThread);
 276             hShimProcess.reset(pi.hProcess);
 277         }
 278         HANDLE h = hShimProcess.get();
 279         while (true)
 280         {
 281             DWORD nWaitResult = MsgWaitForMultipleObjects(1, &h, FALSE, INFINITE, QS_POSTMESSAGE);
 282             // Process any messages in queue before checking if we need to break, to not loose
 283             // possible pending notifications
 284             while (PeekMessageW(&msg, nullptr, 0, 0, PM_REMOVE))
 285             {
 286                 // process it here
 287                 if (msg.message == WM_TWAIN_EVENT)
 288                 {
 289                     NotificationHdl(msg.wParam, msg.lParam);
 290                 }
 291             }
 292             if (nWaitResult == WAIT_OBJECT_0)
 293             {
 294                 // shim process exited - return
 295                 break;
 296             }
 297             if (nWaitResult == WAIT_FAILED)
 298             {
 299                 // Some Win32 error - report and return
 300                 ThrowLastError("MsgWaitForMultipleObjects");
 301             }
 302         }
 303     }
 304     catch (const std::exception& e)
 305     {
 306         msErrorReported = OUString(e.what(), strlen(e.what()), RTL_TEXTENCODING_UTF8);
 307         // allow owner to resume (in case the condition isn't set yet)
 308         mcInitCompleted.set(); // let mbInitSucceeded keep its (maybe false) value!
 309     }
 310     // allow owner to resume (in case the conditions isn't set yet)
 311     mcGotRequestResult.set();
 312     NotifyOwner(TWAIN_EVENT_QUIT);
 313 }
 314
 315 Twain::Twain() {}
 316
 317 Twain::~Twain()
 318 {
 319     osl::MutexGuard aGuard(maMutex);
 320     if (mpThread)
 321     {
 322         mpThread->DontNotify();
 323         mpThread->RequestDestroy();
 324         mpThread->join();
 325         mpThread.clear();
 326     }
 327 }
 328
 329 void Twain::Reset()
 330 {
 331     mpThread->join();
 332     if (!mpThread->getError().isEmpty())
 333         SAL_WARN("extensions.scanner", mpThread->getError());
 334     mpThread.clear();
 335     mpCurMgr = nullptr;
 336     mxMgr.clear();
 337 }
 338
 339 bool Twain::InitializeNewShim(ScannerManager& rMgr, const VclPtr<vcl::Window>& xTopWindow)
 340 {
 341     osl::MutexGuard aGuard(maMutex);
 342     if (mpThread)
 343         return false; // Have a shim for another task already!
 344
 345     // hold reference to ScannerManager, to prevent premature death
 346     mxMgr = mpCurMgr = &rMgr;
 347
 348     mpThread.set(new ShimListenerThread(xTopWindow));
 349     mpThread->launch();
 350     const bool bSuccess = mpThread->WaitInitialization();
 351     if (!bSuccess)
 352         Reset();
 353
 354     return bSuccess;
 355 }
 356
 357 void Twain::Notify(WPARAM nEvent)
 358 {
 359     Application::PostUserEvent(LINK(this, Twain, ImpNotifyHdl), reinterpret_cast<void*>(nEvent));
 360 }
 361
 362 void Twain::NotifyXFer(LPARAM nHandle)
 363 {
 364     Application::PostUserEvent(LINK(this, Twain, ImpNotifyXferHdl),
 365                                reinterpret_cast<void*>(nHandle));
 366 }
 367
 368 bool Twain::SelectSource(ScannerManager& rMgr, const VclPtr<vcl::Window>& xTopWindow)
 369 {
 370     osl::MutexGuard aGuard(maMutex);
 371     bool bRet = false;
 372
 373     if (InitializeNewShim(rMgr, xTopWindow))
 374     {
 375         meState = TWAIN_STATE_NONE;
 376         bRet = mpThread->RequestSelectSource();
 377     }
 378
 379     return bRet;
 380 }
 381
 382 bool Twain::PerformTransfer(ScannerManager& rMgr,
 383                             const css::uno::Reference<css::lang::XEventListener>& rxListener,
 384                             const VclPtr<vcl::Window>& xTopWindow)
 385 {
 386     osl::MutexGuard aGuard(maMutex);
 387     bool bRet = false;
 388
 389     if (InitializeNewShim(rMgr, xTopWindow))
 390     {
 391         mxListener = rxListener;
 392         meState = TWAIN_STATE_NONE;
 393         bRet = mpThread->RequestInitXfer();
 394     }
 395
 396     return bRet;
 397 }
 398
 399 void Twain::WaitReadyForNextTask()
 400 {
 401     while ([&]() {
 402         osl::MutexGuard aGuard(maMutex);
 403         return bool(mpThread);
 404     }())
 405     {
 406         Application::Reschedule(true);
 407     }
 408 }
 409
 410 IMPL_LINK(Twain, ImpNotifyHdl, void*, pParam, void)
 411 {
 412     osl::MutexGuard aGuard(maMutex);
 413     WPARAM nEvent = reinterpret_cast<WPARAM>(pParam);
 414     switch (nEvent)
 415     {
 416         case TWAIN_EVENT_SCANNING:
 417             meState = TWAIN_STATE_SCANNING;
 418             break;
 419
 420         case TWAIN_EVENT_QUIT:
 421         {
 422             if (meState != TWAIN_STATE_DONE)
 423                 meState = TWAIN_STATE_CANCELED;
 424
 425             css::lang::EventObject event(mxMgr); // mxMgr will be cleared below
 426
 427             if (mpThread)
 428                 Reset();
 429
 430             if (mxListener.is())
 431             {
 432                 mxListener->disposing(event);
 433                 mxListener.clear();
 434             }
 435         }
 436         break;
 437
 438         default:
 439             break;
 440     }
 441 }
 442
 443 IMPL_LINK(Twain, ImpNotifyXferHdl, void*, pParam, void)
 444 {
 445     osl::MutexGuard aGuard(maMutex);
 446     if (mpThread)
 447     {
 448         mpCurMgr->SetData(pParam);
 449         meState = pParam ? TWAIN_STATE_DONE : TWAIN_STATE_CANCELED;
 450
 451         css::lang::EventObject event(mxMgr); // mxMgr will be cleared below
 452
 453         Reset();
 454
 455         if (mxListener.is())
 456             mxListener->disposing(css::lang::EventObject(mxMgr));
 457     }
 458
 459     mxListener.clear();
 460 }
 461
 462 VclPtr<vcl::Window> ImplGetActiveFrameWindow()
 463 {
 464     try
 465     {
 466         // query desktop instance
 467         css::uno::Reference<css::frame::XDesktop2> xDesktop
 468             = css::frame::Desktop::create(comphelper::getProcessComponentContext());
 469         if (css::uno::Reference<css::frame::XFrame> xActiveFrame = xDesktop->getActiveFrame())
 470             return VCLUnoHelper::GetWindow(xActiveFrame->getComponentWindow());
 471     }
 472     catch (const css::uno::Exception&)
 473     {
 474     }
 475     SAL_WARN("extensions.scanner", "ImplGetActiveFrame: Could not determine active frame!");
 476     return nullptr;
 477 }
 478
 479 } // namespace
 480
 481 void ScannerManager::AcquireData() {}
 482
 483 void ScannerManager::ReleaseData()
 484 {
 485     if (mpData)
 486     {
 487         CloseHandle(static_cast<HANDLE>(mpData));
 488         mpData = nullptr;
 489     }
 490 }
 491
 492 css::awt::Size ScannerManager::getSize()
 493 {
 494     css::awt::Size aRet;
 495
 496     if (mpData)
 497     {
 498         HANDLE hMap = static_cast<HANDLE>(mpData);
 499         // map full size
 500         const sal_Int8* pMap = static_cast<sal_Int8*>(MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0));
 501         if (pMap)
 502         {
 503             const BITMAPINFOHEADER* pBIH = reinterpret_cast<const BITMAPINFOHEADER*>(pMap + 4);
 504             aRet.Width = pBIH->biWidth;
 505             aRet.Height = pBIH->biHeight;
 506
 507             UnmapViewOfFile(pMap);
 508         }
 509     }
 510
 511     return aRet;
 512 }
 513
 514 css::uno::Sequence<sal_Int8> ScannerManager::getDIB()
 515 {
 516     css::uno::Sequence<sal_Int8> aRet;
 517
 518     if (mpData)
 519     {
 520         HANDLE hMap = static_cast<HANDLE>(mpData);
 521         // map full size
 522         const sal_Int8* pMap = static_cast<sal_Int8*>(MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0));
 523         if (pMap)
 524         {
 525             DWORD nDIBSize;
 526             memcpy(&nDIBSize, pMap, 4); // size of the following DIB
 527
 528             const BITMAPINFOHEADER* pBIH = reinterpret_cast<const BITMAPINFOHEADER*>(pMap + 4);
 529
 530             sal_uInt32 nColEntries = 0;
 531
 532             switch (pBIH->biBitCount)
 533             {
 534                 case 1:
 535                 case 4:
 536                 case 8:
 537                     nColEntries = pBIH->biClrUsed ? pBIH->biClrUsed : (1 << pBIH->biBitCount);
 538                     break;
 539
 540                 case 24:
 541                     nColEntries = pBIH->biClrUsed ? pBIH->biClrUsed : 0;
 542                     break;
 543
 544                 case 16:
 545                 case 32:
 546                     nColEntries = pBIH->biClrUsed;
 547                     if (pBIH->biCompression == BI_BITFIELDS)
 548                         nColEntries += 3;
 549                     break;
 550             }
 551
 552             aRet = css::uno::Sequence<sal_Int8>(sizeof(BITMAPFILEHEADER) + nDIBSize);
 553
 554             sal_Int8* pBuf = aRet.getArray();
 555             SvMemoryStream* pMemStm
 556                 = new SvMemoryStream(pBuf, sizeof(BITMAPFILEHEADER), StreamMode::WRITE);
 557
 558             pMemStm->WriteChar('B').WriteChar('M').WriteUInt32(0).WriteUInt32(0);
 559             pMemStm->WriteUInt32(sizeof(BITMAPFILEHEADER) + pBIH->biSize
 560                                  + (nColEntries * sizeof(RGBQUAD)));
 561
 562             delete pMemStm;
 563             memcpy(pBuf + sizeof(BITMAPFILEHEADER), pBIH, nDIBSize);
 564
 565             UnmapViewOfFile(pMap);
 566         }
 567
 568         ReleaseData();
 569     }
 570
 571     return aRet;
 572 }
 573
 574 css::uno::Sequence<ScannerContext> SAL_CALL ScannerManager::getAvailableScanners()
 575 {
 576     osl::MutexGuard aGuard(maProtector);
 577     css::uno::Sequence<ScannerContext> aRet(1);
 578
 579     aRet.getArray()[0].ScannerName = "TWAIN";
 580     aRet.getArray()[0].InternalData = 0;
 581
 582     return aRet;
 583 }
 584
 585 sal_Bool SAL_CALL ScannerManager::configureScannerAndScan(
 586     ScannerContext& rContext, const css::uno::Reference<css::lang::XEventListener>& rxListener)
 587 {
 588     osl::MutexGuard aGuard(maProtector);
 589     css::uno::Reference<XScannerManager> xThis(this);
 590
 591     if (rContext.InternalData != 0 || rContext.ScannerName != "TWAIN")
 592         throw ScannerException("Scanner does not exist", xThis, ScanError_InvalidContext);
 593
 594     ReleaseData();
 595
 596     VclPtr<vcl::Window> xTopWindow = ImplGetActiveFrameWindow();
 597     if (xTopWindow)
 598         xTopWindow
 599             ->IncModalCount(); // to avoid changes between the two operations that each block the window
 600     comphelper::ScopeGuard aModalGuard([xTopWindow]() {
 601         if (xTopWindow)
 602             xTopWindow->DecModalCount();
 603     });
 604
 605     const bool bSelected = aTwain.SelectSource(*this, xTopWindow);
 606     if (bSelected)
 607     {
 608         aTwain.WaitReadyForNextTask();
 609         aTwain.PerformTransfer(*this, rxListener, xTopWindow);
 610     }
 611     return bSelected;
 612 }
 613
 614 void SAL_CALL
 615 ScannerManager::startScan(const ScannerContext& rContext,
 616                           const css::uno::Reference<css::lang::XEventListener>& rxListener)
 617 {
 618     osl::MutexGuard aGuard(maProtector);
 619     css::uno::Reference<XScannerManager> xThis(this);
 620
 621     if (rContext.InternalData != 0 || rContext.ScannerName != "TWAIN")
 622         throw ScannerException("Scanner does not exist", xThis, ScanError_InvalidContext);
 623
 624     ReleaseData();
 625     aTwain.PerformTransfer(*this, rxListener, ImplGetActiveFrameWindow());
 626 }
 627
 628 ScanError SAL_CALL ScannerManager::getError(const ScannerContext& rContext)
 629 {
 630     osl::MutexGuard aGuard(maProtector);
 631     css::uno::Reference<XScannerManager> xThis(this);
 632
 633     if (rContext.InternalData != 0 || rContext.ScannerName != "TWAIN")
 634         throw ScannerException("Scanner does not exist", xThis, ScanError_InvalidContext);
 635
 636     return ((aTwain.GetState() == TWAIN_STATE_CANCELED) ? ScanError_ScanCanceled
 637                                                         : ScanError_ScanErrorNone);
 638 }
 639
 640 css::uno::Reference<css::awt::XBitmap>
 641     SAL_CALL ScannerManager::getBitmap(const ScannerContext& /*rContext*/)
 642 {
 643     osl::MutexGuard aGuard(maProtector);
 644     return css::uno::Reference<css::awt::XBitmap>(this);
 645 }
 646
 647 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */