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 .
 */
 
#pragma once
 
#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:
    RichStringPortion();
 
    void                setText( const OUString& rText );
    FontRef const &     createFont(const WorkbookHelper& rHelper);
    void                setFontId( sal_Int32 nFontId );
 
    void                finalizeImport(const WorkbookHelper& rHelper);
 
    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;    
};
 
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:
    RichStringPhonetic();
 
    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:
 
    sal_Int32 importText(const AttributeList& rAttribs);
    sal_Int32 importRun();
    RichStringPhoneticRef importPhoneticRun( const AttributeList& rAttribs );
    void                importPhoneticPr( const AttributeList& rAttribs, const WorkbookHelper& rHelper );
 
    void                importString( SequenceInputStream& rStrm, bool bRich, const WorkbookHelper& rHelper );
 
    void                finalizeImport(const WorkbookHelper& rHelper);
 
    bool                extractPlainString(
                            OUString& orString,
                            const oox::xls::Font* pFirstPortionFont ) const;
 
    void                convert( const css::uno::Reference< css::text::XText >& rxText );
    std::unique_ptr<EditTextObject> convert( ScEditEngineDefaulter& rEE, const oox::xls::Font* pFont );
 
    RichStringPortion& getPortion(sal_Int32 nPortionIdx) { return maTextPortions[nPortionIdx]; }
 
    void                setAttributes(const AttributeList& rAttribs);
 
    bool                isPreserveSpace() const { return mbPreserveSpace; }
 
private:
    sal_Int32 createPortion();
    RichStringPhoneticRef createPhonetic();
 
    void                createTextPortions( std::u16string_view aText, FontPortionModelList& rPortions );
    void                createPhoneticPortions( std::u16string_view aText, PhoneticPortionModelList& rPortions, sal_Int32 nBaseLen );
 
private:
    typedef RefVector< RichStringPhonetic > PhoneticVector;
 
    std::vector<RichStringPortion>  maTextPortions; 
    std::unique_ptr<PhoneticSettings> mxPhonSettings; 
    PhoneticVector      maPhonPortions; 
    bool mbPreserveSpace = false;
};
 
typedef std::shared_ptr< RichString > RichStringRef;
 
} // namespace oox::xls
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */