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 <com/sun/star/accessibility/AccessibleRole.hpp>
21 :
22 : #include <vcl/svapp.hxx>
23 : #include <vcl/settings.hxx>
24 :
25 : #include "ipwin.hxx"
26 : #include <hatchwindow.hxx>
27 :
28 : /************************************************************************/
29 : /*************************************************************************
30 : |* SvResizeHelper::SvResizeHelper()
31 : |*
32 : |* Description
33 : *************************************************************************/
34 1 : SvResizeHelper::SvResizeHelper()
35 : : aBorder( 5, 5 )
36 : , nGrab( -1 )
37 1 : , bResizeable( true )
38 : {
39 1 : }
40 :
41 : /*************************************************************************
42 : |* SvResizeHelper::FillHandleRects()
43 : |*
44 : |* Description: the eight handles to magnify
45 : *************************************************************************/
46 1 : void SvResizeHelper::FillHandleRectsPixel( Rectangle aRects[ 8 ] ) const
47 : {
48 : // only because of EMPTY_RECT
49 1 : Point aBottomRight = aOuter.BottomRight();
50 :
51 : // upper left
52 1 : aRects[ 0 ] = Rectangle( aOuter.TopLeft(), aBorder );
53 : // upper middle
54 3 : aRects[ 1 ] = Rectangle( Point( aOuter.Center().X() - aBorder.Width() / 2,
55 : aOuter.Top() ),
56 3 : aBorder );
57 : // upper right
58 1 : aRects[ 2 ] = Rectangle( Point( aBottomRight.X() - aBorder.Width() +1,
59 : aOuter.Top() ),
60 2 : aBorder );
61 : // middle right
62 1 : aRects[ 3 ] = Rectangle( Point( aBottomRight.X() - aBorder.Width() +1,
63 3 : aOuter.Center().Y() - aBorder.Height() / 2 ),
64 4 : aBorder );
65 : // lower right
66 1 : aRects[ 4 ] = Rectangle( Point( aBottomRight.X() - aBorder.Width() +1,
67 1 : aBottomRight.Y() - aBorder.Height() +1 ),
68 3 : aBorder );
69 : // lower middle
70 3 : aRects[ 5 ] = Rectangle( Point( aOuter.Center().X() - aBorder.Width() / 2,
71 1 : aBottomRight.Y() - aBorder.Height() +1),
72 4 : aBorder );
73 : // lower left
74 : aRects[ 6 ] = Rectangle( Point( aOuter.Left(),
75 1 : aBottomRight.Y() - aBorder.Height() +1),
76 2 : aBorder );
77 : // middle left
78 : aRects[ 7 ] = Rectangle( Point( aOuter.Left(),
79 3 : aOuter.Center().Y() - aBorder.Height() / 2 ),
80 3 : aBorder );
81 1 : }
82 :
83 : /*************************************************************************
84 : |* SvResizeHelper::FillMoveRectsPixel()
85 : |*
86 : |* Description: the four edges are calculated
87 : *************************************************************************/
88 3 : void SvResizeHelper::FillMoveRectsPixel( Rectangle aRects[ 4 ] ) const
89 : {
90 : // upper
91 3 : aRects[ 0 ] = aOuter;
92 3 : aRects[ 0 ].Bottom() = aRects[ 0 ].Top() + aBorder.Height() -1;
93 : // right
94 3 : aRects[ 1 ] = aOuter;
95 3 : aRects[ 1 ].Left() = aRects[ 1 ].Right() - aBorder.Width() -1;
96 : // lower
97 3 : aRects[ 2 ] = aOuter;
98 3 : aRects[ 2 ].Top() = aRects[ 2 ].Bottom() - aBorder.Height() -1;
99 : // left
100 3 : aRects[ 3 ] = aOuter;
101 3 : aRects[ 3 ].Right() = aRects[ 3 ].Left() + aBorder.Width() -1;
102 3 : }
103 :
104 : /*************************************************************************
105 : |* SvResizeHelper::Draw()
106 : |*
107 : |* Description
108 : *************************************************************************/
109 1 : void SvResizeHelper::Draw(vcl::RenderContext& rRenderContext)
110 : {
111 1 : rRenderContext.Push();
112 1 : rRenderContext.SetMapMode( MapMode() );
113 1 : Color aColBlack;
114 1 : Color aFillColor( COL_LIGHTGRAY );
115 :
116 1 : rRenderContext.SetFillColor( aFillColor );
117 1 : rRenderContext.SetLineColor();
118 :
119 1 : Rectangle aMoveRects[ 4 ];
120 1 : FillMoveRectsPixel( aMoveRects );
121 : sal_uInt16 i;
122 5 : for (i = 0; i < 4; i++)
123 4 : rRenderContext.DrawRect(aMoveRects[i]);
124 1 : if (bResizeable)
125 : {
126 : // draw handles
127 1 : rRenderContext.SetFillColor(aColBlack);
128 1 : Rectangle aRects[ 8 ];
129 1 : FillHandleRectsPixel(aRects);
130 9 : for (i = 0; i < 8; i++)
131 8 : rRenderContext.DrawRect( aRects[ i ] );
132 : }
133 1 : rRenderContext.Pop();
134 1 : }
135 :
136 : /*************************************************************************
137 : |* SvResizeHelper::InvalidateBorder()
138 : |*
139 : |* Description
140 : *************************************************************************/
141 2 : void SvResizeHelper::InvalidateBorder( vcl::Window * pWin )
142 : {
143 2 : Rectangle aMoveRects[ 4 ];
144 2 : FillMoveRectsPixel( aMoveRects );
145 10 : for( sal_uInt16 i = 0; i < 4; i++ )
146 8 : pWin->Invalidate( aMoveRects[ i ] );
147 2 : }
148 :
149 : /*************************************************************************
150 : |* SvResizeHelper::SelectBegin()
151 : |*
152 : |* Description
153 : *************************************************************************/
154 0 : bool SvResizeHelper::SelectBegin( vcl::Window * pWin, const Point & rPos )
155 : {
156 0 : if( -1 == nGrab )
157 : {
158 0 : nGrab = SelectMove( pWin, rPos );
159 0 : if( -1 != nGrab )
160 : {
161 0 : aSelPos = rPos; // store start position
162 0 : pWin->CaptureMouse();
163 0 : return true;
164 : }
165 : }
166 0 : return false;
167 : }
168 :
169 : /*************************************************************************
170 : |* SvResizeHelper::SelectMove()
171 : |*
172 : |* Description
173 : *************************************************************************/
174 0 : short SvResizeHelper::SelectMove( vcl::Window * pWin, const Point & rPos )
175 : {
176 0 : if( -1 == nGrab )
177 : {
178 0 : if( bResizeable )
179 : {
180 0 : Rectangle aRects[ 8 ];
181 0 : FillHandleRectsPixel( aRects );
182 0 : for( sal_uInt16 i = 0; i < 8; i++ )
183 0 : if( aRects[ i ].IsInside( rPos ) )
184 0 : return i;
185 : }
186 : // Move-Rect overlaps Handles
187 0 : Rectangle aMoveRects[ 4 ];
188 0 : FillMoveRectsPixel( aMoveRects );
189 0 : for( sal_uInt16 i = 0; i < 4; i++ )
190 0 : if( aMoveRects[ i ].IsInside( rPos ) )
191 0 : return 8;
192 : }
193 : else
194 : {
195 0 : Rectangle aRect( GetTrackRectPixel( rPos ) );
196 0 : aRect.SetSize( pWin->PixelToLogic( aRect.GetSize() ) );
197 0 : aRect.SetPos( pWin->PixelToLogic( aRect.TopLeft() ) );
198 0 : pWin->ShowTracking( aRect );
199 : }
200 0 : return nGrab;
201 : }
202 :
203 0 : Point SvResizeHelper::GetTrackPosPixel( const Rectangle & rRect ) const
204 : {
205 : // not important how the rectangle is returned, it is important
206 : // which handle has been touched
207 0 : Point aPos;
208 0 : Rectangle aRect( rRect );
209 0 : aRect.Justify();
210 : // only because of EMPTY_RECT
211 0 : Point aBR = aOuter.BottomRight();
212 0 : Point aTR = aOuter.TopRight();
213 0 : Point aBL = aOuter.BottomLeft();
214 0 : bool bRTL = AllSettings::GetLayoutRTL();
215 0 : switch( nGrab )
216 : {
217 : case 0:
218 : // FIXME: disable it for RTL because it's wrong calculations
219 0 : if( bRTL )
220 0 : break;
221 0 : aPos = aRect.TopLeft() - aOuter.TopLeft();
222 0 : break;
223 : case 1:
224 0 : aPos.Y() = aRect.Top() - aOuter.Top();
225 0 : break;
226 : case 2:
227 : // FIXME: disable it for RTL because it's wrong calculations
228 0 : if( bRTL )
229 0 : break;
230 0 : aPos = aRect.TopRight() - aTR;
231 0 : break;
232 : case 3:
233 0 : if( bRTL )
234 0 : aPos.X() = aRect.Left() - aTR.X();
235 : else
236 0 : aPos.X() = aRect.Right() - aTR.X();
237 0 : break;
238 : case 4:
239 : // FIXME: disable it for RTL because it's wrong calculations
240 0 : if( bRTL )
241 0 : break;
242 0 : aPos = aRect.BottomRight() - aBR;
243 0 : break;
244 : case 5:
245 0 : aPos.Y() = aRect.Bottom() - aBR.Y();
246 0 : break;
247 : case 6:
248 : // FIXME: disable it for RTL because it's wrong calculations
249 0 : if( bRTL )
250 0 : break;
251 0 : aPos = aRect.BottomLeft() - aBL;
252 0 : break;
253 : case 7:
254 0 : if( bRTL )
255 0 : aPos.X() = aRect.Right() + aOuter.Right() - aOuter.TopRight().X();
256 : else
257 0 : aPos.X() = aRect.Left() - aOuter.Left();
258 0 : break;
259 : case 8:
260 0 : aPos = aRect.TopLeft() - aOuter.TopLeft();
261 0 : break;
262 : }
263 0 : return aPos += aSelPos;
264 : }
265 :
266 : /*************************************************************************
267 : |* SvResizeHelper::GetTrackRectPixel()
268 : |*
269 : |* Description
270 : *************************************************************************/
271 0 : Rectangle SvResizeHelper::GetTrackRectPixel( const Point & rTrackPos ) const
272 : {
273 0 : Rectangle aTrackRect;
274 0 : if( -1 != nGrab )
275 : {
276 0 : Point aDiff = rTrackPos - aSelPos;
277 0 : aTrackRect = aOuter;
278 0 : Point aBR = aOuter.BottomRight();
279 0 : bool bRTL = AllSettings::GetLayoutRTL();
280 0 : switch( nGrab )
281 : {
282 : case 0:
283 0 : aTrackRect.Top() += aDiff.Y();
284 : // ugly solution for resizing OLE objects in RTL
285 0 : if( bRTL )
286 0 : aTrackRect.Right() = aBR.X() - aDiff.X();
287 : else
288 0 : aTrackRect.Left() += aDiff.X();
289 0 : break;
290 : case 1:
291 0 : aTrackRect.Top() += aDiff.Y();
292 0 : break;
293 : case 2:
294 0 : aTrackRect.Top() += aDiff.Y();
295 : // ugly solution for resizing OLE objects in RTL
296 0 : if( bRTL )
297 0 : aTrackRect.Left() -= aDiff.X();
298 : else
299 0 : aTrackRect.Right() = aBR.X() + aDiff.X();
300 0 : break;
301 : case 3:
302 : // ugly solution for resizing OLE objects in RTL
303 0 : if( bRTL )
304 0 : aTrackRect.Left() -= aDiff.X();
305 : else
306 0 : aTrackRect.Right() = aBR.X() + aDiff.X();
307 0 : break;
308 : case 4:
309 0 : aTrackRect.Bottom() = aBR.Y() + aDiff.Y();
310 : // ugly solution for resizing OLE objects in RTL
311 0 : if( bRTL )
312 0 : aTrackRect.Left() -= aDiff.X();
313 : else
314 0 : aTrackRect.Right() = aBR.X() + aDiff.X();
315 0 : break;
316 : case 5:
317 0 : aTrackRect.Bottom() = aBR.Y() + aDiff.Y();
318 0 : break;
319 : case 6:
320 0 : aTrackRect.Bottom() = aBR.Y() + aDiff.Y();
321 : // ugly solution for resizing OLE objects in RTL
322 0 : if( bRTL )
323 0 : aTrackRect.Right() = aBR.X() - aDiff.X();
324 : else
325 0 : aTrackRect.Left() += aDiff.X();
326 0 : break;
327 : case 7:
328 : // ugly solution for resizing OLE objects in RTL
329 0 : if( bRTL )
330 0 : aTrackRect.Right() = aBR.X() - aDiff.X();
331 : else
332 0 : aTrackRect.Left() += aDiff.X();
333 0 : break;
334 : case 8:
335 0 : if( bRTL )
336 0 : aDiff.X() = -aDiff.X(); // workaround for move in RTL mode
337 0 : aTrackRect.SetPos( aTrackRect.TopLeft() + aDiff );
338 0 : break;
339 : }
340 : }
341 0 : return aTrackRect;
342 : }
343 :
344 0 : void SvResizeHelper::ValidateRect( Rectangle & rValidate ) const
345 : {
346 0 : switch( nGrab )
347 : {
348 : case 0:
349 0 : if( rValidate.Top() > rValidate.Bottom() )
350 : {
351 0 : rValidate.Top() = rValidate.Bottom();
352 0 : rValidate.Bottom() = RECT_EMPTY;
353 : }
354 0 : if( rValidate.Left() > rValidate.Right() )
355 : {
356 0 : rValidate.Left() = rValidate.Right();
357 0 : rValidate.Right() = RECT_EMPTY;
358 : }
359 0 : break;
360 : case 1:
361 0 : if( rValidate.Top() > rValidate.Bottom() )
362 : {
363 0 : rValidate.Top() = rValidate.Bottom();
364 0 : rValidate.Bottom() = RECT_EMPTY;
365 : }
366 0 : break;
367 : case 2:
368 0 : if( rValidate.Top() > rValidate.Bottom() )
369 : {
370 0 : rValidate.Top() = rValidate.Bottom();
371 0 : rValidate.Bottom() = RECT_EMPTY;
372 : }
373 0 : if( rValidate.Left() > rValidate.Right() )
374 0 : rValidate.Right() = RECT_EMPTY;
375 0 : break;
376 : case 3:
377 0 : if( rValidate.Left() > rValidate.Right() )
378 0 : rValidate.Right() = RECT_EMPTY;
379 0 : break;
380 : case 4:
381 0 : if( rValidate.Top() > rValidate.Bottom() )
382 0 : rValidate.Bottom() = RECT_EMPTY;
383 0 : if( rValidate.Left() > rValidate.Right() )
384 0 : rValidate.Right() = RECT_EMPTY;
385 0 : break;
386 : case 5:
387 0 : if( rValidate.Top() > rValidate.Bottom() )
388 0 : rValidate.Bottom() = RECT_EMPTY;
389 0 : break;
390 : case 6:
391 0 : if( rValidate.Top() > rValidate.Bottom() )
392 0 : rValidate.Bottom() = RECT_EMPTY;
393 0 : if( rValidate.Left() > rValidate.Right() )
394 : {
395 0 : rValidate.Left() = rValidate.Right();
396 0 : rValidate.Right() = RECT_EMPTY;
397 : }
398 0 : break;
399 : case 7:
400 0 : if( rValidate.Left() > rValidate.Right() )
401 : {
402 0 : rValidate.Left() = rValidate.Right();
403 0 : rValidate.Right() = RECT_EMPTY;
404 : }
405 0 : break;
406 : }
407 0 : if( rValidate.Right() == RECT_EMPTY )
408 0 : rValidate.Right() = rValidate.Left();
409 0 : if( rValidate.Bottom() == RECT_EMPTY )
410 0 : rValidate.Bottom() = rValidate.Top();
411 :
412 : // Mindestgr"osse 5 x 5
413 0 : if( rValidate.Left() + 5 > rValidate.Right() )
414 0 : rValidate.Right() = rValidate.Left() +5;
415 0 : if( rValidate.Top() + 5 > rValidate.Bottom() )
416 0 : rValidate.Bottom() = rValidate.Top() +5;
417 0 : }
418 :
419 : /*************************************************************************
420 : |* SvResizeHelper::SelectRelease()
421 : |*
422 : |* Description
423 : *************************************************************************/
424 0 : bool SvResizeHelper::SelectRelease( vcl::Window * pWin, const Point & rPos,
425 : Rectangle & rOutPosSize )
426 : {
427 0 : if( -1 != nGrab )
428 : {
429 0 : rOutPosSize = GetTrackRectPixel( rPos );
430 0 : rOutPosSize.Justify();
431 0 : nGrab = -1;
432 0 : pWin->ReleaseMouse();
433 0 : pWin->HideTracking();
434 0 : return true;
435 : }
436 0 : return false;
437 : }
438 :
439 : /*************************************************************************
440 : |* SvResizeHelper::Release()
441 : |*
442 : |* Description
443 : *************************************************************************/
444 0 : void SvResizeHelper::Release( vcl::Window * pWin )
445 : {
446 0 : if( nGrab != -1 )
447 : {
448 0 : pWin->ReleaseMouse();
449 0 : pWin->HideTracking();
450 0 : nGrab = -1;
451 : }
452 0 : }
453 :
454 : /*************************************************************************
455 : |* SvResizeWindow::SvResizeWindow()
456 : |*
457 : |* Description
458 : *************************************************************************/
459 1 : SvResizeWindow::SvResizeWindow
460 : (
461 : vcl::Window * pParent,
462 : VCLXHatchWindow* pWrapper
463 : )
464 : : Window( pParent, WB_CLIPCHILDREN )
465 : , m_nMoveGrab( -1 )
466 : , m_bActive( false )
467 1 : , m_pWrapper( pWrapper )
468 : {
469 : OSL_ENSURE( pParent != NULL && pWrapper != NULL, "Wrong initialization of hatch window!\n" );
470 1 : SetBackground();
471 1 : SetAccessibleRole( ::com::sun::star::accessibility::AccessibleRole::EMBEDDED_OBJECT );
472 1 : m_aResizer.SetOuterRectPixel( Rectangle( Point(), GetOutputSizePixel() ) );
473 1 : }
474 :
475 : /*************************************************************************
476 : |* SvResizeWindow::SetHatchBorderPixel()
477 : |*
478 : |* Description
479 : *************************************************************************/
480 3 : void SvResizeWindow::SetHatchBorderPixel( const Size & rSize )
481 : {
482 3 : m_aResizer.SetBorderPixel( rSize );
483 3 : }
484 :
485 : /*************************************************************************
486 : |* SvResizeWindow::SelectMouse()
487 : |*
488 : |* Description
489 : *************************************************************************/
490 0 : void SvResizeWindow::SelectMouse( const Point & rPos )
491 : {
492 0 : short nGrab = m_aResizer.SelectMove( this, rPos );
493 0 : if( nGrab >= 4 )
494 0 : nGrab -= 4;
495 0 : if( m_nMoveGrab != nGrab )
496 : { // Pointer did change
497 0 : if( -1 == nGrab )
498 0 : SetPointer( m_aOldPointer );
499 : else
500 : {
501 0 : PointerStyle aStyle = PointerStyle::Move;
502 0 : if( nGrab == 3 )
503 0 : aStyle = PointerStyle::ESize;
504 0 : else if( nGrab == 2 )
505 0 : aStyle = PointerStyle::NESize;
506 0 : else if( nGrab == 1 )
507 0 : aStyle = PointerStyle::SSize;
508 0 : else if( nGrab == 0 )
509 0 : aStyle = PointerStyle::SESize;
510 0 : if( m_nMoveGrab == -1 ) // the first time
511 : {
512 0 : m_aOldPointer = GetPointer();
513 0 : SetPointer( Pointer( aStyle ) );
514 : }
515 : else
516 0 : SetPointer( Pointer( aStyle ) );
517 : }
518 0 : m_nMoveGrab = nGrab;
519 : }
520 0 : }
521 :
522 : /*************************************************************************
523 : |* SvResizeWindow::MouseButtonDown()
524 : |*
525 : |* Description
526 : *************************************************************************/
527 0 : void SvResizeWindow::MouseButtonDown( const MouseEvent & rEvt )
528 : {
529 0 : if( m_aResizer.SelectBegin( this, rEvt.GetPosPixel() ) )
530 0 : SelectMouse( rEvt.GetPosPixel() );
531 0 : }
532 :
533 : /*************************************************************************
534 : |* SvResizeWindow::MouseMove()
535 : |*
536 : |* Description
537 : *************************************************************************/
538 0 : void SvResizeWindow::MouseMove( const MouseEvent & rEvt )
539 : {
540 0 : if( m_aResizer.GetGrab() == -1 )
541 0 : SelectMouse( rEvt.GetPosPixel() );
542 : else
543 : {
544 0 : Rectangle aRect( m_aResizer.GetTrackRectPixel( rEvt.GetPosPixel() ) );
545 0 : Point aDiff = GetPosPixel();
546 0 : aRect.SetPos( aRect.TopLeft() + aDiff );
547 0 : m_aResizer.ValidateRect( aRect );
548 :
549 0 : m_pWrapper->QueryObjAreaPixel( aRect );
550 0 : aRect.SetPos( aRect.TopLeft() - aDiff );
551 0 : Point aPos = m_aResizer.GetTrackPosPixel( aRect );
552 :
553 0 : SelectMouse( aPos );
554 : }
555 0 : }
556 :
557 : /*************************************************************************
558 : |* SvResizeWindow::MouseButtonUp()
559 : |*
560 : |* Description
561 : *************************************************************************/
562 0 : void SvResizeWindow::MouseButtonUp( const MouseEvent & rEvt )
563 : {
564 0 : if( m_aResizer.GetGrab() != -1 )
565 : {
566 0 : Rectangle aRect( m_aResizer.GetTrackRectPixel( rEvt.GetPosPixel() ) );
567 0 : Point aDiff = GetPosPixel();
568 0 : aRect.SetPos( aRect.TopLeft() + aDiff );
569 : // aRect -= GetAllBorderPixel();
570 0 : m_aResizer.ValidateRect( aRect );
571 :
572 0 : m_pWrapper->QueryObjAreaPixel( aRect );
573 :
574 0 : Rectangle aOutRect;
575 0 : if( m_aResizer.SelectRelease( this, rEvt.GetPosPixel(), aOutRect ) )
576 : {
577 0 : m_nMoveGrab = -1;
578 0 : SetPointer( m_aOldPointer );
579 0 : m_pWrapper->RequestObjAreaPixel( aRect );
580 : }
581 : }
582 0 : }
583 :
584 : /*************************************************************************
585 : |* SvResizeWindow::KeyEvent()
586 : |*
587 : |* Description
588 : *************************************************************************/
589 0 : void SvResizeWindow::KeyInput( const KeyEvent & rEvt )
590 : {
591 0 : if( rEvt.GetKeyCode().GetCode() == KEY_ESCAPE )
592 : {
593 0 : m_aResizer.Release( this );
594 0 : m_pWrapper->InplaceDeactivate();
595 : }
596 0 : }
597 :
598 : /*************************************************************************
599 : |* SvResizeWindow::Resize()
600 : |*
601 : |* Description
602 : *************************************************************************/
603 1 : void SvResizeWindow::Resize()
604 : {
605 1 : m_aResizer.InvalidateBorder( this ); // old area
606 1 : m_aResizer.SetOuterRectPixel( Rectangle( Point(), GetOutputSizePixel() ) );
607 1 : m_aResizer.InvalidateBorder( this ); // new area
608 1 : }
609 :
610 : /*************************************************************************
611 : |* SvResizeWindow::Paint()
612 : |*
613 : |* Description
614 : *************************************************************************/
615 1 : void SvResizeWindow::Paint(vcl::RenderContext& rRenderContext, const Rectangle & /*rRect*/ )
616 : {
617 1 : m_aResizer.Draw(rRenderContext);
618 1 : }
619 :
620 7 : bool SvResizeWindow::PreNotify( NotifyEvent& rEvt )
621 : {
622 7 : if ( rEvt.GetType() == MouseNotifyEvent::GETFOCUS && !m_bActive )
623 : {
624 1 : m_bActive = true;
625 1 : m_pWrapper->Activated();
626 : }
627 :
628 7 : return Window::PreNotify(rEvt);
629 : }
630 :
631 19 : bool SvResizeWindow::Notify( NotifyEvent& rEvt )
632 : {
633 19 : if ( rEvt.GetType() == MouseNotifyEvent::LOSEFOCUS && m_bActive )
634 : {
635 3 : bool bHasFocus = HasChildPathFocus(true);
636 3 : if ( !bHasFocus )
637 : {
638 0 : m_bActive = false;
639 0 : m_pWrapper->Deactivated();
640 : }
641 : }
642 :
643 19 : return Window::Notify(rEvt);
644 : }
645 :
646 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
