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