PageRenderTime 70ms CodeModel.GetById 29ms RepoModel.GetById 0ms app.codeStats 1ms

/svx/source/svdraw/svdtrans.cxx

https://bitbucket.org/mst/ooo340
C++ | 1271 lines | 1046 code | 114 blank | 111 comment | 194 complexity | 1bba4ad298fcc9d375d186e8125e3a28 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, LGPL-3.0, AGPL-1.0, BSD-3-Clause-No-Nuclear-License-2014, GPL-3.0, GPL-2.0, BSD-3-Clause, LGPL-2.1 
    

  1. /*************************************************************************
    2. 

  2.  *
    3. 

  3.  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    4. 

  4.  * 
    5. 

  5.  * Copyright 2000, 2010 Oracle and/or its affiliates.
    6. 

  6.  *
    7. 

  7.  * OpenOffice.org - a multi-platform office productivity suite
    8. 

  8.  *
    9. 

  9.  * This file is part of OpenOffice.org.
    10. 

  10.  *
    11. 

  11.  * OpenOffice.org is free software: you can redistribute it and/or modify
    12. 

  12.  * it under the terms of the GNU Lesser General Public License version 3
    13. 

  13.  * only, as published by the Free Software Foundation.
    14. 

  14.  *
    15. 

  15.  * OpenOffice.org is distributed in the hope that it will be useful,
    16. 

  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    17. 

  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    18. 

  18.  * GNU Lesser General Public License version 3 for more details
    19. 

  19.  * (a copy is included in the LICENSE file that accompanied this code).
    20. 

  20.  *
    21. 

  21.  * You should have received a copy of the GNU Lesser General Public License
    22. 

  22.  * version 3 along with OpenOffice.org.  If not, see
    23. 

  23.  * <http://www.openoffice.org/license.html>
    24. 

  24.  * for a copy of the LGPLv3 License.
    25. 

  25.  *
    26. 

  26.  ************************************************************************/
    27. 

  27. 

  28. // MARKER(update_precomp.py): autogen include statement, do not remove
    29. 

  29. #include "precompiled_svx.hxx"
    30. 

  30. 

  31. #include <svx/svdtrans.hxx>
    32. 

  32. #include <math.h>
    33. 

  33. #include <svx/xpoly.hxx>
    34. 

  34. 

  35. #include <vcl/virdev.hxx>
    36. 

  36. #include <tools/bigint.hxx>
    37. 

  37. #include <tools/debug.hxx>
    38. 

  38. #include <unotools/syslocale.hxx>
    39. 

  39. 

  40. ////////////////////////////////////////////////////////////////////////////////////////////////////
    41. 

  41. 

  42. void MoveXPoly(XPolygon& rPoly, const Size& S)
    43. 

  43. {
    44. 

  44. 	rPoly.Move(S.Width(),S.Height());
    45. 

  45. }
    46. 

  46. 

  47. void MoveXPoly(XPolyPolygon& rPoly, const Size& S)
    48. 

  48. {
    49. 

  49. 	rPoly.Move(S.Width(),S.Height());
    50. 

  50. }
    51. 

  51. 

  52. ////////////////////////////////////////////////////////////////////////////////////////////////////
    53. 

  53. 

  54. void ResizeRect(Rectangle& rRect, const Point& rRef, const Fraction& rxFact, const Fraction& ryFact, FASTBOOL bNoJustify)
    55. 

  55. {
    56. 

  56. 	Fraction xFact(rxFact);
    57. 

  57. 	Fraction yFact(ryFact);
    58. 

  58. 	//long nHgt=rRect.Bottom()-rRect.Top();
    59. 

  59. 

  60. 	{
    61. 

  61. 		if (xFact.GetDenominator()==0) {
    62. 

  62. 			long nWdt=rRect.Right()-rRect.Left();
    63. 

  63. 			if (xFact.GetNumerator()>=0) { // DivZero abfangen
    64. 

  64. 				xFact=Fraction(xFact.GetNumerator(),1);
    65. 

  65. 				if (nWdt==0) rRect.Right()++;
    66. 

  66. 			} else {
    67. 

  67. 				xFact=Fraction(xFact.GetNumerator(),-1);
    68. 

  68. 				if (nWdt==0) rRect.Left()--;
    69. 

  69. 			}
    70. 

  70. 		}
    71. 

  71. 		rRect.Left()  =rRef.X()+Round(((double)(rRect.Left()  -rRef.X())*xFact.GetNumerator())/xFact.GetDenominator());
    72. 

  72. 		rRect.Right() =rRef.X()+Round(((double)(rRect.Right() -rRef.X())*xFact.GetNumerator())/xFact.GetDenominator());
    73. 

  73. 	}
    74. 

  74. 	{
    75. 

  75. 		if (yFact.GetDenominator()==0) {
    76. 

  76. 			long nHgt=rRect.Bottom()-rRect.Top();
    77. 

  77. 			if (yFact.GetNumerator()>=0) { // DivZero abfangen
    78. 

  78. 				yFact=Fraction(yFact.GetNumerator(),1);
    79. 

  79. 				if (nHgt==0) rRect.Bottom()++;
    80. 

  80. 			} else {
    81. 

  81. 				yFact=Fraction(yFact.GetNumerator(),-1);
    82. 

  82. 				if (nHgt==0) rRect.Top()--;
    83. 

  83. 			}
    84. 

  84. 

  85. 			yFact=Fraction(yFact.GetNumerator(),1); // DivZero abfangen
    86. 

  86. 		}
    87. 

  87. 		rRect.Top()   =rRef.Y()+Round(((double)(rRect.Top()   -rRef.Y())*yFact.GetNumerator())/yFact.GetDenominator());
    88. 

  88. 		rRect.Bottom()=rRef.Y()+Round(((double)(rRect.Bottom()-rRef.Y())*yFact.GetNumerator())/yFact.GetDenominator());
    89. 

  89. 	}
    90. 

  90. 	if (!bNoJustify) rRect.Justify();
    91. 

  91. }
    92. 

  92. 

  93. 

  94. void ResizePoly(Polygon& rPoly, const Point& rRef, const Fraction& xFact, const Fraction& yFact)
    95. 

  95. {
    96. 

  96. 	USHORT nAnz=rPoly.GetSize();
    97. 

  97. 	for (USHORT i=0; i<nAnz; i++) {
    98. 

  98. 		ResizePoint(rPoly[i],rRef,xFact,yFact);
    99. 

  99. 	}
    100. 

  100. }
    101. 

  101. 

  102. void ResizeXPoly(XPolygon& rPoly, const Point& rRef, const Fraction& xFact, const Fraction& yFact)
    103. 

  103. {
    104. 

  104. 	USHORT nAnz=rPoly.GetPointCount();
    105. 

  105. 	for (USHORT i=0; i<nAnz; i++) {
    106. 

  106. 		ResizePoint(rPoly[i],rRef,xFact,yFact);
    107. 

  107. 	}
    108. 

  108. }
    109. 

  109. 

  110. void ResizePoly(PolyPolygon& rPoly, const Point& rRef, const Fraction& xFact, const Fraction& yFact)
    111. 

  111. {
    112. 

  112. 	USHORT nAnz=rPoly.Count();
    113. 

  113. 	for (USHORT i=0; i<nAnz; i++) {
    114. 

  114. 		ResizePoly(rPoly[i],rRef,xFact,yFact);
    115. 

  115. 	}
    116. 

  116. }
    117. 

  117. 

  118. void ResizeXPoly(XPolyPolygon& rPoly, const Point& rRef, const Fraction& xFact, const Fraction& yFact)
    119. 

  119. {
    120. 

  120. 	USHORT nAnz=rPoly.Count();
    121. 

  121. 	for (USHORT i=0; i<nAnz; i++) {
    122. 

  122. 		ResizeXPoly(rPoly[i],rRef,xFact,yFact);
    123. 

  123. 	}
    124. 

  124. }
    125. 

  125. 

  126. ////////////////////////////////////////////////////////////////////////////////////////////////////
    127. 

  127. 

  128. void RotatePoly(Polygon& rPoly, const Point& rRef, double sn, double cs)
    129. 

  129. {
    130. 

  130. 	USHORT nAnz=rPoly.GetSize();
    131. 

  131. 	for (USHORT i=0; i<nAnz; i++) {
    132. 

  132. 		RotatePoint(rPoly[i],rRef,sn,cs);
    133. 

  133. 	}
    134. 

  134. }
    135. 

  135. 

  136. void RotateXPoly(XPolygon& rPoly, const Point& rRef, double sn, double cs)
    137. 

  137. {
    138. 

  138. 	USHORT nAnz=rPoly.GetPointCount();
    139. 

  139. 	for (USHORT i=0; i<nAnz; i++) {
    140. 

  140. 		RotatePoint(rPoly[i],rRef,sn,cs);
    141. 

  141. 	}
    142. 

  142. }
    143. 

  143. 

  144. void RotatePoly(PolyPolygon& rPoly, const Point& rRef, double sn, double cs)
    145. 

  145. {
    146. 

  146. 	USHORT nAnz=rPoly.Count();
    147. 

  147. 	for (USHORT i=0; i<nAnz; i++) {
    148. 

  148. 		RotatePoly(rPoly[i],rRef,sn,cs);
    149. 

  149. 	}
    150. 

  150. }
    151. 

  151. 

  152. void RotateXPoly(XPolyPolygon& rPoly, const Point& rRef, double sn, double cs)
    153. 

  153. {
    154. 

  154. 	USHORT nAnz=rPoly.Count();
    155. 

  155. 	for (USHORT i=0; i<nAnz; i++) {
    156. 

  156. 		RotateXPoly(rPoly[i],rRef,sn,cs);
    157. 

  157. 	}
    158. 

  158. }
    159. 

  159. 

  160. ////////////////////////////////////////////////////////////////////////////////////////////////////
    161. 

  161. 

  162. void MirrorRect(Rectangle& rRect, const Point& /*rRef1*/, const Point& /*rRef2*/, FASTBOOL bNoJustify)
    163. 

  163. {
    164. 

  164. 	// !!! fehlende Implementation !!!
    165. 

  165. 	if (!bNoJustify) rRect.Justify();
    166. 

  166. }
    167. 

  167. 

  168. void MirrorPoint(Point& rPnt, const Point& rRef1, const Point& rRef2)
    169. 

  169. {
    170. 

  170. 	long mx=rRef2.X()-rRef1.X();
    171. 

  171. 	long my=rRef2.Y()-rRef1.Y();
    172. 

  172. 	if (mx==0) { // Achse senkrecht
    173. 

  173. 		long dx=rRef1.X()-rPnt.X();
    174. 

  174. 		rPnt.X()+=2*dx;
    175. 

  175. 	} else if (my==0) { // Achse waagerecht
    176. 

  176. 		long dy=rRef1.Y()-rPnt.Y();
    177. 

  177. 		rPnt.Y()+=2*dy;
    178. 

  178. 	} else if (mx==my) { // Achse diagonal '\'
    179. 

  179. 		long dx1=rPnt.X()-rRef1.X();
    180. 

  180. 		long dy1=rPnt.Y()-rRef1.Y();
    181. 

  181. 		rPnt.X()=rRef1.X()+dy1;
    182. 

  182. 		rPnt.Y()=rRef1.Y()+dx1;
    183. 

  183. 	} else if (mx==-my) { // Achse diagonal '/'
    184. 

  184. 		long dx1=rPnt.X()-rRef1.X();
    185. 

  185. 		long dy1=rPnt.Y()-rRef1.Y();
    186. 

  186. 		rPnt.X()=rRef1.X()-dy1;
    187. 

  187. 		rPnt.Y()=rRef1.Y()-dx1;
    188. 

  188. 	} else { // beliebige Achse
    189. 

  189. 		// mal optimieren !!!
    190. 

  190. 		// Lot auf der Spiegelachse faellen oder so
    191. 

  191. 		long nRefWink=GetAngle(rRef2-rRef1);
    192. 

  192. 		rPnt-=rRef1;
    193. 

  193. 		long nPntWink=GetAngle(rPnt);
    194. 

  194. 		long nWink=2*(nRefWink-nPntWink);
    195. 

  195. 		double a=nWink*nPi180;
    196. 

  196. 		double nSin=sin(a);
    197. 

  197. 		double nCos=cos(a);
    198. 

  198. 		RotatePoint(rPnt,Point(),nSin,nCos);
    199. 

  199. 		rPnt+=rRef1;
    200. 

  200. 	}
    201. 

  201. }
    202. 

  202. 

  203. void MirrorPoly(Polygon& rPoly, const Point& rRef1, const Point& rRef2)
    204. 

  204. {
    205. 

  205. 	USHORT nAnz=rPoly.GetSize();
    206. 

  206. 	for (USHORT i=0; i<nAnz; i++) {
    207. 

  207. 		MirrorPoint(rPoly[i],rRef1,rRef2);
    208. 

  208. 	}
    209. 

  209. }
    210. 

  210. 

  211. void MirrorXPoly(XPolygon& rPoly, const Point& rRef1, const Point& rRef2)
    212. 

  212. {
    213. 

  213. 	USHORT nAnz=rPoly.GetPointCount();
    214. 

  214. 	for (USHORT i=0; i<nAnz; i++) {
    215. 

  215. 		MirrorPoint(rPoly[i],rRef1,rRef2);
    216. 

  216. 	}
    217. 

  217. }
    218. 

  218. 

  219. void MirrorPoly(PolyPolygon& rPoly, const Point& rRef1, const Point& rRef2)
    220. 

  220. {
    221. 

  221. 	USHORT nAnz=rPoly.Count();
    222. 

  222. 	for (USHORT i=0; i<nAnz; i++) {
    223. 

  223. 		MirrorPoly(rPoly[i],rRef1,rRef2);
    224. 

  224. 	}
    225. 

  225. }
    226. 

  226. 

  227. void MirrorXPoly(XPolyPolygon& rPoly, const Point& rRef1, const Point& rRef2)
    228. 

  228. {
    229. 

  229. 	USHORT nAnz=rPoly.Count();
    230. 

  230. 	for (USHORT i=0; i<nAnz; i++) {
    231. 

  231. 		MirrorXPoly(rPoly[i],rRef1,rRef2);
    232. 

  232. 	}
    233. 

  233. }
    234. 

  234. 

  235. ////////////////////////////////////////////////////////////////////////////////////////////////////
    236. 

  236. 

  237. void ShearPoly(Polygon& rPoly, const Point& rRef, double tn, FASTBOOL bVShear)
    238. 

  238. {
    239. 

  239. 	USHORT nAnz=rPoly.GetSize();
    240. 

  240. 	for (USHORT i=0; i<nAnz; i++) {
    241. 

  241. 		ShearPoint(rPoly[i],rRef,tn,bVShear);
    242. 

  242. 	}
    243. 

  243. }
    244. 

  244. 

  245. void ShearXPoly(XPolygon& rPoly, const Point& rRef, double tn, FASTBOOL bVShear)
    246. 

  246. {
    247. 

  247. 	USHORT nAnz=rPoly.GetPointCount();
    248. 

  248. 	for (USHORT i=0; i<nAnz; i++) {
    249. 

  249. 		ShearPoint(rPoly[i],rRef,tn,bVShear);
    250. 

  250. 	}
    251. 

  251. }
    252. 

  252. 

  253. void ShearPoly(PolyPolygon& rPoly, const Point& rRef, double tn, FASTBOOL bVShear)
    254. 

  254. {
    255. 

  255. 	USHORT nAnz=rPoly.Count();
    256. 

  256. 	for (USHORT i=0; i<nAnz; i++) {
    257. 

  257. 		ShearPoly(rPoly[i],rRef,tn,bVShear);
    258. 

  258. 	}
    259. 

  259. }
    260. 

  260. 

  261. void ShearXPoly(XPolyPolygon& rPoly, const Point& rRef, double tn, FASTBOOL bVShear)
    262. 

  262. {
    263. 

  263. 	USHORT nAnz=rPoly.Count();
    264. 

  264. 	for (USHORT i=0; i<nAnz; i++) {
    265. 

  265. 		ShearXPoly(rPoly[i],rRef,tn,bVShear);
    266. 

  266. 	}
    267. 

  267. }
    268. 

  268. 

  269. ////////////////////////////////////////////////////////////////////////////////////////////////////
    270. 

  270. //
    271. 

  271. //   @@@@  @@@@@   @@@@   @@@@  @@  @@
    272. 

  272. //  @@  @@ @@  @@ @@  @@ @@  @@ @@  @@
    273. 

  273. //  @@     @@  @@ @@  @@ @@  @@ @@ @@
    274. 

  274. //  @@     @@@@@  @@  @@ @@  @@ @@@@
    275. 

  275. //  @@     @@  @@ @@  @@ @@  @@ @@ @@
    276. 

  276. //  @@  @@ @@  @@ @@  @@ @@  @@ @@  @@
    277. 

  277. //   @@@@  @@  @@  @@@@   @@@@  @@  @@
    278. 

  278. //
    279. 

  279. ////////////////////////////////////////////////////////////////////////////////////////////////////
    280. 

  280. 

  281. double CrookRotateXPoint(Point& rPnt, Point* pC1, Point* pC2, const Point& rCenter,
    282. 

  282. 						 const Point& rRad, double& rSin, double& rCos, FASTBOOL bVert)
    283. 

  283. {
    284. 

  284. 	FASTBOOL bC1=pC1!=NULL;
    285. 

  285. 	FASTBOOL bC2=pC2!=NULL;
    286. 

  286. 	long x0=rPnt.X();
    287. 

  287. 	long y0=rPnt.Y();
    288. 

  288. 	long cx=rCenter.X();
    289. 

  289. 	long cy=rCenter.Y();
    290. 

  290. 	double nWink=GetCrookAngle(rPnt,rCenter,rRad,bVert);
    291. 

  291. 	double sn=sin(nWink);
    292. 

  292. 	double cs=cos(nWink);
    293. 

  293. 	RotatePoint(rPnt,rCenter,sn,cs);
    294. 

  294. 	if (bC1) {
    295. 

  295. 		if (bVert) {
    296. 

  296. 			// Richtung Zentrum verschieben, als Ausgangsposition fuer Rotate
    297. 

  297. 			pC1->Y()-=y0;
    298. 

  298. 			// Resize, entsprechend der Entfernung vom Zentrum
    299. 

  299. 			pC1->Y()=Round(((double)pC1->Y()) /rRad.X()*(cx-pC1->X()));
    300. 

  300. 			pC1->Y()+=cy;
    301. 

  301. 		} else {
    302. 

  302. 			// Richtung Zentrum verschieben, als Ausgangsposition fuer Rotate
    303. 

  303. 			pC1->X()-=x0;
    304. 

  304. 			// Resize, entsprechend der Entfernung vom Zentrum
    305. 

  305. 			long nPntRad=cy-pC1->Y();
    306. 

  306. 			double nFact=(double)nPntRad/(double)rRad.Y();
    307. 

  307. 			pC1->X()=Round((double)pC1->X()*nFact);
    308. 

  308. 			pC1->X()+=cx;
    309. 

  309. 		}
    310. 

  310. 		RotatePoint(*pC1,rCenter,sn,cs);
    311. 

  311. 	}
    312. 

  312. 	if (bC2) {
    313. 

  313. 		if (bVert) {
    314. 

  314. 			// Richtung Zentrum verschieben, als Ausgangsposition fuer Rotate
    315. 

  315. 			pC2->Y()-=y0;
    316. 

  316. 			// Resize, entsprechend der Entfernung vom Zentrum
    317. 

  317. 			pC2->Y()=Round(((double)pC2->Y()) /rRad.X()*(rCenter.X()-pC2->X()));
    318. 

  318. 			pC2->Y()+=cy;
    319. 

  319. 		} else {
    320. 

  320. 			// Richtung Zentrum verschieben, als Ausgangsposition fuer Rotate
    321. 

  321. 			pC2->X()-=x0;
    322. 

  322. 			// Resize, entsprechend der Entfernung vom Zentrum
    323. 

  323. 			long nPntRad=rCenter.Y()-pC2->Y();
    324. 

  324. 			double nFact=(double)nPntRad/(double)rRad.Y();
    325. 

  325. 			pC2->X()=Round((double)pC2->X()*nFact);
    326. 

  326. 			pC2->X()+=cx;
    327. 

  327. 		}
    328. 

  328. 		RotatePoint(*pC2,rCenter,sn,cs);
    329. 

  329. 	}
    330. 

  330. 	rSin=sn;
    331. 

  331. 	rCos=cs;
    332. 

  332. 	return nWink;
    333. 

  333. }
    334. 

  334. 

  335. double CrookSlantXPoint(Point& rPnt, Point* pC1, Point* pC2, const Point& rCenter,
    336. 

  336. 						const Point& rRad, double& rSin, double& rCos, FASTBOOL bVert)
    337. 

  337. {
    338. 

  338. 	FASTBOOL bC1=pC1!=NULL;
    339. 

  339. 	FASTBOOL bC2=pC2!=NULL;
    340. 

  340. 	long x0=rPnt.X();
    341. 

  341. 	long y0=rPnt.Y();
    342. 

  342. 	long dx1=0,dy1=0;
    343. 

  343. 	long dxC1=0,dyC1=0;
    344. 

  344. 	long dxC2=0,dyC2=0;
    345. 

  345. 	if (bVert) {
    346. 

  346. 		long nStart=rCenter.X()-rRad.X();
    347. 

  347. 		dx1=rPnt.X()-nStart;
    348. 

  348. 		rPnt.X()=nStart;
    349. 

  349. 		if (bC1) {
    350. 

  350. 			dxC1=pC1->X()-nStart;
    351. 

  351. 			pC1->X()=nStart;
    352. 

  352. 		}
    353. 

  353. 		if (bC2) {
    354. 

  354. 			dxC2=pC2->X()-nStart;
    355. 

  355. 			pC2->X()=nStart;
    356. 

  356. 		}
    357. 

  357. 	} else {
    358. 

  358. 		long nStart=rCenter.Y()-rRad.Y();
    359. 

  359. 		dy1=rPnt.Y()-nStart;
    360. 

  360. 		rPnt.Y()=nStart;
    361. 

  361. 		if (bC1) {
    362. 

  362. 			dyC1=pC1->Y()-nStart;
    363. 

  363. 			pC1->Y()=nStart;
    364. 

  364. 		}
    365. 

  365. 		if (bC2) {
    366. 

  366. 			dyC2=pC2->Y()-nStart;
    367. 

  367. 			pC2->Y()=nStart;
    368. 

  368. 		}
    369. 

  369. 	}
    370. 

  370. 	double nWink=GetCrookAngle(rPnt,rCenter,rRad,bVert);
    371. 

  371. 	double sn=sin(nWink);
    372. 

  372. 	double cs=cos(nWink);
    373. 

  373. 	RotatePoint(rPnt,rCenter,sn,cs);
    374. 

  374. 	if (bC1) { if (bVert) pC1->Y()-=y0-rCenter.Y(); else pC1->X()-=x0-rCenter.X(); RotatePoint(*pC1,rCenter,sn,cs); }
    375. 

  375. 	if (bC2) { if (bVert) pC2->Y()-=y0-rCenter.Y(); else pC2->X()-=x0-rCenter.X(); RotatePoint(*pC2,rCenter,sn,cs); }
    376. 

  376. 	if (bVert) {
    377. 

  377. 		rPnt.X()+=dx1;
    378. 

  378. 		if (bC1) pC1->X()+=dxC1;
    379. 

  379. 		if (bC2) pC2->X()+=dxC2;
    380. 

  380. 	} else {
    381. 

  381. 		rPnt.Y()+=dy1;
    382. 

  382. 		if (bC1) pC1->Y()+=dyC1;
    383. 

  383. 		if (bC2) pC2->Y()+=dyC2;
    384. 

  384. 	}
    385. 

  385. 	rSin=sn;
    386. 

  386. 	rCos=cs;
    387. 

  387. 	return nWink;
    388. 

  388. }
    389. 

  389. 

  390. double CrookStretchXPoint(Point& rPnt, Point* pC1, Point* pC2, const Point& rCenter,
    391. 

  391. 						  const Point& rRad, double& rSin, double& rCos, FASTBOOL bVert,
    392. 

  392. 						  const Rectangle rRefRect)
    393. 

  393. {
    394. 

  394. 	//FASTBOOL bC1=pC1!=NULL;
    395. 

  395. 	//FASTBOOL bC2=pC2!=NULL;
    396. 

  396. 	//long x0=rPnt.X();
    397. 

  397. 	long y0=rPnt.Y();
    398. 

  398. 	CrookSlantXPoint(rPnt,pC1,pC2,rCenter,rRad,rSin,rCos,bVert);
    399. 

  399. 	if (bVert) {
    400. 

  400. 	} else {
    401. 

  401. 		//long nBase=rCenter.Y()-rRad.Y();
    402. 

  402. 		long nTop=rRefRect.Top();
    403. 

  403. 		long nBtm=rRefRect.Bottom();
    404. 

  404. 		long nHgt=nBtm-nTop;
    405. 

  405. 		long dy=rPnt.Y()-y0;
    406. 

  406. 		//FASTBOOL bOben=rRad.Y()<0;
    407. 

  407. 		double a=((double)(y0-nTop))/nHgt;
    408. 

  408. 		a*=dy;
    409. 

  409. 		rPnt.Y()=y0+Round(a);
    410. 

  410. 	} return 0.0;
    411. 

  411. }
    412. 

  412. 

  413. ////////////////////////////////////////////////////////////////////////////////////////////////////
    414. 

  414. 

  415. void CrookRotatePoly(XPolygon& rPoly, const Point& rCenter, const Point& rRad, FASTBOOL bVert)
    416. 

  416. {
    417. 

  417. 	double nSin,nCos;
    418. 

  418. 	USHORT nPointAnz=rPoly.GetPointCount();
    419. 

  419. 	USHORT i=0;
    420. 

  420. 	while (i<nPointAnz) {
    421. 

  421. 		Point* pPnt=&rPoly[i];
    422. 

  422. 		Point* pC1=NULL;
    423. 

  423. 		Point* pC2=NULL;
    424. 

  424. 		if (i+1<nPointAnz && rPoly.IsControl(i)) { // Kontrollpunkt links
    425. 

  425. 			pC1=pPnt;
    426. 

  426. 			i++;
    427. 

  427. 			pPnt=&rPoly[i];
    428. 

  428. 		}
    429. 

  429. 		i++;
    430. 

  430. 		if (i<nPointAnz && rPoly.IsControl(i)) { // Kontrollpunkt rechts
    431. 

  431. 			pC2=&rPoly[i];
    432. 

  432. 			i++;
    433. 

  433. 		}
    434. 

  434. 		CrookRotateXPoint(*pPnt,pC1,pC2,rCenter,rRad,nSin,nCos,bVert);
    435. 

  435. 	}
    436. 

  436. }
    437. 

  437. 

  438. void CrookSlantPoly(XPolygon& rPoly, const Point& rCenter, const Point& rRad, FASTBOOL bVert)
    439. 

  439. {
    440. 

  440. 	double nSin,nCos;
    441. 

  441. 	USHORT nPointAnz=rPoly.GetPointCount();
    442. 

  442. 	USHORT i=0;
    443. 

  443. 	while (i<nPointAnz) {
    444. 

  444. 		Point* pPnt=&rPoly[i];
    445. 

  445. 		Point* pC1=NULL;
    446. 

  446. 		Point* pC2=NULL;
    447. 

  447. 		if (i+1<nPointAnz && rPoly.IsControl(i)) { // Kontrollpunkt links
    448. 

  448. 			pC1=pPnt;
    449. 

  449. 			i++;
    450. 

  450. 			pPnt=&rPoly[i];
    451. 

  451. 		}
    452. 

  452. 		i++;
    453. 

  453. 		if (i<nPointAnz && rPoly.IsControl(i)) { // Kontrollpunkt rechts
    454. 

  454. 			pC2=&rPoly[i];
    455. 

  455. 			i++;
    456. 

  456. 		}
    457. 

  457. 		CrookSlantXPoint(*pPnt,pC1,pC2,rCenter,rRad,nSin,nCos,bVert);
    458. 

  458. 	}
    459. 

  459. }
    460. 

  460. 

  461. void CrookStretchPoly(XPolygon& rPoly, const Point& rCenter, const Point& rRad, FASTBOOL bVert, const Rectangle rRefRect)
    462. 

  462. {
    463. 

  463. 	double nSin,nCos;
    464. 

  464. 	USHORT nPointAnz=rPoly.GetPointCount();
    465. 

  465. 	USHORT i=0;
    466. 

  466. 	while (i<nPointAnz) {
    467. 

  467. 		Point* pPnt=&rPoly[i];
    468. 

  468. 		Point* pC1=NULL;
    469. 

  469. 		Point* pC2=NULL;
    470. 

  470. 		if (i+1<nPointAnz && rPoly.IsControl(i)) { // Kontrollpunkt links
    471. 

  471. 			pC1=pPnt;
    472. 

  472. 			i++;
    473. 

  473. 			pPnt=&rPoly[i];
    474. 

  474. 		}
    475. 

  475. 		i++;
    476. 

  476. 		if (i<nPointAnz && rPoly.IsControl(i)) { // Kontrollpunkt rechts
    477. 

  477. 			pC2=&rPoly[i];
    478. 

  478. 			i++;
    479. 

  479. 		}
    480. 

  480. 		CrookStretchXPoint(*pPnt,pC1,pC2,rCenter,rRad,nSin,nCos,bVert,rRefRect);
    481. 

  481. 	}
    482. 

  482. }
    483. 

  483. 

  484. ////////////////////////////////////////////////////////////////////////////////////////////////////
    485. 

  485. 

  486. void CrookRotatePoly(XPolyPolygon& rPoly, const Point& rCenter, const Point& rRad, FASTBOOL bVert)
    487. 

  487. {
    488. 

  488. 	USHORT nPolyAnz=rPoly.Count();
    489. 

  489. 	for (USHORT nPolyNum=0; nPolyNum<nPolyAnz; nPolyNum++) {
    490. 

  490. 		CrookRotatePoly(rPoly[nPolyNum],rCenter,rRad,bVert);
    491. 

  491. 	}
    492. 

  492. }
    493. 

  493. 

  494. void CrookSlantPoly(XPolyPolygon& rPoly, const Point& rCenter, const Point& rRad, FASTBOOL bVert)
    495. 

  495. {
    496. 

  496. 	USHORT nPolyAnz=rPoly.Count();
    497. 

  497. 	for (USHORT nPolyNum=0; nPolyNum<nPolyAnz; nPolyNum++) {
    498. 

  498. 		CrookSlantPoly(rPoly[nPolyNum],rCenter,rRad,bVert);
    499. 

  499. 	}
    500. 

  500. }
    501. 

  501. 

  502. void CrookStretchPoly(XPolyPolygon& rPoly, const Point& rCenter, const Point& rRad, FASTBOOL bVert, const Rectangle rRefRect)
    503. 

  503. {
    504. 

  504. 	USHORT nPolyAnz=rPoly.Count();
    505. 

  505. 	for (USHORT nPolyNum=0; nPolyNum<nPolyAnz; nPolyNum++) {
    506. 

  506. 		CrookStretchPoly(rPoly[nPolyNum],rCenter,rRad,bVert,rRefRect);
    507. 

  507. 	}
    508. 

  508. }
    509. 

  509. 

  510. ////////////////////////////////////////////////////////////////////////////////////////////////////
    511. 

  511. 

  512. long GetAngle(const Point& rPnt)
    513. 

  513. {
    514. 

  514. 	long a=0;
    515. 

  515. 	if (rPnt.Y()==0) {
    516. 

  516. 		if (rPnt.X()<0) a=-18000;
    517. 

  517. 	} else if (rPnt.X()==0) {
    518. 

  518. 		if (rPnt.Y()>0) a=-9000;
    519. 

  519. 		else a=9000;
    520. 

  520. 	} else {
    521. 

  521. 		a=Round((atan2((double)-rPnt.Y(),(double)rPnt.X())/nPi180));
    522. 

  522. 	}
    523. 

  523. 	return a;
    524. 

  524. }
    525. 

  525. 

  526. long NormAngle180(long a)
    527. 

  527. {
    528. 

  528. 	while (a<18000) a+=36000;
    529. 

  529. 	while (a>=18000) a-=36000;
    530. 

  530. 	return a;
    531. 

  531. }
    532. 

  532. 

  533. long NormAngle360(long a)
    534. 

  534. {
    535. 

  535. 	while (a<0) a+=36000;
    536. 

  536. 	while (a>=36000) a-=36000;
    537. 

  537. 	return a;
    538. 

  538. }
    539. 

  539. 

  540. USHORT GetAngleSector(long nWink)
    541. 

  541. {
    542. 

  542. 	while (nWink<0) nWink+=36000;
    543. 

  543. 	while (nWink>=36000) nWink-=36000;
    544. 

  544. 	if (nWink< 9000) return 0;
    545. 

  545. 	if (nWink<18000) return 1;
    546. 

  546. 	if (nWink<27000) return 2;
    547. 

  547. 	return 3;
    548. 

  548. }
    549. 

  549. 

  550. long GetLen(const Point& rPnt)
    551. 

  551. {
    552. 

  552. 	long x=Abs(rPnt.X());
    553. 

  553. 	long y=Abs(rPnt.Y());
    554. 

  554. 	if (x+y<0x8000) { // weil 7FFF * 7FFF * 2 = 7FFE0002
    555. 

  555. 		x*=x;
    556. 

  556. 		y*=y;
    557. 

  557. 		x+=y;
    558. 

  558. 		x=Round(sqrt((double)x));
    559. 

  559. 		return x;
    560. 

  560. 	} else {
    561. 

  561. 		double nx=x;
    562. 

  562. 		double ny=y;
    563. 

  563. 		nx*=nx;
    564. 

  564. 		ny*=ny;
    565. 

  565. 		nx+=ny;
    566. 

  566. 		nx=sqrt(nx);
    567. 

  567. 		if (nx>0x7FFFFFFF) {
    568. 

  568. 			return 0x7FFFFFFF; // Ueberlauf, mehr is nich!
    569. 

  569. 		} else {
    570. 

  570. 			return Round(nx);
    571. 

  571. 		}
    572. 

  572. 	}
    573. 

  573. }
    574. 

  574. 

  575. ////////////////////////////////////////////////////////////////////////////////////////////////////
    576. 

  576. 

  577. void GeoStat::RecalcSinCos()
    578. 

  578. {
    579. 

  579. 	if (nDrehWink==0) {
    580. 

  580. 		nSin=0.0;
    581. 

  581. 		nCos=1.0;
    582. 

  582. 	} else {
    583. 

  583. 		double a=nDrehWink*nPi180;
    584. 

  584. 		nSin=sin(a);
    585. 

  585. 		nCos=cos(a);
    586. 

  586. 	}
    587. 

  587. }
    588. 

  588. 

  589. void GeoStat::RecalcTan()
    590. 

  590. {
    591. 

  591. 	if (nShearWink==0) {
    592. 

  592. 		nTan=0.0;
    593. 

  593. 	} else {
    594. 

  594. 		double a=nShearWink*nPi180;
    595. 

  595. 		nTan=tan(a);
    596. 

  596. 	}
    597. 

  597. }
    598. 

  598. 

  599. ////////////////////////////////////////////////////////////////////////////////////////////////////
    600. 

  600. 

  601. Polygon Rect2Poly(const Rectangle& rRect, const GeoStat& rGeo)
    602. 

  602. {
    603. 

  603. 	Polygon aPol(5);
    604. 

  604. 	aPol[0]=rRect.TopLeft();
    605. 

  605. 	aPol[1]=rRect.TopRight();
    606. 

  606. 	aPol[2]=rRect.BottomRight();
    607. 

  607. 	aPol[3]=rRect.BottomLeft();
    608. 

  608. 	aPol[4]=rRect.TopLeft();
    609. 

  609. 	if (rGeo.nShearWink!=0) ShearPoly(aPol,rRect.TopLeft(),rGeo.nTan);
    610. 

  610. 	if (rGeo.nDrehWink!=0) RotatePoly(aPol,rRect.TopLeft(),rGeo.nSin,rGeo.nCos);
    611. 

  611. 	return aPol;
    612. 

  612. }
    613. 

  613. 

  614. void Poly2Rect(const Polygon& rPol, Rectangle& rRect, GeoStat& rGeo)
    615. 

  615. {
    616. 

  616. 	rGeo.nDrehWink=GetAngle(rPol[1]-rPol[0]);
    617. 

  617. 	rGeo.nDrehWink=NormAngle360(rGeo.nDrehWink);
    618. 

  618. 	// Drehung ist damit im Kasten
    619. 

  619. 	rGeo.RecalcSinCos();
    620. 

  620. 

  621. 	Point aPt1(rPol[1]-rPol[0]);
    622. 

  622. 	if (rGeo.nDrehWink!=0) RotatePoint(aPt1,Point(0,0),-rGeo.nSin,rGeo.nCos); // -Sin fuer Rueckdrehung
    623. 

  623. 	long nWdt=aPt1.X();
    624. 

  624. 

  625. 	Point aPt0(rPol[0]);
    626. 

  626. 	Point aPt3(rPol[3]-rPol[0]);
    627. 

  627. 	if (rGeo.nDrehWink!=0) RotatePoint(aPt3,Point(0,0),-rGeo.nSin,rGeo.nCos); // -Sin fuer Rueckdrehung
    628. 

  628. 	long nHgt=aPt3.Y();
    629. 

  629. 

  630. 	if(aPt3.X())
    631. 

  631. 	{
    632. 

  632. 		// #i74358# the axes are not orthogonal, so for getting the correct height, 
    633. 

  633. 		// calculate the length of aPt3
    634. 

  634. 

  635. 		// #i74358# this change was wrong, in the field of the old geometry stuff
    636. 

  636. 		// it is not an error. The new height always is the same as before; shear
    637. 

  637. 		// does not change object height at all. This is different from the interactions,
    638. 

  638. 		// but obviously wanted in the old versions.
    639. 

  639. 		//
    640. 

  640. 		// nHgt = static_cast< long >(sqrt(static_cast< double >(aPt3.X() * aPt3.X() + aPt3.Y() * aPt3.Y())));
    641. 

  641. 	}
    642. 

  642. 

  643.     long nShW=GetAngle(aPt3);
    644. 

  644. 	nShW-=27000; // ShearWink wird zur Senkrechten gemessen
    645. 

  645. 	nShW=-nShW;  // Negieren, denn '+' ist Rechtskursivierung
    646. 

  646. 

  647. 	FASTBOOL bMirr=aPt3.Y()<0;
    648. 

  648. 	if (bMirr) { // "Punktetausch" bei Spiegelung
    649. 

  649. 		nHgt=-nHgt;
    650. 

  650. 		nShW+=18000;
    651. 

  651. 		aPt0=rPol[3];
    652. 

  652. 	}
    653. 

  653. 	nShW=NormAngle180(nShW);
    654. 

  654. 	if (nShW<-9000 || nShW>9000) {
    655. 

  655. 		nShW=NormAngle180(nShW+18000);
    656. 

  656. 	}
    657. 

  657. 	if (nShW<-SDRMAXSHEAR) nShW=-SDRMAXSHEAR; // ShearWinkel begrenzen auf +/- 89.00 deg
    658. 

  658. 	if (nShW>SDRMAXSHEAR)  nShW=SDRMAXSHEAR;
    659. 

  659. 	rGeo.nShearWink=nShW;
    660. 

  660. 	rGeo.RecalcTan();
    661. 

  661. 	Point aRU(aPt0);
    662. 

  662. 	aRU.X()+=nWdt;
    663. 

  663. 	aRU.Y()+=nHgt;
    664. 

  664. 	rRect=Rectangle(aPt0,aRU);
    665. 

  665. }
    666. 

  666. 

  667. ////////////////////////////////////////////////////////////////////////////////////////////////////
    668. 

  668. 

  669. void OrthoDistance8(const Point& rPt0, Point& rPt, FASTBOOL bBigOrtho)
    670. 

  670. {
    671. 

  671. 	long dx=rPt.X()-rPt0.X();
    672. 

  672. 	long dy=rPt.Y()-rPt0.Y();
    673. 

  673. 	long dxa=Abs(dx);
    674. 

  674. 	long dya=Abs(dy);
    675. 

  675. 	if (dx==0 || dy==0 || dxa==dya) return;
    676. 

  676. 	if (dxa>=dya*2) { rPt.Y()=rPt0.Y(); return; }
    677. 

  677. 	if (dya>=dxa*2) { rPt.X()=rPt0.X(); return; }
    678. 

  678. 	if ((dxa<dya) != bBigOrtho) {
    679. 

  679. 		rPt.Y()=rPt0.Y()+(dxa* (dy>=0 ? 1 : -1) );
    680. 

  680. 	} else {
    681. 

  681. 		rPt.X()=rPt0.X()+(dya* (dx>=0 ? 1 : -1) );
    682. 

  682. 	}
    683. 

  683. }
    684. 

  684. 

  685. void OrthoDistance4(const Point& rPt0, Point& rPt, FASTBOOL bBigOrtho)
    686. 

  686. {
    687. 

  687. 	long dx=rPt.X()-rPt0.X();
    688. 

  688. 	long dy=rPt.Y()-rPt0.Y();
    689. 

  689. 	long dxa=Abs(dx);
    690. 

  690. 	long dya=Abs(dy);
    691. 

  691. 	if ((dxa<dya) != bBigOrtho) {
    692. 

  692. 		rPt.Y()=rPt0.Y()+(dxa* (dy>=0 ? 1 : -1) );
    693. 

  693. 	} else {
    694. 

  694. 		rPt.X()=rPt0.X()+(dya* (dx>=0 ? 1 : -1) );
    695. 

  695. 	}
    696. 

  696. }
    697. 

  697. 

  698. ////////////////////////////////////////////////////////////////////////////////////////////////////
    699. 

  699. 

  700. long BigMulDiv(long nVal, long nMul, long nDiv)
    701. 

  701. {
    702. 

  702. 	BigInt aVal(nVal);
    703. 

  703. 	aVal*=nMul;
    704. 

  704. 	if (aVal.IsNeg()!=(nDiv<0)) {
    705. 

  705. 		aVal-=nDiv/2; // fuer korrektes Runden
    706. 

  706. 	} else {
    707. 

  707. 		aVal+=nDiv/2; // fuer korrektes Runden
    708. 

  708. 	}
    709. 

  709. 	if(nDiv)
    710. 

  710. 	{
    711. 

  711. 		aVal/=nDiv;
    712. 

  712. 		return long(aVal);
    713. 

  713. 	}
    714. 

  714. 	return 0x7fffffff;
    715. 

  715. }
    716. 

  716. 

  717. void Kuerzen(Fraction& rF, unsigned nDigits)
    718. 

  718. {
    719. 

  719. 	INT32 nMul=rF.GetNumerator();
    720. 

  720. 	INT32 nDiv=rF.GetDenominator();
    721. 

  721. 	FASTBOOL bNeg=FALSE;
    722. 

  722. 	if (nMul<0) { nMul=-nMul; bNeg=!bNeg; }
    723. 

  723. 	if (nDiv<0) { nDiv=-nDiv; bNeg=!bNeg; }
    724. 

  724. 	if (nMul==0 || nDiv==0) return;
    725. 

  725. 	UINT32 a;
    726. 

  726. 	a=UINT32(nMul); unsigned nMulZ=0; // Fuehrende Nullen zaehlen
    727. 

  727. 	while (a<0x00800000) { nMulZ+=8; a<<=8; }
    728. 

  728. 	while (a<0x80000000) { nMulZ++; a<<=1; }
    729. 

  729. 	a=UINT32(nDiv); unsigned nDivZ=0; // Fuehrende Nullen zaehlen
    730. 

  730. 	while (a<0x00800000) { nDivZ+=8; a<<=8; }
    731. 

  731. 	while (a<0x80000000) { nDivZ++; a<<=1; }
    732. 

  732. 	// Anzahl der verwendeten Digits bestimmen
    733. 

  733. 	int nMulDigits=32-nMulZ;
    734. 

  734. 	int nDivDigits=32-nDivZ;
    735. 

  735. 	// Nun bestimmen, wieviele Stellen hinten weg koennen
    736. 

  736. 	int nMulWeg=nMulDigits-nDigits; if (nMulWeg<0) nMulWeg=0;
    737. 

  737. 	int nDivWeg=nDivDigits-nDigits; if (nDivWeg<0) nDivWeg=0;
    738. 

  738. 	int nWeg=Min(nMulWeg,nDivWeg);
    739. 

  739. 	nMul>>=nWeg;
    740. 

  740. 	nDiv>>=nWeg;
    741. 

  741. 	if (nMul==0 || nDiv==0) {
    742. 

  742. 		DBG_WARNING("Oups, beim kuerzen einer Fraction hat sich Joe verrechnet.");
    743. 

  743. 		return;
    744. 

  744. 	}
    745. 

  745. 	if (bNeg) nMul=-nMul;
    746. 

  746. 	rF=Fraction(nMul,nDiv);
    747. 

  747. }
    748. 

  748. 

  749. ////////////////////////////////////////////////////////////////////////////////////////////////////
    750. 

  750. // Wieviele eU-Einheiten passen in einen mm bzw. Inch?
    751. 

  751. // Oder wie gross ist ein eU in mm bzw. Inch, und davon der Kehrwert
    752. 

  752. 

  753. FrPair GetInchOrMM(MapUnit eU)
    754. 

  754. {
    755. 

  755. 	switch (eU) {
    756. 

  756. 		case MAP_1000TH_INCH: return FrPair(1000,1);
    757. 

  757. 		case MAP_100TH_INCH : return FrPair( 100,1);
    758. 

  758. 		case MAP_10TH_INCH  : return FrPair(  10,1);
    759. 

  759. 		case MAP_INCH       : return FrPair(   1,1);
    760. 

  760. 		case MAP_POINT      : return FrPair(  72,1);
    761. 

  761. 		case MAP_TWIP       : return FrPair(1440,1);
    762. 

  762. 		case MAP_100TH_MM   : return FrPair( 100,1);
    763. 

  763. 		case MAP_10TH_MM    : return FrPair(  10,1);
    764. 

  764. 		case MAP_MM         : return FrPair(   1,1);
    765. 

  765. 		case MAP_CM         : return FrPair(   1,10);
    766. 

  766. 		case MAP_PIXEL      : {
    767. 

  767. 			VirtualDevice aVD;
    768. 

  768. 			aVD.SetMapMode(MapMode(MAP_100TH_MM));
    769. 

  769. 			Point aP(aVD.PixelToLogic(Point(64,64))); // 64 Pixel fuer bessere Genauigkeit
    770. 

  770. 			return FrPair(6400,aP.X(),6400,aP.Y());
    771. 

  771. 		}
    772. 

  772. 		case MAP_APPFONT: case MAP_SYSFONT: {
    773. 

  773. 			VirtualDevice aVD;
    774. 

  774. 			aVD.SetMapMode(MapMode(eU));
    775. 

  775. 			Point aP(aVD.LogicToPixel(Point(32,32))); // 32 Einheiten fuer bessere Genauigkeit
    776. 

  776. 			aVD.SetMapMode(MapMode(MAP_100TH_MM));
    777. 

  777. 			aP=aVD.PixelToLogic(aP);
    778. 

  778. 			return FrPair(3200,aP.X(),3200,aP.Y());
    779. 

  779. 		}
    780. 

  780. 		default: break;
    781. 

  781. 	}
    782. 

  782. 	return Fraction(1,1);
    783. 

  783. }
    784. 

  784. 

  785. FrPair GetInchOrMM(FieldUnit eU)
    786. 

  786. {
    787. 

  787. 	switch (eU) {
    788. 

  788. 		case FUNIT_INCH       : return FrPair(   1,1);
    789. 

  789. 		case FUNIT_POINT      : return FrPair(  72,1);
    790. 

  790. 		case FUNIT_TWIP       : return FrPair(1440,1);
    791. 

  791. 		case FUNIT_100TH_MM   : return FrPair( 100,1);
    792. 

  792. 		case FUNIT_MM         : return FrPair(   1,1);
    793. 

  793. 		case FUNIT_CM         : return FrPair(   1,10);
    794. 

  794. 		case FUNIT_M          : return FrPair(   1,1000);
    795. 

  795. 		case FUNIT_KM         : return FrPair(   1,1000000);
    796. 

  796. 		case FUNIT_PICA       : return FrPair(   6,1);
    797. 

  797. 		case FUNIT_FOOT       : return FrPair(   1,12);
    798. 

  798. 		case FUNIT_MILE       : return FrPair(   1,63360);
    799. 

  799. 		default: break;
    800. 

  800. 	}
    801. 

  801. 	return Fraction(1,1);
    802. 

  802. }
    803. 

  803. 

  804. // Den Faktor berechnen, der anzuwenden ist um n Einheiten von eS nach
    805. 

  805. // eD umzurechnen. Z.B. GetMapFactor(UNIT_MM,UNIT_100TH_MM) => 100.
    806. 

  806. 

  807. FrPair GetMapFactor(MapUnit eS, MapUnit eD)
    808. 

  808. {
    809. 

  809. 	if (eS==eD) return FrPair(1,1,1,1);
    810. 

  810. 	FrPair aS(GetInchOrMM(eS));
    811. 

  811. 	FrPair aD(GetInchOrMM(eD));
    812. 

  812. 	FASTBOOL bSInch=IsInch(eS);
    813. 

  813. 	FASTBOOL bDInch=IsInch(eD);
    814. 

  814. 	FrPair aRet(aD.X()/aS.X(),aD.Y()/aS.Y());
    815. 

  815. 	if (bSInch && !bDInch) { aRet.X()*=Fraction(127,5); aRet.Y()*=Fraction(127,5); }
    816. 

  816. 	if (!bSInch && bDInch) { aRet.X()*=Fraction(5,127); aRet.Y()*=Fraction(5,127); }
    817. 

  817. 	return aRet;
    818. 

  818. };
    819. 

  819. 

  820. FrPair GetMapFactor(MapUnit eS, FieldUnit eD)
    821. 

  821. {
    822. 

  822. 	FrPair aS(GetInchOrMM(eS));
    823. 

  823. 	FrPair aD(GetInchOrMM(eD));
    824. 

  824. 	FASTBOOL bSInch=IsInch(eS);
    825. 

  825. 	FASTBOOL bDInch=IsInch(eD);
    826. 

  826. 	FrPair aRet(aD.X()/aS.X(),aD.Y()/aS.Y());
    827. 

  827. 	if (bSInch && !bDInch) { aRet.X()*=Fraction(127,5); aRet.Y()*=Fraction(127,5); }
    828. 

  828. 	if (!bSInch && bDInch) { aRet.X()*=Fraction(5,127); aRet.Y()*=Fraction(5,127); }
    829. 

  829. 	return aRet;
    830. 

  830. };
    831. 

  831. 

  832. FrPair GetMapFactor(FieldUnit eS, MapUnit eD)
    833. 

  833. {
    834. 

  834. 	FrPair aS(GetInchOrMM(eS));
    835. 

  835. 	FrPair aD(GetInchOrMM(eD));
    836. 

  836. 	FASTBOOL bSInch=IsInch(eS);
    837. 

  837. 	FASTBOOL bDInch=IsInch(eD);
    838. 

  838. 	FrPair aRet(aD.X()/aS.X(),aD.Y()/aS.Y());
    839. 

  839. 	if (bSInch && !bDInch) { aRet.X()*=Fraction(127,5); aRet.Y()*=Fraction(127,5); }
    840. 

  840. 	if (!bSInch && bDInch) { aRet.X()*=Fraction(5,127); aRet.Y()*=Fraction(5,127); }
    841. 

  841. 	return aRet;
    842. 

  842. };
    843. 

  843. 

  844. FrPair GetMapFactor(FieldUnit eS, FieldUnit eD)
    845. 

  845. {
    846. 

  846. 	if (eS==eD) return FrPair(1,1,1,1);
    847. 

  847. 	FrPair aS(GetInchOrMM(eS));
    848. 

  848. 	FrPair aD(GetInchOrMM(eD));
    849. 

  849. 	FASTBOOL bSInch=IsInch(eS);
    850. 

  850. 	FASTBOOL bDInch=IsInch(eD);
    851. 

  851. 	FrPair aRet(aD.X()/aS.X(),aD.Y()/aS.Y());
    852. 

  852. 	if (bSInch && !bDInch) { aRet.X()*=Fraction(127,5); aRet.Y()*=Fraction(127,5); }
    853. 

  853. 	if (!bSInch && bDInch) { aRet.X()*=Fraction(5,127); aRet.Y()*=Fraction(5,127); }
    854. 

  854. 	return aRet;
    855. 

  855. };
    856. 

  856. 

  857. ////////////////////////////////////////////////////////////////////////////////////////////////////
    858. 

  858. 

  859. 	// 1 mile    =  8 furlong = 63.360" = 1.609.344,0mm
    860. 

  860. 	// 1 furlong = 10 chains  =  7.920" =   201.168,0mm
    861. 

  861. 	// 1 chain   =  4 poles   =    792" =    20.116,8mm
    862. 

  862. 	// 1 pole    =  5 1/2 yd  =    198" =     5.029,2mm
    863. 

  863. 	// 1 yd      =  3 ft      =     36" =       914,4mm
    864. 

  864. 	// 1 ft      = 12 "       =      1" =       304,8mm
    865. 

  865. 

  866. void GetMeterOrInch(MapUnit eMU, short& rnKomma, long& rnMul, long& rnDiv, FASTBOOL& rbMetr, FASTBOOL& rbInch)
    867. 

  867. {
    868. 

  868. 	rnMul=1; rnDiv=1;
    869. 

  869. 	short nKomma=0;
    870. 

  870. 	FASTBOOL bMetr=FALSE,bInch=FALSE;
    871. 

  871. 	switch (eMU) {
    872. 

  872. 		// Metrisch
    873. 

  873. 		case MAP_100TH_MM   : bMetr=TRUE; nKomma=5; break;
    874. 

  874. 		case MAP_10TH_MM    : bMetr=TRUE; nKomma=4; break;
    875. 

  875. 		case MAP_MM         : bMetr=TRUE; nKomma=3; break;
    876. 

  876. 		case MAP_CM         : bMetr=TRUE; nKomma=2; break;
    877. 

  877. 		// Inch
    878. 

  878. 		case MAP_1000TH_INCH: bInch=TRUE; nKomma=3; break;
    879. 

  879. 		case MAP_100TH_INCH : bInch=TRUE; nKomma=2; break;
    880. 

  880. 		case MAP_10TH_INCH  : bInch=TRUE; nKomma=1; break;
    881. 

  881. 		case MAP_INCH       : bInch=TRUE; nKomma=0; break;
    882. 

  882. 		case MAP_POINT      : bInch=TRUE; rnDiv=72;  break;          // 1Pt   = 1/72"
    883. 

  883. 		case MAP_TWIP       : bInch=TRUE; rnDiv=144; nKomma=1; break; // 1Twip = 1/1440"
    884. 

  884. 		// Sonstiges
    885. 

  885. 		case MAP_PIXEL      : break;
    886. 

  886. 		case MAP_SYSFONT    : break;
    887. 

  887. 		case MAP_APPFONT    : break;
    888. 

  888. 		case MAP_RELATIVE   : break;
    889. 

  889. 		default: break;
    890. 

  890. 	} // switch
    891. 

  891. 	rnKomma=nKomma;
    892. 

  892. 	rbMetr=bMetr;
    893. 

  893. 	rbInch=bInch;
    894. 

  894. }
    895. 

  895. 

  896. void GetMeterOrInch(FieldUnit eFU, short& rnKomma, long& rnMul, long& rnDiv, FASTBOOL& rbMetr, FASTBOOL& rbInch)
    897. 

  897. {
    898. 

  898. 	rnMul=1; rnDiv=1;
    899. 

  899. 	short nKomma=0;
    900. 

  900. 	FASTBOOL bMetr=FALSE,bInch=FALSE;
    901. 

  901. 	switch (eFU) {
    902. 

  902. 		case FUNIT_NONE     : break;
    903. 

  903. 		// Metrisch
    904. 

  904. 		case FUNIT_100TH_MM : bMetr=TRUE; nKomma=5; break;
    905. 

  905. 		case FUNIT_MM       : bMetr=TRUE; nKomma=3; break;
    906. 

  906. 		case FUNIT_CM       : bMetr=TRUE; nKomma=2; break;
    907. 

  907. 		case FUNIT_M        : bMetr=TRUE; nKomma=0; break;
    908. 

  908. 		case FUNIT_KM       : bMetr=TRUE; nKomma=-3; break;
    909. 

  909. 		// Inch
    910. 

  910. 		case FUNIT_TWIP     : bInch=TRUE; rnDiv=144; nKomma=1; break;  // 1Twip = 1/1440"
    911. 

  911. 		case FUNIT_POINT    : bInch=TRUE; rnDiv=72; break;   // 1Pt   = 1/72"
    912. 

  912. 		case FUNIT_PICA     : bInch=TRUE; rnDiv=6; break;    // 1Pica = 1/6"  ?
    913. 

  913. 		case FUNIT_INCH     : bInch=TRUE; break;             // 1"    = 1"
    914. 

  914. 		case FUNIT_FOOT     : bInch=TRUE; rnMul=12; break;   // 1Ft   = 12"
    915. 

  915. 		case FUNIT_MILE     : bInch=TRUE; rnMul=6336; nKomma=-1; break; // 1mile = 63360"
    916. 

  916. 		// sonstiges
    917. 

  917. 		case FUNIT_CUSTOM   : break;
    918. 

  918. 		case FUNIT_PERCENT  : nKomma=2; break;
    919. 

  919. 	} // switch
    920. 

  920. 	rnKomma=nKomma;
    921. 

  921. 	rbMetr=bMetr;
    922. 

  922. 	rbInch=bInch;
    923. 

  923. }
    924. 

  924. 

  925. void SdrFormatter::Undirty()
    926. 

  926. {
    927. 

  927. 	if (aScale.GetNumerator()==0 || aScale.GetDenominator()==0) aScale=Fraction(1,1);
    928. 

  928. 	FASTBOOL bSrcMetr,bSrcInch,bDstMetr,bDstInch;
    929. 

  929. 	long nMul1,nDiv1,nMul2,nDiv2;
    930. 

  930. 	short nKomma1,nKomma2;
    931. 

  931. 	// Zunaechst normalisieren auf m bzw. "
    932. 

  932. 	if (!bSrcFU) {
    933. 

  933. 		GetMeterOrInch(eSrcMU,nKomma1,nMul1,nDiv1,bSrcMetr,bSrcInch);
    934. 

  934. 	} else {
    935. 

  935. 		GetMeterOrInch(eSrcFU,nKomma1,nMul1,nDiv1,bSrcMetr,bSrcInch);
    936. 

  936. 	}
    937. 

  937. 	if (!bDstFU) {
    938. 

  938. 		GetMeterOrInch(eDstMU,nKomma2,nMul2,nDiv2,bDstMetr,bDstInch);
    939. 

  939. 	} else {
    940. 

  940. 		GetMeterOrInch(eDstFU,nKomma2,nMul2,nDiv2,bDstMetr,bDstInch);
    941. 

  941. 	}
    942. 

  942. 	nMul1*=nDiv2;
    943. 

  943. 	nDiv1*=nMul2;
    944. 

  944. 	nKomma1=nKomma1-nKomma2;
    945. 

  945. 

  946. 	if (bSrcInch && bDstMetr) {
    947. 

  947. 		nKomma1+=4;
    948. 

  948. 		nMul1*=254;
    949. 

  949. 	}
    950. 

  950. 	if (bSrcMetr && bDstInch) {
    951. 

  951. 		nKomma1-=4;
    952. 

  952. 		nDiv1*=254;
    953. 

  953. 	}
    954. 

  954. 

  955. 	// Temporaere Fraction zum Kuerzen
    956. 

  956. 	Fraction aTempFract(nMul1,nDiv1);
    957. 

  957. 	nMul1=aTempFract.GetNumerator();
    958. 

  958. 	nDiv1=aTempFract.GetDenominator();
    959. 

  959. 

  960. 	nMul_=nMul1;
    961. 

  961. 	nDiv_=nDiv1;
    962. 

  962. 	nKomma_=nKomma1;
    963. 

  963. 	bDirty=FALSE;
    964. 

  964. }
    965. 

  965. 

  966. 

  967. void SdrFormatter::TakeStr(long nVal, XubString& rStr) const
    968. 

  968. {
    969. 

  969. 	sal_Unicode aNullCode('0');
    970. 

  970. 

  971. 	if(!nVal)
    972. 

  972. 	{
    973. 

  973. 		rStr = UniString();
    974. 

  974. 		rStr += aNullCode;
    975. 

  975. 		return;
    976. 

  976. 	}
    977. 

  977. 

  978. 	// Hier fallen trotzdem evtl. Nachkommastellen weg, wg. MulDiv statt Real
    979. 

  979. 	BOOL bNeg(nVal < 0);
    980. 

  980.     SvtSysLocale aSysLoc;
    981. 

  981.     const LocaleDataWrapper& rLoc = aSysLoc.GetLocaleData();
    982. 

  982. 

  983. 	ForceUndirty();
    984. 

  984. 

  985. 	sal_Int16 nK(nKomma_);
    986. 

  986. 	XubString aStr;
    987. 

  987. 

  988. 	if(bNeg)
    989. 

  989. 		nVal = -nVal;
    990. 

  990. 

  991. 	while(nK <= -3)
    992. 

  992. 	{
    993. 

  993. 		nVal *= 1000;
    994. 

  994. 		nK += 3;
    995. 

  995. 	}
    996. 

  996. 

  997. 	while(nK <= -1)
    998. 

  998. 	{
    999. 

  999. 		nVal *= 10;
    1000. 

  1000. 		nK++;
    1001. 

  1001. 	}
    1002. 

  1002. 

  1003. 	if(nMul_ != nDiv_)
    1004. 

  1004. 		nVal = BigMulDiv(nVal, nMul_, nDiv_);
    1005. 

  1005. 

  1006. 	aStr = UniString::CreateFromInt32(nVal);
    1007. 

  1007. 

  1008. 	if(nK > 0 && aStr.Len() <= nK )
    1009. 

  1009. 	{
    1010. 

  1010. 		// Komma erforderlich
    1011. 

  1011. 		sal_Int16 nAnz(nK - aStr.Len());
    1012. 

  1012. 

  1013.         if(nAnz >= 0 && rLoc.isNumLeadingZero())
    1014. 

  1014. 			nAnz++;
    1015. 

  1015. 

  1016. 		for(xub_StrLen  i=0; i<nAnz; i++)
    1017. 

  1017. 			aStr.Insert(aNullCode, 0);
    1018. 

  1018. 

  1019. 		// zuviele Nachkommastellen abhacken
    1020. 

  1020.         xub_StrLen nNumDigits(rLoc.getNumDigits());
    1021. 

  1021. 		xub_StrLen nWeg(nK - nNumDigits);
    1022. 

  1022. 

  1023. 		if(nWeg > 0)
    1024. 

  1024. 		{
    1025. 

  1025. 			// hier muesste eigentlich noch gerundet werden!
    1026. 

  1026. 			aStr.Erase(aStr.Len() - nWeg);
    1027. 

  1027. 			nK = nNumDigits;
    1028. 

  1028. 		}
    1029. 

  1029. 	}
    1030. 

  1030. 

  1031. 	// Vorkommastellen fuer spaeter merken
    1032. 

  1032. 	xub_StrLen nVorKomma(aStr.Len() - nK);
    1033. 

  1033. 

  1034. 	if(nK > 0)
    1035. 

  1035. 	{
    1036. 

  1036. 		// KommaChar einfuegen
    1037. 

  1037. 		// erstmal trailing Zeros abhacken
    1038. 

  1038. 		while(nK > 0 && aStr.GetChar(aStr.Len() - 1) == aNullCode)
    1039. 

  1039. 		{
    1040. 

  1040. 			aStr.Erase(aStr.Len() - 1);
    1041. 

  1041. 			nK--;
    1042. 

  1042. 		}
    1043. 

  1043. 

  1044. 		if(nK > 0)
    1045. 

  1045. 		{
    1046. 

  1046. 			// na, noch Nachkommastellen da?
    1047. 

  1047.             sal_Unicode cDec(rLoc.getNumDecimalSep().GetChar(0));
    1048. 

  1048. 			aStr.Insert(cDec, nVorKomma);
    1049. 

  1049. 		}
    1050. 

  1050. 	}
    1051. 

  1051. 

  1052. 	// ggf. Trennpunkte bei jedem Tausender einfuegen
    1053. 

  1053.     if( nVorKomma > 3 )
    1054. 

  1054. 	{
    1055. 

  1055.         String aThoSep( rLoc.getNumThousandSep() );
    1056. 

  1056.         if ( aThoSep.Len() > 0 )
    1057. 

  1057.         {
    1058. 

  1058.             sal_Unicode cTho( aThoSep.GetChar(0) );
    1059. 

  1059.             sal_Int32 i(nVorKomma - 3);
    1060. 

  1060. 

  1061.             while(i > 0)
    1062. 

  1062.             {
    1063. 

  1063.                 rStr.Insert(cTho, (xub_StrLen)i);
    1064. 

  1064.                 i -= 3;
    1065. 

  1065.             }
    1066. 

  1066.         }
    1067. 

  1067. 	}
    1068. 

  1068. 

  1069. 	if(!aStr.Len())
    1070. 

  1070. 		aStr += aNullCode;
    1071. 

  1071. 

  1072. 	if(bNeg && (aStr.Len() > 1 || aStr.GetChar(0) != aNullCode))
    1073. 

  1073. 	{
    1074. 

  1074. 		rStr.Insert(sal_Unicode('-'), 0);
    1075. 

  1075. 	}
    1076. 

  1076. 

  1077. 	rStr = aStr;
    1078. 

  1078. }
    1079. 

  1079. 

  1080. void SdrFormatter::TakeUnitStr(MapUnit eUnit, XubString& rStr)
    1081. 

  1081. {
    1082. 

  1082. 	switch(eUnit)
    1083. 

  1083. 	{
    1084. 

  1084. 		// Metrisch
    1085. 

  1085. 		case MAP_100TH_MM   :
    1086. 

  1086. 		{
    1087. 

  1087. 			sal_Char aText[] = "/100mm";
    1088. 

  1088. 			rStr = UniString(aText, sizeof(aText-1));
    1089. 

  1089. 			break;
    1090. 

  1090. 		}
    1091. 

  1091. 		case MAP_10TH_MM    :
    1092. 

  1092. 		{
    1093. 

  1093. 			sal_Char aText[] = "/10mm";
    1094. 

  1094. 			rStr = UniString(aText, sizeof(aText-1));
    1095. 

  1095. 			break;
    1096. 

  1096. 		}
    1097. 

  1097. 		case MAP_MM         :
    1098. 

  1098. 		{
    1099. 

  1099. 			sal_Char aText[] = "mm";
    1100. 

  1100. 			rStr = UniString(aText, sizeof(aText-1));
    1101. 

  1101. 			break;
    1102. 

  1102. 		}
    1103. 

  1103. 		case MAP_CM         :
    1104. 

  1104. 		{
    1105. 

  1105. 			sal_Char aText[] = "cm";
    1106. 

  1106. 			rStr = UniString(aText, sizeof(aText-1));
    1107. 

  1107. 			break;
    1108. 

  1108. 		}
    1109. 

  1109. 

  1110. 		// Inch
    1111. 

  1111. 		case MAP_1000TH_INCH:
    1112. 

  1112. 		{
    1113. 

  1113. 			sal_Char aText[] = "/1000\"";
    1114. 

  1114. 			rStr = UniString(aText, sizeof(aText-1));
    1115. 

  1115. 			break;
    1116. 

  1116. 		}
    1117. 

  1117. 		case MAP_100TH_INCH :
    1118. 

  1118. 		{
    1119. 

  1119. 			sal_Char aText[] = "/100\"";
    1120. 

  1120. 			rStr = UniString(aText, sizeof(aText-1));
    1121. 

  1121. 			break;
    1122. 

  1122. 		}
    1123. 

  1123. 		case MAP_10TH_INCH  :
    1124. 

  1124. 		{
    1125. 

  1125. 			sal_Char aText[] = "/10\"";
    1126. 

  1126. 			rStr = UniString(aText, sizeof(aText-1));
    1127. 

  1127. 			break;
    1128. 

  1128. 		}
    1129. 

  1129. 		case MAP_INCH       :
    1130. 

  1130. 		{
    1131. 

  1131. 			rStr = UniString();
    1132. 

  1132. 			rStr += sal_Unicode('"');
    1133. 

  1133. 			break;
    1134. 

  1134. 		}
    1135. 

  1135. 		case MAP_POINT      :
    1136. 

  1136. 		{
    1137. 

  1137. 			sal_Char aText[] = "pt";
    1138. 

  1138. 			rStr = UniString(aText, sizeof(aText-1));
    1139. 

  1139. 			break;
    1140. 

  1140. 		}
    1141. 

  1141. 		case MAP_TWIP       :
    1142. 

  1142. 		{
    1143. 

  1143. 			sal_Char aText[] = "twip";
    1144. 

  1144. 			rStr = UniString(aText, sizeof(aText-1));
    1145. 

  1145. 			break;
    1146. 

  1146. 		}
    1147. 

  1147. 

  1148. 		// Sonstiges
    1149. 

  1149. 		case MAP_PIXEL      :
    1150. 

  1150. 		{
    1151. 

  1151. 			sal_Char aText[] = "pixel";
    1152. 

  1152. 			rStr = UniString(aText, sizeof(aText-1));
    1153. 

  1153. 			break;
    1154. 

  1154. 		}
    1155. 

  1155. 		case MAP_SYSFONT    :
    1156. 

  1156. 		{
    1157. 

  1157. 			sal_Char aText[] = "sysfont";
    1158. 

  1158. 			rStr = UniString(aText, sizeof(aText-1));
    1159. 

  1159. 			break;
    1160. 

  1160. 		}
    1161. 

  1161. 		case MAP_APPFONT    :
    1162. 

  1162. 		{
    1163. 

  1163. 			sal_Char aText[] = "appfont";
    1164. 

  1164. 			rStr = UniString(aText, sizeof(aText-1));
    1165. 

  1165. 			break;
    1166. 

  1166. 		}
    1167. 

  1167. 		case MAP_RELATIVE   :
    1168. 

  1168. 		{
    1169. 

  1169. 			rStr = UniString();
    1170. 

  1170. 			rStr += sal_Unicode('%');
    1171. 

  1171. 			break;
    1172. 

  1172. 		}
    1173. 

  1173. 		default: break;
    1174. 

  1174. 	}
    1175. 

  1175. }
    1176. 

  1176. 

  1177. void SdrFormatter::TakeUnitStr(FieldUnit eUnit, XubString& rStr)
    1178. 

  1178. {
    1179. 

  1179. 	switch(eUnit)
    1180. 

  1180. 	{
    1181. 

  1181. 		default				:
    1182. 

  1182. 		case FUNIT_NONE		:
    1183. 

  1183. 		case FUNIT_CUSTOM	:
    1184. 

  1184. 		{
    1185. 

  1185. 			rStr = UniString();
    1186. 

  1186. 			break;
    1187. 

  1187. 		}
    1188. 

  1188. 

  1189. 		// Metrisch
    1190. 

  1190. 		case FUNIT_100TH_MM:
    1191. 

  1191. 		{
    1192. 

  1192. 			sal_Char aText[] = "/100mm";
    1193. 

  1193. 			rStr = UniString(aText, sizeof(aText-1));
    1194. 

  1194. 			break;
    1195. 

  1195. 		}
    1196. 

  1196. 		case FUNIT_MM     :
    1197. 

  1197. 		{
    1198. 

  1198. 			sal_Char aText[] = "mm";
    1199. 

  1199. 			rStr = UniString(aText, sizeof(aText-1));
    1200. 

  1200. 			break;
    1201. 

  1201. 		}
    1202. 

  1202. 		case FUNIT_CM     :
    1203. 

  1203. 		{
    1204. 

  1204. 			sal_Char aText[] = "cm";
    1205. 

  1205. 			rStr = UniString(aText, sizeof(aText-1));
    1206. 

  1206. 			break;
    1207. 

  1207. 		}
    1208. 

  1208. 		case FUNIT_M      :
    1209. 

  1209. 		{
    1210. 

  1210. 			rStr = UniString();
    1211. 

  1211. 			rStr += sal_Unicode('m');
    1212. 

  1212. 			break;
    1213. 

  1213. 		}
    1214. 

  1214. 		case FUNIT_KM     :
    1215. 

  1215. 		{
    1216. 

  1216. 			sal_Char aText[] = "km";
    1217. 

  1217. 			rStr = UniString(aText, sizeof(aText-1));
    1218. 

  1218. 			break;
    1219. 

  1219. 		}
    1220. 

  1220. 

  1221. 		// Inch
    1222. 

  1222. 		case FUNIT_TWIP   :
    1223. 

  1223. 		{
    1224. 

  1224. 			sal_Char aText[] = "twip";
    1225. 

  1225. 			rStr = UniString(aText, sizeof(aText-1));
    1226. 

  1226. 			break;
    1227. 

  1227. 		}
    1228. 

  1228. 		case FUNIT_POINT  :
    1229. 

  1229. 		{
    1230. 

  1230. 			sal_Char aText[] = "pt";
    1231. 

  1231. 			rStr = UniString(aText, sizeof(aText-1));
    1232. 

  1232. 			break;
    1233. 

  1233. 		}
    1234. 

  1234. 		case FUNIT_PICA   :
    1235. 

  1235. 		{
    1236. 

  1236. 			sal_Char aText[] = "pica";
    1237. 

  1237. 			rStr = UniString(aText, sizeof(aText-1));
    1238. 

  1238. 			break;
    1239. 

  1239. 		}
    1240. 

  1240. 		case FUNIT_INCH   :
    1241. 

  1241. 		{
    1242. 

  1242. 			rStr = UniString();
    1243. 

  1243. 			rStr += sal_Unicode('"');
    1244. 

  1244. 			break;
    1245. 

  1245. 		}
    1246. 

  1246. 		case FUNIT_FOOT   :
    1247. 

  1247. 		{
    1248. 

  1248. 			sal_Char aText[] = "ft";
    1249. 

  1249. 			rStr = UniString(aText, sizeof(aText-1));
    1250. 

  1250. 			break;
    1251. 

  1251. 		}
    1252. 

  1252. 		case FUNIT_MILE   :
    1253. 

  1253. 		{
    1254. 

  1254. 			sal_Char aText[] = "mile(s)";
    1255. 

  1255. 			rStr = UniString(aText, sizeof(aText-1));
    1256. 

  1256. 			break;
    1257. 

  1257. 		}
    1258. 

  1258. 

  1259. 		// sonstiges
    1260. 

  1260. 		case FUNIT_PERCENT:
    1261. 

  1261. 		{
    1262. 

  1262. 			rStr = UniString();
    1263. 

  1263. 			rStr += sal_Unicode('%');
    1264. 

  1264. 			break;
    1265. 

  1265. 		}
    1266. 

  1266. 	}
    1267. 

  1267. }
    1268. 

  1268. 

  1269. ////////////////////////////////////////////////////////////////////////////////////////////////////
    1270. 

  1270. 

  1271. 

  1272.