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