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