WPSCell.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) 2009, 2011 Alonso Laurent (alonso@loria.fr)
 * Copyright (C) 2006, 2007 Andrew Ziem
 * Copyright (C) 2004-2006 Fridrich Strba (fridrich.strba@bluewin.ch)
 * Copyright (C) 2004 Marc Maurer (uwog@uwog.net)
 * Copyright (C) 2003-2005 William Lachance (william.lachance@sympatico.ca)
 *
 * 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
 */
 
/* Define some classes used to store a Cell
 */
 
#ifndef WPS_CELL_H
#  define WPS_CELL_H
 
#include <iostream>
#include <vector>
 
#include "libwps_internal.h"
 
#include "WPSFont.h"

class WPSCellFormat
{
public:
        enum HorizontalAlignment { HALIGN_LEFT, HALIGN_RIGHT, HALIGN_CENTER,
                                   HALIGN_FULL, HALIGN_DEFAULT
                                 };
        enum VerticalAlignment { VALIGN_TOP, VALIGN_CENTER, VALIGN_BOTTOM, VALIGN_DEFAULT };
        enum Wrapping { WRAP_WRAP, WRAP_NO_WRAP, WRAP_DEFAULT };
        enum FormatType { F_TEXT, F_BOOLEAN, F_NUMBER, F_DATE, F_TIME, F_UNKNOWN };
 
        /*   subformat:
                  NUMBER             DATE                 TIME               TEXT
          0 :    default           default[3/2/2000]  default[10:03:00]    default
          1 :    decimal
          2 :    exponential
          3 :    percent
          4 :    money
          5 :    thousand
          6 :    fixed
          7 :    fraction
         */

        WPSCellFormat()
                : m_font()
                , m_hAlign(HALIGN_DEFAULT)
                , m_vAlign(VALIGN_DEFAULT)
                , m_wrapping(WRAP_DEFAULT)
                , m_rotation(0)
                , m_bordersList()
                , m_format(F_UNKNOWN)
                , m_subFormat(0)
                , m_DTFormat("")
                , m_digits(-1000)
                , m_protected(false)
                , m_backgroundColor(WPSColor::white()) { }
        WPSCellFormat(WPSCellFormat const &)=default;
        WPSCellFormat &operator=(WPSCellFormat const &)=default;
        virtual ~WPSCellFormat();
        bool hasBasicFormat() const
        {
                return m_format==F_TEXT || m_format==F_UNKNOWN;
        }

        std::string getValueType() const;
        void addTo(librevenge::RVNGPropertyList &propList) const;
        bool getNumberingProperties(librevenge::RVNGPropertyList &propList) const;

        WPSFont const &getFont() const
        {
                return m_font;
        }

        void setFont(WPSFont const &font)
        {
                m_font=font;
        }

        HorizontalAlignment hAlignment() const
        {
                return m_hAlign;
        }

        void setHAlignment(HorizontalAlignment align)
        {
                m_hAlign = align;
        }

        VerticalAlignment vAlignment() const
        {
                return m_vAlign;
        }

        void setVAlignment(VerticalAlignment align)
        {
                m_vAlign = align;
        }

        Wrapping wrapping() const
        {
                return m_wrapping;
        }

        void setWrapping(Wrapping align)
        {
                m_wrapping = align;
        }

        int getTextRotation() const
        {
                return m_rotation;
        }

        void setTextRotation(int rotation)
        {
                m_rotation = rotation;
        }

        FormatType getFormat() const
        {
                return m_format;
        }

        int getSubFormat() const
        {
                return m_subFormat;
        }

        std::string getDTFormat() const
        {
                return m_DTFormat;
        }

        void setFormat(FormatType form, int subForm=0)
        {
                m_format = form;
                m_subFormat = subForm;
        }

        void setDTFormat(FormatType form, std::string const &dtFormat="")
        {
                m_format = form;
                m_subFormat = 0;
                m_DTFormat = dtFormat;
        }

        int digits() const
        {
                return m_digits;
        }

        void setDigits(int newDigit)
        {
                m_digits = newDigit;
        }

        bool isProtected() const
        {
                return m_protected;
        }

        void setProtected(bool fl)
        {
                m_protected = fl;
        }

        bool hasBorders() const
        {
                return m_bordersList.size() != 0;
        }

        std::vector<WPSBorder> const &borders() const
        {
                return m_bordersList;
        }

        void resetBorders()
        {
                m_bordersList.resize(0);
        }

        void setBorders(int wh, WPSBorder const &border);
        void setBorders(std::vector<WPSBorder> const &newBorders)
        {
                m_bordersList=newBorders;
        }

        WPSColor backgroundColor() const
        {
                return m_backgroundColor;
        }

        void setBackgroundColor(WPSColor const &color)
        {
                m_backgroundColor = color;
        }

        int compare(WPSCellFormat const &cell, bool onlyNumbering=false) const;

        friend std::ostream &operator<<(std::ostream &o, WPSCellFormat const &cell);

        struct CompareFormat
        {
                CompareFormat() {}
                bool operator()(WPSCellFormat const &c1, WPSCellFormat const &c2) const
                {
                        return c1.compare(c2, true) < 0;
                }
        };
 
protected:
        static bool convertDTFormat(std::string const &dtFormat, librevenge::RVNGPropertyListVector &propListVector);
        WPSFont m_font;
        HorizontalAlignment m_hAlign;
        VerticalAlignment m_vAlign;
        Wrapping m_wrapping;
        int m_rotation;
        std::vector<WPSBorder> m_bordersList;
        FormatType m_format;
        int m_subFormat;
        std::string m_DTFormat;
        int m_digits;
        bool m_protected;
        WPSColor m_backgroundColor;
};
 
class WPSTable;

class WPSCell : public WPSCellFormat
{
        friend class WPSTable;
public:
        WPSCell()
                : WPSCellFormat()
                , m_box()
                , m_verticalSet(true)
                , m_position(0,0)
                , m_numberCellSpanned(1,1) {}
        WPSCell(WPSCell const &)=default;
        WPSCell &operator=(WPSCell const &)=default;
        ~WPSCell() override;

        void addTo(librevenge::RVNGPropertyList &propList) const;

        void setBox(WPSBox2f const &b)
        {
                m_box = b;
        }

        WPSBox2f const &box() const
        {
                return m_box;
        }

        bool isVerticalSet() const
        {
                return m_verticalSet;
        }

        void setVerticalSet(bool verticalSet)
        {
                m_verticalSet = verticalSet;
        }

        Vec2i &position()
        {
                return m_position;
        }

        Vec2i const &position() const
        {
                return m_position;
        }

        void setPosition(Vec2i posi)
        {
                m_position = posi;
        }

        Vec2i const &numSpannedCells() const
        {
                return m_numberCellSpanned;
        }

        void setNumSpannedCells(Vec2i numSpanned)
        {
                m_numberCellSpanned=numSpanned;
        }

        virtual bool send(WPSListenerPtr &listener) = 0;

        virtual bool sendContent(WPSListenerPtr &listener) = 0;

        friend std::ostream &operator<<(std::ostream &o, WPSCell const &cell);
 
protected:
        struct Compare
        {
                explicit Compare(int dim)
                        : m_coord(dim) {}

                struct Point
                {
                        Point(int wh, WPSCell const *cell)
                                : m_which(wh)
                                , m_cell(cell) {}
                        float getPos(int coord) const
                        {
                                if (m_which)
                                        return m_cell->box().max()[coord];
                                return m_cell->box().min()[coord];
                        }
                        float getSize(int coord) const
                        {
                                return m_cell->box().size()[coord];
                        }
                        int m_which;
                        WPSCell const *m_cell;
                };

                bool operator()(Point const &c1, Point const &c2) const
                {
                        float diffF = c1.getPos(m_coord)-c2.getPos(m_coord);
                        if (diffF < 0) return true;
                        if (diffF > 0) return false;
                        int diff = c2.m_which - c1.m_which;
                        if (diff) return (diff < 0);
                        diffF = c1.m_cell->box().size()[m_coord]
                                - c2.m_cell->box().size()[m_coord];
                        if (diffF < 0) return true;
                        if (diffF > 0) return false;
                        if (c1.m_cell->m_verticalSet != c2.m_cell->m_verticalSet) return c1.m_cell->m_verticalSet;
#ifdef _WIN64
                        return ((__int64)c1.m_cell < (__int64)c2.m_cell);
#else
                        return long(c1.m_cell) < long(c2.m_cell);
#endif
                }

                int m_coord;
        };

        WPSBox2f m_box;
        bool m_verticalSet;
        Vec2i m_position;
        Vec2i m_numberCellSpanned;
};
 
#endif
/* vim:set shiftwidth=4 softtabstop=4 noexpandtab: */