cui/source/dialogs/cuigaldlg.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 "sal/config.h"
  21
  22 #include <algorithm>
  23 #include <cassert>
  24
  25 #include <ucbhelper/content.hxx>
  26 #include <osl/mutex.hxx>
  27 #include <vcl/svapp.hxx>
  28 #include <vcl/msgbox.hxx>
  29 #include <avmedia/mediawindow.hxx>
  30 #include <unotools/pathoptions.hxx>
  31 #include <sfx2/opengrf.hxx>
  32 #include <vcl/graphicfilter.hxx>
  33 #include <svx/gallery1.hxx>
  34 #include <svx/galtheme.hxx>
  35 #include "cuigaldlg.hxx"
  36 #include "helpid.hrc"
  37 #include <unotools/syslocale.hxx>
  38 #include <cppuhelper/implbase1.hxx>
  39 #include <com/sun/star/uno/Reference.hxx>
  40 #include <com/sun/star/lang/XInitialization.hpp>
  41 #include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp>
  42 #include <comphelper/processfactory.hxx>
  43 #include <com/sun/star/sdbc/XResultSet.hpp>
  44 #include <com/sun/star/sdbc/XRow.hpp>
  45 #include <com/sun/star/ucb/XContentAccess.hpp>
  46 #include <com/sun/star/ui/dialogs/FolderPicker.hpp>
  47 #include <com/sun/star/ui/dialogs/XAsynchronousExecutableDialog.hpp>
  48 #include <sfx2/sfxuno.hxx>
  49 #include "dialmgr.hxx"
  50 #include "gallery.hrc"
  51 #include <svx/dialogs.hrc>
  52 #include <svx/dialmgr.hxx>
  53
  54
  55
  56 // - Namespaces -
  57
  58
  59 using namespace ::ucbhelper;
  60 using namespace ::cppu;
  61 using namespace ::com::sun::star::lang;
  62 using namespace ::com::sun::star::sdbc;
  63 using namespace ::com::sun::star::ucb;
  64 using namespace ::com::sun::star::ui::dialogs;
  65 using namespace ::com::sun::star::uno;
  66
  67
  68 // - SearchThread -
  69
  70
  71 SearchThread::SearchThread( SearchProgress* pProgess,
  72                             TPGalleryThemeProperties* pBrowser,
  73                             const INetURLObject& rStartURL ) :
  74         Thread      ( "cuiSearchThread" ),
  75         mpProgress  ( pProgess ),
  76         mpBrowser   ( pBrowser ),
  77         maStartURL  ( rStartURL )
  78 {
  79 }
  80
  81
  82
  83 SearchThread::~SearchThread()
  84 {
  85 }
  86
  87
  88
  89 void SearchThread::execute()
  90 {
  91     const OUString aFileType( mpBrowser->m_pCbbFileType->GetText() );
  92
  93     if( !aFileType.isEmpty() )
  94     {
  95         const sal_uInt16        nFileNumber = mpBrowser->m_pCbbFileType->GetEntryPos( aFileType );
  96         sal_uInt16              nBeginFormat, nEndFormat;
  97         ::std::vector< OUString > aFormats;
  98
  99         if( !nFileNumber || ( nFileNumber >= mpBrowser->m_pCbbFileType->GetEntryCount() ) )
 100         {
 101             nBeginFormat = 1;
 102             nEndFormat = mpBrowser->m_pCbbFileType->GetEntryCount() - 1;
 103         }
 104         else
 105             nBeginFormat = nEndFormat = nFileNumber;
 106
 107         for( sal_uInt16 i = nBeginFormat; i <= nEndFormat; ++i )
 108             aFormats.push_back( mpBrowser->aFilterEntryList[ i ]->aFilterName.toAsciiLowerCase() );
 109
 110         ImplSearch( maStartURL, aFormats, mpBrowser->bSearchRecursive );
 111     }
 112
 113     Application::PostUserEvent( LINK( mpProgress, SearchProgress, CleanUpHdl ), NULL, true );
 114 }
 115
 116
 117
 118 void SearchThread::ImplSearch( const INetURLObject& rStartURL,
 119                                const ::std::vector< OUString >& rFormats,
 120                                bool bRecursive )
 121 {
 122     {
 123         SolarMutexGuard aGuard;
 124
 125         mpProgress->SetDirectory( rStartURL );
 126         mpProgress->Sync();
 127     }
 128
 129     try
 130     {
 131         ::com::sun::star::uno::Reference< XCommandEnvironment > xEnv;
 132         Content aCnt( rStartURL.GetMainURL( INetURLObject::NO_DECODE ), xEnv, comphelper::getProcessComponentContext() );
 133         Sequence< OUString > aProps( 2 );
 134
 135         aProps.getArray()[ 0 ] = "IsFolder";
 136         aProps.getArray()[ 1 ] = "IsDocument";
 137         ::com::sun::star::uno::Reference< XResultSet > xResultSet(
 138             aCnt.createCursor( aProps, INCLUDE_FOLDERS_AND_DOCUMENTS ) );
 139
 140         if( xResultSet.is() )
 141         {
 142             ::com::sun::star::uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY_THROW );
 143             ::com::sun::star::uno::Reference< XRow > xRow( xResultSet, UNO_QUERY_THROW );
 144
 145             while( xResultSet->next() && schedule() )
 146             {
 147                 INetURLObject   aFoundURL( xContentAccess->queryContentIdentifierString() );
 148                 DBG_ASSERT( aFoundURL.GetProtocol() != INetProtocol::NotValid, "invalid URL" );
 149
 150                 bool bFolder = xRow->getBoolean( 1 ); // property "IsFolder"
 151                 if ( xRow->wasNull() )
 152                     bFolder = false;
 153
 154                 if( bRecursive && bFolder )
 155                     ImplSearch( aFoundURL, rFormats, true );
 156                 else
 157                 {
 158                     bool bDocument = xRow->getBoolean( 2 ); // property "IsDocument"
 159                     if ( xRow->wasNull() )
 160                         bDocument = false;
 161
 162                     if( bDocument )
 163                     {
 164                         GraphicDescriptor   aDesc( aFoundURL );
 165
 166                         if( ( aDesc.Detect() &&
 167                               ::std::find( rFormats.begin(),
 168                                            rFormats.end(),
 169                                            GraphicDescriptor::GetImportFormatShortName(
 170                                                aDesc.GetFileFormat() ).toAsciiLowerCase() )
 171                               != rFormats.end() ) ||
 172                             ::std::find( rFormats.begin(),
 173                                          rFormats.end(),
 174                                          aFoundURL.GetExtension().toAsciiLowerCase() )
 175                             != rFormats.end() )
 176                         {
 177                             SolarMutexGuard aGuard;
 178
 179                             mpBrowser->aFoundList.push_back(
 180                                 aFoundURL.GetMainURL( INetURLObject::NO_DECODE )
 181                             );
 182                             mpBrowser->m_pLbxFound->InsertEntry(
 183                                 GetReducedString( aFoundURL, 50 ),
 184                                 (sal_uInt16) mpBrowser->aFoundList.size() - 1 );
 185                         }
 186                     }
 187                 }
 188             }
 189         }
 190     }
 191     catch (const ContentCreationException&)
 192     {
 193     }
 194     catch (const ::com::sun::star::uno::RuntimeException&)
 195     {
 196     }
 197     catch (const ::com::sun::star::uno::Exception&)
 198     {
 199     }
 200 }
 201
 202
 203 // - SearchProgress -
 204
 205
 206 SearchProgress::SearchProgress( vcl::Window* pParent, const INetURLObject& rStartURL )
 207     : ModalDialog(pParent, "GallerySearchProgress", "cui/ui/gallerysearchprogress.ui")
 208     , parent_(pParent)
 209     , startUrl_(rStartURL)
 210 {
 211     get(m_pFtSearchDir, "dir");
 212     get(m_pFtSearchType, "file");
 213     m_pFtSearchType->set_width_request(m_pFtSearchType->get_preferred_size().Width());
 214     get(m_pBtnCancel, "cancel");
 215     m_pBtnCancel->SetClickHdl( LINK( this, SearchProgress, ClickCancelBtn ) );
 216 }
 217
 218 SearchProgress::~SearchProgress()
 219 {
 220     disposeOnce();
 221 }
 222
 223 void SearchProgress::dispose()
 224 {
 225     m_pFtSearchDir.clear();
 226     m_pFtSearchType.clear();
 227     m_pBtnCancel.clear();
 228     parent_.clear();
 229     ModalDialog::dispose();
 230 }
 231
 232
 233 void SearchProgress::Terminate()
 234 {
 235     if (maSearchThread.is())
 236         maSearchThread->terminate();
 237 }
 238
 239
 240
 241 IMPL_LINK_NOARG(SearchProgress, ClickCancelBtn)
 242 {
 243     Terminate();
 244     return 0L;
 245 }
 246
 247
 248
 249 IMPL_LINK_NOARG(SearchProgress, CleanUpHdl)
 250 {
 251     if (maSearchThread.is())
 252         maSearchThread->join();
 253
 254     EndDialog( RET_OK );
 255
 256     disposeOnce();
 257     return 0L;
 258 }
 259
 260
 261
 262 short SearchProgress::Execute()
 263 {
 264     OSL_FAIL( "SearchProgress cannot be executed via Dialog::Execute!\n"
 265                "It creates a thread that will call back to VCL apartment => deadlock!\n"
 266                "Use Dialog::StartExecuteModal to execute the dialog!" );
 267     return RET_CANCEL;
 268 }
 269
 270
 271
 272 void SearchProgress::StartExecuteModal( const Link<>& rEndDialogHdl )
 273 {
 274     assert(!maSearchThread.is());
 275     maSearchThread = new SearchThread(
 276         this, static_cast< TPGalleryThemeProperties * >(parent_.get()), startUrl_);
 277     maSearchThread->launch();
 278     ModalDialog::StartExecuteModal( rEndDialogHdl );
 279 }
 280
 281
 282 // - TakeThread -
 283
 284
 285 TakeThread::TakeThread(
 286     TakeProgress* pProgess,
 287     TPGalleryThemeProperties* pBrowser,
 288     TokenList_impl& rTakenList
 289 ) :
 290     Thread      ( "cuiTakeThread" ),
 291     mpProgress  ( pProgess ),
 292     mpBrowser   ( pBrowser ),
 293     mrTakenList ( rTakenList )
 294 {
 295 }
 296
 297
 298
 299 TakeThread::~TakeThread()
 300 {
 301 }
 302
 303
 304
 305 void TakeThread::execute()
 306 {
 307     INetURLObject       aURL;
 308     sal_uInt16          nEntries;
 309     GalleryTheme*       pThm = mpBrowser->GetXChgData()->pTheme;
 310     sal_uInt16          nPos;
 311     GalleryProgress*    pStatusProgress;
 312
 313     {
 314         SolarMutexGuard aGuard;
 315         pStatusProgress = new GalleryProgress;
 316         nEntries = mpBrowser->bTakeAll ? mpBrowser->m_pLbxFound->GetEntryCount() : mpBrowser->m_pLbxFound->GetSelectEntryCount();
 317         pThm->LockBroadcaster();
 318     }
 319
 320     for( sal_uInt16 i = 0; i < nEntries && schedule(); i++ )
 321     {
 322         if( mpBrowser->bTakeAll )
 323             aURL = INetURLObject( mpBrowser->aFoundList[ nPos = i ] );
 324         else
 325             aURL = INetURLObject( mpBrowser->aFoundList[ nPos = mpBrowser->m_pLbxFound->GetSelectEntryPos( i ) ]);
 326
 327         mrTakenList.push_back( (sal_uLong)nPos );
 328
 329         {
 330             SolarMutexGuard aGuard;
 331
 332             mpProgress->SetFile( aURL );
 333             pStatusProgress->Update( i, nEntries - 1 );
 334             mpProgress->Sync();
 335             pThm->InsertURL( aURL );
 336         }
 337     }
 338
 339     {
 340         SolarMutexGuard aGuard;
 341
 342         pThm->UnlockBroadcaster();
 343         delete pStatusProgress;
 344     }
 345
 346     Application::PostUserEvent( LINK( mpProgress, TakeProgress, CleanUpHdl ), NULL, true );
 347 }
 348
 349 // - TakeProgress -
 350 TakeProgress::TakeProgress(vcl::Window* pWindow)
 351     : ModalDialog(pWindow, "GalleryApplyProgress",
 352         "cui/ui/galleryapplyprogress.ui")
 353     , window_(pWindow)
 354 {
 355     get(m_pFtTakeFile, "file");
 356     get(m_pBtnCancel, "cancel");
 357
 358     m_pBtnCancel->SetClickHdl( LINK( this, TakeProgress, ClickCancelBtn ) );
 359 }
 360
 361 TakeProgress::~TakeProgress()
 362 {
 363     disposeOnce();
 364 }
 365
 366 void TakeProgress::dispose()
 367 {
 368     m_pFtTakeFile.clear();
 369     m_pBtnCancel.clear();
 370     window_.clear();
 371     ModalDialog::dispose();
 372 }
 373
 374 void TakeProgress::Terminate()
 375 {
 376     if (maTakeThread.is())
 377         maTakeThread->terminate();
 378 }
 379
 380 IMPL_LINK_NOARG(TakeProgress, ClickCancelBtn)
 381 {
 382     Terminate();
 383     return 0L;
 384 }
 385
 386 IMPL_LINK_NOARG(TakeProgress, CleanUpHdl)
 387 {
 388     if (maTakeThread.is())
 389         maTakeThread->join();
 390
 391     TPGalleryThemeProperties*   mpBrowser = static_cast<TPGalleryThemeProperties*>( GetParent() );
 392     ::std::vector<bool, std::allocator<bool> >           aRemoveEntries( mpBrowser->aFoundList.size(), false );
 393     ::std::vector< OUString >   aRemainingVector;
 394     sal_uInt32                  i, nCount;
 395
 396     GetParent()->EnterWait();
 397     mpBrowser->m_pLbxFound->SetUpdateMode( false );
 398     mpBrowser->m_pLbxFound->SetNoSelection();
 399
 400     // mark all taken positions in aRemoveEntries
 401     for( i = 0, nCount = maTakenList.size(); i < nCount; ++i )
 402         aRemoveEntries[ maTakenList[ i ] ] = true;
 403     maTakenList.clear();
 404
 405     // refill found list
 406     for( i = 0, nCount = aRemoveEntries.size(); i < nCount; ++i )
 407         if( !aRemoveEntries[ i ] )
 408             aRemainingVector.push_back( mpBrowser->aFoundList[i] );
 409
 410     mpBrowser->aFoundList.clear();
 411
 412     for( i = 0, nCount = aRemainingVector.size(); i < nCount; ++i )
 413         mpBrowser->aFoundList.push_back( aRemainingVector[ i ] );
 414
 415     aRemainingVector.clear();
 416
 417     // refill list box
 418     for( i = 0, nCount = aRemoveEntries.size(); i < nCount; ++i )
 419         if( !aRemoveEntries[ i ] )
 420             aRemainingVector.push_back( mpBrowser->m_pLbxFound->GetEntry( (sal_uInt16) i ) );
 421
 422     mpBrowser->m_pLbxFound->Clear();
 423
 424     for( i = 0, nCount = aRemainingVector.size(); i < nCount; ++i )
 425         mpBrowser->m_pLbxFound->InsertEntry( aRemainingVector[ i ] );
 426
 427     aRemainingVector.clear();
 428
 429     mpBrowser->m_pLbxFound->SetUpdateMode( true );
 430     mpBrowser->SelectFoundHdl( NULL );
 431     GetParent()->LeaveWait();
 432
 433     EndDialog( RET_OK );
 434     disposeOnce();
 435     return 0L;
 436 }
 437
 438
 439
 440 short TakeProgress::Execute()
 441 {
 442     OSL_FAIL( "TakeProgress cannot be executed via Dialog::Execute!\n"
 443                "It creates a thread that will call back to VCL apartment => deadlock!\n"
 444                "Use Dialog::StartExecuteModal to execute the dialog!" );
 445     return RET_CANCEL;
 446 }
 447
 448
 449
 450 void TakeProgress::StartExecuteModal( const Link<>& rEndDialogHdl )
 451 {
 452     assert(!maTakeThread.is());
 453     maTakeThread = new TakeThread(
 454         this, static_cast< TPGalleryThemeProperties * >(window_.get()), maTakenList);
 455     maTakeThread->launch();
 456     ModalDialog::StartExecuteModal( rEndDialogHdl );
 457 }
 458
 459
 460 // - ActualizeProgress -
 461 ActualizeProgress::ActualizeProgress(vcl::Window* pWindow, GalleryTheme* pThm)
 462     : ModalDialog(pWindow, "GalleryUpdateProgress",
 463         "cui/ui/galleryupdateprogress.ui")
 464     , pIdle(NULL)
 465     , pTheme(pThm)
 466 {
 467     get(m_pFtActualizeFile, "file");
 468     get(m_pBtnCancel, "cancel");
 469     m_pBtnCancel->SetClickHdl( LINK( this, ActualizeProgress, ClickCancelBtn ) );
 470 }
 471
 472 ActualizeProgress::~ActualizeProgress()
 473 {
 474     disposeOnce();
 475 }
 476
 477 void ActualizeProgress::dispose()
 478 {
 479     m_pFtActualizeFile.clear();
 480     m_pBtnCancel.clear();
 481     ModalDialog::dispose();
 482 }
 483
 484 short ActualizeProgress::Execute()
 485 {
 486     short nRet;
 487
 488     pIdle = new Idle;
 489     pIdle->SetIdleHdl( LINK( this, ActualizeProgress, TimeoutHdl ) );
 490     pIdle->SetPriority( SchedulerPriority::LOWEST );
 491     pIdle->Start();
 492
 493     nRet = ModalDialog::Execute();
 494
 495     return nRet;
 496 }
 497
 498
 499
 500 IMPL_LINK_NOARG(ActualizeProgress, ClickCancelBtn)
 501 {
 502     pTheme->AbortActualize();
 503     EndDialog( RET_OK );
 504
 505     return 0L;
 506 }
 507
 508
 509
 510 IMPL_LINK_TYPED( ActualizeProgress, TimeoutHdl, Idle*, _pTimer, void)
 511 {
 512     if ( _pTimer )
 513     {
 514         _pTimer->Stop();
 515         delete _pTimer;
 516     }
 517
 518     pTheme->Actualize( LINK( this, ActualizeProgress, ActualizeHdl ), &aStatusProgress );
 519     ClickCancelBtn( NULL );
 520 }
 521
 522
 523
 524 IMPL_LINK( ActualizeProgress, ActualizeHdl, INetURLObject*, pURL )
 525 {
 526     for( long i = 0; i < 128; i++ )
 527         Application::Reschedule();
 528
 529     Flush();
 530     Sync();
 531
 532     if( pURL )
 533     {
 534         m_pFtActualizeFile->SetText( GetReducedString( *pURL, 30 ) );
 535         m_pFtActualizeFile->Flush();
 536         m_pFtActualizeFile->Sync();
 537     }
 538
 539     return 0;
 540 }
 541
 542 TitleDialog::TitleDialog(vcl::Window* pParent, const OUString& rOldTitle)
 543     : ModalDialog(pParent, "GalleryTitleDialog", "cui/ui/gallerytitledialog.ui")
 544 {
 545     get(m_pEdit, "entry");
 546     m_pEdit->SetText( rOldTitle );
 547     m_pEdit->GrabFocus();
 548 }
 549
 550 TitleDialog::~TitleDialog()
 551 {
 552     disposeOnce();
 553 }
 554
 555 void TitleDialog::dispose()
 556 {
 557     m_pEdit.clear();
 558     ModalDialog::dispose();
 559 }
 560
 561
 562 // - GalleryIdDialog -
 563
 564
 565 GalleryIdDialog::GalleryIdDialog( vcl::Window* pParent, GalleryTheme* _pThm )
 566     : ModalDialog(pParent, "GalleryThemeIDDialog", "cui/ui/gallerythemeiddialog.ui")
 567     , pThm(_pThm )
 568 {
 569     get(m_pBtnOk, "ok");
 570     get(m_pLbResName, "entry");
 571
 572     m_pLbResName->InsertEntry( OUString( "!!! No Id !!!" ) );
 573
 574     GalleryTheme::InsertAllThemes(*m_pLbResName);
 575
 576     m_pLbResName->SelectEntryPos( (sal_uInt16) pThm->GetId() );
 577     m_pLbResName->GrabFocus();
 578
 579     m_pBtnOk->SetClickHdl( LINK( this, GalleryIdDialog, ClickOkHdl ) );
 580 }
 581
 582 GalleryIdDialog::~GalleryIdDialog()
 583 {
 584     disposeOnce();
 585 }
 586
 587 void GalleryIdDialog::dispose()
 588 {
 589     m_pBtnOk.clear();
 590     m_pLbResName.clear();
 591     ModalDialog::dispose();
 592 }
 593
 594 IMPL_LINK_NOARG(GalleryIdDialog, ClickOkHdl)
 595 {
 596     Gallery*    pGal = pThm->GetParent();
 597     const sal_uLong nId = GetId();
 598     bool        bDifferentThemeExists = false;
 599
 600     for( sal_uLong i = 0, nCount = pGal->GetThemeCount(); i < nCount && !bDifferentThemeExists; i++ )
 601     {
 602         const GalleryThemeEntry* pInfo = pGal->GetThemeInfo( i );
 603
 604         if( ( pInfo->GetId() == nId ) && ( pInfo->GetThemeName() != pThm->GetName() ) )
 605         {
 606             OUString aStr( CUI_RES( RID_SVXSTR_GALLERY_ID_EXISTS ) );
 607
 608             aStr += " (";
 609             aStr += pInfo->GetThemeName();
 610             aStr += ")";
 611
 612             ScopedVclPtrInstance< InfoBox > aBox( this, aStr );
 613             aBox->Execute();
 614             m_pLbResName->GrabFocus();
 615             bDifferentThemeExists = true;
 616         }
 617     }
 618
 619     if( !bDifferentThemeExists )
 620         EndDialog( RET_OK );
 621
 622     return 0L;
 623 }
 624
 625
 626
 627 // - GalleryThemeProperties -
 628
 629
 630 GalleryThemeProperties::GalleryThemeProperties(vcl::Window* pParent,
 631     ExchangeData* _pData, SfxItemSet* pItemSet)
 632     : SfxTabDialog( pParent, "GalleryThemeDialog",
 633         "cui/ui/gallerythemedialog.ui", pItemSet)
 634     , pData(_pData)
 635     , m_nGeneralPageId(0)
 636     , m_nFilesPageId(0)
 637 {
 638     m_nGeneralPageId = AddTabPage("general", TPGalleryThemeGeneral::Create, 0);
 639     m_nFilesPageId = AddTabPage("files", TPGalleryThemeProperties::Create, 0);
 640
 641     if( pData->pTheme->IsReadOnly() )
 642         RemoveTabPage(m_nFilesPageId);
 643
 644     OUString aText( GetText() );
 645
 646     aText += pData->pTheme->GetName();
 647
 648     if( pData->pTheme->IsReadOnly() )
 649         aText +=  CUI_RES( RID_SVXSTR_GALLERY_READONLY );
 650
 651     SetText( aText );
 652 }
 653
 654 void GalleryThemeProperties::PageCreated( sal_uInt16 nId, SfxTabPage &rPage )
 655 {
 656     if (nId == m_nGeneralPageId)
 657         static_cast<TPGalleryThemeGeneral&>( rPage ).SetXChgData( pData );
 658     else
 659         static_cast<TPGalleryThemeProperties&>( rPage ).SetXChgData( pData );
 660 }
 661
 662 // - TPGalleryThemeGeneral -
 663 TPGalleryThemeGeneral::TPGalleryThemeGeneral(vcl::Window* pParent, const SfxItemSet& rSet)
 664     : SfxTabPage(pParent, "GalleryGeneralPage",
 665         "cui/ui/gallerygeneralpage.ui", &rSet)
 666     , pData(NULL)
 667 {
 668     get(m_pFiMSImage, "image");
 669     get(m_pEdtMSName, "name");
 670     get(m_pFtMSShowType, "type");
 671     get(m_pFtMSShowPath, "location");
 672     get(m_pFtMSShowContent, "contents");
 673     get(m_pFtMSShowChangeDate, "modified");
 674 }
 675
 676 TPGalleryThemeGeneral::~TPGalleryThemeGeneral()
 677 {
 678     disposeOnce();
 679 }
 680
 681 void TPGalleryThemeGeneral::dispose()
 682 {
 683     m_pFiMSImage.clear();
 684     m_pEdtMSName.clear();
 685     m_pFtMSShowType.clear();
 686     m_pFtMSShowPath.clear();
 687     m_pFtMSShowContent.clear();
 688     m_pFtMSShowChangeDate.clear();
 689     SfxTabPage::dispose();
 690 }
 691
 692 void TPGalleryThemeGeneral::SetXChgData( ExchangeData* _pData )
 693 {
 694     pData = _pData;
 695
 696     GalleryTheme*       pThm = pData->pTheme;
 697     OUString            aOutStr( OUString::number(pThm->GetObjectCount()) );
 698     OUString            aObjStr( CUI_RES( RID_SVXSTR_GALLERYPROPS_OBJECT ) );
 699     OUString            aAccess;
 700     OUString            aType( SVX_RES( RID_SVXSTR_GALLERYPROPS_GALTHEME ) );
 701     bool            bReadOnly = pThm->IsReadOnly();
 702
 703     m_pEdtMSName->SetText( pThm->GetName() );
 704     m_pEdtMSName->SetReadOnly( bReadOnly );
 705
 706     if( bReadOnly )
 707         m_pEdtMSName->Disable();
 708     else
 709         m_pEdtMSName->Enable();
 710
 711     if( pThm->IsReadOnly() )
 712         aType += CUI_RES( RID_SVXSTR_GALLERY_READONLY );
 713
 714     m_pFtMSShowType->SetText( aType );
 715     m_pFtMSShowPath->SetText( pThm->GetSdgURL().GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS ) );
 716
 717     // singular or plural?
 718     if ( 1 == pThm->GetObjectCount() )
 719         aObjStr = aObjStr.getToken( 0, ';' );
 720     else
 721         aObjStr = aObjStr.getToken( 1, ';' );
 722
 723     aOutStr += " " + aObjStr;
 724
 725     m_pFtMSShowContent->SetText( aOutStr );
 726
 727     // get locale wrapper (singleton)
 728     const SvtSysLocale aSysLocale;
 729     const LocaleDataWrapper&    aLocaleData = aSysLocale.GetLocaleData();
 730
 731     // ChangeDate/Time
 732     aAccess = aLocaleData.getDate( pData->aThemeChangeDate ) + ", " + aLocaleData.getTime( pData->aThemeChangeTime );
 733     m_pFtMSShowChangeDate->SetText( aAccess );
 734
 735     // set image
 736     sal_uInt16 nId;
 737
 738     if( pThm->IsReadOnly() )
 739         nId = RID_SVXBMP_THEME_READONLY_BIG;
 740     else if( pThm->IsDefault() )
 741         nId = RID_SVXBMP_THEME_DEFAULT_BIG;
 742     else
 743         nId = RID_SVXBMP_THEME_NORMAL_BIG;
 744
 745     m_pFiMSImage->SetImage( Image( Bitmap( CUI_RES( nId ) ), COL_LIGHTMAGENTA ) );
 746 }
 747
 748
 749
 750 bool TPGalleryThemeGeneral::FillItemSet( SfxItemSet* /*rSet*/ )
 751 {
 752     pData->aEditedTitle = m_pEdtMSName->GetText();
 753     return true;
 754 }
 755
 756
 757
 758 VclPtr<SfxTabPage> TPGalleryThemeGeneral::Create( vcl::Window* pParent, const SfxItemSet* rSet )
 759 {
 760     return VclPtr<TPGalleryThemeGeneral>::Create( pParent, *rSet );
 761 }
 762
 763 // - TPGalleryThemeProperties -
 764 TPGalleryThemeProperties::TPGalleryThemeProperties( vcl::Window* pWindow, const SfxItemSet& rSet )
 765     : SfxTabPage(pWindow, "GalleryFilesPage", "cui/ui/galleryfilespage.ui", &rSet)
 766     , pData(NULL)
 767     , nCurFilterPos(0)
 768     , nFirstExtFilterPos(0)
 769     , bEntriesFound(false)
 770     , bInputAllowed(true)
 771     , bTakeAll(false)
 772     , bSearchRecursive(false)
 773     , xDialogListener(new ::svt::DialogClosedListener())
 774 {
 775     get(m_pCbbFileType, "filetype");
 776     get(m_pLbxFound, "files");
 777     Size aSize(LogicToPixel(Size(172, 156), MAP_APPFONT));
 778     m_pLbxFound->set_width_request(aSize.Width());
 779     m_pLbxFound->set_height_request(aSize.Height());
 780     m_pLbxFound->EnableMultiSelection(true);
 781     get(m_pBtnSearch, "findfiles");
 782     get(m_pBtnTake, "add");
 783     get(m_pBtnTakeAll, "addall");
 784     get(m_pCbxPreview, "preview");
 785     get(m_pWndPreview, "image");
 786
 787     xDialogListener->SetDialogClosedLink( LINK( this, TPGalleryThemeProperties, DialogClosedHdl ) );
 788 }
 789
 790 void TPGalleryThemeProperties::SetXChgData( ExchangeData* _pData )
 791 {
 792     pData = _pData;
 793
 794     aPreviewTimer.SetTimeoutHdl( LINK( this, TPGalleryThemeProperties, PreviewTimerHdl ) );
 795     aPreviewTimer.SetTimeout( 500 );
 796     m_pBtnSearch->SetClickHdl(LINK(this, TPGalleryThemeProperties, ClickSearchHdl));
 797     m_pBtnTake->SetClickHdl(LINK(this, TPGalleryThemeProperties, ClickTakeHdl));
 798     m_pBtnTakeAll->SetClickHdl(LINK(this, TPGalleryThemeProperties, ClickTakeAllHdl));
 799     m_pCbxPreview->SetClickHdl(LINK(this, TPGalleryThemeProperties, ClickPreviewHdl));
 800     m_pCbbFileType->SetSelectHdl(LINK(this, TPGalleryThemeProperties, SelectFileTypeHdl));
 801     m_pCbbFileType->EnableDDAutoWidth( false );
 802     m_pLbxFound->SetDoubleClickHdl(LINK(this, TPGalleryThemeProperties, DClickFoundHdl));
 803     m_pLbxFound->SetSelectHdl(LINK(this, TPGalleryThemeProperties, SelectFoundHdl));
 804     m_pLbxFound->InsertEntry(OUString(CUI_RES(RID_SVXSTR_GALLERY_NOFILES)));
 805     m_pLbxFound->Show();
 806
 807     FillFilterList();
 808
 809     m_pBtnTake->Enable();
 810     m_pBtnTakeAll->Disable();
 811     m_pCbxPreview->Disable();
 812 }
 813
 814
 815
 816 void TPGalleryThemeProperties::StartSearchFiles( const OUString& _rFolderURL, short _nDlgResult )
 817 {
 818     if ( RET_OK == _nDlgResult )
 819     {
 820         aURL = INetURLObject( _rFolderURL );
 821         bSearchRecursive = true;    // UI choice no longer possible, windows file picker allows no user controls
 822         SearchFiles();
 823     }
 824
 825     nCurFilterPos = m_pCbbFileType->GetEntryPos( m_pCbbFileType->GetText() );
 826 }
 827
 828
 829
 830 TPGalleryThemeProperties::~TPGalleryThemeProperties()
 831 {
 832     disposeOnce();
 833 }
 834
 835 void TPGalleryThemeProperties::dispose()
 836 {
 837     xMediaPlayer.clear();
 838     xDialogListener.clear();
 839
 840     for ( size_t i = 0, n = aFilterEntryList.size(); i < n; ++i ) {
 841         delete aFilterEntryList[ i ];
 842     }
 843     aFilterEntryList.clear();
 844
 845     m_pCbbFileType.clear();
 846     m_pLbxFound.clear();
 847     m_pBtnSearch.clear();
 848     m_pBtnTake.clear();
 849     m_pBtnTakeAll.clear();
 850     m_pCbxPreview.clear();
 851     m_pWndPreview.clear();
 852     SfxTabPage::dispose();
 853 }
 854
 855 VclPtr<SfxTabPage> TPGalleryThemeProperties::Create( vcl::Window* pParent, const SfxItemSet* rSet )
 856 {
 857     return VclPtr<TPGalleryThemeProperties>::Create( pParent, *rSet );
 858 }
 859
 860 OUString TPGalleryThemeProperties::addExtension( const OUString& _rDisplayText, const OUString& _rExtension )
 861 {
 862     OUString sAllFilter( "(*.*)" );
 863     OUString sOpenBracket( " (" );
 864     OUString sCloseBracket( ")" );
 865     OUString sRet = _rDisplayText;
 866
 867     if ( sRet.indexOf( sAllFilter ) == -1 )
 868     {
 869         OUString sExt = _rExtension;
 870         sRet += sOpenBracket;
 871         sRet += sExt;
 872         sRet += sCloseBracket;
 873     }
 874     return sRet;
 875 }
 876
 877
 878
 879 void TPGalleryThemeProperties::FillFilterList()
 880 {
 881     GraphicFilter &rFilter = GraphicFilter::GetGraphicFilter();
 882     OUString            aExt;
 883     OUString            aName;
 884     FilterEntry*        pFilterEntry;
 885     sal_uInt16          i, nKeyCount;
 886
 887     // graphic filters
 888     for( i = 0, nKeyCount = rFilter.GetImportFormatCount(); i < nKeyCount; i++ )
 889     {
 890         aExt = rFilter.GetImportFormatShortName( i );
 891         aName = rFilter.GetImportFormatName( i );
 892         size_t entryIndex = 0;
 893         FilterEntry* pTestEntry = aFilterEntryList.empty() ? NULL : aFilterEntryList[ entryIndex ];
 894         bool bInList = false;
 895
 896         OUString aExtensions;
 897         int j = 0;
 898         OUString sWildcard;
 899         while( true )
 900         {
 901             sWildcard = rFilter.GetImportWildcard( i, j++ );
 902             if ( sWildcard.isEmpty() )
 903                 break;
 904             if ( aExtensions.indexOf( sWildcard ) == -1 )
 905             {
 906                 if ( !aExtensions.isEmpty() )
 907                     aExtensions += ";";
 908                 aExtensions += sWildcard;
 909             }
 910         }
 911         aName = addExtension( aName, aExtensions );
 912
 913         while( pTestEntry )
 914         {
 915             if ( pTestEntry->aFilterName == aExt )
 916             {
 917                 bInList = true;
 918                 break;
 919             }
 920             pTestEntry = ( ++entryIndex < aFilterEntryList.size() )
 921                        ? aFilterEntryList[ entryIndex ] : NULL;
 922         }
 923         if ( !bInList )
 924         {
 925             pFilterEntry = new FilterEntry;
 926             pFilterEntry->aFilterName = aExt;
 927             size_t pos = m_pCbbFileType->InsertEntry( aName );
 928             if ( pos < aFilterEntryList.size() ) {
 929                 aFilterEntryList.insert( aFilterEntryList.begin() + pos, pFilterEntry );
 930             } else {
 931                 aFilterEntryList.push_back( pFilterEntry );
 932             }
 933         }
 934     }
 935
 936     // media filters
 937     static const char aWildcard[] = "*.";
 938     ::avmedia::FilterNameVector     aFilters;
 939     ::avmedia::MediaWindow::getMediaFilters( aFilters );
 940
 941     for( unsigned long l = 0; l < aFilters.size(); ++l )
 942     {
 943         for( sal_Int32 nIndex = 0; nIndex >= 0; )
 944         {
 945             OUString aFilterWildcard( aWildcard );
 946
 947             pFilterEntry = new FilterEntry;
 948             pFilterEntry->aFilterName = aFilters[ l ].second.getToken( 0, ';', nIndex );
 949             nFirstExtFilterPos = m_pCbbFileType->InsertEntry(
 950                 addExtension(
 951                     aFilters[ l ].first,
 952                     aFilterWildcard += pFilterEntry->aFilterName
 953                 )
 954             );
 955             if ( nFirstExtFilterPos < aFilterEntryList.size() ) {
 956                 aFilterEntryList.insert(
 957                     aFilterEntryList.begin() + nFirstExtFilterPos,
 958                     pFilterEntry
 959                 );
 960             } else {
 961                 aFilterEntryList.push_back( pFilterEntry );
 962             }
 963         }
 964     }
 965
 966     // 'All' filters
 967     OUString aExtensions;
 968
 969     // graphic filters
 970     for ( i = 0; i < nKeyCount; ++i )
 971     {
 972         int j = 0;
 973         OUString sWildcard;
 974         while( true )
 975         {
 976             sWildcard = rFilter.GetImportWildcard( i, j++ );
 977             if ( sWildcard.isEmpty() )
 978                 break;
 979             if ( aExtensions.indexOf( sWildcard ) == -1 )
 980             {
 981                 if ( !aExtensions.isEmpty() )
 982                     aExtensions += ";";
 983
 984                 aExtensions += sWildcard;
 985             }
 986         }
 987     }
 988
 989     // media filters
 990     for( unsigned long k = 0; k < aFilters.size(); ++k )
 991     {
 992         for( sal_Int32 nIndex = 0; nIndex >= 0; )
 993         {
 994             if ( !aExtensions.isEmpty() )
 995                 aExtensions += ";";
 996             aExtensions += aWildcard + aFilters[ k ].second.getToken( 0, ';', nIndex );
 997         }
 998      }
 999
1000 #if defined(WNT)
1001     if (aExtensions.getLength() > 240)
1002         aExtensions = "*.*";
1003 #endif
1004
1005     pFilterEntry = new FilterEntry;
1006     pFilterEntry->aFilterName = CUI_RESSTR(RID_SVXSTR_GALLERY_ALLFILES);
1007     pFilterEntry->aFilterName = addExtension( pFilterEntry->aFilterName, aExtensions );
1008     size_t pos = m_pCbbFileType->InsertEntry( pFilterEntry->aFilterName, 0 );
1009     if ( pos < aFilterEntryList.size() ) {
1010         aFilterEntryList.insert( aFilterEntryList.begin() + pos, pFilterEntry );
1011     } else {
1012         aFilterEntryList.push_back( pFilterEntry );
1013     }
1014     m_pCbbFileType->SetText( pFilterEntry->aFilterName );
1015 }
1016
1017
1018
1019 IMPL_LINK_NOARG(TPGalleryThemeProperties, SelectFileTypeHdl)
1020 {
1021     OUString aText( m_pCbbFileType->GetText() );
1022
1023     if( bInputAllowed && ( aLastFilterName != aText ) )
1024     {
1025         aLastFilterName = aText;
1026
1027         if( ScopedVclPtrInstance<MessageDialog>::Create( this, "QueryUpdateFileListDialog","cui/ui/queryupdategalleryfilelistdialog.ui" )->Execute() == RET_YES )
1028             SearchFiles();
1029     }
1030
1031     return 0L;
1032 }
1033
1034
1035
1036 void TPGalleryThemeProperties::SearchFiles()
1037 {
1038     SearchProgress* pProgress = VclPtr<SearchProgress>::Create( this, aURL );
1039
1040     aFoundList.clear();
1041     m_pLbxFound->Clear();
1042
1043     pProgress->SetFileType( m_pCbbFileType->GetText() );
1044     pProgress->SetDirectory( INetURLObject() );
1045     pProgress->Update();
1046
1047     pProgress->StartExecuteModal( LINK( this, TPGalleryThemeProperties, EndSearchProgressHdl ) );
1048 }
1049
1050
1051
1052 IMPL_LINK_NOARG(TPGalleryThemeProperties, ClickSearchHdl)
1053 {
1054     if( bInputAllowed )
1055     {
1056         try
1057         {
1058             // setup folder picker
1059             com::sun::star::uno::Reference< XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
1060             xFolderPicker = FolderPicker::create(xContext);
1061
1062             OUString  aDlgPathName( SvtPathOptions().GetGraphicPath() );
1063             xFolderPicker->setDisplayDirectory(aDlgPathName);
1064
1065             aPreviewTimer.Stop();
1066
1067             com::sun::star::uno::Reference< XAsynchronousExecutableDialog > xAsyncDlg( xFolderPicker, UNO_QUERY );
1068             if ( xAsyncDlg.is() )
1069                 xAsyncDlg->startExecuteModal( xDialogListener.get() );
1070             else
1071             {
1072                 if( xFolderPicker->execute() == RET_OK )
1073                 {
1074                     aURL = INetURLObject( xFolderPicker->getDirectory() );
1075                     bSearchRecursive = true;    // UI choice no longer possible, windows file picker allows no user controls
1076                     SearchFiles();
1077                 }
1078
1079                 nCurFilterPos = m_pCbbFileType->GetEntryPos( m_pCbbFileType->GetText() );
1080             }
1081         }
1082         catch (const IllegalArgumentException&)
1083         {
1084             OSL_FAIL( "Folder picker failed with illegal arguments" );
1085         }
1086     }
1087
1088     return 0L;
1089 }
1090
1091
1092
1093 void TPGalleryThemeProperties::TakeFiles()
1094 {
1095     if( m_pLbxFound->GetSelectEntryCount() || ( bTakeAll && bEntriesFound ) )
1096     {
1097         VclPtrInstance<TakeProgress> pTakeProgress( this );
1098         pTakeProgress->Update();
1099
1100         pTakeProgress->StartExecuteModal(
1101             Link<>() /* no postprocessing needed, pTakeProgress
1102                       will be disposed in TakeProgress::CleanupHdl */ );
1103     }
1104 }
1105
1106
1107
1108 IMPL_LINK_NOARG(TPGalleryThemeProperties, ClickPreviewHdl)
1109 {
1110     if ( bInputAllowed )
1111     {
1112         aPreviewTimer.Stop();
1113         aPreviewString.clear();
1114
1115         if( !m_pCbxPreview->IsChecked() )
1116         {
1117             xMediaPlayer.clear();
1118             m_pWndPreview->SetGraphic( Graphic() );
1119             m_pWndPreview->Invalidate();
1120         }
1121         else
1122             DoPreview();
1123     }
1124
1125     return 0;
1126 }
1127
1128
1129
1130 void TPGalleryThemeProperties::DoPreview()
1131 {
1132     OUString aString( m_pLbxFound->GetSelectEntry() );
1133
1134     if( aString != aPreviewString )
1135     {
1136         INetURLObject   _aURL( aFoundList[ m_pLbxFound->GetEntryPos( aString ) ] );
1137         bInputAllowed = false;
1138
1139         if ( !m_pWndPreview->SetGraphic( _aURL ) )
1140         {
1141             GetParent()->LeaveWait();
1142             ErrorHandler::HandleError( ERRCODE_IO_NOTEXISTSPATH );
1143             GetParent()->EnterWait();
1144         }
1145         else if( ::avmedia::MediaWindow::isMediaURL( _aURL.GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS ), "" ) )
1146         {
1147             xMediaPlayer = ::avmedia::MediaWindow::createPlayer( _aURL.GetMainURL( INetURLObject::NO_DECODE ), "" );
1148             if( xMediaPlayer.is() )
1149                 xMediaPlayer->start();
1150         }
1151
1152         bInputAllowed = true;
1153         aPreviewString = aString;
1154     }
1155 }
1156
1157
1158
1159 IMPL_LINK_NOARG(TPGalleryThemeProperties, ClickTakeHdl)
1160 {
1161     if( bInputAllowed )
1162     {
1163         aPreviewTimer.Stop();
1164
1165         if( !m_pLbxFound->GetSelectEntryCount() || !bEntriesFound )
1166         {
1167             SvxOpenGraphicDialog aDlg("Gallery");
1168             aDlg.EnableLink(false);
1169             aDlg.AsLink(false);
1170
1171             if( !aDlg.Execute() )
1172                 pData->pTheme->InsertURL( INetURLObject( aDlg.GetPath() ) );
1173         }
1174         else
1175         {
1176             bTakeAll = false;
1177             TakeFiles();
1178         }
1179     }
1180
1181     return 0L;
1182 }
1183
1184
1185
1186 IMPL_LINK_NOARG(TPGalleryThemeProperties, ClickTakeAllHdl)
1187 {
1188     if( bInputAllowed )
1189     {
1190         aPreviewTimer.Stop();
1191         bTakeAll = true;
1192         TakeFiles();
1193     }
1194
1195     return 0L;
1196 }
1197
1198
1199
1200 IMPL_LINK_NOARG(TPGalleryThemeProperties, SelectFoundHdl)
1201 {
1202     if( bInputAllowed )
1203     {
1204         bool bPreviewPossible = false;
1205
1206         aPreviewTimer.Stop();
1207
1208         if( bEntriesFound )
1209         {
1210             if( m_pLbxFound->GetSelectEntryCount() == 1 )
1211             {
1212                 m_pCbxPreview->Enable();
1213                 bPreviewPossible = true;
1214             }
1215             else
1216                 m_pCbxPreview->Disable();
1217
1218             if( !aFoundList.empty() )
1219                 m_pBtnTakeAll->Enable();
1220             else
1221                 m_pBtnTakeAll->Disable();
1222         }
1223
1224         if( bPreviewPossible && m_pCbxPreview->IsChecked() )
1225             aPreviewTimer.Start();
1226     }
1227
1228     return 0;
1229 }
1230
1231
1232
1233 IMPL_LINK_NOARG(TPGalleryThemeProperties, DClickFoundHdl)
1234 {
1235     if( bInputAllowed )
1236     {
1237         aPreviewTimer.Stop();
1238
1239         return (m_pLbxFound->GetSelectEntryCount() == 1 && bEntriesFound) ?
1240             ClickTakeHdl(NULL) : 0;
1241     }
1242     else
1243         return 0;
1244 }
1245
1246
1247
1248 IMPL_LINK_NOARG_TYPED(TPGalleryThemeProperties, PreviewTimerHdl, Timer *, void)
1249 {
1250     aPreviewTimer.Stop();
1251     DoPreview();
1252 }
1253
1254
1255
1256 IMPL_LINK_NOARG(TPGalleryThemeProperties, EndSearchProgressHdl)
1257 {
1258   if( !aFoundList.empty() )
1259   {
1260       m_pLbxFound->SelectEntryPos( 0 );
1261       m_pBtnTakeAll->Enable();
1262       m_pCbxPreview->Enable();
1263       bEntriesFound = true;
1264   }
1265   else
1266   {
1267       m_pLbxFound->InsertEntry( OUString( CUI_RES( RID_SVXSTR_GALLERY_NOFILES ) ) );
1268       m_pBtnTakeAll->Disable();
1269       m_pCbxPreview->Disable();
1270       bEntriesFound = false;
1271   }
1272   return 0L;
1273 }
1274
1275
1276
1277 IMPL_LINK( TPGalleryThemeProperties, DialogClosedHdl, ::com::sun::star::ui::dialogs::DialogClosedEvent*, pEvt )
1278 {
1279     DBG_ASSERT( xFolderPicker.is(), "TPGalleryThemeProperties::DialogClosedHdl(): no folder picker" );
1280
1281     OUString sURL = xFolderPicker->getDirectory();
1282     StartSearchFiles( sURL, pEvt->DialogResult );
1283
1284     return 0L;
1285 }
1286
1287 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */