Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*
3 : : * This file is part of the LibreOffice project.
4 : : *
5 : : * This Source Code Form is subject to the terms of the Mozilla Public
6 : : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : : *
9 : : * This file incorporates work covered by the following license notice:
10 : : *
11 : : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : : * contributor license agreements. See the NOTICE file distributed
13 : : * with this work for additional information regarding copyright
14 : : * ownership. The ASF licenses this file to you under the Apache
15 : : * License, Version 2.0 (the "License"); you may not use this file
16 : : * except in compliance with the License. You may obtain a copy of
17 : : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : : */
19 : :
20 : :
21 : : #include "gradtrns.hxx"
22 : : #include <svx/svdobj.hxx>
23 : : #include <basegfx/range/b2drange.hxx>
24 : : #include <basegfx/matrix/b2dhommatrix.hxx>
25 : : #include <basegfx/matrix/b2dhommatrixtools.hxx>
26 : : #include <tools/helpers.hxx>
27 : :
28 : : //////////////////////////////////////////////////////////////////////////////
29 : :
30 : 0 : void GradTransformer::GradToVec(GradTransGradient& rG, GradTransVector& rV, const SdrObject* pObj)
31 : : {
32 : : // handle start color
33 : 0 : rV.aCol1 = rG.aGradient.GetStartColor();
34 [ # # ]: 0 : if(100 != rG.aGradient.GetStartIntens())
35 : : {
36 : 0 : const double fFact((double)rG.aGradient.GetStartIntens() / 100.0);
37 : 0 : rV.aCol1 = Color(rV.aCol1.getBColor() * fFact);
38 : : }
39 : :
40 : : // handle end color
41 : 0 : rV.aCol2 = rG.aGradient.GetEndColor();
42 [ # # ]: 0 : if(100 != rG.aGradient.GetEndIntens())
43 : : {
44 : 0 : const double fFact((double)rG.aGradient.GetEndIntens() / 100.0);
45 : 0 : rV.aCol2 = Color(rV.aCol2.getBColor() * fFact);
46 : : }
47 : :
48 : : // calc the basic positions
49 [ # # ]: 0 : const Rectangle aObjectSnapRectangle(pObj->GetSnapRect());
50 [ # # ]: 0 : const basegfx::B2DRange aRange(aObjectSnapRectangle.Left(), aObjectSnapRectangle.Top(), aObjectSnapRectangle.Right(), aObjectSnapRectangle.Bottom());
51 [ # # ]: 0 : const basegfx::B2DPoint aCenter(aRange.getCenter());
52 : 0 : basegfx::B2DPoint aStartPos, aEndPos;
53 : :
54 [ # # # # : 0 : switch(rG.aGradient.GetGradientStyle())
# ]
55 : : {
56 : : case XGRAD_LINEAR :
57 : : {
58 [ # # ]: 0 : aStartPos = basegfx::B2DPoint(aCenter.getX(), aRange.getMinY());
59 [ # # ]: 0 : aEndPos = basegfx::B2DPoint(aCenter.getX(), aRange.getMaximum().getY());
60 : :
61 [ # # ]: 0 : if(rG.aGradient.GetBorder())
62 : : {
63 : 0 : basegfx::B2DVector aFullVec(aStartPos - aEndPos);
64 [ # # ]: 0 : const double fLen = (aFullVec.getLength() * (100.0 - (double)rG.aGradient.GetBorder())) / 100.0;
65 [ # # ]: 0 : aFullVec.normalize();
66 [ # # ]: 0 : aStartPos = aEndPos + (aFullVec * fLen);
67 : : }
68 : :
69 [ # # ]: 0 : if(rG.aGradient.GetAngle())
70 : : {
71 : 0 : const double fAngle = (double)rG.aGradient.GetAngle() * (F_PI180 / 10.0);
72 [ # # ]: 0 : const basegfx::B2DHomMatrix aTransformation(basegfx::tools::createRotateAroundPoint(aCenter, -fAngle));
73 : :
74 [ # # ]: 0 : aStartPos *= aTransformation;
75 [ # # ][ # # ]: 0 : aEndPos *= aTransformation;
76 : : }
77 : 0 : break;
78 : : }
79 : : case XGRAD_AXIAL :
80 : : {
81 : 0 : aStartPos = aCenter;
82 [ # # ]: 0 : aEndPos = basegfx::B2DPoint(aCenter.getX(), aRange.getMaximum().getY());
83 : :
84 [ # # ]: 0 : if(rG.aGradient.GetBorder())
85 : : {
86 : 0 : basegfx::B2DVector aFullVec(aEndPos - aStartPos);
87 [ # # ]: 0 : const double fLen = (aFullVec.getLength() * (100.0 - (double)rG.aGradient.GetBorder())) / 100.0;
88 [ # # ]: 0 : aFullVec.normalize();
89 [ # # ]: 0 : aEndPos = aStartPos + (aFullVec * fLen);
90 : : }
91 : :
92 [ # # ]: 0 : if(rG.aGradient.GetAngle())
93 : : {
94 : 0 : const double fAngle = (double)rG.aGradient.GetAngle() * (F_PI180 / 10.0);
95 [ # # ]: 0 : const basegfx::B2DHomMatrix aTransformation(basegfx::tools::createRotateAroundPoint(aCenter, -fAngle));
96 : :
97 [ # # ]: 0 : aStartPos *= aTransformation;
98 [ # # ][ # # ]: 0 : aEndPos *= aTransformation;
99 : : }
100 : 0 : break;
101 : : }
102 : : case XGRAD_RADIAL :
103 : : case XGRAD_SQUARE :
104 : : {
105 [ # # ][ # # ]: 0 : aStartPos = basegfx::B2DPoint(aRange.getMinX(), aRange.getMaximum().getY());
106 [ # # ][ # # ]: 0 : aEndPos = basegfx::B2DPoint(aRange.getMinX(), aRange.getMinY());
107 : :
108 [ # # ]: 0 : if(rG.aGradient.GetBorder())
109 : : {
110 : 0 : basegfx::B2DVector aFullVec(aStartPos - aEndPos);
111 [ # # ]: 0 : const double fLen = (aFullVec.getLength() * (100.0 - (double)rG.aGradient.GetBorder())) / 100.0;
112 [ # # ]: 0 : aFullVec.normalize();
113 [ # # ]: 0 : aStartPos = aEndPos + (aFullVec * fLen);
114 : : }
115 : :
116 [ # # ]: 0 : if(rG.aGradient.GetAngle())
117 : : {
118 : 0 : const double fAngle = (double)rG.aGradient.GetAngle() * (F_PI180 / 10.0);
119 [ # # ]: 0 : const basegfx::B2DHomMatrix aTransformation(basegfx::tools::createRotateAroundPoint(aEndPos, -fAngle));
120 : :
121 [ # # ]: 0 : aStartPos *= aTransformation;
122 [ # # ][ # # ]: 0 : aEndPos *= aTransformation;
123 : : }
124 : :
125 [ # # ][ # # ]: 0 : if(rG.aGradient.GetXOffset() || rG.aGradient.GetYOffset())
[ # # ]
126 : : {
127 : : basegfx::B2DPoint aOffset(
128 [ # # ]: 0 : (aRange.getWidth() * rG.aGradient.GetXOffset()) / 100.0,
129 [ # # ]: 0 : (aRange.getHeight() * rG.aGradient.GetYOffset()) / 100.0);
130 : :
131 : 0 : aStartPos += aOffset;
132 : 0 : aEndPos += aOffset;
133 : : }
134 : :
135 : 0 : break;
136 : : }
137 : : case XGRAD_ELLIPTICAL :
138 : : case XGRAD_RECT :
139 : : {
140 [ # # ]: 0 : aStartPos = basegfx::B2DPoint(aRange.getMinX(), aCenter.getY());
141 [ # # ][ # # ]: 0 : aEndPos = basegfx::B2DPoint(aRange.getMinX(), aRange.getMinY());
142 : :
143 [ # # ]: 0 : if(rG.aGradient.GetBorder())
144 : : {
145 : 0 : basegfx::B2DVector aFullVec(aStartPos - aEndPos);
146 [ # # ]: 0 : const double fLen = (aFullVec.getLength() * (100.0 - (double)rG.aGradient.GetBorder())) / 100.0;
147 [ # # ]: 0 : aFullVec.normalize();
148 [ # # ]: 0 : aStartPos = aEndPos + (aFullVec * fLen);
149 : : }
150 : :
151 [ # # ]: 0 : if(rG.aGradient.GetAngle())
152 : : {
153 : 0 : const double fAngle = (double)rG.aGradient.GetAngle() * (F_PI180 / 10.0);
154 [ # # ]: 0 : const basegfx::B2DHomMatrix aTransformation(basegfx::tools::createRotateAroundPoint(aEndPos, -fAngle));
155 : :
156 [ # # ]: 0 : aStartPos *= aTransformation;
157 [ # # ][ # # ]: 0 : aEndPos *= aTransformation;
158 : : }
159 : :
160 [ # # ][ # # ]: 0 : if(rG.aGradient.GetXOffset() || rG.aGradient.GetYOffset())
[ # # ]
161 : : {
162 : : basegfx::B2DPoint aOffset(
163 [ # # ]: 0 : (aRange.getWidth() * rG.aGradient.GetXOffset()) / 100.0,
164 [ # # ]: 0 : (aRange.getHeight() * rG.aGradient.GetYOffset()) / 100.0);
165 : :
166 : 0 : aStartPos += aOffset;
167 : 0 : aEndPos += aOffset;
168 : : }
169 : :
170 : 0 : break;
171 : : }
172 : : }
173 : :
174 : : // set values for vector positions now
175 : 0 : rV.maPositionA = aStartPos;
176 : 0 : rV.maPositionB = aEndPos;
177 : 0 : }
178 : :
179 : : //////////////////////////////////////////////////////////////////////////////
180 : :
181 : 0 : void GradTransformer::VecToGrad(GradTransVector& rV, GradTransGradient& rG, GradTransGradient& rGOld, const SdrObject* pObj,
182 : : sal_Bool bMoveSingle, sal_Bool bMoveFirst)
183 : : {
184 : : // fill old gradient to new gradient to have a base
185 : 0 : rG = rGOld;
186 : :
187 : : // handle color changes
188 [ # # ]: 0 : if(rV.aCol1 != rGOld.aGradient.GetStartColor())
189 : : {
190 : 0 : rG.aGradient.SetStartColor(rV.aCol1);
191 : 0 : rG.aGradient.SetStartIntens(100);
192 : : }
193 [ # # ]: 0 : if(rV.aCol2 != rGOld.aGradient.GetEndColor())
194 : : {
195 : 0 : rG.aGradient.SetEndColor(rV.aCol2);
196 : 0 : rG.aGradient.SetEndIntens(100);
197 : : }
198 : :
199 : : // calc the basic positions
200 [ # # ]: 0 : const Rectangle aObjectSnapRectangle(pObj->GetSnapRect());
201 [ # # ]: 0 : const basegfx::B2DRange aRange(aObjectSnapRectangle.Left(), aObjectSnapRectangle.Top(), aObjectSnapRectangle.Right(), aObjectSnapRectangle.Bottom());
202 [ # # ]: 0 : const basegfx::B2DPoint aCenter(aRange.getCenter());
203 : 0 : basegfx::B2DPoint aStartPos(rV.maPositionA);
204 : 0 : basegfx::B2DPoint aEndPos(rV.maPositionB);
205 : :
206 [ # # # # : 0 : switch(rG.aGradient.GetGradientStyle())
# ]
207 : : {
208 : : case XGRAD_LINEAR :
209 : : {
210 [ # # ][ # # ]: 0 : if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
[ # # ]
211 : : {
212 : 0 : basegfx::B2DVector aFullVec(aEndPos - aStartPos);
213 : :
214 [ # # ]: 0 : if(bMoveSingle)
215 : : {
216 [ # # ]: 0 : aFullVec = aEndPos - aCenter;
217 : : }
218 : :
219 [ # # ]: 0 : aFullVec.normalize();
220 : :
221 : 0 : double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
222 : 0 : fNewFullAngle /= F_PI180;
223 : 0 : fNewFullAngle *= -10.0;
224 : 0 : fNewFullAngle += 900.0;
225 : :
226 : : // clip
227 [ # # ]: 0 : while(fNewFullAngle < 0.0)
228 : : {
229 : 0 : fNewFullAngle += 3600.0;
230 : : }
231 : :
232 [ # # ]: 0 : while(fNewFullAngle >= 3600.0)
233 : : {
234 : 0 : fNewFullAngle -= 3600.0;
235 : : }
236 : :
237 : : // to int and set
238 : 0 : sal_Int32 nNewAngle = FRound(fNewFullAngle);
239 : :
240 [ # # ]: 0 : if(nNewAngle != rGOld.aGradient.GetAngle())
241 : : {
242 : 0 : rG.aGradient.SetAngle(nNewAngle);
243 : 0 : }
244 : : }
245 : :
246 [ # # ][ # # ]: 0 : if(!bMoveSingle || (bMoveSingle && bMoveFirst))
[ # # ]
247 : : {
248 : 0 : const basegfx::B2DVector aFullVec(aEndPos - aStartPos);
249 [ # # ][ # # ]: 0 : const basegfx::B2DPoint aBottomLeft(aRange.getMinX(), aRange.getMaximum().getY());
250 [ # # ][ # # ]: 0 : const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
251 : 0 : const basegfx::B2DVector aOldVec(aBottomLeft - aTopLeft);
252 [ # # ]: 0 : const double fFullLen(aFullVec.getLength());
253 [ # # ]: 0 : const double fOldLen(aOldVec.getLength());
254 : 0 : const double fNewBorder((fFullLen * 100.0) / fOldLen);
255 : 0 : sal_Int32 nNewBorder(100L - FRound(fNewBorder));
256 : :
257 : : // clip
258 [ # # ]: 0 : if(nNewBorder < 0L)
259 : : {
260 : 0 : nNewBorder = 0L;
261 : : }
262 : :
263 [ # # ]: 0 : if(nNewBorder > 100L)
264 : : {
265 : 0 : nNewBorder = 100L;
266 : : }
267 : :
268 : : // set
269 [ # # ]: 0 : if(nNewBorder != rG.aGradient.GetBorder())
270 : : {
271 : 0 : rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
272 : 0 : }
273 : : }
274 : :
275 : 0 : break;
276 : : }
277 : : case XGRAD_AXIAL :
278 : : {
279 [ # # ][ # # ]: 0 : if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
[ # # ]
280 : : {
281 : 0 : basegfx::B2DVector aFullVec(aEndPos - aCenter);
282 [ # # ]: 0 : const basegfx::B2DVector aOldVec(basegfx::B2DPoint(aCenter.getX(), aRange.getMaximum().getY()) - aCenter);
283 [ # # ]: 0 : const double fFullLen(aFullVec.getLength());
284 [ # # ]: 0 : const double fOldLen(aOldVec.getLength());
285 : 0 : const double fNewBorder((fFullLen * 100.0) / fOldLen);
286 : 0 : sal_Int32 nNewBorder = 100 - FRound(fNewBorder);
287 : :
288 : : // clip
289 [ # # ]: 0 : if(nNewBorder < 0L)
290 : : {
291 : 0 : nNewBorder = 0L;
292 : : }
293 : :
294 [ # # ]: 0 : if(nNewBorder > 100L)
295 : : {
296 : 0 : nNewBorder = 100L;
297 : : }
298 : :
299 : : // set
300 [ # # ]: 0 : if(nNewBorder != rG.aGradient.GetBorder())
301 : : {
302 : 0 : rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
303 : : }
304 : :
305 [ # # ]: 0 : aFullVec.normalize();
306 : 0 : double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
307 : 0 : fNewFullAngle /= F_PI180;
308 : 0 : fNewFullAngle *= -10.0;
309 : 0 : fNewFullAngle += 900.0;
310 : :
311 : : // clip
312 [ # # ]: 0 : while(fNewFullAngle < 0.0)
313 : : {
314 : 0 : fNewFullAngle += 3600.0;
315 : : }
316 : :
317 [ # # ]: 0 : while(fNewFullAngle >= 3600.0)
318 : : {
319 : 0 : fNewFullAngle -= 3600.0;
320 : : }
321 : :
322 : : // to int and set
323 : 0 : const sal_Int32 nNewAngle(FRound(fNewFullAngle));
324 : :
325 [ # # ]: 0 : if(nNewAngle != rGOld.aGradient.GetAngle())
326 : : {
327 : 0 : rG.aGradient.SetAngle(nNewAngle);
328 : 0 : }
329 : : }
330 : :
331 : 0 : break;
332 : : }
333 : : case XGRAD_RADIAL :
334 : : case XGRAD_SQUARE :
335 : : {
336 [ # # ][ # # ]: 0 : if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
[ # # ]
337 : : {
338 [ # # ][ # # ]: 0 : const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
339 : 0 : const basegfx::B2DPoint aOffset(aEndPos - aTopLeft);
340 [ # # ]: 0 : sal_Int32 nNewXOffset(FRound((aOffset.getX() * 100.0) / aRange.getWidth()));
341 [ # # ]: 0 : sal_Int32 nNewYOffset(FRound((aOffset.getY() * 100.0) / aRange.getHeight()));
342 : :
343 : : // clip
344 [ # # ]: 0 : if(nNewXOffset < 0L)
345 : : {
346 : 0 : nNewXOffset = 0L;
347 : : }
348 : :
349 [ # # ]: 0 : if(nNewXOffset > 100L)
350 : : {
351 : 0 : nNewXOffset = 100L;
352 : : }
353 : :
354 [ # # ]: 0 : if(nNewYOffset < 0L)
355 : : {
356 : 0 : nNewYOffset = 0L;
357 : : }
358 : :
359 [ # # ]: 0 : if(nNewYOffset > 100L)
360 : : {
361 : 0 : nNewYOffset = 100L;
362 : : }
363 : :
364 : 0 : rG.aGradient.SetXOffset((sal_uInt16)nNewXOffset);
365 : 0 : rG.aGradient.SetYOffset((sal_uInt16)nNewYOffset);
366 : :
367 : 0 : aStartPos -= aOffset;
368 : 0 : aEndPos -= aOffset;
369 : : }
370 : :
371 [ # # ][ # # ]: 0 : if(!bMoveSingle || (bMoveSingle && bMoveFirst))
[ # # ]
372 : : {
373 : 0 : basegfx::B2DVector aFullVec(aStartPos - aEndPos);
374 [ # # ][ # # ]: 0 : const basegfx::B2DPoint aBottomLeft(aRange.getMinX(), aRange.getMaximum().getY());
375 [ # # ][ # # ]: 0 : const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
376 : 0 : const basegfx::B2DVector aOldVec(aBottomLeft - aTopLeft);
377 [ # # ]: 0 : const double fFullLen(aFullVec.getLength());
378 [ # # ]: 0 : const double fOldLen(aOldVec.getLength());
379 : 0 : const double fNewBorder((fFullLen * 100.0) / fOldLen);
380 : 0 : sal_Int32 nNewBorder(100L - FRound(fNewBorder));
381 : :
382 : : // clip
383 [ # # ]: 0 : if(nNewBorder < 0L)
384 : : {
385 : 0 : nNewBorder = 0L;
386 : : }
387 : :
388 [ # # ]: 0 : if(nNewBorder > 100L)
389 : : {
390 : 0 : nNewBorder = 100L;
391 : : }
392 : :
393 : : // set
394 [ # # ]: 0 : if(nNewBorder != rG.aGradient.GetBorder())
395 : : {
396 : 0 : rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
397 : : }
398 : :
399 : : // angle is not definitely necessary for these modes, but it makes
400 : : // controlling more fun for the user
401 [ # # ]: 0 : aFullVec.normalize();
402 : 0 : double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
403 : 0 : fNewFullAngle /= F_PI180;
404 : 0 : fNewFullAngle *= -10.0;
405 : 0 : fNewFullAngle += 900.0;
406 : :
407 : : // clip
408 [ # # ]: 0 : while(fNewFullAngle < 0.0)
409 : : {
410 : 0 : fNewFullAngle += 3600.0;
411 : : }
412 : :
413 [ # # ]: 0 : while(fNewFullAngle >= 3600.0)
414 : : {
415 : 0 : fNewFullAngle -= 3600.0;
416 : : }
417 : :
418 : : // to int and set
419 : 0 : const sal_Int32 nNewAngle(FRound(fNewFullAngle));
420 : :
421 [ # # ]: 0 : if(nNewAngle != rGOld.aGradient.GetAngle())
422 : : {
423 : 0 : rG.aGradient.SetAngle(nNewAngle);
424 : 0 : }
425 : : }
426 : :
427 : 0 : break;
428 : : }
429 : : case XGRAD_ELLIPTICAL :
430 : : case XGRAD_RECT :
431 : : {
432 [ # # ][ # # ]: 0 : if(!bMoveSingle || (bMoveSingle && !bMoveFirst))
[ # # ]
433 : : {
434 [ # # ][ # # ]: 0 : const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
435 : 0 : const basegfx::B2DPoint aOffset(aEndPos - aTopLeft);
436 [ # # ]: 0 : sal_Int32 nNewXOffset(FRound((aOffset.getX() * 100.0) / aRange.getWidth()));
437 [ # # ]: 0 : sal_Int32 nNewYOffset(FRound((aOffset.getY() * 100.0) / aRange.getHeight()));
438 : :
439 : : // clip
440 [ # # ]: 0 : if(nNewXOffset < 0L)
441 : : {
442 : 0 : nNewXOffset = 0L;
443 : : }
444 : :
445 [ # # ]: 0 : if(nNewXOffset > 100L)
446 : : {
447 : 0 : nNewXOffset = 100L;
448 : : }
449 : :
450 [ # # ]: 0 : if(nNewYOffset < 0L)
451 : : {
452 : 0 : nNewYOffset = 0L;
453 : : }
454 : :
455 [ # # ]: 0 : if(nNewYOffset > 100L)
456 : : {
457 : 0 : nNewYOffset = 100L;
458 : : }
459 : :
460 : 0 : rG.aGradient.SetXOffset((sal_uInt16)nNewXOffset);
461 : 0 : rG.aGradient.SetYOffset((sal_uInt16)nNewYOffset);
462 : :
463 : 0 : aStartPos -= aOffset;
464 : 0 : aEndPos -= aOffset;
465 : : }
466 : :
467 [ # # ][ # # ]: 0 : if(!bMoveSingle || (bMoveSingle && bMoveFirst))
[ # # ]
468 : : {
469 : 0 : basegfx::B2DVector aFullVec(aStartPos - aEndPos);
470 [ # # ][ # # ]: 0 : const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY());
471 [ # # ][ # # ]: 0 : const basegfx::B2DPoint aCenterLeft(aRange.getMinX(), aRange.getHeight());
472 : 0 : const basegfx::B2DVector aOldVec(aCenterLeft - aTopLeft);
473 [ # # ]: 0 : const double fFullLen(aFullVec.getLength());
474 [ # # ]: 0 : const double fOldLen(aOldVec.getLength());
475 : 0 : const double fNewBorder((fFullLen * 100.0) / fOldLen);
476 : 0 : sal_Int32 nNewBorder(100L - FRound(fNewBorder));
477 : :
478 : : // clip
479 [ # # ]: 0 : if(nNewBorder < 0L)
480 : : {
481 : 0 : nNewBorder = 0L;
482 : : }
483 : :
484 [ # # ]: 0 : if(nNewBorder > 100L)
485 : : {
486 : 0 : nNewBorder = 100L;
487 : : }
488 : :
489 : : // set
490 [ # # ]: 0 : if(nNewBorder != rG.aGradient.GetBorder())
491 : : {
492 : 0 : rG.aGradient.SetBorder((sal_uInt16)nNewBorder);
493 : : }
494 : :
495 : : // angle is not definitely necessary for these modes, but it makes
496 : : // controlling more fun for the user
497 [ # # ]: 0 : aFullVec.normalize();
498 : 0 : double fNewFullAngle(atan2(aFullVec.getY(), aFullVec.getX()));
499 : 0 : fNewFullAngle /= F_PI180;
500 : 0 : fNewFullAngle *= -10.0;
501 : 0 : fNewFullAngle += 900.0;
502 : :
503 : : // clip
504 [ # # ]: 0 : while(fNewFullAngle < 0.0)
505 : : {
506 : 0 : fNewFullAngle += 3600.0;
507 : : }
508 : :
509 [ # # ]: 0 : while(fNewFullAngle >= 3600.0)
510 : : {
511 : 0 : fNewFullAngle -= 3600.0;
512 : : }
513 : :
514 : : // to int and set
515 : 0 : const sal_Int32 nNewAngle(FRound(fNewFullAngle));
516 : :
517 [ # # ]: 0 : if(nNewAngle != rGOld.aGradient.GetAngle())
518 : : {
519 : 0 : rG.aGradient.SetAngle(nNewAngle);
520 : 0 : }
521 : : }
522 : :
523 : 0 : break;
524 : : }
525 : 0 : }
526 : 0 : }
527 : :
528 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
