impex.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#pragma once
 
#include <o3tl/deleter.hxx>
#include <sot/formats.hxx>
#include <address.hxx>
#include <tools/stream.hxx>
 
#include <com/sun/star/uno/Any.hxx>
 
class ScDocShell;
class ScDocument;
class ScAsciiOptions;
 
struct ScExportTextOptions
{
    enum NewlineConversion { ToSystem, ToSpace, None };
    ScExportTextOptions( NewlineConversion eNewlineConversion = ToSystem, sal_Unicode cSeparatorConvertTo = 0, bool bAddQuotes = false ) :
        meNewlineConversion( eNewlineConversion ), mcSeparatorConvertTo( cSeparatorConvertTo ), mbAddQuotes( bAddQuotes ) {}
 
    NewlineConversion meNewlineConversion;
    sal_Unicode mcSeparatorConvertTo;   // Convert separator to this character
    bool mbAddQuotes;
};
 
class SC_DLLPUBLIC ScImportExport
{
    ScDocShell* pDocSh;
    ScDocument& rDoc;
    std::unique_ptr<ScDocument, o3tl::default_delete<ScDocument>> pUndoDoc;
    ScRange     aRange;
    OUString    aStreamPath;
    OUString    aNonConvertibleChars;
    OUString    maFilterOptions;
    sal_uInt32  nSizeLimit;
    SCROW       nMaxImportRow;
    sal_Unicode cSep;                   // Separator
    sal_Unicode cStr;                   // String Delimiter
    bool        bFormulas;              // Formula in Text?
    bool        bIncludeFiltered;       // include filtered rows? (default true)
    bool        bAll;                   // no selection
    bool        bSingle;                // Single selection
    bool        bUndo;                  // with Undo?
    bool        bOverflowRow;           // too many rows
    bool        bOverflowCol;           // too many columns
    bool        bOverflowCell;          // too much data for a cell
    bool        mbApi;
    bool        mbImportBroadcast; // whether or not to broadcast after data import.
    bool        mbOverwriting;  // Whether we could be overwriting existing values (paste).
                                // In this case we cannot use the insert optimization, but we
                                // do not need to broadcast after the import.
    bool        mbIncludeBOM; // Whether to include a byte-order-mark in the output.
    ScExportTextOptions mExportTextOptions;
 
    std::unique_ptr<ScAsciiOptions> pExtOptions;        // extended options
 
    bool StartPaste();                  // Protect check, set up Undo
    void EndPaste(bool bAutoRowHeight = true);                    // Undo/Redo actions, Repaint
    bool Doc2Text( SvStream& );
    bool Text2Doc( SvStream& );
    bool Doc2Sylk( SvStream& );
    bool Sylk2Doc( SvStream& );
    bool Doc2HTML( SvStream&, const OUString& );
    bool Doc2RTF( SvStream& );
    bool Doc2Dif( SvStream& );
    bool Dif2Doc( SvStream& );
    bool ExtText2Doc( SvStream& );      // with pExtOptions
    bool RTF2Doc( SvStream&, const OUString& rBaseURL );
    bool HTML2Doc( SvStream&, const OUString& rBaseURL );
 
public:
    ScImportExport( ScDocument& );                  // the whole document
    ScImportExport( ScDocument&, const OUString& );   // Range/cell input
    ScImportExport( ScDocument&, const ScAddress& );
    ScImportExport( ScDocument&, const ScRange& );
   ~ScImportExport() COVERITY_NOEXCEPT_FALSE;
 
    void SetExtOptions( const ScAsciiOptions& rOpt );
    void SetFilterOptions( const OUString& rFilterOptions );
    bool IsRef() const       { return !bAll; }
 
    const ScRange& GetRange() const { return aRange; }
 
    static void EmbeddedNullTreatment( OUString & rStr );
 
    static bool  IsFormatSupported( SotClipboardFormatId nFormat );
    static const sal_Unicode* ScanNextFieldFromString( const sal_Unicode* p,
            OUString& rField, sal_Unicode cStr, const sal_Unicode* pSeps,
            bool bMergeSeps, bool& rbIsQuoted, bool& rbOverflowCell, bool bRemoveSpace );
    static  void    WriteUnicodeOrByteString( SvStream& rStrm, std::u16string_view rString, bool bZero = false );
    static  void    WriteUnicodeOrByteEndl( SvStream& rStrm );
 
    static sal_Int32 CountVisualWidth(const OUString& rStr, sal_Int32& nIdx, sal_Int32 nMaxWidth);
 
    static sal_Int32 CountVisualWidth(const OUString& rStr);
 
    static  void    SetNoEndianSwap( SvStream& rStrm );
 
    void SetSeparator( sal_Unicode c ) { cSep = c; }
    void SetDelimiter( sal_Unicode c ) { cStr = c; }
    void SetFormulas( bool b ) { bFormulas = b; }
    void SetIncludeFiltered( bool b ) { bIncludeFiltered = b; }
 
    void            SetStreamPath( const OUString& rPath ) { aStreamPath = rPath; }
 
    bool ImportString( const OUString&, SotClipboardFormatId );
    bool ExportString( OUString&, SotClipboardFormatId );
    bool ExportByteString( OString&, rtl_TextEncoding, SotClipboardFormatId );
 
    bool ImportStream( SvStream&, const OUString& rBaseURL, SotClipboardFormatId );
    bool ExportStream( SvStream&, const OUString& rBaseURL, SotClipboardFormatId );
 
    bool ExportData( const OUString& rMimeType,
                     css::uno::Any & rValue  );
 
    // after import
    bool IsOverflowRow() const { return bOverflowRow; }
    bool IsOverflowCol() const { return bOverflowCol; }
    bool IsOverflowCell() const { return bOverflowCell; }
    bool IsOverflow() const { return bOverflowRow || bOverflowCol || bOverflowCell; }
 
    const OUString& GetNonConvertibleChars() const { return aNonConvertibleChars; }
 
    void SetApi( bool bApi ) { mbApi = bApi; }
    void SetImportBroadcast( bool b ) { mbImportBroadcast = b; }
    void SetOverwriting( const bool bOverwriting ) { mbOverwriting = bOverwriting; }
    void SetExportTextOptions( const ScExportTextOptions& options ) { mExportTextOptions = options; }
 
    bool GetIncludeBOM() const { return mbIncludeBOM; }
    void SetIncludeBOM(bool bVal) { mbIncludeBOM = bVal; }
};
 
// Helper class for importing clipboard strings as streams.
class ScImportStringStream : public SvMemoryStream
{
public:
    ScImportStringStream(const OUString& rStr);
};
 
SC_DLLPUBLIC OUString ReadCsvLine( SvStream &rStream, bool bEmbeddedLineBreak,
        OUString& rFieldSeparators, sal_Unicode cFieldQuote, sal_Unicode& rcDetectSep,
        sal_uInt32 nMaxSourceLines = 0 );
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */