extensions/source/scanner/scanwin.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_extensions.hxx"
  30 #include <com/sun/star/uno/Any.hxx>
  31 #include <com/sun/star/uno/Reference.hxx>
  32 #include <com/sun/star/util/XCloseable.hpp>
  33 #include <com/sun/star/util/XCloseBroadcaster.hpp>
  34 #include <com/sun/star/util/XCloseListener.hpp>
  35 #include <com/sun/star/frame/XFrame.hpp>
  36 #include <com/sun/star/frame/XDesktop.hpp>
  37 #include <com/sun/star/beans/XPropertySet.hpp>
  38 #include <cppuhelper/implbase1.hxx>
  39 #include <comphelper/processfactory.hxx>
  40
  41 #include <math.h>
  42 #include <tools/svwin.h>
  43 #include <tools/stream.hxx>
  44 #include <vos/mutex.hxx>
  45 #include <vos/module.hxx>
  46 #include <vcl/svapp.hxx>
  47 #include <vcl/wrkwin.hxx>
  48 #include <vcl/sysdata.hxx>
  49 #include <vcl/salbtype.hxx>
  50 #include "scanner.hxx"
  51
  52 #pragma warning (push,1)
  53 #pragma warning (disable:4668)
  54 #include "twain/twain.h"
  55 #pragma warning (pop)
  56
  57 using namespace ::com::sun::star;
  58
  59 // -----------
  60 // - Defines -
  61 // -----------
  62
  63 #define TWAIN_SELECT            0x00000001UL
  64 #define TWAIN_ACQUIRE           0x00000002UL
  65 #define TWAIN_TERMINATE         0xFFFFFFFFUL
  66
  67 #define TWAIN_EVENT_NONE        0x00000000UL
  68 #define TWAIN_EVENT_QUIT        0x00000001UL
  69 #define TWAIN_EVENT_SCANNING    0x00000002UL
  70 #define TWAIN_EVENT_XFER        0x00000004UL
  71
  72 #define PFUNC                   (*pDSM)
  73 #define PTWAINMSG               MSG*
  74 #define FIXTODOUBLE( nFix )     ((double)nFix.Whole+(double)nFix.Frac/65536.)
  75 #define FIXTOLONG( nFix )       ((long)floor(FIXTODOUBLE(nFix)+0.5))
  76
  77 #if defined WIN
  78 #define TWAIN_LIBNAME           "TWAIN.DLL"
  79 #define TWAIN_FUNCNAME          "DSM_Entry"
  80 #elif defined WNT
  81 #define TWAIN_LIBNAME           "TWAIN_32.DLL"
  82 #define TWAIN_FUNCNAME          "DSM_Entry"
  83 #endif
  84
  85 // --------------
  86 // - TwainState -
  87 // --------------
  88
  89 enum TwainState
  90 {
  91     TWAIN_STATE_NONE = 0,
  92     TWAIN_STATE_SCANNING = 1,
  93     TWAIN_STATE_DONE = 2,
  94     TWAIN_STATE_CANCELED = 3
  95 };
  96
  97 // ------------
  98 // - ImpTwain -
  99 // ------------
 100
 101 class ImpTwain : public ::cppu::WeakImplHelper1< util::XCloseListener >
 102 {
 103     friend LRESULT CALLBACK TwainMsgProc( int nCode, WPARAM wParam, LPARAM lParam );
 104
 105     uno::Reference< uno::XInterface >           mxSelfRef;
 106     uno::Reference< scanner::XScannerManager >  mxMgr;
 107     ScannerManager&                             mrMgr;
 108     TW_IDENTITY                                 aAppIdent;
 109     TW_IDENTITY                                 aSrcIdent;
 110     Link                                        aNotifyLink;
 111     DSMENTRYPROC                                pDSM;
 112     NAMESPACE_VOS( OModule )*                   pMod;
 113     ULONG                                       nCurState;
 114     HWND                                        hTwainWnd;
 115     HHOOK                                       hTwainHook;
 116     bool                                        mbCloseFrameOnExit;
 117
 118     bool                                        ImplHandleMsg( void* pMsg );
 119     void                                        ImplCreate();
 120     void                                        ImplOpenSourceManager();
 121     void                                        ImplOpenSource();
 122     bool                                        ImplEnableSource();
 123     void                                        ImplXfer();
 124     void                                        ImplFallback( ULONG nEvent );
 125     void                                        ImplSendCloseEvent();
 126     void                                        ImplDeregisterCloseListener();
 127     void                                        ImplRegisterCloseListener();
 128     uno::Reference< frame::XFrame >             ImplGetActiveFrame();
 129     uno::Reference< util::XCloseBroadcaster >   ImplGetActiveFrameCloseBroadcaster();
 130
 131                                                 DECL_LINK( ImplFallbackHdl, void* );
 132                                                 DECL_LINK( ImplDestroyHdl, void* );
 133
 134     // from util::XCloseListener
 135     virtual void SAL_CALL queryClosing( const lang::EventObject& Source, sal_Bool GetsOwnership ) throw (util::CloseVetoException, uno::RuntimeException);
 136     virtual void SAL_CALL notifyClosing( const lang::EventObject& Source ) throw (uno::RuntimeException);
 137
 138     // from lang::XEventListener
 139     virtual void SAL_CALL disposing( const lang::EventObject& Source ) throw (uno::RuntimeException);
 140
 141 public:
 142
 143                                                 ImpTwain( ScannerManager& rMgr, const Link& rNotifyLink );
 144                                                 ~ImpTwain();
 145
 146     void                                        Destroy();
 147
 148     bool                                        SelectSource();
 149     bool                                        InitXfer();
 150 };
 151
 152 // ---------
 153 // - Procs -
 154 // ---------
 155
 156 static ImpTwain* pImpTwainInstance = NULL;
 157
 158 // -------------------------------------------------------------------------
 159
 160 LRESULT CALLBACK TwainWndProc( HWND hWnd,UINT nMsg, WPARAM nPar1, LPARAM nPar2 )
 161 {
 162     return DefWindowProc( hWnd, nMsg, nPar1, nPar2 );
 163 }
 164
 165 // -------------------------------------------------------------------------
 166
 167 LRESULT CALLBACK TwainMsgProc( int nCode, WPARAM wParam, LPARAM lParam )
 168 {
 169     MSG* pMsg = (MSG*) lParam;
 170
 171     if( ( nCode < 0 ) || ( pImpTwainInstance->hTwainWnd != pMsg->hwnd ) || !pImpTwainInstance->ImplHandleMsg( (void*) lParam ) )
 172     {
 173         return CallNextHookEx( pImpTwainInstance->hTwainHook, nCode, wParam, lParam );
 174     }
 175     else
 176     {
 177         pMsg->message = WM_USER;
 178         pMsg->lParam = 0;
 179
 180         return 0;
 181     }
 182 }
 183
 184 // -----------------------------------------------------------------------------
 185
 186 // #107835# hold reference to ScannerManager, to prevent premature death
 187 ImpTwain::ImpTwain( ScannerManager& rMgr, const Link& rNotifyLink ) :
 188             mrMgr( rMgr ),
 189             mxMgr( uno::Reference< scanner::XScannerManager >( static_cast< OWeakObject* >( &rMgr ), uno::UNO_QUERY) ),
 190             aNotifyLink( rNotifyLink ),
 191             pDSM( NULL ),
 192             pMod( NULL ),
 193             hTwainWnd( 0 ),
 194             hTwainHook( 0 ),
 195             nCurState( 1 ),
 196             mbCloseFrameOnExit( false )
 197 {
 198     // setup TWAIN window
 199     pImpTwainInstance = this;
 200
 201     aAppIdent.Id = 0;
 202     aAppIdent.Version.MajorNum = 1;
 203     aAppIdent.Version.MinorNum = 0;
 204     aAppIdent.Version.Language = TWLG_USA;
 205     aAppIdent.Version.Country = TWCY_USA;
 206     aAppIdent.ProtocolMajor = TWON_PROTOCOLMAJOR;
 207     aAppIdent.ProtocolMinor = TWON_PROTOCOLMINOR;
 208     aAppIdent.SupportedGroups = DG_IMAGE | DG_CONTROL;
 209     strncpy( aAppIdent.Version.Info, "8.0", 32 );
 210     aAppIdent.Version.Info[32] = aAppIdent.Version.Info[33] = 0;
 211     strncpy( aAppIdent.Manufacturer, "Sun Microsystems", 32 );
 212     aAppIdent.Manufacturer[32] = aAppIdent.Manufacturer[33] = 0;
 213     strncpy( aAppIdent.ProductFamily,"Office", 32 );
 214     aAppIdent.ProductFamily[32] = aAppIdent.ProductFamily[33] = 0;
 215     strncpy( aAppIdent.ProductName, "Office", 32 );
 216     aAppIdent.ProductName[32] = aAppIdent.ProductName[33] = 0;
 217
 218     WNDCLASS aWc = { 0, &TwainWndProc, 0, sizeof( WNDCLASS ), GetModuleHandle( NULL ), NULL, NULL, NULL, NULL, "TwainClass" };
 219     RegisterClass( &aWc );
 220
 221     hTwainWnd = CreateWindowEx( WS_EX_TOPMOST, aWc.lpszClassName, "TWAIN", 0, 0, 0, 0, 0, HWND_DESKTOP, NULL, aWc.hInstance, 0 );
 222     hTwainHook = SetWindowsHookEx( WH_GETMESSAGE, &TwainMsgProc, NULL, GetCurrentThreadId() );
 223
 224     // #107835# block destruction until ImplDestroyHdl is called
 225     mxSelfRef = static_cast< ::cppu::OWeakObject* >( this );
 226 }
 227
 228 // -----------------------------------------------------------------------------
 229
 230 ImpTwain::~ImpTwain()
 231 {
 232     // are we responsible for application shutdown?
 233     if( mbCloseFrameOnExit )
 234         ImplSendCloseEvent();
 235 }
 236
 237 // -----------------------------------------------------------------------------
 238
 239 void ImpTwain::Destroy()
 240 {
 241     ImplFallback( TWAIN_EVENT_NONE );
 242     Application::PostUserEvent( LINK( this, ImpTwain, ImplDestroyHdl ), NULL );
 243 }
 244
 245 // -----------------------------------------------------------------------------
 246
 247 bool ImpTwain::SelectSource()
 248 {
 249     TW_UINT16 nRet = TWRC_FAILURE;
 250
 251     ImplOpenSourceManager();
 252
 253     if( 3 == nCurState )
 254     {
 255         TW_IDENTITY aIdent;
 256
 257         aIdent.Id = 0, aIdent.ProductName[ 0 ] = '\0';
 258         aNotifyLink.Call( (void*) TWAIN_EVENT_SCANNING );
 259         nRet = PFUNC( &aAppIdent, NULL, DG_CONTROL, DAT_IDENTITY, MSG_USERSELECT, &aIdent );
 260     }
 261
 262     ImplFallback( TWAIN_EVENT_QUIT );
 263
 264     return( TWRC_SUCCESS == nRet );
 265 }
 266
 267 // -----------------------------------------------------------------------------
 268
 269 bool ImpTwain::InitXfer()
 270 {
 271     bool bRet = false;
 272
 273     ImplOpenSourceManager();
 274
 275     if( 3 == nCurState )
 276     {
 277         ImplOpenSource();
 278
 279         if( 4 == nCurState )
 280             bRet = ImplEnableSource();
 281     }
 282
 283     if( !bRet )
 284         ImplFallback( TWAIN_EVENT_QUIT );
 285
 286     return bRet;
 287 }
 288
 289 // -----------------------------------------------------------------------------
 290
 291 void ImpTwain::ImplOpenSourceManager()
 292 {
 293     if( 1 == nCurState )
 294     {
 295         pMod = new ::vos::OModule( ::rtl::OUString() );
 296
 297         if( pMod->load( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( TWAIN_LIBNAME ) ) ) )
 298         {
 299             nCurState = 2;
 300
 301             if( ( ( pDSM = (DSMENTRYPROC) pMod->getSymbol( String( RTL_CONSTASCII_USTRINGPARAM( TWAIN_FUNCNAME ) ) ) ) != NULL ) &&
 302                 ( PFUNC( &aAppIdent, NULL, DG_CONTROL, DAT_PARENT, MSG_OPENDSM, &hTwainWnd ) == TWRC_SUCCESS ) )
 303             {
 304                 nCurState = 3;
 305             }
 306         }
 307         else
 308         {
 309             delete pMod;
 310             pMod = NULL;
 311         }
 312     }
 313 }
 314
 315 // -----------------------------------------------------------------------------
 316
 317 void ImpTwain::ImplOpenSource()
 318 {
 319     if( 3 == nCurState )
 320     {
 321         if( ( PFUNC( &aAppIdent, NULL, DG_CONTROL, DAT_IDENTITY, MSG_GETDEFAULT, &aSrcIdent ) == TWRC_SUCCESS ) &&
 322             ( PFUNC( &aAppIdent, NULL, DG_CONTROL, DAT_IDENTITY, MSG_OPENDS, &aSrcIdent ) == TWRC_SUCCESS ) )
 323         {
 324             TW_CAPABILITY   aCap = { CAP_XFERCOUNT, TWON_ONEVALUE, GlobalAlloc( GHND, sizeof( TW_ONEVALUE ) ) };
 325             TW_ONEVALUE*    pVal = (TW_ONEVALUE*) GlobalLock( aCap.hContainer );
 326
 327             pVal->ItemType = TWTY_INT16, pVal->Item = 1;
 328             GlobalUnlock( aCap.hContainer );
 329             PFUNC( &aAppIdent, &aSrcIdent, DG_CONTROL, DAT_CAPABILITY, MSG_SET, &aCap );
 330             GlobalFree( aCap.hContainer );
 331             nCurState = 4;
 332         }
 333     }
 334 }
 335
 336 // -----------------------------------------------------------------------------
 337
 338 bool ImpTwain::ImplEnableSource()
 339 {
 340     bool bRet = false;
 341
 342     if( 4 == nCurState )
 343     {
 344         TW_USERINTERFACE aUI = { true, true, hTwainWnd };
 345
 346         aNotifyLink.Call( (void*) TWAIN_EVENT_SCANNING );
 347         nCurState = 5;
 348
 349         // #107835# register as vetoable close listener, to prevent application to die under us
 350         ImplRegisterCloseListener();
 351
 352         if( PFUNC( &aAppIdent, &aSrcIdent, DG_CONTROL, DAT_USERINTERFACE, MSG_ENABLEDS, &aUI ) == TWRC_SUCCESS )
 353         {
 354             bRet = true;
 355         }
 356         else
 357         {
 358             nCurState = 4;
 359
 360             // #107835# deregister as vetoable close listener, dialog failed
 361             ImplDeregisterCloseListener();
 362         }
 363     }
 364
 365     return bRet;
 366 }
 367
 368 // -----------------------------------------------------------------------------
 369
 370 bool ImpTwain::ImplHandleMsg( void* pMsg )
 371 {
 372     TW_UINT16   nRet;
 373     PTWAINMSG   pMess = (PTWAINMSG) pMsg;
 374     TW_EVENT    aEvt = { pMess, MSG_NULL };
 375
 376     nRet = PFUNC( &aAppIdent, &aSrcIdent, DG_CONTROL, DAT_EVENT, MSG_PROCESSEVENT, &aEvt );
 377
 378     if( aEvt.TWMessage != MSG_NULL )
 379     {
 380         switch( aEvt.TWMessage )
 381         {
 382             case MSG_XFERREADY:
 383             {
 384                 ULONG nEvent = TWAIN_EVENT_QUIT;
 385
 386                 if( 5 == nCurState )
 387                 {
 388                     nCurState = 6;
 389                     ImplXfer();
 390
 391                     if( mrMgr.GetData() )
 392                         nEvent = TWAIN_EVENT_XFER;
 393                 }
 394
 395                 ImplFallback( nEvent );
 396             }
 397             break;
 398
 399             case MSG_CLOSEDSREQ:
 400                 ImplFallback( TWAIN_EVENT_QUIT );
 401             break;
 402
 403             default:
 404             break;
 405         }
 406     }
 407     else
 408         nRet = TWRC_NOTDSEVENT;
 409
 410     return( TWRC_DSEVENT == nRet );
 411 }
 412
 413 // -----------------------------------------------------------------------------
 414
 415 void ImpTwain::ImplXfer()
 416 {
 417     if( nCurState == 6 )
 418     {
 419         TW_IMAGEINFO    aInfo;
 420         TW_UINT32       hDIB = 0;
 421         long            nWidth, nHeight, nXRes, nYRes;
 422
 423         if( PFUNC( &aAppIdent, &aSrcIdent, DG_IMAGE, DAT_IMAGEINFO, MSG_GET, &aInfo ) == TWRC_SUCCESS )
 424         {
 425             nWidth = aInfo.ImageWidth;
 426             nHeight = aInfo.ImageLength;
 427             nXRes = FIXTOLONG( aInfo.XResolution );
 428             nYRes = FIXTOLONG( aInfo.YResolution );
 429         }
 430         else
 431             nWidth = nHeight = nXRes = nYRes = -1L;
 432
 433         switch( PFUNC( &aAppIdent, &aSrcIdent, DG_IMAGE, DAT_IMAGENATIVEXFER, MSG_GET, &hDIB ) )
 434         {
 435             case( TWRC_CANCEL ):
 436                 nCurState = 7;
 437             break;
 438
 439             case( TWRC_XFERDONE ):
 440             {
 441                 if( hDIB )
 442                 {
 443                     if( ( nXRes != -1 ) && ( nYRes != - 1 ) && ( nWidth != - 1 ) && ( nHeight != - 1 ) )
 444                     {
 445                         // set resolution of bitmap
 446                         BITMAPINFOHEADER*   pBIH = (BITMAPINFOHEADER*) GlobalLock( (HGLOBAL) hDIB );
 447                         static const double fFactor = 100.0 / 2.54;
 448
 449                         pBIH->biXPelsPerMeter = FRound( fFactor * nXRes );
 450                         pBIH->biYPelsPerMeter = FRound( fFactor * nYRes );
 451
 452                         GlobalUnlock( (HGLOBAL) hDIB );
 453                     }
 454
 455                     mrMgr.SetData( (void*)(long) hDIB );
 456                 }
 457                 else
 458                     GlobalFree( (HGLOBAL) hDIB );
 459
 460                 nCurState = 7;
 461             }
 462             break;
 463
 464             default:
 465             break;
 466         }
 467     }
 468 }
 469
 470 // -----------------------------------------------------------------------------
 471
 472 void ImpTwain::ImplFallback( ULONG nEvent )
 473 {
 474     Application::PostUserEvent( LINK( this, ImpTwain, ImplFallbackHdl ), (void*) nEvent );
 475 }
 476
 477 // -----------------------------------------------------------------------------
 478
 479 IMPL_LINK( ImpTwain, ImplFallbackHdl, void*, pData )
 480 {
 481     const ULONG nEvent = (ULONG) pData;
 482     bool        bFallback = true;
 483
 484     switch( nCurState )
 485     {
 486         case( 7 ):
 487         case( 6 ):
 488         {
 489             TW_PENDINGXFERS aXfers;
 490
 491             if( PFUNC( &aAppIdent, &aSrcIdent, DG_CONTROL, DAT_PENDINGXFERS, MSG_ENDXFER, &aXfers ) == TWRC_SUCCESS )
 492             {
 493                 if( aXfers.Count != 0 )
 494                     PFUNC( &aAppIdent, &aSrcIdent, DG_CONTROL, DAT_PENDINGXFERS, MSG_RESET, &aXfers );
 495             }
 496
 497             nCurState = 5;
 498         }
 499         break;
 500
 501         case( 5 ):
 502         {
 503             TW_USERINTERFACE aUI = { true, true, hTwainWnd };
 504
 505             PFUNC( &aAppIdent, &aSrcIdent, DG_CONTROL, DAT_USERINTERFACE, MSG_DISABLEDS, &aUI );
 506             nCurState = 4;
 507
 508             // #107835# deregister as vetoable close listener
 509             ImplDeregisterCloseListener();
 510         }
 511         break;
 512
 513         case( 4 ):
 514         {
 515             PFUNC( &aAppIdent, NULL, DG_CONTROL, DAT_IDENTITY, MSG_CLOSEDS, &aSrcIdent );
 516             nCurState = 3;
 517         }
 518         break;
 519
 520         case( 3 ):
 521         {
 522             PFUNC( &aAppIdent, NULL, DG_CONTROL, DAT_PARENT, MSG_CLOSEDSM, &hTwainWnd );
 523             nCurState = 2;
 524         }
 525         break;
 526
 527         case( 2 ):
 528         {
 529             delete pMod;
 530             pMod = NULL;
 531             nCurState = 1;
 532         }
 533         break;
 534
 535         default:
 536         {
 537             if( nEvent != TWAIN_EVENT_NONE )
 538                 aNotifyLink.Call( (void*) nEvent );
 539
 540             bFallback = false;
 541         }
 542         break;
 543     }
 544
 545     if( bFallback )
 546         ImplFallback( nEvent );
 547
 548     return 0L;
 549 }
 550
 551 // -----------------------------------------------------------------------------
 552
 553 IMPL_LINK( ImpTwain, ImplDestroyHdl, void*, /*p*/ )
 554 {
 555     if( hTwainWnd )
 556         DestroyWindow( hTwainWnd );
 557
 558     if( hTwainHook )
 559         UnhookWindowsHookEx( hTwainHook );
 560
 561     // #107835# permit destruction of ourselves (normally, refcount
 562     // should drop to zero exactly here)
 563     mxSelfRef = NULL;
 564     pImpTwainInstance = NULL;
 565
 566     return 0L;
 567 }
 568
 569 // -----------------------------------------------------------------------------
 570
 571 uno::Reference< frame::XFrame > ImpTwain::ImplGetActiveFrame()
 572 {
 573     try
 574     {
 575         uno::Reference< lang::XMultiServiceFactory >  xMgr( ::comphelper::getProcessServiceFactory() );
 576
 577         if( xMgr.is() )
 578         {
 579             // query desktop instance
 580             uno::Reference< frame::XDesktop > xDesktop( xMgr->createInstance(
 581                                                             OUString::createFromAscii( "com.sun.star.frame.Desktop" ) ), uno::UNO_QUERY );
 582
 583             if( xDesktop.is() )
 584             {
 585                 // query property set from desktop, which contains the currently active frame
 586                 uno::Reference< beans::XPropertySet > xDesktopProps( xDesktop, uno::UNO_QUERY );
 587
 588                 if( xDesktopProps.is() )
 589                 {
 590                     uno::Any aActiveFrame;
 591
 592                     try
 593                     {
 594                         aActiveFrame = xDesktopProps->getPropertyValue(
 595                             OUString::createFromAscii( "ActiveFrame" ) );
 596                     }
 597                     catch( const beans::UnknownPropertyException& )
 598                     {
 599                         // property unknown.
 600                         DBG_ERROR("ImpTwain::ImplGetActiveFrame: ActiveFrame property unknown, cannot determine active frame!");
 601                         return uno::Reference< frame::XFrame >();
 602                     }
 603
 604                     uno::Reference< frame::XFrame > xActiveFrame;
 605
 606                     if( (aActiveFrame >>= xActiveFrame) &&
 607                         xActiveFrame.is() )
 608                     {
 609                         return xActiveFrame;
 610                     }
 611                 }
 612             }
 613         }
 614     }
 615     catch( const uno::Exception& )
 616     {
 617     }
 618
 619     DBG_ERROR("ImpTwain::ImplGetActiveFrame: Could not determine active frame!");
 620     return uno::Reference< frame::XFrame >();
 621 }
 622
 623 // -----------------------------------------------------------------------------
 624
 625 uno::Reference< util::XCloseBroadcaster > ImpTwain::ImplGetActiveFrameCloseBroadcaster()
 626 {
 627     try
 628     {
 629         return uno::Reference< util::XCloseBroadcaster >( ImplGetActiveFrame(), uno::UNO_QUERY );
 630     }
 631     catch( const uno::Exception& )
 632     {
 633     }
 634
 635     DBG_ERROR("ImpTwain::ImplGetActiveFrameCloseBroadcaster: Could determine close broadcaster on active frame!");
 636     return uno::Reference< util::XCloseBroadcaster >();
 637 }
 638
 639 // -----------------------------------------------------------------------------
 640
 641 void ImpTwain::ImplRegisterCloseListener()
 642 {
 643     try
 644     {
 645         uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster( ImplGetActiveFrameCloseBroadcaster() );
 646
 647         if( xCloseBroadcaster.is() )
 648         {
 649             xCloseBroadcaster->addCloseListener(this);
 650             return; // successfully registered as a close listener
 651         }
 652         else
 653         {
 654             // interface unknown. don't register, then
 655             DBG_ERROR("ImpTwain::ImplRegisterCloseListener: XFrame has no XCloseBroadcaster!");
 656             return;
 657         }
 658     }
 659     catch( const uno::Exception& )
 660     {
 661     }
 662
 663     DBG_ERROR("ImpTwain::ImplRegisterCloseListener: Could not register as close listener!");
 664 }
 665
 666 // -----------------------------------------------------------------------------
 667
 668 void ImpTwain::ImplDeregisterCloseListener()
 669 {
 670     try
 671     {
 672         uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster(
 673             ImplGetActiveFrameCloseBroadcaster() );
 674
 675         if( xCloseBroadcaster.is() )
 676         {
 677             xCloseBroadcaster->removeCloseListener(this);
 678             return; // successfully deregistered as a close listener
 679         }
 680         else
 681         {
 682             // interface unknown. don't deregister, then
 683             DBG_ERROR("ImpTwain::ImplDeregisterCloseListener: XFrame has no XCloseBroadcaster!");
 684             return;
 685         }
 686     }
 687     catch( const uno::Exception& )
 688     {
 689     }
 690
 691     DBG_ERROR("ImpTwain::ImplDeregisterCloseListener: Could not deregister as close listener!");
 692 }
 693
 694 // -----------------------------------------------------------------------------
 695
 696 void SAL_CALL ImpTwain::queryClosing( const lang::EventObject& /*Source*/, sal_Bool GetsOwnership ) throw (util::CloseVetoException, uno::RuntimeException)
 697 {
 698     // shall we re-send the close query later on?
 699     mbCloseFrameOnExit = GetsOwnership;
 700
 701     // the sole purpose of this listener is to forbid closing of the listened-at frame
 702     throw util::CloseVetoException();
 703 }
 704
 705 // -----------------------------------------------------------------------------
 706
 707 void SAL_CALL ImpTwain::notifyClosing( const lang::EventObject& /*Source*/ ) throw (uno::RuntimeException)
 708 {
 709     // should not happen
 710     DBG_ERROR("ImpTwain::notifyClosing called, but we vetoed the closing before!");
 711 }
 712
 713 // -----------------------------------------------------------------------------
 714
 715 void SAL_CALL ImpTwain::disposing( const lang::EventObject& /*Source*/ ) throw (uno::RuntimeException)
 716 {
 717     // we're not holding any references to the frame, thus noop
 718 }
 719
 720 // -----------------------------------------------------------------------------
 721
 722 void ImpTwain::ImplSendCloseEvent()
 723 {
 724     try
 725     {
 726         uno::Reference< util::XCloseable > xCloseable( ImplGetActiveFrame(), uno::UNO_QUERY );
 727
 728         if( xCloseable.is() )
 729             xCloseable->close( true );
 730     }
 731     catch( const uno::Exception& )
 732     {
 733     }
 734
 735     DBG_ERROR("ImpTwain::ImplSendCloseEvent: Could not send required close broadcast!");
 736 }
 737
 738
 739 // ---------
 740 // - Twain -
 741 // ---------
 742
 743 class Twain
 744 {
 745     uno::Reference< lang::XEventListener >      mxListener;
 746     uno::Reference< scanner::XScannerManager >  mxMgr;
 747     const ScannerManager*                       mpCurMgr;
 748     ImpTwain*                                   mpImpTwain;
 749     TwainState                                  meState;
 750
 751                                                 DECL_LINK( ImpNotifyHdl, ImpTwain* );
 752
 753 public:
 754
 755                                     Twain();
 756                                     ~Twain();
 757
 758     bool                            SelectSource( ScannerManager& rMgr );
 759     bool                            PerformTransfer( ScannerManager& rMgr, const uno::Reference< lang::XEventListener >& rxListener );
 760
 761     TwainState                      GetState() const { return meState; }
 762 };
 763
 764 // ------------------------------------------------------------------------
 765
 766 Twain::Twain() :
 767         mpCurMgr( NULL ),
 768         mpImpTwain( NULL ),
 769         meState( TWAIN_STATE_NONE )
 770 {
 771 }
 772
 773 // ------------------------------------------------------------------------
 774
 775 Twain::~Twain()
 776 {
 777     if( mpImpTwain )
 778         mpImpTwain->Destroy();
 779 }
 780
 781 // ------------------------------------------------------------------------
 782
 783 bool Twain::SelectSource( ScannerManager& rMgr )
 784 {
 785     bool bRet;
 786
 787     if( !mpImpTwain )
 788     {
 789         // #107835# hold reference to ScannerManager, to prevent premature death
 790         mxMgr = uno::Reference< scanner::XScannerManager >( static_cast< OWeakObject* >( const_cast< ScannerManager* >( mpCurMgr = &rMgr ) ),
 791                                                             uno::UNO_QUERY ),
 792
 793         meState = TWAIN_STATE_NONE;
 794         mpImpTwain = new ImpTwain( rMgr, LINK( this, Twain, ImpNotifyHdl ) );
 795         bRet = mpImpTwain->SelectSource();
 796     }
 797     else
 798         bRet = false;
 799
 800     return bRet;
 801 }
 802
 803 // ------------------------------------------------------------------------
 804
 805 bool Twain::PerformTransfer( ScannerManager& rMgr, const uno::Reference< lang::XEventListener >& rxListener )
 806 {
 807     bool bRet;
 808
 809     if( !mpImpTwain )
 810     {
 811         // #107835# hold reference to ScannerManager, to prevent premature death
 812         mxMgr = uno::Reference< scanner::XScannerManager >( static_cast< OWeakObject* >( const_cast< ScannerManager* >( mpCurMgr = &rMgr ) ),
 813                                                             uno::UNO_QUERY ),
 814
 815         mxListener = rxListener;
 816         meState = TWAIN_STATE_NONE;
 817         mpImpTwain = new ImpTwain( rMgr, LINK( this, Twain, ImpNotifyHdl ) );
 818         bRet = mpImpTwain->InitXfer();
 819     }
 820     else
 821         bRet = false;
 822
 823     return bRet;
 824 }
 825
 826 // ------------------------------------------------------------------------
 827
 828 IMPL_LINK( Twain, ImpNotifyHdl, ImpTwain*, nEvent )
 829 {
 830     switch( (ULONG)(void*) nEvent )
 831     {
 832         case( TWAIN_EVENT_SCANNING ):
 833             meState = TWAIN_STATE_SCANNING;
 834         break;
 835
 836         case( TWAIN_EVENT_QUIT ):
 837         {
 838             if( meState != TWAIN_STATE_DONE )
 839                 meState = TWAIN_STATE_CANCELED;
 840
 841             if( mpImpTwain )
 842             {
 843                 mpImpTwain->Destroy();
 844                 mpImpTwain = NULL;
 845                 mpCurMgr = NULL;
 846             }
 847
 848             if( mxListener.is() )
 849                 mxListener->disposing( lang::EventObject( mxMgr ) );
 850
 851             mxListener = NULL;
 852         }
 853         break;
 854
 855         case( TWAIN_EVENT_XFER ):
 856         {
 857             if( mpImpTwain )
 858             {
 859                 meState = ( mpCurMgr->GetData() ? TWAIN_STATE_DONE : TWAIN_STATE_CANCELED );
 860
 861                 mpImpTwain->Destroy();
 862                 mpImpTwain = NULL;
 863                 mpCurMgr = NULL;
 864
 865                 if( mxListener.is() )
 866                     mxListener->disposing( lang::EventObject( mxMgr ) );
 867             }
 868
 869             mxListener = NULL;
 870         }
 871         break;
 872
 873         default:
 874         break;
 875     }
 876
 877     return 0L;
 878 }
 879
 880 // -----------
 881 // - statics -
 882 // -----------
 883
 884 static Twain aTwain;
 885
 886 // ------------------
 887 // - ScannerManager -
 888 // ------------------
 889
 890 void ScannerManager::DestroyData()
 891 {
 892     if( mpData )
 893     {
 894         GlobalFree( (HGLOBAL)(long) mpData );
 895         mpData = NULL;
 896     }
 897 }
 898
 899 // -----------------------------------------------------------------------------
 900
 901 AWT::Size ScannerManager::getSize() throw()
 902 {
 903     AWT::Size   aRet;
 904     HGLOBAL     hDIB = (HGLOBAL)(long) mpData;
 905
 906     if( hDIB )
 907     {
 908         BITMAPINFOHEADER* pBIH = (BITMAPINFOHEADER*) GlobalLock( hDIB );
 909
 910         if( pBIH )
 911         {
 912             aRet.Width = pBIH->biWidth;
 913             aRet.Height = pBIH->biHeight;
 914         }
 915         else
 916             aRet.Width = aRet.Height = 0;
 917
 918         GlobalUnlock( hDIB );
 919     }
 920     else
 921         aRet.Width = aRet.Height = 0;
 922
 923     return aRet;
 924 }
 925
 926 // -----------------------------------------------------------------------------
 927
 928 SEQ( sal_Int8 ) ScannerManager::getDIB() throw()
 929 {
 930     SEQ( sal_Int8 ) aRet;
 931
 932     if( mpData )
 933     {
 934         HGLOBAL             hDIB = (HGLOBAL)(long) mpData;
 935         const sal_uInt32    nDIBSize = GlobalSize( hDIB );
 936         BITMAPINFOHEADER*   pBIH = (BITMAPINFOHEADER*) GlobalLock( hDIB );
 937
 938         if( pBIH )
 939         {
 940             sal_uInt32  nColEntries;
 941
 942             switch( pBIH->biBitCount )
 943             {
 944                 case( 1 ):
 945                 case( 4 ):
 946                 case( 8 ):
 947                     nColEntries = pBIH->biClrUsed ? pBIH->biClrUsed : ( 1 << pBIH->biBitCount );
 948                 break;
 949
 950                 case( 24 ):
 951                     nColEntries = pBIH->biClrUsed ? pBIH->biClrUsed : 0;
 952                 break;
 953
 954                 case( 16 ):
 955                 case( 32 ):
 956                 {
 957                     nColEntries = pBIH->biClrUsed;
 958
 959                     if( pBIH->biCompression == BI_BITFIELDS )
 960                         nColEntries += 3;
 961                 }
 962                 break;
 963
 964                 default:
 965                     nColEntries = 0;
 966                 break;
 967             }
 968
 969             aRet = SEQ( sal_Int8 )( sizeof( BITMAPFILEHEADER ) + nDIBSize );
 970
 971             sal_Int8*       pBuf = aRet.getArray();
 972             SvMemoryStream* pMemStm = new SvMemoryStream( (char*) pBuf, sizeof( BITMAPFILEHEADER ), STREAM_WRITE );
 973
 974             *pMemStm << 'B' << 'M' << (sal_uInt32) 0 << (sal_uInt32) 0;
 975             *pMemStm << (sal_uInt32) ( sizeof( BITMAPFILEHEADER ) + pBIH->biSize + ( nColEntries * sizeof( RGBQUAD ) ) );
 976
 977             delete pMemStm;
 978             memcpy( pBuf + sizeof( BITMAPFILEHEADER ), pBIH, nDIBSize );
 979         }
 980
 981         GlobalUnlock( hDIB );
 982         DestroyData();
 983     }
 984
 985     return aRet;
 986 }
 987
 988 // -----------------------------------------------------------------------------
 989
 990 SEQ( ScannerContext ) SAL_CALL ScannerManager::getAvailableScanners() throw()
 991 {
 992     vos::OGuard             aGuard( maProtector );
 993     SEQ( ScannerContext )   aRet( 1 );
 994
 995     aRet.getArray()[0].ScannerName = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "TWAIN" ) );
 996     aRet.getArray()[0].InternalData = 0;
 997
 998     return aRet;
 999 }
1000
1001 // -----------------------------------------------------------------------------
1002
1003 BOOL SAL_CALL ScannerManager::configureScanner( ScannerContext& rContext )
1004     throw( ScannerException )
1005 {
1006     vos::OGuard                         aGuard( maProtector );
1007     uno::Reference< XScannerManager >   xThis( this );
1008
1009     if( rContext.InternalData != 0 || rContext.ScannerName != ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "TWAIN" ) ) )
1010         throw ScannerException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Scanner does not exist" ) ), xThis, ScanError_InvalidContext );
1011
1012     DestroyData();
1013
1014     return aTwain.SelectSource( *this );
1015 }
1016
1017 // -----------------------------------------------------------------------------
1018
1019 void SAL_CALL ScannerManager::startScan( const ScannerContext& rContext, const uno::Reference< lang::XEventListener >& rxListener )
1020     throw( ScannerException )
1021 {
1022     vos::OGuard                         aGuard( maProtector );
1023     uno::Reference< XScannerManager >   xThis( this );
1024
1025     if( rContext.InternalData != 0 || rContext.ScannerName != ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "TWAIN" ) ) )
1026         throw ScannerException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Scanner does not exist" ) ), xThis, ScanError_InvalidContext );
1027
1028     DestroyData();
1029     aTwain.PerformTransfer( *this, rxListener );
1030 }
1031
1032 // -----------------------------------------------------------------------------
1033
1034 ScanError SAL_CALL ScannerManager::getError( const ScannerContext& rContext )
1035     throw( ScannerException )
1036 {
1037     vos::OGuard                         aGuard( maProtector );
1038     uno::Reference< XScannerManager >   xThis( this );
1039
1040     if( rContext.InternalData != 0 || rContext.ScannerName != ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "TWAIN" ) ) )
1041         throw ScannerException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Scanner does not exist" ) ), xThis, ScanError_InvalidContext );
1042
1043     return( ( aTwain.GetState() == TWAIN_STATE_CANCELED ) ? ScanError_ScanCanceled : ScanError_ScanErrorNone );
1044 }
1045
1046 // -----------------------------------------------------------------------------
1047
1048 uno::Reference< awt::XBitmap > SAL_CALL ScannerManager::getBitmap( const ScannerContext& /*rContext*/ )
1049     throw( ScannerException )
1050 {
1051     vos::OGuard aGuard( maProtector );
1052     return uno::Reference< awt::XBitmap >( this );
1053 }