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