fpicker/source/win32/filepicker/FilePicker.cxx

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