fpicker/source/win32/filepicker/FilePicker.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 <tchar.h>
  21 #include <com/sun/star/lang/DisposedException.hpp>
  22 #include <cppuhelper/interfacecontainer.h>
  23 #include <osl/diagnose.h>
  24
  25 #include "FilePicker.hxx"
  26 #include "WinFileOpenImpl.hxx"
  27
  28 #include "FPServiceInfo.hxx"
  29 #include "../misc/WinImplHelper.hxx"
  30 #include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
  31 #include "filepickereventnotification.hxx"
  32
  33 #include <comphelper/sequenceasvector.hxx>
  34
  35 //------------------------------------------------------------------------
  36 // namespace directives
  37 //------------------------------------------------------------------------
  38
  39 using namespace com::sun::star;
  40
  41 using namespace ::com::sun::star::ui::dialogs;
  42 using namespace ::com::sun::star::ui::dialogs::TemplateDescription;
  43
  44 #define FILE_PICKER_DLL_NAME  TEXT("fps.dll")
  45
  46 //------------------------------------------------------------------------
  47 // helper functions
  48 //------------------------------------------------------------------------
  49
  50 namespace
  51 {
  52     // controling event notifications
  53     const bool STARTUP_SUSPENDED = true;
  54     const bool STARTUP_ALIVE     = false;
  55
  56     uno::Sequence<OUString> SAL_CALL FilePicker_getSupportedServiceNames()
  57     {
  58         uno::Sequence<OUString> aRet(2);
  59         aRet[0] = OUString("com.sun.star.ui.dialogs.FilePicker");
  60         aRet[1] = OUString("com.sun.star.ui.dialogs.SystemFilePicker");
  61         return aRet;
  62     }
  63 }
  64
  65 //-----------------------------------------------------------------------------------------
  66 //
  67 //-----------------------------------------------------------------------------------------
  68
  69 CFilePicker::CFilePicker( const uno::Reference<lang::XMultiServiceFactory>& xServiceMgr) :
  70     CFilePicker_Base(m_rbHelperMtx),
  71     m_xServiceMgr(xServiceMgr),
  72     m_aAsyncEventNotifier(rBHelper)
  73 {
  74     HINSTANCE hInstance = GetModuleHandle(FILE_PICKER_DLL_NAME);
  75     OSL_POSTCOND( hInstance, "The name of the service dll must have changed" );
  76
  77     // create a default FileOpen dialog without any additional ui elements
  78     m_pImpl = std::auto_ptr< CWinFileOpenImpl >(
  79         new CWinFileOpenImpl(
  80             this,
  81             true,
  82             0,
  83             0,
  84             hInstance ) );
  85 }
  86
  87 //------------------------------------------------------------------------------------
  88 // XFPEventListenerManager
  89 //------------------------------------------------------------------------------------
  90
  91 void SAL_CALL CFilePicker::addFilePickerListener(const uno::Reference<XFilePickerListener>& xListener)
  92     throw(uno::RuntimeException)
  93 {
  94     if ( rBHelper.bDisposed )
  95         throw lang::DisposedException(
  96             OUString( "object is already disposed" ),
  97             static_cast< XFilePicker2* >( this ) );
  98
  99     if ( !rBHelper.bInDispose && !rBHelper.bDisposed )
 100         rBHelper.aLC.addInterface( getCppuType( &xListener ), xListener );
 101 }
 102
 103 //-----------------------------------------------------------------------------------------
 104 //
 105 //-----------------------------------------------------------------------------------------
 106
 107 void SAL_CALL CFilePicker::removeFilePickerListener(const uno::Reference<XFilePickerListener>& xListener )
 108     throw(uno::RuntimeException)
 109 {
 110     if ( rBHelper.bDisposed )
 111         throw lang::DisposedException(
 112             OUString( "object is already disposed" ),
 113             static_cast< XFilePicker2* >( this ) );
 114
 115     rBHelper.aLC.removeInterface( getCppuType( &xListener ), xListener );
 116 }
 117
 118 // -------------------------------------------------
 119 // XEventListener
 120 // -------------------------------------------------
 121
 122 void SAL_CALL CFilePicker::disposing(const lang::EventObject& aEvent) throw(uno::RuntimeException)
 123 {
 124     uno::Reference<XFilePickerListener> xFilePickerListener(aEvent.Source, ::com::sun::star::uno::UNO_QUERY);
 125
 126     if (xFilePickerListener.is())
 127         removeFilePickerListener(xFilePickerListener);
 128 }
 129
 130 //-----------------------------------------------------------------------------------------
 131 //
 132 //-----------------------------------------------------------------------------------------
 133
 134 void SAL_CALL CFilePicker::fileSelectionChanged(FilePickerEvent aEvent)
 135 {
 136     aEvent.Source = uno::Reference<uno::XInterface>(static_cast<XFilePickerNotifier*>(this));
 137     m_aAsyncEventNotifier.notifyEvent(
 138         new CFilePickerParamEventNotification(&XFilePickerListener::fileSelectionChanged,aEvent));
 139 }
 140
 141 //-----------------------------------------------------------------------------------------
 142 //
 143 //-----------------------------------------------------------------------------------------
 144
 145 void SAL_CALL CFilePicker::directoryChanged(FilePickerEvent aEvent)
 146 {
 147     aEvent.Source = uno::Reference<uno::XInterface>(static_cast<XFilePickerNotifier*>(this));
 148     m_aAsyncEventNotifier.notifyEvent(
 149         new CFilePickerParamEventNotification(&XFilePickerListener::directoryChanged,aEvent));
 150 }
 151
 152 //-----------------------------------------------------------------------------------------
 153 //
 154 //-----------------------------------------------------------------------------------------
 155
 156 void SAL_CALL CFilePicker::controlStateChanged(FilePickerEvent aEvent)
 157 {
 158     aEvent.Source = uno::Reference<uno::XInterface>(static_cast<XFilePickerNotifier*>(this));
 159     m_aAsyncEventNotifier.notifyEvent(
 160         new CFilePickerParamEventNotification(&XFilePickerListener::controlStateChanged,aEvent));
 161 }
 162
 163 //-----------------------------------------------------------------------------------------
 164 //
 165 //-----------------------------------------------------------------------------------------
 166
 167 void SAL_CALL CFilePicker::dialogSizeChanged()
 168 {
 169     m_aAsyncEventNotifier.notifyEvent(
 170         new CFilePickerEventNotification(&XFilePickerListener::dialogSizeChanged));
 171 }
 172
 173 //-----------------------------------------------------------------------------------------
 174 // If there are more then one listener the return value of the last one wins
 175 //-----------------------------------------------------------------------------------------
 176
 177 OUString SAL_CALL CFilePicker::helpRequested(FilePickerEvent aEvent) const
 178 {
 179     OUString aHelpText;
 180
 181     ::cppu::OInterfaceContainerHelper* pICHelper =
 182         rBHelper.getContainer( getCppuType((uno::Reference<XFilePickerListener>*)0));
 183
 184     if (pICHelper)
 185     {
 186         ::cppu::OInterfaceIteratorHelper iter(*pICHelper);
 187
 188         while(iter.hasMoreElements())
 189         {
 190             try
 191             {
 192                 /*
 193                   if there are multiple listeners responding
 194                   to this notification the next response
 195                   overwrittes  the one before if it is not empty
 196                 */
 197
 198                 OUString temp;
 199
 200                 uno::Reference<XFilePickerListener> xFPListener(iter.next(), uno::UNO_QUERY);
 201                 if (xFPListener.is())
 202                 {
 203                     temp = xFPListener->helpRequested(aEvent);
 204                     if (temp.getLength())
 205                         aHelpText = temp;
 206                 }
 207
 208             }
 209             catch(uno::RuntimeException&)
 210             {
 211                 OSL_FAIL( "RuntimeException during event dispatching" );
 212             }
 213         }
 214     }
 215
 216     return aHelpText;
 217 }
 218
 219 //-------------------------------------
 220 //
 221 //-------------------------------------
 222
 223 bool CFilePicker::startupEventNotification(bool bStartupSuspended)
 224 {
 225     return m_aAsyncEventNotifier.startup(bStartupSuspended);
 226 }
 227
 228 //-------------------------------------
 229 //
 230 //-------------------------------------
 231
 232 void CFilePicker::shutdownEventNotification()
 233 {
 234     m_aAsyncEventNotifier.shutdown();
 235 }
 236
 237 //-------------------------------------
 238 //
 239 //-------------------------------------
 240
 241 void CFilePicker::suspendEventNotification()
 242 {
 243     m_aAsyncEventNotifier.suspend();
 244 }
 245
 246 //-------------------------------------
 247 //
 248 //-------------------------------------
 249
 250 void CFilePicker::resumeEventNotification()
 251 {
 252     m_aAsyncEventNotifier.resume();
 253 }
 254
 255 //------------------------------------------------------------------------------------
 256 // XFilePicker functions
 257 //------------------------------------------------------------------------------------
 258
 259 void SAL_CALL CFilePicker::setMultiSelectionMode(sal_Bool bMode) throw(uno::RuntimeException)
 260 {
 261     OSL_ASSERT(0 != m_pImpl.get());
 262     osl::MutexGuard aGuard(m_aMutex);
 263     m_pImpl->setMultiSelectionMode(bMode);
 264 }
 265
 266 //-----------------------------------------------------------------------------------------
 267 //
 268 //-----------------------------------------------------------------------------------------
 269
 270 void SAL_CALL CFilePicker::setTitle(const OUString& aTitle) throw(uno::RuntimeException)
 271 {
 272     OSL_ASSERT(0 != m_pImpl.get());
 273     osl::MutexGuard aGuard(m_aMutex);
 274     m_pImpl->setTitle(aTitle);
 275 }
 276
 277 //-----------------------------------------------------------------------------------------
 278 //
 279 //-----------------------------------------------------------------------------------------
 280
 281 void SAL_CALL CFilePicker::appendFilter(const OUString& aTitle, const OUString& aFilter)
 282     throw(lang::IllegalArgumentException, uno::RuntimeException)
 283 {
 284     OSL_ASSERT(0 != m_pImpl.get());
 285     osl::MutexGuard aGuard(m_aMutex);
 286     m_pImpl->appendFilter(aTitle, aFilter);
 287 }
 288
 289 //-----------------------------------------------------------------------------------------
 290 //
 291 //-----------------------------------------------------------------------------------------
 292
 293 void SAL_CALL CFilePicker::setCurrentFilter(const OUString& aTitle)
 294     throw(lang::IllegalArgumentException, uno::RuntimeException)
 295 {
 296     OSL_ASSERT(0 != m_pImpl.get());
 297     osl::MutexGuard aGuard(m_aMutex);
 298     m_pImpl->setCurrentFilter(aTitle);
 299 }
 300
 301 //-----------------------------------------------------------------------------------------
 302 //
 303 //-----------------------------------------------------------------------------------------
 304
 305 OUString SAL_CALL CFilePicker::getCurrentFilter() throw(uno::RuntimeException)
 306 {
 307     OSL_ASSERT(0 != m_pImpl.get());
 308     osl::MutexGuard aGuard(m_aMutex);
 309     return m_pImpl->getCurrentFilter();
 310 }
 311
 312 //-----------------------------------------------------------------------------------------
 313 //
 314 //-----------------------------------------------------------------------------------------
 315
 316 void SAL_CALL CFilePicker::appendFilterGroup(const OUString& sGroupTitle, const uno::Sequence<beans::StringPair>& aFilters)
 317     throw (lang::IllegalArgumentException, uno::RuntimeException)
 318 {
 319     OSL_ASSERT(0 != m_pImpl.get());
 320     osl::MutexGuard aGuard(m_aMutex);
 321     m_pImpl->appendFilterGroup(sGroupTitle, aFilters);
 322 }
 323
 324 //-----------------------------------------------------------------------------------------
 325 //
 326 //-----------------------------------------------------------------------------------------
 327
 328 void SAL_CALL CFilePicker::setDefaultName(const OUString& aName)
 329     throw(uno::RuntimeException)
 330 {
 331     OSL_ASSERT(0 != m_pImpl.get());
 332     osl::MutexGuard aGuard(m_aMutex);
 333     m_pImpl->setDefaultName(aName);
 334 }
 335
 336 //-----------------------------------------------------------------------------------------
 337 //
 338 //-----------------------------------------------------------------------------------------
 339
 340 void SAL_CALL CFilePicker::setDisplayDirectory(const OUString& aDirectory)
 341     throw(lang::IllegalArgumentException, uno::RuntimeException)
 342 {
 343     OSL_ASSERT(0 != m_pImpl.get());
 344     osl::MutexGuard aGuard(m_aMutex);
 345     m_pImpl->setDisplayDirectory(aDirectory);
 346 }
 347
 348 //-----------------------------------------------------------------------------------------
 349 //
 350 //-----------------------------------------------------------------------------------------
 351
 352 OUString SAL_CALL CFilePicker::getDisplayDirectory() throw(uno::RuntimeException)
 353 {
 354     OSL_ASSERT(0 != m_pImpl.get());
 355     osl::MutexGuard aGuard(m_aMutex);
 356     return m_pImpl->getDisplayDirectory();
 357 }
 358
 359 //-----------------------------------------------------------------------------------------
 360 //
 361 //-----------------------------------------------------------------------------------------
 362
 363 uno::Sequence<OUString> SAL_CALL CFilePicker::getFiles() throw(uno::RuntimeException)
 364 {
 365     OSL_ASSERT(0 != m_pImpl.get());
 366     osl::MutexGuard aGuard(m_aMutex);
 367     return m_pImpl->getFiles();
 368 }
 369
 370 //-----------------------------------------------------------------------------------------
 371 //
 372 //-----------------------------------------------------------------------------------------
 373 uno::Sequence< OUString > SAL_CALL CFilePicker::getSelectedFiles() throw (uno::RuntimeException)
 374 {
 375     OSL_ASSERT(0 != m_pImpl.get());
 376     osl::MutexGuard aGuard(m_aMutex);
 377
 378     const uno::Sequence< OUString > lSource = m_pImpl->getFiles();
 379     const ::sal_Int32                      c       = lSource.getLength();
 380     if (c < 2)
 381         return lSource;
 382
 383     const OUString                                   sPath  = lSource[0];
 384           ::comphelper::SequenceAsVector< OUString > lTarget;
 385           ::sal_Int32                                       i      = 1;
 386     for (i=1; i<c; ++i)
 387     {
 388         const OUString sFile = lSource[i];
 389         if (sFile.indexOf ('/') > 0)
 390         {
 391             // a) file contains own path !
 392             lTarget.push_back(sFile);
 393         }
 394         else
 395         {
 396             // b) file is relative to given path
 397             OUStringBuffer sFull(256);
 398
 399             sFull.append     (sPath);
 400             sFull.appendAscii("/"  );
 401             sFull.append     (sFile);
 402
 403             lTarget.push_back(sFull.makeStringAndClear());
 404         }
 405     }
 406
 407     return lTarget.getAsConstList();
 408 }
 409
 410 //-----------------------------------------------------------------------------------------
 411 //
 412 //-----------------------------------------------------------------------------------------
 413
 414 sal_Int16 SAL_CALL CFilePicker::execute() throw(uno::RuntimeException)
 415 {
 416     OSL_ASSERT(0 != m_pImpl.get());
 417
 418     sal_Int16 ret;
 419
 420     if (startupEventNotification(STARTUP_SUSPENDED))
 421     {
 422         // we should not block in this call else
 423         // in the case of an event the client can't
 424         // call another function an we run into a
 425         // deadlock !!!!!
 426         ret = m_pImpl->execute( );
 427
 428         shutdownEventNotification();
 429     }
 430     else
 431     {
 432         OSL_FAIL("Could not start event notifier thread!");
 433
 434         throw uno::RuntimeException(
 435             OUString("Error executing dialog"),
 436             static_cast<XFilePicker2*>(this));
 437     }
 438
 439     return ret;
 440 }
 441
 442 //------------------------------------------------------------------------------------
 443 // XFilePicker functions
 444 //------------------------------------------------------------------------------------
 445
 446 void SAL_CALL CFilePicker::setValue(sal_Int16 aControlId, sal_Int16 aControlAction, const uno::Any& aValue)
 447     throw(uno::RuntimeException)
 448 {
 449     OSL_ASSERT(0 != m_pImpl.get());
 450
 451     osl::MutexGuard aGuard(m_aMutex);
 452     m_pImpl->setValue(aControlId, aControlAction, aValue);
 453 }
 454
 455 //-----------------------------------------------------------------------------------------
 456 //
 457 //-----------------------------------------------------------------------------------------
 458
 459 uno::Any SAL_CALL CFilePicker::getValue(sal_Int16 aControlId, sal_Int16 aControlAction)
 460     throw(uno::RuntimeException)
 461 {
 462     OSL_ASSERT(0 != m_pImpl.get());
 463
 464     osl::MutexGuard aGuard(m_aMutex);
 465     return m_pImpl->getValue(aControlId, aControlAction);
 466 }
 467
 468 //-----------------------------------------------------------------------------------------
 469 //
 470 //-----------------------------------------------------------------------------------------
 471
 472 void SAL_CALL CFilePicker::enableControl(sal_Int16 aControlId, sal_Bool bEnable)
 473 throw(uno::RuntimeException)
 474 {
 475     OSL_ASSERT( 0 != m_pImpl.get( ) );
 476
 477     osl::MutexGuard aGuard( m_aMutex );
 478     m_pImpl->enableControl( aControlId, bEnable );
 479 }
 480
 481 //-----------------------------------------------------------------------------------------
 482 //
 483 //-----------------------------------------------------------------------------------------
 484
 485 void SAL_CALL CFilePicker::setLabel(sal_Int16 aControlId, const OUString& aLabel)
 486     throw (uno::RuntimeException)
 487 {
 488     OSL_ASSERT(0 != m_pImpl.get());
 489
 490     osl::MutexGuard aGuard(m_aMutex);
 491     m_pImpl->setLabel(aControlId, aLabel);
 492 }
 493
 494 //-----------------------------------------------------------------------------------------
 495 //
 496 //-----------------------------------------------------------------------------------------
 497
 498 OUString SAL_CALL CFilePicker::getLabel(sal_Int16 aControlId)
 499     throw (uno::RuntimeException)
 500 {
 501     OSL_ASSERT(0 != m_pImpl.get());
 502
 503     osl::MutexGuard aGuard(m_aMutex);
 504     return m_pImpl->getLabel(aControlId);
 505 }
 506
 507 //------------------------------------------------------------------------------------
 508 //
 509 //------------------------------------------------------------------------------------
 510
 511 uno::Sequence<sal_Int16> SAL_CALL CFilePicker::getSupportedImageFormats() throw (uno::RuntimeException)
 512 {
 513     OSL_ASSERT(0 != m_pImpl.get());
 514
 515     osl::MutexGuard aGuard(m_aMutex);
 516     return m_pImpl->getSupportedImageFormats();
 517 }
 518
 519 //------------------------------------------------------------------------------------
 520 //
 521 //------------------------------------------------------------------------------------
 522
 523 sal_Int32 SAL_CALL CFilePicker::getTargetColorDepth() throw (uno::RuntimeException)
 524 {
 525     OSL_ASSERT(0 != m_pImpl.get());
 526
 527     osl::MutexGuard aGuard(m_aMutex);
 528     return m_pImpl->getTargetColorDepth();
 529 }
 530
 531 //------------------------------------------------------------------------------------
 532 //
 533 //------------------------------------------------------------------------------------
 534
 535 sal_Int32 SAL_CALL CFilePicker::getAvailableWidth() throw (uno::RuntimeException)
 536 {
 537     OSL_ASSERT(0 != m_pImpl.get());
 538
 539     osl::MutexGuard aGuard(m_aMutex);
 540     return m_pImpl->getAvailableWidth();
 541 }
 542
 543 //------------------------------------------------------------------------------------
 544 //
 545 //------------------------------------------------------------------------------------
 546
 547 sal_Int32 SAL_CALL CFilePicker::getAvailableHeight() throw (uno::RuntimeException)
 548 {
 549     OSL_ASSERT(0 != m_pImpl.get());
 550
 551     osl::MutexGuard aGuard(m_aMutex);
 552     return m_pImpl->getAvailableHeight();
 553 }
 554
 555 //------------------------------------------------------------------------------------
 556 //
 557 //------------------------------------------------------------------------------------
 558
 559 void SAL_CALL CFilePicker::setImage(sal_Int16 aImageFormat, const uno::Any& aImage)
 560     throw (lang::IllegalArgumentException, uno::RuntimeException)
 561 {
 562     OSL_ASSERT(0 != m_pImpl.get());
 563
 564     osl::MutexGuard aGuard(m_aMutex);
 565     m_pImpl->setImage(aImageFormat, aImage);
 566 }
 567
 568 //------------------------------------------------------------------------------------
 569 //
 570 //------------------------------------------------------------------------------------
 571
 572 sal_Bool SAL_CALL CFilePicker::setShowState(sal_Bool bShowState) throw (uno::RuntimeException)
 573 {
 574     OSL_ASSERT(0 != m_pImpl.get());
 575
 576     osl::MutexGuard aGuard(m_aMutex);
 577     return m_pImpl->setShowState(bShowState);
 578 }
 579
 580 //------------------------------------------------------------------------------------
 581 //
 582 //------------------------------------------------------------------------------------
 583
 584 sal_Bool SAL_CALL CFilePicker::getShowState() throw (uno::RuntimeException)
 585 {
 586     OSL_ASSERT(0 != m_pImpl.get());
 587
 588     osl::MutexGuard aGuard(m_aMutex);
 589     return m_pImpl->getShowState();
 590 }
 591
 592 //------------------------------------------------------------------------------------
 593 //
 594 //------------------------------------------------------------------------------------
 595
 596 void SAL_CALL CFilePicker::initialize(const uno::Sequence<uno::Any>& aArguments)
 597     throw( uno::Exception, uno::RuntimeException)
 598 {
 599     // parameter checking
 600     uno::Any aAny;
 601     if ( 0 == aArguments.getLength( ) )
 602         throw lang::IllegalArgumentException(
 603             OUString( "no arguments" ),
 604             static_cast<XFilePicker2*>(this), 1);
 605
 606     aAny = aArguments[0];
 607
 608     if ( (aAny.getValueType() != ::getCppuType((sal_Int16*)0)) &&
 609          (aAny.getValueType() != ::getCppuType((sal_Int8*)0)) )
 610          throw lang::IllegalArgumentException(
 611             OUString("invalid argument type"),
 612             static_cast<XFilePicker2*>(this), 1);
 613
 614     sal_Int16 templateId = -1;
 615     aAny >>= templateId;
 616
 617     sal_Bool   bFileOpenDialog  = sal_True;
 618     sal_uInt32 winResTemplateId = 0;
 619
 620     switch ( templateId )
 621     {
 622     case FILEOPEN_SIMPLE:
 623         bFileOpenDialog = sal_True;
 624         break;
 625
 626     case FILESAVE_SIMPLE:
 627         bFileOpenDialog = sal_False;
 628         break;
 629
 630     case FILESAVE_AUTOEXTENSION_PASSWORD:
 631         bFileOpenDialog = sal_False;
 632         winResTemplateId = TMPL2000_FILESAVE_AUTOEXT_PASSWORD_BOX_ID;
 633         break;
 634
 635     case FILESAVE_AUTOEXTENSION_PASSWORD_FILTEROPTIONS:
 636         bFileOpenDialog = sal_False;
 637         winResTemplateId = TMPL2000_AUTOEXT_PASSWORD_FILTEROPTION_BOX;
 638         break;
 639
 640     case FILESAVE_AUTOEXTENSION_SELECTION:
 641         bFileOpenDialog = sal_False;
 642         winResTemplateId = TMPL2000_AUTOEXT_SELECTION_BOX;
 643         break;
 644
 645     case FILESAVE_AUTOEXTENSION_TEMPLATE:
 646         bFileOpenDialog = sal_False;
 647         winResTemplateId = TMPL2000_FILEOPEN_AUTOEXT_TEMPLATE_BOX_ID;
 648         break;
 649
 650     case FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE:
 651         winResTemplateId = TMPL2000_FILEOPEN_LINK_PREVIEW_BOX_ID;
 652         break;
 653
 654     case FILEOPEN_PLAY:
 655         winResTemplateId = TMPL2000_PLAY_PUSHBUTTON;
 656         break;
 657
 658     case FILEOPEN_READONLY_VERSION:
 659         winResTemplateId = TMPL2000_FILEOPEN_READONLY_VERSION_BOX_ID;
 660         break;
 661
 662     case FILEOPEN_LINK_PREVIEW:
 663         winResTemplateId = TMPL2000_FILEOPEN_LINK_PREVIEW_BOX_SIMPLE_ID;
 664         break;
 665
 666     case FILESAVE_AUTOEXTENSION:
 667         bFileOpenDialog = sal_False;
 668         winResTemplateId = TMPL2000_FILESAVE_AUTOEXT;
 669         break;
 670
 671     default:
 672         throw lang::IllegalArgumentException(
 673             OUString( "Unknown template" ),
 674             static_cast< XFilePicker2* >( this ),
 675             1 );
 676     }
 677
 678     HINSTANCE hInstance = GetModuleHandle( FILE_PICKER_DLL_NAME );
 679     OSL_POSTCOND( hInstance, "The name of the service dll must have changed" );
 680
 681     // create a new impl-class here based on the
 682     // given string, if the given string is empty
 683     // we do nothing
 684     m_pImpl = std::auto_ptr< CWinFileOpenImpl >(
 685         new CWinFileOpenImpl(
 686             this,
 687             bFileOpenDialog,
 688             0,
 689             winResTemplateId,
 690             hInstance ) );
 691 }
 692
 693 //------------------------------------------------------------------------------------
 694 //
 695 //------------------------------------------------------------------------------------
 696
 697 void SAL_CALL CFilePicker::cancel()
 698     throw(uno::RuntimeException)
 699 {
 700     OSL_ASSERT(m_pImpl.get());
 701
 702     osl::MutexGuard aGuard(m_aMutex);
 703     m_pImpl->cancel();
 704 }
 705
 706 // -------------------------------------------------
 707 // XServiceInfo
 708 // -------------------------------------------------
 709
 710 OUString SAL_CALL CFilePicker::getImplementationName()
 711     throw(uno::RuntimeException)
 712 {
 713     return OUString(RTL_CONSTASCII_USTRINGPARAM(FILE_PICKER_IMPL_NAME));
 714 }
 715
 716 // -------------------------------------------------
 717 //  XServiceInfo
 718 // -------------------------------------------------
 719
 720 sal_Bool SAL_CALL CFilePicker::supportsService(const OUString& ServiceName)
 721     throw(uno::RuntimeException )
 722 {
 723     uno::Sequence <OUString> SupportedServicesNames = FilePicker_getSupportedServiceNames();
 724
 725     for (sal_Int32 n = SupportedServicesNames.getLength(); n--;)
 726         if (SupportedServicesNames[n] == ServiceName)
 727             return sal_True;
 728
 729     return sal_False;
 730 }
 731
 732 // -------------------------------------------------
 733 //  XServiceInfo
 734 // -------------------------------------------------
 735
 736 uno::Sequence<OUString> SAL_CALL CFilePicker::getSupportedServiceNames()
 737     throw(uno::RuntimeException)
 738 {
 739     return FilePicker_getSupportedServiceNames();
 740 }
 741
 742 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */