svdtrans.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 <rtl/ustring.hxx>
#include <svx/svxdllapi.h>
#include <tools/degree.hxx>
#include <tools/fldunit.hxx>
#include <tools/fract.hxx>
#include <tools/gen.hxx>
#include <tools/helpers.hxx>
#include <tools/mapunit.hxx>
#include <tools/poly.hxx>

// The DrawingEngine's angles are specified in 1/100th degrees
// We need to convert these angles to radians, in order to be able
// to process them with trigonometric functions.
// This is done, using the constant F_PI18000.
//
// Example usage:
// nAngle ... is an angle in 1/100 Deg
//
// Which is converted, by this:
//   double nSin=sin(nAngle*F_PI18000);
//
// To convert it back, we use division.

// That maximum shear angle
constexpr Degree100 SDRMAXSHEAR(8900);

class XPolygon;
class XPolyPolygon;

inline void MovePoly(tools::Polygon& rPoly, const Size& S)      { rPoly.Move(S.Width(),S.Height()); }
void MoveXPoly(XPolygon& rPoly, const Size& S);

SVXCORE_DLLPUBLIC void ResizeRect(tools::Rectangle& rRect, const Point& rRef, const Fraction& xFact, const Fraction& yFact);
inline void ResizePoint(Point& rPnt, const Point& rRef, const Fraction& xFract, const Fraction& yFract);
void ResizePoly(tools::Polygon& rPoly, const Point& rRef, const Fraction& xFact, const Fraction& yFact);
void ResizeXPoly(XPolygon& rPoly, const Point& rRef, const Fraction& xFact, const Fraction& yFact);

inline void RotatePoint(Point& rPnt, const Point& rRef, double sn, double cs);
SVXCORE_DLLPUBLIC void RotatePoly(tools::Polygon& rPoly, const Point& rRef, double sn, double cs);
void RotateXPoly(XPolygon& rPoly, const Point& rRef, double sn, double cs);
void RotateXPoly(XPolyPolygon& rPoly, const Point& rRef, double sn, double cs);

void MirrorPoint(Point& rPnt, const Point& rRef1, const Point& rRef2);
void MirrorXPoly(XPolygon& rPoly, const Point& rRef1, const Point& rRef2);

inline void ShearPoint(Point& rPnt, const Point& rRef, double tn, bool bVShear = false);
SVXCORE_DLLPUBLIC void ShearPoly(tools::Polygon& rPoly, const Point& rRef, double tn);
void ShearXPoly(XPolygon& rPoly, const Point& rRef, double tn, bool bVShear = false);

inline double GetCrookAngle(Point& rPnt, const Point& rCenter, const Point& rRad, bool bVertical);

double CrookRotateXPoint(Point& rPnt, Point* pC1, Point* pC2, const Point& rCenter,
                         const Point& rRad, double& rSin, double& rCos, bool bVert);
double CrookSlantXPoint(Point& rPnt, Point* pC1, Point* pC2, const Point& rCenter,
                        const Point& rRad, double& rSin, double& rCos, bool bVert);
double CrookStretchXPoint(Point& rPnt, Point* pC1, Point* pC2, const Point& rCenter,
                          const Point& rRad, double& rSin, double& rCos, bool bVert,
                          const tools::Rectangle& rRefRect);

void CrookRotatePoly(XPolygon& rPoly, const Point& rCenter, const Point& rRad, bool bVert);
void CrookSlantPoly(XPolygon& rPoly, const Point& rCenter, const Point& rRad, bool bVert);
void CrookStretchPoly(XPolygon& rPoly, const Point& rCenter, const Point& rRad, bool bVert, const tools::Rectangle& rRefRect);

void CrookRotatePoly(XPolyPolygon& rPoly, const Point& rCenter, const Point& rRad, bool bVert);
void CrookSlantPoly(XPolyPolygon& rPoly, const Point& rCenter, const Point& rRad, bool bVert);
void CrookStretchPoly(XPolyPolygon& rPoly, const Point& rCenter, const Point& rRad, bool bVert, const tools::Rectangle& rRefRect);

/**************************************************************************************************/
/*  Inline                                                                                        */
/**************************************************************************************************/

inline void ResizePoint(Point& rPnt, const Point& rRef, const Fraction& xFract, const Fraction& yFract)
{
    double nxFract = xFract.IsValid() ? static_cast<double>(xFract) : 1.0;
    double nyFract = yFract.IsValid() ? static_cast<double>(yFract) : 1.0;
    rPnt.setX(rRef.X() + FRound( (rPnt.X() - rRef.X()) * nxFract ));
    rPnt.setY(rRef.Y() + FRound( (rPnt.Y() - rRef.Y()) * nyFract ));
}

inline void RotatePoint(Point& rPnt, const Point& rRef, double sn, double cs)
{
    tools::Long dx=rPnt.X()-rRef.X();
    tools::Long dy=rPnt.Y()-rRef.Y();
    rPnt.setX(FRound(rRef.X()+dx*cs+dy*sn));
    rPnt.setY(FRound(rRef.Y()+dy*cs-dx*sn));
}

inline void ShearPoint(Point& rPnt, const Point& rRef, double tn, bool bVShear)
{
    if (!bVShear) { // Horizontal
        if (rPnt.Y()!=rRef.Y()) { // else not needed
            rPnt.AdjustX(-FRound((rPnt.Y()-rRef.Y())*tn));
        }
    } else { // or else vertical
        if (rPnt.X()!=rRef.X()) { // else not needed
            rPnt.AdjustY(-FRound((rPnt.X()-rRef.X())*tn));
        }
    }
}

inline double GetCrookAngle(Point& rPnt, const Point& rCenter, const Point& rRad, bool bVertical)
{
    double nAngle;
    if (bVertical) {
        tools::Long dy=rPnt.Y()-rCenter.Y();
        nAngle=static_cast<double>(dy)/static_cast<double>(rRad.Y());
        rPnt.setY(rCenter.Y());
    } else {
        tools::Long dx=rCenter.X()-rPnt.X();
        nAngle=static_cast<double>(dx)/static_cast<double>(rRad.X());
        rPnt.setX(rCenter.X());
    }
    return nAngle;
}

/**************************************************************************************************/
/**************************************************************************************************/

SVXCORE_DLLPUBLIC Degree100 GetAngle(const Point& rPnt);

Degree100 NormAngle18000(Degree100 a); 

SVXCORE_DLLPUBLIC Degree100 NormAngle36000(Degree100 a); 

sal_uInt16 GetAngleSector(Degree100 nAngle); 

tools::Long GetLen(const Point& rPnt);

class GeoStat { // Geometric state for a rect
public:
    Degree100 nRotationAngle;
    Degree100 nShearAngle;
    double   mfTanShearAngle;      // tan(nShearAngle)
    double   mfSinRotationAngle;   // sin(nRotationAngle)
    double   mfCosRotationAngle;   // cos(nRotationAngle)

    GeoStat(): nRotationAngle(0),nShearAngle(0),mfTanShearAngle(0.0),mfSinRotationAngle(0.0),mfCosRotationAngle(1.0) {}
    void RecalcSinCos();
    void RecalcTan();
};

tools::Polygon Rect2Poly(const tools::Rectangle& rRect, const GeoStat& rGeo);
void Poly2Rect(const tools::Polygon& rPol, tools::Rectangle& rRect, GeoStat& rGeo);

void OrthoDistance8(const Point& rPt0, Point& rPt, bool bBigOrtho);
void OrthoDistance4(const Point& rPt0, Point& rPt, bool bBigOrtho);

// Multiplication and subsequent division
// Calculation and intermediate values are in BigInt
SVXCORE_DLLPUBLIC tools::Long BigMulDiv(tools::Long nVal, tools::Long nMul, tools::Long nDiv);

class FrPair {
    Fraction aX;
    Fraction aY;
public:
    FrPair(const Fraction& rBoth)                     : aX(rBoth),aY(rBoth)         {}
    FrPair(const Fraction& rX, const Fraction& rY)    : aX(rX),aY(rY)               {}
    FrPair(tools::Long nMul, tools::Long nDiv)                      : aX(nMul,nDiv),aY(nMul,nDiv) {}
    FrPair(tools::Long xMul, tools::Long xDiv, tools::Long yMul, tools::Long yDiv): aX(xMul,xDiv),aY(yMul,yDiv) {}
    const Fraction& X() const { return aX; }
    const Fraction& Y() const { return aY; }
    Fraction& X()             { return aX; }
    Fraction& Y()             { return aY; }
};

// To convert units of measurement
SVXCORE_DLLPUBLIC FrPair GetMapFactor(MapUnit eS, MapUnit eD);
FrPair GetMapFactor(FieldUnit eS, FieldUnit eD);

inline bool IsMetric(MapUnit eU) {
    return (eU==MapUnit::Map100thMM || eU==MapUnit::Map10thMM || eU==MapUnit::MapMM || eU==MapUnit::MapCM);
}

inline bool IsInch(MapUnit eU) {
    return (eU==MapUnit::Map1000thInch || eU==MapUnit::Map100thInch || eU==MapUnit::Map10thInch || eU==MapUnit::MapInch ||
            eU==MapUnit::MapPoint       || eU==MapUnit::MapTwip);
}

inline bool IsMetric(FieldUnit eU) {
    return (eU == FieldUnit::MM || eU == FieldUnit::CM || eU == FieldUnit::M
            || eU == FieldUnit::KM || eU == FieldUnit::MM_100TH);
}

inline bool IsInch(FieldUnit eU) {
    return (eU == FieldUnit::TWIP || eU == FieldUnit::POINT
            || eU == FieldUnit::PICA || eU == FieldUnit::INCH
            || eU == FieldUnit::FOOT || eU == FieldUnit::MILE);
}

class SVXCORE_DLLPUBLIC SdrFormatter {
    tools::Long      nMul_;
    tools::Long      nDiv_;
    short     nComma_;
    bool      bDirty;
    MapUnit   eSrcMU;
    MapUnit   eDstMU;
private:
    SVX_DLLPRIVATE void Undirty();
public:
    SdrFormatter(MapUnit eSrc, MapUnit eDst)
        : nMul_(0)
        , nDiv_(0)
        , nComma_(0)
        , bDirty(true)
        , eSrcMU(eSrc)
        , eDstMU(eDst)
    {
    }
    OUString GetStr(tools::Long nVal) const;
    static OUString GetUnitStr(MapUnit eUnit);
    static OUString GetUnitStr(FieldUnit eUnit);
};

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