WPSPosition.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
 */
 
#ifndef WPS_POSITION_H
#define WPS_POSITION_H
 
#include <ostream>
 
#include <librevenge/librevenge.h>
 
#include "libwps_internal.h"

class WPSPosition
{
public:
        enum AnchorTo { Cell, Char, CharBaseLine, Paragraph, ParagraphContent, Page, PageContent };
        enum Wrapping { WNone, WDynamic, WRunThrough }; // Add something for background ?
        enum XPos { XRight, XLeft, XCenter, XFull };
        enum YPos { YTop, YBottom, YCenter, YFull };
 
public:
        explicit WPSPosition(Vec2f const &orig=Vec2f(), Vec2f const &sz=Vec2f(), librevenge::RVNGUnit unt=librevenge::RVNG_INCH)
                : m_anchorTo(Char)
                , m_anchorCellName()
                , m_xPos(XLeft)
                , m_yPos(YTop)
                , m_wrapping(WNone)
                , m_page(0)
                , m_orig(orig)
                , m_size(sz)
                , m_naturalSize()
                , m_unit(unt)
                , m_order(0) {}
        WPSPosition(WPSPosition const &)=default;
        WPSPosition(WPSPosition &&)=default;
        WPSPosition &operator=(WPSPosition const &)=default;
        WPSPosition &operator=(WPSPosition &&)=default;
        ~WPSPosition() {}
        friend std::ostream &operator<<(std::ostream &o, WPSPosition const &pos)
        {
                Vec2f dest(pos.m_orig+pos.m_size);
                o << "Pos=" << pos.m_orig << "x" << dest;
                switch (pos.m_unit)
                {
                case librevenge::RVNG_INCH:
                        o << "(inch)";
                        break;
                case librevenge::RVNG_POINT:
                        o << "(pt)";
                        break;
                case librevenge::RVNG_TWIP:
                        o << "(tw)";
                        break;
                case librevenge::RVNG_PERCENT:
                case librevenge::RVNG_GENERIC:
                case librevenge::RVNG_UNIT_ERROR:
                default:
                        break;
                }
                if (pos.page()>0) o << ", page=" << pos.page();
                return o;
        }

        bool operator==(WPSPosition const &f) const
        {
                return cmp(f) == 0;
        }

        bool operator!=(WPSPosition const &f) const
        {
                return cmp(f) != 0;
        }

        bool operator<(WPSPosition const &f) const
        {
                return cmp(f) < 0;
        }

        int page() const
        {
                return m_page;
        }

        Vec2f const &origin() const
        {
                return m_orig;
        }

        Vec2f const &size() const
        {
                return m_size;
        }

        Vec2f const &naturalSize() const
        {
                return m_naturalSize;
        }

        librevenge::RVNGUnit unit() const
        {
                return m_unit;
        }

        static float getScaleFactor(librevenge::RVNGUnit orig, librevenge::RVNGUnit dest)
        {
                float actSc = 1.0, newSc = 1.0;
                switch (orig)
                {
                case librevenge::RVNG_TWIP:
                        break;
                case librevenge::RVNG_POINT:
                        actSc=20;
                        break;
                case librevenge::RVNG_INCH:
                        actSc = 1440;
                        break;
                case librevenge::RVNG_PERCENT:
                case librevenge::RVNG_GENERIC:
                case librevenge::RVNG_UNIT_ERROR:
                default:
                        WPS_DEBUG_MSG(("WPSPosition::getScaleFactor %d unit must not appear\n", int(orig)));
                }
                switch (dest)
                {
                case librevenge::RVNG_TWIP:
                        break;
                case librevenge::RVNG_POINT:
                        newSc=20;
                        break;
                case librevenge::RVNG_INCH:
                        newSc = 1440;
                        break;
                case librevenge::RVNG_PERCENT:
                case librevenge::RVNG_GENERIC:
                case librevenge::RVNG_UNIT_ERROR:
                default:
                        WPS_DEBUG_MSG(("WPSPosition::getScaleFactor %d unit must not appear\n", int(dest)));
                }
                return actSc/newSc;
        }

        float getInvUnitScale(librevenge::RVNGUnit unt) const
        {
                return getScaleFactor(unt, m_unit);
        }

        void setPage(int pg) const
        {
                const_cast<WPSPosition *>(this)->m_page = pg;
        }

        void setOrigin(Vec2f const &orig)
        {
                m_orig = orig;
        }

        void setSize(Vec2f const &sz)
        {
                m_size = sz;
        }

        void setNaturalSize(Vec2f const &natSize)
        {
                m_naturalSize = natSize;
        }

        void setUnit(librevenge::RVNGUnit unt)
        {
                m_unit = unt;
        }

        void setPagePos(int pg, Vec2f const &newOrig) const
        {
                const_cast<WPSPosition *>(this)->m_page = pg;
                const_cast<WPSPosition *>(this)->m_orig = newOrig;
        }

        void setRelativePosition(AnchorTo anchor, XPos X = XLeft, YPos Y=YTop)
        {
                m_anchorTo = anchor;
                m_xPos = X;
                m_yPos = Y;
        }

        void setAnchorToCell(librevenge::RVNGString const &cellName)
        {
                m_anchorTo = Cell;
                m_xPos = XLeft;
                m_yPos = YTop;
                m_anchorCellName=cellName;
        }

        int order() const
        {
                return m_order;
        }

        void setOrder(int ord) const
        {
                m_order = ord;
        }

        AnchorTo m_anchorTo;
        librevenge::RVNGString m_anchorCellName;
        XPos m_xPos;
        YPos m_yPos;
        Wrapping m_wrapping;
 
protected:
        int cmp(WPSPosition const &f) const
        {
                int diff = int(m_anchorTo) - int(f.m_anchorTo);
                if (diff) return diff < 0 ? -1 : 1;
                if (m_anchorCellName<f.m_anchorCellName) return -1;
                if (m_anchorCellName>f.m_anchorCellName) return 1;
                diff = int(m_xPos) - int(f.m_xPos);
                if (diff) return diff < 0 ? -1 : 1;
                diff = int(m_yPos) - int(f.m_yPos);
                if (diff) return diff < 0 ? -1 : 1;
                diff = page() - f.page();
                if (diff) return diff < 0 ? -1 : 1;
                diff = int(m_unit) - int(f.m_unit);
                if (diff) return diff < 0 ? -1 : 1;
                diff = m_orig.cmpY(f.m_orig);
                if (diff) return diff;
                diff = m_size.cmpY(f.m_size);
                if (diff) return diff;
                diff = m_naturalSize.cmpY(f.m_naturalSize);
                if (diff) return diff;
 
                return 0;
        }

        int m_page;
        Vec2f m_orig , m_size /* the size of the data*/, m_naturalSize ;
        librevenge::RVNGUnit m_unit;
        mutable int m_order;
};
 
#endif
/* vim:set shiftwidth=4 softtabstop=4 noexpandtab: */