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 <tools/debug.hxx>
21 : #include <tools/time.hxx>
22 :
23 : #include <unotools/localedatawrapper.hxx>
24 :
25 : #include <vcl/i18nhelp.hxx>
26 : #include <vcl/unohelp.hxx>
27 : #include <vcl/timer.hxx>
28 : #include <vcl/event.hxx>
29 : #include <vcl/settings.hxx>
30 : #include <vcl/svapp.hxx>
31 : #include <vcl/cursor.hxx>
32 : #include <vcl/wrkwin.hxx>
33 : #include <vcl/floatwin.hxx>
34 : #include <vcl/dialog.hxx>
35 : #include <vcl/help.hxx>
36 : #include <vcl/dockwin.hxx>
37 : #include <vcl/menu.hxx>
38 :
39 : #include <svdata.hxx>
40 : #include <dbggui.hxx>
41 : #include <salwtype.hxx>
42 : #include <salframe.hxx>
43 : #include <accmgr.hxx>
44 : #include <print.h>
45 : #include <window.h>
46 : #include <helpwin.hxx>
47 : #include <brdwin.hxx>
48 : #include <salgdi.hxx>
49 : #include <dndlcon.hxx>
50 :
51 : #include <com/sun/star/datatransfer/dnd/XDragSource.hpp>
52 : #include <com/sun/star/awt/MouseEvent.hpp>
53 :
54 : // =======================================================================
55 :
56 : #define IMPL_MIN_NEEDSYSWIN 49
57 :
58 : // =======================================================================
59 :
60 10111 : long ImplCallPreNotify( NotifyEvent& rEvt )
61 : {
62 10111 : long nRet = Application::CallEventHooks( rEvt );
63 10111 : if ( !nRet )
64 10111 : nRet = rEvt.GetWindow()->PreNotify( rEvt );
65 10111 : return nRet;
66 : }
67 :
68 : // =======================================================================
69 :
70 0 : long ImplCallEvent( NotifyEvent& rEvt )
71 : {
72 0 : long nRet = ImplCallPreNotify( rEvt );
73 0 : if ( !nRet )
74 : {
75 0 : Window* pWindow = rEvt.GetWindow();
76 0 : switch ( rEvt.GetType() )
77 : {
78 : case EVENT_MOUSEBUTTONDOWN:
79 0 : pWindow->MouseButtonDown( *rEvt.GetMouseEvent() );
80 0 : break;
81 : case EVENT_MOUSEBUTTONUP:
82 0 : pWindow->MouseButtonUp( *rEvt.GetMouseEvent() );
83 0 : break;
84 : case EVENT_MOUSEMOVE:
85 0 : pWindow->MouseMove( *rEvt.GetMouseEvent() );
86 0 : break;
87 : case EVENT_KEYINPUT:
88 0 : pWindow->KeyInput( *rEvt.GetKeyEvent() );
89 0 : break;
90 : case EVENT_KEYUP:
91 0 : pWindow->KeyUp( *rEvt.GetKeyEvent() );
92 0 : break;
93 : case EVENT_GETFOCUS:
94 0 : pWindow->GetFocus();
95 0 : break;
96 : case EVENT_LOSEFOCUS:
97 0 : pWindow->LoseFocus();
98 0 : break;
99 : case EVENT_COMMAND:
100 0 : pWindow->Command( *rEvt.GetCommandEvent() );
101 0 : break;
102 : }
103 : }
104 :
105 0 : return nRet;
106 : }
107 :
108 : // =======================================================================
109 :
110 0 : static sal_Bool ImplHandleMouseFloatMode( Window* pChild, const Point& rMousePos,
111 : sal_uInt16 nCode, sal_uInt16 nSVEvent,
112 : sal_Bool bMouseLeave )
113 : {
114 0 : ImplSVData* pSVData = ImplGetSVData();
115 :
116 0 : if ( pSVData->maWinData.mpFirstFloat && !pSVData->maWinData.mpCaptureWin &&
117 0 : !pSVData->maWinData.mpFirstFloat->ImplIsFloatPopupModeWindow( pChild ) )
118 : {
119 : /*
120 : * #93895# since floats are system windows, coordinates have
121 : * to be converted to float relative for the hittest
122 : */
123 0 : sal_uInt16 nHitTest = IMPL_FLOATWIN_HITTEST_OUTSIDE;
124 0 : FloatingWindow* pFloat = pSVData->maWinData.mpFirstFloat->ImplFloatHitTest( pChild, rMousePos, nHitTest );
125 : FloatingWindow* pLastLevelFloat;
126 : sal_uLong nPopupFlags;
127 0 : if ( nSVEvent == EVENT_MOUSEMOVE )
128 : {
129 0 : if ( bMouseLeave )
130 0 : return sal_True;
131 :
132 0 : if ( !pFloat || (nHitTest & IMPL_FLOATWIN_HITTEST_RECT) )
133 : {
134 0 : if ( pSVData->maHelpData.mpHelpWin && !pSVData->maHelpData.mbKeyboardHelp )
135 0 : ImplDestroyHelpWindow( true );
136 0 : pChild->ImplGetFrame()->SetPointer( POINTER_ARROW );
137 0 : return sal_True;
138 : }
139 : }
140 : else
141 : {
142 0 : if ( nCode & MOUSE_LEFT )
143 : {
144 0 : if ( nSVEvent == EVENT_MOUSEBUTTONDOWN )
145 : {
146 0 : if ( !pFloat )
147 : {
148 0 : pLastLevelFloat = pSVData->maWinData.mpFirstFloat->ImplFindLastLevelFloat();
149 0 : nPopupFlags = pLastLevelFloat->GetPopupModeFlags();
150 0 : pLastLevelFloat->EndPopupMode( FLOATWIN_POPUPMODEEND_CANCEL | FLOATWIN_POPUPMODEEND_CLOSEALL );
151 : // Erstmal ausgebaut als Hack fuer Bug 53378
152 : // if ( nPopupFlags & FLOATWIN_POPUPMODE_PATHMOUSECANCELCLICK )
153 : // return sal_False;
154 : // else
155 0 : return sal_True;
156 : }
157 0 : else if ( nHitTest & IMPL_FLOATWIN_HITTEST_RECT )
158 : {
159 0 : if ( !(pFloat->GetPopupModeFlags() & FLOATWIN_POPUPMODE_NOMOUSERECTCLOSE) )
160 0 : pFloat->ImplSetMouseDown();
161 0 : return sal_True;
162 : }
163 : }
164 : else
165 : {
166 0 : if ( pFloat )
167 : {
168 0 : if ( nHitTest & IMPL_FLOATWIN_HITTEST_RECT )
169 : {
170 0 : if ( pFloat->ImplIsMouseDown() )
171 0 : pFloat->EndPopupMode( FLOATWIN_POPUPMODEEND_CANCEL );
172 0 : return sal_True;
173 : }
174 : }
175 : else
176 : {
177 0 : pLastLevelFloat = pSVData->maWinData.mpFirstFloat->ImplFindLastLevelFloat();
178 0 : nPopupFlags = pLastLevelFloat->GetPopupModeFlags();
179 0 : if ( !(nPopupFlags & FLOATWIN_POPUPMODE_NOMOUSEUPCLOSE) )
180 : {
181 0 : pLastLevelFloat->EndPopupMode( FLOATWIN_POPUPMODEEND_CANCEL | FLOATWIN_POPUPMODEEND_CLOSEALL );
182 0 : return sal_True;
183 : }
184 : }
185 : }
186 : }
187 : else
188 : {
189 0 : if ( !pFloat )
190 : {
191 0 : pLastLevelFloat = pSVData->maWinData.mpFirstFloat->ImplFindLastLevelFloat();
192 0 : nPopupFlags = pLastLevelFloat->GetPopupModeFlags();
193 0 : if ( nPopupFlags & FLOATWIN_POPUPMODE_ALLMOUSEBUTTONCLOSE )
194 : {
195 0 : if ( (nPopupFlags & FLOATWIN_POPUPMODE_NOMOUSEUPCLOSE) &&
196 : (nSVEvent == EVENT_MOUSEBUTTONUP) )
197 0 : return sal_True;
198 0 : pLastLevelFloat->EndPopupMode( FLOATWIN_POPUPMODEEND_CANCEL | FLOATWIN_POPUPMODEEND_CLOSEALL );
199 0 : if ( nPopupFlags & FLOATWIN_POPUPMODE_PATHMOUSECANCELCLICK )
200 0 : return sal_False;
201 : else
202 0 : return sal_True;
203 : }
204 : else
205 0 : return sal_True;
206 : }
207 : }
208 : }
209 : }
210 :
211 0 : return sal_False;
212 : }
213 :
214 : // -----------------------------------------------------------------------
215 :
216 0 : static void ImplHandleMouseHelpRequest( Window* pChild, const Point& rMousePos )
217 : {
218 0 : ImplSVData* pSVData = ImplGetSVData();
219 0 : if ( !pSVData->maHelpData.mpHelpWin ||
220 0 : !( pSVData->maHelpData.mpHelpWin->IsWindowOrChild( pChild ) ||
221 0 : pChild->IsWindowOrChild( pSVData->maHelpData.mpHelpWin ) ) )
222 : {
223 0 : sal_uInt16 nHelpMode = 0;
224 0 : if ( pSVData->maHelpData.mbQuickHelp )
225 0 : nHelpMode = HELPMODE_QUICK;
226 0 : if ( pSVData->maHelpData.mbBalloonHelp )
227 0 : nHelpMode |= HELPMODE_BALLOON;
228 0 : if ( nHelpMode )
229 : {
230 0 : if ( pChild->IsInputEnabled() && !pChild->IsInModalNonRefMode() )
231 : {
232 0 : HelpEvent aHelpEvent( rMousePos, nHelpMode );
233 0 : pSVData->maHelpData.mbRequestingHelp = sal_True;
234 0 : pChild->RequestHelp( aHelpEvent );
235 0 : pSVData->maHelpData.mbRequestingHelp = sal_False;
236 : }
237 : // #104172# do not kill keyboard activated tooltips
238 0 : else if ( pSVData->maHelpData.mpHelpWin && !pSVData->maHelpData.mbKeyboardHelp)
239 : {
240 0 : ImplDestroyHelpWindow( true );
241 : }
242 : }
243 : }
244 0 : }
245 :
246 : // -----------------------------------------------------------------------
247 :
248 0 : static void ImplSetMousePointer( Window* pChild )
249 : {
250 0 : ImplSVData* pSVData = ImplGetSVData();
251 0 : if ( pSVData->maHelpData.mbExtHelpMode )
252 0 : pChild->ImplGetFrame()->SetPointer( POINTER_HELP );
253 : else
254 0 : pChild->ImplGetFrame()->SetPointer( pChild->ImplGetMousePointer() );
255 0 : }
256 :
257 : // -----------------------------------------------------------------------
258 :
259 0 : static sal_Bool ImplCallCommand( Window* pChild, sal_uInt16 nEvt, void* pData = NULL,
260 : sal_Bool bMouse = sal_False, Point* pPos = NULL )
261 : {
262 0 : Point aPos;
263 0 : if ( pPos )
264 0 : aPos = *pPos;
265 : else
266 : {
267 0 : if( bMouse )
268 0 : aPos = pChild->GetPointerPosPixel();
269 : else
270 : {
271 : // simulate mouseposition at center of window
272 0 : Size aSize( pChild->GetOutputSizePixel() );
273 0 : aPos = Point( aSize.getWidth()/2, aSize.getHeight()/2 );
274 : }
275 : }
276 :
277 0 : CommandEvent aCEvt( aPos, nEvt, bMouse, pData );
278 0 : NotifyEvent aNCmdEvt( EVENT_COMMAND, pChild, &aCEvt );
279 0 : ImplDelData aDelData( pChild );
280 0 : sal_Bool bPreNotify = (ImplCallPreNotify( aNCmdEvt ) != 0);
281 0 : if ( aDelData.IsDead() )
282 0 : return sal_False;
283 0 : if ( !bPreNotify )
284 : {
285 0 : pChild->ImplGetWindowImpl()->mbCommand = sal_False;
286 0 : pChild->Command( aCEvt );
287 :
288 0 : if( aDelData.IsDead() )
289 0 : return sal_False;
290 0 : pChild->ImplNotifyKeyMouseCommandEventListeners( aNCmdEvt );
291 0 : if ( aDelData.IsDead() )
292 0 : return sal_False;
293 0 : if ( pChild->ImplGetWindowImpl()->mbCommand )
294 0 : return sal_True;
295 : }
296 :
297 0 : return sal_False;
298 : }
299 :
300 : // -----------------------------------------------------------------------
301 :
302 : /* #i34277# delayed context menu activation;
303 : * necessary if there already was a popup menu running.
304 : */
305 :
306 0 : struct ContextMenuEvent
307 : {
308 : Window* pWindow;
309 : ImplDelData aDelData;
310 : Point aChildPos;
311 : };
312 :
313 0 : static long ContextMenuEventLink( void* pCEvent, void* )
314 : {
315 0 : ContextMenuEvent* pEv = (ContextMenuEvent*)pCEvent;
316 :
317 0 : if( ! pEv->aDelData.IsDead() )
318 : {
319 0 : pEv->pWindow->ImplRemoveDel( &pEv->aDelData );
320 0 : ImplCallCommand( pEv->pWindow, COMMAND_CONTEXTMENU, NULL, sal_True, &pEv->aChildPos );
321 : }
322 0 : delete pEv;
323 :
324 0 : return 0;
325 : }
326 :
327 0 : long ImplHandleMouseEvent( Window* pWindow, sal_uInt16 nSVEvent, sal_Bool bMouseLeave,
328 : long nX, long nY, sal_uLong nMsgTime,
329 : sal_uInt16 nCode, sal_uInt16 nMode )
330 : {
331 0 : ImplSVData* pSVData = ImplGetSVData();
332 0 : Point aMousePos( nX, nY );
333 : Window* pChild;
334 : long nRet;
335 : sal_uInt16 nClicks;
336 0 : ImplFrameData* pWinFrameData = pWindow->ImplGetFrameData();
337 0 : sal_uInt16 nOldCode = pWinFrameData->mnMouseCode;
338 :
339 : // we need a mousemove event, befor we get a mousebuttondown or a
340 : // mousebuttonup event
341 0 : if ( (nSVEvent == EVENT_MOUSEBUTTONDOWN) ||
342 : (nSVEvent == EVENT_MOUSEBUTTONUP) )
343 : {
344 0 : if ( (nSVEvent == EVENT_MOUSEBUTTONUP) && pSVData->maHelpData.mbExtHelpMode )
345 0 : Help::EndExtHelp();
346 0 : if ( pSVData->maHelpData.mpHelpWin )
347 : {
348 0 : if( pWindow->ImplGetWindow() == pSVData->maHelpData.mpHelpWin )
349 : {
350 0 : ImplDestroyHelpWindow( false );
351 0 : return 1; // pWindow is dead now - avoid crash!
352 : }
353 : else
354 0 : ImplDestroyHelpWindow( true );
355 : }
356 :
357 0 : if ( (pWinFrameData->mnLastMouseX != nX) ||
358 0 : (pWinFrameData->mnLastMouseY != nY) )
359 : {
360 0 : ImplHandleMouseEvent( pWindow, EVENT_MOUSEMOVE, sal_False, nX, nY, nMsgTime, nCode, nMode );
361 : }
362 : }
363 :
364 : // update frame data
365 0 : pWinFrameData->mnBeforeLastMouseX = pWinFrameData->mnLastMouseX;
366 0 : pWinFrameData->mnBeforeLastMouseY = pWinFrameData->mnLastMouseY;
367 0 : pWinFrameData->mnLastMouseX = nX;
368 0 : pWinFrameData->mnLastMouseY = nY;
369 0 : pWinFrameData->mnMouseCode = nCode;
370 0 : pWinFrameData->mnMouseMode = nMode & ~(MOUSE_SYNTHETIC | MOUSE_MODIFIERCHANGED);
371 0 : if ( bMouseLeave )
372 : {
373 0 : pWinFrameData->mbMouseIn = sal_False;
374 0 : if ( pSVData->maHelpData.mpHelpWin && !pSVData->maHelpData.mbKeyboardHelp )
375 : {
376 0 : ImplDelData aDelData( pWindow );
377 :
378 0 : ImplDestroyHelpWindow( true );
379 :
380 0 : if ( aDelData.IsDead() )
381 0 : return 1; // pWindow is dead now - avoid crash! (#122045#)
382 : }
383 : }
384 : else
385 0 : pWinFrameData->mbMouseIn = sal_True;
386 :
387 : DBG_ASSERT( !pSVData->maWinData.mpTrackWin ||
388 : (pSVData->maWinData.mpTrackWin == pSVData->maWinData.mpCaptureWin),
389 : "ImplHandleMouseEvent: TrackWin != CaptureWin" );
390 :
391 : // AutoScrollMode
392 0 : if ( pSVData->maWinData.mpAutoScrollWin && (nSVEvent == EVENT_MOUSEBUTTONDOWN) )
393 : {
394 0 : pSVData->maWinData.mpAutoScrollWin->EndAutoScroll();
395 0 : return 1;
396 : }
397 :
398 : // find mouse window
399 0 : if ( pSVData->maWinData.mpCaptureWin )
400 : {
401 0 : pChild = pSVData->maWinData.mpCaptureWin;
402 :
403 : DBG_ASSERT( pWindow == pChild->ImplGetFrameWindow(),
404 : "ImplHandleMouseEvent: mouse event is not sent to capture window" );
405 :
406 : // java client cannot capture mouse correctly
407 0 : if ( pWindow != pChild->ImplGetFrameWindow() )
408 0 : return 0;
409 :
410 0 : if ( bMouseLeave )
411 0 : return 0;
412 : }
413 : else
414 : {
415 0 : if ( bMouseLeave )
416 0 : pChild = NULL;
417 : else
418 0 : pChild = pWindow->ImplFindWindow( aMousePos );
419 : }
420 :
421 : // test this because mouse events are buffered in the remote version
422 : // and size may not be in sync
423 0 : if ( !pChild && !bMouseLeave )
424 0 : return 0;
425 :
426 : // execute a few tests and catch the message or implement the status
427 0 : if ( pChild )
428 : {
429 0 : if( pChild->ImplIsAntiparallel() )
430 : {
431 : // - RTL - re-mirror frame pos at pChild
432 0 : pChild->ImplReMirror( aMousePos );
433 : }
434 : // no mouse messages to system object windows ?
435 : // !!!KA: Is it OK to comment this out? !!!
436 : // if ( pChild->ImplGetWindowImpl()->mpSysObj )
437 : // return 0;
438 :
439 : // no mouse messages to disabled windows
440 : // #106845# if the window was disabed during capturing we have to pass the mouse events to release capturing
441 0 : if ( pSVData->maWinData.mpCaptureWin != pChild && (!pChild->IsEnabled() || !pChild->IsInputEnabled() || pChild->IsInModalNonRefMode() ) )
442 : {
443 0 : ImplHandleMouseFloatMode( pChild, aMousePos, nCode, nSVEvent, bMouseLeave );
444 0 : if ( nSVEvent == EVENT_MOUSEMOVE )
445 : {
446 0 : ImplHandleMouseHelpRequest( pChild, aMousePos );
447 0 : if( pWinFrameData->mpMouseMoveWin != pChild )
448 0 : nMode |= MOUSE_ENTERWINDOW;
449 : }
450 :
451 : // Call the hook also, if Window is disabled
452 0 : Point aChildPos = pChild->ImplFrameToOutput( aMousePos );
453 0 : MouseEvent aMEvt( aChildPos, pWinFrameData->mnClickCount, nMode, nCode, nCode );
454 0 : NotifyEvent aNEvt( nSVEvent, pChild, &aMEvt );
455 0 : Application::CallEventHooks( aNEvt );
456 :
457 0 : if( pChild->IsCallHandlersOnInputDisabled() )
458 : {
459 0 : pWinFrameData->mpMouseMoveWin = pChild;
460 0 : pChild->ImplNotifyKeyMouseCommandEventListeners( aNEvt );
461 : }
462 :
463 0 : if ( nSVEvent == EVENT_MOUSEBUTTONDOWN )
464 0 : return 1;
465 : else
466 : {
467 : // Set normal MousePointer for disabled windows
468 0 : if ( nSVEvent == EVENT_MOUSEMOVE )
469 0 : ImplSetMousePointer( pChild );
470 :
471 0 : return 0;
472 : }
473 : }
474 :
475 : // End ExtTextInput-Mode, if the user click in the same TopLevel Window
476 0 : if ( pSVData->maWinData.mpExtTextInputWin &&
477 0 : ((nSVEvent == EVENT_MOUSEBUTTONDOWN) ||
478 : (nSVEvent == EVENT_MOUSEBUTTONUP)) )
479 0 : pSVData->maWinData.mpExtTextInputWin->EndExtTextInput( EXTTEXTINPUT_END_COMPLETE );
480 : }
481 :
482 : // determine mouse event data
483 0 : if ( nSVEvent == EVENT_MOUSEMOVE )
484 : {
485 : // check if MouseMove belongs to same window and if the
486 : // status did not change
487 0 : if ( pChild )
488 : {
489 0 : Point aChildMousePos = pChild->ImplFrameToOutput( aMousePos );
490 0 : if ( !bMouseLeave &&
491 0 : (pChild == pWinFrameData->mpMouseMoveWin) &&
492 0 : (aChildMousePos.X() == pWinFrameData->mnLastMouseWinX) &&
493 0 : (aChildMousePos.Y() == pWinFrameData->mnLastMouseWinY) &&
494 0 : (nOldCode == pWinFrameData->mnMouseCode) )
495 : {
496 : // set mouse pointer anew, as it could have changed
497 : // due to the mode switch
498 0 : ImplSetMousePointer( pChild );
499 0 : return 0;
500 : }
501 :
502 0 : pWinFrameData->mnLastMouseWinX = aChildMousePos.X();
503 0 : pWinFrameData->mnLastMouseWinY = aChildMousePos.Y();
504 : }
505 :
506 : // mouse click
507 0 : nClicks = pWinFrameData->mnClickCount;
508 :
509 : // call Start-Drag handler if required
510 : // Warning: should be called before Move, as otherwise during
511 : // fast mouse movements the applications move to the selection state
512 0 : Window* pMouseDownWin = pWinFrameData->mpMouseDownWin;
513 0 : if ( pMouseDownWin )
514 : {
515 : // check for matching StartDrag mode. We only compare
516 : // the status of the mouse buttons, such that e. g. Mod1 can
517 : // change immediately to the copy mode
518 0 : const MouseSettings& rMSettings = pMouseDownWin->GetSettings().GetMouseSettings();
519 0 : if ( (nCode & (MOUSE_LEFT | MOUSE_RIGHT | MOUSE_MIDDLE)) ==
520 0 : (rMSettings.GetStartDragCode() & (MOUSE_LEFT | MOUSE_RIGHT | MOUSE_MIDDLE)) )
521 : {
522 0 : if ( !pMouseDownWin->ImplGetFrameData()->mbStartDragCalled )
523 : {
524 0 : long nDragW = rMSettings.GetStartDragWidth();
525 0 : long nDragH = rMSettings.GetStartDragWidth();
526 : //long nMouseX = nX;
527 : //long nMouseY = nY;
528 0 : long nMouseX = aMousePos.X(); // #106074# use the possibly re-mirrored coordinates (RTL) ! nX,nY are unmodified !
529 0 : long nMouseY = aMousePos.Y();
530 0 : if ( !(((nMouseX-nDragW) <= pMouseDownWin->ImplGetFrameData()->mnFirstMouseX) &&
531 0 : ((nMouseX+nDragW) >= pMouseDownWin->ImplGetFrameData()->mnFirstMouseX)) ||
532 0 : !(((nMouseY-nDragH) <= pMouseDownWin->ImplGetFrameData()->mnFirstMouseY) &&
533 0 : ((nMouseY+nDragH) >= pMouseDownWin->ImplGetFrameData()->mnFirstMouseY)) )
534 : {
535 0 : pMouseDownWin->ImplGetFrameData()->mbStartDragCalled = sal_True;
536 :
537 : // Check if drag source provides it's own recognizer
538 0 : if( pMouseDownWin->ImplGetFrameData()->mbInternalDragGestureRecognizer )
539 : {
540 : // query DropTarget from child window
541 : ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDragGestureRecognizer > xDragGestureRecognizer =
542 0 : ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDragGestureRecognizer > ( pMouseDownWin->ImplGetWindowImpl()->mxDNDListenerContainer,
543 0 : ::com::sun::star::uno::UNO_QUERY );
544 :
545 0 : if( xDragGestureRecognizer.is() )
546 : {
547 : // retrieve mouse position relative to mouse down window
548 : Point relLoc = pMouseDownWin->ImplFrameToOutput( Point(
549 0 : pMouseDownWin->ImplGetFrameData()->mnFirstMouseX,
550 0 : pMouseDownWin->ImplGetFrameData()->mnFirstMouseY ) );
551 :
552 : // create a uno mouse event out of the available data
553 : ::com::sun::star::awt::MouseEvent aMouseEvent(
554 : static_cast < ::com::sun::star::uno::XInterface * > ( 0 ),
555 : #ifdef MACOSX
556 : nCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2 | KEY_MOD3),
557 : #else
558 : nCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2),
559 : #endif
560 : nCode & (MOUSE_LEFT | MOUSE_RIGHT | MOUSE_MIDDLE),
561 : nMouseX,
562 : nMouseY,
563 : nClicks,
564 0 : sal_False );
565 :
566 0 : sal_uLong nCount = Application::ReleaseSolarMutex();
567 :
568 : // FIXME: where do I get Action from ?
569 0 : ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDragSource > xDragSource = pMouseDownWin->GetDragSource();
570 :
571 0 : if( xDragSource.is() )
572 : {
573 0 : static_cast < DNDListenerContainer * > ( xDragGestureRecognizer.get() )->fireDragGestureEvent( 0,
574 0 : relLoc.X(), relLoc.Y(), xDragSource, ::com::sun::star::uno::makeAny( aMouseEvent ) );
575 : }
576 :
577 0 : Application::AcquireSolarMutex( nCount );
578 0 : }
579 : }
580 : }
581 : }
582 : }
583 : else
584 0 : pMouseDownWin->ImplGetFrameData()->mbStartDragCalled = sal_True;
585 : }
586 :
587 : // test for mouseleave and mouseenter
588 0 : Window* pMouseMoveWin = pWinFrameData->mpMouseMoveWin;
589 0 : if ( pChild != pMouseMoveWin )
590 : {
591 0 : if ( pMouseMoveWin )
592 : {
593 0 : Point aLeaveMousePos = pMouseMoveWin->ImplFrameToOutput( aMousePos );
594 0 : MouseEvent aMLeaveEvt( aLeaveMousePos, nClicks, nMode | MOUSE_LEAVEWINDOW, nCode, nCode );
595 0 : NotifyEvent aNLeaveEvt( EVENT_MOUSEMOVE, pMouseMoveWin, &aMLeaveEvt );
596 0 : ImplDelData aDelData;
597 0 : ImplDelData aDelData2;
598 0 : pWinFrameData->mbInMouseMove = sal_True;
599 0 : pMouseMoveWin->ImplGetWinData()->mbMouseOver = sal_False;
600 0 : pMouseMoveWin->ImplAddDel( &aDelData );
601 :
602 : // A MouseLeave can destroy this window
603 0 : if ( pChild )
604 0 : pChild->ImplAddDel( &aDelData2 );
605 0 : if ( !ImplCallPreNotify( aNLeaveEvt ) )
606 : {
607 0 : pMouseMoveWin->MouseMove( aMLeaveEvt );
608 : // #82968#
609 0 : if( !aDelData.IsDead() )
610 0 : aNLeaveEvt.GetWindow()->ImplNotifyKeyMouseCommandEventListeners( aNLeaveEvt );
611 : }
612 :
613 0 : pWinFrameData->mpMouseMoveWin = NULL;
614 0 : pWinFrameData->mbInMouseMove = sal_False;
615 :
616 0 : if ( pChild )
617 : {
618 0 : if ( aDelData2.IsDead() )
619 0 : pChild = NULL;
620 : else
621 0 : pChild->ImplRemoveDel( &aDelData2 );
622 : }
623 0 : if ( aDelData.IsDead() )
624 0 : return 1;
625 0 : pMouseMoveWin->ImplRemoveDel( &aDelData );
626 : }
627 :
628 0 : nMode |= MOUSE_ENTERWINDOW;
629 : }
630 0 : pWinFrameData->mpMouseMoveWin = pChild;
631 0 : if( pChild )
632 0 : pChild->ImplGetWinData()->mbMouseOver = sal_True;
633 :
634 : // MouseLeave
635 0 : if ( !pChild )
636 0 : return 0;
637 : }
638 : else
639 : {
640 : // mouse click
641 0 : if ( nSVEvent == EVENT_MOUSEBUTTONDOWN )
642 : {
643 0 : const MouseSettings& rMSettings = pChild->GetSettings().GetMouseSettings();
644 0 : sal_uLong nDblClkTime = rMSettings.GetDoubleClickTime();
645 0 : long nDblClkW = rMSettings.GetDoubleClickWidth();
646 0 : long nDblClkH = rMSettings.GetDoubleClickHeight();
647 : //long nMouseX = nX;
648 : //long nMouseY = nY;
649 0 : long nMouseX = aMousePos.X(); // #106074# use the possibly re-mirrored coordinates (RTL) ! nX,nY are unmodified !
650 0 : long nMouseY = aMousePos.Y();
651 :
652 0 : if ( (pChild == pChild->ImplGetFrameData()->mpMouseDownWin) &&
653 0 : (nCode == pChild->ImplGetFrameData()->mnFirstMouseCode) &&
654 0 : ((nMsgTime-pChild->ImplGetFrameData()->mnMouseDownTime) < nDblClkTime) &&
655 0 : ((nMouseX-nDblClkW) <= pChild->ImplGetFrameData()->mnFirstMouseX) &&
656 0 : ((nMouseX+nDblClkW) >= pChild->ImplGetFrameData()->mnFirstMouseX) &&
657 0 : ((nMouseY-nDblClkH) <= pChild->ImplGetFrameData()->mnFirstMouseY) &&
658 0 : ((nMouseY+nDblClkH) >= pChild->ImplGetFrameData()->mnFirstMouseY) )
659 : {
660 0 : pChild->ImplGetFrameData()->mnClickCount++;
661 0 : pChild->ImplGetFrameData()->mbStartDragCalled = sal_True;
662 : }
663 : else
664 : {
665 0 : pChild->ImplGetFrameData()->mpMouseDownWin = pChild;
666 0 : pChild->ImplGetFrameData()->mnClickCount = 1;
667 0 : pChild->ImplGetFrameData()->mnFirstMouseX = nMouseX;
668 0 : pChild->ImplGetFrameData()->mnFirstMouseY = nMouseY;
669 0 : pChild->ImplGetFrameData()->mnFirstMouseCode = nCode;
670 0 : pChild->ImplGetFrameData()->mbStartDragCalled = !((nCode & (MOUSE_LEFT | MOUSE_RIGHT | MOUSE_MIDDLE)) ==
671 0 : (rMSettings.GetStartDragCode() & (MOUSE_LEFT | MOUSE_RIGHT | MOUSE_MIDDLE)));
672 : }
673 0 : pChild->ImplGetFrameData()->mnMouseDownTime = nMsgTime;
674 : }
675 0 : nClicks = pChild->ImplGetFrameData()->mnClickCount;
676 :
677 0 : pSVData->maAppData.mnLastInputTime = Time::GetSystemTicks();
678 : }
679 :
680 : DBG_ASSERT( pChild, "ImplHandleMouseEvent: pChild == NULL" );
681 :
682 : // create mouse event
683 0 : Point aChildPos = pChild->ImplFrameToOutput( aMousePos );
684 0 : MouseEvent aMEvt( aChildPos, nClicks, nMode, nCode, nCode );
685 :
686 : // tracking window gets the mouse events
687 0 : if ( pSVData->maWinData.mpTrackWin )
688 0 : pChild = pSVData->maWinData.mpTrackWin;
689 :
690 : // handle FloatingMode
691 0 : if ( !pSVData->maWinData.mpTrackWin && pSVData->maWinData.mpFirstFloat )
692 : {
693 0 : ImplDelData aDelData;
694 0 : pChild->ImplAddDel( &aDelData );
695 0 : if ( ImplHandleMouseFloatMode( pChild, aMousePos, nCode, nSVEvent, bMouseLeave ) )
696 : {
697 0 : if ( !aDelData.IsDead() )
698 : {
699 0 : pChild->ImplRemoveDel( &aDelData );
700 0 : pChild->ImplGetFrameData()->mbStartDragCalled = sal_True;
701 : }
702 0 : return 1;
703 : }
704 : else
705 0 : pChild->ImplRemoveDel( &aDelData );
706 : }
707 :
708 : // call handler
709 0 : sal_Bool bDrag = sal_False;
710 0 : sal_Bool bCallHelpRequest = sal_True;
711 : DBG_ASSERT( pChild, "ImplHandleMouseEvent: pChild is NULL" );
712 :
713 0 : ImplDelData aDelData;
714 0 : NotifyEvent aNEvt( nSVEvent, pChild, &aMEvt );
715 0 : pChild->ImplAddDel( &aDelData );
716 0 : if ( nSVEvent == EVENT_MOUSEMOVE )
717 0 : pChild->ImplGetFrameData()->mbInMouseMove = sal_True;
718 :
719 : // bring window into foreground on mouseclick
720 0 : if ( nSVEvent == EVENT_MOUSEBUTTONDOWN )
721 : {
722 0 : if( !pSVData->maWinData.mpFirstFloat && // totop for floating windows in popup would change the focus and would close them immediately
723 0 : !(pChild->ImplGetFrameWindow()->GetStyle() & WB_OWNERDRAWDECORATION) ) // ownerdrawdecorated windows must never grab focus
724 0 : pChild->ToTop();
725 0 : if ( aDelData.IsDead() )
726 0 : return 1;
727 : }
728 :
729 0 : if ( ImplCallPreNotify( aNEvt ) || aDelData.IsDead() )
730 0 : nRet = 1;
731 : else
732 : {
733 0 : nRet = 0;
734 0 : if ( nSVEvent == EVENT_MOUSEMOVE )
735 : {
736 0 : if ( pSVData->maWinData.mpTrackWin )
737 : {
738 0 : TrackingEvent aTEvt( aMEvt );
739 0 : pChild->Tracking( aTEvt );
740 0 : if ( !aDelData.IsDead() )
741 : {
742 : // When ScrollRepeat, we restart the timer
743 0 : if ( pSVData->maWinData.mpTrackTimer &&
744 0 : (pSVData->maWinData.mnTrackFlags & STARTTRACK_SCROLLREPEAT) )
745 0 : pSVData->maWinData.mpTrackTimer->Start();
746 : }
747 0 : bCallHelpRequest = sal_False;
748 0 : nRet = 1;
749 : }
750 : else
751 : {
752 : // Auto-ToTop
753 0 : if ( !pSVData->maWinData.mpCaptureWin &&
754 0 : (pChild->GetSettings().GetMouseSettings().GetOptions() & MOUSE_OPTION_AUTOFOCUS) )
755 0 : pChild->ToTop( TOTOP_NOGRABFOCUS );
756 :
757 0 : if( aDelData.IsDead() )
758 0 : bCallHelpRequest = sal_False;
759 : else
760 : {
761 : // if the MouseMove handler changes the help window's visibility
762 : // the HelpRequest handler should not be called anymore
763 0 : Window* pOldHelpTextWin = pSVData->maHelpData.mpHelpWin;
764 0 : pChild->ImplGetWindowImpl()->mbMouseMove = sal_False;
765 0 : pChild->MouseMove( aMEvt );
766 0 : if ( pOldHelpTextWin != pSVData->maHelpData.mpHelpWin )
767 0 : bCallHelpRequest = sal_False;
768 : }
769 : }
770 : }
771 0 : else if ( nSVEvent == EVENT_MOUSEBUTTONDOWN )
772 : {
773 0 : if ( pSVData->maWinData.mpTrackWin &&
774 0 : !(pSVData->maWinData.mnTrackFlags & STARTTRACK_MOUSEBUTTONDOWN) )
775 0 : nRet = 1;
776 : else
777 : {
778 0 : pChild->ImplGetWindowImpl()->mbMouseButtonDown = sal_False;
779 0 : pChild->MouseButtonDown( aMEvt );
780 : }
781 : }
782 : else
783 : {
784 0 : if ( pSVData->maWinData.mpTrackWin )
785 : {
786 0 : pChild->EndTracking();
787 0 : nRet = 1;
788 : }
789 : else
790 : {
791 0 : pChild->ImplGetWindowImpl()->mbMouseButtonUp = sal_False;
792 0 : pChild->MouseButtonUp( aMEvt );
793 : }
794 : }
795 :
796 : // #82968#
797 0 : if ( !aDelData.IsDead() )
798 0 : aNEvt.GetWindow()->ImplNotifyKeyMouseCommandEventListeners( aNEvt );
799 : }
800 :
801 0 : if ( aDelData.IsDead() )
802 0 : return 1;
803 :
804 :
805 0 : if ( nSVEvent == EVENT_MOUSEMOVE )
806 0 : pChild->ImplGetWindowImpl()->mpFrameData->mbInMouseMove = sal_False;
807 :
808 0 : if ( nSVEvent == EVENT_MOUSEMOVE )
809 : {
810 0 : if ( bCallHelpRequest && !pSVData->maHelpData.mbKeyboardHelp )
811 0 : ImplHandleMouseHelpRequest( pChild, pChild->OutputToScreenPixel( aMEvt.GetPosPixel() ) );
812 0 : nRet = 1;
813 : }
814 0 : else if ( !nRet )
815 : {
816 0 : if ( nSVEvent == EVENT_MOUSEBUTTONDOWN )
817 : {
818 0 : if ( !pChild->ImplGetWindowImpl()->mbMouseButtonDown )
819 0 : nRet = 1;
820 : }
821 : else
822 : {
823 0 : if ( !pChild->ImplGetWindowImpl()->mbMouseButtonUp )
824 0 : nRet = 1;
825 : }
826 : }
827 :
828 0 : pChild->ImplRemoveDel( &aDelData );
829 :
830 0 : if ( nSVEvent == EVENT_MOUSEMOVE )
831 : {
832 : // set new mouse pointer
833 0 : if ( !bMouseLeave )
834 0 : ImplSetMousePointer( pChild );
835 : }
836 0 : else if ( (nSVEvent == EVENT_MOUSEBUTTONDOWN) || (nSVEvent == EVENT_MOUSEBUTTONUP) )
837 : {
838 0 : if ( !bDrag )
839 : {
840 : // Command-Events
841 0 : if ( /*(nRet == 0) &&*/ (nClicks == 1) && (nSVEvent == EVENT_MOUSEBUTTONDOWN) &&
842 : (nCode == MOUSE_MIDDLE) )
843 : {
844 0 : sal_uInt16 nMiddleAction = pChild->GetSettings().GetMouseSettings().GetMiddleButtonAction();
845 0 : if ( nMiddleAction == MOUSE_MIDDLE_AUTOSCROLL )
846 0 : nRet = !ImplCallCommand( pChild, COMMAND_STARTAUTOSCROLL, NULL, sal_True, &aChildPos );
847 0 : else if ( nMiddleAction == MOUSE_MIDDLE_PASTESELECTION )
848 0 : nRet = !ImplCallCommand( pChild, COMMAND_PASTESELECTION, NULL, sal_True, &aChildPos );
849 : }
850 : else
851 : {
852 : // ContextMenu
853 0 : const MouseSettings& rMSettings = pChild->GetSettings().GetMouseSettings();
854 0 : if ( (nCode == rMSettings.GetContextMenuCode()) &&
855 0 : (nClicks == rMSettings.GetContextMenuClicks()) )
856 : {
857 : sal_Bool bContextMenu;
858 0 : if ( rMSettings.GetContextMenuDown() )
859 0 : bContextMenu = (nSVEvent == EVENT_MOUSEBUTTONDOWN);
860 : else
861 0 : bContextMenu = (nSVEvent == EVENT_MOUSEBUTTONUP);
862 0 : if ( bContextMenu )
863 : {
864 0 : if( pSVData->maAppData.mpActivePopupMenu )
865 : {
866 : /* #i34277# there already is a context menu open
867 : * that was probably just closed with EndPopupMode.
868 : * We need to give the eventual corresponding
869 : * PopupMenu::Execute a chance to end properly.
870 : * Therefore delay context menu command and
871 : * issue only after popping one frame of the
872 : * Yield stack.
873 : */
874 0 : ContextMenuEvent* pEv = new ContextMenuEvent;
875 0 : pEv->pWindow = pChild;
876 0 : pEv->aChildPos = aChildPos;
877 0 : pChild->ImplAddDel( &pEv->aDelData );
878 0 : Application::PostUserEvent( Link( pEv, ContextMenuEventLink ) );
879 : }
880 : else
881 0 : nRet = ! ImplCallCommand( pChild, COMMAND_CONTEXTMENU, NULL, sal_True, &aChildPos );
882 : }
883 : }
884 : }
885 : }
886 : }
887 :
888 0 : return nRet;
889 : }
890 :
891 : // -----------------------------------------------------------------------
892 :
893 0 : static Window* ImplGetKeyInputWindow( Window* pWindow )
894 : {
895 0 : ImplSVData* pSVData = ImplGetSVData();
896 :
897 : // determine last input time
898 0 : pSVData->maAppData.mnLastInputTime = Time::GetSystemTicks();
899 :
900 : // #127104# workaround for destroyed windows
901 0 : if( pWindow->ImplGetWindowImpl() == NULL )
902 0 : return 0;
903 :
904 : // find window - is every time the window which has currently the
905 : // focus or the last time the focus.
906 : // the first floating window always has the focus
907 0 : Window* pChild = pSVData->maWinData.mpFirstFloat;
908 0 : if( !pChild || ( pChild->ImplGetWindowImpl()->mbFloatWin && !((FloatingWindow *)pChild)->GrabsFocus() ) )
909 0 : pChild = pWindow->ImplGetWindowImpl()->mpFrameData->mpFocusWin;
910 : else
911 : {
912 : // allow floaters to forward keyinput to some member
913 0 : pChild = pChild->GetPreferredKeyInputWindow();
914 : }
915 :
916 : // no child - than no input
917 0 : if ( !pChild )
918 0 : return 0;
919 :
920 : // We call also KeyInput if we haven't the focus, because on Unix
921 : // system this is often the case when a Lookup Choise Window has
922 : // the focus - because this windows send the KeyInput directly to
923 : // the window without resetting the focus
924 : DBG_ASSERTWARNING( pChild == pSVData->maWinData.mpFocusWin,
925 : "ImplHandleKey: Keyboard-Input is sent to a frame without focus" );
926 :
927 : // no keyinput to disabled windows
928 0 : if ( !pChild->IsEnabled() || !pChild->IsInputEnabled() || pChild->IsInModalMode() )
929 0 : return 0;
930 :
931 0 : return pChild;
932 : }
933 :
934 : // -----------------------------------------------------------------------
935 :
936 0 : static long ImplHandleKey( Window* pWindow, sal_uInt16 nSVEvent,
937 : sal_uInt16 nKeyCode, sal_uInt16 nCharCode, sal_uInt16 nRepeat, sal_Bool bForward )
938 : {
939 0 : ImplSVData* pSVData = ImplGetSVData();
940 0 : KeyCode aKeyCode( nKeyCode, nKeyCode );
941 0 : sal_uInt16 nEvCode = aKeyCode.GetCode();
942 :
943 : // allow application key listeners to remove the key event
944 : // but make sure we're not forwarding external KeyEvents, (ie where bForward is sal_False)
945 : // because those are coming back from the listener itself and MUST be processed
946 0 : KeyEvent aKeyEvent( (sal_Unicode)nCharCode, aKeyCode, nRepeat );
947 0 : if( bForward )
948 : {
949 : sal_uInt16 nVCLEvent;
950 0 : switch( nSVEvent )
951 : {
952 : case EVENT_KEYINPUT:
953 0 : nVCLEvent = VCLEVENT_WINDOW_KEYINPUT;
954 0 : break;
955 : case EVENT_KEYUP:
956 0 : nVCLEvent = VCLEVENT_WINDOW_KEYUP;
957 0 : break;
958 : default:
959 0 : nVCLEvent = 0;
960 0 : break;
961 : }
962 0 : if( nVCLEvent && pSVData->mpApp->HandleKey( nVCLEvent, pWindow, &aKeyEvent ) )
963 0 : return 1;
964 : }
965 :
966 : // #i1820# use locale specific decimal separator
967 0 : if( nEvCode == KEY_DECIMAL )
968 : {
969 0 : if( Application::GetSettings().GetMiscSettings().GetEnableLocalizedDecimalSep() )
970 : {
971 0 : String aSep( pWindow->GetSettings().GetLocaleDataWrapper().getNumDecimalSep() );
972 0 : nCharCode = (sal_uInt16) aSep.GetChar(0);
973 : }
974 : }
975 :
976 0 : sal_Bool bCtrlF6 = (aKeyCode.GetCode() == KEY_F6) && aKeyCode.IsMod1();
977 :
978 : // determine last input time
979 0 : pSVData->maAppData.mnLastInputTime = Time::GetSystemTicks();
980 :
981 : // handle tracking window
982 0 : if ( nSVEvent == EVENT_KEYINPUT )
983 : {
984 : #ifdef DBG_UTIL
985 : // #105224# use Ctrl-Alt-Shift-D, Ctrl-Shift-D must be useable by app
986 : if ( aKeyCode.IsShift() && aKeyCode.IsMod1() && (aKeyCode.IsMod2() || aKeyCode.IsMod3()) && (aKeyCode.GetCode() == KEY_D) )
987 : {
988 : DBGGUI_START();
989 : return 1;
990 : }
991 : #endif
992 :
993 0 : if ( pSVData->maHelpData.mbExtHelpMode )
994 : {
995 0 : Help::EndExtHelp();
996 0 : if ( nEvCode == KEY_ESCAPE )
997 0 : return 1;
998 : }
999 0 : if ( pSVData->maHelpData.mpHelpWin )
1000 0 : ImplDestroyHelpWindow( false );
1001 :
1002 : // AutoScrollMode
1003 0 : if ( pSVData->maWinData.mpAutoScrollWin )
1004 : {
1005 0 : pSVData->maWinData.mpAutoScrollWin->EndAutoScroll();
1006 0 : if ( nEvCode == KEY_ESCAPE )
1007 0 : return 1;
1008 : }
1009 :
1010 0 : if ( pSVData->maWinData.mpTrackWin )
1011 : {
1012 0 : sal_uInt16 nOrigCode = aKeyCode.GetCode();
1013 :
1014 0 : if ( (nOrigCode == KEY_ESCAPE) && !(pSVData->maWinData.mnTrackFlags & STARTTRACK_NOKEYCANCEL) )
1015 : {
1016 0 : pSVData->maWinData.mpTrackWin->EndTracking( ENDTRACK_CANCEL | ENDTRACK_KEY );
1017 0 : if ( pSVData->maWinData.mpFirstFloat )
1018 : {
1019 0 : FloatingWindow* pLastLevelFloat = pSVData->maWinData.mpFirstFloat->ImplFindLastLevelFloat();
1020 0 : if ( !(pLastLevelFloat->GetPopupModeFlags() & FLOATWIN_POPUPMODE_NOKEYCLOSE) )
1021 : {
1022 0 : sal_uInt16 nEscCode = aKeyCode.GetCode();
1023 :
1024 0 : if ( nEscCode == KEY_ESCAPE )
1025 0 : pLastLevelFloat->EndPopupMode( FLOATWIN_POPUPMODEEND_CANCEL | FLOATWIN_POPUPMODEEND_CLOSEALL );
1026 : }
1027 : }
1028 0 : return 1;
1029 : }
1030 0 : else if ( nOrigCode == KEY_RETURN )
1031 : {
1032 0 : pSVData->maWinData.mpTrackWin->EndTracking( ENDTRACK_KEY );
1033 0 : return 1;
1034 : }
1035 0 : else if ( !(pSVData->maWinData.mnTrackFlags & STARTTRACK_KEYINPUT) )
1036 0 : return 1;
1037 : }
1038 :
1039 : // handle FloatingMode
1040 0 : if ( pSVData->maWinData.mpFirstFloat )
1041 : {
1042 0 : FloatingWindow* pLastLevelFloat = pSVData->maWinData.mpFirstFloat->ImplFindLastLevelFloat();
1043 0 : if ( !(pLastLevelFloat->GetPopupModeFlags() & FLOATWIN_POPUPMODE_NOKEYCLOSE) )
1044 : {
1045 0 : sal_uInt16 nCode = aKeyCode.GetCode();
1046 :
1047 0 : if ( (nCode == KEY_ESCAPE) || bCtrlF6)
1048 : {
1049 0 : pLastLevelFloat->EndPopupMode( FLOATWIN_POPUPMODEEND_CANCEL | FLOATWIN_POPUPMODEEND_CLOSEALL );
1050 0 : if( !bCtrlF6 )
1051 0 : return 1;
1052 : }
1053 : }
1054 : }
1055 :
1056 : // test for accel
1057 0 : if ( pSVData->maAppData.mpAccelMgr )
1058 : {
1059 0 : if ( pSVData->maAppData.mpAccelMgr->IsAccelKey( aKeyCode, nRepeat ) )
1060 0 : return 1;
1061 : }
1062 : }
1063 :
1064 : // find window
1065 0 : Window* pChild = ImplGetKeyInputWindow( pWindow );
1066 0 : if ( !pChild )
1067 0 : return 0;
1068 :
1069 : // --- RTL --- mirror cursor keys
1070 0 : if( (aKeyCode.GetCode() == KEY_LEFT || aKeyCode.GetCode() == KEY_RIGHT) &&
1071 0 : pChild->ImplHasMirroredGraphics() && pChild->IsRTLEnabled() )
1072 0 : aKeyCode = KeyCode( aKeyCode.GetCode() == KEY_LEFT ? KEY_RIGHT : KEY_LEFT, aKeyCode.GetModifier() );
1073 :
1074 : // call handler
1075 0 : ImplDelData aDelData;
1076 0 : pChild->ImplAddDel( &aDelData );
1077 :
1078 0 : KeyEvent aKeyEvt( (sal_Unicode)nCharCode, aKeyCode, nRepeat );
1079 0 : NotifyEvent aNotifyEvt( nSVEvent, pChild, &aKeyEvt );
1080 0 : sal_Bool bKeyPreNotify = (ImplCallPreNotify( aNotifyEvt ) != 0);
1081 0 : long nRet = 1;
1082 :
1083 0 : if ( !bKeyPreNotify && !aDelData.IsDead() )
1084 : {
1085 0 : if ( nSVEvent == EVENT_KEYINPUT )
1086 : {
1087 0 : pChild->ImplGetWindowImpl()->mbKeyInput = sal_False;
1088 0 : pChild->KeyInput( aKeyEvt );
1089 : }
1090 : else
1091 : {
1092 0 : pChild->ImplGetWindowImpl()->mbKeyUp = sal_False;
1093 0 : pChild->KeyUp( aKeyEvt );
1094 : }
1095 : // #82968#
1096 0 : if( !aDelData.IsDead() )
1097 0 : aNotifyEvt.GetWindow()->ImplNotifyKeyMouseCommandEventListeners( aNotifyEvt );
1098 : }
1099 :
1100 0 : if ( aDelData.IsDead() )
1101 0 : return 1;
1102 :
1103 0 : pChild->ImplRemoveDel( &aDelData );
1104 :
1105 0 : if ( nSVEvent == EVENT_KEYINPUT )
1106 : {
1107 0 : if ( !bKeyPreNotify && pChild->ImplGetWindowImpl()->mbKeyInput )
1108 : {
1109 0 : sal_uInt16 nCode = aKeyCode.GetCode();
1110 :
1111 : // #101999# is focus in or below toolbox
1112 0 : sal_Bool bToolboxFocus=sal_False;
1113 0 : if( (nCode == KEY_F1) && aKeyCode.IsShift() )
1114 : {
1115 0 : Window *pWin = pWindow->ImplGetWindowImpl()->mpFrameData->mpFocusWin;
1116 0 : while( pWin )
1117 : {
1118 0 : if( pWin->ImplGetWindowImpl()->mbToolBox )
1119 : {
1120 0 : bToolboxFocus = sal_True;
1121 0 : break;
1122 : }
1123 : else
1124 0 : pWin = pWin->GetParent();
1125 : }
1126 : }
1127 :
1128 : // ContextMenu
1129 0 : if ( (nCode == KEY_CONTEXTMENU) || ((nCode == KEY_F10) && aKeyCode.IsShift() && !aKeyCode.IsMod1() && !aKeyCode.IsMod2() ) )
1130 0 : nRet = !ImplCallCommand( pChild, COMMAND_CONTEXTMENU, NULL, sal_False );
1131 0 : else if ( ( (nCode == KEY_F2) && aKeyCode.IsShift() ) || ( (nCode == KEY_F1) && aKeyCode.IsMod1() ) ||
1132 : // #101999# no active help when focus in toolbox, simulate BallonHelp instead
1133 0 : ( (nCode == KEY_F1) && aKeyCode.IsShift() && bToolboxFocus ) )
1134 : {
1135 : // TipHelp via Keyboard (Shift-F2 or Ctrl-F1)
1136 : // simulate mouseposition at center of window
1137 :
1138 0 : Size aSize = pChild->GetOutputSize();
1139 0 : Point aPos = Point( aSize.getWidth()/2, aSize.getHeight()/2 );
1140 0 : aPos = pChild->OutputToScreenPixel( aPos );
1141 :
1142 0 : HelpEvent aHelpEvent( aPos, HELPMODE_BALLOON );
1143 0 : aHelpEvent.SetKeyboardActivated( sal_True );
1144 0 : pSVData->maHelpData.mbSetKeyboardHelp = sal_True;
1145 0 : pChild->RequestHelp( aHelpEvent );
1146 0 : pSVData->maHelpData.mbSetKeyboardHelp = sal_False;
1147 : }
1148 0 : else if ( (nCode == KEY_F1) || (nCode == KEY_HELP) )
1149 : {
1150 0 : if ( !aKeyCode.GetModifier() )
1151 : {
1152 0 : if ( pSVData->maHelpData.mbContextHelp )
1153 : {
1154 0 : Point aMousePos = pChild->OutputToScreenPixel( pChild->GetPointerPosPixel() );
1155 0 : HelpEvent aHelpEvent( aMousePos, HELPMODE_CONTEXT );
1156 0 : pChild->RequestHelp( aHelpEvent );
1157 : }
1158 : else
1159 0 : nRet = 0;
1160 : }
1161 0 : else if ( aKeyCode.IsShift() )
1162 : {
1163 0 : if ( pSVData->maHelpData.mbExtHelp )
1164 0 : Help::StartExtHelp();
1165 : else
1166 0 : nRet = 0;
1167 0 : }
1168 : }
1169 : else
1170 : {
1171 0 : if ( ImplCallHotKey( aKeyCode ) )
1172 0 : nRet = 1;
1173 : else
1174 0 : nRet = 0;
1175 : }
1176 : }
1177 : }
1178 : else
1179 : {
1180 0 : if ( !bKeyPreNotify && pChild->ImplGetWindowImpl()->mbKeyUp )
1181 0 : nRet = 0;
1182 : }
1183 :
1184 : // #105591# send keyinput to parent if we are a floating window and the key was not pocessed yet
1185 0 : if( !nRet && pWindow->ImplGetWindowImpl()->mbFloatWin && pWindow->GetParent() && (pWindow->ImplGetWindowImpl()->mpFrame != pWindow->GetParent()->ImplGetWindowImpl()->mpFrame) )
1186 : {
1187 0 : pChild = pWindow->GetParent();
1188 :
1189 : // call handler
1190 0 : ImplDelData aChildDelData( pChild );
1191 0 : KeyEvent aKEvt( (sal_Unicode)nCharCode, aKeyCode, nRepeat );
1192 0 : NotifyEvent aNEvt( nSVEvent, pChild, &aKEvt );
1193 0 : sal_Bool bPreNotify = (ImplCallPreNotify( aNEvt ) != 0);
1194 0 : if ( aChildDelData.IsDead() )
1195 0 : return 1;
1196 :
1197 0 : if ( !bPreNotify )
1198 : {
1199 0 : if ( nSVEvent == EVENT_KEYINPUT )
1200 : {
1201 0 : pChild->ImplGetWindowImpl()->mbKeyInput = sal_False;
1202 0 : pChild->KeyInput( aKEvt );
1203 : }
1204 : else
1205 : {
1206 0 : pChild->ImplGetWindowImpl()->mbKeyUp = sal_False;
1207 0 : pChild->KeyUp( aKEvt );
1208 : }
1209 : // #82968#
1210 0 : if( !aChildDelData.IsDead() )
1211 0 : aNEvt.GetWindow()->ImplNotifyKeyMouseCommandEventListeners( aNEvt );
1212 0 : if ( aChildDelData.IsDead() )
1213 0 : return 1;
1214 : }
1215 :
1216 0 : if( bPreNotify || !pChild->ImplGetWindowImpl()->mbKeyInput )
1217 0 : nRet = 1;
1218 : }
1219 :
1220 0 : return nRet;
1221 : }
1222 :
1223 : // -----------------------------------------------------------------------
1224 :
1225 0 : static long ImplHandleExtTextInput( Window* pWindow,
1226 : const XubString& rText,
1227 : const sal_uInt16* pTextAttr,
1228 : sal_uLong nCursorPos, sal_uInt16 nCursorFlags )
1229 : {
1230 0 : ImplSVData* pSVData = ImplGetSVData();
1231 0 : Window* pChild = NULL;
1232 :
1233 0 : int nTries = 200;
1234 0 : while( nTries-- )
1235 : {
1236 0 : pChild = pSVData->maWinData.mpExtTextInputWin;
1237 0 : if ( !pChild )
1238 : {
1239 0 : pChild = ImplGetKeyInputWindow( pWindow );
1240 0 : if ( !pChild )
1241 0 : return 0;
1242 : }
1243 0 : if( !pChild->ImplGetWindowImpl()->mpFrameData->mnFocusId )
1244 0 : break;
1245 0 : Application::Yield();
1246 : }
1247 :
1248 : // If it is the first ExtTextInput call, we inform the information
1249 : // and allocate the data, which we must store in this mode
1250 0 : ImplWinData* pWinData = pChild->ImplGetWinData();
1251 0 : if ( !pChild->ImplGetWindowImpl()->mbExtTextInput )
1252 : {
1253 0 : pChild->ImplGetWindowImpl()->mbExtTextInput = sal_True;
1254 0 : pWinData->mpExtOldText = new OUString;
1255 0 : if ( pWinData->mpExtOldAttrAry )
1256 : {
1257 0 : delete [] pWinData->mpExtOldAttrAry;
1258 0 : pWinData->mpExtOldAttrAry = NULL;
1259 : }
1260 0 : pSVData->maWinData.mpExtTextInputWin = pChild;
1261 0 : ImplCallCommand( pChild, COMMAND_STARTEXTTEXTINPUT );
1262 : }
1263 :
1264 : // be aware of being recursively called in StartExtTextInput
1265 0 : if ( !pChild->ImplGetWindowImpl()->mbExtTextInput )
1266 0 : return 0;
1267 :
1268 : // Test for changes
1269 0 : sal_Bool bOnlyCursor = sal_False;
1270 0 : xub_StrLen nMinLen = std::min( pWinData->mpExtOldText->getLength(), sal_Int32(rText.Len()) );
1271 0 : xub_StrLen nDeltaStart = 0;
1272 0 : while ( nDeltaStart < nMinLen )
1273 : {
1274 0 : if ( (*pWinData->mpExtOldText)[nDeltaStart] != rText.GetChar( nDeltaStart ) )
1275 0 : break;
1276 0 : nDeltaStart++;
1277 : }
1278 0 : if ( pWinData->mpExtOldAttrAry || pTextAttr )
1279 : {
1280 0 : if ( !pWinData->mpExtOldAttrAry || !pTextAttr )
1281 0 : nDeltaStart = 0;
1282 : else
1283 : {
1284 0 : xub_StrLen i = 0;
1285 0 : while ( i < nDeltaStart )
1286 : {
1287 0 : if ( pWinData->mpExtOldAttrAry[i] != pTextAttr[i] )
1288 : {
1289 0 : nDeltaStart = i;
1290 0 : break;
1291 : }
1292 0 : i++;
1293 : }
1294 : }
1295 : }
1296 0 : if ( (nDeltaStart >= nMinLen) &&
1297 0 : (pWinData->mpExtOldText->getLength() == rText.Len()) )
1298 0 : bOnlyCursor = sal_True;
1299 :
1300 : // Call Event and store the information
1301 : CommandExtTextInputData aData( rText, pTextAttr,
1302 : (xub_StrLen)nCursorPos, nCursorFlags,
1303 0 : nDeltaStart, pWinData->mpExtOldText->getLength(),
1304 0 : bOnlyCursor );
1305 0 : *pWinData->mpExtOldText = rText;
1306 0 : if ( pWinData->mpExtOldAttrAry )
1307 : {
1308 0 : delete [] pWinData->mpExtOldAttrAry;
1309 0 : pWinData->mpExtOldAttrAry = NULL;
1310 : }
1311 0 : if ( pTextAttr )
1312 : {
1313 0 : pWinData->mpExtOldAttrAry = new sal_uInt16[rText.Len()];
1314 0 : memcpy( pWinData->mpExtOldAttrAry, pTextAttr, rText.Len()*sizeof( sal_uInt16 ) );
1315 : }
1316 0 : return !ImplCallCommand( pChild, COMMAND_EXTTEXTINPUT, &aData );
1317 : }
1318 :
1319 : // -----------------------------------------------------------------------
1320 :
1321 0 : static long ImplHandleEndExtTextInput( Window* /* pWindow */ )
1322 : {
1323 0 : ImplSVData* pSVData = ImplGetSVData();
1324 0 : Window* pChild = pSVData->maWinData.mpExtTextInputWin;
1325 0 : long nRet = 0;
1326 :
1327 0 : if ( pChild )
1328 : {
1329 0 : pChild->ImplGetWindowImpl()->mbExtTextInput = sal_False;
1330 0 : pSVData->maWinData.mpExtTextInputWin = NULL;
1331 0 : ImplWinData* pWinData = pChild->ImplGetWinData();
1332 0 : if ( pWinData->mpExtOldText )
1333 : {
1334 0 : delete pWinData->mpExtOldText;
1335 0 : pWinData->mpExtOldText = NULL;
1336 : }
1337 0 : if ( pWinData->mpExtOldAttrAry )
1338 : {
1339 0 : delete [] pWinData->mpExtOldAttrAry;
1340 0 : pWinData->mpExtOldAttrAry = NULL;
1341 : }
1342 0 : nRet = !ImplCallCommand( pChild, COMMAND_ENDEXTTEXTINPUT );
1343 : }
1344 :
1345 0 : return nRet;
1346 : }
1347 :
1348 : // -----------------------------------------------------------------------
1349 :
1350 0 : static void ImplHandleExtTextInputPos( Window* pWindow,
1351 : Rectangle& rRect, long& rInputWidth,
1352 : bool * pVertical )
1353 : {
1354 0 : ImplSVData* pSVData = ImplGetSVData();
1355 0 : Window* pChild = pSVData->maWinData.mpExtTextInputWin;
1356 :
1357 0 : if ( !pChild )
1358 0 : pChild = ImplGetKeyInputWindow( pWindow );
1359 : else
1360 : {
1361 : // Test, if the Window is related to the frame
1362 0 : if ( !pWindow->ImplIsWindowOrChild( pChild ) )
1363 0 : pChild = ImplGetKeyInputWindow( pWindow );
1364 : }
1365 :
1366 0 : if ( pChild )
1367 : {
1368 0 : ImplCallCommand( pChild, COMMAND_CURSORPOS );
1369 0 : const Rectangle* pRect = pChild->GetCursorRect();
1370 0 : if ( pRect )
1371 0 : rRect = pChild->ImplLogicToDevicePixel( *pRect );
1372 : else
1373 : {
1374 0 : Cursor* pCursor = pChild->GetCursor();
1375 0 : if ( pCursor )
1376 : {
1377 0 : Point aPos = pChild->ImplLogicToDevicePixel( pCursor->GetPos() );
1378 0 : Size aSize = pChild->LogicToPixel( pCursor->GetSize() );
1379 0 : if ( !aSize.Width() )
1380 0 : aSize.Width() = pChild->GetSettings().GetStyleSettings().GetCursorSize();
1381 0 : rRect = Rectangle( aPos, aSize );
1382 : }
1383 : else
1384 0 : rRect = Rectangle( Point( pChild->GetOutOffXPixel(), pChild->GetOutOffYPixel() ), Size() );
1385 : }
1386 0 : rInputWidth = pChild->ImplLogicWidthToDevicePixel( pChild->GetCursorExtTextInputWidth() );
1387 0 : if ( !rInputWidth )
1388 0 : rInputWidth = rRect.GetWidth();
1389 : }
1390 0 : if (pVertical != 0)
1391 : *pVertical
1392 0 : = pChild != 0 && pChild->GetInputContext().GetFont().IsVertical();
1393 0 : }
1394 :
1395 : // -----------------------------------------------------------------------
1396 :
1397 0 : static long ImplHandleInputContextChange( Window* pWindow, LanguageType eNewLang )
1398 : {
1399 0 : Window* pChild = ImplGetKeyInputWindow( pWindow );
1400 0 : CommandInputContextData aData( eNewLang );
1401 0 : return !ImplCallCommand( pChild, COMMAND_INPUTCONTEXTCHANGE, &aData );
1402 : }
1403 :
1404 : // -----------------------------------------------------------------------
1405 :
1406 0 : static sal_Bool ImplCallWheelCommand( Window* pWindow, const Point& rPos,
1407 : const CommandWheelData* pWheelData )
1408 : {
1409 0 : Point aCmdMousePos = pWindow->ImplFrameToOutput( rPos );
1410 0 : CommandEvent aCEvt( aCmdMousePos, COMMAND_WHEEL, sal_True, pWheelData );
1411 0 : NotifyEvent aNCmdEvt( EVENT_COMMAND, pWindow, &aCEvt );
1412 0 : ImplDelData aDelData( pWindow );
1413 0 : sal_Bool bPreNotify = (ImplCallPreNotify( aNCmdEvt ) != 0);
1414 0 : if ( aDelData.IsDead() )
1415 0 : return sal_False;
1416 0 : if ( !bPreNotify )
1417 : {
1418 0 : pWindow->ImplGetWindowImpl()->mbCommand = sal_False;
1419 0 : pWindow->Command( aCEvt );
1420 0 : if ( aDelData.IsDead() )
1421 0 : return sal_False;
1422 0 : if ( pWindow->ImplGetWindowImpl()->mbCommand )
1423 0 : return sal_True;
1424 : }
1425 0 : return sal_False;
1426 : }
1427 :
1428 : // -----------------------------------------------------------------------
1429 :
1430 0 : static long ImplHandleWheelEvent( Window* pWindow, const SalWheelMouseEvent& rEvt, bool scaleDirectly = false )
1431 : {
1432 0 : ImplDelData aDogTag( pWindow );
1433 :
1434 0 : ImplSVData* pSVData = ImplGetSVData();
1435 0 : if ( pSVData->maWinData.mpAutoScrollWin )
1436 0 : pSVData->maWinData.mpAutoScrollWin->EndAutoScroll();
1437 0 : if ( pSVData->maHelpData.mpHelpWin )
1438 0 : ImplDestroyHelpWindow( true );
1439 0 : if( aDogTag.IsDead() )
1440 0 : return 0;
1441 :
1442 : sal_uInt16 nMode;
1443 0 : sal_uInt16 nCode = rEvt.mnCode;
1444 0 : bool bHorz = rEvt.mbHorz;
1445 0 : bool bPixel = rEvt.mbDeltaIsPixel;
1446 0 : if ( scaleDirectly )
1447 0 : nMode = COMMAND_WHEEL_ZOOM_SCALE;
1448 0 : else if ( nCode & KEY_MOD1 )
1449 0 : nMode = COMMAND_WHEEL_ZOOM;
1450 0 : else if ( nCode & KEY_MOD2 )
1451 0 : nMode = COMMAND_WHEEL_DATAZOOM;
1452 : else
1453 : {
1454 0 : nMode = COMMAND_WHEEL_SCROLL;
1455 : // #i85450# interpret shift-wheel as horizontal wheel action
1456 0 : if( (nCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2 | KEY_MOD3)) == KEY_SHIFT )
1457 0 : bHorz = true;
1458 : }
1459 :
1460 0 : CommandWheelData aWheelData( rEvt.mnDelta, rEvt.mnNotchDelta, rEvt.mnScrollLines, nMode, nCode, bHorz, bPixel );
1461 0 : Point aMousePos( rEvt.mnX, rEvt.mnY );
1462 0 : sal_Bool bRet = sal_True;
1463 :
1464 : // first check any floating window ( eg. drop down listboxes)
1465 0 : bool bIsFloat = false;
1466 0 : Window *pMouseWindow = NULL;
1467 0 : if ( pSVData->maWinData.mpFirstFloat && !pSVData->maWinData.mpCaptureWin &&
1468 0 : !pSVData->maWinData.mpFirstFloat->ImplIsFloatPopupModeWindow( pWindow ) )
1469 : {
1470 0 : sal_uInt16 nHitTest = IMPL_FLOATWIN_HITTEST_OUTSIDE;
1471 0 : pMouseWindow = pSVData->maWinData.mpFirstFloat->ImplFloatHitTest( pWindow, aMousePos, nHitTest );
1472 : }
1473 : // then try the window directly beneath the mouse
1474 0 : if( !pMouseWindow )
1475 0 : pMouseWindow = pWindow->ImplFindWindow( aMousePos );
1476 : else
1477 : {
1478 : // transform coordinates to float window frame coordinates
1479 : pMouseWindow = pMouseWindow->ImplFindWindow(
1480 : pMouseWindow->OutputToScreenPixel(
1481 : pMouseWindow->AbsoluteScreenToOutputPixel(
1482 : pWindow->OutputToAbsoluteScreenPixel(
1483 0 : pWindow->ScreenToOutputPixel( aMousePos ) ) ) ) );
1484 0 : bIsFloat = true;
1485 : }
1486 :
1487 0 : if ( pMouseWindow &&
1488 0 : pMouseWindow->IsEnabled() && pMouseWindow->IsInputEnabled() && ! pMouseWindow->IsInModalMode() )
1489 : {
1490 : // transform coordinates to float window frame coordinates
1491 : Point aRelMousePos( pMouseWindow->OutputToScreenPixel(
1492 : pMouseWindow->AbsoluteScreenToOutputPixel(
1493 : pWindow->OutputToAbsoluteScreenPixel(
1494 0 : pWindow->ScreenToOutputPixel( aMousePos ) ) ) ) );
1495 0 : bRet = ImplCallWheelCommand( pMouseWindow, aRelMousePos, &aWheelData );
1496 : }
1497 :
1498 : // if the commad was not handled try the focus window
1499 0 : if ( bRet )
1500 : {
1501 0 : Window* pFocusWindow = pWindow->ImplGetWindowImpl()->mpFrameData->mpFocusWin;
1502 0 : if ( pFocusWindow && (pFocusWindow != pMouseWindow) &&
1503 0 : (pFocusWindow == pSVData->maWinData.mpFocusWin) )
1504 : {
1505 : // no wheel-messages to disabled windows
1506 0 : if ( pFocusWindow->IsEnabled() && pFocusWindow->IsInputEnabled() && ! pFocusWindow->IsInModalMode() )
1507 : {
1508 : // transform coordinates to focus window frame coordinates
1509 : Point aRelMousePos( pFocusWindow->OutputToScreenPixel(
1510 : pFocusWindow->AbsoluteScreenToOutputPixel(
1511 : pWindow->OutputToAbsoluteScreenPixel(
1512 0 : pWindow->ScreenToOutputPixel( aMousePos ) ) ) ) );
1513 0 : bRet = ImplCallWheelCommand( pFocusWindow, aRelMousePos, &aWheelData );
1514 : }
1515 : }
1516 : }
1517 :
1518 : // close floaters
1519 0 : if( ! bIsFloat && pSVData->maWinData.mpFirstFloat )
1520 : {
1521 0 : FloatingWindow* pLastLevelFloat = pSVData->maWinData.mpFirstFloat->ImplFindLastLevelFloat();
1522 0 : if( pLastLevelFloat )
1523 : {
1524 0 : sal_uLong nPopupFlags = pLastLevelFloat->GetPopupModeFlags();
1525 0 : if ( nPopupFlags & FLOATWIN_POPUPMODE_ALLMOUSEBUTTONCLOSE )
1526 : {
1527 0 : pLastLevelFloat->EndPopupMode( FLOATWIN_POPUPMODEEND_CANCEL | FLOATWIN_POPUPMODEEND_CLOSEALL );
1528 : }
1529 : }
1530 : }
1531 :
1532 0 : return !bRet;
1533 : }
1534 :
1535 : // -----------------------------------------------------------------------
1536 : #define IMPL_PAINT_CHECKRTL ((sal_uInt16)0x0020)
1537 :
1538 971 : static void ImplHandlePaint( Window* pWindow, const Rectangle& rBoundRect, bool bImmediateUpdate )
1539 : {
1540 : // give up background save when sytem paints arrive
1541 971 : Window* pSaveBackWin = pWindow->ImplGetWindowImpl()->mpFrameData->mpFirstBackWin;
1542 1942 : while ( pSaveBackWin )
1543 : {
1544 0 : Window* pNext = pSaveBackWin->ImplGetWindowImpl()->mpOverlapData->mpNextBackWin;
1545 : Rectangle aRect( Point( pSaveBackWin->GetOutOffXPixel(), pSaveBackWin->GetOutOffYPixel() ),
1546 0 : Size( pSaveBackWin->GetOutputWidthPixel(), pSaveBackWin->GetOutputHeightPixel() ) );
1547 0 : if ( aRect.IsOver( rBoundRect ) )
1548 0 : pSaveBackWin->ImplDeleteOverlapBackground();
1549 0 : pSaveBackWin = pNext;
1550 : }
1551 :
1552 : // system paint events must be checked for re-mirroring
1553 971 : pWindow->ImplGetWindowImpl()->mnPaintFlags |= IMPL_PAINT_CHECKRTL;
1554 :
1555 : // trigger paint for all windows that live in the new paint region
1556 971 : Region aRegion( rBoundRect );
1557 971 : pWindow->ImplInvalidateOverlapFrameRegion( aRegion );
1558 971 : if( bImmediateUpdate )
1559 : {
1560 : // #i87663# trigger possible pending resize notifications
1561 : // (GetSizePixel does that for us)
1562 0 : pWindow->GetSizePixel();
1563 : // force drawing inmmediately
1564 0 : pWindow->Update();
1565 971 : }
1566 971 : }
1567 :
1568 : // -----------------------------------------------------------------------
1569 :
1570 2248 : static void KillOwnPopups( Window* pWindow )
1571 : {
1572 2248 : ImplSVData* pSVData = ImplGetSVData();
1573 2248 : Window *pParent = pWindow->ImplGetWindowImpl()->mpFrameWindow;
1574 2248 : Window *pChild = pSVData->maWinData.mpFirstFloat;
1575 2248 : if ( pChild && pParent->ImplIsWindowOrChild( pChild, sal_True ) )
1576 : {
1577 0 : if ( !(pSVData->maWinData.mpFirstFloat->GetPopupModeFlags() & FLOATWIN_POPUPMODE_NOAPPFOCUSCLOSE) )
1578 0 : pSVData->maWinData.mpFirstFloat->EndPopupMode( FLOATWIN_POPUPMODEEND_CANCEL | FLOATWIN_POPUPMODEEND_CLOSEALL );
1579 : }
1580 2248 : }
1581 :
1582 : // -----------------------------------------------------------------------
1583 :
1584 5042 : void ImplHandleResize( Window* pWindow, long nNewWidth, long nNewHeight )
1585 : {
1586 5042 : if( pWindow->GetStyle() & (WB_MOVEABLE|WB_SIZEABLE) )
1587 : {
1588 2248 : KillOwnPopups( pWindow );
1589 2248 : if( pWindow->ImplGetWindow() != ImplGetSVData()->maHelpData.mpHelpWin )
1590 2248 : ImplDestroyHelpWindow( true );
1591 : }
1592 :
1593 5042 : if (
1594 5099 : (nNewWidth > 0 && nNewHeight > 0) ||
1595 57 : pWindow->ImplGetWindow()->ImplGetWindowImpl()->mbAllResize
1596 : )
1597 : {
1598 5004 : if ( (nNewWidth != pWindow->GetOutputWidthPixel()) || (nNewHeight != pWindow->GetOutputHeightPixel()) )
1599 : {
1600 3482 : pWindow->mnOutWidth = nNewWidth;
1601 3482 : pWindow->mnOutHeight = nNewHeight;
1602 3482 : pWindow->ImplGetWindowImpl()->mbWaitSystemResize = sal_False;
1603 3482 : if ( pWindow->IsReallyVisible() )
1604 42 : pWindow->ImplSetClipFlag();
1605 9252 : if ( pWindow->IsVisible() || pWindow->ImplGetWindow()->ImplGetWindowImpl()->mbAllResize ||
1606 4604 : ( pWindow->ImplGetWindowImpl()->mbFrame && pWindow->ImplGetWindowImpl()->mpClientWindow ) ) // propagate resize for system border windows
1607 : {
1608 3468 : bool bStartTimer = true;
1609 : // use resize buffering for user resizes
1610 : // ownerdraw decorated windows and floating windows can be resized immediately (i.e. synchronously)
1611 10404 : if( pWindow->ImplGetWindowImpl()->mbFrame && (pWindow->GetStyle() & WB_SIZEABLE)
1612 1110 : && !(pWindow->GetStyle() & WB_OWNERDRAWDECORATION) // synchronous resize for ownerdraw decorated windows (toolbars)
1613 4578 : && !pWindow->ImplGetWindowImpl()->mbFloatWin ) // synchronous resize for floating windows, #i43799#
1614 : {
1615 1110 : if( pWindow->ImplGetWindowImpl()->mpClientWindow )
1616 : {
1617 : // #i42750# presentation wants to be informed about resize
1618 : // as early as possible
1619 1110 : WorkWindow* pWorkWindow = dynamic_cast<WorkWindow*>(pWindow->ImplGetWindowImpl()->mpClientWindow);
1620 1110 : if( ! pWorkWindow || pWorkWindow->IsPresentationMode() )
1621 0 : bStartTimer = false;
1622 : }
1623 : else
1624 : {
1625 0 : WorkWindow* pWorkWindow = dynamic_cast<WorkWindow*>(pWindow);
1626 0 : if( ! pWorkWindow || pWorkWindow->IsPresentationMode() )
1627 0 : bStartTimer = false;
1628 : }
1629 : }
1630 : else
1631 2358 : bStartTimer = false;
1632 :
1633 3468 : if( bStartTimer )
1634 1110 : pWindow->ImplGetWindowImpl()->mpFrameData->maResizeTimer.Start();
1635 : else
1636 2358 : pWindow->ImplCallResize(); // otherwise menus cannot be positioned
1637 : }
1638 : else
1639 14 : pWindow->ImplGetWindowImpl()->mbCallResize = sal_True;
1640 : }
1641 : }
1642 :
1643 10084 : pWindow->ImplGetWindowImpl()->mpFrameData->mbNeedSysWindow = (nNewWidth < IMPL_MIN_NEEDSYSWIN) ||
1644 10084 : (nNewHeight < IMPL_MIN_NEEDSYSWIN);
1645 5042 : sal_Bool bMinimized = (nNewWidth <= 0) || (nNewHeight <= 0);
1646 5042 : if( bMinimized != pWindow->ImplGetWindowImpl()->mpFrameData->mbMinimized )
1647 80 : pWindow->ImplGetWindowImpl()->mpFrameWindow->ImplNotifyIconifiedState( bMinimized );
1648 5042 : pWindow->ImplGetWindowImpl()->mpFrameData->mbMinimized = bMinimized;
1649 5042 : }
1650 :
1651 : // -----------------------------------------------------------------------
1652 :
1653 0 : static void ImplHandleMove( Window* pWindow )
1654 : {
1655 0 : if( pWindow->ImplGetWindowImpl()->mbFrame && pWindow->ImplIsFloatingWindow() && pWindow->IsReallyVisible() )
1656 : {
1657 0 : static_cast<FloatingWindow*>(pWindow)->EndPopupMode( FLOATWIN_POPUPMODEEND_TEAROFF );
1658 0 : pWindow->ImplCallMove();
1659 : }
1660 :
1661 0 : if( pWindow->GetStyle() & (WB_MOVEABLE|WB_SIZEABLE) )
1662 : {
1663 0 : KillOwnPopups( pWindow );
1664 0 : if( pWindow->ImplGetWindow() != ImplGetSVData()->maHelpData.mpHelpWin )
1665 0 : ImplDestroyHelpWindow( true );
1666 : }
1667 :
1668 0 : if ( pWindow->IsVisible() )
1669 0 : pWindow->ImplCallMove();
1670 : else
1671 0 : pWindow->ImplGetWindowImpl()->mbCallMove = sal_True; // make sure the framepos will be updated on the next Show()
1672 :
1673 0 : if ( pWindow->ImplGetWindowImpl()->mbFrame && pWindow->ImplGetWindowImpl()->mpClientWindow )
1674 0 : pWindow->ImplGetWindowImpl()->mpClientWindow->ImplCallMove(); // notify client to update geometry
1675 :
1676 0 : }
1677 :
1678 : // -----------------------------------------------------------------------
1679 :
1680 0 : static void ImplHandleMoveResize( Window* pWindow, long nNewWidth, long nNewHeight )
1681 : {
1682 0 : ImplHandleMove( pWindow );
1683 0 : ImplHandleResize( pWindow, nNewWidth, nNewHeight );
1684 0 : }
1685 :
1686 : // -----------------------------------------------------------------------
1687 :
1688 962 : static void ImplActivateFloatingWindows( Window* pWindow, sal_Bool bActive )
1689 : {
1690 : // First check all overlapping windows
1691 962 : Window* pTempWindow = pWindow->ImplGetWindowImpl()->mpFirstOverlap;
1692 1924 : while ( pTempWindow )
1693 : {
1694 0 : if ( !pTempWindow->GetActivateMode() )
1695 : {
1696 0 : if ( (pTempWindow->GetType() == WINDOW_BORDERWINDOW) &&
1697 0 : (pTempWindow->ImplGetWindow()->GetType() == WINDOW_FLOATINGWINDOW) )
1698 0 : ((ImplBorderWindow*)pTempWindow)->SetDisplayActive( bActive );
1699 : }
1700 :
1701 0 : ImplActivateFloatingWindows( pTempWindow, bActive );
1702 0 : pTempWindow = pTempWindow->ImplGetWindowImpl()->mpNext;
1703 : }
1704 962 : }
1705 :
1706 :
1707 : // -----------------------------------------------------------------------
1708 :
1709 1968 : IMPL_LINK_NOARG(Window, ImplAsyncFocusHdl)
1710 : {
1711 984 : ImplGetWindowImpl()->mpFrameData->mnFocusId = 0;
1712 :
1713 : // If the status has been preserved, because we got back the focus
1714 : // in the meantime, we do nothing
1715 984 : sal_Bool bHasFocus = ImplGetWindowImpl()->mpFrameData->mbHasFocus || ImplGetWindowImpl()->mpFrameData->mbSysObjFocus;
1716 :
1717 : // next execute the delayed functions
1718 984 : if ( bHasFocus )
1719 : {
1720 : // redraw all floating windows inactive
1721 942 : if ( ImplGetWindowImpl()->mpFrameData->mbStartFocusState != bHasFocus )
1722 923 : ImplActivateFloatingWindows( this, bHasFocus );
1723 :
1724 942 : if ( ImplGetWindowImpl()->mpFrameData->mpFocusWin )
1725 : {
1726 942 : sal_Bool bHandled = sal_False;
1727 1884 : if ( ImplGetWindowImpl()->mpFrameData->mpFocusWin->IsInputEnabled() &&
1728 942 : ! ImplGetWindowImpl()->mpFrameData->mpFocusWin->IsInModalMode() )
1729 : {
1730 942 : if ( ImplGetWindowImpl()->mpFrameData->mpFocusWin->IsEnabled() )
1731 : {
1732 942 : ImplGetWindowImpl()->mpFrameData->mpFocusWin->GrabFocus();
1733 942 : bHandled = sal_True;
1734 : }
1735 0 : else if( ImplGetWindowImpl()->mpFrameData->mpFocusWin->ImplHasDlgCtrl() )
1736 : {
1737 : // #109094# if the focus is restored to a disabled dialog control (was disabled meanwhile)
1738 : // try to move it to the next control
1739 0 : ImplGetWindowImpl()->mpFrameData->mpFocusWin->ImplDlgCtrlNextWindow();
1740 0 : bHandled = sal_True;
1741 : }
1742 : }
1743 942 : if ( !bHandled )
1744 : {
1745 0 : ImplSVData* pSVData = ImplGetSVData();
1746 0 : Window* pTopLevelWindow = ImplGetWindowImpl()->mpFrameData->mpFocusWin->ImplGetFirstOverlapWindow();
1747 0 : if ( ( ! pTopLevelWindow->IsInputEnabled() || pTopLevelWindow->IsInModalMode() )
1748 0 : && pSVData->maWinData.mpLastExecuteDlg )
1749 0 : pSVData->maWinData.mpLastExecuteDlg->ToTop( TOTOP_RESTOREWHENMIN | TOTOP_GRABFOCUSONLY);
1750 : else
1751 0 : pTopLevelWindow->GrabFocus();
1752 : }
1753 : }
1754 : else
1755 0 : GrabFocus();
1756 : }
1757 : else
1758 : {
1759 42 : Window* pFocusWin = ImplGetWindowImpl()->mpFrameData->mpFocusWin;
1760 42 : if ( pFocusWin )
1761 : {
1762 42 : ImplSVData* pSVData = ImplGetSVData();
1763 :
1764 42 : if ( pSVData->maWinData.mpFocusWin == pFocusWin )
1765 : {
1766 : // FocusWindow umsetzen
1767 37 : Window* pOverlapWindow = pFocusWin->ImplGetFirstOverlapWindow();
1768 37 : pOverlapWindow->ImplGetWindowImpl()->mpLastFocusWindow = pFocusWin;
1769 37 : pSVData->maWinData.mpFocusWin = NULL;
1770 :
1771 37 : if ( pFocusWin->ImplGetWindowImpl()->mpCursor )
1772 13 : pFocusWin->ImplGetWindowImpl()->mpCursor->ImplHide( true );
1773 :
1774 : // Deaktivate rufen
1775 37 : Window* pOldFocusWindow = pFocusWin;
1776 37 : if ( pOldFocusWindow )
1777 : {
1778 37 : Window* pOldOverlapWindow = pOldFocusWindow->ImplGetFirstOverlapWindow();
1779 37 : Window* pOldRealWindow = pOldOverlapWindow->ImplGetWindow();
1780 :
1781 37 : pOldOverlapWindow->ImplGetWindowImpl()->mbActive = sal_False;
1782 37 : pOldOverlapWindow->Deactivate();
1783 37 : if ( pOldRealWindow != pOldOverlapWindow )
1784 : {
1785 37 : pOldRealWindow->ImplGetWindowImpl()->mbActive = sal_False;
1786 37 : pOldRealWindow->Deactivate();
1787 : }
1788 : }
1789 :
1790 : // TrackingMode is ended in ImplHandleLoseFocus
1791 : // To avoid problems with the Unix IME
1792 : // pFocusWin->EndExtTextInput( EXTTEXTINPUT_END_COMPLETE );
1793 :
1794 : // XXX #102010# hack for accessibility: do not close the menu,
1795 : // even after focus lost
1796 37 : static const char* pEnv = getenv("SAL_FLOATWIN_NOAPPFOCUSCLOSE");
1797 37 : if( !(pEnv && *pEnv) )
1798 : {
1799 37 : NotifyEvent aNEvt( EVENT_LOSEFOCUS, pFocusWin );
1800 37 : if ( !ImplCallPreNotify( aNEvt ) )
1801 37 : pFocusWin->LoseFocus();
1802 37 : pFocusWin->ImplCallDeactivateListeners( NULL );
1803 37 : GetpApp()->FocusChanged();
1804 : }
1805 : // XXX
1806 : }
1807 : }
1808 :
1809 : // Redraw all floating window inactive
1810 42 : if ( ImplGetWindowImpl()->mpFrameData->mbStartFocusState != bHasFocus )
1811 39 : ImplActivateFloatingWindows( this, bHasFocus );
1812 : }
1813 :
1814 984 : return 0;
1815 : }
1816 :
1817 : // -----------------------------------------------------------------------
1818 :
1819 2816 : static void ImplHandleGetFocus( Window* pWindow )
1820 : {
1821 2816 : pWindow->ImplGetWindowImpl()->mpFrameData->mbHasFocus = sal_True;
1822 :
1823 :
1824 : // execute Focus-Events after a delay, such that SystemChildWindows
1825 : // do not blink when they receive focus
1826 2816 : if ( !pWindow->ImplGetWindowImpl()->mpFrameData->mnFocusId )
1827 : {
1828 931 : pWindow->ImplGetWindowImpl()->mpFrameData->mbStartFocusState = !pWindow->ImplGetWindowImpl()->mpFrameData->mbHasFocus;
1829 931 : Application::PostUserEvent( pWindow->ImplGetWindowImpl()->mpFrameData->mnFocusId, LINK( pWindow, Window, ImplAsyncFocusHdl ) );
1830 931 : Window* pFocusWin = pWindow->ImplGetWindowImpl()->mpFrameData->mpFocusWin;
1831 931 : if ( pFocusWin && pFocusWin->ImplGetWindowImpl()->mpCursor )
1832 6 : pFocusWin->ImplGetWindowImpl()->mpCursor->ImplShow();
1833 : }
1834 2816 : }
1835 :
1836 : // -----------------------------------------------------------------------
1837 :
1838 1929 : static void ImplHandleLoseFocus( Window* pWindow )
1839 : {
1840 1929 : ImplSVData* pSVData = ImplGetSVData();
1841 :
1842 : // Abort the autoscroll if the frame loses focus
1843 1929 : if ( pSVData->maWinData.mpAutoScrollWin )
1844 0 : pSVData->maWinData.mpAutoScrollWin->EndAutoScroll();
1845 :
1846 : // Abort tracking if the frame loses focus
1847 1929 : if ( pSVData->maWinData.mpTrackWin )
1848 : {
1849 0 : if ( pSVData->maWinData.mpTrackWin->ImplGetWindowImpl()->mpFrameWindow == pWindow )
1850 0 : pSVData->maWinData.mpTrackWin->EndTracking( ENDTRACK_CANCEL );
1851 : }
1852 :
1853 : // here we always terminate the popupmode, also when NOFOCUSCLOSE
1854 : // is set, such that we do not show windows during the switch
1855 1929 : if ( pSVData->maWinData.mpFirstFloat )
1856 : {
1857 0 : if ( !(pSVData->maWinData.mpFirstFloat->GetPopupModeFlags() & FLOATWIN_POPUPMODE_NOAPPFOCUSCLOSE) )
1858 0 : pSVData->maWinData.mpFirstFloat->EndPopupMode( FLOATWIN_POPUPMODEEND_CANCEL | FLOATWIN_POPUPMODEEND_CLOSEALL );
1859 : }
1860 :
1861 1929 : pWindow->ImplGetWindowImpl()->mpFrameData->mbHasFocus = sal_False;
1862 :
1863 : // execute Focus-Events after a delay, such that SystemChildWindows
1864 : // do not flicker when they receive focus
1865 1929 : if ( !pWindow->ImplGetWindowImpl()->mpFrameData->mnFocusId )
1866 : {
1867 59 : pWindow->ImplGetWindowImpl()->mpFrameData->mbStartFocusState = !pWindow->ImplGetWindowImpl()->mpFrameData->mbHasFocus;
1868 59 : Application::PostUserEvent( pWindow->ImplGetWindowImpl()->mpFrameData->mnFocusId, LINK( pWindow, Window, ImplAsyncFocusHdl ) );
1869 : }
1870 :
1871 1929 : Window* pFocusWin = pWindow->ImplGetWindowImpl()->mpFrameData->mpFocusWin;
1872 1929 : if ( pFocusWin && pFocusWin->ImplGetWindowImpl()->mpCursor )
1873 39 : pFocusWin->ImplGetWindowImpl()->mpCursor->ImplHide( true );
1874 1929 : }
1875 :
1876 : // -----------------------------------------------------------------------
1877 0 : struct DelayedCloseEvent
1878 : {
1879 : Window* pWindow;
1880 : ImplDelData aDelData;
1881 : };
1882 :
1883 0 : static long DelayedCloseEventLink( void* pCEvent, void* )
1884 : {
1885 0 : DelayedCloseEvent* pEv = (DelayedCloseEvent*)pCEvent;
1886 :
1887 0 : if( ! pEv->aDelData.IsDead() )
1888 : {
1889 0 : pEv->pWindow->ImplRemoveDel( &pEv->aDelData );
1890 : // dispatch to correct window type
1891 0 : if( pEv->pWindow->IsSystemWindow() )
1892 0 : ((SystemWindow*)pEv->pWindow)->Close();
1893 0 : else if( pEv->pWindow->ImplIsDockingWindow() )
1894 0 : ((DockingWindow*)pEv->pWindow)->Close();
1895 : }
1896 0 : delete pEv;
1897 :
1898 0 : return 0;
1899 : }
1900 :
1901 0 : void ImplHandleClose( Window* pWindow )
1902 : {
1903 0 : ImplSVData* pSVData = ImplGetSVData();
1904 :
1905 0 : bool bWasPopup = false;
1906 0 : if( pWindow->ImplIsFloatingWindow() &&
1907 0 : static_cast<FloatingWindow*>(pWindow)->ImplIsInPrivatePopupMode() )
1908 : {
1909 0 : bWasPopup = true;
1910 : }
1911 :
1912 : // on Close stop all floating modes and end popups
1913 0 : if ( pSVData->maWinData.mpFirstFloat )
1914 : {
1915 : FloatingWindow* pLastLevelFloat;
1916 0 : pLastLevelFloat = pSVData->maWinData.mpFirstFloat->ImplFindLastLevelFloat();
1917 0 : pLastLevelFloat->EndPopupMode( FLOATWIN_POPUPMODEEND_CANCEL | FLOATWIN_POPUPMODEEND_CLOSEALL );
1918 : }
1919 0 : if ( pSVData->maHelpData.mbExtHelpMode )
1920 0 : Help::EndExtHelp();
1921 0 : if ( pSVData->maHelpData.mpHelpWin )
1922 0 : ImplDestroyHelpWindow( false );
1923 : // AutoScrollMode
1924 0 : if ( pSVData->maWinData.mpAutoScrollWin )
1925 0 : pSVData->maWinData.mpAutoScrollWin->EndAutoScroll();
1926 :
1927 0 : if ( pSVData->maWinData.mpTrackWin )
1928 0 : pSVData->maWinData.mpTrackWin->EndTracking( ENDTRACK_CANCEL | ENDTRACK_KEY );
1929 :
1930 0 : if (bWasPopup)
1931 0 : return;
1932 :
1933 0 : Window *pWin = pWindow->ImplGetWindow();
1934 0 : SystemWindow* pSysWin = dynamic_cast<SystemWindow*>(pWin);
1935 0 : if (pSysWin)
1936 : {
1937 : // See if the custom close handler is set.
1938 0 : const Link& rLink = pSysWin->GetCloseHdl();
1939 0 : if (rLink.IsSet())
1940 : {
1941 0 : rLink.Call(pSysWin);
1942 0 : return;
1943 : }
1944 : }
1945 :
1946 : // check whether close is allowed
1947 0 : if ( pWin->IsEnabled() && pWin->IsInputEnabled() && !pWin->IsInModalMode() )
1948 : {
1949 0 : DelayedCloseEvent* pEv = new DelayedCloseEvent;
1950 0 : pEv->pWindow = pWin;
1951 0 : pWin->ImplAddDel( &pEv->aDelData );
1952 0 : Application::PostUserEvent( Link( pEv, DelayedCloseEventLink ) );
1953 : }
1954 : }
1955 :
1956 : // -----------------------------------------------------------------------
1957 :
1958 15538 : static void ImplHandleUserEvent( ImplSVEvent* pSVEvent )
1959 : {
1960 15538 : if ( pSVEvent )
1961 : {
1962 15538 : if ( pSVEvent->mbCall && !pSVEvent->maDelData.IsDead() )
1963 : {
1964 10814 : if ( pSVEvent->mpWindow )
1965 : {
1966 13 : pSVEvent->mpWindow->ImplRemoveDel( &(pSVEvent->maDelData) );
1967 13 : if ( pSVEvent->mpLink )
1968 13 : pSVEvent->mpLink->Call( pSVEvent->mpData );
1969 : else
1970 0 : pSVEvent->mpWindow->UserEvent( pSVEvent->mnEvent, pSVEvent->mpData );
1971 : }
1972 : else
1973 : {
1974 10801 : if ( pSVEvent->mpLink )
1975 10801 : pSVEvent->mpLink->Call( pSVEvent->mpData );
1976 : else
1977 0 : GetpApp()->UserEvent( pSVEvent->mnEvent, pSVEvent->mpData );
1978 : }
1979 : }
1980 :
1981 15538 : delete pSVEvent->mpLink;
1982 15538 : delete pSVEvent;
1983 : }
1984 15538 : }
1985 :
1986 : // =======================================================================
1987 :
1988 0 : static sal_uInt16 ImplGetMouseMoveMode( SalMouseEvent* pEvent )
1989 : {
1990 0 : sal_uInt16 nMode = 0;
1991 0 : if ( !pEvent->mnCode )
1992 0 : nMode |= MOUSE_SIMPLEMOVE;
1993 0 : if ( (pEvent->mnCode & MOUSE_LEFT) && !(pEvent->mnCode & KEY_MOD1) )
1994 0 : nMode |= MOUSE_DRAGMOVE;
1995 0 : if ( (pEvent->mnCode & MOUSE_LEFT) && (pEvent->mnCode & KEY_MOD1) )
1996 0 : nMode |= MOUSE_DRAGCOPY;
1997 0 : return nMode;
1998 : }
1999 :
2000 : // -----------------------------------------------------------------------
2001 :
2002 0 : static sal_uInt16 ImplGetMouseButtonMode( SalMouseEvent* pEvent )
2003 : {
2004 0 : sal_uInt16 nMode = 0;
2005 0 : if ( pEvent->mnButton == MOUSE_LEFT )
2006 0 : nMode |= MOUSE_SIMPLECLICK;
2007 0 : if ( (pEvent->mnButton == MOUSE_LEFT) && !(pEvent->mnCode & (MOUSE_MIDDLE | MOUSE_RIGHT)) )
2008 0 : nMode |= MOUSE_SELECT;
2009 0 : if ( (pEvent->mnButton == MOUSE_LEFT) && (pEvent->mnCode & KEY_MOD1) &&
2010 0 : !(pEvent->mnCode & (MOUSE_MIDDLE | MOUSE_RIGHT | KEY_SHIFT)) )
2011 0 : nMode |= MOUSE_MULTISELECT;
2012 0 : if ( (pEvent->mnButton == MOUSE_LEFT) && (pEvent->mnCode & KEY_SHIFT) &&
2013 0 : !(pEvent->mnCode & (MOUSE_MIDDLE | MOUSE_RIGHT | KEY_MOD1)) )
2014 0 : nMode |= MOUSE_RANGESELECT;
2015 0 : return nMode;
2016 : }
2017 :
2018 : // -----------------------------------------------------------------------
2019 :
2020 0 : inline long ImplHandleSalMouseLeave( Window* pWindow, SalMouseEvent* pEvent )
2021 : {
2022 : return ImplHandleMouseEvent( pWindow, EVENT_MOUSEMOVE, sal_True,
2023 : pEvent->mnX, pEvent->mnY,
2024 : pEvent->mnTime, pEvent->mnCode,
2025 0 : ImplGetMouseMoveMode( pEvent ) );
2026 : }
2027 :
2028 : // -----------------------------------------------------------------------
2029 :
2030 0 : inline long ImplHandleSalMouseMove( Window* pWindow, SalMouseEvent* pEvent )
2031 : {
2032 : return ImplHandleMouseEvent( pWindow, EVENT_MOUSEMOVE, sal_False,
2033 : pEvent->mnX, pEvent->mnY,
2034 : pEvent->mnTime, pEvent->mnCode,
2035 0 : ImplGetMouseMoveMode( pEvent ) );
2036 : }
2037 :
2038 : // -----------------------------------------------------------------------
2039 :
2040 0 : inline long ImplHandleSalMouseButtonDown( Window* pWindow, SalMouseEvent* pEvent )
2041 : {
2042 : return ImplHandleMouseEvent( pWindow, EVENT_MOUSEBUTTONDOWN, sal_False,
2043 : pEvent->mnX, pEvent->mnY,
2044 : pEvent->mnTime,
2045 : #ifdef MACOSX
2046 : pEvent->mnButton | (pEvent->mnCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2 | KEY_MOD3)),
2047 : #else
2048 : pEvent->mnButton | (pEvent->mnCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2)),
2049 : #endif
2050 0 : ImplGetMouseButtonMode( pEvent ) );
2051 : }
2052 :
2053 : // -----------------------------------------------------------------------
2054 :
2055 0 : inline long ImplHandleSalMouseButtonUp( Window* pWindow, SalMouseEvent* pEvent )
2056 : {
2057 : return ImplHandleMouseEvent( pWindow, EVENT_MOUSEBUTTONUP, sal_False,
2058 : pEvent->mnX, pEvent->mnY,
2059 : pEvent->mnTime,
2060 : #ifdef MACOSX
2061 : pEvent->mnButton | (pEvent->mnCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2 | KEY_MOD3)),
2062 : #else
2063 : pEvent->mnButton | (pEvent->mnCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2)),
2064 : #endif
2065 0 : ImplGetMouseButtonMode( pEvent ) );
2066 : }
2067 :
2068 : // -----------------------------------------------------------------------
2069 :
2070 0 : static long ImplHandleSalMouseActivate( Window* /*pWindow*/, SalMouseActivateEvent* /*pEvent*/ )
2071 : {
2072 0 : return sal_False;
2073 : }
2074 :
2075 : // -----------------------------------------------------------------------
2076 :
2077 0 : static long ImplHandleMenuEvent( Window* pWindow, SalMenuEvent* pEvent, sal_uInt16 nEvent )
2078 : {
2079 : // Find SystemWindow and its Menubar and let it dispatch the command
2080 0 : long nRet = 0;
2081 0 : Window *pWin = pWindow->ImplGetWindowImpl()->mpFirstChild;
2082 0 : while ( pWin )
2083 : {
2084 0 : if ( pWin->ImplGetWindowImpl()->mbSysWin )
2085 0 : break;
2086 0 : pWin = pWin->ImplGetWindowImpl()->mpNext;
2087 : }
2088 0 : if( pWin )
2089 : {
2090 0 : MenuBar *pMenuBar = ((SystemWindow*) pWin)->GetMenuBar();
2091 0 : if( pMenuBar )
2092 : {
2093 0 : switch( nEvent )
2094 : {
2095 : case SALEVENT_MENUACTIVATE:
2096 0 : nRet = pMenuBar->HandleMenuActivateEvent( (Menu*) pEvent->mpMenu ) ? 1 : 0;
2097 0 : break;
2098 : case SALEVENT_MENUDEACTIVATE:
2099 0 : nRet = pMenuBar->HandleMenuDeActivateEvent( (Menu*) pEvent->mpMenu ) ? 1 : 0;
2100 0 : break;
2101 : case SALEVENT_MENUHIGHLIGHT:
2102 0 : nRet = pMenuBar->HandleMenuHighlightEvent( (Menu*) pEvent->mpMenu, pEvent->mnId ) ? 1 : 0;
2103 0 : break;
2104 : case SALEVENT_MENUBUTTONCOMMAND:
2105 0 : nRet = pMenuBar->HandleMenuButtonEvent( (Menu*) pEvent->mpMenu, pEvent->mnId ) ? 1 : 0;
2106 0 : break;
2107 : case SALEVENT_MENUCOMMAND:
2108 0 : nRet = pMenuBar->HandleMenuCommandEvent( (Menu*) pEvent->mpMenu, pEvent->mnId ) ? 1 : 0;
2109 0 : break;
2110 : default:
2111 0 : break;
2112 : }
2113 : }
2114 : }
2115 0 : return nRet;
2116 : }
2117 :
2118 : // -----------------------------------------------------------------------
2119 :
2120 0 : static void ImplHandleSalKeyMod( Window* pWindow, SalKeyModEvent* pEvent )
2121 : {
2122 0 : ImplSVData* pSVData = ImplGetSVData();
2123 0 : Window* pTrackWin = pSVData->maWinData.mpTrackWin;
2124 0 : if ( pTrackWin )
2125 0 : pWindow = pTrackWin;
2126 : #ifdef MACOSX
2127 : sal_uInt16 nOldCode = pWindow->ImplGetWindowImpl()->mpFrameData->mnMouseCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2 | KEY_MOD3);
2128 : #else
2129 0 : sal_uInt16 nOldCode = pWindow->ImplGetWindowImpl()->mpFrameData->mnMouseCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2);
2130 : #endif
2131 0 : sal_uInt16 nNewCode = pEvent->mnCode;
2132 0 : if ( nOldCode != nNewCode )
2133 : {
2134 : #ifdef MACOSX
2135 : nNewCode |= pWindow->ImplGetWindowImpl()->mpFrameData->mnMouseCode & ~(KEY_SHIFT | KEY_MOD1 | KEY_MOD2 | KEY_MOD3);
2136 : #else
2137 0 : nNewCode |= pWindow->ImplGetWindowImpl()->mpFrameData->mnMouseCode & ~(KEY_SHIFT | KEY_MOD1 | KEY_MOD2);
2138 : #endif
2139 0 : pWindow->ImplGetWindowImpl()->mpFrameWindow->ImplCallMouseMove( nNewCode, sal_True );
2140 : }
2141 :
2142 : // #105224# send commandevent to allow special treatment of Ctrl-LeftShift/Ctrl-RightShift etc.
2143 :
2144 : // find window
2145 0 : Window* pChild = ImplGetKeyInputWindow( pWindow );
2146 0 : if ( !pChild )
2147 0 : return;
2148 :
2149 : // send modkey events only if useful data is available
2150 0 : if( pEvent->mnModKeyCode != 0 )
2151 : {
2152 0 : CommandModKeyData data( pEvent->mnModKeyCode );
2153 0 : ImplCallCommand( pChild, COMMAND_MODKEYCHANGE, &data );
2154 : }
2155 : }
2156 :
2157 : // -----------------------------------------------------------------------
2158 :
2159 0 : static void ImplHandleInputLanguageChange( Window* pWindow )
2160 : {
2161 : // find window
2162 0 : Window* pChild = ImplGetKeyInputWindow( pWindow );
2163 0 : if ( !pChild )
2164 0 : return;
2165 :
2166 0 : ImplCallCommand( pChild, COMMAND_INPUTLANGUAGECHANGE );
2167 : }
2168 :
2169 : // -----------------------------------------------------------------------
2170 :
2171 0 : static void ImplHandleSalSettings( Window* pWindow, sal_uInt16 nEvent )
2172 : {
2173 : // Application Notification werden nur fuer das erste Window ausgeloest
2174 0 : ImplSVData* pSVData = ImplGetSVData();
2175 0 : if ( pWindow != pSVData->maWinData.mpFirstFrame )
2176 0 : return;
2177 :
2178 0 : Application* pApp = GetpApp();
2179 0 : if ( !pApp )
2180 0 : return;
2181 :
2182 0 : if ( nEvent == SALEVENT_SETTINGSCHANGED )
2183 : {
2184 0 : AllSettings aSettings = pApp->GetSettings();
2185 0 : pApp->MergeSystemSettings( aSettings );
2186 0 : pApp->SystemSettingsChanging( aSettings, pWindow );
2187 0 : pApp->SetSettings( aSettings );
2188 : }
2189 : else
2190 : {
2191 : sal_uInt16 nType;
2192 0 : switch ( nEvent )
2193 : {
2194 : case SALEVENT_VOLUMECHANGED:
2195 0 : nType = 0;
2196 0 : break;
2197 : case SALEVENT_PRINTERCHANGED:
2198 0 : ImplDeletePrnQueueList();
2199 0 : nType = DATACHANGED_PRINTER;
2200 0 : break;
2201 : case SALEVENT_DISPLAYCHANGED:
2202 0 : nType = DATACHANGED_DISPLAY;
2203 0 : break;
2204 : case SALEVENT_FONTCHANGED:
2205 0 : OutputDevice::ImplUpdateAllFontData( sal_True );
2206 0 : nType = DATACHANGED_FONTS;
2207 0 : break;
2208 : case SALEVENT_DATETIMECHANGED:
2209 0 : nType = DATACHANGED_DATETIME;
2210 0 : break;
2211 : case SALEVENT_KEYBOARDCHANGED:
2212 0 : nType = 0;
2213 0 : break;
2214 : default:
2215 0 : nType = 0;
2216 0 : break;
2217 : }
2218 :
2219 0 : if ( nType )
2220 : {
2221 0 : DataChangedEvent aDCEvt( nType );
2222 0 : pApp->DataChanged( aDCEvt );
2223 0 : pApp->NotifyAllWindows( aDCEvt );
2224 : }
2225 : }
2226 : }
2227 :
2228 : // -----------------------------------------------------------------------
2229 :
2230 0 : static void ImplHandleSalExtTextInputPos( Window* pWindow, SalExtTextInputPosEvent* pEvt )
2231 : {
2232 0 : Rectangle aCursorRect;
2233 0 : ImplHandleExtTextInputPos( pWindow, aCursorRect, pEvt->mnExtWidth, &pEvt->mbVertical );
2234 0 : if ( aCursorRect.IsEmpty() )
2235 : {
2236 0 : pEvt->mnX = -1;
2237 0 : pEvt->mnY = -1;
2238 0 : pEvt->mnWidth = -1;
2239 0 : pEvt->mnHeight = -1;
2240 : }
2241 : else
2242 : {
2243 0 : pEvt->mnX = aCursorRect.Left();
2244 0 : pEvt->mnY = aCursorRect.Top();
2245 0 : pEvt->mnWidth = aCursorRect.GetWidth();
2246 0 : pEvt->mnHeight = aCursorRect.GetHeight();
2247 : }
2248 0 : }
2249 :
2250 : // -----------------------------------------------------------------------
2251 :
2252 0 : static long ImplHandleShowDialog( Window* pWindow, int nDialogId )
2253 : {
2254 0 : if( ! pWindow )
2255 0 : return sal_False;
2256 :
2257 0 : if( pWindow->GetType() == WINDOW_BORDERWINDOW )
2258 : {
2259 0 : Window* pWrkWin = pWindow->GetWindow( WINDOW_CLIENT );
2260 0 : if( pWrkWin )
2261 0 : pWindow = pWrkWin;
2262 : }
2263 0 : CommandDialogData aCmdData( nDialogId );
2264 0 : return ImplCallCommand( pWindow, COMMAND_SHOWDIALOG, &aCmdData );
2265 : }
2266 :
2267 : // -----------------------------------------------------------------------
2268 :
2269 0 : static void ImplHandleSurroundingTextRequest( Window *pWindow,
2270 : OUString& rText,
2271 : Selection &rSelRange )
2272 : {
2273 0 : Window* pChild = ImplGetKeyInputWindow( pWindow );
2274 :
2275 0 : if ( !pChild )
2276 : {
2277 0 : rText = OUString();
2278 0 : rSelRange.setMin( 0 );
2279 0 : rSelRange.setMax( 0 );
2280 : }
2281 : else
2282 : {
2283 0 : rText = pChild->GetSurroundingText();
2284 0 : Selection aSel = pChild->GetSurroundingTextSelection();
2285 0 : rSelRange.setMin( aSel.Min() );
2286 0 : rSelRange.setMax( aSel.Max() );
2287 : }
2288 0 : }
2289 :
2290 : // -----------------------------------------------------------------------
2291 :
2292 0 : static void ImplHandleSalSurroundingTextRequest( Window *pWindow,
2293 : SalSurroundingTextRequestEvent *pEvt )
2294 : {
2295 0 : Selection aSelRange;
2296 0 : ImplHandleSurroundingTextRequest( pWindow, pEvt->maText, aSelRange );
2297 :
2298 0 : aSelRange.Justify();
2299 :
2300 0 : if( aSelRange.Min() < 0 )
2301 0 : pEvt->mnStart = 0;
2302 0 : else if( aSelRange.Min() > pEvt->maText.getLength() )
2303 0 : pEvt->mnStart = pEvt->maText.getLength();
2304 : else
2305 0 : pEvt->mnStart = aSelRange.Min();
2306 :
2307 0 : if( aSelRange.Max() < 0 )
2308 0 : pEvt->mnStart = 0;
2309 0 : else if( aSelRange.Max() > pEvt->maText.getLength() )
2310 0 : pEvt->mnEnd = pEvt->maText.getLength();
2311 : else
2312 0 : pEvt->mnEnd = aSelRange.Max();
2313 0 : }
2314 :
2315 : // -----------------------------------------------------------------------
2316 :
2317 0 : static void ImplHandleSurroundingTextSelectionChange( Window *pWindow,
2318 : sal_uLong nStart,
2319 : sal_uLong nEnd )
2320 : {
2321 0 : Window* pChild = ImplGetKeyInputWindow( pWindow );
2322 0 : if( pChild )
2323 : {
2324 0 : CommandSelectionChangeData data( nStart, nEnd );
2325 0 : ImplCallCommand( pChild, COMMAND_SELECTIONCHANGE, &data );
2326 : }
2327 0 : }
2328 :
2329 : // -----------------------------------------------------------------------
2330 :
2331 0 : static void ImplHandleStartReconversion( Window *pWindow )
2332 : {
2333 0 : Window* pChild = ImplGetKeyInputWindow( pWindow );
2334 0 : if( pChild )
2335 0 : ImplCallCommand( pChild, COMMAND_PREPARERECONVERSION );
2336 0 : }
2337 :
2338 : // -----------------------------------------------------------------------
2339 :
2340 0 : static void ImplHandleSalQueryCharPosition( Window *pWindow,
2341 : SalQueryCharPositionEvent *pEvt )
2342 : {
2343 0 : pEvt->mbValid = false;
2344 0 : pEvt->mbVertical = false;
2345 0 : pEvt->mnCursorBoundX = 0;
2346 0 : pEvt->mnCursorBoundY = 0;
2347 0 : pEvt->mnCursorBoundWidth = 0;
2348 0 : pEvt->mnCursorBoundHeight = 0;
2349 :
2350 0 : ImplSVData* pSVData = ImplGetSVData();
2351 0 : Window* pChild = pSVData->maWinData.mpExtTextInputWin;
2352 :
2353 0 : if ( !pChild )
2354 0 : pChild = ImplGetKeyInputWindow( pWindow );
2355 : else
2356 : {
2357 : // Test, if the Window is related to the frame
2358 0 : if ( !pWindow->ImplIsWindowOrChild( pChild ) )
2359 0 : pChild = ImplGetKeyInputWindow( pWindow );
2360 : }
2361 :
2362 0 : if( pChild )
2363 : {
2364 0 : ImplCallCommand( pChild, COMMAND_QUERYCHARPOSITION );
2365 :
2366 0 : ImplWinData* pWinData = pChild->ImplGetWinData();
2367 0 : if ( pWinData->mpCompositionCharRects && pEvt->mnCharPos < static_cast<sal_uLong>( pWinData->mnCompositionCharRects ) )
2368 : {
2369 0 : const Rectangle& aRect = pWinData->mpCompositionCharRects[ pEvt->mnCharPos ];
2370 0 : Rectangle aDeviceRect = pChild->ImplLogicToDevicePixel( aRect );
2371 0 : Point aAbsScreenPos = pChild->OutputToAbsoluteScreenPixel( pChild->ScreenToOutputPixel(aDeviceRect.TopLeft()) );
2372 0 : pEvt->mnCursorBoundX = aAbsScreenPos.X();
2373 0 : pEvt->mnCursorBoundY = aAbsScreenPos.Y();
2374 0 : pEvt->mnCursorBoundWidth = aDeviceRect.GetWidth();
2375 0 : pEvt->mnCursorBoundHeight = aDeviceRect.GetHeight();
2376 0 : pEvt->mbVertical = (pWinData->mbVertical != sal_False);
2377 0 : pEvt->mbValid = true;
2378 : }
2379 : }
2380 0 : }
2381 :
2382 : // -----------------------------------------------------------------------
2383 :
2384 22263 : long ImplWindowFrameProc( Window* pWindow, SalFrame* /*pFrame*/,
2385 : sal_uInt16 nEvent, const void* pEvent )
2386 : {
2387 : DBG_TESTSOLARMUTEX();
2388 :
2389 22263 : long nRet = 0;
2390 :
2391 : // #119709# for some unknown reason it is possible to receive events (in this case key events)
2392 : // although the corresponding VCL window must have been destroyed already
2393 : // at least ImplGetWindowImpl() was NULL in these cases, so check this here
2394 22263 : if( pWindow->ImplGetWindowImpl() == NULL )
2395 0 : return 0;
2396 :
2397 22263 : switch ( nEvent )
2398 : {
2399 : case SALEVENT_MOUSEMOVE:
2400 0 : nRet = ImplHandleSalMouseMove( pWindow, (SalMouseEvent*)pEvent );
2401 0 : break;
2402 : case SALEVENT_EXTERNALMOUSEMOVE:
2403 : {
2404 0 : MouseEvent* pMouseEvt = (MouseEvent*) pEvent;
2405 : SalMouseEvent aSalMouseEvent;
2406 :
2407 0 : aSalMouseEvent.mnTime = Time::GetSystemTicks();
2408 0 : aSalMouseEvent.mnX = pMouseEvt->GetPosPixel().X();
2409 0 : aSalMouseEvent.mnY = pMouseEvt->GetPosPixel().Y();
2410 0 : aSalMouseEvent.mnButton = 0;
2411 0 : aSalMouseEvent.mnCode = pMouseEvt->GetButtons() | pMouseEvt->GetModifier();
2412 :
2413 0 : nRet = ImplHandleSalMouseMove( pWindow, &aSalMouseEvent );
2414 : }
2415 0 : break;
2416 : case SALEVENT_MOUSELEAVE:
2417 0 : nRet = ImplHandleSalMouseLeave( pWindow, (SalMouseEvent*)pEvent );
2418 0 : break;
2419 : case SALEVENT_MOUSEBUTTONDOWN:
2420 0 : nRet = ImplHandleSalMouseButtonDown( pWindow, (SalMouseEvent*)pEvent );
2421 0 : break;
2422 : case SALEVENT_EXTERNALMOUSEBUTTONDOWN:
2423 : {
2424 0 : MouseEvent* pMouseEvt = (MouseEvent*) pEvent;
2425 : SalMouseEvent aSalMouseEvent;
2426 :
2427 0 : aSalMouseEvent.mnTime = Time::GetSystemTicks();
2428 0 : aSalMouseEvent.mnX = pMouseEvt->GetPosPixel().X();
2429 0 : aSalMouseEvent.mnY = pMouseEvt->GetPosPixel().Y();
2430 0 : aSalMouseEvent.mnButton = pMouseEvt->GetButtons();
2431 0 : aSalMouseEvent.mnCode = pMouseEvt->GetButtons() | pMouseEvt->GetModifier();
2432 :
2433 0 : nRet = ImplHandleSalMouseButtonDown( pWindow, &aSalMouseEvent );
2434 : }
2435 0 : break;
2436 : case SALEVENT_MOUSEBUTTONUP:
2437 0 : nRet = ImplHandleSalMouseButtonUp( pWindow, (SalMouseEvent*)pEvent );
2438 0 : break;
2439 : case SALEVENT_EXTERNALMOUSEBUTTONUP:
2440 : {
2441 0 : MouseEvent* pMouseEvt = (MouseEvent*) pEvent;
2442 : SalMouseEvent aSalMouseEvent;
2443 :
2444 0 : aSalMouseEvent.mnTime = Time::GetSystemTicks();
2445 0 : aSalMouseEvent.mnX = pMouseEvt->GetPosPixel().X();
2446 0 : aSalMouseEvent.mnY = pMouseEvt->GetPosPixel().Y();
2447 0 : aSalMouseEvent.mnButton = pMouseEvt->GetButtons();
2448 0 : aSalMouseEvent.mnCode = pMouseEvt->GetButtons() | pMouseEvt->GetModifier();
2449 :
2450 0 : nRet = ImplHandleSalMouseButtonUp( pWindow, &aSalMouseEvent );
2451 : }
2452 0 : break;
2453 : case SALEVENT_MOUSEACTIVATE:
2454 0 : nRet = ImplHandleSalMouseActivate( pWindow, (SalMouseActivateEvent*)pEvent );
2455 0 : break;
2456 : case SALEVENT_KEYINPUT:
2457 : {
2458 0 : SalKeyEvent* pKeyEvt = (SalKeyEvent*)pEvent;
2459 : nRet = ImplHandleKey( pWindow, EVENT_KEYINPUT,
2460 0 : pKeyEvt->mnCode, pKeyEvt->mnCharCode, pKeyEvt->mnRepeat, sal_True );
2461 : }
2462 0 : break;
2463 : case SALEVENT_EXTERNALKEYINPUT:
2464 : {
2465 0 : KeyEvent* pKeyEvt = (KeyEvent*) pEvent;
2466 : nRet = ImplHandleKey( pWindow, EVENT_KEYINPUT,
2467 0 : pKeyEvt->GetKeyCode().GetFullCode(), pKeyEvt->GetCharCode(), pKeyEvt->GetRepeat(), sal_False );
2468 : }
2469 0 : break;
2470 : case SALEVENT_KEYUP:
2471 : {
2472 0 : SalKeyEvent* pKeyEvt = (SalKeyEvent*)pEvent;
2473 : nRet = ImplHandleKey( pWindow, EVENT_KEYUP,
2474 0 : pKeyEvt->mnCode, pKeyEvt->mnCharCode, pKeyEvt->mnRepeat, sal_True );
2475 : }
2476 0 : break;
2477 : case SALEVENT_EXTERNALKEYUP:
2478 : {
2479 0 : KeyEvent* pKeyEvt = (KeyEvent*) pEvent;
2480 : nRet = ImplHandleKey( pWindow, EVENT_KEYUP,
2481 0 : pKeyEvt->GetKeyCode().GetFullCode(), pKeyEvt->GetCharCode(), pKeyEvt->GetRepeat(), sal_False );
2482 : }
2483 0 : break;
2484 : case SALEVENT_KEYMODCHANGE:
2485 0 : ImplHandleSalKeyMod( pWindow, (SalKeyModEvent*)pEvent );
2486 0 : break;
2487 :
2488 : case SALEVENT_INPUTLANGUAGECHANGE:
2489 0 : ImplHandleInputLanguageChange( pWindow );
2490 0 : break;
2491 :
2492 : case SALEVENT_MENUACTIVATE:
2493 : case SALEVENT_MENUDEACTIVATE:
2494 : case SALEVENT_MENUHIGHLIGHT:
2495 : case SALEVENT_MENUCOMMAND:
2496 : case SALEVENT_MENUBUTTONCOMMAND:
2497 0 : nRet = ImplHandleMenuEvent( pWindow, (SalMenuEvent*)pEvent, nEvent );
2498 0 : break;
2499 :
2500 : case SALEVENT_WHEELMOUSE:
2501 0 : nRet = ImplHandleWheelEvent( pWindow, *(const SalWheelMouseEvent*)pEvent);
2502 0 : break;
2503 :
2504 : case SALEVENT_PAINT:
2505 : {
2506 971 : SalPaintEvent* pPaintEvt = (SalPaintEvent*)pEvent;
2507 :
2508 971 : if( Application::GetSettings().GetLayoutRTL() )
2509 : {
2510 : // --- RTL --- (mirror paint rect)
2511 0 : SalFrame* pSalFrame = pWindow->ImplGetWindowImpl()->mpFrame;
2512 0 : pPaintEvt->mnBoundX = pSalFrame->maGeometry.nWidth-pPaintEvt->mnBoundWidth-pPaintEvt->mnBoundX;
2513 : }
2514 :
2515 : Rectangle aBoundRect( Point( pPaintEvt->mnBoundX, pPaintEvt->mnBoundY ),
2516 971 : Size( pPaintEvt->mnBoundWidth, pPaintEvt->mnBoundHeight ) );
2517 971 : ImplHandlePaint( pWindow, aBoundRect, pPaintEvt->mbImmediateUpdate );
2518 : }
2519 971 : break;
2520 :
2521 : case SALEVENT_MOVE:
2522 0 : ImplHandleMove( pWindow );
2523 0 : break;
2524 :
2525 : case SALEVENT_RESIZE:
2526 : {
2527 : long nNewWidth;
2528 : long nNewHeight;
2529 1009 : pWindow->ImplGetWindowImpl()->mpFrame->GetClientSize( nNewWidth, nNewHeight );
2530 1009 : ImplHandleResize( pWindow, nNewWidth, nNewHeight );
2531 : }
2532 1009 : break;
2533 :
2534 : case SALEVENT_MOVERESIZE:
2535 : {
2536 0 : SalFrameGeometry g = pWindow->ImplGetWindowImpl()->mpFrame->GetGeometry();
2537 0 : ImplHandleMoveResize( pWindow, g.nWidth, g.nHeight );
2538 : }
2539 0 : break;
2540 :
2541 : case SALEVENT_CLOSEPOPUPS:
2542 : {
2543 0 : KillOwnPopups( pWindow );
2544 : }
2545 0 : break;
2546 :
2547 : case SALEVENT_GETFOCUS:
2548 2816 : ImplHandleGetFocus( pWindow );
2549 2816 : break;
2550 : case SALEVENT_LOSEFOCUS:
2551 1929 : ImplHandleLoseFocus( pWindow );
2552 1929 : break;
2553 :
2554 : case SALEVENT_CLOSE:
2555 0 : ImplHandleClose( pWindow );
2556 0 : break;
2557 :
2558 : case SALEVENT_SHUTDOWN:
2559 : {
2560 : static bool bInQueryExit = false;
2561 0 : if( !bInQueryExit )
2562 : {
2563 0 : bInQueryExit = true;
2564 0 : if ( GetpApp()->QueryExit() )
2565 : {
2566 : // Message-Schleife beenden
2567 0 : Application::Quit();
2568 0 : return sal_False;
2569 : }
2570 : else
2571 : {
2572 0 : bInQueryExit = false;
2573 0 : return sal_True;
2574 : }
2575 : }
2576 0 : return sal_False;
2577 : }
2578 :
2579 : case SALEVENT_SETTINGSCHANGED:
2580 : case SALEVENT_VOLUMECHANGED:
2581 : case SALEVENT_PRINTERCHANGED:
2582 : case SALEVENT_DISPLAYCHANGED:
2583 : case SALEVENT_FONTCHANGED:
2584 : case SALEVENT_DATETIMECHANGED:
2585 : case SALEVENT_KEYBOARDCHANGED:
2586 0 : ImplHandleSalSettings( pWindow, nEvent );
2587 0 : break;
2588 :
2589 : case SALEVENT_USEREVENT:
2590 15538 : ImplHandleUserEvent( (ImplSVEvent*)pEvent );
2591 15538 : break;
2592 :
2593 : case SALEVENT_EXTTEXTINPUT:
2594 : {
2595 0 : SalExtTextInputEvent* pEvt = (SalExtTextInputEvent*)pEvent;
2596 : nRet = ImplHandleExtTextInput( pWindow,
2597 : pEvt->maText, pEvt->mpTextAttr,
2598 0 : pEvt->mnCursorPos, pEvt->mnCursorFlags );
2599 : }
2600 0 : break;
2601 : case SALEVENT_ENDEXTTEXTINPUT:
2602 0 : nRet = ImplHandleEndExtTextInput( pWindow );
2603 0 : break;
2604 : case SALEVENT_EXTTEXTINPUTPOS:
2605 0 : ImplHandleSalExtTextInputPos( pWindow, (SalExtTextInputPosEvent*)pEvent );
2606 0 : break;
2607 : case SALEVENT_INPUTCONTEXTCHANGE:
2608 0 : nRet = ImplHandleInputContextChange( pWindow, ((SalInputContextChangeEvent*)pEvent)->meLanguage );
2609 0 : break;
2610 : case SALEVENT_SHOWDIALOG:
2611 : {
2612 0 : int nDialogID = static_cast<int>(reinterpret_cast<sal_IntPtr>(pEvent));
2613 0 : nRet = ImplHandleShowDialog( pWindow, nDialogID );
2614 : }
2615 0 : break;
2616 : case SALEVENT_SURROUNDINGTEXTREQUEST:
2617 0 : ImplHandleSalSurroundingTextRequest( pWindow, (SalSurroundingTextRequestEvent*)pEvent );
2618 0 : break;
2619 : case SALEVENT_SURROUNDINGTEXTSELECTIONCHANGE:
2620 : {
2621 : SalSurroundingTextSelectionChangeEvent* pEvt
2622 0 : = (SalSurroundingTextSelectionChangeEvent*)pEvent;
2623 : ImplHandleSurroundingTextSelectionChange( pWindow,
2624 : pEvt->mnStart,
2625 0 : pEvt->mnEnd );
2626 : }
2627 : case SALEVENT_STARTRECONVERSION:
2628 0 : ImplHandleStartReconversion( pWindow );
2629 0 : break;
2630 : case SALEVENT_EXTERNALZOOM:
2631 : {
2632 0 : ZoomEvent* pZoomEvent = (ZoomEvent*) pEvent;
2633 0 : SalWheelMouseEvent aSalWheelMouseEvent;
2634 :
2635 0 : aSalWheelMouseEvent.mnTime = Time::GetSystemTicks();
2636 0 : aSalWheelMouseEvent.mnX = pZoomEvent->GetCenter().getX();
2637 0 : aSalWheelMouseEvent.mnY = pZoomEvent->GetCenter().getY();
2638 :
2639 : // Pass on the scale as a percentage of current zoom factor
2640 0 : aSalWheelMouseEvent.mnDelta = (long) (pZoomEvent->GetScale() * 100);
2641 :
2642 : // Other SalWheelMouseEvent fields ignored when the
2643 : // scaleDirectly parameter to ImplHandleWheelEvent() is
2644 : // true.
2645 0 : nRet = ImplHandleWheelEvent( pWindow, aSalWheelMouseEvent, true );
2646 : }
2647 0 : break;
2648 : case SALEVENT_EXTERNALSCROLL:
2649 : {
2650 0 : ScrollEvent* pScrollEvent = (ScrollEvent*) pEvent;
2651 0 : SalWheelMouseEvent aSalWheelMouseEvent;
2652 :
2653 0 : aSalWheelMouseEvent.mnTime = Time::GetSystemTicks();
2654 0 : aSalWheelMouseEvent.mnX = 0; // ???
2655 0 : aSalWheelMouseEvent.mnY = 0;
2656 :
2657 : // Note that it seems that the delta-is-pixels thing is
2658 : // not actually implemented. The field is just passed on
2659 : // but its value never tested and has no effect?
2660 0 : aSalWheelMouseEvent.mbDeltaIsPixel = sal_True;
2661 :
2662 : // First scroll vertically, then horizontally
2663 0 : aSalWheelMouseEvent.mnDelta = (long) pScrollEvent->GetYOffset();
2664 :
2665 : // No way to figure out correct amount of "lines" to
2666 : // scroll, and for touch devices (for which this
2667 : // SALEVENBT_EXTERNALSCROLL was introduced) we don't even
2668 : // display the scroll bars. This means that the scroll
2669 : // bars (which still exist as objects, all the scrolling
2670 : // action goes through them) apparently use some dummy
2671 : // default values for range, line size and page size
2672 : // anyway, not related to actual contents of scrolled
2673 : // window. This all is very broken. I really wish the
2674 : // delta-is-pixels feature (which would be exactly what
2675 : // one wants for touch devices) would work.
2676 0 : aSalWheelMouseEvent.mnScrollLines = aSalWheelMouseEvent.mnDelta;
2677 :
2678 0 : if (aSalWheelMouseEvent.mnDelta != 0)
2679 : {
2680 0 : aSalWheelMouseEvent.mnNotchDelta = (aSalWheelMouseEvent.mnDelta < 0) ? -1 : 1;
2681 0 : aSalWheelMouseEvent.mnCode = 0;
2682 0 : aSalWheelMouseEvent.mbHorz = sal_False;
2683 0 : nRet = ImplHandleWheelEvent( pWindow, aSalWheelMouseEvent );
2684 : }
2685 0 : aSalWheelMouseEvent.mnDelta = (long) pScrollEvent->GetXOffset();
2686 0 : if (aSalWheelMouseEvent.mnDelta != 0)
2687 : {
2688 0 : aSalWheelMouseEvent.mnNotchDelta = (aSalWheelMouseEvent.mnDelta < 0) ? -1 : 1;
2689 0 : aSalWheelMouseEvent.mnCode = 0;
2690 0 : aSalWheelMouseEvent.mbHorz = sal_True;
2691 0 : nRet = ImplHandleWheelEvent( pWindow, aSalWheelMouseEvent );
2692 : }
2693 : }
2694 0 : break;
2695 : case SALEVENT_QUERYCHARPOSITION:
2696 0 : ImplHandleSalQueryCharPosition( pWindow, (SalQueryCharPositionEvent*)pEvent );
2697 0 : break;
2698 : #ifdef DBG_UTIL
2699 : default:
2700 : SAL_WARN( "vcl.layout", "ImplWindowFrameProc(): unknown event (" << nEvent << ")" );
2701 : break;
2702 : #endif
2703 : }
2704 :
2705 22263 : return nRet;
2706 465 : }
2707 :
2708 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
