richstring.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 .
 */

#ifndef INCLUDED_SC_SOURCE_FILTER_INC_RICHSTRING_HXX
#define INCLUDED_SC_SOURCE_FILTER_INC_RICHSTRING_HXX

#include <oox/helper/refvector.hxx>
#include "stylesbuffer.hxx"

class EditTextObject;
struct ESelection;
class ScEditEngineDefaulter;

namespace com::sun::star {
    namespace text { class XText; }
}

namespace oox { class SequenceInputStream; }

namespace oox::xls {

class RichStringPortion : public WorkbookHelper
{
public:
    explicit            RichStringPortion( const WorkbookHelper& rHelper );

    void                setText( const OUString& rText );
    FontRef const &     createFont();
    void                setFontId( sal_Int32 nFontId );

    void                finalizeImport();

    const OUString& getText() const { return maText; }
    bool         hasFont() const { return bool(mxFont); }

    void                convert(
                            const css::uno::Reference< css::text::XText >& rxText,
                            bool bReplace );
    void                convert( ScEditEngineDefaulter& rEE, ESelection& rSelection, const oox::xls::Font* pFont );

    void                writeFontProperties(
                            const css::uno::Reference< css::text::XText >& rxText ) const;

private:
    OUString            maText;         
    FontRef             mxFont;         
    sal_Int32           mnFontId;       
    bool                mbConverted;    
};

typedef std::shared_ptr< RichStringPortion > RichStringPortionRef;

struct FontPortionModel
{
    sal_Int32           mnPos;          
    sal_Int32           mnFontId;       

    explicit FontPortionModel() : mnPos( 0 ), mnFontId( -1 ) {}
    explicit FontPortionModel( sal_Int32 nPos ) : mnPos( nPos ), mnFontId( -1 ) {}

    void                read( SequenceInputStream& rStrm );
};

class FontPortionModelList {
    ::std::vector< FontPortionModel > mvModels;

public:
    explicit     FontPortionModelList() : mvModels() {}

    bool empty() const { return mvModels.empty(); }

    const FontPortionModel& back() const { return mvModels.back(); }
    const FontPortionModel& front() const { return mvModels.front(); }

    void push_back(const FontPortionModel& rModel) { mvModels.push_back(rModel); }

    void insert(::std::vector< FontPortionModel >::iterator it,
                const FontPortionModel& rModel)
    { mvModels.insert(it, rModel); }

    ::std::vector< FontPortionModel >::iterator begin() { return mvModels.begin(); }

    void                appendPortion( const FontPortionModel& rPortion );
    void                importPortions( SequenceInputStream& rStrm );
};

struct PhoneticDataModel
{
    sal_Int32           mnFontId;       
    sal_Int32           mnType;         
    sal_Int32           mnAlignment;    

    explicit            PhoneticDataModel();

    void                setBiffData( sal_Int32 nType, sal_Int32 nAlignment );
};

class PhoneticSettings : public WorkbookHelper
{
public:
    explicit            PhoneticSettings( const WorkbookHelper& rHelper );

    void                importPhoneticPr( const AttributeList& rAttribs );
    void                importPhoneticPr( SequenceInputStream& rStrm );

    void                importStringData( SequenceInputStream& rStrm );

private:
    PhoneticDataModel   maModel;
};

class RichStringPhonetic : public WorkbookHelper
{
public:
    explicit            RichStringPhonetic( const WorkbookHelper& rHelper );

    void                setText( const OUString& rText );
    void                importPhoneticRun( const AttributeList& rAttribs );
    void                setBaseRange( sal_Int32 nBasePos, sal_Int32 nBaseEnd );

private:
    OUString     maText;         
    sal_Int32           mnBasePos;      
    sal_Int32           mnBaseEnd;      
};

typedef std::shared_ptr< RichStringPhonetic > RichStringPhoneticRef;

struct PhoneticPortionModel
{
    sal_Int32           mnPos;          
    sal_Int32           mnBasePos;      
    sal_Int32           mnBaseLen;      

    explicit PhoneticPortionModel() : mnPos( -1 ), mnBasePos( -1 ), mnBaseLen( 0 ) {}
    explicit PhoneticPortionModel( sal_Int32 nPos, sal_Int32 nBasePos, sal_Int32 nBaseLen ) :
                            mnPos( nPos ), mnBasePos( nBasePos ), mnBaseLen( nBaseLen ) {}

    void                read( SequenceInputStream& rStrm );
};

class PhoneticPortionModelList
{
public:
    explicit     PhoneticPortionModelList() : mvModels() {}

    bool empty() const { return mvModels.empty(); }

    const PhoneticPortionModel& back() const { return mvModels.back(); }

    void push_back(const PhoneticPortionModel& rModel) { mvModels.push_back(rModel); }

    ::std::vector< PhoneticPortionModel >::const_iterator begin() const { return mvModels.begin(); }

    void                appendPortion( const PhoneticPortionModel& rPortion );
    void                importPortions( SequenceInputStream& rStrm );

private:
    ::std::vector< PhoneticPortionModel > mvModels;
};

class RichString : public WorkbookHelper
{
public:
    explicit            RichString( const WorkbookHelper& rHelper );

    RichStringPortionRef importText();
    RichStringPortionRef importRun();
    RichStringPhoneticRef importPhoneticRun( const AttributeList& rAttribs );
    void                importPhoneticPr( const AttributeList& rAttribs );

    void                importString( SequenceInputStream& rStrm, bool bRich );

    void                finalizeImport();

    bool                extractPlainString(
                            OUString& orString,
                            const oox::xls::Font* pFirstPortionFont ) const;

    void                convert( const css::uno::Reference< css::text::XText >& rxText ) const;
    std::unique_ptr<EditTextObject> convert( ScEditEngineDefaulter& rEE, const oox::xls::Font* pFont ) const;

private:
    RichStringPortionRef createPortion();
    RichStringPhoneticRef createPhonetic();

    void                createTextPortions( const OUString& rText, FontPortionModelList& rPortions );
    void                createPhoneticPortions( const OUString& rText, PhoneticPortionModelList& rPortions, sal_Int32 nBaseLen );

private:
    typedef RefVector< RichStringPortion >  PortionVector;
    typedef RefVector< RichStringPhonetic > PhoneticVector;

    PortionVector       maTextPortions; 
    PhoneticSettings    maPhonSettings; 
    PhoneticVector      maPhonPortions; 
};

typedef std::shared_ptr< RichString > RichStringRef;

} // namespace oox::xls

#endif

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */