filter/source/xsltdialog/xmlfiltersettingsdialog.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/beans/XPropertySet.hpp>
  21 #include <com/sun/star/util/XFlushable.hpp>
  22 #include <com/sun/star/uno/XComponentContext.hpp>
  23
  24 #include <com/sun/star/beans/PropertyValue.hpp>
  25
  26 #include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
  27 #include <tools/diagnose_ex.h>
  28 #include <tools/urlobj.hxx>
  29 #include <unotools/pathoptions.hxx>
  30 #include <unotools/resmgr.hxx>
  31 #include <unotools/streamwrap.hxx>
  32 #include <osl/file.hxx>
  33 #include <o3tl/enumrange.hxx>
  34 #include <vcl/svapp.hxx>
  35 #include <vcl/weld.hxx>
  36 #include <sfx2/filedlghelper.hxx>
  37 #include <tools/stream.hxx>
  38
  39 #include <rtl/uri.hxx>
  40
  41 #include <algorithm>
  42 #include <memory>
  43
  44 #include <strings.hrc>
  45 #include "xmlfiltersettingsdialog.hxx"
  46 #include "xmlfiltertabdialog.hxx"
  47 #include "xmlfiltertestdialog.hxx"
  48 #include "xmlfilterjar.hxx"
  49 #include <strings.hxx>
  50
  51 using namespace osl;
  52 using namespace com::sun::star::lang;
  53 using namespace com::sun::star::uno;
  54 using namespace com::sun::star::io;
  55 using namespace com::sun::star::container;
  56 using namespace com::sun::star::beans;
  57 using namespace com::sun::star::util;
  58
  59 using ::rtl::Uri;
  60
  61 OUString XsltResId(const char* pId)
  62 {
  63     return Translate::get(pId, Translate::Create("flt"));
  64 }
  65
  66 XMLFilterSettingsDialog::XMLFilterSettingsDialog(weld::Window* pParent,
  67         const css::uno::Reference<css::uno::XComponentContext>& rxContext)
  68     : GenericDialogController(pParent, "filter/ui/xmlfiltersettings.ui", "XMLFilterSettingsDialog")
  69     , mxContext( rxContext )
  70     , m_sTemplatePath("$(user)/template/")
  71     , m_sDocTypePrefix("doctype:")
  72     , m_xPBNew(m_xBuilder->weld_button("new"))
  73     , m_xPBEdit(m_xBuilder->weld_button("edit"))
  74     , m_xPBTest(m_xBuilder->weld_button("test"))
  75     , m_xPBDelete(m_xBuilder->weld_button("delete"))
  76     , m_xPBSave(m_xBuilder->weld_button("save"))
  77     , m_xPBOpen(m_xBuilder->weld_button("open"))
  78     , m_xPBClose(m_xBuilder->weld_button("close"))
  79     , m_xFilterListBox(m_xBuilder->weld_tree_view("filterlist"))
  80 {
  81     m_xFilterListBox->set_selection_mode(SelectionMode::Multiple);
  82
  83     m_xFilterListBox->set_size_request(m_xFilterListBox->get_approximate_digit_width() * 65,
  84                                        m_xFilterListBox->get_height_rows(12));
  85
  86     m_xFilterListBox->connect_changed( LINK( this, XMLFilterSettingsDialog, SelectionChangedHdl_Impl ) );
  87     m_xFilterListBox->connect_row_activated( LINK( this, XMLFilterSettingsDialog, DoubleClickHdl_Impl ) );
  88     m_xFilterListBox->set_accessible_name(XsltResId(STR_XML_FILTER_LISTBOX));
  89
  90     m_xPBNew->connect_clicked(LINK( this, XMLFilterSettingsDialog, ClickHdl_Impl ) );
  91     m_xPBEdit->connect_clicked(LINK( this, XMLFilterSettingsDialog, ClickHdl_Impl ) );
  92     m_xPBTest->connect_clicked(LINK( this, XMLFilterSettingsDialog, ClickHdl_Impl ) );
  93     m_xPBDelete->connect_clicked(LINK( this, XMLFilterSettingsDialog, ClickHdl_Impl ) );
  94     m_xPBSave->connect_clicked(LINK( this, XMLFilterSettingsDialog, ClickHdl_Impl ) );
  95     m_xPBOpen->connect_clicked(LINK( this, XMLFilterSettingsDialog, ClickHdl_Impl ) );
  96     m_xPBClose->connect_clicked(LINK( this, XMLFilterSettingsDialog, ClickHdl_Impl ) );
  97
  98     try
  99     {
 100         mxFilterContainer.set( rxContext->getServiceManager()->createInstanceWithContext( "com.sun.star.document.FilterFactory", rxContext ), UNO_QUERY );
 101         mxTypeDetection.set( rxContext->getServiceManager()->createInstanceWithContext( "com.sun.star.document.TypeDetection", rxContext ), UNO_QUERY );
 102         mxExtendedTypeDetection.set( rxContext->getServiceManager()->createInstanceWithContext( "com.sun.star.document.ExtendedTypeDetectionFactory", rxContext ), UNO_QUERY );
 103
 104         SvtPathOptions aOptions;
 105         m_sTemplatePath = aOptions.SubstituteVariable( m_sTemplatePath );
 106     }
 107     catch(const Exception&)
 108     {
 109         TOOLS_WARN_EXCEPTION("filter.xslt", "");
 110     }
 111 }
 112
 113 XMLFilterSettingsDialog::~XMLFilterSettingsDialog()
 114 {
 115 }
 116
 117 IMPL_LINK(XMLFilterSettingsDialog, ClickHdl_Impl, weld::Button&, rButton, void)
 118 {
 119     // tdf#122171 block closing libreoffice until the following dialog is dismissed
 120     incBusy();
 121
 122     if (m_xPBNew.get() == &rButton)
 123     {
 124         onNew();
 125     }
 126     else if (m_xPBEdit.get() == &rButton)
 127     {
 128         onEdit();
 129     }
 130     else if (m_xPBTest.get() == &rButton)
 131     {
 132         onTest();
 133     }
 134     else if (m_xPBDelete.get() == &rButton)
 135     {
 136         onDelete();
 137     }
 138     else if (m_xPBSave.get() == &rButton)
 139     {
 140         onSave();
 141     }
 142     else if (m_xPBOpen.get() == &rButton)
 143     {
 144         onOpen();
 145     }
 146
 147     decBusy();
 148
 149     if (m_xPBClose.get() == &rButton)
 150         m_xDialog->response(RET_CLOSE);
 151 }
 152
 153 IMPL_LINK_NOARG(XMLFilterSettingsDialog, SelectionChangedHdl_Impl, weld::TreeView&, void)
 154 {
 155     updateStates();
 156 }
 157
 158 IMPL_LINK_NOARG(XMLFilterSettingsDialog, DoubleClickHdl_Impl, weld::TreeView&, bool)
 159 {
 160     onEdit();
 161     return true;
 162 }
 163
 164 void XMLFilterSettingsDialog::UpdateWindow()
 165 {
 166     m_xFilterListBox->grab_focus();
 167     disposeFilterList();
 168     m_xFilterListBox->clear();
 169     initFilterList();
 170     updateStates();
 171 }
 172
 173 void XMLFilterSettingsDialog::updateStates()
 174 {
 175     std::vector<int> aRows = m_xFilterListBox->get_selected_rows();
 176
 177     bool bHasSelection = !aRows.empty();
 178
 179     bool bMultiSelection = aRows.size() > 1;
 180     bool bIsReadonly = false;
 181     bool bIsDefault = false;
 182     if (bHasSelection)
 183     {
 184         filter_info_impl* pInfo = reinterpret_cast<filter_info_impl*>(m_xFilterListBox->get_id(aRows[0]).toInt64());
 185         bIsReadonly = pInfo->mbReadonly;
 186
 187         for( auto nFact : o3tl::enumrange<SvtModuleOptions::EFactory>())
 188         {
 189             OUString sDefault = maModuleOpt.GetFactoryDefaultFilter(nFact);
 190             if( sDefault == pInfo->maFilterName )
 191             {
 192                 bIsDefault = true;
 193                 break;
 194             }
 195         }
 196     }
 197     m_xPBEdit->set_sensitive( bHasSelection && !bMultiSelection && !bIsReadonly);
 198     m_xPBTest->set_sensitive( bHasSelection && !bMultiSelection );
 199     m_xPBDelete->set_sensitive( bHasSelection && !bMultiSelection && !bIsReadonly && !bIsDefault);
 200     m_xPBSave->set_sensitive( bHasSelection );
 201 }
 202
 203 /** is called when the user clicks on the "New" button */
 204 void XMLFilterSettingsDialog::onNew()
 205 {
 206     filter_info_impl aTempInfo;
 207
 208     // create a unique filter name
 209     aTempInfo.maFilterName = createUniqueFilterName(XsltResId(STR_DEFAULT_FILTER_NAME));
 210
 211     // init default extension
 212     aTempInfo.maExtension = STR_DEFAULT_EXTENSION;
 213
 214     // set default ui name
 215     aTempInfo.maInterfaceName = createUniqueInterfaceName(XsltResId(STR_DEFAULT_UI_NAME));
 216
 217     // set default application
 218     aTempInfo.maDocumentService = "com.sun.star.text.TextDocument";
 219
 220     // execute XML Filter Dialog
 221     XMLFilterTabDialog aDlg(m_xDialog.get(), mxContext, &aTempInfo);
 222     if (aDlg.run() == RET_OK)
 223     {
 224         // insert the new filter
 225         insertOrEdit( aDlg.getNewFilterInfo() );
 226     }
 227 }
 228
 229 /** is called when the user clicks on the "Edit" Button */
 230 void XMLFilterSettingsDialog::onEdit()
 231 {
 232     // get selected filter info
 233     filter_info_impl* pOldInfo = reinterpret_cast<filter_info_impl*>(m_xFilterListBox->get_selected_id().toInt64());
 234     if (!pOldInfo)
 235         return;
 236
 237     // execute XML Filter Dialog
 238     XMLFilterTabDialog aDlg(m_xDialog.get(), mxContext, pOldInfo);
 239     if (aDlg.run() == RET_OK)
 240     {
 241         filter_info_impl* pNewInfo = aDlg.getNewFilterInfo();
 242
 243         if( !(*pOldInfo == *pNewInfo) )
 244         {
 245             // change filter
 246             insertOrEdit( pNewInfo, pOldInfo );
 247         }
 248     }
 249 }
 250
 251 /** helper to create a sequence of strings from an extensions strings
 252     "ext1;ext2;ext3" will become { "ext1", "ext2", "ext3" } */
 253 static Sequence< OUString > createExtensionsSequence( const OUString& rExtensions )
 254 {
 255     // first count how many extensions we have inside the string
 256     int nExtensions = 0;
 257
 258     int nLength = rExtensions.getLength();
 259     if( nLength )
 260     {
 261         // a non empty string has at least one extension
 262         nExtensions++;
 263
 264         // now count the delimiters ';'
 265         const sal_Unicode * pString = rExtensions.getStr();
 266         int i;
 267         for( i = 0; i < nLength; i++, pString++ )
 268         {
 269             if( *pString == ';' )
 270                 nExtensions++;
 271         }
 272     }
 273
 274     Sequence< OUString > aExtensions( nExtensions );
 275
 276     // extract the extensions from the source string and fill the sequence
 277
 278     int nLastIndex = 0;
 279     int nCurrentIndex = 0;
 280     int i;
 281
 282     for( i = 0; i < nExtensions; i++ )
 283     {
 284         nLastIndex = rExtensions.indexOf( ';', nLastIndex );
 285
 286         if( nLastIndex == -1 )
 287         {
 288             aExtensions[i] = rExtensions.copy( nCurrentIndex );
 289             break;
 290         }
 291         else
 292         {
 293             aExtensions[i] = rExtensions.copy( nCurrentIndex, nLastIndex - nCurrentIndex );
 294             nCurrentIndex = nLastIndex + 1;
 295             nLastIndex = nCurrentIndex;
 296         }
 297     }
 298
 299     return aExtensions;
 300 }
 301
 302 /** checks if the given name is unique inside the filter factory. If not,
 303     numbers are added until the returned name is unique */
 304 OUString XMLFilterSettingsDialog::createUniqueFilterName( const OUString& rFilterName )
 305 {
 306     OUString aFilterName( rFilterName );
 307
 308     sal_Int32 nId = 2;
 309
 310     while( mxFilterContainer->hasByName( aFilterName ) )
 311     {
 312         aFilterName = rFilterName + " " + OUString::number( nId++ );
 313     }
 314
 315     return aFilterName;
 316 }
 317
 318 /** checks if the given name is unique inside the type detection. If not,
 319     numbers are added until the returned name is unique */
 320 OUString XMLFilterSettingsDialog::createUniqueTypeName( const OUString& rTypeName )
 321 {
 322     OUString aTypeName( rTypeName );
 323
 324     sal_Int32 nId = 2;
 325
 326     while( mxFilterContainer->hasByName( aTypeName ) )
 327     {
 328         aTypeName = rTypeName + " " + OUString::number( nId++ );
 329     }
 330
 331     return aTypeName;
 332 }
 333
 334 /** checks if the given name is a unique ui name inside the filter factory. If not,
 335     numbers are added until the returned name is unique */
 336 OUString XMLFilterSettingsDialog::createUniqueInterfaceName( const OUString& rInterfaceName )
 337 {
 338     sal_Int32 nDefaultNumber = 0;
 339
 340     try
 341     {
 342         const Sequence< OUString > aFilterNames( mxFilterContainer->getElementNames() );
 343
 344         Sequence< PropertyValue > aValues;
 345         for( OUString const & filterName : aFilterNames)
 346         {
 347             Any aAny( mxFilterContainer->getByName( filterName ) );
 348             if( !(aAny >>= aValues) )
 349                 continue;
 350
 351             const sal_Int32 nValueCount( aValues.getLength() );
 352             PropertyValue* pValues = aValues.getArray();
 353             sal_Int32 nValue;
 354
 355             for( nValue = 0; nValue < nValueCount; nValue++, pValues++ )
 356             {
 357                 if ( pValues->Name == "UIName" )
 358                 {
 359                     OUString aInterfaceName;
 360                     pValues->Value >>= aInterfaceName;
 361
 362
 363                     // see if this filter matches our default filter name
 364                     if( aInterfaceName.match( rInterfaceName ) )
 365                     {
 366                         // if yes, make sure we generate a unique name with a higher number
 367                         // this is dump but fast
 368                         sal_Int32 nNumber = aInterfaceName.copy( rInterfaceName.getLength() ).toInt32();
 369                         if( nNumber >= nDefaultNumber )
 370                             nDefaultNumber = nNumber + 1;
 371                     }
 372                 }
 373             }
 374         }
 375     }
 376     catch( const Exception& )
 377     {
 378         TOOLS_WARN_EXCEPTION("filter.xslt", "");
 379     }
 380
 381     OUString aInterfaceName( rInterfaceName );
 382     if( nDefaultNumber )
 383     {
 384         aInterfaceName += " " + OUString::number( nDefaultNumber );
 385     }
 386
 387     return aInterfaceName;
 388 }
 389
 390 /** inserts a new filter into the ui and configuration if pOldInfo is NULL.
 391     If pOldInfo is not null, the old filter will be replaced with the new settings */
 392 bool XMLFilterSettingsDialog::insertOrEdit( filter_info_impl* pNewInfo, const filter_info_impl* pOldInfo )
 393 {
 394     bool bOk = true;
 395
 396     if( pOldInfo )
 397     {
 398         // see if we need to update the type name
 399         if( pOldInfo->maFilterName != pNewInfo->maFilterName )
 400         {
 401             if( pOldInfo->maType == pOldInfo->maFilterName )
 402             {
 403                 pNewInfo->maType.clear();
 404             }
 405         }
 406
 407         // see if we need to clean up old stuff first
 408         try
 409         {
 410             // if filter name changed, we need to remove the old filter first
 411             if( pOldInfo->maFilterName != pNewInfo->maFilterName )
 412                 mxFilterContainer->removeByName( pOldInfo->maFilterName );
 413
 414             // if type name changed, we need to remove the old type first
 415             if( pOldInfo->maType != pNewInfo->maType )
 416                 mxTypeDetection->removeByName( pOldInfo->maType );
 417         }
 418         catch( const Exception& )
 419         {
 420             TOOLS_WARN_EXCEPTION("filter.xslt", "");
 421             bOk = false;
 422         }
 423     }
 424
 425     filter_info_impl* pFilterEntry( nullptr );
 426
 427     if( bOk )
 428     {
 429         // create or copy filter info
 430         if( pOldInfo )
 431         {
 432             // change existing filter entry in filter list box
 433             pFilterEntry = const_cast<filter_info_impl*>(pOldInfo);
 434             *pFilterEntry = *pNewInfo;
 435         }
 436         else
 437         {
 438             // add new entry to filter list box
 439             pFilterEntry = new filter_info_impl( *pNewInfo );
 440         }
 441     }
 442
 443     // check if we need to copy the template
 444     if( bOk && !pFilterEntry->maImportTemplate.isEmpty() )
 445     {
 446         if( !pFilterEntry->maImportTemplate.matchIgnoreAsciiCase( m_sTemplatePath ) )
 447         {
 448             INetURLObject aSourceURL( pFilterEntry->maImportTemplate );
 449             if (!aSourceURL.GetLastName().isEmpty())
 450             {
 451                 OUString aDestURL = m_sTemplatePath + pFilterEntry->maFilterName + "/";
 452                 if( createDirectory( aDestURL ) )
 453                 {
 454                     aDestURL += aSourceURL.GetLastName();
 455
 456                     SvFileStream aInputStream(pFilterEntry->maImportTemplate, StreamMode::READ );
 457                     Reference< XInputStream > xIS( new utl::OInputStreamWrapper( aInputStream ) );
 458                     SvFileStream aOutputStream(aDestURL, StreamMode::WRITE );
 459                     Reference< XOutputStream > xOS(  new utl::OOutputStreamWrapper( aOutputStream ) );
 460
 461                     if( copyStreams( xIS, xOS ) )
 462                         pFilterEntry->maImportTemplate = aDestURL;
 463                 }
 464             }
 465         }
 466     }
 467
 468     if( bOk )
 469     {
 470         if( pFilterEntry->maType.isEmpty() )
 471         {
 472             pFilterEntry->maType = createUniqueTypeName( pNewInfo->maFilterName );
 473         }
 474
 475         // update import/export flags
 476         if( !pFilterEntry->maImportXSLT.isEmpty() )
 477         {
 478             pFilterEntry->maFlags |= 1;
 479         }
 480         else
 481         {
 482             pFilterEntry->maFlags &= ~1;
 483         }
 484
 485         if( !pFilterEntry->maExportXSLT.isEmpty() )
 486         {
 487             pFilterEntry->maFlags |= 2;
 488         }
 489         else
 490         {
 491             pFilterEntry->maFlags &= ~2;
 492         }
 493         pFilterEntry->maFlags |= 0x80040;
 494
 495         // 2. create user data for filter entry
 496         Sequence< OUString > aUserData( pFilterEntry->getFilterUserData());
 497
 498         // 3. create property values for filter entry
 499         Sequence< PropertyValue > aFilterData( 8 );
 500
 501         aFilterData[0].Name = "Type";
 502         aFilterData[0].Value <<= pFilterEntry->maType;
 503
 504         aFilterData[1].Name = "UIName";
 505         aFilterData[1].Value <<= pFilterEntry->maInterfaceName;
 506
 507         aFilterData[2].Name = "DocumentService";
 508         aFilterData[2].Value <<= pFilterEntry->maDocumentService;
 509
 510         aFilterData[3].Name = "FilterService";
 511         aFilterData[3].Value <<= OUString( "com.sun.star.comp.Writer.XmlFilterAdaptor" );
 512
 513         aFilterData[4].Name = "Flags";
 514         aFilterData[4].Value <<= pFilterEntry->maFlags;
 515
 516         aFilterData[5].Name = "UserData";
 517         aFilterData[5].Value <<= aUserData;
 518
 519         aFilterData[6].Name = "FileFormatVersion";
 520         aFilterData[6].Value <<= pFilterEntry->maFileFormatVersion;
 521
 522         aFilterData[7].Name = "TemplateName";
 523         aFilterData[7].Value <<= pFilterEntry->maImportTemplate;
 524
 525         // 4. insert new or replace existing filter
 526         try
 527         {
 528             Any aAny( makeAny( aFilterData ) );
 529             if( mxFilterContainer->hasByName( pFilterEntry->maFilterName ) )
 530             {
 531                 mxFilterContainer->replaceByName( pFilterEntry->maFilterName, aAny );
 532             }
 533             else
 534             {
 535                 mxFilterContainer->insertByName( pFilterEntry->maFilterName, aAny );
 536             }
 537         }
 538         catch( const Exception& )
 539         {
 540             TOOLS_WARN_EXCEPTION("filter.xslt", "");
 541             bOk = false;
 542         }
 543     }
 544
 545     // 5. prepare type information
 546     if( bOk )
 547     {
 548         Sequence< PropertyValue > aValues(4);
 549
 550         aValues[0].Name = "UIName";
 551         aValues[0].Value <<= pFilterEntry->maInterfaceName;
 552         aValues[1].Name = "ClipboardFormat";
 553         OUString aDocType;
 554         if( !pFilterEntry->maDocType.match( m_sDocTypePrefix ) )
 555         {
 556             aDocType = m_sDocTypePrefix + pFilterEntry->maDocType;
 557         }
 558         else
 559         {
 560             aDocType = pFilterEntry->maDocType;
 561         }
 562         if (aDocType == m_sDocTypePrefix)
 563             aValues[1].Value <<= OUString();
 564         else
 565             aValues[1].Value <<= aDocType;
 566
 567         aValues[2].Name = "DocumentIconID";
 568         aValues[2].Value <<= pFilterEntry->mnDocumentIconID;
 569
 570         aValues[3].Name = "Extensions";
 571         aValues[3].Value <<= createExtensionsSequence( pFilterEntry->maExtension );
 572
 573         // the detect service will only be registered, if a doctype/search token was specified
 574         if (aDocType.getLength() > m_sDocTypePrefix.getLength())
 575         {
 576             aValues.realloc(5);
 577             aValues[4].Name = "DetectService";
 578             aValues[4].Value <<= OUString( "com.sun.star.comp.filters.XMLFilterDetect" );
 579         }
 580
 581         // 6. insert new or replace existing type information
 582         if( mxTypeDetection.is() )
 583         {
 584             try
 585             {
 586                 Any aAny( makeAny( aValues ) );
 587                 if( mxTypeDetection->hasByName( pFilterEntry->maType ) )
 588                 {
 589                     mxTypeDetection->replaceByName( pFilterEntry->maType, aAny );
 590                 }
 591                 else
 592                 {
 593                     mxTypeDetection->insertByName( pFilterEntry->maType, aAny );
 594                 }
 595             }
 596             catch( const Exception& )
 597             {
 598                 TOOLS_WARN_EXCEPTION("filter.xslt", "");
 599                 bOk = false;
 600             }
 601         }
 602
 603         if( bOk )
 604         {
 605             try
 606             {
 607                 Reference< XFlushable > xFlushable( mxTypeDetection, UNO_QUERY );
 608                 if( xFlushable.is() )
 609                     xFlushable->flush();
 610             }
 611             catch( const Exception& )
 612             {
 613                 TOOLS_WARN_EXCEPTION("filter.xslt", "");
 614                 bOk = false;
 615             }
 616         }
 617
 618         if( !bOk )
 619         {
 620             // we failed to add the type, so lets remove the filter
 621             try
 622             {
 623                 mxFilterContainer->removeByName( pFilterEntry->maFilterName );
 624             }
 625             catch( const Exception& )
 626             {
 627                 TOOLS_WARN_EXCEPTION("filter.xslt", "");
 628                 bOk = false;
 629             }
 630         }
 631         else // bOk
 632         {
 633             try
 634             {
 635                 Reference< XFlushable > xFlushable( mxFilterContainer, UNO_QUERY );
 636                 if( xFlushable.is() )
 637                     xFlushable->flush();
 638             }
 639             catch( const Exception& )
 640             {
 641                 TOOLS_WARN_EXCEPTION("filter.xslt", "");
 642                 bOk = false;
 643             }
 644
 645             if( !bOk )
 646             {
 647                 // we failed to add the filter, so lets remove the type
 648                 try
 649                 {
 650                     mxTypeDetection->removeByName( pFilterEntry->maType );
 651                 }
 652                 catch( const Exception& )
 653                 {
 654                     TOOLS_WARN_EXCEPTION("filter.xslt", "");
 655                 }
 656
 657             }
 658         }
 659     }
 660
 661     if( bOk )
 662     {
 663         if( mxExtendedTypeDetection.is() )
 664         {
 665             OUString sFilterDetectService( "com.sun.star.comp.filters.XMLFilterDetect" );
 666             if( mxExtendedTypeDetection->hasByName( sFilterDetectService ) )
 667             {
 668                 Sequence< PropertyValue > aSequence;
 669                 if( mxExtendedTypeDetection->getByName( sFilterDetectService ) >>= aSequence )
 670                 {
 671                     sal_Int32 nCount = aSequence.getLength();
 672                     sal_Int32 nIndex;
 673                     for( nIndex = 0; nIndex < nCount; nIndex++ )
 674                     {
 675                         if ( aSequence[nIndex].Name == "Types" )
 676                         {
 677                             Sequence< OUString > aTypes;
 678                             if( aSequence[nIndex].Value >>= aTypes )
 679                             {
 680                                 sal_Int32 nStrCount = aTypes.getLength();
 681                                 sal_Int32 nStr;
 682                                 for( nStr = 0; nStr < nStrCount; nStr++ )
 683                                 {
 684                                     if( aTypes[nStr] == pFilterEntry->maType )
 685                                         break;
 686                                 }
 687
 688                                 if( nStr == nStrCount )
 689                                 {
 690                                     aTypes.realloc( nStrCount + 1 );
 691                                     aTypes[nStrCount] = pFilterEntry->maType;
 692
 693                                     aSequence[nIndex].Value <<= aTypes;
 694
 695                                     mxExtendedTypeDetection->replaceByName( sFilterDetectService, makeAny( aSequence ) );
 696
 697                                     Reference< XFlushable > xFlushable( mxExtendedTypeDetection, UNO_QUERY );
 698                                     if( xFlushable.is() )
 699                                         xFlushable->flush();
 700                                 }
 701                             }
 702
 703                             break;
 704                         }
 705                     }
 706                 }
 707             }
 708         }
 709     }
 710
 711     // update ui
 712     if( bOk )
 713     {
 714         if( pOldInfo )
 715         {
 716             changeEntry( pFilterEntry );
 717         }
 718         else
 719         {
 720             addFilterEntry( pFilterEntry );
 721             maFilterVector.push_back( std::unique_ptr<filter_info_impl>(pFilterEntry) );
 722         }
 723     }
 724
 725     return bOk;
 726 }
 727
 728 /** is called when the user clicks the "Test" button */
 729 void XMLFilterSettingsDialog::onTest()
 730 {
 731     // get the first selected filter
 732     filter_info_impl* pInfo = reinterpret_cast<filter_info_impl*>(m_xFilterListBox->get_selected_id().toInt64());
 733     if (pInfo)
 734     {
 735         XMLFilterTestDialog aDlg(m_xDialog.get(), mxContext);
 736         aDlg.test( *pInfo );
 737     }
 738 }
 739
 740 void XMLFilterSettingsDialog::onDelete()
 741 {
 742     int nIndex = m_xFilterListBox->get_selected_index();
 743     if (nIndex == -1)
 744         return;
 745     filter_info_impl* pInfo = reinterpret_cast<filter_info_impl*>(m_xFilterListBox->get_id(nIndex).toInt64());
 746     if (pInfo)
 747     {
 748         OUString aMessage(XsltResId(STR_WARN_DELETE));
 749         aMessage = aMessage.replaceFirst( "%s", pInfo->maFilterName );
 750
 751         std::unique_ptr<weld::MessageDialog> xWarn(Application::CreateMessageDialog(m_xDialog.get(),
 752                                                    VclMessageType::Warning, VclButtonsType::YesNo,
 753                                                    aMessage));
 754         xWarn->set_default_response(RET_YES);
 755         if (xWarn->run() == RET_YES)
 756         {
 757             try
 758             {
 759                 if( mxFilterContainer->hasByName( pInfo->maFilterName ) )
 760                 {
 761                     mxFilterContainer->removeByName( pInfo->maFilterName );
 762
 763                     bool bTypeStillUsed = false;
 764
 765                     // now loop over all filter and see if someone else uses the same type
 766                     Sequence< OUString > aFilterNames( mxFilterContainer->getElementNames() );
 767                     OUString* pFilterName = aFilterNames.getArray();
 768
 769                     const sal_Int32 nCount = aFilterNames.getLength();
 770                     sal_Int32 nFilter;
 771                     Sequence< PropertyValue > aValues;
 772
 773                     for( nFilter = 0; (nFilter < nCount) && !bTypeStillUsed; nFilter++, pFilterName++ )
 774                     {
 775                         Any aAny( mxFilterContainer->getByName( *pFilterName ) );
 776                         if( !(aAny >>= aValues) )
 777                             continue;
 778
 779                         const sal_Int32 nValueCount( aValues.getLength() );
 780                         PropertyValue* pValues = aValues.getArray();
 781                         sal_Int32 nValue;
 782
 783                         for (nValue = 0; nValue < nValueCount; nValue++, pValues++)
 784                         {
 785                             if ( pValues->Name == "Type" )
 786                             {
 787                                 OUString aType;
 788                                 pValues->Value >>= aType;
 789                                 if( aType == pInfo->maType )
 790                                     bTypeStillUsed = true;
 791
 792                                 break;
 793                             }
 794                         }
 795                     }
 796
 797                     // if the type is not used anymore, remove it also
 798                     if( !bTypeStillUsed )
 799                     {
 800                         if( mxTypeDetection->hasByName( pInfo->maType ) )
 801                         {
 802                             mxTypeDetection->removeByName( pInfo->maType );
 803                         }
 804                     }
 805
 806                     Reference< XFlushable > xFlushable( mxFilterContainer, UNO_QUERY );
 807                     if( xFlushable.is() )
 808                         xFlushable->flush();
 809
 810                     xFlushable.set( mxTypeDetection, UNO_QUERY );
 811                     if( xFlushable.is() )
 812                         xFlushable->flush();
 813
 814                     // now remove entry from ui
 815                     m_xFilterListBox->remove(nIndex);
 816
 817                     // and delete the filter entry
 818                     maFilterVector.erase(std::find_if( maFilterVector.begin(), maFilterVector.end(),
 819                                             [&] (std::unique_ptr<filter_info_impl> const & p)
 820                                             { return p.get() == pInfo; }));
 821                 }
 822             }
 823             catch( const Exception& )
 824             {
 825                 TOOLS_WARN_EXCEPTION("filter.xslt", "");
 826             }
 827         }
 828     }
 829
 830     updateStates();
 831 }
 832
 833 void XMLFilterSettingsDialog::onSave()
 834 {
 835     std::vector<filter_info_impl*> aFilters;
 836
 837     int nFilters = 0;
 838
 839     m_xFilterListBox->selected_foreach([&](weld::TreeIter& rEntry){
 840         filter_info_impl* pInfo = reinterpret_cast<filter_info_impl*>(m_xFilterListBox->get_id(rEntry).toInt64());
 841         aFilters.push_back(pInfo);
 842         ++nFilters;
 843         return false;
 844     });
 845
 846     // Open Fileopen-Dialog
 847     ::sfx2::FileDialogHelper aDlg(
 848         css::ui::dialogs::TemplateDescription::FILESAVE_AUTOEXTENSION,
 849         FileDialogFlags::NONE, m_xDialog.get());
 850
 851     OUString aExtensions( "*.jar" );
 852     OUString aFilterName = XsltResId(STR_FILTER_PACKAGE) +
 853         " (" + aExtensions + ")";
 854
 855     aDlg.AddFilter( aFilterName, aExtensions );
 856
 857     if ( aDlg.Execute() != ERRCODE_NONE )
 858         return;
 859
 860     XMLFilterJarHelper aJarHelper( mxContext );
 861     aJarHelper.savePackage( aDlg.GetPath(), aFilters );
 862
 863     INetURLObject aURL( aDlg.GetPath() );
 864
 865     OUString sPlaceholder( "%s" );
 866
 867     OUString aMsg;
 868     if( nFilters > 0 )
 869     {
 870         aMsg = XsltResId(STR_FILTERS_HAVE_BEEN_SAVED);
 871         aMsg = aMsg.replaceFirst( sPlaceholder, OUString::number( nFilters ) );
 872         aMsg = aMsg.replaceFirst(sPlaceholder, aURL.GetLastName());
 873     }
 874     else
 875     {
 876         aMsg = XsltResId(STR_FILTER_HAS_BEEN_SAVED);
 877         aMsg = aMsg.replaceFirst( sPlaceholder, (*aFilters.begin())->maFilterName );
 878         aMsg = aMsg.replaceFirst(sPlaceholder, aURL.GetLastName());
 879     }
 880
 881     std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(m_xDialog.get(),
 882                                                   VclMessageType::Info, VclButtonsType::Ok,
 883                                                   aMsg));
 884     xInfoBox->run();
 885 }
 886
 887 void XMLFilterSettingsDialog::onOpen()
 888 {
 889     std::vector< std::unique_ptr<filter_info_impl> > aFilters;
 890
 891     // Open Fileopen-Dialog
 892     ::sfx2::FileDialogHelper aDlg(
 893     css::ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE,
 894     FileDialogFlags::NONE, m_xDialog.get());
 895
 896     OUString aExtensions( "*.jar" );
 897     OUString aFilterName = XsltResId(STR_FILTER_PACKAGE) +
 898         " (" + aExtensions + ")";
 899
 900     aDlg.AddFilter( aFilterName, aExtensions );
 901
 902     if ( aDlg.Execute() != ERRCODE_NONE )
 903         return;
 904
 905     OUString aURL( aDlg.GetPath() );
 906
 907     XMLFilterJarHelper aJarHelper( mxContext );
 908     aJarHelper.openPackage( aURL, aFilters );
 909
 910     int nFilters = 0;
 911     for (auto& filter : aFilters)
 912     {
 913         if( insertOrEdit(filter.get()) )
 914         {
 915             aFilterName = filter->maFilterName;
 916             nFilters++;
 917         }
 918
 919         filter.reset();
 920     }
 921
 922     disposeFilterList();
 923     initFilterList();
 924
 925     OUString sPlaceholder( "%s" );
 926     OUString aMsg;
 927     if( nFilters == 0 )
 928     {
 929         INetURLObject aURLObj( aURL );
 930         aMsg = XsltResId(STR_NO_FILTERS_FOUND);
 931         aMsg = aMsg.replaceFirst(sPlaceholder, aURLObj.GetLastName());
 932     }
 933     else if( nFilters == 1 )
 934     {
 935         aMsg = XsltResId(STR_FILTER_INSTALLED);
 936         aMsg = aMsg.replaceFirst( sPlaceholder, aFilterName );
 937
 938     }
 939     else
 940     {
 941         aMsg = XsltResId(STR_FILTERS_INSTALLED);
 942         aMsg = aMsg.replaceFirst( sPlaceholder, OUString::number( nFilters ) );
 943     }
 944
 945     std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(m_xDialog.get(),
 946                                                   VclMessageType::Info, VclButtonsType::Ok,
 947                                                   aMsg));
 948     xInfoBox->run();
 949 }
 950
 951 void XMLFilterSettingsDialog::disposeFilterList()
 952 {
 953     maFilterVector.clear();
 954     m_xFilterListBox->clear();
 955 }
 956
 957 void XMLFilterSettingsDialog::initFilterList()
 958 {
 959     if( mxFilterContainer.is() )
 960     {
 961         const Sequence< OUString > aFilterNames( mxFilterContainer->getElementNames() );
 962
 963         Sequence< PropertyValue > aValues;
 964
 965         std::unique_ptr<filter_info_impl> pTempFilter( new filter_info_impl );
 966         Sequence< OUString > aUserData;
 967
 968         for( OUString const & filterName : aFilterNames )
 969         {
 970             aUserData.realloc(0);
 971
 972             try
 973             {
 974                 Any aAny( mxFilterContainer->getByName( filterName ) );
 975                 if( !(aAny >>= aValues) )
 976                     continue;
 977
 978                 OUString aFilterService;
 979                 pTempFilter->maFilterName = filterName;
 980
 981                 const sal_Int32 nValueCount( aValues.getLength() );
 982                 PropertyValue* pValues = aValues.getArray();
 983                 sal_Int32 nValue;
 984
 985                 for( nValue = 0; nValue < nValueCount; nValue++, pValues++ )
 986                 {
 987                     if ( pValues->Name == "Type" )
 988                     {
 989                         pValues->Value >>= pTempFilter->maType;
 990                     }
 991                     else if ( pValues->Name == "UIName" )
 992                     {
 993                         pValues->Value >>= pTempFilter->maInterfaceName;
 994                     }
 995                     else if ( pValues->Name == "DocumentService" )
 996                     {
 997                         pValues->Value >>= pTempFilter->maDocumentService;
 998                     }
 999                     else if ( pValues->Name == "FilterService" )
1000                     {
1001                         pValues->Value >>= aFilterService;
1002                     }
1003                     else if ( pValues->Name == "Flags" )
1004                     {
1005                         pValues->Value >>= pTempFilter->maFlags;
1006                     }
1007                     else if ( pValues->Name == "UserData" )
1008                     {
1009                         pValues->Value >>= aUserData;
1010                     }
1011                     else if ( pValues->Name == "FileFormatVersion" )
1012                     {
1013                         pValues->Value >>= pTempFilter->maFileFormatVersion;
1014                     }
1015                     else if ( pValues->Name == "TemplateName" )
1016                     {
1017                         pValues->Value >>= pTempFilter->maImportTemplate;
1018                     }
1019                     else if ( pValues->Name == "Finalized" )
1020                     {
1021                         pValues->Value >>= pTempFilter->mbReadonly;
1022                     }
1023                 }
1024
1025                 // if this is not a XmlFilterAdaptor entry, skip it
1026                 if( aFilterService != "com.sun.star.comp.Writer.XmlFilterAdaptor" )
1027                     continue;
1028
1029
1030                 // if we don't have the needed user data, skip it
1031                 if( aUserData.getLength() < 6 )
1032                     continue;
1033
1034                 // if this is not an XSLTFilter entry, skip it
1035                 if( aUserData[0] != "com.sun.star.documentconversion.XSLTFilter" )
1036                     continue;
1037
1038                 // get filter information from userdata
1039                 pTempFilter->mbNeedsXSLT2 = aUserData[1].toBoolean();
1040                 pTempFilter->maImportService = aUserData[2];
1041                 pTempFilter->maExportService = aUserData[3];
1042                 pTempFilter->maImportXSLT = aUserData[4];
1043                 pTempFilter->maExportXSLT = aUserData[5];
1044                 if( aUserData.getLength() >= 8 )
1045                     pTempFilter->maComment = aUserData[7];
1046
1047                 // get type information
1048                 if( mxTypeDetection.is() )
1049                 {
1050                     try
1051                     {
1052                         aAny = mxTypeDetection->getByName( pTempFilter->maType );
1053                         Sequence< PropertyValue > aValues2;
1054
1055                         if( aAny >>= aValues2 )
1056                         {
1057                             const sal_Int32 nValueCount2( aValues2.getLength() );
1058                             PropertyValue* pValues2 = aValues2.getArray();
1059                             sal_Int32 nValue2;
1060
1061                             for( nValue2 = 0; nValue2 < nValueCount2; nValue2++, pValues2++ )
1062                             {
1063                                 if ( pValues2->Name == "ClipboardFormat" )
1064                                 {
1065                                     OUString aDocType;
1066                                     pValues2->Value >>= aDocType;
1067
1068                                     if( aDocType.match( m_sDocTypePrefix ) )
1069                                         aDocType = aDocType.copy( m_sDocTypePrefix.getLength() );
1070
1071                                     pTempFilter->maDocType = aDocType;
1072                                 }
1073                                 else if ( pValues2->Name == "Extensions" )
1074                                 {
1075                                     Sequence< OUString > aExtensions;
1076                                     if( pValues2->Value >>= aExtensions )
1077                                     {
1078                                         pTempFilter->maExtension.clear();
1079
1080                                         sal_Int32 nCount3( aExtensions.getLength() );
1081                                         OUString* pExtensions = aExtensions.getArray();
1082                                         sal_Int32 n;
1083                                         for( n = 0; n < nCount3; n++ )
1084                                         {
1085                                             if( n > 0 )
1086                                                 pTempFilter->maExtension += ";";
1087                                             pTempFilter->maExtension += *pExtensions++;
1088                                         }
1089                                     }
1090                                 }
1091                                 else if ( pValues2->Name == "DocumentIconID" )
1092                                 {
1093                                     pValues2->Value >>= pTempFilter->mnDocumentIconID;
1094                                 }
1095                                 else if ( pValues2->Name == "Finalized" )
1096                                 {
1097                                     // both the filter and the type may be finalized
1098                                     bool bTemp = false;
1099                                     pValues2->Value >>= bTemp;
1100                                     pTempFilter->mbReadonly |= bTemp;
1101                                 }
1102                             }
1103                         }
1104                     }
1105                     catch( const css::container::NoSuchElementException& )
1106                     {
1107                         OSL_FAIL( "Type not found, user error?" ); // TODO: error?
1108                     }
1109                 }
1110
1111                 // add entry to internal container and to ui filter list box
1112                 maFilterVector.push_back( std::unique_ptr<filter_info_impl>(pTempFilter.get()) );
1113                 addFilterEntry( pTempFilter.release() );
1114
1115
1116                 pTempFilter.reset( new filter_info_impl );
1117             }
1118             catch( const Exception& )
1119             {
1120                 TOOLS_WARN_EXCEPTION("filter.xslt", "");
1121             }
1122
1123         }
1124     }
1125
1126     if (m_xFilterListBox->n_children())
1127     {
1128         m_xFilterListBox->columns_autosize();
1129         m_xFilterListBox->select(0);
1130     }
1131 }
1132
1133 application_info_impl::application_info_impl( const char * pDocumentService, const OUString& rUINameRes, const char * mpXMLImporter, const char * mpXMLExporter )
1134 :   maDocumentService( pDocumentService, strlen( pDocumentService ), RTL_TEXTENCODING_ASCII_US ),
1135     maDocumentUIName(Translate::ExpandVariables(rUINameRes)),
1136     maXMLImporter( mpXMLImporter, strlen( mpXMLImporter ), RTL_TEXTENCODING_ASCII_US ),
1137     maXMLExporter( mpXMLExporter, strlen( mpXMLExporter ), RTL_TEXTENCODING_ASCII_US )
1138 {
1139 }
1140
1141 std::vector< application_info_impl > const & getApplicationInfos()
1142 {
1143     static std::vector< application_info_impl > const aInfos
1144     {
1145         {   "com.sun.star.text.TextDocument",
1146             STR_APPL_NAME_WRITER,
1147             "com.sun.star.comp.Writer.XMLImporter",
1148             "com.sun.star.comp.Writer.XMLExporter" },
1149
1150         {   "com.sun.star.sheet.SpreadsheetDocument",
1151             STR_APPL_NAME_CALC,
1152             "com.sun.star.comp.Calc.XMLImporter",
1153             "com.sun.star.comp.Calc.XMLExporter" },
1154
1155         {  "com.sun.star.presentation.PresentationDocument",
1156             STR_APPL_NAME_IMPRESS,
1157             "com.sun.star.comp.Impress.XMLImporter",
1158             "com.sun.star.comp.Impress.XMLExporter" },
1159
1160         {   "com.sun.star.drawing.DrawingDocument",
1161             STR_APPL_NAME_DRAW,
1162             "com.sun.star.comp.Draw.XMLImporter",
1163             "com.sun.star.comp.Draw.XMLExporter" },
1164
1165         // --- oasis file formats...
1166         {   "com.sun.star.text.TextDocument",
1167             STR_APPL_NAME_OASIS_WRITER,
1168             "com.sun.star.comp.Writer.XMLOasisImporter",
1169             "com.sun.star.comp.Writer.XMLOasisExporter" },
1170
1171         {   "com.sun.star.sheet.SpreadsheetDocument",
1172             STR_APPL_NAME_OASIS_CALC,
1173             "com.sun.star.comp.Calc.XMLOasisImporter",
1174             "com.sun.star.comp.Calc.XMLOasisExporter" },
1175
1176         {   "com.sun.star.presentation.PresentationDocument",
1177             STR_APPL_NAME_OASIS_IMPRESS,
1178             "com.sun.star.comp.Impress.XMLOasisImporter",
1179             "com.sun.star.comp.Impress.XMLOasisExporter" },
1180
1181         {  "com.sun.star.drawing.DrawingDocument",
1182             STR_APPL_NAME_OASIS_DRAW,
1183             "com.sun.star.comp.Draw.XMLOasisImporter",
1184             "com.sun.star.comp.Draw.XMLOasisExporter" },
1185     };
1186
1187     return aInfos;
1188 }
1189
1190 const application_info_impl* getApplicationInfo( const OUString& rServiceName )
1191 {
1192     std::vector< application_info_impl > const & rInfos = getApplicationInfos();
1193     for (auto const& info : rInfos)
1194     {
1195         if( rServiceName == info.maXMLExporter ||
1196             rServiceName == info.maXMLImporter)
1197         {
1198             return &info;
1199         }
1200     }
1201     return nullptr;
1202 }
1203
1204 OUString getApplicationUIName( const OUString& rServiceName )
1205 {
1206     const application_info_impl* pInfo = getApplicationInfo( rServiceName );
1207     if( pInfo )
1208     {
1209         return pInfo->maDocumentUIName;
1210     }
1211     else
1212     {
1213         OUString aRet = XsltResId(STR_UNKNOWN_APPLICATION);
1214         if( !rServiceName.isEmpty() )
1215         {
1216             aRet += " (" + rServiceName + ")";
1217         }
1218         return aRet;
1219     }
1220 }
1221
1222 /** adds a new filter info entry to the ui filter list */
1223 void XMLFilterSettingsDialog::addFilterEntry( const filter_info_impl* pInfo )
1224 {
1225     int nRow = m_xFilterListBox->n_children();
1226     OUString sId(OUString::number(reinterpret_cast<sal_Int64>(pInfo)));
1227     m_xFilterListBox->append(sId, pInfo->maFilterName);
1228     m_xFilterListBox->set_text(nRow, getEntryString(pInfo), 1);
1229 }
1230
1231 void XMLFilterSettingsDialog::changeEntry( const filter_info_impl* pInfo )
1232 {
1233     const int nCount = m_xFilterListBox->n_children();
1234     for(int nPos = 0; nPos < nCount; ++nPos)
1235     {
1236         filter_info_impl* pEntry = reinterpret_cast<filter_info_impl*>(m_xFilterListBox->get_id(nPos).toInt64());
1237         if (pEntry == pInfo)
1238         {
1239             m_xFilterListBox->set_text(nPos, pInfo->maFilterName, 0);
1240             m_xFilterListBox->set_text(nPos, getEntryString(pInfo), 1);
1241             break;
1242         }
1243     }
1244 }
1245
1246 OUString XMLFilterSettingsDialog::getEntryString( const filter_info_impl* pInfo )
1247 {
1248     OUString aEntryStr;
1249     if ( !pInfo->maExportService.isEmpty() )
1250         aEntryStr = getApplicationUIName( pInfo->maExportService );
1251     else
1252         aEntryStr = getApplicationUIName( pInfo->maImportService );
1253     aEntryStr += " - ";
1254
1255     if( pInfo->maFlags & 1 )
1256     {
1257         if( pInfo->maFlags & 2 )
1258         {
1259             aEntryStr += XsltResId(STR_IMPORT_EXPORT);
1260         }
1261         else
1262         {
1263             aEntryStr += XsltResId(STR_IMPORT_ONLY);
1264         }
1265     }
1266     else if( pInfo->maFlags & 2 )
1267     {
1268         aEntryStr += XsltResId(STR_EXPORT_ONLY);
1269     }
1270     else
1271     {
1272         aEntryStr += XsltResId(STR_UNDEFINED_FILTER);
1273     }
1274
1275     return aEntryStr;
1276 }
1277
1278 filter_info_impl::filter_info_impl()
1279     : maFlags(0x00080040)
1280     , maFileFormatVersion(0)
1281     , mnDocumentIconID(0)
1282     , mbReadonly(false)
1283     , mbNeedsXSLT2(false)
1284 {
1285 }
1286
1287 bool filter_info_impl::operator==( const filter_info_impl& r ) const
1288 {
1289     return maFilterName == r.maFilterName &&
1290         maType == r.maType &&
1291         maDocumentService == r.maDocumentService &&
1292         maInterfaceName == r.maInterfaceName &&
1293         maComment == r.maComment &&
1294         maExtension == r.maExtension &&
1295         maDocType == r.maDocType &&
1296         maExportXSLT == r.maExportXSLT &&
1297         maImportXSLT == r.maImportXSLT &&
1298         maExportService == r.maExportService &&
1299         maImportService == r.maImportService &&
1300         maImportTemplate == r.maImportTemplate &&
1301         maFlags == r.maFlags &&
1302         maFileFormatVersion == r.maFileFormatVersion &&
1303         mbNeedsXSLT2 == r.mbNeedsXSLT2;
1304 }
1305
1306
1307 Sequence< OUString > filter_info_impl::getFilterUserData() const
1308 {
1309     Sequence< OUString > aUserData(8);
1310
1311     aUserData[0] = "com.sun.star.documentconversion.XSLTFilter";
1312     aUserData[1] = OUString::boolean( mbNeedsXSLT2 );
1313     aUserData[2] = maImportService;
1314     aUserData[3] = maExportService;
1315     aUserData[4] = maImportXSLT;
1316     aUserData[5] = maExportXSLT;
1317     aUserData[7] = maComment;
1318
1319     return aUserData;
1320 }
1321
1322 OUString string_encode( const OUString & rText )
1323 {
1324     static sal_Bool const uricNoSlash[] = {
1325         false, false, false, false, false, false, false, false,
1326         false, false, false, false, false, false, false, false,
1327         false, false, false, false, false, false, false, false,
1328         false, false, false, false, false, false, false, false,
1329         false,  true, false, false,  true, false,  true,  true,  //  !"#$%&'
1330          true,  true,  true,  true, false,  true,  true, false,  // ()*+,-./
1331          true,  true,  true,  true,  true,  true,  true,  true,  // 01234567
1332          true,  true,  true, false, false,  true, false,  true,  // 89:;<=>?
1333          true,  true,  true,  true,  true,  true,  true,  true,  // @ABCDEFG
1334          true,  true,  true,  true,  true,  true,  true,  true,  // HIJKLMNO
1335          true,  true,  true,  true,  true,  true,  true,  true,  // PQRSTUVW
1336          true,  true,  true, false, false, false, false,  true,  // XYZ[\]^_
1337         false,  true,  true,  true,  true,  true,  true,  true,  // `abcdefg
1338          true,  true,  true,  true,  true,  true,  true,  true,  // hijklmno
1339          true,  true,  true,  true,  true,  true,  true,  true,  // pqrstuvw
1340          true,  true,  true, false, false, false,  true, false}; // xyz{|}~
1341
1342
1343     return Uri::encode( rText, uricNoSlash, rtl_UriEncodeCheckEscapes, RTL_TEXTENCODING_UTF8 );
1344 }
1345
1346 OUString string_decode( const OUString & rText )
1347 {
1348     return Uri::decode( rText, rtl_UriDecodeWithCharset, RTL_TEXTENCODING_UTF8 );
1349 }
1350
1351 bool copyStreams( const Reference< XInputStream >& xIS, const Reference< XOutputStream >& xOS )
1352 {
1353     try
1354     {
1355         sal_Int32 nBufferSize = 512;
1356         Sequence< sal_Int8 > aDataBuffer(nBufferSize);
1357
1358         sal_Int32 nRead;
1359         do
1360         {
1361             nRead = xIS->readBytes( aDataBuffer, nBufferSize );
1362
1363             if( nRead )
1364             {
1365                 if( nRead < nBufferSize )
1366                 {
1367                     nBufferSize = nRead;
1368                     aDataBuffer.realloc(nRead);
1369                 }
1370
1371                 xOS->writeBytes( aDataBuffer );
1372             }
1373         }
1374         while( nRead );
1375
1376         xOS->flush();
1377
1378         return true;
1379     }
1380     catch(const Exception&)
1381     {
1382         TOOLS_WARN_EXCEPTION("filter.xslt", "");
1383     }
1384
1385     return false;
1386 }
1387
1388 bool createDirectory( OUString const & rURL )
1389 {
1390     sal_Int32 nLastIndex = sizeof( "file:///" ) - 2;
1391     while( nLastIndex != -1 )
1392     {
1393         nLastIndex = rURL.indexOf( '/', nLastIndex + 1);
1394         if( nLastIndex != -1 )
1395         {
1396             OUString aDirURL( rURL.copy( 0, nLastIndex ) );
1397             Directory aDir( aDirURL );
1398             Directory::RC rc = aDir.open();
1399             if( rc == Directory::E_NOENT )
1400                 rc = osl::Directory::create( aDirURL );
1401
1402             if( rc != Directory::E_None )
1403             {
1404                 return false;
1405             }
1406         }
1407     }
1408
1409     return true;
1410 }
1411
1412 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */