WKSContentListener.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* libwps
 * Version: MPL 2.0 / LGPLv2.1+
 *
 * 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/.
 *
 * Major Contributor(s):
 * Copyright (C) 2006, 2007 Andrew Ziem
 * Copyright (C) 2006 Fridrich Strba (fridrich.strba@bluewin.ch)
 * Copyright (C) 2003-2005 William Lachance (william.lachance@sympatico.ca)
 * Copyright (C) 2003 Marc Maurer (uwog@uwog.net)
 *
 * For minor contributions see the git repository.
 *
 * Alternatively, the contents of this file may be used under the terms
 * of the GNU Lesser General Public License Version 2.1 or later
 * (LGPLv2.1+), in which case the provisions of the LGPLv2.1+ are
 * applicable instead of those above.
 *
 * For further information visit http://libwps.sourceforge.net
 */
 
#ifndef WKSCONTENTLISTENER_H
#define WKSCONTENTLISTENER_H
 
#include <vector>
 
#include <librevenge/librevenge.h>
 
#include "libwps_internal.h"
 
#include "WPSEntry.h"
#include "WPSGraphicStyle.h"
 
#include "WPSListener.h"
 
class WPSCellFormat;
class WKSChart;
struct WPSColumnFormat;
class WPSGraphicShape;
class WPSGraphicStyle;
class WPSList;
class WPSPageSpan;
struct WPSParagraph;
struct WPSRowFormat;
struct WPSTabStop;
 
struct WKSContentParsingState;
struct WKSDocumentParsingState;
 
class WKSContentListener final : public WPSListener
{
public:
        struct FormulaInstruction
        {
                enum What { F_Operator, F_Function, F_Cell, F_CellList, F_Long, F_Double, F_Text };
                FormulaInstruction()
                        : m_type(F_Text)
                        , m_content()
                        , m_longValue(0)
                        , m_doubleValue(0)
                        , m_fileName()
                {
                        for (auto &pos : m_position) pos=Vec2i(0,0);
                        for (auto &pos : m_positionRelative) pos=Vec2b(false,false);
                        for (auto &id : m_sheetId) id=-1;
                }

                librevenge::RVNGPropertyList getPropertyList() const;
                friend std::ostream &operator<<(std::ostream &o, FormulaInstruction const &inst);
                What m_type;
                std::string m_content;
                double m_longValue;
                double m_doubleValue;
                Vec2i m_position[2];
                Vec2b m_positionRelative[2];
                librevenge::RVNGString m_sheetName[2];
                int m_sheetId[2];
                librevenge::RVNGString m_fileName;
        };

        struct CellContent
        {
                enum ContentType { C_NONE, C_TEXT, C_NUMBER, C_FORMULA, C_UNKNOWN };
                CellContent()
                        : m_contentType(C_UNKNOWN)
                        , m_value(0.0)
                        , m_valueSet(false)
                        , m_textEntry()
                        , m_formula() { }
                CellContent(CellContent const &)=default;
                CellContent &operator=(CellContent const &)=default;
                ~CellContent() {}
                friend std::ostream &operator<<(std::ostream &o, CellContent const &cell);

                bool empty() const
                {
                        if (m_contentType == C_NUMBER) return false;
                        if (m_contentType == C_TEXT && !m_textEntry.valid()) return false;
                        if (m_contentType == C_FORMULA && (m_formula.size() || isValueSet())) return false;
                        return true;
                }

                void setValue(double value)
                {
                        m_value = value;
                        m_valueSet = true;
                }

                bool isValueSet() const
                {
                        return m_valueSet;
                }

                bool hasText() const
                {
                        return m_textEntry.valid();
                }

                static bool double2Date(double val, int &Y, int &M, int &D);
                static bool double2Time(double val, int &H, int &M, int &S);

                ContentType m_contentType;
                double m_value;
                bool m_valueSet;
                WPSEntry m_textEntry;
                std::vector<FormulaInstruction> m_formula;
        };
 
        WKSContentListener(std::vector<WPSPageSpan> const &pageList, librevenge::RVNGSpreadsheetInterface *documentInterface);
        ~WKSContentListener() final;
 
        void setDocumentLanguage(int lcid) final;
        void setMetaData(const librevenge::RVNGPropertyList &list);
 
        void startDocument();
        void endDocument();
        void handleSubDocument(WPSSubDocumentPtr &subDocument, libwps::SubDocumentType subDocumentType);
 
        // ------ text data -----------

        void insertCharacter(uint8_t character) final;
        void insertUnicode(uint32_t character) final;
        void insertUnicodeString(librevenge::RVNGString const &str) final;
 
        void insertTab() final;
        void insertEOL(bool softBreak=false) final;
        void insertBreak(const uint8_t breakType) final;
 
        // ------ text format -----------
        void setFont(const WPSFont &font) final;
        WPSFont const &getFont() const final;
 
        // ------ paragraph format -----------
        bool isParagraphOpened() const final;
        void setParagraph(const WPSParagraph &para) final;
        WPSParagraph const &getParagraph() const final;
 
        // ------- fields ----------------
        void insertField(WPSField const &field) final;
 
        // ------- subdocument -----------------
        void insertComment(WPSSubDocumentPtr &subDocument);
        void insertPicture(WPSPosition const &pos, const librevenge::RVNGBinaryData &binaryData,
                           std::string const &type="image/pict", WPSGraphicStyle const &style=WPSGraphicStyle::emptyStyle());
        void insertObject(WPSPosition const &pos, const WPSEmbeddedObject &obj,
                          WPSGraphicStyle const &style=WPSGraphicStyle::emptyStyle());
        void insertPicture(WPSPosition const &pos, WPSGraphicShape const &shape, WPSGraphicStyle const &style);
        void insertTextBox(WPSPosition const &pos, WPSSubDocumentPtr subDocument,
                           WPSGraphicStyle const &frameStyle=WPSGraphicStyle::emptyStyle());
        bool openGroup(WPSPosition const &pos) final;
        void closeGroup() final;
 
        // ------- sheet -----------------
        void openSheet(std::vector<WPSColumnFormat> const &columns, librevenge::RVNGString const &name="");
        void closeSheet();
        void openSheetRow(WPSRowFormat const &f, int numRepeated=1);
        void closeSheetRow();
        void openSheetCell(WPSCell const &cell, CellContent const &content, int numRepeated=1);
        void closeSheetCell();
 
        // ------- chart -----------------
        void insertChart(WPSPosition const &pos, WKSChart const &chart,
                         WPSGraphicStyle const &style=WPSGraphicStyle::emptyStyle());
protected:
        void _openPageSpan();
        void _closePageSpan();
 
        void _handleFrameParameters(librevenge::RVNGPropertyList &propList, WPSPosition const &pos);
        bool _openFrame(WPSPosition const &pos, WPSGraphicStyle const &style);
        void _closeFrame();
 
        void _startSubDocument();
        void _endSubDocument();
 
        void _openParagraph();
        void _closeParagraph();
        void _appendParagraphProperties(librevenge::RVNGPropertyList &propList, const bool isListElement=false);
        void _resetParagraphState(const bool isListElement=false);
 
        void _openSpan();
        void _closeSpan();
 
        void _flushText();
        void _flushDeferredTabs();
 
        void _insertBreakIfNecessary(librevenge::RVNGPropertyList &propList);

        std::shared_ptr<WKSContentParsingState> _pushParsingState();
        void _popParsingState();
 
protected:
        std::shared_ptr<WKSDocumentParsingState> m_ds; // main parse state
        std::shared_ptr<WKSContentParsingState> m_ps; // parse state
        std::vector<std::shared_ptr<WKSContentParsingState> > m_psStack;
        librevenge::RVNGSpreadsheetInterface *m_documentInterface;
 
private:
        WKSContentListener(const WKSContentListener &) = delete;
        WKSContentListener &operator=(const WKSContentListener &) = delete;
};
 
#endif
/* vim:set shiftwidth=4 softtabstop=4 noexpandtab: */