?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 5.0.4.1
[LibreOffice.git] / extensions / source / scanner / grid.cxx
blob6fa2dc7b88bc2b3976e60055d6bbc84b05a5779e
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 #include <sal/config.h>
21 #include <osl/thread.h>
22 #include <cstdio>
23 #include <math.h>
24 #include <boost/math/special_functions/expm1.hpp>
25
26 #include <cmath>
27
28 #include <grid.hxx>
29 #include <vcl/builderfactory.hxx>
30
31 #include <algorithm>
32 #include <boost/scoped_array.hpp>
33
34 class GridWindow : public vcl::Window
35 {
36 // helper class for handles
37 struct impHandle
38 {
39 Point maPos;
40 sal_uInt16 mnOffX;
41 sal_uInt16 mnOffY;
42
43 impHandle(const Point& rPos, sal_uInt16 nX, sal_uInt16 nY)
44 : maPos(rPos), mnOffX(nX), mnOffY(nY)
45 {
46 }
47
48 bool operator<(const impHandle& rComp) const
49 {
50 return (maPos.X() < rComp.maPos.X());
51 }
52
53 void draw(vcl::RenderContext& rRenderContext, const BitmapEx& rBitmapEx)
54 {
55 const Point aOffset(rRenderContext.PixelToLogic(Point(mnOffX, mnOffY)));
56 rRenderContext.DrawBitmapEx(maPos - aOffset, rBitmapEx);
57 }
58
59 bool isHit(vcl::Window& rWin, const Point& rPos)
60 {
61 const Point aOffset(rWin.PixelToLogic(Point(mnOffX, mnOffY)));
62 const Rectangle aTarget(maPos - aOffset, maPos + aOffset);
63 return aTarget.IsInside(rPos);
64 }
65 };
66
67 Rectangle m_aGridArea;
68
69 double m_fMinX;
70 double m_fMinY;
71 double m_fMaxX;
72 double m_fMaxY;
73
74 double m_fChunkX;
75 double m_fMinChunkX;
76 double m_fChunkY;
77 double m_fMinChunkY;
78
79 double* m_pXValues;
80 double* m_pOrigYValues;
81 int m_nValues;
82 double* m_pNewYValues;
83
84 sal_uInt16 m_BmOffX;
85 sal_uInt16 m_BmOffY;
86
87 bool m_bCutValues;
88
89 // stuff for handles
90 std::vector< impHandle > m_aHandles;
91 sal_uInt32 m_nDragIndex;
92
93 BitmapEx m_aMarkerBitmap;
94
95 Point transform( double x, double y );
96 void transform( const Point& rOriginal, double& x, double& y );
97
98 double findMinX();
99 double findMinY();
100 double findMaxX();
101 double findMaxY();
102
103 void drawGrid(vcl::RenderContext& rRenderContext);
104 void drawOriginal(vcl::RenderContext& rRenderContext);
105 void drawNew(vcl::RenderContext& rRenderContext);
106 void drawHandles(vcl::RenderContext& rRenderContext);
107
108 void computeExtremes();
109 static void computeChunk( double fMin, double fMax, double& fChunkOut, double& fMinChunkOut );
110 void computeNew();
111 static double interpolate( double x, double* pNodeX, double* pNodeY, int nNodes );
112
113 virtual void MouseMove( const MouseEvent& ) SAL_OVERRIDE;
114 virtual void MouseButtonDown( const MouseEvent& ) SAL_OVERRIDE;
115 virtual void MouseButtonUp( const MouseEvent& ) SAL_OVERRIDE;
116 void onResize();
117 virtual void Resize() SAL_OVERRIDE;
118 virtual Size GetOptimalSize() const SAL_OVERRIDE;
119 void drawLine(vcl::RenderContext& rRenderContext, double x1, double y1, double x2, double y2);
120 public:
121 GridWindow(vcl::Window* pParent);
122 void Init(double* pXValues, double* pYValues, int nValues, bool bCutValues, const BitmapEx &rMarkerBitmap);
123 virtual ~GridWindow();
124 virtual void dispose() SAL_OVERRIDE;
125
126 void setBoundings( double fMinX, double fMinY, double fMaxX, double fMaxY );
127
128 double* getNewYValues() { return m_pNewYValues; }
129
130 void ChangeMode(int nType);
131
132 virtual void Paint( vcl::RenderContext& /*rRenderContext*/, const Rectangle& rRect ) SAL_OVERRIDE;
133 };
134
135 GridWindow::GridWindow(vcl::Window* pParent)
136 : Window(pParent, 0)
137 , m_aGridArea(50, 15, 100, 100)
138 , m_fMinX(0.0)
139 , m_fMinY(0.0)
140 , m_fMaxX(0.0)
141 , m_fMaxY(0.0)
142 , m_fChunkX(0.0)
143 , m_fMinChunkX(0.0)
144 , m_fChunkY(0.0)
145 , m_fMinChunkY(0.0)
146 , m_pXValues(NULL)
147 , m_pOrigYValues(NULL)
148 , m_nValues(0)
149 , m_pNewYValues(NULL)
150 , m_BmOffX(0)
151 , m_BmOffY(0)
152 , m_bCutValues(false)
153 , m_aHandles()
154 , m_nDragIndex(0xffffffff)
155 {
156 SetMapMode(MapMode(MAP_PIXEL));
157 }
158
159 void GridWindow::Init(double* pXValues, double* pYValues, int nValues, bool bCutValues, const BitmapEx &rMarkerBitmap)
160 {
161 m_aMarkerBitmap = rMarkerBitmap;
162 m_pXValues = pXValues;
163 m_pOrigYValues = pYValues;
164 m_nValues = nValues;
165 m_bCutValues = bCutValues;
166
167 SetSizePixel(GetOptimalSize());
168 onResize();
169
170 if (m_pOrigYValues && m_nValues)
171 {
172 m_pNewYValues = new double[ m_nValues ];
173 memcpy( m_pNewYValues, m_pOrigYValues, sizeof( double ) * m_nValues );
174 }
175
176 setBoundings( 0, 0, 1023, 1023 );
177 computeExtremes();
178
179 // create left and right marker as first and last entry
180 m_BmOffX = sal_uInt16(m_aMarkerBitmap.GetSizePixel().Width() >> 1);
181 m_BmOffY = sal_uInt16(m_aMarkerBitmap.GetSizePixel().Height() >> 1);
182 m_aHandles.push_back(impHandle(transform(findMinX(), findMinY()), m_BmOffX, m_BmOffY));
183 m_aHandles.push_back(impHandle(transform(findMaxX(), findMaxY()), m_BmOffX, m_BmOffY));
184 }
185
186 void GridWindow::Resize()
187 {
188 onResize();
189 }
190
191 void GridWindow::onResize()
192 {
193 Size aSize = GetSizePixel();
194 m_aGridArea.setWidth( aSize.Width() - 80 );
195 m_aGridArea.setHeight( aSize.Height() - 40 );
196 }
197
198 Size GridWindow::GetOptimalSize() const
199 {
200 return LogicToPixel(Size(240, 200), MAP_APPFONT);
201 }
202
203 GridDialog::GridDialog(double* pXValues, double* pYValues, int nValues, vcl::Window* pParent, bool bCutValues )
204 : ModalDialog(pParent, "GridDialog", "modules/scanner/ui/griddialog.ui")
205 {
206 get(m_pOKButton, "ok");
207 get(m_pResetTypeBox, "resetTypeCombobox");
208 get(m_pResetButton, "resetButton");
209 get(m_pGridWindow, "gridwindow");
210 m_pGridWindow->Init(pXValues, pYValues, nValues, bCutValues, get<FixedImage>("handle")->GetImage().GetBitmapEx());
211
212 m_pResetTypeBox->SelectEntryPos( 0 );
213
214 m_pResetButton->SetClickHdl( LINK( this, GridDialog, ClickButtonHdl ) );
215 }
216
217 GridDialog::~GridDialog()
218 {
219 disposeOnce();
220 }
221
222 void GridDialog::dispose()
223 {
224 m_pOKButton.clear();
225 m_pResetTypeBox.clear();
226 m_pResetButton.clear();
227 m_pGridWindow.clear();
228 ModalDialog::dispose();
229 }
230
231 GridWindow::~GridWindow()
232 {
233 disposeOnce();
234 }
235
236 void GridWindow::dispose()
237 {
238 delete [] m_pNewYValues;
239 vcl::Window::dispose();
240 }
241
242 double GridWindow::findMinX()
243 {
244 if( ! m_pXValues )
245 return 0.0;
246 double fMin = m_pXValues[0];
247 for( int i = 1; i < m_nValues; i++ )
248 if( m_pXValues[ i ] < fMin )
249 fMin = m_pXValues[ i ];
250 return fMin;
251 }
252
253 double GridWindow::findMinY()
254 {
255 if( ! m_pNewYValues )
256 return 0.0;
257 double fMin = m_pNewYValues[0];
258 for( int i = 1; i < m_nValues; i++ )
259 if( m_pNewYValues[ i ] < fMin )
260 fMin = m_pNewYValues[ i ];
261 return fMin;
262 }
263
264
265
266 double GridWindow::findMaxX()
267 {
268 if( ! m_pXValues )
269 return 0.0;
270 double fMax = m_pXValues[0];
271 for( int i = 1; i < m_nValues; i++ )
272 if( m_pXValues[ i ] > fMax )
273 fMax = m_pXValues[ i ];
274 return fMax;
275 }
276
277
278
279 double GridWindow::findMaxY()
280 {
281 if( ! m_pNewYValues )
282 return 0.0;
283 double fMax = m_pNewYValues[0];
284 for( int i = 1; i < m_nValues; i++ )
285 if( m_pNewYValues[ i ] > fMax )
286 fMax = m_pNewYValues[ i ];
287 return fMax;
288 }
289
290
291
292 void GridWindow::computeExtremes()
293 {
294 if( m_nValues && m_pXValues && m_pOrigYValues )
295 {
296 m_fMaxX = m_fMinX = m_pXValues[0];
297 m_fMaxY = m_fMinY = m_pOrigYValues[0];
298 for( int i = 1; i < m_nValues; i++ )
299 {
300 if( m_pXValues[ i ] > m_fMaxX )
301 m_fMaxX = m_pXValues[ i ];
302 else if( m_pXValues[ i ] < m_fMinX )
303 m_fMinX = m_pXValues[ i ];
304 if( m_pOrigYValues[ i ] > m_fMaxY )
305 m_fMaxY = m_pOrigYValues[ i ];
306 else if( m_pOrigYValues[ i ] < m_fMinY )
307 m_fMinY = m_pOrigYValues[ i ];
308 }
309 setBoundings( m_fMinX, m_fMinY, m_fMaxX, m_fMaxY );
310 }
311 }
312
313
314
315 Point GridWindow::transform( double x, double y )
316 {
317 Point aRet;
318
319 aRet.X() = (long)( ( x - m_fMinX ) *
320 (double)m_aGridArea.GetWidth() / ( m_fMaxX - m_fMinX )
321 + m_aGridArea.Left() );
322 aRet.Y() = (long)(
323 m_aGridArea.Bottom() -
324 ( y - m_fMinY ) *
325 (double)m_aGridArea.GetHeight() / ( m_fMaxY - m_fMinY ) );
326 return aRet;
327 }
328
329 void GridWindow::transform( const Point& rOriginal, double& x, double& y )
330 {
331 const long nWidth = m_aGridArea.GetWidth();
332 const long nHeight = m_aGridArea.GetHeight();
333 if (!nWidth || !nHeight)
334 return;
335 x = ( rOriginal.X() - m_aGridArea.Left() ) * (m_fMaxX - m_fMinX) / (double)nWidth + m_fMinX;
336 y = ( m_aGridArea.Bottom() - rOriginal.Y() ) * (m_fMaxY - m_fMinY) / (double)nHeight + m_fMinY;
337 }
338
339 void GridWindow::drawLine(vcl::RenderContext& rRenderContext, double x1, double y1, double x2, double y2 )
340 {
341 rRenderContext.DrawLine(transform(x1, y1), transform(x2, y2));
342 }
343
344 void GridWindow::computeChunk( double fMin, double fMax, double& fChunkOut, double& fMinChunkOut )
345 {
346 // get a nice chunk size like 10, 100, 25 or such
347 fChunkOut = ( fMax - fMin ) / 6.0;
348 int logchunk = (int)std::log10( fChunkOut );
349 int nChunk = (int)( fChunkOut / std::exp( (double)(logchunk-1) * M_LN10 ) );
350 if( nChunk >= 75 )
351 nChunk = 100;
352 else if( nChunk >= 35 )
353 nChunk = 50;
354 else if ( nChunk > 20 )
355 nChunk = 25;
356 else if ( nChunk >= 13 )
357 nChunk = 20;
358 else if( nChunk > 5 )
359 nChunk = 10;
360 else
361 nChunk = 5;
362 fChunkOut = (double) nChunk * exp( (double)(logchunk-1) * M_LN10 );
363 // compute whole chunks fitting into fMin
364 nChunk = (int)( fMin / fChunkOut );
365 fMinChunkOut = (double)nChunk * fChunkOut;
366 while( fMinChunkOut < fMin )
367 fMinChunkOut += fChunkOut;
368 }
369
370
371
372 void GridWindow::computeNew()
373 {
374 if(2L == m_aHandles.size())
375 {
376 // special case: only left and right markers
377 double xleft, yleft;
378 double xright, yright;
379 transform(m_aHandles[0L].maPos, xleft, yleft);
380 transform(m_aHandles[1L].maPos, xright, yright );
381 double factor = (yright-yleft)/(xright-xleft);
382 for( int i = 0; i < m_nValues; i++ )
383 {
384 m_pNewYValues[ i ] = yleft + ( m_pXValues[ i ] - xleft )*factor;
385 }
386 }
387 else
388 {
389 // sort markers
390 std::sort(m_aHandles.begin(), m_aHandles.end());
391 const int nSorted = m_aHandles.size();
392 int i;
393
394 // get node arrays
395 boost::scoped_array<double> nodex(new double[ nSorted ]);
396 boost::scoped_array<double> nodey(new double[ nSorted ]);
397
398 for( i = 0L; i < nSorted; i++ )
399 transform( m_aHandles[i].maPos, nodex[ i ], nodey[ i ] );
400
401 for( i = 0; i < m_nValues; i++ )
402 {
403 double x = m_pXValues[ i ];
404 m_pNewYValues[ i ] = interpolate( x, nodex.get(), nodey.get(), nSorted );
405 if( m_bCutValues )
406 {
407 if( m_pNewYValues[ i ] > m_fMaxY )
408 m_pNewYValues[ i ] = m_fMaxY;
409 else if( m_pNewYValues[ i ] < m_fMinY )
410 m_pNewYValues[ i ] = m_fMinY;
411 }
412 }
413 }
414 }
415
416
417
418 double GridWindow::interpolate(
419 double x,
420 double* pNodeX,
421 double* pNodeY,
422 int nNodes )
423 {
424 // compute Lagrange interpolation
425 double ret = 0;
426 for( int i = 0; i < nNodes; i++ )
427 {
428 double sum = pNodeY[ i ];
429 for( int n = 0; n < nNodes; n++ )
430 {
431 if( n != i )
432 {
433 sum *= x - pNodeX[ n ];
434 sum /= pNodeX[ i ] - pNodeX[ n ];
435 }
436 }
437 ret += sum;
438 }
439 return ret;
440 }
441
442 void GridDialog::setBoundings(double fMinX, double fMinY, double fMaxX, double fMaxY)
443 {
444 m_pGridWindow->setBoundings(fMinX, fMinY, fMaxX, fMaxY);
445 }
446
447 void GridWindow::setBoundings(double fMinX, double fMinY, double fMaxX, double fMaxY)
448 {
449 m_fMinX = fMinX;
450 m_fMinY = fMinY;
451 m_fMaxX = fMaxX;
452 m_fMaxY = fMaxY;
453
454 computeChunk( m_fMinX, m_fMaxX, m_fChunkX, m_fMinChunkX );
455 computeChunk( m_fMinY, m_fMaxY, m_fChunkY, m_fMinChunkY );
456 }
457
458 void GridWindow::drawGrid(vcl::RenderContext& rRenderContext)
459 {
460 char pBuf[256];
461 rRenderContext.SetLineColor(Color(COL_BLACK));
462 // draw vertical lines
463 for (double fX = m_fMinChunkX; fX < m_fMaxX; fX += m_fChunkX)
464 {
465 drawLine(rRenderContext, fX, m_fMinY, fX, m_fMaxY);
466 // draw tickmarks
467 Point aPt = transform(fX, m_fMinY);
468 std::sprintf(pBuf, "%g", fX);
469 OUString aMark(pBuf, strlen(pBuf), osl_getThreadTextEncoding());
470 Size aTextSize(rRenderContext.GetTextWidth(aMark), rRenderContext.GetTextHeight());
471 aPt.X() -= aTextSize.Width() / 2;
472 aPt.Y() += aTextSize.Height() / 2;
473 rRenderContext.DrawText(aPt, aMark);
474 }
475 // draw horizontal lines
476 for (double fY = m_fMinChunkY; fY < m_fMaxY; fY += m_fChunkY)
477 {
478 drawLine(rRenderContext, m_fMinX, fY, m_fMaxX, fY);
479 // draw tickmarks
480 Point aPt = transform(m_fMinX, fY);
481 std::sprintf(pBuf, "%g", fY);
482 OUString aMark(pBuf, strlen(pBuf), osl_getThreadTextEncoding());
483 Size aTextSize(rRenderContext.GetTextWidth(aMark), rRenderContext.GetTextHeight());
484 aPt.X() -= aTextSize.Width() + 2;
485 aPt.Y() -= aTextSize.Height() / 2;
486 rRenderContext.DrawText(aPt, aMark);
487 }
488
489 // draw boundings
490 drawLine(rRenderContext, m_fMinX, m_fMinY, m_fMaxX, m_fMinY);
491 drawLine(rRenderContext, m_fMinX, m_fMaxY, m_fMaxX, m_fMaxY);
492 drawLine(rRenderContext, m_fMinX, m_fMinY, m_fMinX, m_fMaxY);
493 drawLine(rRenderContext, m_fMaxX, m_fMinY, m_fMaxX, m_fMaxY);
494 }
495
496 void GridWindow::drawOriginal(vcl::RenderContext& rRenderContext)
497 {
498 if (m_nValues && m_pXValues && m_pOrigYValues)
499 {
500 rRenderContext.SetLineColor(Color(COL_RED));
501 for (int i = 0; i < m_nValues - 1; i++)
502 {
503 drawLine(rRenderContext,
504 m_pXValues[i], m_pOrigYValues[i],
505 m_pXValues[i + 1], m_pOrigYValues[i + 1]);
506 }
507 }
508 }
509
510 void GridWindow::drawNew(vcl::RenderContext& rRenderContext)
511 {
512 if (m_nValues && m_pXValues && m_pNewYValues)
513 {
514 rRenderContext.SetClipRegion(vcl::Region(m_aGridArea));
515 rRenderContext.SetLineColor(Color(COL_YELLOW));
516 for (int i = 0; i < m_nValues - 1; i++)
517 {
518 drawLine(rRenderContext,
519 m_pXValues[i], m_pNewYValues[i],
520 m_pXValues[i + 1], m_pNewYValues[i + 1]);
521 }
522 rRenderContext.SetClipRegion();
523 }
524 }
525
526 void GridWindow::drawHandles(vcl::RenderContext& rRenderContext)
527 {
528 for(sal_uInt32 i(0L); i < m_aHandles.size(); i++)
529 {
530 m_aHandles[i].draw(rRenderContext, m_aMarkerBitmap);
531 }
532 }
533
534 void GridWindow::Paint(vcl::RenderContext& rRenderContext, const Rectangle& rRect)
535 {
536 Window::Paint(rRenderContext, rRect);
537 drawGrid(rRenderContext);
538 drawOriginal(rRenderContext);
539 drawNew(rRenderContext);
540 drawHandles(rRenderContext);
541 }
542
543 void GridWindow::MouseMove( const MouseEvent& rEvt )
544 {
545 if( rEvt.GetButtons() == MOUSE_LEFT && m_nDragIndex != 0xffffffff )
546 {
547 Point aPoint( rEvt.GetPosPixel() );
548
549 if( m_nDragIndex == 0L || m_nDragIndex == m_aHandles.size() - 1L)
550 {
551 aPoint.X() = m_aHandles[m_nDragIndex].maPos.X();
552 }
553 else
554 {
555 if(aPoint.X() < m_aGridArea.Left())
556 aPoint.X() = m_aGridArea.Left();
557 else if(aPoint.X() > m_aGridArea.Right())
558 aPoint.X() = m_aGridArea.Right();
559 }
560
561 if( aPoint.Y() < m_aGridArea.Top() )
562 aPoint.Y() = m_aGridArea.Top();
563 else if( aPoint.Y() > m_aGridArea.Bottom() )
564 aPoint.Y() = m_aGridArea.Bottom();
565
566 if( aPoint != m_aHandles[m_nDragIndex].maPos )
567 {
568 m_aHandles[m_nDragIndex].maPos = aPoint;
569 Invalidate( m_aGridArea );
570 }
571 }
572
573 Window::MouseMove( rEvt );
574 }
575
576 void GridWindow::MouseButtonUp( const MouseEvent& rEvt )
577 {
578 if( rEvt.GetButtons() == MOUSE_LEFT )
579 {
580 if( m_nDragIndex != 0xffffffff )
581 {
582 m_nDragIndex = 0xffffffff;
583 computeNew();
584 Invalidate(m_aGridArea);
585 }
586 }
587
588 Window::MouseButtonUp( rEvt );
589 }
590
591 void GridWindow::MouseButtonDown( const MouseEvent& rEvt )
592 {
593 Point aPoint( rEvt.GetPosPixel() );
594 sal_uInt32 nMarkerIndex = 0xffffffff;
595
596 for(sal_uInt32 a(0L); nMarkerIndex == 0xffffffff && a < m_aHandles.size(); a++)
597 {
598 if(m_aHandles[a].isHit(*this, aPoint))
599 {
600 nMarkerIndex = a;
601 }
602 }
603
604 if( rEvt.GetButtons() == MOUSE_LEFT )
605 {
606 // user wants to drag a button
607 if( nMarkerIndex != 0xffffffff )
608 {
609 m_nDragIndex = nMarkerIndex;
610 }
611 }
612 else if( rEvt.GetButtons() == MOUSE_RIGHT )
613 {
614 // user wants to add/delete a button
615 if( nMarkerIndex != 0xffffffff )
616 {
617 if( nMarkerIndex != 0L && nMarkerIndex != m_aHandles.size() - 1L)
618 {
619 // delete marker under mouse
620 if( m_nDragIndex == nMarkerIndex )
621 m_nDragIndex = 0xffffffff;
622
623 m_aHandles.erase(m_aHandles.begin() + nMarkerIndex);
624 }
625 }
626 else
627 {
628 m_BmOffX = sal_uInt16(m_aMarkerBitmap.GetSizePixel().Width() >> 1);
629 m_BmOffY = sal_uInt16(m_aMarkerBitmap.GetSizePixel().Height() >> 1);
630 m_aHandles.push_back(impHandle(aPoint, m_BmOffX, m_BmOffY));
631 }
632
633 computeNew();
634 Invalidate(m_aGridArea);
635 }
636
637 Window::MouseButtonDown( rEvt );
638 }
639
640 void GridWindow::ChangeMode(int nType)
641 {
642 switch( nType )
643 {
644 case LINEAR_ASCENDING:
645 {
646 for( int i = 0; i < m_nValues; i++ )
647 {
648 m_pNewYValues[ i ] = m_fMinY + (m_fMaxY-m_fMinY)/(m_fMaxX-m_fMinX)*(m_pXValues[i]-m_fMinX);
649 }
650 }
651 break;
652 case LINEAR_DESCENDING:
653 {
654 for( int i = 0; i < m_nValues; i++ )
655 {
656 m_pNewYValues[ i ] = m_fMaxY - (m_fMaxY-m_fMinY)/(m_fMaxX-m_fMinX)*(m_pXValues[i]-m_fMinX);
657 }
658 }
659 break;
660 case RESET:
661 {
662 if( m_pOrigYValues && m_pNewYValues && m_nValues )
663 memcpy( m_pNewYValues, m_pOrigYValues, m_nValues*sizeof(double) );
664 }
665 break;
666 case EXPONENTIAL:
667 {
668 for( int i = 0; i < m_nValues; i++ )
669 {
670 m_pNewYValues[ i ] = m_fMinY + (m_fMaxY-m_fMinY)*(boost::math::expm1((m_pXValues[i]-m_fMinX)/(m_fMaxX-m_fMinX)))/(M_E-1.0);
671 }
672 }
673 break;
674
675 default:
676 break;
677 }
678
679 if (m_pNewYValues)
680 {
681 for(sal_uInt32 i(0L); i < m_aHandles.size(); i++)
682 {
683 // find nearest xvalue
684 double x, y;
685 transform( m_aHandles[i].maPos, x, y );
686 int nIndex = 0;
687 double delta = std::fabs( x-m_pXValues[0] );
688 for( int n = 1; n < m_nValues; n++ )
689 {
690 if( delta > std::fabs( x - m_pXValues[ n ] ) )
691 {
692 delta = std::fabs( x - m_pXValues[ n ] );
693 nIndex = n;
694 }
695 }
696 if( 0 == i )
697 m_aHandles[i].maPos = transform( m_fMinX, m_pNewYValues[ nIndex ] );
698 else if( m_aHandles.size() - 1L == i )
699 m_aHandles[i].maPos = transform( m_fMaxX, m_pNewYValues[ nIndex ] );
700 else
701 m_aHandles[i].maPos = transform( m_pXValues[ nIndex ], m_pNewYValues[ nIndex ] );
702 }
703 }
704
705 Invalidate();
706 }
707
708 IMPL_LINK( GridDialog, ClickButtonHdl, Button*, pButton )
709 {
710 if (pButton == m_pResetButton)
711 {
712 int nType = m_pResetTypeBox->GetSelectEntryPos();
713 m_pGridWindow->ChangeMode(nType);
714 }
715 return 0;
716 }
717
718 double* GridDialog::getNewYValues()
719 {
720 return m_pGridWindow->getNewYValues();
721 }
722
723 VCL_BUILDER_FACTORY(GridWindow)
724
725 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE