vcl/unx/kde/UnxFilePicker.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 <com/sun/star/lang/DisposedException.hpp>
  21 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  22 #include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
  23 #include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp>
  24 #include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp>
  25 #include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
  26 #include <com/sun/star/ui/dialogs/ControlActions.hpp>
  27
  28 #include <FPServiceInfo.hxx>
  29
  30 #include <cppuhelper/interfacecontainer.h>
  31 #include <cppuhelper/supportsservice.hxx>
  32 #include <osl/diagnose.h>
  33 #include <osl/file.hxx>
  34 #include <rtl/ustring.hxx>
  35 #include <rtl/ustrbuf.hxx>
  36 #include <rtl/bootstrap.hxx>
  37 #include <tools/resmgr.hxx>
  38
  39 #include <UnxFilePicker.hxx>
  40 #include <UnxCommandThread.hxx>
  41 #include <UnxNotifyThread.hxx>
  42
  43 #include <vcl/fpicker.hrc>
  44 #include <vcl/svapp.hxx>
  45 #include <vcl/sysdata.hxx>
  46 #include <vcl/syswin.hxx>
  47 #include <vcl/window.hxx>
  48
  49 #include <sys/wait.h>
  50 #include <unistd.h>
  51 #include <fcntl.h>
  52 #include <stdio.h>
  53
  54 #include <iostream>
  55
  56 #include <config_vclplug.h>
  57
  58 using namespace ::com::sun::star;
  59
  60 using namespace ::com::sun::star::ui::dialogs;
  61 using namespace ::com::sun::star::ui::dialogs::TemplateDescription;
  62
  63 // helper functions
  64
  65 namespace
  66 {
  67     uno::Sequence<OUString> SAL_CALL FilePicker_getSupportedServiceNames()
  68     {
  69         uno::Sequence<OUString> aRet(3);
  70         aRet[0] = "com.sun.star.ui.dialogs.FilePicker";
  71         aRet[1] = "com.sun.star.ui.dialogs.SystemFilePicker";
  72 #if ENABLE_TDE
  73         aRet[2] = "com.sun.star.ui.dialogs.TDEFilePicker";
  74 #else // ENABLE_TDE
  75         aRet[2] = "com.sun.star.ui.dialogs.KDEFilePicker";
  76 #endif // ENABLE_TDE
  77         return aRet;
  78     }
  79 }
  80
  81 // UnxFilePicker
  82
  83 UnxFilePicker::UnxFilePicker( const uno::Reference<uno::XComponentContext>& )
  84     : UnxFilePicker_Base( m_rbHelperMtx ),
  85           m_nFilePickerPid( -1 ),
  86           m_nFilePickerWrite( -1 ),
  87           m_nFilePickerRead( -1 ),
  88           m_pNotifyThread( NULL ),
  89           m_pCommandThread( NULL ),
  90           m_pResMgr( ResMgr::CreateResMgr("fps_office") )
  91 {
  92 }
  93
  94 UnxFilePicker::~UnxFilePicker()
  95 {
  96     if ( m_nFilePickerPid > 0 )
  97     {
  98         sendCommand( OUString( "exit" ) );
  99         waitpid( m_nFilePickerPid, NULL, 0 );
 100     }
 101
 102     if ( m_pCommandThread )
 103     {
 104         m_pCommandThread->join();
 105
 106         delete m_pCommandThread, m_pCommandThread = NULL;
 107     }
 108
 109     if ( m_pNotifyThread )
 110     {
 111         m_pNotifyThread->exit();
 112
 113         m_pNotifyThread->join();
 114
 115         delete m_pNotifyThread, m_pNotifyThread = NULL;
 116     }
 117
 118     if ( m_nFilePickerWrite >= 0 )
 119         close( m_nFilePickerWrite );
 120
 121     if ( m_nFilePickerRead >= 0 )
 122         close( m_nFilePickerRead );
 123
 124     delete m_pResMgr, m_pResMgr = NULL;
 125 }
 126
 127 void SAL_CALL UnxFilePicker::addFilePickerListener( const uno::Reference<XFilePickerListener>& xListener )
 128     throw( uno::RuntimeException, std::exception )
 129 {
 130     OSL_ASSERT( m_pNotifyThread );
 131     osl::MutexGuard aGuard( m_aMutex );
 132
 133     m_pNotifyThread->addFilePickerListener( xListener );
 134 }
 135
 136 void SAL_CALL UnxFilePicker::removeFilePickerListener( const uno::Reference<XFilePickerListener>& xListener )
 137     throw( uno::RuntimeException, std::exception )
 138 {
 139     OSL_ASSERT( m_pNotifyThread );
 140     osl::MutexGuard aGuard( m_aMutex );
 141
 142     m_pNotifyThread->removeFilePickerListener( xListener );
 143 }
 144
 145 void SAL_CALL UnxFilePicker::setTitle( const OUString &rTitle )
 146     throw( uno::RuntimeException, std::exception )
 147 {
 148     checkFilePicker();
 149     ::osl::MutexGuard aGuard( m_aMutex );
 150
 151     OUStringBuffer aBuffer( 1024 );
 152
 153     aBuffer.appendAscii( "setTitle " );
 154     appendEscaped( aBuffer, rTitle );
 155
 156     sendCommand( aBuffer.makeStringAndClear() );
 157 }
 158
 159 sal_Int16 SAL_CALL UnxFilePicker::execute()
 160     throw( uno::RuntimeException, std::exception )
 161 {
 162     checkFilePicker();
 163
 164     // this is _not_ an osl::Condition, see i#93366
 165     m_pCommandThread->execCondition().reset();
 166
 167     sendCommand( OUString( "exec" ));
 168
 169     m_pCommandThread->execCondition().wait();
 170
 171     return m_pCommandThread->result()
 172         ? css::ui::dialogs::ExecutableDialogResults::OK
 173         : css::ui::dialogs::ExecutableDialogResults::CANCEL;
 174 }
 175
 176 void SAL_CALL UnxFilePicker::setMultiSelectionMode( sal_Bool bMode )
 177     throw( uno::RuntimeException, std::exception )
 178 {
 179     checkFilePicker();
 180     ::osl::MutexGuard aGuard( m_aMutex );
 181
 182     OUString aString = bMode?
 183         OUString( "setMultiSelection true" ):
 184         OUString( "setMultiSelection false" );
 185
 186     sendCommand( aString );
 187 }
 188
 189 void SAL_CALL UnxFilePicker::setDefaultName( const OUString &rName )
 190     throw( uno::RuntimeException, std::exception )
 191 {
 192     checkFilePicker();
 193     ::osl::MutexGuard aGuard( m_aMutex );
 194
 195     OUStringBuffer aBuffer( 1024 );
 196
 197     aBuffer.appendAscii( "setDefaultName " );
 198     appendEscaped( aBuffer, rName );
 199
 200     sendCommand( aBuffer.makeStringAndClear() );
 201 }
 202
 203 void SAL_CALL UnxFilePicker::setDisplayDirectory( const OUString &rDirectory )
 204     throw( uno::RuntimeException, std::exception )
 205 {
 206     checkFilePicker();
 207     ::osl::MutexGuard aGuard( m_aMutex );
 208
 209     OUStringBuffer aBuffer( 1024 );
 210
 211     aBuffer.appendAscii( "setDirectory " );
 212     appendEscaped( aBuffer, rDirectory );
 213
 214     sendCommand( aBuffer.makeStringAndClear() );
 215 }
 216
 217 OUString SAL_CALL UnxFilePicker::getDisplayDirectory()
 218     throw( uno::RuntimeException, std::exception )
 219 {
 220     checkFilePicker();
 221     ::osl::MutexGuard aGuard( m_aMutex );
 222
 223     sendCommand( OUString( "getDirectory" ),
 224                  m_pCommandThread->getDirectoryCondition() );
 225
 226     return m_pCommandThread->getDirectory();
 227 }
 228
 229 uno::Sequence< OUString > SAL_CALL UnxFilePicker::getFiles()
 230     throw( uno::RuntimeException, std::exception )
 231 {
 232     checkFilePicker();
 233     ::osl::MutexGuard aGuard( m_aMutex );
 234
 235     sendCommand( OUString( "getFiles" ),
 236                  m_pCommandThread->getFilesCondition() );
 237
 238     return m_pCommandThread->getFiles();
 239 }
 240
 241 void SAL_CALL UnxFilePicker::appendFilter( const OUString &rTitle, const OUString &rFilter )
 242     throw( lang::IllegalArgumentException, uno::RuntimeException, std::exception )
 243 {
 244     checkFilePicker();
 245     ::osl::MutexGuard aGuard( m_aMutex );
 246
 247     OUStringBuffer aBuffer( 1024 );
 248
 249     aBuffer.appendAscii( "appendFilter " );
 250     appendEscaped( aBuffer, rTitle );
 251     aBuffer.appendAscii( " ", 1 );
 252     appendEscaped( aBuffer, rFilter );
 253
 254     sendCommand( aBuffer.makeStringAndClear() );
 255 }
 256
 257 void SAL_CALL UnxFilePicker::setCurrentFilter( const OUString &rTitle )
 258     throw( lang::IllegalArgumentException, uno::RuntimeException, std::exception )
 259 {
 260     checkFilePicker();
 261     ::osl::MutexGuard aGuard( m_aMutex );
 262
 263     OUStringBuffer aBuffer( 1024 );
 264
 265     aBuffer.appendAscii( "setCurrentFilter " );
 266     appendEscaped( aBuffer, rTitle );
 267
 268     sendCommand( aBuffer.makeStringAndClear() );
 269 }
 270
 271 OUString SAL_CALL UnxFilePicker::getCurrentFilter()
 272     throw( uno::RuntimeException, std::exception )
 273 {
 274     checkFilePicker();
 275     ::osl::MutexGuard aGuard( m_aMutex );
 276
 277     sendCommand( OUString( "getCurrentFilter" ),
 278                  m_pCommandThread->getCurrentFilterCondition() );
 279
 280     return m_pCommandThread->getCurrentFilter();
 281 }
 282
 283 void SAL_CALL UnxFilePicker::appendFilterGroup( const OUString &rGroupTitle, const uno::Sequence<beans::StringPair> &rFilters )
 284     throw( lang::IllegalArgumentException, uno::RuntimeException, std::exception )
 285 {
 286     checkFilePicker();
 287     ::osl::MutexGuard aGuard( m_aMutex );
 288
 289     OUStringBuffer aBuffer( 1024 );
 290
 291     aBuffer.appendAscii( "appendFilterGroup " );
 292     appendEscaped( aBuffer, rGroupTitle );
 293
 294     for ( sal_Int32 i = 0; i < rFilters.getLength(); ++i )
 295     {
 296         beans::StringPair aPair = rFilters[i];
 297
 298         aBuffer.appendAscii( " ", 1 );
 299         appendEscaped( aBuffer, aPair.First );
 300         aBuffer.appendAscii( " ", 1 );
 301         appendEscaped( aBuffer, aPair.Second );
 302     }
 303
 304     sendCommand( aBuffer.makeStringAndClear() );
 305 }
 306
 307 void SAL_CALL UnxFilePicker::setValue( sal_Int16 nControlId, sal_Int16 nControlAction, const uno::Any &rValue )
 308     throw( uno::RuntimeException, std::exception )
 309 {
 310     checkFilePicker();
 311     ::osl::MutexGuard aGuard( m_aMutex );
 312
 313     OUString aType;
 314     OUString aAction;
 315     sal_Int32 nTitleId;
 316
 317     if ( controlIdInfo( nControlId, aType, nTitleId ) && controlActionInfo( nControlAction, aAction ) )
 318     {
 319         OUStringBuffer aBuffer( 1024 );
 320
 321         aBuffer.appendAscii( "setValue " );
 322         aBuffer.append( static_cast< sal_Int32 >( nControlId ) );
 323         aBuffer.appendAscii( " ", 1 );
 324         aBuffer.append( aAction );
 325
 326         if ( aType == "checkbox" )
 327         {
 328             bool bControlValue;
 329             if ( ( rValue >>= bControlValue ) && bControlValue )
 330                 aBuffer.appendAscii( " true" );
 331             else
 332                 aBuffer.appendAscii( " false" );
 333         }
 334         else if ( aType == "listbox" )
 335         {
 336             switch ( nControlAction )
 337             {
 338                 case ControlActions::ADD_ITEM:
 339                 case ControlActions::SET_HELP_URL:
 340                     {
 341                         OUString aString;
 342                         if ( rValue >>= aString )
 343                         {
 344                             aBuffer.appendAscii( " ", 1 );
 345                             appendEscaped( aBuffer, aString );
 346                         }
 347                     }
 348                     break;
 349
 350                 case ControlActions::ADD_ITEMS:
 351                     {
 352                         uno::Sequence< OUString > aSequence;
 353                         if ( rValue >>= aSequence )
 354                         {
 355                             for ( sal_Int32 nIdx = 0; nIdx < aSequence.getLength(); ++nIdx )
 356                             {
 357                                 aBuffer.appendAscii( " ", 1 );
 358                                 appendEscaped( aBuffer, aSequence[nIdx] );
 359                             }
 360
 361                         }
 362                     }
 363                     break;
 364
 365                 case ControlActions::DELETE_ITEM:
 366                 case ControlActions::SET_SELECT_ITEM:
 367                     {
 368                         sal_Int32 nInt;
 369                         if ( rValue >>= nInt )
 370                         {
 371                             aBuffer.appendAscii( " ", 1 );
 372                             aBuffer.append( nInt );
 373                         }
 374                     }
 375                     break;
 376
 377                 default:
 378                     // nothing
 379                     break;
 380             }
 381         }
 382         // TODO else if push button...
 383
 384         sendCommand( aBuffer.makeStringAndClear() );
 385     }
 386 }
 387
 388 uno::Any SAL_CALL UnxFilePicker::getValue( sal_Int16 nControlId, sal_Int16 nControlAction )
 389     throw( uno::RuntimeException, std::exception )
 390 {
 391     checkFilePicker();
 392     ::osl::MutexGuard aGuard( m_aMutex );
 393
 394     OUString aAction;
 395
 396     if ( controlActionInfo( nControlAction, aAction ) )
 397     {
 398         OUStringBuffer aBuffer( 1024 );
 399
 400         aBuffer.appendAscii( "getValue " );
 401         aBuffer.append( static_cast< sal_Int32 >( nControlId ) );
 402         aBuffer.appendAscii( " ", 1 );
 403         aBuffer.append( aAction );
 404
 405         sendCommand( aBuffer.makeStringAndClear(),
 406                 m_pCommandThread->getValueCondition() );
 407
 408         return m_pCommandThread->getValue();
 409     }
 410
 411     return uno::Any();
 412 }
 413
 414 void SAL_CALL UnxFilePicker::enableControl( sal_Int16 nControlId, sal_Bool bEnable )
 415     throw( uno::RuntimeException, std::exception )
 416 {
 417     checkFilePicker();
 418     ::osl::MutexGuard aGuard( m_aMutex );
 419
 420     OUStringBuffer aBuffer( 1024 );
 421
 422     aBuffer.appendAscii( "enableControl " );
 423     aBuffer.append( static_cast< sal_Int32 >( nControlId ) );
 424     aBuffer.appendAscii( bEnable? " true": " false" );
 425
 426     sendCommand( aBuffer.makeStringAndClear() );
 427 }
 428
 429 void SAL_CALL UnxFilePicker::setLabel( sal_Int16 nControlId, const OUString &rLabel )
 430     throw( uno::RuntimeException, std::exception )
 431 {
 432     checkFilePicker();
 433     ::osl::MutexGuard aGuard( m_aMutex );
 434
 435     OUStringBuffer aBuffer( 1024 );
 436
 437     aBuffer.appendAscii( "setLabel " );
 438     aBuffer.append( static_cast< sal_Int32 >( nControlId ) );
 439     aBuffer.appendAscii( " ", 1 );
 440     appendEscaped( aBuffer, rLabel );
 441
 442     sendCommand( aBuffer.makeStringAndClear() );
 443 }
 444
 445 OUString SAL_CALL UnxFilePicker::getLabel(sal_Int16 /*nControlId*/)
 446     throw ( uno::RuntimeException, std::exception )
 447 {
 448     // FIXME getLabel() is not yet implemented
 449     checkFilePicker();
 450     ::osl::MutexGuard aGuard( m_aMutex );
 451
 452     // TODO return m_pImpl->getLabel(nControlId);
 453     return OUString();
 454 }
 455
 456 /* TODO
 457 uno::Sequence<sal_Int16> SAL_CALL UnxFilePicker::getSupportedImageFormats()
 458     throw( uno::RuntimeException )
 459 {
 460     checkFilePicker();
 461     ::osl::MutexGuard aGuard( m_aMutex );
 462
 463     return m_pImpl->getSupportedImageFormats();
 464 }
 465
 466 sal_Int32 SAL_CALL UnxFilePicker::getTargetColorDepth()
 467     throw( uno::RuntimeException )
 468 {
 469     checkFilePicker();
 470     ::osl::MutexGuard aGuard( m_aMutex );
 471
 472     return m_pImpl->getTargetColorDepth();
 473 }
 474
 475 sal_Int32 SAL_CALL UnxFilePicker::getAvailableWidth()
 476     throw( uno::RuntimeException )
 477 {
 478     checkFilePicker();
 479     ::osl::MutexGuard aGuard( m_aMutex );
 480
 481     return m_pImpl->getAvailableWidth();
 482 }
 483
 484 sal_Int32 SAL_CALL UnxFilePicker::getAvailableHeight()
 485     throw( uno::RuntimeException )
 486 {
 487     checkFilePicker();
 488     ::osl::MutexGuard aGuard( m_aMutex );
 489
 490     return m_pImpl->getAvailableHeight();
 491 }
 492
 493 void SAL_CALL UnxFilePicker::setImage( sal_Int16 aImageFormat, const uno::Any &rImage )
 494     throw( lang::IllegalArgumentException, uno::RuntimeException )
 495 {
 496     checkFilePicker();
 497     ::osl::MutexGuard aGuard( m_aMutex );
 498
 499     m_pImpl->setImage( aImageFormat, aImage );
 500 }
 501
 502 sal_Bool SAL_CALL UnxFilePicker::setShowState( sal_Bool bShowState )
 503     throw( uno::RuntimeException )
 504 {
 505     checkFilePicker();
 506     ::osl::MutexGuard aGuard( m_aMutex );
 507
 508     return m_pImpl->setShowState( bShowState );
 509 }
 510
 511 sal_Bool SAL_CALL UnxFilePicker::getShowState()
 512     throw( uno::RuntimeException )
 513 {
 514     checkFilePicker();
 515     ::osl::MutexGuard aGuard( m_aMutex );
 516
 517     return m_pImpl->getShowState();
 518 }
 519 */
 520
 521 void SAL_CALL UnxFilePicker::initialize( const uno::Sequence<uno::Any> &rArguments )
 522     throw( uno::Exception, uno::RuntimeException, std::exception )
 523 {
 524     initFilePicker();
 525
 526     // parameter checking
 527     uno::Any aAny;
 528     if ( 0 == rArguments.getLength( ) )
 529         throw lang::IllegalArgumentException(
 530                 OUString( "no arguments" ),
 531                 static_cast< XFilePicker2* >( this ), 1 );
 532
 533     aAny = rArguments[0];
 534
 535     if ( ( aAny.getValueType() != cppu::UnoType<sal_Int16>::get()) && ( aAny.getValueType() != cppu::UnoType<sal_Int8>::get()) )
 536         throw lang::IllegalArgumentException(
 537                 OUString( "invalid argument type" ),
 538                 static_cast< XFilePicker2* >( this ), 1 );
 539
 540     sal_Int16 templateId = -1;
 541     aAny >>= templateId;
 542
 543     OUString aTypeOpen( "setType \"open\"" );
 544     OUString aTypeSaveAs( "setType \"save\"" );
 545
 546     switch ( templateId )
 547     {
 548         case FILEOPEN_SIMPLE:
 549             sendCommand( aTypeOpen );
 550             break;
 551
 552         case FILESAVE_SIMPLE:
 553             sendCommand( aTypeSaveAs );
 554             break;
 555
 556         case FILESAVE_AUTOEXTENSION_PASSWORD:
 557             sendCommand( aTypeSaveAs );
 558
 559             sendAppendControlCommand( ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION );
 560             sendAppendControlCommand( ExtendedFilePickerElementIds::CHECKBOX_PASSWORD );
 561             break;
 562
 563         case FILESAVE_AUTOEXTENSION_PASSWORD_FILTEROPTIONS:
 564             sendCommand( aTypeSaveAs );
 565
 566             sendAppendControlCommand( ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION );
 567             sendAppendControlCommand( ExtendedFilePickerElementIds::CHECKBOX_PASSWORD );
 568             sendAppendControlCommand( ExtendedFilePickerElementIds::CHECKBOX_FILTEROPTIONS );
 569             break;
 570
 571         case FILESAVE_AUTOEXTENSION_SELECTION:
 572             sendCommand( aTypeSaveAs );
 573
 574             sendAppendControlCommand( ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION );
 575             sendAppendControlCommand( ExtendedFilePickerElementIds::CHECKBOX_SELECTION );
 576             break;
 577
 578         case FILESAVE_AUTOEXTENSION_TEMPLATE:
 579             sendCommand( aTypeSaveAs );
 580
 581             sendAppendControlCommand( ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION );
 582             sendAppendControlCommand( ExtendedFilePickerElementIds::LISTBOX_TEMPLATE );
 583             break;
 584
 585         case FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE:
 586             sendCommand( aTypeOpen );
 587
 588             sendAppendControlCommand( ExtendedFilePickerElementIds::CHECKBOX_LINK );
 589             sendAppendControlCommand( ExtendedFilePickerElementIds::CHECKBOX_PREVIEW );
 590             sendAppendControlCommand( ExtendedFilePickerElementIds::LISTBOX_IMAGE_TEMPLATE );
 591             break;
 592
 593         case FILEOPEN_PLAY:
 594             sendCommand( aTypeOpen );
 595
 596             sendAppendControlCommand( ExtendedFilePickerElementIds::PUSHBUTTON_PLAY );
 597             break;
 598
 599         case FILEOPEN_READONLY_VERSION:
 600             sendCommand( aTypeOpen );
 601
 602             sendAppendControlCommand( ExtendedFilePickerElementIds::CHECKBOX_READONLY );
 603             sendAppendControlCommand( ExtendedFilePickerElementIds::LISTBOX_VERSION );
 604             break;
 605
 606         case FILEOPEN_LINK_PREVIEW:
 607             sendCommand( aTypeOpen );
 608
 609             sendAppendControlCommand( ExtendedFilePickerElementIds::CHECKBOX_LINK );
 610             sendAppendControlCommand( ExtendedFilePickerElementIds::CHECKBOX_PREVIEW );
 611             break;
 612
 613         case FILESAVE_AUTOEXTENSION:
 614             sendCommand( aTypeSaveAs );
 615
 616             sendAppendControlCommand( ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION );
 617             break;
 618
 619         default:
 620             throw lang::IllegalArgumentException(
 621                     OUString( "Unknown template" ),
 622                     static_cast< XFilePicker2* >( this ),
 623                     1 );
 624     }
 625 }
 626
 627 void SAL_CALL UnxFilePicker::cancel()
 628     throw ( uno::RuntimeException, std::exception )
 629 {
 630     // FIXME cancel() is not implemented
 631     checkFilePicker();
 632     ::osl::MutexGuard aGuard( m_aMutex );
 633
 634     // TODO m_pImpl->cancel();
 635 }
 636
 637 void SAL_CALL UnxFilePicker::disposing( const lang::EventObject &rEvent )
 638     throw( uno::RuntimeException )
 639 {
 640     uno::Reference<XFilePickerListener> xFilePickerListener( rEvent.Source, uno::UNO_QUERY );
 641
 642     if ( xFilePickerListener.is() )
 643         removeFilePickerListener( xFilePickerListener );
 644 }
 645
 646 OUString SAL_CALL UnxFilePicker::getImplementationName()
 647     throw( uno::RuntimeException, std::exception )
 648 {
 649     return OUString( FILE_PICKER_IMPL_NAME );
 650 }
 651
 652 sal_Bool SAL_CALL UnxFilePicker::supportsService( const OUString& ServiceName )
 653     throw( uno::RuntimeException, std::exception )
 654 {
 655     return cppu::supportsService(this, ServiceName);
 656 }
 657
 658 uno::Sequence< OUString > SAL_CALL UnxFilePicker::getSupportedServiceNames()
 659     throw( uno::RuntimeException, std::exception )
 660 {
 661     return FilePicker_getSupportedServiceNames();
 662 }
 663
 664 void UnxFilePicker::initFilePicker()
 665 {
 666     int aFiledesStdin[2], aFiledesStdout[2];
 667     if ( pipe( aFiledesStdin ) < 0 || pipe( aFiledesStdout ) < 0 )
 668         return;
 669
 670     m_nFilePickerPid = fork();
 671     if ( m_nFilePickerPid < 0 )
 672         return;
 673
 674     if ( m_nFilePickerPid == 0 )
 675     {
 676         // Child...
 677         close( aFiledesStdin[1] ); // write end of the pipe
 678         dup2(  aFiledesStdin[0], 0 );
 679         close( aFiledesStdin[0] );
 680
 681         close( aFiledesStdout[0] ); // read end of the pipe
 682         dup2(  aFiledesStdout[1], 1 );
 683         close( aFiledesStdout[1] );
 684
 685 #if OSL_DEBUG_LEVEL == 0
 686         int nRedirect = open( "/dev/null", O_WRONLY );
 687         if( nRedirect != -1 )
 688         {
 689             dup2( nRedirect, 2 );
 690         }
 691 #endif
 692
 693         // The executable name
 694 #if ENABLE_TDE
 695         OUString helperurl("${ORIGIN}/tdefilepicker");
 696 #else // ENABLE_TDE
 697         OUString helperurl("${ORIGIN}/kdefilepicker");
 698 #endif // ENABLE_TDE
 699         rtl::Bootstrap::expandMacros( helperurl );
 700         OUString helperpath;
 701         osl::FileBase::getSystemPathFromFileURL( helperurl, helperpath );
 702         OString helper( OUStringToOString( helperpath, osl_getThreadTextEncoding()));
 703
 704         // ID of the main window
 705         const int nIdLen = 20;
 706         char pWinId[nIdLen] = "0";
 707
 708         // TODO pass here the real parent (not possible for system dialogs
 709         // yet), and default to GetDefDialogParent() only when the real parent
 710         // is NULL
 711         Window *pParentWin = Application::GetDefDialogParent();
 712         if ( pParentWin )
 713         {
 714             const SystemEnvData* pSysData = ((SystemWindow *)pParentWin)->GetSystemData();
 715             if ( pSysData )
 716             {
 717                 snprintf( pWinId, nIdLen, "%ld", pSysData->aWindow ); // unx only
 718                 pWinId[nIdLen-1] = 0;
 719             }
 720         }
 721
 722         // Execute the fpicker implementation
 723         execlp( helper.getStr(), helper.getStr(), "--winid", pWinId, NULL );
 724
 725         // Error, finish the child
 726         exit( -1 );
 727     }
 728
 729     // Parent continues
 730     close( aFiledesStdin[0] );
 731     m_nFilePickerWrite = aFiledesStdin[1];
 732
 733     close( aFiledesStdout[1] );
 734     m_nFilePickerRead = aFiledesStdout[0];
 735
 736     // Create the notify thread
 737     if ( !m_pNotifyThread )
 738         m_pNotifyThread = new UnxFilePickerNotifyThread( this );
 739
 740     // Create the command thread
 741     if ( !m_pCommandThread )
 742         m_pCommandThread = new UnxFilePickerCommandThread( m_pNotifyThread, m_nFilePickerRead );
 743
 744     // Start the threads
 745     m_pNotifyThread->create();
 746     m_pCommandThread->create();
 747
 748     return;
 749 }
 750
 751 void UnxFilePicker::checkFilePicker() throw( ::com::sun::star::uno::RuntimeException )
 752 {
 753     if ( m_nFilePickerPid > 0 )
 754     {
 755         // TODO check if external file picker is runnning
 756     }
 757     else
 758     {
 759         throw uno::RuntimeException(
 760                 OUString( "the external file picker does not run" ),
 761                 *this );
 762     }
 763 }
 764
 765 void UnxFilePicker::sendCommand( const OUString &rCommand )
 766 {
 767     if ( m_nFilePickerWrite < 0 )
 768         return;
 769
 770     OString aUtfString = OUStringToOString( rCommand + "\n", RTL_TEXTENCODING_UTF8 );
 771
 772 #if OSL_DEBUG_LEVEL > 0
 773     ::std::cerr << "UnxFilePicker sent: \"" << aUtfString.getStr() << "\"" << ::std::endl;
 774 #endif
 775
 776     write( m_nFilePickerWrite, aUtfString.getStr(), aUtfString.getLength() );
 777 }
 778
 779 void UnxFilePicker::sendCommand( const OUString &rCommand, ::osl::Condition &rCondition )
 780 {
 781     rCondition.reset();
 782
 783     sendCommand( rCommand );
 784
 785     rCondition.wait();
 786 }
 787
 788 void UnxFilePicker::appendEscaped( OUStringBuffer &rBuffer, const OUString &rString )
 789 {
 790     const sal_Unicode *pUnicode = rString.getStr();
 791     const sal_Unicode *pEnd     = pUnicode + rString.getLength();
 792
 793     rBuffer.appendAscii( "\"" , 1 );
 794
 795     for ( ; pUnicode != pEnd; ++pUnicode )
 796     {
 797         if ( *pUnicode == '\\' )
 798             rBuffer.appendAscii( "\\\\", 2 );
 799         else if ( *pUnicode == '"' )
 800             rBuffer.appendAscii( "\\\"", 2 );
 801         else if ( *pUnicode == '\n' )
 802             rBuffer.appendAscii( "\\n", 2 );
 803         else
 804             rBuffer.append( *pUnicode );
 805     }
 806
 807     rBuffer.appendAscii( "\"", 1 );
 808 }
 809
 810 bool UnxFilePicker::controlIdInfo( sal_Int16 nControlId, OUString &rType, sal_Int32 &rTitleId )
 811 {
 812     typedef struct {
 813         sal_Int16 nId;
 814         const OUString *pType;
 815         sal_Int32 nTitle;
 816     } ElementToName;
 817
 818     const OUString aCheckBox(   "checkbox" );
 819     const OUString aControl(    "control" );
 820     const OUString aEdit(       "edit" );
 821     const OUString aLabel(      "label" );
 822     const OUString aListBox(    "listbox" );
 823     const OUString aPushButton( "pushbutton" );
 824
 825     const ElementToName *pPtr;
 826     const ElementToName pArray[] =
 827     {
 828         { CommonFilePickerElementIds::PUSHBUTTON_OK,            &aPushButton, 0/*FIXME?*/ },
 829         { CommonFilePickerElementIds::PUSHBUTTON_CANCEL,        &aPushButton, 0/*FIXME?*/ },
 830         { CommonFilePickerElementIds::LISTBOX_FILTER,           &aListBox,    0/*FIXME?*/ },
 831         { CommonFilePickerElementIds::CONTROL_FILEVIEW,         &aControl,    0/*FIXME?*/ },
 832         { CommonFilePickerElementIds::EDIT_FILEURL,             &aEdit,       0/*FIXME?*/ },
 833         { CommonFilePickerElementIds::LISTBOX_FILTER_LABEL,     &aLabel,      0/*FIXME?*/ },
 834         { CommonFilePickerElementIds::EDIT_FILEURL_LABEL,       &aLabel,      0/*FIXME?*/ },
 835
 836         { ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION, &aCheckBox,   STR_SVT_FILEPICKER_AUTO_EXTENSION },
 837         { ExtendedFilePickerElementIds::CHECKBOX_PASSWORD,      &aCheckBox,   STR_SVT_FILEPICKER_PASSWORD },
 838         { ExtendedFilePickerElementIds::CHECKBOX_FILTEROPTIONS, &aCheckBox,   STR_SVT_FILEPICKER_FILTER_OPTIONS },
 839         { ExtendedFilePickerElementIds::CHECKBOX_READONLY,      &aCheckBox,   STR_SVT_FILEPICKER_READONLY },
 840         { ExtendedFilePickerElementIds::CHECKBOX_LINK,          &aCheckBox,   STR_SVT_FILEPICKER_INSERT_AS_LINK },
 841         { ExtendedFilePickerElementIds::CHECKBOX_PREVIEW,       &aCheckBox,   STR_SVT_FILEPICKER_SHOW_PREVIEW },
 842         { ExtendedFilePickerElementIds::PUSHBUTTON_PLAY,        &aPushButton, STR_SVT_FILEPICKER_PLAY },
 843         { ExtendedFilePickerElementIds::LISTBOX_VERSION,        &aListBox,    STR_SVT_FILEPICKER_VERSION },
 844         { ExtendedFilePickerElementIds::LISTBOX_TEMPLATE,       &aListBox,    STR_SVT_FILEPICKER_TEMPLATES },
 845         { ExtendedFilePickerElementIds::LISTBOX_IMAGE_TEMPLATE, &aListBox,    STR_SVT_FILEPICKER_IMAGE_TEMPLATE },
 846         { ExtendedFilePickerElementIds::CHECKBOX_SELECTION,     &aCheckBox,   STR_SVT_FILEPICKER_SELECTION },
 847         { 0, 0, 0 }
 848     };
 849
 850     for ( pPtr = pArray; pPtr->nId && ( pPtr->nId != nControlId ); ++pPtr )
 851         ;
 852
 853     if ( pPtr->nId == nControlId )
 854     {
 855         rType = *(pPtr->pType);
 856         rTitleId = pPtr->nTitle;
 857
 858         return true;
 859     }
 860
 861     return false;
 862 }
 863
 864 bool UnxFilePicker::controlActionInfo( sal_Int16 nControlAction, OUString &rType )
 865 {
 866     typedef struct {
 867         sal_Int16 nId;
 868         const OUString pType;
 869     } ElementToName;
 870
 871     const ElementToName *pPtr;
 872     const ElementToName pArray[] =
 873     {
 874         { ControlActions::ADD_ITEM,                OUString( "addItem" ) },
 875         { ControlActions::ADD_ITEMS,               OUString( "addItems" ) },
 876         { ControlActions::DELETE_ITEM,             OUString( "deleteItem" ) },
 877         { ControlActions::DELETE_ITEMS,            OUString( "deleteItems" ) },
 878         { ControlActions::SET_SELECT_ITEM,         OUString( "setSelectedItem" ) },
 879         { ControlActions::GET_ITEMS,               OUString( "getItems" ) },
 880         { ControlActions::GET_SELECTED_ITEM,       OUString( "getSelectedItem" ) },
 881         { ControlActions::GET_SELECTED_ITEM_INDEX, OUString( "getSelectedItemIndex" ) },
 882         { ControlActions::SET_HELP_URL,            OUString( "setHelpURL" ) },
 883         { ControlActions::GET_HELP_URL,            OUString( "getHelpURL" ) },
 884         { 0,                                       OUString( "noAction" ) }
 885     };
 886
 887     for ( pPtr = pArray; pPtr->nId && ( pPtr->nId != nControlAction ); ++pPtr )
 888         ;
 889
 890     rType = pPtr->pType;
 891
 892     return true;
 893 }
 894
 895 void UnxFilePicker::sendAppendControlCommand( sal_Int16 nControlId )
 896 {
 897     OUString aType;
 898     sal_Int32 nTitleId;
 899
 900     if ( controlIdInfo( nControlId, aType, nTitleId ) )
 901     {
 902         OUStringBuffer aBuffer( 1024 );
 903
 904         aBuffer.appendAscii( "appendControl " );
 905         aBuffer.append( static_cast< sal_Int32 >( nControlId ) );
 906         aBuffer.appendAscii( " ", 1 );
 907         appendEscaped( aBuffer, aType );
 908         aBuffer.appendAscii( " ", 1 );
 909         appendEscaped( aBuffer, m_pResMgr? ResId(nTitleId, *m_pResMgr).toString(): OUString() );
 910
 911         sendCommand( aBuffer.makeStringAndClear() );
 912     }
 913 }
 914
 915 uno::Sequence< OUString > SAL_CALL UnxFilePicker::getSelectedFiles()
 916     throw( uno::RuntimeException, std::exception )
 917 {
 918     return getFiles();
 919 }
 920
 921 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */