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