cui/source/options/optsave.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 <svl/eitem.hxx>
  21 #include <svl/intitem.hxx>
  22
  23 #include "optsave.hrc"
  24 #include <cuires.hrc>
  25
  26 #include "optsave.hxx"
  27 #include <dialmgr.hxx>
  28 #include <comphelper/processfactory.hxx>
  29 #include <unotools/moduleoptions.hxx>
  30 #include <unotools/saveopt.hxx>
  31 #include <comphelper/sequence.hxx>
  32 #include <comphelper/sequenceashashmap.hxx>
  33 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  34 #include <com/sun/star/container/XNameContainer.hpp>
  35 #include <com/sun/star/container/XContainerQuery.hpp>
  36 #include <com/sun/star/container/XEnumeration.hpp>
  37 #include <com/sun/star/beans/PropertyValue.hpp>
  38 #include <com/sun/star/util/XFlushable.hpp>
  39 #include <sfx2/docfilt.hxx>
  40 #include <svtools/stdctrl.hxx>
  41 #include <vcl/fixed.hxx>
  42 #include <unotools/configitem.hxx>
  43 #include <unotools/optionsdlg.hxx>
  44
  45 #include <vcl/msgbox.hxx>
  46
  47 using namespace com::sun::star::uno;
  48 using namespace com::sun::star::util;
  49 using namespace com::sun::star::lang;
  50 using namespace com::sun::star::beans;
  51 using namespace com::sun::star::container;
  52 using namespace comphelper;
  53
  54 #define CFG_PAGE_AND_GROUP          OUString("General"), OUString("LoadSave")
  55
  56
  57
  58 struct SvxSaveTabPage_Impl
  59 {
  60     Reference< XNameContainer > xFact;
  61     Sequence< OUString >        aFilterArr[APP_COUNT];
  62     Sequence< sal_Bool >        aAlienArr[APP_COUNT];
  63     Sequence< sal_Bool >        aODFArr[APP_COUNT];
  64     Sequence< OUString >        aUIFilterArr[APP_COUNT];
  65     OUString                    aDefaultArr[APP_COUNT];
  66     sal_Bool                    aDefaultReadonlyArr[APP_COUNT];
  67     bool                    bInitialized;
  68
  69     SvxSaveTabPage_Impl();
  70     ~SvxSaveTabPage_Impl();
  71 };
  72
  73 SvxSaveTabPage_Impl::SvxSaveTabPage_Impl() : bInitialized( false )
  74 {
  75 }
  76
  77 SvxSaveTabPage_Impl::~SvxSaveTabPage_Impl()
  78 {
  79 }
  80
  81 // class SvxSaveTabPage --------------------------------------------------
  82
  83 SfxSaveTabPage::SfxSaveTabPage( vcl::Window* pParent, const SfxItemSet& rCoreSet ) :
  84     SfxTabPage( pParent, "OptSavePage", "cui/ui/optsavepage.ui", &rCoreSet ),
  85     pImpl               ( new SvxSaveTabPage_Impl )
  86 {
  87     get(aLoadUserSettingsCB, "load_settings");
  88     get(aLoadDocPrinterCB,  "load_docprinter");
  89
  90     get(aDocInfoCB, "docinfo");
  91     get(aBackupCB, "backup");
  92     get(aAutoSaveCB, "autosave");
  93     get(aAutoSaveEdit, "autosave_spin");
  94     get(aMinuteFT, "autosave_mins");
  95     get(aUserAutoSaveCB, "userautosave");
  96     get(aRelativeFsysCB, "relative_fsys");
  97     get(aRelativeInetCB, "relative_inet");
  98
  99     get(aODFVersionLB, "odfversion");
 100     get(aWarnAlienFormatCB, "warnalienformat");
 101     get(aDocTypeLB, "doctype");
 102     get(aSaveAsFT, "saveas_label");
 103     get(aSaveAsLB, "saveas");
 104     get(aODFWarningFI, "odfwarning_image");
 105     get(aODFWarningFT, "odfwarning_label");
 106
 107
 108     aODFVersionLB->SetEntryData(0, reinterpret_cast<void*>(2         )); // 1.0/1.1
 109     aODFVersionLB->SetEntryData(1, reinterpret_cast<void*>(4         )); // 1.2
 110     aODFVersionLB->SetEntryData(2, reinterpret_cast<void*>(8         )); // 1.2 Extended (compatibility mode)
 111     aODFVersionLB->SetEntryData(3, reinterpret_cast<void*>(0x7fffffff)); // 1.2 Extended (recommended)
 112
 113     aDocTypeLB->SetEntryData(0, reinterpret_cast<void*>(APP_WRITER)       );
 114     aDocTypeLB->SetEntryData(1, reinterpret_cast<void*>(APP_WRITER_WEB)   );
 115     aDocTypeLB->SetEntryData(2, reinterpret_cast<void*>(APP_WRITER_GLOBAL));
 116     aDocTypeLB->SetEntryData(3, reinterpret_cast<void*>(APP_CALC)         );
 117     aDocTypeLB->SetEntryData(4, reinterpret_cast<void*>(APP_IMPRESS)      );
 118     aDocTypeLB->SetEntryData(5, reinterpret_cast<void*>(APP_DRAW)         );
 119     aDocTypeLB->SetEntryData(6, reinterpret_cast<void*>(APP_MATH)         );
 120
 121     Link<> aLink = LINK( this, SfxSaveTabPage, AutoClickHdl_Impl );
 122     aAutoSaveCB->SetClickHdl( aLink );
 123     aAutoSaveEdit->SetMaxTextLen( 2 );
 124
 125     SvtModuleOptions aModuleOpt;
 126     if ( !aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::MATH ) )
 127     {
 128         aSaveAsLB->RemoveEntry(aSaveAsLB->GetEntryPos( reinterpret_cast<void*>(APP_MATH) ));
 129         aDocTypeLB->RemoveEntry(aDocTypeLB->GetEntryPos( reinterpret_cast<void*>(APP_MATH) ));
 130     }
 131     else
 132     {
 133         pImpl->aDefaultArr[APP_MATH] = aModuleOpt.GetFactoryDefaultFilter(SvtModuleOptions::EFactory::MATH);
 134         pImpl->aDefaultReadonlyArr[APP_MATH] = aModuleOpt.IsDefaultFilterReadonly(SvtModuleOptions::EFactory::MATH);
 135     }
 136
 137     if ( !aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::DRAW ) )
 138     {
 139         aSaveAsLB->RemoveEntry(aSaveAsLB->GetEntryPos( reinterpret_cast<void*>(APP_DRAW) ));
 140         aDocTypeLB->RemoveEntry(aDocTypeLB->GetEntryPos( reinterpret_cast<void*>(APP_DRAW) ));
 141     }
 142     else
 143     {
 144         pImpl->aDefaultArr[APP_DRAW] = aModuleOpt.GetFactoryDefaultFilter(SvtModuleOptions::EFactory::DRAW);
 145         pImpl->aDefaultReadonlyArr[APP_DRAW] = aModuleOpt.IsDefaultFilterReadonly(SvtModuleOptions::EFactory::DRAW);
 146     }
 147
 148     if ( !aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::IMPRESS ) )
 149     {
 150         aSaveAsLB->RemoveEntry(aSaveAsLB->GetEntryPos( reinterpret_cast<void*>(APP_IMPRESS) ));
 151         aDocTypeLB->RemoveEntry(aDocTypeLB->GetEntryPos( reinterpret_cast<void*>(APP_IMPRESS) ));
 152     }
 153     else
 154     {
 155         pImpl->aDefaultArr[APP_IMPRESS] = aModuleOpt.GetFactoryDefaultFilter(SvtModuleOptions::EFactory::IMPRESS);
 156         pImpl->aDefaultReadonlyArr[APP_IMPRESS] = aModuleOpt.IsDefaultFilterReadonly(SvtModuleOptions::EFactory::IMPRESS);
 157     }
 158
 159     if ( !aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::CALC ) )
 160     {
 161         aSaveAsLB->RemoveEntry(aSaveAsLB->GetEntryPos( reinterpret_cast<void*>(APP_CALC) ));
 162         aDocTypeLB->RemoveEntry(aDocTypeLB->GetEntryPos( reinterpret_cast<void*>(APP_CALC) ));
 163     }
 164     else
 165     {
 166         pImpl->aDefaultArr[APP_CALC] = aModuleOpt.GetFactoryDefaultFilter(SvtModuleOptions::EFactory::CALC);
 167         pImpl->aDefaultReadonlyArr[APP_CALC] = aModuleOpt.IsDefaultFilterReadonly(SvtModuleOptions::EFactory::CALC);
 168     }
 169
 170     if ( !aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::WRITER ) )
 171     {
 172         aSaveAsLB->RemoveEntry(aSaveAsLB->GetEntryPos( reinterpret_cast<void*>(APP_WRITER) ));
 173         aSaveAsLB->RemoveEntry(aSaveAsLB->GetEntryPos( reinterpret_cast<void*>(APP_WRITER_WEB) ));
 174         aSaveAsLB->RemoveEntry(aSaveAsLB->GetEntryPos( reinterpret_cast<void*>(APP_WRITER_GLOBAL) ));
 175         aDocTypeLB->RemoveEntry(aDocTypeLB->GetEntryPos( reinterpret_cast<void*>(APP_WRITER) ));
 176         aDocTypeLB->RemoveEntry(aDocTypeLB->GetEntryPos( reinterpret_cast<void*>(APP_WRITER_WEB) ));
 177         aDocTypeLB->RemoveEntry(aDocTypeLB->GetEntryPos( reinterpret_cast<void*>(APP_WRITER_GLOBAL) ));
 178     }
 179     else
 180     {
 181         pImpl->aDefaultArr[APP_WRITER] = aModuleOpt.GetFactoryDefaultFilter(SvtModuleOptions::EFactory::WRITER);
 182         pImpl->aDefaultArr[APP_WRITER_WEB] = aModuleOpt.GetFactoryDefaultFilter(SvtModuleOptions::EFactory::WRITERWEB);
 183         pImpl->aDefaultArr[APP_WRITER_GLOBAL] = aModuleOpt.GetFactoryDefaultFilter(SvtModuleOptions::EFactory::WRITERGLOBAL);
 184         pImpl->aDefaultReadonlyArr[APP_WRITER] = aModuleOpt.IsDefaultFilterReadonly(SvtModuleOptions::EFactory::WRITER);
 185         pImpl->aDefaultReadonlyArr[APP_WRITER_WEB] = aModuleOpt.IsDefaultFilterReadonly(SvtModuleOptions::EFactory::WRITERWEB);
 186         pImpl->aDefaultReadonlyArr[APP_WRITER_GLOBAL] = aModuleOpt.IsDefaultFilterReadonly(SvtModuleOptions::EFactory::WRITERGLOBAL);
 187     }
 188
 189     aLink = LINK( this, SfxSaveTabPage, ODFVersionHdl_Impl );
 190     aODFVersionLB->SetSelectHdl( aLink );
 191     aLink = LINK( this, SfxSaveTabPage, FilterHdl_Impl );
 192     aDocTypeLB->SetSelectHdl( aLink );
 193     aSaveAsLB->SetSelectHdl( aLink );
 194
 195     DetectHiddenControls();
 196 }
 197
 198
 199
 200 SfxSaveTabPage::~SfxSaveTabPage()
 201 {
 202     disposeOnce();
 203 }
 204
 205 void SvxSaveTabPage::dispose()
 206 {
 207     delete pImpl;
 208     pImpl = NULL;
 209     aLoadUserSettingsCB.clear();
 210     aLoadDocPrinterCB.clear();
 211     aDocInfoCB.clear();
 212     aBackupCB.clear();
 213     aAutoSaveCB.clear();
 214     aAutoSaveEdit.clear();
 215     aMinuteFT.clear();
 216     aUserAutoSaveCB.clear();
 217     aRelativeFsysCB.clear();
 218     aRelativeInetCB.clear();
 219     aODFVersionLB.clear();
 220     aWarnAlienFormatCB.clear();
 221     aDocTypeLB.clear();
 222     aSaveAsFT.clear();
 223     aSaveAsLB.clear();
 224     aODFWarningFI.clear();
 225     aODFWarningFT.clear();
 226     SfxTabPage::dispose();
 227 }
 228
 229 VclPtr<SfxTabPage> SfxSaveTabPage::Create( vcl::Window* pParent,
 230                                            const SfxItemSet* rAttrSet )
 231 {
 232     return VclPtr<SfxSaveTabPage>::Create( pParent, *rAttrSet );
 233 }
 234
 235 void SfxSaveTabPage::DetectHiddenControls()
 236 {
 237     SvtOptionsDialogOptions aOptionsDlgOpt;
 238
 239     if ( aOptionsDlgOpt.IsOptionHidden( "Backup", CFG_PAGE_AND_GROUP ) )
 240     {
 241         // hide controls of "Backup"
 242         aBackupCB->Hide();
 243     }
 244
 245     if ( aOptionsDlgOpt.IsOptionHidden( "AutoSave", CFG_PAGE_AND_GROUP ) )
 246     {
 247         // hide controls of "AutoSave"
 248         aAutoSaveCB->Hide();
 249         aAutoSaveEdit->Hide();
 250         aMinuteFT->Hide();
 251     }
 252
 253     if ( aOptionsDlgOpt.IsOptionHidden( "UserAutoSave", CFG_PAGE_AND_GROUP ) )
 254     {
 255         // hide controls of "UserAutoSave"
 256         aUserAutoSaveCB->Hide();
 257     }
 258
 259 }
 260
 261 bool SfxSaveTabPage::FillItemSet( SfxItemSet* rSet )
 262 {
 263     bool bModified = false;
 264     SvtSaveOptions aSaveOpt;
 265     if(aLoadUserSettingsCB->IsValueChangedFromSaved())
 266     {
 267         aSaveOpt.SetLoadUserSettings(aLoadUserSettingsCB->IsChecked());
 268     }
 269
 270     if ( aLoadDocPrinterCB->IsValueChangedFromSaved() )
 271         aSaveOpt.SetLoadDocumentPrinter( aLoadDocPrinterCB->IsChecked() );
 272
 273     if ( aODFVersionLB->IsValueChangedFromSaved() )
 274     {
 275         sal_IntPtr nVersion = sal_IntPtr( aODFVersionLB->GetSelectEntryData() );
 276         aSaveOpt.SetODFDefaultVersion( SvtSaveOptions::ODFDefaultVersion( nVersion ) );
 277     }
 278
 279     if ( aDocInfoCB->IsValueChangedFromSaved() )
 280     {
 281         rSet->Put( SfxBoolItem( GetWhich( SID_ATTR_DOCINFO ),
 282                                aDocInfoCB->IsChecked() ) );
 283         bModified |= true;
 284     }
 285
 286     if ( aBackupCB->IsEnabled() && aBackupCB->IsValueChangedFromSaved() )
 287     {
 288         rSet->Put( SfxBoolItem( GetWhich( SID_ATTR_BACKUP ),
 289                                aBackupCB->IsChecked() ) );
 290         bModified |= true;
 291     }
 292
 293     if ( aAutoSaveCB->IsValueChangedFromSaved() )
 294     {
 295         rSet->Put( SfxBoolItem( GetWhich( SID_ATTR_AUTOSAVE ),
 296                                aAutoSaveCB->IsChecked() ) );
 297         bModified |= true;
 298     }
 299     if ( aWarnAlienFormatCB->IsValueChangedFromSaved() )
 300     {
 301         rSet->Put( SfxBoolItem( GetWhich( SID_ATTR_WARNALIENFORMAT ),
 302                                aWarnAlienFormatCB->IsChecked() ) );
 303         bModified |= true;
 304     }
 305
 306     if ( aAutoSaveEdit->IsValueChangedFromSaved() )
 307     {
 308         rSet->Put( SfxUInt16Item( GetWhich( SID_ATTR_AUTOSAVEMINUTE ),
 309                                  (sal_uInt16)aAutoSaveEdit->GetValue() ) );
 310         bModified |= true;
 311     }
 312
 313     if ( aUserAutoSaveCB->IsValueChangedFromSaved() )
 314     {
 315         rSet->Put( SfxBoolItem( GetWhich( SID_ATTR_USERAUTOSAVE ),
 316                                aUserAutoSaveCB->IsChecked() ) );
 317         bModified |= true;
 318     }
 319     // save relatively
 320     if ( aRelativeFsysCB->IsValueChangedFromSaved() )
 321     {
 322         rSet->Put( SfxBoolItem( GetWhich( SID_SAVEREL_FSYS ),
 323                                aRelativeFsysCB->IsChecked() ) );
 324         bModified |= true;
 325     }
 326
 327     if ( aRelativeInetCB->IsValueChangedFromSaved() )
 328     {
 329         rSet->Put( SfxBoolItem( GetWhich( SID_SAVEREL_INET ),
 330                                aRelativeInetCB->IsChecked() ) );
 331         bModified |= true;
 332     }
 333
 334     SvtModuleOptions aModuleOpt;
 335     if(!pImpl->aDefaultArr[APP_MATH].isEmpty() &&
 336             pImpl->aDefaultArr[APP_MATH] != aModuleOpt.GetFactoryDefaultFilter(SvtModuleOptions::EFactory::MATH))
 337         aModuleOpt.SetFactoryDefaultFilter(SvtModuleOptions::EFactory::MATH, pImpl->aDefaultArr[APP_MATH]);
 338
 339     if( !pImpl->aDefaultArr[APP_DRAW].isEmpty() &&
 340             pImpl->aDefaultArr[APP_DRAW] != aModuleOpt.GetFactoryDefaultFilter(SvtModuleOptions::EFactory::DRAW))
 341             aModuleOpt.SetFactoryDefaultFilter(SvtModuleOptions::EFactory::DRAW, pImpl->aDefaultArr[APP_DRAW]);
 342
 343     if(!pImpl->aDefaultArr[APP_IMPRESS].isEmpty() &&
 344             pImpl->aDefaultArr[APP_IMPRESS] != aModuleOpt.GetFactoryDefaultFilter(SvtModuleOptions::EFactory::IMPRESS))
 345         aModuleOpt.SetFactoryDefaultFilter(SvtModuleOptions::EFactory::IMPRESS, pImpl->aDefaultArr[APP_IMPRESS]);
 346
 347     if(!pImpl->aDefaultArr[APP_CALC].isEmpty() &&
 348             pImpl->aDefaultArr[APP_CALC] != aModuleOpt.GetFactoryDefaultFilter(SvtModuleOptions::EFactory::CALC))
 349         aModuleOpt.SetFactoryDefaultFilter(SvtModuleOptions::EFactory::CALC, pImpl->aDefaultArr[APP_CALC]);
 350
 351     if(!pImpl->aDefaultArr[APP_WRITER].isEmpty() &&
 352             pImpl->aDefaultArr[APP_WRITER] != aModuleOpt.GetFactoryDefaultFilter(SvtModuleOptions::EFactory::WRITER))
 353         aModuleOpt.SetFactoryDefaultFilter(SvtModuleOptions::EFactory::WRITER, pImpl->aDefaultArr[APP_WRITER]);
 354
 355     if(!pImpl->aDefaultArr[APP_WRITER_WEB].isEmpty() &&
 356             pImpl->aDefaultArr[APP_WRITER_WEB] != aModuleOpt.GetFactoryDefaultFilter(SvtModuleOptions::EFactory::WRITERWEB))
 357         aModuleOpt.SetFactoryDefaultFilter(SvtModuleOptions::EFactory::WRITERWEB, pImpl->aDefaultArr[APP_WRITER_WEB]);
 358
 359     if(!pImpl->aDefaultArr[APP_WRITER_GLOBAL].isEmpty() &&
 360             pImpl->aDefaultArr[APP_WRITER_GLOBAL] != aModuleOpt.GetFactoryDefaultFilter(SvtModuleOptions::EFactory::WRITERGLOBAL))
 361         aModuleOpt.SetFactoryDefaultFilter(SvtModuleOptions::EFactory::WRITERGLOBAL, pImpl->aDefaultArr[APP_WRITER_GLOBAL]);
 362
 363     return bModified;
 364 }
 365
 366
 367
 368 bool isODFFormat( const OUString& sFilter )
 369 {
 370     static const char* aODFFormats[] =
 371     {
 372         "writer8",
 373         "writer8_template",
 374         "writerglobal8",
 375         "writerglobal8_writer",
 376         "calc8",
 377         "calc8_template",
 378         "draw8",
 379         "draw8_template",
 380         "impress8",
 381         "impress8_template",
 382         "impress8_draw",
 383         "chart8",
 384         "math8",
 385         NULL
 386     };
 387
 388     bool bRet = false;
 389     int i = 0;
 390     while ( aODFFormats[i] != NULL )
 391     {
 392         if ( sFilter.equalsAscii( aODFFormats[i++] ) )
 393         {
 394             bRet = true;
 395             break;
 396         }
 397     }
 398
 399     return bRet;
 400 }
 401
 402 void SfxSaveTabPage::Reset( const SfxItemSet* )
 403 {
 404     SvtSaveOptions aSaveOpt;
 405     aLoadUserSettingsCB->Check(aSaveOpt.IsLoadUserSettings());
 406     aLoadUserSettingsCB->SaveValue();
 407     aLoadDocPrinterCB->Check( aSaveOpt.IsLoadDocumentPrinter() );
 408     aLoadDocPrinterCB->SaveValue();
 409
 410     if ( !pImpl->bInitialized )
 411     {
 412         try
 413         {
 414             Reference< XMultiServiceFactory > xMSF = comphelper::getProcessServiceFactory();
 415             pImpl->xFact = Reference<XNameContainer>(
 416                     xMSF->createInstance("com.sun.star.document.FilterFactory"), UNO_QUERY);
 417
 418             DBG_ASSERT(pImpl->xFact.is(), "service com.sun.star.document.FilterFactory unavailable");
 419             Reference< XContainerQuery > xQuery(pImpl->xFact, UNO_QUERY);
 420             if(xQuery.is())
 421             {
 422                 for(sal_uInt16 n = 0; n < aDocTypeLB->GetEntryCount(); n++)
 423                 {
 424                     sal_IntPtr nData = reinterpret_cast<sal_IntPtr>(aDocTypeLB->GetEntryData(n));
 425                     OUString sCommand;
 426                     sCommand = "matchByDocumentService=%1:iflags=" +
 427                                OUString::number(static_cast<int>(SfxFilterFlags::IMPORT|SfxFilterFlags::EXPORT)) +
 428                                ":eflags=" +
 429                                OUString::number(static_cast<int>(SfxFilterFlags::NOTINFILEDLG)) +
 430                                ":default_first";
 431                     OUString sReplace;
 432                     switch(nData)
 433                     {
 434                         case  APP_WRITER        : sReplace = "com.sun.star.text.TextDocument";  break;
 435                         case  APP_WRITER_WEB    : sReplace = "com.sun.star.text.WebDocument";   break;
 436                         case  APP_WRITER_GLOBAL : sReplace = "com.sun.star.text.GlobalDocument";   break;
 437                         case  APP_CALC          : sReplace = "com.sun.star.sheet.SpreadsheetDocument";break;
 438                         case  APP_IMPRESS       : sReplace = "com.sun.star.presentation.PresentationDocument";break;
 439                         case  APP_DRAW          : sReplace = "com.sun.star.drawing.DrawingDocument";break;
 440                         case  APP_MATH          : sReplace = "com.sun.star.formula.FormulaProperties";break;
 441                         default: OSL_FAIL("illegal user data");
 442                     }
 443                     sCommand = sCommand.replaceFirst("%1", sReplace);
 444                     Reference< XEnumeration > xList = xQuery->createSubSetEnumerationByQuery(sCommand);
 445                     std::vector< OUString > lList;
 446                     std::vector< sal_Bool > lAlienList;
 447                     std::vector< sal_Bool > lODFList;
 448                     while(xList->hasMoreElements())
 449                     {
 450                         SequenceAsHashMap aFilter(xList->nextElement());
 451                         OUString sFilter = aFilter.getUnpackedValueOrDefault("Name",OUString());
 452                         if (!sFilter.isEmpty())
 453                         {
 454                             SfxFilterFlags nFlags = static_cast<SfxFilterFlags>(aFilter.getUnpackedValueOrDefault("Flags",sal_Int32()));
 455                             lList.push_back(sFilter);
 456                             lAlienList.push_back(bool(nFlags & SfxFilterFlags::ALIEN));
 457                             lODFList.push_back( isODFFormat( sFilter ) );
 458                         }
 459                     }
 460                     pImpl->aFilterArr[nData] = comphelper::containerToSequence(lList);
 461                     pImpl->aAlienArr[nData] = comphelper::containerToSequence(lAlienList);
 462                     pImpl->aODFArr[nData] = comphelper::containerToSequence(lODFList);
 463                 }
 464             }
 465             aDocTypeLB->SelectEntryPos(0);
 466             FilterHdl_Impl(aDocTypeLB);
 467         }
 468         catch(Exception& e)
 469         {
 470             (void) e;
 471             OSL_FAIL(
 472                 OUStringToOString(
 473                     "exception in FilterFactory access: " + e.Message,
 474                     RTL_TEXTENCODING_UTF8).
 475                 getStr());
 476         }
 477
 478         pImpl->bInitialized = true;
 479     }
 480
 481     aDocInfoCB->Check(aSaveOpt.IsDocInfoSave());
 482
 483     aBackupCB->Check(aSaveOpt.IsBackup());
 484     bool bBackupRO = aSaveOpt.IsReadOnly(SvtSaveOptions::E_BACKUP);
 485     aBackupCB->Enable(!bBackupRO);
 486
 487     aAutoSaveCB->Check(aSaveOpt.IsAutoSave());
 488     aUserAutoSaveCB->Check(aSaveOpt.IsUserAutoSave());
 489     aWarnAlienFormatCB->Check(aSaveOpt.IsWarnAlienFormat());
 490     aWarnAlienFormatCB->Enable(!aSaveOpt.IsReadOnly(SvtSaveOptions::E_WARNALIENFORMAT));
 491
 492     aAutoSaveEdit->SetValue( aSaveOpt.GetAutoSaveTime() );
 493
 494     // save relatively
 495     aRelativeFsysCB->Check( aSaveOpt.IsSaveRelFSys() );
 496
 497     aRelativeInetCB->Check( aSaveOpt.IsSaveRelINet() );
 498
 499     void* pDefaultVersion = reinterpret_cast<void*>( aSaveOpt.GetODFDefaultVersion() );
 500     aODFVersionLB->SelectEntryPos( aODFVersionLB->GetEntryPos( pDefaultVersion ) );
 501
 502     AutoClickHdl_Impl( aAutoSaveCB );
 503     ODFVersionHdl_Impl( aODFVersionLB );
 504
 505     aDocInfoCB->SaveValue();
 506     aBackupCB->SaveValue();
 507     aWarnAlienFormatCB->SaveValue();
 508     aAutoSaveCB->SaveValue();
 509     aAutoSaveEdit->SaveValue();
 510
 511     aUserAutoSaveCB->SaveValue();
 512
 513     aRelativeFsysCB->SaveValue();
 514     aRelativeInetCB->SaveValue();
 515     aODFVersionLB->SaveValue();
 516 }
 517
 518
 519
 520 IMPL_LINK( SfxSaveTabPage, AutoClickHdl_Impl, CheckBox *, pBox )
 521 {
 522     if ( pBox == aAutoSaveCB )
 523     {
 524         if ( aAutoSaveCB->IsChecked() )
 525         {
 526             aAutoSaveEdit->Enable();
 527             aMinuteFT->Enable();
 528             aUserAutoSaveCB->Enable();
 529         }
 530         else
 531         {
 532             aAutoSaveEdit->Disable();
 533             aMinuteFT->Disable();
 534             aUserAutoSaveCB->Disable();
 535         }
 536     }
 537     return 0;
 538 }
 539
 540 static OUString lcl_ExtracUIName(const Sequence<PropertyValue> &rProperties)
 541 {
 542     OUString sName;
 543     const PropertyValue* pPropVal = rProperties.getConstArray();
 544     const PropertyValue* const pEnd = pPropVal + rProperties.getLength();
 545     for( ; pPropVal != pEnd; pPropVal++ )
 546     {
 547         const OUString &rName = pPropVal->Name;
 548         if (rName == "UIName")
 549         {
 550             OUString sUIName;
 551             if ( ( pPropVal->Value >>= sUIName ) && sUIName.getLength() )
 552                 return sUIName;
 553         }
 554         else if (rName == "Name")
 555         {
 556             pPropVal->Value >>= sName;
 557         }
 558     }
 559
 560     OSL_ENSURE( false, "Filter without UIName!" );
 561
 562     return sName;
 563 }
 564
 565 IMPL_LINK( SfxSaveTabPage, FilterHdl_Impl, ListBox *, pBox )
 566 {
 567     sal_uInt16 nCurPos = aDocTypeLB->GetSelectEntryPos();
 568
 569     sal_IntPtr nData = -1;
 570     if(nCurPos < APP_COUNT)
 571         nData = reinterpret_cast<sal_IntPtr>( aDocTypeLB->GetEntryData(nCurPos) );
 572
 573     if ( nData >= 0 && nData < APP_COUNT )
 574     {
 575         if(aDocTypeLB == pBox)
 576         {
 577             aSaveAsLB->Clear();
 578             const OUString* pFilters = pImpl->aFilterArr[nData].getConstArray();
 579             if(!pImpl->aUIFilterArr[nData].getLength())
 580             {
 581                 pImpl->aUIFilterArr[nData].realloc(pImpl->aFilterArr[nData].getLength());
 582                 OUString* pUIFilters = pImpl->aUIFilterArr[nData].getArray();
 583                 for(int nFilter = 0; nFilter < pImpl->aFilterArr[nData].getLength(); nFilter++)
 584                 {
 585                     Any aProps = pImpl->xFact->getByName(pFilters[nFilter]);
 586                     Sequence<PropertyValue> aProperties;
 587                     aProps >>= aProperties;
 588                     pUIFilters[nFilter] = lcl_ExtracUIName(aProperties);
 589                 }
 590             }
 591             const OUString* pUIFilters = pImpl->aUIFilterArr[nData].getConstArray();
 592             OUString sSelect;
 593             for(int i = 0; i < pImpl->aUIFilterArr[nData].getLength(); i++)
 594             {
 595                 sal_uInt16 nEntryPos = aSaveAsLB->InsertEntry(pUIFilters[i]);
 596                 if ( pImpl->aODFArr[nData][i] )
 597                     aSaveAsLB->SetEntryData( nEntryPos, (void*)pImpl );
 598                 if(pFilters[i] == pImpl->aDefaultArr[nData])
 599                     sSelect = pUIFilters[i];
 600             }
 601             if(!sSelect.isEmpty())
 602             {
 603                 aSaveAsLB->SelectEntry(sSelect);
 604             }
 605
 606             aSaveAsFT->Enable(!pImpl->aDefaultReadonlyArr[nData]);
 607             aSaveAsLB->Enable(!pImpl->aDefaultReadonlyArr[nData]);
 608         }
 609         else
 610         {
 611             OUString sSelect = pBox->GetSelectEntry();
 612             const OUString* pFilters = pImpl->aFilterArr[nData].getConstArray();
 613             OUString* pUIFilters = pImpl->aUIFilterArr[nData].getArray();
 614             for(int i = 0; i < pImpl->aUIFilterArr[nData].getLength(); i++)
 615                 if(pUIFilters[i] == sSelect)
 616                 {
 617                     sSelect = pFilters[i];
 618                     break;
 619                 }
 620
 621             pImpl->aDefaultArr[nData] = sSelect;
 622         }
 623     }
 624
 625     ODFVersionHdl_Impl( aSaveAsLB );
 626     return 0;
 627 };
 628
 629 IMPL_LINK_NOARG(SfxSaveTabPage, ODFVersionHdl_Impl)
 630 {
 631     sal_IntPtr nVersion = sal_IntPtr( aODFVersionLB->GetSelectEntryData() );
 632     bool bShown = SvtSaveOptions::ODFDefaultVersion( nVersion ) != SvtSaveOptions::ODFVER_LATEST;
 633     if ( bShown )
 634     {
 635         bool bHasODFFormat = false;
 636         sal_uInt16 i = 0, nCount = aSaveAsLB->GetEntryCount();
 637         for ( ; i < nCount; ++ i )
 638         {
 639             if ( aSaveAsLB->GetEntryData(i) != NULL )
 640             {
 641                 bHasODFFormat = true;
 642                 break;
 643             }
 644         }
 645
 646         bShown = !bHasODFFormat
 647                 || ( aSaveAsLB->GetSelectEntryData() != NULL );
 648     }
 649
 650     aODFWarningFI->Show( bShown );
 651     aODFWarningFT->Show( bShown );
 652
 653     return 0;
 654 }
 655
 656 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */