sc/source/ui/unoobj/filtuno.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/ui/dialogs/ExecutableDialogResults.hpp>
  21 #include <tools/urlobj.hxx>
  22 #include <vcl/svapp.hxx>
  23 #include <unotools/ucbstreamhelper.hxx>
  24 #include <connectivity/dbtools.hxx>
  25 #include <osl/diagnose.h>
  26
  27 #include <filtuno.hxx>
  28 #include <miscuno.hxx>
  29 #include <scdll.hxx>
  30 #include <imoptdlg.hxx>
  31 #include <asciiopt.hxx>
  32 #include <docsh.hxx>
  33 #include <globstr.hrc>
  34 #include <scresid.hxx>
  35
  36 #include <scabstdlg.hxx>
  37 #include <i18nlangtag/lang.h>
  38
  39 #include <optutil.hxx>
  40 #include <com/sun/star/uno/Any.hxx>
  41 #include <com/sun/star/uno/Sequence.hxx>
  42 #include <comphelper/namedvaluecollection.hxx>
  43 #include <comphelper/propertysequence.hxx>
  44 #include <memory>
  45
  46 using namespace com::sun::star;
  47 using namespace com::sun::star::uno;
  48 using namespace connectivity::dbase;
  49
  50 constexpr OUString SCFILTEROPTIONSOBJ_SERVICE = u"com.sun.star.ui.dialogs.FilterOptionsDialog"_ustr;
  51 constexpr OUStringLiteral SCFILTEROPTIONSOBJ_IMPLNAME = u"com.sun.star.comp.Calc.FilterOptionsDialog";
  52
  53 SC_SIMPLE_SERVICE_INFO( ScFilterOptionsObj, SCFILTEROPTIONSOBJ_IMPLNAME, SCFILTEROPTIONSOBJ_SERVICE )
  54
  55 constexpr OUStringLiteral SC_UNONAME_FILENAME = u"URL";
  56 constexpr OUStringLiteral SC_UNONAME_FILTERNAME = u"FilterName";
  57 constexpr OUString SC_UNONAME_FILTEROPTIONS = u"FilterOptions"_ustr;
  58 constexpr OUStringLiteral SC_UNONAME_INPUTSTREAM = u"InputStream";
  59
  60 constexpr OUString DBF_CHAR_SET = u"CharSet"_ustr;
  61 constexpr OUString DBF_SEP_PATH_IMPORT = u"Office.Calc/Dialogs/DBFImport"_ustr;
  62 constexpr OUString DBF_SEP_PATH_EXPORT = u"Office.Calc/Dialogs/DBFExport"_ustr;
  63
  64 namespace
  65 {
  66
  67     enum class charsetSource
  68     {
  69         charset_from_file,
  70         charset_from_user_setting,
  71         charset_default
  72     };
  73
  74     charsetSource load_CharSet(rtl_TextEncoding &nCharSet, bool bExport, SvStream* dbf_Stream)
  75     {
  76         if (dbf_Stream && dbfReadCharset(nCharSet, dbf_Stream))
  77         {
  78             return charsetSource::charset_from_file;
  79         }
  80
  81         Sequence<Any> aValues;
  82         const Any *pProperties;
  83         Sequence<OUString> aNames { DBF_CHAR_SET };
  84         ScLinkConfigItem aItem( bExport ? DBF_SEP_PATH_EXPORT : DBF_SEP_PATH_IMPORT );
  85
  86         aValues = aItem.GetProperties( aNames );
  87         pProperties = aValues.getConstArray();
  88
  89         if( pProperties[0].hasValue() )
  90         {
  91             sal_Int32 nChar = 0;
  92             pProperties[0] >>= nChar;
  93             if( nChar >= 0)
  94             {
  95                 nCharSet = static_cast<rtl_TextEncoding>(nChar);
  96                 return charsetSource::charset_from_user_setting;
  97             }
  98         }
  99
 100         // Default choice
 101         nCharSet = RTL_TEXTENCODING_IBM_850;
 102         return charsetSource::charset_default;
 103     }
 104
 105     void save_CharSet( rtl_TextEncoding nCharSet, bool bExport )
 106     {
 107         Sequence<Any> aValues;
 108         Any *pProperties;
 109         Sequence<OUString> aNames { DBF_CHAR_SET };
 110         ScLinkConfigItem aItem( bExport ? DBF_SEP_PATH_EXPORT : DBF_SEP_PATH_IMPORT );
 111
 112         aValues = aItem.GetProperties( aNames );
 113         pProperties = aValues.getArray();
 114         pProperties[0] <<= static_cast<sal_Int32>(nCharSet);
 115
 116         aItem.PutProperties(aNames, aValues);
 117     }
 118 }
 119
 120 ScFilterOptionsObj::ScFilterOptionsObj() :
 121     bExport( false )
 122 {
 123 }
 124
 125 ScFilterOptionsObj::~ScFilterOptionsObj()
 126 {
 127 }
 128
 129 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 130 Calc_FilterOptionsDialog_get_implementation(css::uno::XComponentContext*, css::uno::Sequence<css::uno::Any> const &)
 131 {
 132     SolarMutexGuard aGuard;
 133     ScDLL::Init();
 134     return cppu::acquire(new ScFilterOptionsObj);
 135 }
 136
 137 // XPropertyAccess
 138
 139 uno::Sequence<beans::PropertyValue> SAL_CALL ScFilterOptionsObj::getPropertyValues()
 140 {
 141     return comphelper::InitPropertySequence({
 142         { SC_UNONAME_FILTEROPTIONS, Any(aFilterOptions) }
 143     });
 144 }
 145
 146 void SAL_CALL ScFilterOptionsObj::setPropertyValues( const uno::Sequence<beans::PropertyValue>& aProps )
 147 {
 148     for (const beans::PropertyValue& rProp : aProps)
 149     {
 150         OUString aPropName(rProp.Name);
 151
 152         if ( aPropName == SC_UNONAME_FILENAME )
 153             rProp.Value >>= aFileName;
 154         else if ( aPropName == SC_UNONAME_FILTERNAME )
 155             rProp.Value >>= aFilterName;
 156         else if ( aPropName == SC_UNONAME_FILTEROPTIONS )
 157             rProp.Value >>= aFilterOptions;
 158         else if ( aPropName == SC_UNONAME_INPUTSTREAM )
 159             rProp.Value >>= xInputStream;
 160     }
 161 }
 162
 163 // XExecutableDialog
 164
 165 void SAL_CALL ScFilterOptionsObj::setTitle( const OUString& /* aTitle */ )
 166 {
 167     // not used
 168 }
 169
 170 sal_Int16 SAL_CALL ScFilterOptionsObj::execute()
 171 {
 172     sal_Int16 nRet = ui::dialogs::ExecutableDialogResults::CANCEL;
 173
 174     OUString aFilterString( aFilterName );
 175
 176     ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
 177
 178     if ( !bExport && aFilterString == ScDocShell::GetAsciiFilterName() )
 179     {
 180         //  ascii import is special...
 181
 182         INetURLObject aURL( aFileName );
 183         // tdf#132421 - don't URL encode filename for the import ASCII dialog title
 184         OUString aPrivDatName(aURL.GetLastName(INetURLObject::DecodeMechanism::Unambiguous));
 185         std::unique_ptr<SvStream> pInStream;
 186         if ( xInputStream.is() )
 187             pInStream = utl::UcbStreamHelper::CreateStream( xInputStream );
 188
 189         ScopedVclPtr<AbstractScImportAsciiDlg> pDlg(pFact->CreateScImportAsciiDlg(Application::GetFrameWeld(xDialogParent), aPrivDatName,
 190                                                                                   pInStream.get(), SC_IMPORTFILE));
 191         if ( pDlg->Execute() == RET_OK )
 192         {
 193             ScAsciiOptions aOptions;
 194             pDlg->GetOptions( aOptions );
 195             pDlg->SaveParameters();
 196             aFilterOptions = aOptions.WriteToString();
 197             nRet = ui::dialogs::ExecutableDialogResults::OK;
 198         }
 199     }
 200     else if ( aFilterString == ScDocShell::GetWebQueryFilterName() || aFilterString == ScDocShell::GetHtmlFilterName() )
 201     {
 202         if (bExport)
 203             nRet = ui::dialogs::ExecutableDialogResults::OK;    // export HTML without dialog
 204         else
 205         {
 206             // HTML import.
 207             ScopedVclPtr<AbstractScTextImportOptionsDlg> pDlg(
 208                 pFact->CreateScTextImportOptionsDlg(Application::GetFrameWeld(xDialogParent)));
 209
 210             if (pDlg->Execute() == RET_OK)
 211             {
 212                 LanguageType eLang = pDlg->GetLanguageType();
 213                 OUStringBuffer aBuf;
 214
 215                 aBuf.append(static_cast<sal_Int32>(static_cast<sal_uInt16>(eLang)));
 216                 aBuf.append(' ');
 217                 aBuf.append(pDlg->IsDateConversionSet() ? u'1' : u'0');
 218                 aBuf.append(' ');
 219                 aBuf.append(pDlg->IsScientificConversionSet() ? u'1' : u'0');
 220                 aFilterOptions = aBuf.makeStringAndClear();
 221                 nRet = ui::dialogs::ExecutableDialogResults::OK;
 222             }
 223         }
 224     }
 225     else
 226     {
 227         bool bDBEnc     = false;
 228         bool bAscii     = false;
 229         bool skipDialog = false;
 230
 231         sal_Unicode const cStrDel = '"';
 232         sal_Unicode cAsciiDel = ';';
 233         rtl_TextEncoding eEncoding = RTL_TEXTENCODING_DONTKNOW;
 234
 235         OUString aTitle;
 236         bool bIncludeBOM = false;
 237
 238         if ( aFilterString == ScDocShell::GetAsciiFilterName() )
 239         {
 240             //  ascii export (import is handled above)
 241
 242             INetURLObject aURL( aFileName );
 243             OUString aExt(aURL.getExtension());
 244             if (aExt.equalsIgnoreAsciiCase("CSV"))
 245                 cAsciiDel = ',';
 246             else
 247                 cAsciiDel = '\t';
 248
 249             aTitle = ScResId( STR_EXPORT_ASCII );
 250             bAscii = true;
 251
 252             ScAsciiOptions aOptions;
 253             aOptions.ReadFromString(aFilterOptions);
 254             bIncludeBOM = aOptions.GetIncludeBOM();
 255         }
 256         else if ( aFilterString == ScDocShell::GetLotusFilterName() )
 257         {
 258             //  lotus is only imported
 259             OSL_ENSURE( !bExport, "Filter Options for Lotus Export is not implemented" );
 260
 261             aTitle = ScResId( STR_IMPORT_LOTUS );
 262             eEncoding = RTL_TEXTENCODING_IBM_437;
 263         }
 264         else if ( aFilterString == ScDocShell::GetDBaseFilterName() )
 265         {
 266             if ( bExport )
 267             {
 268                 //  dBase export
 269                 aTitle = ScResId( STR_EXPORT_DBF );
 270             }
 271             else
 272             {
 273                 //  dBase import
 274                 aTitle = ScResId( STR_IMPORT_DBF );
 275             }
 276
 277             std::unique_ptr<SvStream> pInStream;
 278             if ( xInputStream.is() )
 279                 pInStream = utl::UcbStreamHelper::CreateStream( xInputStream );
 280             switch(load_CharSet( eEncoding, bExport, pInStream.get()))
 281             {
 282                 case charsetSource::charset_from_file:
 283                   skipDialog = true;
 284                   break;
 285                 case charsetSource::charset_from_user_setting:
 286                 case charsetSource::charset_default:
 287                    break;
 288             }
 289             bDBEnc = true;
 290             // pInStream goes out of scope, the stream is automatically closed
 291         }
 292         else if ( aFilterString == ScDocShell::GetDifFilterName() )
 293         {
 294             if ( bExport )
 295             {
 296                 //  DIF export
 297                 aTitle = ScResId( STR_EXPORT_DIF );
 298             }
 299             else
 300             {
 301                 //  DIF import
 302                 aTitle = ScResId( STR_IMPORT_DIF );
 303             }
 304             // common for DIF import/export
 305             eEncoding = RTL_TEXTENCODING_MS_1252;
 306         }
 307
 308         ScImportOptions aOptions( cAsciiDel, cStrDel, eEncoding);
 309         aOptions.bIncludeBOM = bIncludeBOM;
 310         if(skipDialog)
 311         {
 312             // TODO: check we are not missing some of the stuff that ScImportOptionsDlg::GetImportOptions
 313             // (file sc/source/ui/dbgui/scuiimoptdlg.cxx) does
 314             // that is, if the dialog sets options that are not selected by the user (!)
 315             // then we are missing them here.
 316             // Then we may need to rip them out of the dialog.
 317             // Or we actually change the dialog to not display if skipDialog==true
 318             // in that case, add an argument skipDialog to CreateScImportOptionsDlg
 319             nRet = ui::dialogs::ExecutableDialogResults::OK;
 320         }
 321         else
 322         {
 323             ScopedVclPtr<AbstractScImportOptionsDlg> pDlg(pFact->CreateScImportOptionsDlg(Application::GetFrameWeld(xDialogParent),
 324                                                                             bAscii, &aOptions, &aTitle,
 325                                                                             bDBEnc, !bExport));
 326             if ( pDlg->Execute() == RET_OK )
 327             {
 328                 pDlg->SaveImportOptions();
 329                 pDlg->GetImportOptions( aOptions );
 330                 save_CharSet( aOptions.eCharSet, bExport );
 331                 nRet = ui::dialogs::ExecutableDialogResults::OK;
 332             }
 333         }
 334         if (nRet == ui::dialogs::ExecutableDialogResults::OK)
 335         {
 336             if ( bAscii )
 337                 aFilterOptions = aOptions.BuildString();
 338             else
 339                 aFilterOptions = aOptions.aStrFont;
 340         }
 341     }
 342
 343     xInputStream.clear();   // don't hold the stream longer than necessary
 344
 345     return nRet;
 346 }
 347
 348 // XImporter
 349
 350 void SAL_CALL ScFilterOptionsObj::setTargetDocument( const uno::Reference<lang::XComponent>& /* xDoc */ )
 351 {
 352     bExport = false;
 353 }
 354
 355 // XExporter
 356
 357 void SAL_CALL ScFilterOptionsObj::setSourceDocument( const uno::Reference<lang::XComponent>& /* xDoc */ )
 358 {
 359     bExport = true;
 360 }
 361
 362 // XInitialization
 363
 364 void SAL_CALL ScFilterOptionsObj::initialize(const uno::Sequence<uno::Any>& rArguments)
 365 {
 366     ::comphelper::NamedValueCollection aProperties(rArguments);
 367     if (aProperties.has(u"ParentWindow"_ustr))
 368         aProperties.get(u"ParentWindow"_ustr) >>= xDialogParent;
 369 }
 370
 371 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */