| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svx.hxx" |
| |
| #include <svx/svdtrans.hxx> |
| #include <math.h> |
| #include <svx/xpoly.hxx> |
| |
| #include <vcl/virdev.hxx> |
| #include <tools/bigint.hxx> |
| #include <tools/debug.hxx> |
| #include <unotools/syslocale.hxx> |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void MoveXPoly(XPolygon& rPoly, const Size& S) |
| { |
| rPoly.Move(S.Width(),S.Height()); |
| } |
| |
| void MoveXPoly(XPolyPolygon& rPoly, const Size& S) |
| { |
| rPoly.Move(S.Width(),S.Height()); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void ResizeRect(Rectangle& rRect, const Point& rRef, const Fraction& rxFact, const Fraction& ryFact, FASTBOOL bNoJustify) |
| { |
| Fraction xFact(rxFact); |
| Fraction yFact(ryFact); |
| //long nHgt=rRect.Bottom()-rRect.Top(); |
| |
| { |
| if (xFact.GetDenominator()==0) { |
| long nWdt=rRect.Right()-rRect.Left(); |
| if (xFact.GetNumerator()>=0) { // DivZero abfangen |
| xFact=Fraction(xFact.GetNumerator(),1); |
| if (nWdt==0) rRect.Right()++; |
| } else { |
| xFact=Fraction(xFact.GetNumerator(),-1); |
| if (nWdt==0) rRect.Left()--; |
| } |
| } |
| rRect.Left() =rRef.X()+Round(((double)(rRect.Left() -rRef.X())*xFact.GetNumerator())/xFact.GetDenominator()); |
| rRect.Right() =rRef.X()+Round(((double)(rRect.Right() -rRef.X())*xFact.GetNumerator())/xFact.GetDenominator()); |
| } |
| { |
| if (yFact.GetDenominator()==0) { |
| long nHgt=rRect.Bottom()-rRect.Top(); |
| if (yFact.GetNumerator()>=0) { // DivZero abfangen |
| yFact=Fraction(yFact.GetNumerator(),1); |
| if (nHgt==0) rRect.Bottom()++; |
| } else { |
| yFact=Fraction(yFact.GetNumerator(),-1); |
| if (nHgt==0) rRect.Top()--; |
| } |
| |
| yFact=Fraction(yFact.GetNumerator(),1); // DivZero abfangen |
| } |
| rRect.Top() =rRef.Y()+Round(((double)(rRect.Top() -rRef.Y())*yFact.GetNumerator())/yFact.GetDenominator()); |
| rRect.Bottom()=rRef.Y()+Round(((double)(rRect.Bottom()-rRef.Y())*yFact.GetNumerator())/yFact.GetDenominator()); |
| } |
| if (!bNoJustify) rRect.Justify(); |
| } |
| |
| |
| void ResizePoly(Polygon& rPoly, const Point& rRef, const Fraction& xFact, const Fraction& yFact) |
| { |
| sal_uInt16 nAnz=rPoly.GetSize(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| ResizePoint(rPoly[i],rRef,xFact,yFact); |
| } |
| } |
| |
| void ResizeXPoly(XPolygon& rPoly, const Point& rRef, const Fraction& xFact, const Fraction& yFact) |
| { |
| sal_uInt16 nAnz=rPoly.GetPointCount(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| ResizePoint(rPoly[i],rRef,xFact,yFact); |
| } |
| } |
| |
| void ResizePoly(PolyPolygon& rPoly, const Point& rRef, const Fraction& xFact, const Fraction& yFact) |
| { |
| sal_uInt16 nAnz=rPoly.Count(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| ResizePoly(rPoly[i],rRef,xFact,yFact); |
| } |
| } |
| |
| void ResizeXPoly(XPolyPolygon& rPoly, const Point& rRef, const Fraction& xFact, const Fraction& yFact) |
| { |
| sal_uInt16 nAnz=rPoly.Count(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| ResizeXPoly(rPoly[i],rRef,xFact,yFact); |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void RotatePoly(Polygon& rPoly, const Point& rRef, double sn, double cs) |
| { |
| sal_uInt16 nAnz=rPoly.GetSize(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| RotatePoint(rPoly[i],rRef,sn,cs); |
| } |
| } |
| |
| void RotateXPoly(XPolygon& rPoly, const Point& rRef, double sn, double cs) |
| { |
| sal_uInt16 nAnz=rPoly.GetPointCount(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| RotatePoint(rPoly[i],rRef,sn,cs); |
| } |
| } |
| |
| void RotatePoly(PolyPolygon& rPoly, const Point& rRef, double sn, double cs) |
| { |
| sal_uInt16 nAnz=rPoly.Count(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| RotatePoly(rPoly[i],rRef,sn,cs); |
| } |
| } |
| |
| void RotateXPoly(XPolyPolygon& rPoly, const Point& rRef, double sn, double cs) |
| { |
| sal_uInt16 nAnz=rPoly.Count(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| RotateXPoly(rPoly[i],rRef,sn,cs); |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void MirrorRect(Rectangle& rRect, const Point& /*rRef1*/, const Point& /*rRef2*/, FASTBOOL bNoJustify) |
| { |
| // !!! fehlende Implementation !!! |
| if (!bNoJustify) rRect.Justify(); |
| } |
| |
| void MirrorPoint(Point& rPnt, const Point& rRef1, const Point& rRef2) |
| { |
| long mx=rRef2.X()-rRef1.X(); |
| long my=rRef2.Y()-rRef1.Y(); |
| if (mx==0) { // Achse senkrecht |
| long dx=rRef1.X()-rPnt.X(); |
| rPnt.X()+=2*dx; |
| } else if (my==0) { // Achse waagerecht |
| long dy=rRef1.Y()-rPnt.Y(); |
| rPnt.Y()+=2*dy; |
| } else if (mx==my) { // Achse diagonal '\' |
| long dx1=rPnt.X()-rRef1.X(); |
| long dy1=rPnt.Y()-rRef1.Y(); |
| rPnt.X()=rRef1.X()+dy1; |
| rPnt.Y()=rRef1.Y()+dx1; |
| } else if (mx==-my) { // Achse diagonal '/' |
| long dx1=rPnt.X()-rRef1.X(); |
| long dy1=rPnt.Y()-rRef1.Y(); |
| rPnt.X()=rRef1.X()-dy1; |
| rPnt.Y()=rRef1.Y()-dx1; |
| } else { // beliebige Achse |
| // mal optimieren !!! |
| // Lot auf der Spiegelachse faellen oder so |
| long nRefWink=GetAngle(rRef2-rRef1); |
| rPnt-=rRef1; |
| long nPntWink=GetAngle(rPnt); |
| long nWink=2*(nRefWink-nPntWink); |
| double a=nWink*nPi180; |
| double nSin=sin(a); |
| double nCos=cos(a); |
| RotatePoint(rPnt,Point(),nSin,nCos); |
| rPnt+=rRef1; |
| } |
| } |
| |
| void MirrorPoly(Polygon& rPoly, const Point& rRef1, const Point& rRef2) |
| { |
| sal_uInt16 nAnz=rPoly.GetSize(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| MirrorPoint(rPoly[i],rRef1,rRef2); |
| } |
| } |
| |
| void MirrorXPoly(XPolygon& rPoly, const Point& rRef1, const Point& rRef2) |
| { |
| sal_uInt16 nAnz=rPoly.GetPointCount(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| MirrorPoint(rPoly[i],rRef1,rRef2); |
| } |
| } |
| |
| void MirrorPoly(PolyPolygon& rPoly, const Point& rRef1, const Point& rRef2) |
| { |
| sal_uInt16 nAnz=rPoly.Count(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| MirrorPoly(rPoly[i],rRef1,rRef2); |
| } |
| } |
| |
| void MirrorXPoly(XPolyPolygon& rPoly, const Point& rRef1, const Point& rRef2) |
| { |
| sal_uInt16 nAnz=rPoly.Count(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| MirrorXPoly(rPoly[i],rRef1,rRef2); |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void ShearPoly(Polygon& rPoly, const Point& rRef, double tn, FASTBOOL bVShear) |
| { |
| sal_uInt16 nAnz=rPoly.GetSize(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| ShearPoint(rPoly[i],rRef,tn,bVShear); |
| } |
| } |
| |
| void ShearXPoly(XPolygon& rPoly, const Point& rRef, double tn, FASTBOOL bVShear) |
| { |
| sal_uInt16 nAnz=rPoly.GetPointCount(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| ShearPoint(rPoly[i],rRef,tn,bVShear); |
| } |
| } |
| |
| void ShearPoly(PolyPolygon& rPoly, const Point& rRef, double tn, FASTBOOL bVShear) |
| { |
| sal_uInt16 nAnz=rPoly.Count(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| ShearPoly(rPoly[i],rRef,tn,bVShear); |
| } |
| } |
| |
| void ShearXPoly(XPolyPolygon& rPoly, const Point& rRef, double tn, FASTBOOL bVShear) |
| { |
| sal_uInt16 nAnz=rPoly.Count(); |
| for (sal_uInt16 i=0; i<nAnz; i++) { |
| ShearXPoly(rPoly[i],rRef,tn,bVShear); |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // |
| // @@@@ @@@@@ @@@@ @@@@ @@ @@ |
| // @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ |
| // @@ @@ @@ @@ @@ @@ @@ @@ @@ |
| // @@ @@@@@ @@ @@ @@ @@ @@@@ |
| // @@ @@ @@ @@ @@ @@ @@ @@ @@ |
| // @@ @@ @@ @@ @@ @@ @@ @@ @@ @@ |
| // @@@@ @@ @@ @@@@ @@@@ @@ @@ |
| // |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| double CrookRotateXPoint(Point& rPnt, Point* pC1, Point* pC2, const Point& rCenter, |
| const Point& rRad, double& rSin, double& rCos, FASTBOOL bVert) |
| { |
| FASTBOOL bC1=pC1!=NULL; |
| FASTBOOL bC2=pC2!=NULL; |
| long x0=rPnt.X(); |
| long y0=rPnt.Y(); |
| long cx=rCenter.X(); |
| long cy=rCenter.Y(); |
| double nWink=GetCrookAngle(rPnt,rCenter,rRad,bVert); |
| double sn=sin(nWink); |
| double cs=cos(nWink); |
| RotatePoint(rPnt,rCenter,sn,cs); |
| if (bC1) { |
| if (bVert) { |
| // Richtung Zentrum verschieben, als Ausgangsposition fuer Rotate |
| pC1->Y()-=y0; |
| // Resize, entsprechend der Entfernung vom Zentrum |
| pC1->Y()=Round(((double)pC1->Y()) /rRad.X()*(cx-pC1->X())); |
| pC1->Y()+=cy; |
| } else { |
| // Richtung Zentrum verschieben, als Ausgangsposition fuer Rotate |
| pC1->X()-=x0; |
| // Resize, entsprechend der Entfernung vom Zentrum |
| long nPntRad=cy-pC1->Y(); |
| double nFact=(double)nPntRad/(double)rRad.Y(); |
| pC1->X()=Round((double)pC1->X()*nFact); |
| pC1->X()+=cx; |
| } |
| RotatePoint(*pC1,rCenter,sn,cs); |
| } |
| if (bC2) { |
| if (bVert) { |
| // Richtung Zentrum verschieben, als Ausgangsposition fuer Rotate |
| pC2->Y()-=y0; |
| // Resize, entsprechend der Entfernung vom Zentrum |
| pC2->Y()=Round(((double)pC2->Y()) /rRad.X()*(rCenter.X()-pC2->X())); |
| pC2->Y()+=cy; |
| } else { |
| // Richtung Zentrum verschieben, als Ausgangsposition fuer Rotate |
| pC2->X()-=x0; |
| // Resize, entsprechend der Entfernung vom Zentrum |
| long nPntRad=rCenter.Y()-pC2->Y(); |
| double nFact=(double)nPntRad/(double)rRad.Y(); |
| pC2->X()=Round((double)pC2->X()*nFact); |
| pC2->X()+=cx; |
| } |
| RotatePoint(*pC2,rCenter,sn,cs); |
| } |
| rSin=sn; |
| rCos=cs; |
| return nWink; |
| } |
| |
| double CrookSlantXPoint(Point& rPnt, Point* pC1, Point* pC2, const Point& rCenter, |
| const Point& rRad, double& rSin, double& rCos, FASTBOOL bVert) |
| { |
| FASTBOOL bC1=pC1!=NULL; |
| FASTBOOL bC2=pC2!=NULL; |
| long x0=rPnt.X(); |
| long y0=rPnt.Y(); |
| long dx1=0,dy1=0; |
| long dxC1=0,dyC1=0; |
| long dxC2=0,dyC2=0; |
| if (bVert) { |
| long nStart=rCenter.X()-rRad.X(); |
| dx1=rPnt.X()-nStart; |
| rPnt.X()=nStart; |
| if (bC1) { |
| dxC1=pC1->X()-nStart; |
| pC1->X()=nStart; |
| } |
| if (bC2) { |
| dxC2=pC2->X()-nStart; |
| pC2->X()=nStart; |
| } |
| } else { |
| long nStart=rCenter.Y()-rRad.Y(); |
| dy1=rPnt.Y()-nStart; |
| rPnt.Y()=nStart; |
| if (bC1) { |
| dyC1=pC1->Y()-nStart; |
| pC1->Y()=nStart; |
| } |
| if (bC2) { |
| dyC2=pC2->Y()-nStart; |
| pC2->Y()=nStart; |
| } |
| } |
| double nWink=GetCrookAngle(rPnt,rCenter,rRad,bVert); |
| double sn=sin(nWink); |
| double cs=cos(nWink); |
| RotatePoint(rPnt,rCenter,sn,cs); |
| if (bC1) { if (bVert) pC1->Y()-=y0-rCenter.Y(); else pC1->X()-=x0-rCenter.X(); RotatePoint(*pC1,rCenter,sn,cs); } |
| if (bC2) { if (bVert) pC2->Y()-=y0-rCenter.Y(); else pC2->X()-=x0-rCenter.X(); RotatePoint(*pC2,rCenter,sn,cs); } |
| if (bVert) { |
| rPnt.X()+=dx1; |
| if (bC1) pC1->X()+=dxC1; |
| if (bC2) pC2->X()+=dxC2; |
| } else { |
| rPnt.Y()+=dy1; |
| if (bC1) pC1->Y()+=dyC1; |
| if (bC2) pC2->Y()+=dyC2; |
| } |
| rSin=sn; |
| rCos=cs; |
| return nWink; |
| } |
| |
| double CrookStretchXPoint(Point& rPnt, Point* pC1, Point* pC2, const Point& rCenter, |
| const Point& rRad, double& rSin, double& rCos, FASTBOOL bVert, |
| const Rectangle rRefRect) |
| { |
| //FASTBOOL bC1=pC1!=NULL; |
| //FASTBOOL bC2=pC2!=NULL; |
| //long x0=rPnt.X(); |
| long y0=rPnt.Y(); |
| CrookSlantXPoint(rPnt,pC1,pC2,rCenter,rRad,rSin,rCos,bVert); |
| if (bVert) { |
| } else { |
| //long nBase=rCenter.Y()-rRad.Y(); |
| long nTop=rRefRect.Top(); |
| long nBtm=rRefRect.Bottom(); |
| long nHgt=nBtm-nTop; |
| long dy=rPnt.Y()-y0; |
| //FASTBOOL bOben=rRad.Y()<0; |
| double a=((double)(y0-nTop))/nHgt; |
| a*=dy; |
| rPnt.Y()=y0+Round(a); |
| } return 0.0; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void CrookRotatePoly(XPolygon& rPoly, const Point& rCenter, const Point& rRad, FASTBOOL bVert) |
| { |
| double nSin,nCos; |
| sal_uInt16 nPointAnz=rPoly.GetPointCount(); |
| sal_uInt16 i=0; |
| while (i<nPointAnz) { |
| Point* pPnt=&rPoly[i]; |
| Point* pC1=NULL; |
| Point* pC2=NULL; |
| if (i+1<nPointAnz && rPoly.IsControl(i)) { // Kontrollpunkt links |
| pC1=pPnt; |
| i++; |
| pPnt=&rPoly[i]; |
| } |
| i++; |
| if (i<nPointAnz && rPoly.IsControl(i)) { // Kontrollpunkt rechts |
| pC2=&rPoly[i]; |
| i++; |
| } |
| CrookRotateXPoint(*pPnt,pC1,pC2,rCenter,rRad,nSin,nCos,bVert); |
| } |
| } |
| |
| void CrookSlantPoly(XPolygon& rPoly, const Point& rCenter, const Point& rRad, FASTBOOL bVert) |
| { |
| double nSin,nCos; |
| sal_uInt16 nPointAnz=rPoly.GetPointCount(); |
| sal_uInt16 i=0; |
| while (i<nPointAnz) { |
| Point* pPnt=&rPoly[i]; |
| Point* pC1=NULL; |
| Point* pC2=NULL; |
| if (i+1<nPointAnz && rPoly.IsControl(i)) { // Kontrollpunkt links |
| pC1=pPnt; |
| i++; |
| pPnt=&rPoly[i]; |
| } |
| i++; |
| if (i<nPointAnz && rPoly.IsControl(i)) { // Kontrollpunkt rechts |
| pC2=&rPoly[i]; |
| i++; |
| } |
| CrookSlantXPoint(*pPnt,pC1,pC2,rCenter,rRad,nSin,nCos,bVert); |
| } |
| } |
| |
| void CrookStretchPoly(XPolygon& rPoly, const Point& rCenter, const Point& rRad, FASTBOOL bVert, const Rectangle rRefRect) |
| { |
| double nSin,nCos; |
| sal_uInt16 nPointAnz=rPoly.GetPointCount(); |
| sal_uInt16 i=0; |
| while (i<nPointAnz) { |
| Point* pPnt=&rPoly[i]; |
| Point* pC1=NULL; |
| Point* pC2=NULL; |
| if (i+1<nPointAnz && rPoly.IsControl(i)) { // Kontrollpunkt links |
| pC1=pPnt; |
| i++; |
| pPnt=&rPoly[i]; |
| } |
| i++; |
| if (i<nPointAnz && rPoly.IsControl(i)) { // Kontrollpunkt rechts |
| pC2=&rPoly[i]; |
| i++; |
| } |
| CrookStretchXPoint(*pPnt,pC1,pC2,rCenter,rRad,nSin,nCos,bVert,rRefRect); |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void CrookRotatePoly(XPolyPolygon& rPoly, const Point& rCenter, const Point& rRad, FASTBOOL bVert) |
| { |
| sal_uInt16 nPolyAnz=rPoly.Count(); |
| for (sal_uInt16 nPolyNum=0; nPolyNum<nPolyAnz; nPolyNum++) { |
| CrookRotatePoly(rPoly[nPolyNum],rCenter,rRad,bVert); |
| } |
| } |
| |
| void CrookSlantPoly(XPolyPolygon& rPoly, const Point& rCenter, const Point& rRad, FASTBOOL bVert) |
| { |
| sal_uInt16 nPolyAnz=rPoly.Count(); |
| for (sal_uInt16 nPolyNum=0; nPolyNum<nPolyAnz; nPolyNum++) { |
| CrookSlantPoly(rPoly[nPolyNum],rCenter,rRad,bVert); |
| } |
| } |
| |
| void CrookStretchPoly(XPolyPolygon& rPoly, const Point& rCenter, const Point& rRad, FASTBOOL bVert, const Rectangle rRefRect) |
| { |
| sal_uInt16 nPolyAnz=rPoly.Count(); |
| for (sal_uInt16 nPolyNum=0; nPolyNum<nPolyAnz; nPolyNum++) { |
| CrookStretchPoly(rPoly[nPolyNum],rCenter,rRad,bVert,rRefRect); |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| long GetAngle(const Point& rPnt) |
| { |
| long a=0; |
| if (rPnt.Y()==0) { |
| if (rPnt.X()<0) a=-18000; |
| } else if (rPnt.X()==0) { |
| if (rPnt.Y()>0) a=-9000; |
| else a=9000; |
| } else { |
| a=Round((atan2((double)-rPnt.Y(),(double)rPnt.X())/nPi180)); |
| } |
| return a; |
| } |
| |
| long NormAngle180(long a) |
| { |
| while (a<18000) a+=36000; |
| while (a>=18000) a-=36000; |
| return a; |
| } |
| |
| long NormAngle360(long a) |
| { |
| while (a<0) a+=36000; |
| while (a>=36000) a-=36000; |
| return a; |
| } |
| |
| sal_uInt16 GetAngleSector(long nWink) |
| { |
| while (nWink<0) nWink+=36000; |
| while (nWink>=36000) nWink-=36000; |
| if (nWink< 9000) return 0; |
| if (nWink<18000) return 1; |
| if (nWink<27000) return 2; |
| return 3; |
| } |
| |
| long GetLen(const Point& rPnt) |
| { |
| long x=Abs(rPnt.X()); |
| long y=Abs(rPnt.Y()); |
| if (x+y<0x8000) { // weil 7FFF * 7FFF * 2 = 7FFE0002 |
| x*=x; |
| y*=y; |
| x+=y; |
| x=Round(sqrt((double)x)); |
| return x; |
| } else { |
| double nx=x; |
| double ny=y; |
| nx*=nx; |
| ny*=ny; |
| nx+=ny; |
| nx=sqrt(nx); |
| if (nx>0x7FFFFFFF) { |
| return 0x7FFFFFFF; // Ueberlauf, mehr is nich! |
| } else { |
| return Round(nx); |
| } |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void GeoStat::RecalcSinCos() |
| { |
| if (nDrehWink==0) { |
| nSin=0.0; |
| nCos=1.0; |
| } else { |
| double a=nDrehWink*nPi180; |
| nSin=sin(a); |
| nCos=cos(a); |
| } |
| } |
| |
| void GeoStat::RecalcTan() |
| { |
| if (nShearWink==0) { |
| nTan=0.0; |
| } else { |
| double a=nShearWink*nPi180; |
| nTan=tan(a); |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| Polygon Rect2Poly(const Rectangle& rRect, const GeoStat& rGeo) |
| { |
| Polygon aPol(5); |
| aPol[0]=rRect.TopLeft(); |
| aPol[1]=rRect.TopRight(); |
| aPol[2]=rRect.BottomRight(); |
| aPol[3]=rRect.BottomLeft(); |
| aPol[4]=rRect.TopLeft(); |
| if (rGeo.nShearWink!=0) ShearPoly(aPol,rRect.TopLeft(),rGeo.nTan); |
| if (rGeo.nDrehWink!=0) RotatePoly(aPol,rRect.TopLeft(),rGeo.nSin,rGeo.nCos); |
| return aPol; |
| } |
| |
| void Poly2Rect(const Polygon& rPol, Rectangle& rRect, GeoStat& rGeo) |
| { |
| rGeo.nDrehWink=GetAngle(rPol[1]-rPol[0]); |
| rGeo.nDrehWink=NormAngle360(rGeo.nDrehWink); |
| // Drehung ist damit im Kasten |
| rGeo.RecalcSinCos(); |
| |
| Point aPt1(rPol[1]-rPol[0]); |
| if (rGeo.nDrehWink!=0) RotatePoint(aPt1,Point(0,0),-rGeo.nSin,rGeo.nCos); // -Sin fuer Rueckdrehung |
| long nWdt=aPt1.X(); |
| |
| Point aPt0(rPol[0]); |
| Point aPt3(rPol[3]-rPol[0]); |
| if (rGeo.nDrehWink!=0) RotatePoint(aPt3,Point(0,0),-rGeo.nSin,rGeo.nCos); // -Sin fuer Rueckdrehung |
| long nHgt=aPt3.Y(); |
| |
| if(aPt3.X()) |
| { |
| // #i74358# the axes are not orthogonal, so for getting the correct height, |
| // calculate the length of aPt3 |
| |
| // #i74358# this change was wrong, in the field of the old geometry stuff |
| // it is not an error. The new height always is the same as before; shear |
| // does not change object height at all. This is different from the interactions, |
| // but obviously wanted in the old versions. |
| // |
| // nHgt = static_cast< long >(sqrt(static_cast< double >(aPt3.X() * aPt3.X() + aPt3.Y() * aPt3.Y()))); |
| } |
| |
| long nShW=GetAngle(aPt3); |
| nShW-=27000; // ShearWink wird zur Senkrechten gemessen |
| nShW=-nShW; // Negieren, denn '+' ist Rechtskursivierung |
| |
| FASTBOOL bMirr=aPt3.Y()<0; |
| if (bMirr) { // "Punktetausch" bei Spiegelung |
| nHgt=-nHgt; |
| nShW+=18000; |
| aPt0=rPol[3]; |
| } |
| nShW=NormAngle180(nShW); |
| if (nShW<-9000 || nShW>9000) { |
| nShW=NormAngle180(nShW+18000); |
| } |
| if (nShW<-SDRMAXSHEAR) nShW=-SDRMAXSHEAR; // ShearWinkel begrenzen auf +/- 89.00 deg |
| if (nShW>SDRMAXSHEAR) nShW=SDRMAXSHEAR; |
| rGeo.nShearWink=nShW; |
| rGeo.RecalcTan(); |
| Point aRU(aPt0); |
| aRU.X()+=nWdt; |
| aRU.Y()+=nHgt; |
| rRect=Rectangle(aPt0,aRU); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void OrthoDistance8(const Point& rPt0, Point& rPt, FASTBOOL bBigOrtho) |
| { |
| long dx=rPt.X()-rPt0.X(); |
| long dy=rPt.Y()-rPt0.Y(); |
| long dxa=Abs(dx); |
| long dya=Abs(dy); |
| if (dx==0 || dy==0 || dxa==dya) return; |
| if (dxa>=dya*2) { rPt.Y()=rPt0.Y(); return; } |
| if (dya>=dxa*2) { rPt.X()=rPt0.X(); return; } |
| if ((dxa<dya) != bBigOrtho) { |
| rPt.Y()=rPt0.Y()+(dxa* (dy>=0 ? 1 : -1) ); |
| } else { |
| rPt.X()=rPt0.X()+(dya* (dx>=0 ? 1 : -1) ); |
| } |
| } |
| |
| void OrthoDistance4(const Point& rPt0, Point& rPt, FASTBOOL bBigOrtho) |
| { |
| long dx=rPt.X()-rPt0.X(); |
| long dy=rPt.Y()-rPt0.Y(); |
| long dxa=Abs(dx); |
| long dya=Abs(dy); |
| if ((dxa<dya) != bBigOrtho) { |
| rPt.Y()=rPt0.Y()+(dxa* (dy>=0 ? 1 : -1) ); |
| } else { |
| rPt.X()=rPt0.X()+(dya* (dx>=0 ? 1 : -1) ); |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| long BigMulDiv(long nVal, long nMul, long nDiv) |
| { |
| BigInt aVal(nVal); |
| aVal*=nMul; |
| if (aVal.IsNeg()!=(nDiv<0)) { |
| aVal-=nDiv/2; // fuer korrektes Runden |
| } else { |
| aVal+=nDiv/2; // fuer korrektes Runden |
| } |
| if(nDiv) |
| { |
| aVal/=nDiv; |
| return long(aVal); |
| } |
| return 0x7fffffff; |
| } |
| |
| void Kuerzen(Fraction& rF, unsigned nDigits) |
| { |
| sal_Int32 nMul=rF.GetNumerator(); |
| sal_Int32 nDiv=rF.GetDenominator(); |
| FASTBOOL bNeg=sal_False; |
| if (nMul<0) { nMul=-nMul; bNeg=!bNeg; } |
| if (nDiv<0) { nDiv=-nDiv; bNeg=!bNeg; } |
| if (nMul==0 || nDiv==0) return; |
| sal_uInt32 a; |
| a=sal_uInt32(nMul); unsigned nMulZ=0; // Fuehrende Nullen zaehlen |
| while (a<0x00800000) { nMulZ+=8; a<<=8; } |
| while (a<0x80000000) { nMulZ++; a<<=1; } |
| a=sal_uInt32(nDiv); unsigned nDivZ=0; // Fuehrende Nullen zaehlen |
| while (a<0x00800000) { nDivZ+=8; a<<=8; } |
| while (a<0x80000000) { nDivZ++; a<<=1; } |
| // Anzahl der verwendeten Digits bestimmen |
| int nMulDigits=32-nMulZ; |
| int nDivDigits=32-nDivZ; |
| // Nun bestimmen, wieviele Stellen hinten weg koennen |
| int nMulWeg=nMulDigits-nDigits; if (nMulWeg<0) nMulWeg=0; |
| int nDivWeg=nDivDigits-nDigits; if (nDivWeg<0) nDivWeg=0; |
| int nWeg=Min(nMulWeg,nDivWeg); |
| nMul>>=nWeg; |
| nDiv>>=nWeg; |
| if (nMul==0 || nDiv==0) { |
| DBG_WARNING("Oups, beim kuerzen einer Fraction hat sich Joe verrechnet."); |
| return; |
| } |
| if (bNeg) nMul=-nMul; |
| rF=Fraction(nMul,nDiv); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // Wieviele eU-Einheiten passen in einen mm bzw. Inch? |
| // Oder wie gross ist ein eU in mm bzw. Inch, und davon der Kehrwert |
| |
| FrPair GetInchOrMM(MapUnit eU) |
| { |
| switch (eU) { |
| case MAP_1000TH_INCH: return FrPair(1000,1); |
| case MAP_100TH_INCH : return FrPair( 100,1); |
| case MAP_10TH_INCH : return FrPair( 10,1); |
| case MAP_INCH : return FrPair( 1,1); |
| case MAP_POINT : return FrPair( 72,1); |
| case MAP_TWIP : return FrPair(1440,1); |
| case MAP_100TH_MM : return FrPair( 100,1); |
| case MAP_10TH_MM : return FrPair( 10,1); |
| case MAP_MM : return FrPair( 1,1); |
| case MAP_CM : return FrPair( 1,10); |
| case MAP_PIXEL : { |
| VirtualDevice aVD; |
| aVD.SetMapMode(MapMode(MAP_100TH_MM)); |
| Point aP(aVD.PixelToLogic(Point(64,64))); // 64 Pixel fuer bessere Genauigkeit |
| return FrPair(6400,aP.X(),6400,aP.Y()); |
| } |
| case MAP_APPFONT: case MAP_SYSFONT: { |
| VirtualDevice aVD; |
| aVD.SetMapMode(MapMode(eU)); |
| Point aP(aVD.LogicToPixel(Point(32,32))); // 32 Einheiten fuer bessere Genauigkeit |
| aVD.SetMapMode(MapMode(MAP_100TH_MM)); |
| aP=aVD.PixelToLogic(aP); |
| return FrPair(3200,aP.X(),3200,aP.Y()); |
| } |
| default: break; |
| } |
| return Fraction(1,1); |
| } |
| |
| FrPair GetInchOrMM(FieldUnit eU) |
| { |
| switch (eU) { |
| case FUNIT_INCH : return FrPair( 1,1); |
| case FUNIT_POINT : return FrPair( 72,1); |
| case FUNIT_TWIP : return FrPair(1440,1); |
| case FUNIT_100TH_MM : return FrPair( 100,1); |
| case FUNIT_MM : return FrPair( 1,1); |
| case FUNIT_CM : return FrPair( 1,10); |
| case FUNIT_M : return FrPair( 1,1000); |
| case FUNIT_KM : return FrPair( 1,1000000); |
| case FUNIT_PICA : return FrPair( 6,1); |
| case FUNIT_FOOT : return FrPair( 1,12); |
| case FUNIT_MILE : return FrPair( 1,63360); |
| default: break; |
| } |
| return Fraction(1,1); |
| } |
| |
| // Den Faktor berechnen, der anzuwenden ist um n Einheiten von eS nach |
| // eD umzurechnen. Z.B. GetMapFactor(UNIT_MM,UNIT_100TH_MM) => 100. |
| |
| FrPair GetMapFactor(MapUnit eS, MapUnit eD) |
| { |
| if (eS==eD) return FrPair(1,1,1,1); |
| FrPair aS(GetInchOrMM(eS)); |
| FrPair aD(GetInchOrMM(eD)); |
| FASTBOOL bSInch=IsInch(eS); |
| FASTBOOL bDInch=IsInch(eD); |
| FrPair aRet(aD.X()/aS.X(),aD.Y()/aS.Y()); |
| if (bSInch && !bDInch) { aRet.X()*=Fraction(127,5); aRet.Y()*=Fraction(127,5); } |
| if (!bSInch && bDInch) { aRet.X()*=Fraction(5,127); aRet.Y()*=Fraction(5,127); } |
| return aRet; |
| }; |
| |
| FrPair GetMapFactor(MapUnit eS, FieldUnit eD) |
| { |
| FrPair aS(GetInchOrMM(eS)); |
| FrPair aD(GetInchOrMM(eD)); |
| FASTBOOL bSInch=IsInch(eS); |
| FASTBOOL bDInch=IsInch(eD); |
| FrPair aRet(aD.X()/aS.X(),aD.Y()/aS.Y()); |
| if (bSInch && !bDInch) { aRet.X()*=Fraction(127,5); aRet.Y()*=Fraction(127,5); } |
| if (!bSInch && bDInch) { aRet.X()*=Fraction(5,127); aRet.Y()*=Fraction(5,127); } |
| return aRet; |
| }; |
| |
| FrPair GetMapFactor(FieldUnit eS, MapUnit eD) |
| { |
| FrPair aS(GetInchOrMM(eS)); |
| FrPair aD(GetInchOrMM(eD)); |
| FASTBOOL bSInch=IsInch(eS); |
| FASTBOOL bDInch=IsInch(eD); |
| FrPair aRet(aD.X()/aS.X(),aD.Y()/aS.Y()); |
| if (bSInch && !bDInch) { aRet.X()*=Fraction(127,5); aRet.Y()*=Fraction(127,5); } |
| if (!bSInch && bDInch) { aRet.X()*=Fraction(5,127); aRet.Y()*=Fraction(5,127); } |
| return aRet; |
| }; |
| |
| FrPair GetMapFactor(FieldUnit eS, FieldUnit eD) |
| { |
| if (eS==eD) return FrPair(1,1,1,1); |
| FrPair aS(GetInchOrMM(eS)); |
| FrPair aD(GetInchOrMM(eD)); |
| FASTBOOL bSInch=IsInch(eS); |
| FASTBOOL bDInch=IsInch(eD); |
| FrPair aRet(aD.X()/aS.X(),aD.Y()/aS.Y()); |
| if (bSInch && !bDInch) { aRet.X()*=Fraction(127,5); aRet.Y()*=Fraction(127,5); } |
| if (!bSInch && bDInch) { aRet.X()*=Fraction(5,127); aRet.Y()*=Fraction(5,127); } |
| return aRet; |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| // 1 mile = 8 furlong = 63.360" = 1.609.344,0mm |
| // 1 furlong = 10 chains = 7.920" = 201.168,0mm |
| // 1 chain = 4 poles = 792" = 20.116,8mm |
| // 1 pole = 5 1/2 yd = 198" = 5.029,2mm |
| // 1 yd = 3 ft = 36" = 914,4mm |
| // 1 ft = 12 " = 1" = 304,8mm |
| |
| void GetMeterOrInch(MapUnit eMU, short& rnKomma, long& rnMul, long& rnDiv, int& rbMetr, int& rbInch) |
| { |
| rnMul=1; rnDiv=1; |
| short nKomma=0; |
| FASTBOOL bMetr=sal_False,bInch=sal_False; |
| switch (eMU) { |
| // Metrisch |
| case MAP_100TH_MM : bMetr=sal_True; nKomma=5; break; |
| case MAP_10TH_MM : bMetr=sal_True; nKomma=4; break; |
| case MAP_MM : bMetr=sal_True; nKomma=3; break; |
| case MAP_CM : bMetr=sal_True; nKomma=2; break; |
| // Inch |
| case MAP_1000TH_INCH: bInch=sal_True; nKomma=3; break; |
| case MAP_100TH_INCH : bInch=sal_True; nKomma=2; break; |
| case MAP_10TH_INCH : bInch=sal_True; nKomma=1; break; |
| case MAP_INCH : bInch=sal_True; nKomma=0; break; |
| case MAP_POINT : bInch=sal_True; rnDiv=72; break; // 1Pt = 1/72" |
| case MAP_TWIP : bInch=sal_True; rnDiv=144; nKomma=1; break; // 1Twip = 1/1440" |
| // Sonstiges |
| case MAP_PIXEL : break; |
| case MAP_SYSFONT : break; |
| case MAP_APPFONT : break; |
| case MAP_RELATIVE : break; |
| default: break; |
| } // switch |
| rnKomma=nKomma; |
| rbMetr=bMetr; |
| rbInch=bInch; |
| } |
| |
| void GetMeterOrInch(FieldUnit eFU, short& rnKomma, long& rnMul, long& rnDiv, int& rbMetr, int& rbInch) |
| { |
| rnMul=1; rnDiv=1; |
| short nKomma=0; |
| FASTBOOL bMetr=sal_False,bInch=sal_False; |
| switch (eFU) { |
| case FUNIT_NONE : break; |
| // Metrisch |
| case FUNIT_100TH_MM : bMetr=sal_True; nKomma=5; break; |
| case FUNIT_MM : bMetr=sal_True; nKomma=3; break; |
| case FUNIT_CM : bMetr=sal_True; nKomma=2; break; |
| case FUNIT_M : bMetr=sal_True; nKomma=0; break; |
| case FUNIT_KM : bMetr=sal_True; nKomma=-3; break; |
| // Inch |
| case FUNIT_TWIP : bInch=sal_True; rnDiv=144; nKomma=1; break; // 1Twip = 1/1440" |
| case FUNIT_POINT : bInch=sal_True; rnDiv=72; break; // 1Pt = 1/72" |
| case FUNIT_PICA : bInch=sal_True; rnDiv=6; break; // 1Pica = 1/6" ? |
| case FUNIT_INCH : bInch=sal_True; break; // 1" = 1" |
| case FUNIT_FOOT : bInch=sal_True; rnMul=12; break; // 1Ft = 12" |
| case FUNIT_MILE : bInch=sal_True; rnMul=6336; nKomma=-1; break; // 1mile = 63360" |
| // sonstiges |
| case FUNIT_CUSTOM : break; |
| case FUNIT_PERCENT : nKomma=2; break; |
| } // switch |
| rnKomma=nKomma; |
| rbMetr=bMetr; |
| rbInch=bInch; |
| } |
| |
| void SdrFormatter::Undirty() |
| { |
| if (aScale.GetNumerator()==0 || aScale.GetDenominator()==0) aScale=Fraction(1,1); |
| FASTBOOL bSrcMetr,bSrcInch,bDstMetr,bDstInch; |
| long nMul1,nDiv1,nMul2,nDiv2; |
| short nKomma1,nKomma2; |
| // Zunaechst normalisieren auf m bzw. " |
| if (!bSrcFU) { |
| GetMeterOrInch(eSrcMU,nKomma1,nMul1,nDiv1,bSrcMetr,bSrcInch); |
| } else { |
| GetMeterOrInch(eSrcFU,nKomma1,nMul1,nDiv1,bSrcMetr,bSrcInch); |
| } |
| if (!bDstFU) { |
| GetMeterOrInch(eDstMU,nKomma2,nMul2,nDiv2,bDstMetr,bDstInch); |
| } else { |
| GetMeterOrInch(eDstFU,nKomma2,nMul2,nDiv2,bDstMetr,bDstInch); |
| } |
| nMul1*=nDiv2; |
| nDiv1*=nMul2; |
| nKomma1=nKomma1-nKomma2; |
| |
| if (bSrcInch && bDstMetr) { |
| nKomma1+=4; |
| nMul1*=254; |
| } |
| if (bSrcMetr && bDstInch) { |
| nKomma1-=4; |
| nDiv1*=254; |
| } |
| |
| // Temporaere Fraction zum Kuerzen |
| Fraction aTempFract(nMul1,nDiv1); |
| nMul1=aTempFract.GetNumerator(); |
| nDiv1=aTempFract.GetDenominator(); |
| |
| nMul_=nMul1; |
| nDiv_=nDiv1; |
| nKomma_=nKomma1; |
| bDirty=sal_False; |
| } |
| |
| |
| void SdrFormatter::TakeStr(long nVal, XubString& rStr) const |
| { |
| sal_Unicode aNullCode('0'); |
| |
| if(!nVal) |
| { |
| rStr = UniString(); |
| rStr += aNullCode; |
| return; |
| } |
| |
| // Hier fallen trotzdem evtl. Nachkommastellen weg, wg. MulDiv statt Real |
| sal_Bool bNeg(nVal < 0); |
| SvtSysLocale aSysLoc; |
| const LocaleDataWrapper& rLoc = aSysLoc.GetLocaleData(); |
| |
| ForceUndirty(); |
| |
| sal_Int16 nK(nKomma_); |
| XubString aStr; |
| |
| if(bNeg) |
| nVal = -nVal; |
| |
| while(nK <= -3) |
| { |
| nVal *= 1000; |
| nK += 3; |
| } |
| |
| while(nK <= -1) |
| { |
| nVal *= 10; |
| nK++; |
| } |
| |
| if(nMul_ != nDiv_) |
| nVal = BigMulDiv(nVal, nMul_, nDiv_); |
| |
| aStr = UniString::CreateFromInt32(nVal); |
| |
| if(nK > 0 && aStr.Len() <= nK ) |
| { |
| // Komma erforderlich |
| sal_Int16 nAnz(nK - aStr.Len()); |
| |
| if(nAnz >= 0 && rLoc.isNumLeadingZero()) |
| nAnz++; |
| |
| for(xub_StrLen i=0; i<nAnz; i++) |
| aStr.Insert(aNullCode, 0); |
| |
| // zuviele Nachkommastellen abhacken |
| xub_StrLen nNumDigits(rLoc.getNumDigits()); |
| xub_StrLen nWeg(nK - nNumDigits); |
| |
| if(nWeg > 0) |
| { |
| // hier muesste eigentlich noch gerundet werden! |
| aStr.Erase(aStr.Len() - nWeg); |
| nK = nNumDigits; |
| } |
| } |
| |
| // Vorkommastellen fuer spaeter merken |
| xub_StrLen nVorKomma(aStr.Len() - nK); |
| |
| if(nK > 0) |
| { |
| // KommaChar einfuegen |
| // erstmal trailing Zeros abhacken |
| while(nK > 0 && aStr.GetChar(aStr.Len() - 1) == aNullCode) |
| { |
| aStr.Erase(aStr.Len() - 1); |
| nK--; |
| } |
| |
| if(nK > 0) |
| { |
| // na, noch Nachkommastellen da? |
| sal_Unicode cDec(rLoc.getNumDecimalSep().GetChar(0)); |
| aStr.Insert(cDec, nVorKomma); |
| } |
| } |
| |
| // ggf. Trennpunkte bei jedem Tausender einfuegen |
| if( nVorKomma > 3 ) |
| { |
| String aThoSep( rLoc.getNumThousandSep() ); |
| if ( aThoSep.Len() > 0 ) |
| { |
| sal_Unicode cTho( aThoSep.GetChar(0) ); |
| sal_Int32 i(nVorKomma - 3); |
| |
| while(i > 0) |
| { |
| rStr.Insert(cTho, (xub_StrLen)i); |
| i -= 3; |
| } |
| } |
| } |
| |
| if(!aStr.Len()) |
| aStr += aNullCode; |
| |
| if(bNeg && (aStr.Len() > 1 || aStr.GetChar(0) != aNullCode)) |
| { |
| rStr.Insert(sal_Unicode('-'), 0); |
| } |
| |
| rStr = aStr; |
| } |
| |
| void SdrFormatter::TakeUnitStr(MapUnit eUnit, XubString& rStr) |
| { |
| const sal_Char* pText; |
| |
| switch(eUnit) |
| { |
| // metric units |
| case MAP_100TH_MM : pText = "/100mm"; break; |
| case MAP_10TH_MM : pText = "/10mm"; break; |
| case MAP_MM : pText = "mm"; break; |
| case MAP_CM : pText = "cm"; break; |
| |
| // imperial units |
| case MAP_1000TH_INCH: pText = "/1000\""; break; |
| case MAP_100TH_INCH : pText = "/100\""; break; |
| case MAP_10TH_INCH : pText = "/10\""; break; |
| case MAP_INCH : pText = "\""; break; |
| case MAP_POINT : pText = "pt"; break; |
| case MAP_TWIP : pText = "twip"; break; |
| |
| // other units |
| case MAP_PIXEL : pText = "pixel"; break; |
| case MAP_SYSFONT : pText = "sysfont"; break; |
| case MAP_APPFONT : pText = "appfont"; break; |
| case MAP_RELATIVE : pText = "%"; break; |
| |
| default : pText = ""; break; |
| } |
| |
| rStr = XubString::CreateFromAscii( pText ); |
| } |
| |
| void SdrFormatter::TakeUnitStr(FieldUnit eUnit, XubString& rStr) |
| { |
| const sal_Char* pText; |
| |
| switch(eUnit) |
| { |
| // metric units |
| case FUNIT_100TH_MM : pText = "/100mm"; break; |
| case FUNIT_MM : pText = "mm"; break; |
| case FUNIT_CM : pText = "cm"; break; |
| case FUNIT_M : pText = "m"; break; |
| case FUNIT_KM : pText = "km"; break; |
| |
| // imperial units |
| case FUNIT_TWIP : pText = "twip"; break; |
| case FUNIT_POINT : pText = "pt"; break; |
| case FUNIT_PICA : pText = "pica"; break; |
| case FUNIT_INCH : pText = "\""; break; |
| case FUNIT_FOOT : pText = "ft"; break; |
| case FUNIT_MILE : pText = "mile(s)"; break; |
| |
| // other units |
| case FUNIT_PERCENT: pText = "%"; break; |
| |
| // case FUNIT_NONE : |
| // case FUNIT_CUSTOM : |
| default : pText = ""; break; |
| } |
| |
| rStr = XubString::CreateFromAscii( pText ); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| |
