?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
OInterfaceContainerHelper3 needs to be thread-safe
[LibreOffice.git] / vcl / win / window / salframe.cxx
blobe016430611ad3729c9caa0aa589b754c4ad5fca5
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
21 #include <com/sun/star/container/XIndexAccess.hpp>
22 #include <com/sun/star/beans/XPropertySet.hpp>
23 #include <com/sun/star/awt/Rectangle.hpp>
24
25 #include <officecfg/Office/Common.hxx>
26
27 #include <memory>
28 #include <string.h>
29 #include <limits.h>
30
31 #include <svsys.h>
32
33 #include <comphelper/windowserrorstring.hxx>
34
35 #include <fstream>
36 #include <boost/property_tree/ptree.hpp>
37 #include <boost/property_tree/ini_parser.hpp>
38 #include <osl/file.hxx>
39 #include <osl/process.h>
40
41 #include <rtl/string.h>
42 #include <rtl/ustring.h>
43 #include <sal/log.hxx>
44
45 #include <osl/module.h>
46
47 #include <tools/debug.hxx>
48 #include <o3tl/enumarray.hxx>
49 #include <o3tl/char16_t2wchar_t.hxx>
50
51 #include <vcl/event.hxx>
52 #include <vcl/sysdata.hxx>
53 #include <vcl/timer.hxx>
54 #include <vcl/settings.hxx>
55 #include <vcl/keycodes.hxx>
56 #include <vcl/window.hxx>
57 #include <vcl/wrkwin.hxx>
58 #include <vcl/svapp.hxx>
59 #include <vcl/ptrstyle.hxx>
60
61 #include <win/wincomp.hxx>
62 #include <win/salids.hrc>
63 #include <win/saldata.hxx>
64 #include <win/salinst.h>
65 #include <win/salbmp.h>
66 #include <win/salgdi.h>
67 #include <win/salsys.h>
68 #include <win/salframe.h>
69 #include <win/salvd.h>
70 #include <win/salmenu.h>
71 #include <win/salobj.h>
72 #include <win/saltimer.h>
73
74 #include <helpwin.hxx>
75 #include <window.h>
76 #include <sallayout.hxx>
77
78 #define COMPILE_MULTIMON_STUBS
79 #pragma warning(push)
80 #pragma warning(disable:4996) // 'GetVersionExA': was declared deprecated
81 #include <multimon.h>
82 #pragma warning(pop)
83 #include <vector>
84
85 #include <com/sun/star/uno/Exception.hpp>
86
87 #include <oleacc.h>
88 #include <com/sun/star/accessibility/XMSAAService.hpp>
89 #ifndef WM_GETOBJECT // TESTME does this ever happen ?
90 # define WM_GETOBJECT 0x003D
91 #endif
92
93 #include <time.h>
94
95 #if !defined WIN32_LEAN_AND_MEAN
96 # define WIN32_LEAN_AND_MEAN
97 #endif
98 #include <windows.h>
99 #include <shobjidl.h>
100 #include <propkey.h>
101 #include <propvarutil.h>
102 #include <shellapi.h>
103
104 using namespace ::com::sun::star;
105 using namespace ::com::sun::star::uno;
106 using namespace ::com::sun::star::lang;
107 using namespace ::com::sun::star::container;
108 using namespace ::com::sun::star::beans;
109
110 #ifndef SPI_GETWHEELSCROLLCHARS
111 # define SPI_GETWHEELSCROLLCHARS 0x006C
112 #endif
113 #ifndef SPI_SETWHEELSCROLLCHARS
114 # define SPI_SETWHEELSCROLLCHARS 0x006D
115 #endif
116 #ifndef WM_MOUSEHWHEEL
117 # define WM_MOUSEHWHEEL 0x020E
118 #endif
119 #ifndef IDC_PEN
120 # define IDC_PEN MAKEINTRESOURCE(32631)
121 #endif
122
123 const unsigned int WM_USER_SYSTEM_WINDOW_ACTIVATED = RegisterWindowMessageW(L"SYSTEM_WINDOW_ACTIVATED");
124
125 bool WinSalFrame::mbInReparent = false;
126
127 // Macros for support of WM_UNICHAR & Keyman 6.0
128 //#define Uni_UTF32ToSurrogate1(ch) (((unsigned long) (ch) - 0x10000) / 0x400 + 0xD800)
129 #define Uni_UTF32ToSurrogate2(ch) ((static_cast<tools::ULong>(ch) - 0x10000) % 0x400 + 0xDC00)
130 #define Uni_SupplementaryPlanesStart 0x10000
131
132 static void UpdateFrameGeometry( HWND hWnd, WinSalFrame* pFrame );
133 static void SetMaximizedFrameGeometry( HWND hWnd, WinSalFrame* pFrame, RECT* pParentRect = nullptr );
134
135 static void ImplSaveFrameState( WinSalFrame* pFrame )
136 {
137 // save position, size and state for GetWindowState()
138 if ( !pFrame->mbFullScreen )
139 {
140 bool bVisible = (GetWindowStyle( pFrame->mhWnd ) & WS_VISIBLE) != 0;
141 if ( IsIconic( pFrame->mhWnd ) )
142 {
143 pFrame->maState.mnState |= WindowStateState::Minimized;
144 if ( bVisible )
145 pFrame->mnShowState = SW_SHOWMAXIMIZED;
146 }
147 else if ( IsZoomed( pFrame->mhWnd ) )
148 {
149 pFrame->maState.mnState &= ~WindowStateState::Minimized;
150 pFrame->maState.mnState |= WindowStateState::Maximized;
151 if ( bVisible )
152 pFrame->mnShowState = SW_SHOWMAXIMIZED;
153 pFrame->mbRestoreMaximize = true;
154
155 WINDOWPLACEMENT aPlacement;
156 aPlacement.length = sizeof(aPlacement);
157 if( GetWindowPlacement( pFrame->mhWnd, &aPlacement ) )
158 {
159 RECT aRect = aPlacement.rcNormalPosition;
160 RECT aRect2 = aRect;
161 AdjustWindowRectEx( &aRect2, GetWindowStyle( pFrame->mhWnd ),
162 FALSE, GetWindowExStyle( pFrame->mhWnd ) );
163 tools::Long nTopDeco = abs( aRect.top - aRect2.top );
164 tools::Long nLeftDeco = abs( aRect.left - aRect2.left );
165 tools::Long nBottomDeco = abs( aRect.bottom - aRect2.bottom );
166 tools::Long nRightDeco = abs( aRect.right - aRect2.right );
167
168 pFrame->maState.mnX = aRect.left + nLeftDeco;
169 pFrame->maState.mnY = aRect.top + nTopDeco;
170 pFrame->maState.mnWidth = aRect.right - aRect.left - nLeftDeco - nRightDeco;
171 pFrame->maState.mnHeight = aRect.bottom - aRect.top - nTopDeco - nBottomDeco;
172 }
173 }
174 else
175 {
176 RECT aRect;
177 GetWindowRect( pFrame->mhWnd, &aRect );
178
179 // to be consistent with Unix, the frame state is without(!) decoration
180 RECT aRect2 = aRect;
181 AdjustWindowRectEx( &aRect2, GetWindowStyle( pFrame->mhWnd ),
182 FALSE, GetWindowExStyle( pFrame->mhWnd ) );
183 tools::Long nTopDeco = abs( aRect.top - aRect2.top );
184 tools::Long nLeftDeco = abs( aRect.left - aRect2.left );
185 tools::Long nBottomDeco = abs( aRect.bottom - aRect2.bottom );
186 tools::Long nRightDeco = abs( aRect.right - aRect2.right );
187
188 pFrame->maState.mnState &= ~WindowStateState(WindowStateState::Minimized | WindowStateState::Maximized);
189 // subtract decoration
190 pFrame->maState.mnX = aRect.left+nLeftDeco;
191 pFrame->maState.mnY = aRect.top+nTopDeco;
192 pFrame->maState.mnWidth = aRect.right-aRect.left-nLeftDeco-nRightDeco;
193 pFrame->maState.mnHeight = aRect.bottom-aRect.top-nTopDeco-nBottomDeco;
194 if ( bVisible )
195 pFrame->mnShowState = SW_SHOWNORMAL;
196 pFrame->mbRestoreMaximize = false;
197 }
198 }
199 }
200
201 // if pParentRect is set, the workarea of the monitor that contains pParentRect is returned
202 void ImplSalGetWorkArea( HWND hWnd, RECT *pRect, const RECT *pParentRect )
203 {
204 // check if we or our parent is fullscreen, then the taskbar should be ignored
205 bool bIgnoreTaskbar = false;
206 WinSalFrame* pFrame = GetWindowPtr( hWnd );
207 if( pFrame )
208 {
209 vcl::Window *pWin = pFrame->GetWindow();
210 while( pWin )
211 {
212 WorkWindow *pWorkWin = (pWin->GetType() == WindowType::WORKWINDOW) ? static_cast<WorkWindow *>(pWin) : nullptr;
213 if( pWorkWin && pWorkWin->ImplGetWindowImpl()->mbReallyVisible && pWorkWin->IsFullScreenMode() )
214 {
215 bIgnoreTaskbar = true;
216 break;
217 }
218 else
219 pWin = pWin->ImplGetWindowImpl()->mpParent;
220 }
221 }
222
223 // calculates the work area taking multiple monitors into account
224 static int nMonitors = GetSystemMetrics( SM_CMONITORS );
225 if( nMonitors == 1 )
226 {
227 if( bIgnoreTaskbar )
228 {
229 pRect->left = pRect->top = 0;
230 pRect->right = GetSystemMetrics( SM_CXSCREEN );
231 pRect->bottom = GetSystemMetrics( SM_CYSCREEN );
232 }
233 else
234 SystemParametersInfoW( SPI_GETWORKAREA, 0, pRect, 0 );
235 }
236 else
237 {
238 if( pParentRect != nullptr )
239 {
240 // return the size of the monitor where pParentRect lives
241 HMONITOR hMonitor;
242 MONITORINFO mi;
243
244 // get the nearest monitor to the passed rect.
245 hMonitor = MonitorFromRect(pParentRect, MONITOR_DEFAULTTONEAREST);
246
247 // get the work area or entire monitor rect.
248 mi.cbSize = sizeof(mi);
249 GetMonitorInfo(hMonitor, &mi);
250 if( !bIgnoreTaskbar )
251 *pRect = mi.rcWork;
252 else
253 *pRect = mi.rcMonitor;
254 }
255 else
256 {
257 // return the union of all monitors
258 pRect->left = GetSystemMetrics( SM_XVIRTUALSCREEN );
259 pRect->top = GetSystemMetrics( SM_YVIRTUALSCREEN );
260 pRect->right = pRect->left + GetSystemMetrics( SM_CXVIRTUALSCREEN );
261 pRect->bottom = pRect->top + GetSystemMetrics( SM_CYVIRTUALSCREEN );
262
263 // virtualscreen does not take taskbar into account, so use the corresponding
264 // diffs between screen and workarea from the default screen
265 // however, this is still not perfect: the taskbar might not be on the primary screen
266 if( !bIgnoreTaskbar )
267 {
268 RECT wRect, scrRect;
269 SystemParametersInfoW( SPI_GETWORKAREA, 0, &wRect, 0 );
270 scrRect.left = 0;
271 scrRect.top = 0;
272 scrRect.right = GetSystemMetrics( SM_CXSCREEN );
273 scrRect.bottom = GetSystemMetrics( SM_CYSCREEN );
274
275 pRect->left += wRect.left;
276 pRect->top += wRect.top;
277 pRect->right -= scrRect.right - wRect.right;
278 pRect->bottom -= scrRect.bottom - wRect.bottom;
279 }
280 }
281 }
282 }
283
284 SalFrame* ImplSalCreateFrame( WinSalInstance* pInst,
285 HWND hWndParent, SalFrameStyleFlags nSalFrameStyle )
286 {
287 WinSalFrame* pFrame = new WinSalFrame;
288 HWND hWnd;
289 DWORD nSysStyle = 0;
290 DWORD nExSysStyle = 0;
291 bool bSubFrame = false;
292
293 static const char* pEnvSynchronize = getenv("SAL_SYNCHRONIZE");
294 if ( pEnvSynchronize ) // no buffering of drawing commands
295 GdiSetBatchLimit( 1 );
296
297 static const char* pEnvTransparentFloats = getenv("SAL_TRANSPARENT_FLOATS" );
298
299 // determine creation data
300 if ( nSalFrameStyle & (SalFrameStyleFlags::PLUG | SalFrameStyleFlags::SYSTEMCHILD) )
301 {
302 nSysStyle |= WS_CHILD;
303 if( nSalFrameStyle & SalFrameStyleFlags::SYSTEMCHILD )
304 nSysStyle |= WS_CLIPSIBLINGS;
305 }
306 else
307 {
308 // #i87402# commenting out WS_CLIPCHILDREN
309 // this breaks SalFrameStyleFlags::SYSTEMCHILD handling, which is not
310 // used currently. Probably SalFrameStyleFlags::SYSTEMCHILD should be
311 // removed again.
312
313 // nSysStyle |= WS_CLIPCHILDREN;
314 if ( hWndParent )
315 {
316 nSysStyle |= WS_POPUP;
317 bSubFrame = true;
318 pFrame->mbNoIcon = true;
319 }
320 else
321 {
322 // Only with WS_OVERLAPPED we get a useful default position/size
323 if ( (nSalFrameStyle & (SalFrameStyleFlags::SIZEABLE | SalFrameStyleFlags::MOVEABLE)) ==
324 (SalFrameStyleFlags::SIZEABLE | SalFrameStyleFlags::MOVEABLE) )
325 nSysStyle |= WS_OVERLAPPED;
326 else
327 {
328 nSysStyle |= WS_POPUP;
329 if ( !(nSalFrameStyle & SalFrameStyleFlags::MOVEABLE) )
330 nExSysStyle |= WS_EX_TOOLWINDOW; // avoid taskbar appearance, for eg splash screen
331 }
332 }
333
334 if ( nSalFrameStyle & SalFrameStyleFlags::MOVEABLE )
335 {
336 pFrame->mbCaption = true;
337 nSysStyle |= WS_SYSMENU | WS_CAPTION;
338 if ( !hWndParent )
339 nSysStyle |= WS_SYSMENU | WS_MINIMIZEBOX;
340 else
341 nExSysStyle |= WS_EX_DLGMODALFRAME;
342
343 if ( nSalFrameStyle & SalFrameStyleFlags::SIZEABLE )
344 {
345 pFrame->mbSizeBorder = true;
346 nSysStyle |= WS_THICKFRAME;
347 if ( !hWndParent )
348 nSysStyle |= WS_MAXIMIZEBOX;
349 }
350 else
351 pFrame->mbFixBorder = true;
352
353 if ( nSalFrameStyle & SalFrameStyleFlags::DEFAULT )
354 nExSysStyle |= WS_EX_APPWINDOW;
355 }
356 if( nSalFrameStyle & SalFrameStyleFlags::TOOLWINDOW
357 // #100656# toolwindows lead to bad alt-tab behaviour, if they have the focus
358 // you must press it twice to leave the application
359 // so toolwindows are only used for non sizeable windows
360 // which are typically small, so a small caption makes sense
361
362 // #103578# looked too bad - above changes reverted
363 /* && !(nSalFrameStyle & SalFrameStyleFlags::SIZEABLE) */ )
364 {
365 pFrame->mbNoIcon = true;
366 nExSysStyle |= WS_EX_TOOLWINDOW;
367 if ( pEnvTransparentFloats /*&& !(nSalFrameStyle & SalFrameStyleFlags::MOVEABLE) */)
368 nExSysStyle |= WS_EX_LAYERED;
369 }
370 }
371 if ( nSalFrameStyle & SalFrameStyleFlags::FLOAT )
372 {
373 nExSysStyle |= WS_EX_TOOLWINDOW;
374 pFrame->mbFloatWin = true;
375
376 if (pEnvTransparentFloats)
377 nExSysStyle |= WS_EX_LAYERED;
378
379 }
380 if (nSalFrameStyle & SalFrameStyleFlags::TOOLTIP)
381 nExSysStyle |= WS_EX_TOPMOST;
382
383 // init frame data
384 pFrame->mnStyle = nSalFrameStyle;
385
386 // determine show style
387 pFrame->mnShowState = SW_SHOWNORMAL;
388 if ( (nSysStyle & (WS_POPUP | WS_MAXIMIZEBOX | WS_THICKFRAME)) == (WS_MAXIMIZEBOX | WS_THICKFRAME) )
389 {
390 if ( GetSystemMetrics( SM_CXSCREEN ) <= 1024 )
391 pFrame->mnShowState = SW_SHOWMAXIMIZED;
392 else
393 {
394 if ( nSalFrameStyle & SalFrameStyleFlags::DEFAULT )
395 {
396 SalData* pSalData = GetSalData();
397 pFrame->mnShowState = pSalData->mnCmdShow;
398 if ( (pFrame->mnShowState != SW_SHOWMINIMIZED) &&
399 (pFrame->mnShowState != SW_MINIMIZE) &&
400 (pFrame->mnShowState != SW_SHOWMINNOACTIVE) )
401 {
402 if ( (pFrame->mnShowState == SW_SHOWMAXIMIZED) ||
403 (pFrame->mnShowState == SW_MAXIMIZE) )
404 pFrame->mbOverwriteState = false;
405 pFrame->mnShowState = SW_SHOWMAXIMIZED;
406 }
407 else
408 pFrame->mbOverwriteState = false;
409 }
410 else
411 {
412 // Document Windows are also maximized, if the current Document Window
413 // is also maximized
414 HWND hWnd2 = GetForegroundWindow();
415 if ( hWnd2 && IsMaximized( hWnd2 ) &&
416 (GetWindowInstance( hWnd2 ) == pInst->mhInst) &&
417 ((GetWindowStyle( hWnd2 ) & (WS_POPUP | WS_MAXIMIZEBOX | WS_THICKFRAME)) == (WS_MAXIMIZEBOX | WS_THICKFRAME)) )
418 pFrame->mnShowState = SW_SHOWMAXIMIZED;
419 }
420 }
421 }
422
423 // create frame
424 LPCWSTR pClassName;
425 if ( bSubFrame )
426 {
427 if ( nSalFrameStyle & (SalFrameStyleFlags::MOVEABLE|SalFrameStyleFlags::NOSHADOW) ) // check if shadow not wanted
428 pClassName = SAL_SUBFRAME_CLASSNAMEW;
429 else
430 pClassName = SAL_TMPSUBFRAME_CLASSNAMEW; // undecorated floaters will get shadow on XP
431 }
432 else
433 {
434 if ( nSalFrameStyle & SalFrameStyleFlags::MOVEABLE )
435 pClassName = SAL_FRAME_CLASSNAMEW;
436 else
437 pClassName = SAL_TMPSUBFRAME_CLASSNAMEW;
438 }
439 hWnd = CreateWindowExW( nExSysStyle, pClassName, L"", nSysStyle,
440 CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
441 hWndParent, nullptr, pInst->mhInst, pFrame );
442 SAL_WARN_IF(!hWnd, "vcl", "CreateWindowExW failed: " << WindowsErrorString(GetLastError()));
443
444 #if OSL_DEBUG_LEVEL > 1
445 // set transparency value
446 if( GetWindowExStyle( hWnd ) & WS_EX_LAYERED )
447 SetLayeredWindowAttributes( hWnd, 0, 230, 0x00000002 /*LWA_ALPHA*/ );
448 #endif
449 if ( !hWnd )
450 {
451 delete pFrame;
452 return nullptr;
453 }
454
455 // If we have a Window with a Caption Bar and without
456 // a MaximizeBox, we change the SystemMenu
457 if ( (nSysStyle & (WS_CAPTION | WS_MAXIMIZEBOX)) == (WS_CAPTION) )
458 {
459 HMENU hSysMenu = GetSystemMenu( hWnd, FALSE );
460 if ( hSysMenu )
461 {
462 if ( !(nSysStyle & (WS_MINIMIZEBOX | WS_MAXIMIZEBOX)) )
463 DeleteMenu( hSysMenu, SC_RESTORE, MF_BYCOMMAND );
464 else
465 EnableMenuItem( hSysMenu, SC_RESTORE, MF_BYCOMMAND | MF_GRAYED | MF_DISABLED );
466 if ( !(nSysStyle & WS_MINIMIZEBOX) )
467 DeleteMenu( hSysMenu, SC_MINIMIZE, MF_BYCOMMAND );
468 if ( !(nSysStyle & WS_MAXIMIZEBOX) )
469 DeleteMenu( hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND );
470 if ( !(nSysStyle & WS_THICKFRAME) )
471 DeleteMenu( hSysMenu, SC_SIZE, MF_BYCOMMAND );
472 }
473 }
474 if ( (nSysStyle & WS_SYSMENU) && !(nSalFrameStyle & SalFrameStyleFlags::CLOSEABLE) )
475 {
476 HMENU hSysMenu = GetSystemMenu( hWnd, FALSE );
477 if ( hSysMenu )
478 EnableMenuItem( hSysMenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED | MF_DISABLED );
479 }
480
481 // reset input context
482 pFrame->mhDefIMEContext = ImmAssociateContext( hWnd, nullptr );
483
484 // determine output size and state
485 RECT aRect;
486 GetClientRect( hWnd, &aRect );
487 pFrame->mnWidth = aRect.right;
488 pFrame->mnHeight = aRect.bottom;
489 ImplSaveFrameState( pFrame );
490 pFrame->mbDefPos = true;
491
492 UpdateFrameGeometry( hWnd, pFrame );
493
494 if( pFrame->mnShowState == SW_SHOWMAXIMIZED )
495 {
496 // #96084 set a useful internal window size because
497 // the window will not be maximized (and the size updated) before show()
498
499 SetMaximizedFrameGeometry( hWnd, pFrame );
500 }
501
502 return pFrame;
503 }
504
505 // helper that only creates the HWND
506 // to allow for easy reparenting of system windows, (i.e. destroy and create new)
507 HWND ImplSalReCreateHWND( HWND hWndParent, HWND oldhWnd, bool bAsChild )
508 {
509 HINSTANCE hInstance = GetSalData()->mhInst;
510 sal_uLong nSysStyle = GetWindowLongW( oldhWnd, GWL_STYLE );
511 sal_uLong nExSysStyle = GetWindowLongW( oldhWnd, GWL_EXSTYLE );
512
513 if( bAsChild )
514 {
515 nSysStyle = WS_CHILD;
516 nExSysStyle = 0;
517 }
518
519 LPCWSTR pClassName = SAL_SUBFRAME_CLASSNAMEW;
520 return CreateWindowExW( nExSysStyle, pClassName, L"", nSysStyle,
521 CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
522 hWndParent, nullptr, hInstance, GetWindowPtr( oldhWnd ) );
523 }
524
525 // translation table from System keycodes into StartView keycodes
526 #define KEY_TAB_SIZE 146
527
528 const sal_uInt16 aImplTranslateKeyTab[KEY_TAB_SIZE] =
529 {
530 // StarView-Code System-Code Index
531 0, // 0
532 0, // VK_LBUTTON 1
533 0, // VK_RBUTTON 2
534 0, // VK_CANCEL 3
535 0, // VK_MBUTTON 4
536 0, // 5
537 0, // 6
538 0, // 7
539 KEY_BACKSPACE, // VK_BACK 8
540 KEY_TAB, // VK_TAB 9
541 0, // 10
542 0, // 11
543 0, // VK_CLEAR 12
544 KEY_RETURN, // VK_RETURN 13
545 0, // 14
546 0, // 15
547 0, // VK_SHIFT 16
548 0, // VK_CONTROL 17
549 0, // VK_MENU 18
550 0, // VK_PAUSE 19
551 0, // VK_CAPITAL 20
552 0, // VK_HANGUL 21
553 0, // 22
554 0, // 23
555 0, // 24
556 KEY_HANGUL_HANJA, // VK_HANJA 25
557 0, // 26
558 KEY_ESCAPE, // VK_ESCAPE 27
559 0, // 28
560 0, // 29
561 0, // 30
562 0, // 31
563 KEY_SPACE, // VK_SPACE 32
564 KEY_PAGEUP, // VK_PRIOR 33
565 KEY_PAGEDOWN, // VK_NEXT 34
566 KEY_END, // VK_END 35
567 KEY_HOME, // VK_HOME 36
568 KEY_LEFT, // VK_LEFT 37
569 KEY_UP, // VK_UP 38
570 KEY_RIGHT, // VK_RIGHT 39
571 KEY_DOWN, // VK_DOWN 40
572 0, // VK_SELECT 41
573 0, // VK_PRINT 42
574 0, // VK_EXECUTE 43
575 0, // VK_SNAPSHOT 44
576 KEY_INSERT, // VK_INSERT 45
577 KEY_DELETE, // VK_DELETE 46
578 KEY_HELP, // VK_HELP 47
579 KEY_0, // 48
580 KEY_1, // 49
581 KEY_2, // 50
582 KEY_3, // 51
583 KEY_4, // 52
584 KEY_5, // 53
585 KEY_6, // 54
586 KEY_7, // 55
587 KEY_8, // 56
588 KEY_9, // 57
589 0, // 58
590 0, // 59
591 0, // 60
592 0, // 61
593 0, // 62
594 0, // 63
595 0, // 64
596 KEY_A, // 65
597 KEY_B, // 66
598 KEY_C, // 67
599 KEY_D, // 68
600 KEY_E, // 69
601 KEY_F, // 70
602 KEY_G, // 71
603 KEY_H, // 72
604 KEY_I, // 73
605 KEY_J, // 74
606 KEY_K, // 75
607 KEY_L, // 76
608 KEY_M, // 77
609 KEY_N, // 78
610 KEY_O, // 79
611 KEY_P, // 80
612 KEY_Q, // 81
613 KEY_R, // 82
614 KEY_S, // 83
615 KEY_T, // 84
616 KEY_U, // 85
617 KEY_V, // 86
618 KEY_W, // 87
619 KEY_X, // 88
620 KEY_Y, // 89
621 KEY_Z, // 90
622 0, // VK_LWIN 91
623 0, // VK_RWIN 92
624 KEY_CONTEXTMENU, // VK_APPS 93
625 0, // 94
626 0, // 95
627 KEY_0, // VK_NUMPAD0 96
628 KEY_1, // VK_NUMPAD1 97
629 KEY_2, // VK_NUMPAD2 98
630 KEY_3, // VK_NUMPAD3 99
631 KEY_4, // VK_NUMPAD4 100
632 KEY_5, // VK_NUMPAD5 101
633 KEY_6, // VK_NUMPAD6 102
634 KEY_7, // VK_NUMPAD7 103
635 KEY_8, // VK_NUMPAD8 104
636 KEY_9, // VK_NUMPAD9 105
637 KEY_MULTIPLY, // VK_MULTIPLY 106
638 KEY_ADD, // VK_ADD 107
639 KEY_DECIMAL, // VK_SEPARATOR 108
640 KEY_SUBTRACT, // VK_SUBTRACT 109
641 KEY_DECIMAL, // VK_DECIMAL 110
642 KEY_DIVIDE, // VK_DIVIDE 111
643 KEY_F1, // VK_F1 112
644 KEY_F2, // VK_F2 113
645 KEY_F3, // VK_F3 114
646 KEY_F4, // VK_F4 115
647 KEY_F5, // VK_F5 116
648 KEY_F6, // VK_F6 117
649 KEY_F7, // VK_F7 118
650 KEY_F8, // VK_F8 119
651 KEY_F9, // VK_F9 120
652 KEY_F10, // VK_F10 121
653 KEY_F11, // VK_F11 122
654 KEY_F12, // VK_F12 123
655 KEY_F13, // VK_F13 124
656 KEY_F14, // VK_F14 125
657 KEY_F15, // VK_F15 126
658 KEY_F16, // VK_F16 127
659 KEY_F17, // VK_F17 128
660 KEY_F18, // VK_F18 129
661 KEY_F19, // VK_F19 130
662 KEY_F20, // VK_F20 131
663 KEY_F21, // VK_F21 132
664 KEY_F22, // VK_F22 133
665 KEY_F23, // VK_F23 134
666 KEY_F24, // VK_F24 135
667 0, // 136
668 0, // 137
669 0, // 138
670 0, // 139
671 0, // 140
672 0, // 141
673 0, // 142
674 0, // 143
675 0, // NUMLOCK 144
676 0 // SCROLLLOCK 145
677 };
678
679 static UINT ImplSalGetWheelScrollLines()
680 {
681 UINT nScrLines = 0;
682 HWND hWndMsWheel = FindWindowW( MSH_WHEELMODULE_CLASS, MSH_WHEELMODULE_TITLE );
683 if ( hWndMsWheel )
684 {
685 UINT nGetScrollLinesMsgId = RegisterWindowMessageW( MSH_SCROLL_LINES );
686 nScrLines = static_cast<UINT>(SendMessageW( hWndMsWheel, nGetScrollLinesMsgId, 0, 0 ));
687 }
688
689 if ( !nScrLines )
690 if( !SystemParametersInfoW( SPI_GETWHEELSCROLLLINES, 0, &nScrLines, 0 ) )
691 nScrLines = 0 ;
692
693 if ( !nScrLines )
694 nScrLines = 3;
695
696 return nScrLines;
697 }
698
699 static UINT ImplSalGetWheelScrollChars()
700 {
701 UINT nScrChars = 0;
702 if( !SystemParametersInfoW( SPI_GETWHEELSCROLLCHARS, 0, &nScrChars, 0 ) )
703 {
704 return 3;
705 }
706
707 // system settings successfully read
708 return nScrChars;
709 }
710
711 static void ImplSalAddBorder( const WinSalFrame* pFrame, int& width, int& height )
712 {
713 // transform client size into window size
714 RECT aWinRect;
715 aWinRect.left = 0;
716 aWinRect.right = width-1;
717 aWinRect.top = 0;
718 aWinRect.bottom = height-1;
719 AdjustWindowRectEx( &aWinRect, GetWindowStyle( pFrame->mhWnd ),
720 FALSE, GetWindowExStyle( pFrame->mhWnd ) );
721 width = aWinRect.right - aWinRect.left + 1;
722 height = aWinRect.bottom - aWinRect.top + 1;
723 }
724
725 static void ImplSalCalcFullScreenSize( const WinSalFrame* pFrame,
726 int& rX, int& rY, int& rDX, int& rDY )
727 {
728 // set window to screen size
729 int nFrameX;
730 int nFrameY;
731 int nCaptionY;
732 int nScreenX = 0;
733 int nScreenY = 0;
734 int nScreenDX = 0;
735 int nScreenDY = 0;
736
737 if ( pFrame->mbSizeBorder )
738 {
739 nFrameX = GetSystemMetrics( SM_CXSIZEFRAME );
740 nFrameY = GetSystemMetrics( SM_CYSIZEFRAME );
741 }
742 else if ( pFrame->mbFixBorder )
743 {
744 nFrameX = GetSystemMetrics( SM_CXFIXEDFRAME );
745 nFrameY = GetSystemMetrics( SM_CYFIXEDFRAME );
746 }
747 else if ( pFrame->mbBorder )
748 {
749 nFrameX = GetSystemMetrics( SM_CXBORDER );
750 nFrameY = GetSystemMetrics( SM_CYBORDER );
751 }
752 else
753 {
754 nFrameX = 0;
755 nFrameY = 0;
756 }
757 if ( pFrame->mbCaption )
758 nCaptionY = GetSystemMetrics( SM_CYCAPTION );
759 else
760 nCaptionY = 0;
761
762 try
763 {
764 sal_Int32 nMonitors = Application::GetScreenCount();
765 if( (pFrame->mnDisplay >= 0) && (pFrame->mnDisplay < nMonitors) )
766 {
767 tools::Rectangle aRect = Application::GetScreenPosSizePixel( pFrame->mnDisplay );
768 nScreenX = aRect.Left();
769 nScreenY = aRect.Top();
770 nScreenDX = aRect.GetWidth();
771 nScreenDY = aRect.GetHeight();
772 }
773 else
774 {
775 tools::Rectangle aCombined = Application::GetScreenPosSizePixel( 0 );
776 for( sal_Int32 i = 1 ; i < nMonitors ; i++ )
777 {
778 aCombined.Union( Application::GetScreenPosSizePixel( i ) );
779 }
780 nScreenX = aCombined.Left();
781 nScreenY = aCombined.Top();
782 nScreenDX = aCombined.GetWidth();
783 nScreenDY = aCombined.GetHeight();
784 }
785 }
786 catch( Exception& )
787 {
788 }
789
790 if( !nScreenDX || !nScreenDY )
791 {
792 nScreenDX = GetSystemMetrics( SM_CXSCREEN );
793 nScreenDY = GetSystemMetrics( SM_CYSCREEN );
794 }
795
796 rX = nScreenX -nFrameX;
797 rY = nScreenY -(nFrameY+nCaptionY);
798 rDX = nScreenDX+(nFrameX*2);
799 rDY = nScreenDY+(nFrameY*2)+nCaptionY;
800 }
801
802 static void ImplSalFrameFullScreenPos( WinSalFrame* pFrame, bool bAlways = false )
803 {
804 if ( bAlways || !IsIconic( pFrame->mhWnd ) )
805 {
806 // set window to screen size
807 int nX;
808 int nY;
809 int nWidth;
810 int nHeight;
811 ImplSalCalcFullScreenSize( pFrame, nX, nY, nWidth, nHeight );
812 SetWindowPos( pFrame->mhWnd, nullptr,
813 nX, nY, nWidth, nHeight,
814 SWP_NOZORDER | SWP_NOACTIVATE );
815 }
816 }
817
818 namespace {
819
820 void SetForegroundWindow_Impl(HWND hwnd)
821 {
822 if (!Application::IsHeadlessModeEnabled())
823 SetForegroundWindow(hwnd);
824 }
825
826 }
827
828 WinSalFrame::WinSalFrame()
829 {
830 SalData* pSalData = GetSalData();
831
832 mhWnd = nullptr;
833 mhCursor = LoadCursor( nullptr, IDC_ARROW );
834 mhDefIMEContext = nullptr;
835 mpLocalGraphics = nullptr;
836 mpThreadGraphics = nullptr;
837 mnShowState = SW_SHOWNORMAL;
838 mnWidth = 0;
839 mnHeight = 0;
840 mnMinWidth = 0;
841 mnMinHeight = 0;
842 mnMaxWidth = SHRT_MAX;
843 mnMaxHeight = SHRT_MAX;
844 mnInputLang = 0;
845 mnInputCodePage = 0;
846 mbGraphics = false;
847 mbCaption = false;
848 mbBorder = false;
849 mbFixBorder = false;
850 mbSizeBorder = false;
851 mbFullScreenCaption = false;
852 mbFullScreen = false;
853 mbPresentation = false;
854 mbInShow = false;
855 mbRestoreMaximize = false;
856 mbInMoveMsg = false;
857 mbInSizeMsg = false;
858 mbFullScreenToolWin = false;
859 mbDefPos = true;
860 mbOverwriteState = true;
861 mbIME = false;
862 mbHandleIME = false;
863 mbSpezIME = false;
864 mbAtCursorIME = false;
865 mbCandidateMode = false;
866 mbFloatWin = false;
867 mbNoIcon = false;
868 mSelectedhMenu = nullptr;
869 mLastActivatedhMenu = nullptr;
870 mpClipRgnData = nullptr;
871 mbFirstClipRect = true;
872 mpNextClipRect = nullptr;
873 mnDisplay = 0;
874 mbPropertiesStored = false;
875
876 // get data, when making 1st frame
877 if ( !pSalData->mpFirstFrame )
878 {
879 if ( !aSalShlData.mnWheelScrollLines )
880 aSalShlData.mnWheelScrollLines = ImplSalGetWheelScrollLines();
881 if ( !aSalShlData.mnWheelScrollChars )
882 aSalShlData.mnWheelScrollChars = ImplSalGetWheelScrollChars();
883 }
884
885 // insert frame in framelist
886 mpNextFrame = pSalData->mpFirstFrame;
887 pSalData->mpFirstFrame = this;
888 }
889
890 void WinSalFrame::updateScreenNumber()
891 {
892 if( mnDisplay == -1 ) // spans all monitors
893 return;
894 WinSalSystem* pSys = static_cast<WinSalSystem*>(ImplGetSalSystem());
895 if( pSys )
896 {
897 const std::vector<WinSalSystem::DisplayMonitor>& rMonitors =
898 pSys->getMonitors();
899 Point aPoint( maGeometry.nX, maGeometry.nY );
900 size_t nMon = rMonitors.size();
901 for( size_t i = 0; i < nMon; i++ )
902 {
903 if( rMonitors[i].m_aArea.IsInside( aPoint ) )
904 {
905 mnDisplay = static_cast<sal_Int32>(i);
906 maGeometry.nDisplayScreenNumber = static_cast<unsigned int>(i);
907 }
908 }
909 }
910 }
911
912 bool WinSalFrame::ReleaseFrameGraphicsDC( WinSalGraphics* pGraphics )
913 {
914 assert( pGraphics );
915 SalData* pSalData = GetSalData();
916 HDC hDC = pGraphics->getHDC();
917 if ( !hDC )
918 return false;
919 if ( pGraphics->getDefPal() )
920 SelectPalette( hDC, pGraphics->getDefPal(), TRUE );
921 pGraphics->DeInitGraphics();
922 SendMessageW( pSalData->mpInstance->mhComWnd, SAL_MSG_RELEASEDC,
923 reinterpret_cast<WPARAM>(mhWnd), reinterpret_cast<LPARAM>(hDC) );
924 if ( pGraphics == mpThreadGraphics )
925 pSalData->mnCacheDCInUse--;
926 pGraphics->setHDC(nullptr);
927 return true;
928 }
929
930 WinSalFrame::~WinSalFrame()
931 {
932 SalData* pSalData = GetSalData();
933
934 if( mpClipRgnData )
935 delete [] reinterpret_cast<BYTE*>(mpClipRgnData);
936
937 // remove frame from framelist
938 WinSalFrame** ppFrame = &pSalData->mpFirstFrame;
939 for(; (*ppFrame != this) && *ppFrame; ppFrame = &(*ppFrame)->mpNextFrame );
940 if( *ppFrame )
941 *ppFrame = mpNextFrame;
942 mpNextFrame = nullptr;
943
944 // destroy the thread SalGraphics
945 if ( mpThreadGraphics )
946 {
947 ReleaseFrameGraphicsDC( mpThreadGraphics );
948 delete mpThreadGraphics;
949 mpThreadGraphics = nullptr;
950 }
951
952 // destroy the local SalGraphics
953 if ( mpLocalGraphics )
954 {
955 ReleaseFrameGraphicsDC( mpLocalGraphics );
956 delete mpLocalGraphics;
957 mpLocalGraphics = nullptr;
958 }
959
960 if ( mhWnd )
961 {
962 // reset mouse leave data
963 if ( pSalData->mhWantLeaveMsg == mhWnd )
964 {
965 pSalData->mhWantLeaveMsg = nullptr;
966 if ( pSalData->mpMouseLeaveTimer )
967 {
968 delete pSalData->mpMouseLeaveTimer;
969 pSalData->mpMouseLeaveTimer = nullptr;
970 }
971 }
972
973 // remove windows properties
974 if ( mbPropertiesStored )
975 SetApplicationID( OUString() );
976
977 // destroy system frame
978 if ( !DestroyWindow( mhWnd ) )
979 SetWindowPtr( mhWnd, nullptr );
980
981 mhWnd = nullptr;
982 }
983 }
984
985 bool WinSalFrame::InitFrameGraphicsDC( WinSalGraphics *pGraphics, HDC hDC, HWND hWnd )
986 {
987 SalData* pSalData = GetSalData();
988 assert( pGraphics );
989 pGraphics->setHWND( hWnd );
990
991 HDC hCurrentDC = pGraphics->getHDC();
992 assert( !hCurrentDC || (hCurrentDC == hDC) );
993 if ( hCurrentDC )
994 return true;
995 pGraphics->setHDC( hDC );
996
997 if ( !hDC )
998 return false;
999
1000 if ( pSalData->mhDitherPal )
1001 {
1002 pGraphics->setDefPal(SelectPalette( hDC, pSalData->mhDitherPal, TRUE ));
1003 RealizePalette( hDC );
1004 }
1005 pGraphics->InitGraphics();
1006
1007 if ( pGraphics == mpThreadGraphics )
1008 pSalData->mnCacheDCInUse++;
1009 return true;
1010 }
1011
1012 SalGraphics* WinSalFrame::AcquireGraphics()
1013 {
1014 if ( mbGraphics || !mhWnd )
1015 return nullptr;
1016
1017 SalData* pSalData = GetSalData();
1018 WinSalGraphics *pGraphics = nullptr;
1019 HDC hDC = nullptr;
1020
1021 // Other threads get an own DC, because Windows modify in the
1022 // other case our DC (changing clip region), when they send a
1023 // WM_ERASEBACKGROUND message
1024 if ( !pSalData->mpInstance->IsMainThread() )
1025 {
1026 // We use only three CacheDC's for all threads, because W9x is limited
1027 // to max. 5 Cache DC's per thread
1028 if ( pSalData->mnCacheDCInUse >= 3 )
1029 return nullptr;
1030
1031 if ( !mpThreadGraphics )
1032 mpThreadGraphics = new WinSalGraphics(WinSalGraphics::WINDOW, true, mhWnd, this);
1033 pGraphics = mpThreadGraphics;
1034 assert( !pGraphics->getHDC() );
1035 hDC = reinterpret_cast<HDC>(static_cast<sal_IntPtr>(SendMessageW( pSalData->mpInstance->mhComWnd,
1036 SAL_MSG_GETCACHEDDC, reinterpret_cast<WPARAM>(mhWnd), 0 )));
1037 }
1038 else
1039 {
1040 if ( !mpLocalGraphics )
1041 mpLocalGraphics = new WinSalGraphics(WinSalGraphics::WINDOW, true, mhWnd, this);
1042 pGraphics = mpLocalGraphics;
1043 hDC = pGraphics->getHDC();
1044 if ( !hDC )
1045 hDC = GetDC( mhWnd );
1046 }
1047
1048 mbGraphics = InitFrameGraphicsDC( pGraphics, hDC, mhWnd );
1049 return mbGraphics ? pGraphics : nullptr;
1050 }
1051
1052 void WinSalFrame::ReleaseGraphics( SalGraphics* pGraphics )
1053 {
1054 if ( mpThreadGraphics == pGraphics )
1055 ReleaseFrameGraphicsDC( mpThreadGraphics );
1056 mbGraphics = false;
1057 }
1058
1059 bool WinSalFrame::PostEvent(std::unique_ptr<ImplSVEvent> pData)
1060 {
1061 bool const ret = PostMessageW(mhWnd, SAL_MSG_USEREVENT, 0, reinterpret_cast<LPARAM>(pData.release()));
1062 SAL_WARN_IF(!ret, "vcl", "ERROR: PostMessage() failed!");
1063 return ret;
1064 }
1065
1066 void WinSalFrame::SetTitle( const OUString& rTitle )
1067 {
1068 static_assert( sizeof( WCHAR ) == sizeof( sal_Unicode ), "must be the same size" );
1069
1070 SetWindowTextW( mhWnd, o3tl::toW(rTitle.getStr()) );
1071 }
1072
1073 void WinSalFrame::SetIcon( sal_uInt16 nIcon )
1074 {
1075 // If we have a window without an Icon (for example a dialog), ignore this call
1076 if ( mbNoIcon )
1077 return;
1078
1079 // 0 means default (class) icon
1080 HICON hIcon = nullptr, hSmIcon = nullptr;
1081 if ( !nIcon )
1082 nIcon = 1;
1083
1084 ImplLoadSalIcon( nIcon, hIcon, hSmIcon );
1085
1086 SAL_WARN_IF( !hIcon , "vcl", "WinSalFrame::SetIcon(): Could not load large icon !" );
1087 SAL_WARN_IF( !hSmIcon , "vcl", "WinSalFrame::SetIcon(): Could not load small icon !" );
1088
1089 SendMessageW( mhWnd, WM_SETICON, ICON_BIG, reinterpret_cast<LPARAM>(hIcon) );
1090 SendMessageW( mhWnd, WM_SETICON, ICON_SMALL, reinterpret_cast<LPARAM>(hSmIcon) );
1091 }
1092
1093 void WinSalFrame::SetMenu( SalMenu* pSalMenu )
1094 {
1095 WinSalMenu* pWMenu = static_cast<WinSalMenu*>(pSalMenu);
1096 if( pSalMenu && pWMenu->mbMenuBar )
1097 ::SetMenu( mhWnd, pWMenu->mhMenu );
1098 }
1099
1100 void WinSalFrame::DrawMenuBar()
1101 {
1102 ::DrawMenuBar( mhWnd );
1103 }
1104
1105 static HWND ImplGetParentHwnd( HWND hWnd )
1106 {
1107 WinSalFrame* pFrame = GetWindowPtr( hWnd );
1108 if( !pFrame || !pFrame->GetWindow())
1109 return ::GetParent( hWnd );
1110 vcl::Window *pRealParent = pFrame->GetWindow()->ImplGetWindowImpl()->mpRealParent;
1111 if( pRealParent )
1112 return static_cast<WinSalFrame*>(pRealParent->ImplGetWindowImpl()->mpFrame)->mhWnd;
1113 else
1114 return ::GetParent( hWnd );
1115
1116 }
1117
1118 SalFrame* WinSalFrame::GetParent() const
1119 {
1120 return GetWindowPtr( ImplGetParentHwnd( mhWnd ) );
1121 }
1122
1123 static void ImplSalShow( HWND hWnd, bool bVisible, bool bNoActivate )
1124 {
1125 WinSalFrame* pFrame = GetWindowPtr( hWnd );
1126 if ( !pFrame )
1127 return;
1128
1129 if ( bVisible )
1130 {
1131 pFrame->mbDefPos = false;
1132 pFrame->mbOverwriteState = true;
1133 pFrame->mbInShow = true;
1134
1135 // #i4715, save position
1136 RECT aRectPreMatrox, aRectPostMatrox;
1137 GetWindowRect( hWnd, &aRectPreMatrox );
1138
1139 vcl::DeletionListener aDogTag( pFrame );
1140 if( bNoActivate )
1141 ShowWindow( hWnd, SW_SHOWNOACTIVATE );
1142 else
1143 ShowWindow( hWnd, pFrame->mnShowState );
1144 if( aDogTag.isDeleted() )
1145 return;
1146
1147 if (pFrame->mbFloatWin && !(pFrame->mnStyle & SalFrameStyleFlags::NOSHADOW))
1148 {
1149 // erase the window immediately to improve XP shadow effect
1150 // otherwise the shadow may appears long time before the rest of the window
1151 // especially when accessibility is on
1152 HDC dc = GetDC( hWnd );
1153 RECT aRect;
1154 GetClientRect( hWnd, &aRect );
1155 FillRect( dc, &aRect, reinterpret_cast<HBRUSH>(COLOR_MENU+1) ); // choose the menucolor, because its mostly noticeable for menus
1156 ReleaseDC( hWnd, dc );
1157 }
1158
1159 // #i4715, matrox centerpopup might have changed our position
1160 // reposition popups without caption (menus, dropdowns, tooltips)
1161 GetWindowRect( hWnd, &aRectPostMatrox );
1162 if( (GetWindowStyle( hWnd ) & WS_POPUP) &&
1163 !pFrame->mbCaption &&
1164 (aRectPreMatrox.left != aRectPostMatrox.left || aRectPreMatrox.top != aRectPostMatrox.top) )
1165 SetWindowPos( hWnd, nullptr, aRectPreMatrox.left, aRectPreMatrox.top, 0, 0, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE );
1166
1167 if( aDogTag.isDeleted() )
1168 return;
1169 vcl::Window *pClientWin = pFrame->GetWindow()->ImplGetClientWindow();
1170 if ( pFrame->mbFloatWin || ( pClientWin && (pClientWin->GetStyle() & WB_SYSTEMFLOATWIN) ) )
1171 pFrame->mnShowState = SW_SHOWNOACTIVATE;
1172 else
1173 pFrame->mnShowState = SW_SHOW;
1174 // hide toolbar for W98
1175 if ( pFrame->mbPresentation )
1176 {
1177 HWND hWndParent = ::GetParent( hWnd );
1178 if ( hWndParent )
1179 SetForegroundWindow_Impl( hWndParent );
1180 SetForegroundWindow_Impl( hWnd );
1181 }
1182
1183 pFrame->mbInShow = false;
1184 pFrame->updateScreenNumber();
1185
1186 // Direct Paint only, if we get the SolarMutex
1187 if ( ImplSalYieldMutexTryToAcquire() )
1188 {
1189 UpdateWindow( hWnd );
1190 ImplSalYieldMutexRelease();
1191 }
1192 }
1193 else
1194 {
1195 ShowWindow( hWnd, SW_HIDE );
1196 }
1197 }
1198
1199 void WinSalFrame::SetExtendedFrameStyle( SalExtStyle )
1200 {
1201 }
1202
1203 void WinSalFrame::Show( bool bVisible, bool bNoActivate )
1204 {
1205 // Post this Message to the window, because this only works
1206 // in the thread of the window, which has create this window.
1207 // We post this message to avoid deadlocks
1208 if ( GetSalData()->mnAppThreadId != GetCurrentThreadId() )
1209 {
1210 bool const ret = PostMessageW(mhWnd, SAL_MSG_SHOW, WPARAM(bVisible), LPARAM(bNoActivate));
1211 SAL_WARN_IF(!ret, "vcl", "ERROR: PostMessage() failed!");
1212 }
1213 else
1214 ImplSalShow( mhWnd, bVisible, bNoActivate );
1215 }
1216
1217 void WinSalFrame::SetMinClientSize( tools::Long nWidth, tools::Long nHeight )
1218 {
1219 mnMinWidth = nWidth;
1220 mnMinHeight = nHeight;
1221 }
1222
1223 void WinSalFrame::SetMaxClientSize( tools::Long nWidth, tools::Long nHeight )
1224 {
1225 mnMaxWidth = nWidth;
1226 mnMaxHeight = nHeight;
1227 }
1228
1229 void WinSalFrame::SetPosSize( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight,
1230 sal_uInt16 nFlags )
1231 {
1232 bool bVisible = (GetWindowStyle( mhWnd ) & WS_VISIBLE) != 0;
1233 if ( !bVisible )
1234 {
1235 vcl::Window *pClientWin = GetWindow()->ImplGetClientWindow();
1236 if ( mbFloatWin || ( pClientWin && (pClientWin->GetStyle() & WB_SYSTEMFLOATWIN) ) )
1237 mnShowState = SW_SHOWNOACTIVATE;
1238 else
1239 mnShowState = SW_SHOWNORMAL;
1240 }
1241 else
1242 {
1243 if ( IsIconic( mhWnd ) || IsZoomed( mhWnd ) )
1244 ShowWindow( mhWnd, SW_RESTORE );
1245 }
1246
1247 SalEvent nEvent = SalEvent::NONE;
1248 UINT nPosSize = 0;
1249 RECT aClientRect, aWindowRect;
1250 GetClientRect( mhWnd, &aClientRect ); // x,y always 0,0, but width and height without border
1251 GetWindowRect( mhWnd, &aWindowRect ); // x,y in screen coordinates, width and height with border
1252
1253 if ( !(nFlags & (SAL_FRAME_POSSIZE_X | SAL_FRAME_POSSIZE_Y)) )
1254 nPosSize |= SWP_NOMOVE;
1255 else
1256 {
1257 //SAL_WARN_IF( !nX || !nY, "vcl", " Windowposition of (0,0) requested!" );
1258 nEvent = SalEvent::Move;
1259 }
1260 if ( !(nFlags & (SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT)) )
1261 nPosSize |= SWP_NOSIZE;
1262 else
1263 nEvent = (nEvent == SalEvent::Move) ? SalEvent::MoveResize : SalEvent::Resize;
1264
1265 if ( !(nFlags & SAL_FRAME_POSSIZE_X) )
1266 nX = aWindowRect.left;
1267 if ( !(nFlags & SAL_FRAME_POSSIZE_Y) )
1268 nY = aWindowRect.top;
1269 if ( !(nFlags & SAL_FRAME_POSSIZE_WIDTH) )
1270 nWidth = aClientRect.right-aClientRect.left;
1271 if ( !(nFlags & SAL_FRAME_POSSIZE_HEIGHT) )
1272 nHeight = aClientRect.bottom-aClientRect.top;
1273
1274 // Calculate window size including the border
1275 RECT aWinRect;
1276 aWinRect.left = 0;
1277 aWinRect.right = static_cast<int>(nWidth)-1;
1278 aWinRect.top = 0;
1279 aWinRect.bottom = static_cast<int>(nHeight)-1;
1280 AdjustWindowRectEx( &aWinRect, GetWindowStyle( mhWnd ),
1281 FALSE, GetWindowExStyle( mhWnd ) );
1282 nWidth = aWinRect.right - aWinRect.left + 1;
1283 nHeight = aWinRect.bottom - aWinRect.top + 1;
1284
1285 if ( !(nPosSize & SWP_NOMOVE) && ::GetParent( mhWnd ) )
1286 {
1287 RECT aParentRect;
1288 GetClientRect( ImplGetParentHwnd( mhWnd ), &aParentRect );
1289 if( AllSettings::GetLayoutRTL() )
1290 nX = (aParentRect.right - aParentRect.left) - nWidth-1 - nX;
1291
1292 //#110386#, do not transform coordinates for system child windows
1293 if( !(GetWindowStyle( mhWnd ) & WS_CHILD) )
1294 {
1295 POINT aPt;
1296 aPt.x = nX;
1297 aPt.y = nY;
1298
1299 HWND parentHwnd = ImplGetParentHwnd( mhWnd );
1300 WinSalFrame* pParentFrame = GetWindowPtr( parentHwnd );
1301 if ( pParentFrame && pParentFrame->mnShowState == SW_SHOWMAXIMIZED )
1302 {
1303 // #i42485#: parent will be shown maximized in which case
1304 // a ClientToScreen uses the wrong coordinates (i.e. those from the restore pos)
1305 // so use the (already updated) frame geometry for the transformation
1306 aPt.x += pParentFrame->maGeometry.nX;
1307 aPt.y += pParentFrame->maGeometry.nY;
1308 }
1309 else
1310 ClientToScreen( parentHwnd, &aPt );
1311
1312 nX = aPt.x;
1313 nY = aPt.y;
1314
1315 // the position is set
1316 mbDefPos = false;
1317 }
1318 }
1319
1320 // #i3338# to be conformant to UNIX we must position the client window, ie without the decoration
1321 // #i43250# if the position was read from the system (GetWindowRect(), see above), it must not be modified
1322 if ( nFlags & SAL_FRAME_POSSIZE_X )
1323 nX += aWinRect.left;
1324 if ( nFlags & SAL_FRAME_POSSIZE_Y )
1325 nY += aWinRect.top;
1326
1327 int nScreenX;
1328 int nScreenY;
1329 int nScreenWidth;
1330 int nScreenHeight;
1331
1332 RECT aRect;
1333 ImplSalGetWorkArea( mhWnd, &aRect, nullptr );
1334 nScreenX = aRect.left;
1335 nScreenY = aRect.top;
1336 nScreenWidth = aRect.right-aRect.left;
1337 nScreenHeight = aRect.bottom-aRect.top;
1338
1339 if ( mbDefPos && (nPosSize & SWP_NOMOVE)) // we got no positioning request, so choose default position
1340 {
1341 // center window
1342
1343 HWND hWndParent = ::GetParent( mhWnd );
1344 // Search for TopLevel Frame
1345 while ( hWndParent && (GetWindowStyle( hWndParent ) & WS_CHILD) )
1346 hWndParent = ::GetParent( hWndParent );
1347 // if the Window has a Parent, then center the window to
1348 // the parent, in the other case to the screen
1349 if ( hWndParent && !IsIconic( hWndParent ) &&
1350 (GetWindowStyle( hWndParent ) & WS_VISIBLE) )
1351 {
1352 RECT aParentRect;
1353 GetWindowRect( hWndParent, &aParentRect );
1354 int nParentWidth = aParentRect.right-aParentRect.left;
1355 int nParentHeight = aParentRect.bottom-aParentRect.top;
1356
1357 // We don't center, when Parent is smaller than our window
1358 if ( (nParentWidth-GetSystemMetrics( SM_CXFIXEDFRAME ) <= nWidth) &&
1359 (nParentHeight-GetSystemMetrics( SM_CYFIXEDFRAME ) <= nHeight) )
1360 {
1361 int nOff = GetSystemMetrics( SM_CYSIZEFRAME ) + GetSystemMetrics( SM_CYCAPTION );
1362 nX = aParentRect.left+nOff;
1363 nY = aParentRect.top+nOff;
1364 }
1365 else
1366 {
1367 nX = (nParentWidth-nWidth)/2 + aParentRect.left;
1368 nY = (nParentHeight-nHeight)/2 + aParentRect.top;
1369 }
1370 }
1371 else
1372 {
1373 POINT pt;
1374 GetCursorPos( &pt );
1375 RECT aRect2;
1376 aRect2.left = pt.x;
1377 aRect2.top = pt.y;
1378 aRect2.right = pt.x+2;
1379 aRect2.bottom = pt.y+2;
1380
1381 // dualmonitor support:
1382 // Get screensize of the monitor with the mouse pointer
1383 ImplSalGetWorkArea( mhWnd, &aRect2, &aRect2 );
1384
1385 nX = ((aRect2.right-aRect2.left)-nWidth)/2 + aRect2.left;
1386 nY = ((aRect2.bottom-aRect2.top)-nHeight)/2 + aRect2.top;
1387 }
1388
1389 //if ( bVisible )
1390 // mbDefPos = FALSE;
1391
1392 mbDefPos = false; // center only once
1393 nPosSize &= ~SWP_NOMOVE; // activate positioning
1394 nEvent = SalEvent::MoveResize;
1395 }
1396
1397 // Adjust Window in the screen
1398 bool bCheckOffScreen = true;
1399
1400 // but don't do this for floaters or ownerdraw windows that are currently moved interactively
1401 if( (mnStyle & SalFrameStyleFlags::FLOAT) && !(mnStyle & SalFrameStyleFlags::OWNERDRAWDECORATION) )
1402 bCheckOffScreen = false;
1403
1404 if( mnStyle & SalFrameStyleFlags::OWNERDRAWDECORATION )
1405 {
1406 // may be the window is currently being moved (mouse is captured), then no check is required
1407 if( mhWnd == ::GetCapture() )
1408 bCheckOffScreen = false;
1409 else
1410 bCheckOffScreen = true;
1411 }
1412
1413 if( bCheckOffScreen )
1414 {
1415 if ( nX+nWidth > nScreenX+nScreenWidth )
1416 nX = (nScreenX+nScreenWidth) - nWidth;
1417 if ( nY+nHeight > nScreenY+nScreenHeight )
1418 nY = (nScreenY+nScreenHeight) - nHeight;
1419 if ( nX < nScreenX )
1420 nX = nScreenX;
1421 if ( nY < nScreenY )
1422 nY = nScreenY;
1423 }
1424
1425 UINT nPosFlags = SWP_NOACTIVATE | SWP_NOOWNERZORDER | nPosSize;
1426 // bring floating windows always to top
1427 if( !(mnStyle & SalFrameStyleFlags::FLOAT) )
1428 nPosFlags |= SWP_NOZORDER; // do not change z-order
1429
1430 SetWindowPos( mhWnd, HWND_TOP, nX, nY, static_cast<int>(nWidth), static_cast<int>(nHeight), nPosFlags );
1431
1432 UpdateFrameGeometry( mhWnd, this );
1433
1434 // Notification -- really ???
1435 if( nEvent != SalEvent::NONE )
1436 CallCallback( nEvent, nullptr );
1437 }
1438
1439 void WinSalFrame::ImplSetParentFrame( HWND hNewParentWnd, bool bAsChild )
1440 {
1441 // save hwnd, will be overwritten in WM_CREATE during createwindow
1442 HWND hWndOld = mhWnd;
1443 HWND hWndOldParent = ::GetParent( hWndOld );
1444 SalData* pSalData = GetSalData();
1445
1446 if( hNewParentWnd == hWndOldParent )
1447 return;
1448
1449 ::std::vector< WinSalFrame* > children;
1450 ::std::vector< WinSalObject* > systemChildren;
1451
1452 // search child windows
1453 WinSalFrame *pFrame = pSalData->mpFirstFrame;
1454 while( pFrame )
1455 {
1456 HWND hWndParent = ::GetParent( pFrame->mhWnd );
1457 if( mhWnd == hWndParent )
1458 children.push_back( pFrame );
1459 pFrame = pFrame->mpNextFrame;
1460 }
1461
1462 // search system child windows (plugins etc.)
1463 WinSalObject *pObject = pSalData->mpFirstObject;
1464 while( pObject )
1465 {
1466 HWND hWndParent = ::GetParent( pObject->mhWnd );
1467 if( mhWnd == hWndParent )
1468 systemChildren.push_back( pObject );
1469 pObject = pObject->mpNextObject;
1470 }
1471
1472 // to recreate the DCs, if they were destroyed
1473 bool bHadLocalGraphics = false, bHadThreadGraphics = false;
1474
1475 HFONT hFont = nullptr;
1476 HPEN hPen = nullptr;
1477 HBRUSH hBrush = nullptr;
1478
1479 int oldCount = pSalData->mnCacheDCInUse;
1480
1481 // release the thread DC
1482 if ( mpThreadGraphics )
1483 {
1484 // save current gdi objects before hdc is gone
1485 HDC hDC = mpThreadGraphics->getHDC();
1486 if ( hDC )
1487 {
1488 hFont = static_cast<HFONT>(GetCurrentObject( hDC, OBJ_FONT ));
1489 hPen = static_cast<HPEN>(GetCurrentObject( hDC, OBJ_PEN ));
1490 hBrush = static_cast<HBRUSH>(GetCurrentObject( hDC, OBJ_BRUSH ));
1491 }
1492
1493 bHadThreadGraphics = ReleaseFrameGraphicsDC( mpThreadGraphics );
1494 assert( (bHadThreadGraphics && hDC) || (!bHadThreadGraphics && !hDC) );
1495 }
1496
1497 // release the local DC
1498 if ( mpLocalGraphics )
1499 bHadLocalGraphics = ReleaseFrameGraphicsDC( mpLocalGraphics );
1500
1501 // create a new hwnd with the same styles
1502 HWND hWndParent = hNewParentWnd;
1503 // forward to main thread
1504 HWND hWnd = reinterpret_cast<HWND>(static_cast<sal_IntPtr>(SendMessageW( pSalData->mpInstance->mhComWnd,
1505 bAsChild ? SAL_MSG_RECREATECHILDHWND : SAL_MSG_RECREATEHWND,
1506 reinterpret_cast<WPARAM>(hWndParent), reinterpret_cast<LPARAM>(mhWnd) )));
1507
1508 // succeeded ?
1509 SAL_WARN_IF( !IsWindow( hWnd ), "vcl", "WinSalFrame::SetParent not successful");
1510
1511 // re-create thread DC
1512 if( bHadThreadGraphics )
1513 {
1514 HDC hDC = reinterpret_cast<HDC>(static_cast<sal_IntPtr>(
1515 SendMessageW( pSalData->mpInstance->mhComWnd,
1516 SAL_MSG_GETCACHEDDC, reinterpret_cast<WPARAM>(hWnd), 0 )));
1517 InitFrameGraphicsDC( mpThreadGraphics, hDC, hWnd );
1518 if ( hDC )
1519 {
1520 // re-select saved gdi objects
1521 if( hFont )
1522 SelectObject( hDC, hFont );
1523 if( hPen )
1524 SelectObject( hDC, hPen );
1525 if( hBrush )
1526 SelectObject( hDC, hBrush );
1527
1528 SAL_WARN_IF( oldCount != pSalData->mnCacheDCInUse, "vcl", "WinSalFrame::SetParent() hDC count corrupted");
1529 }
1530 }
1531
1532 // re-create local DC
1533 if( bHadLocalGraphics )
1534 InitFrameGraphicsDC( mpLocalGraphics, GetDC( hWnd ), hWnd );
1535
1536 // TODO: add SetParent() call for SalObjects
1537 SAL_WARN_IF( !systemChildren.empty(), "vcl", "WinSalFrame::SetParent() parent of living system child window will be destroyed!");
1538
1539 // reparent children before old parent is destroyed
1540 for (auto & child : children)
1541 child->ImplSetParentFrame( hWnd, false );
1542
1543 children.clear();
1544 systemChildren.clear();
1545
1546 // Now destroy original HWND in the thread where it was created.
1547 SendMessageW( GetSalData()->mpInstance->mhComWnd,
1548 SAL_MSG_DESTROYHWND, WPARAM(0), reinterpret_cast<LPARAM>(hWndOld));
1549 }
1550
1551 void WinSalFrame::SetParent( SalFrame* pNewParent )
1552 {
1553 WinSalFrame::mbInReparent = true;
1554 ImplSetParentFrame( static_cast<WinSalFrame*>(pNewParent)->mhWnd, false );
1555 WinSalFrame::mbInReparent = false;
1556 }
1557
1558 bool WinSalFrame::SetPluginParent( SystemParentData* pNewParent )
1559 {
1560 if ( pNewParent->hWnd == nullptr )
1561 {
1562 pNewParent->hWnd = GetDesktopWindow();
1563 }
1564
1565 WinSalFrame::mbInReparent = true;
1566 ImplSetParentFrame( pNewParent->hWnd, true );
1567 WinSalFrame::mbInReparent = false;
1568 return true;
1569 }
1570
1571 void WinSalFrame::GetWorkArea( tools::Rectangle &rRect )
1572 {
1573 RECT aRect;
1574 ImplSalGetWorkArea( mhWnd, &aRect, nullptr );
1575 rRect.SetLeft( aRect.left );
1576 rRect.SetRight( aRect.right-1 );
1577 rRect.SetTop( aRect.top );
1578 rRect.SetBottom( aRect.bottom-1 );
1579 }
1580
1581 void WinSalFrame::GetClientSize( tools::Long& rWidth, tools::Long& rHeight )
1582 {
1583 rWidth = maGeometry.nWidth;
1584 rHeight = maGeometry.nHeight;
1585 }
1586
1587 void WinSalFrame::SetWindowState( const SalFrameState* pState )
1588 {
1589 // Check if the window fits into the screen, in case the screen
1590 // resolution changed
1591 int nX;
1592 int nY;
1593 int nWidth;
1594 int nHeight;
1595 int nScreenX;
1596 int nScreenY;
1597 int nScreenWidth;
1598 int nScreenHeight;
1599
1600 RECT aRect;
1601 ImplSalGetWorkArea( mhWnd, &aRect, nullptr );
1602 // #102500# allow some overlap, the window could have been made a little larger than the physical screen
1603 nScreenX = aRect.left-10;
1604 nScreenY = aRect.top-10;
1605 nScreenWidth = aRect.right-aRect.left+20;
1606 nScreenHeight = aRect.bottom-aRect.top+20;
1607
1608 UINT nPosSize = 0;
1609 RECT aWinRect;
1610 GetWindowRect( mhWnd, &aWinRect );
1611
1612 // to be consistent with Unix, the frame state is without(!) decoration
1613 // ->add the decoration
1614 RECT aRect2 = aWinRect;
1615 AdjustWindowRectEx( &aRect2, GetWindowStyle( mhWnd ),
1616 FALSE, GetWindowExStyle( mhWnd ) );
1617 tools::Long nTopDeco = abs( aWinRect.top - aRect2.top );
1618 tools::Long nLeftDeco = abs( aWinRect.left - aRect2.left );
1619 tools::Long nBottomDeco = abs( aWinRect.bottom - aRect2.bottom );
1620 tools::Long nRightDeco = abs( aWinRect.right - aRect2.right );
1621
1622 // adjust window position/size to fit the screen
1623 if ( !(pState->mnMask & (WindowStateMask::X | WindowStateMask::Y)) )
1624 nPosSize |= SWP_NOMOVE;
1625 if ( !(pState->mnMask & (WindowStateMask::Width | WindowStateMask::Height)) )
1626 nPosSize |= SWP_NOSIZE;
1627 if ( pState->mnMask & WindowStateMask::X )
1628 nX = static_cast<int>(pState->mnX) - nLeftDeco;
1629 else
1630 nX = aWinRect.left;
1631 if ( pState->mnMask & WindowStateMask::Y )
1632 nY = static_cast<int>(pState->mnY) - nTopDeco;
1633 else
1634 nY = aWinRect.top;
1635 if ( pState->mnMask & WindowStateMask::Width )
1636 nWidth = static_cast<int>(pState->mnWidth) + nLeftDeco + nRightDeco;
1637 else
1638 nWidth = aWinRect.right-aWinRect.left;
1639 if ( pState->mnMask & WindowStateMask::Height )
1640 nHeight = static_cast<int>(pState->mnHeight) + nTopDeco + nBottomDeco;
1641 else
1642 nHeight = aWinRect.bottom-aWinRect.top;
1643
1644 // Adjust Window in the screen:
1645 // if it does not fit into the screen do nothing, ie default pos/size will be used
1646 // if there is an overlap with the screen border move the window while keeping its size
1647
1648 if( nWidth > nScreenWidth || nHeight > nScreenHeight )
1649 nPosSize |= (SWP_NOMOVE | SWP_NOSIZE);
1650
1651 if ( nX+nWidth > nScreenX+nScreenWidth )
1652 nX = (nScreenX+nScreenWidth) - nWidth;
1653 if ( nY+nHeight > nScreenY+nScreenHeight )
1654 nY = (nScreenY+nScreenHeight) - nHeight;
1655 if ( nX < nScreenX )
1656 nX = nScreenX;
1657 if ( nY < nScreenY )
1658 nY = nScreenY;
1659
1660 // set Restore-Position
1661 WINDOWPLACEMENT aPlacement;
1662 aPlacement.length = sizeof( aPlacement );
1663 GetWindowPlacement( mhWnd, &aPlacement );
1664
1665 // set State
1666 bool bVisible = (GetWindowStyle( mhWnd ) & WS_VISIBLE) != 0;
1667 bool bUpdateHiddenFramePos = false;
1668 if ( !bVisible )
1669 {
1670 aPlacement.showCmd = SW_HIDE;
1671
1672 if ( mbOverwriteState )
1673 {
1674 if ( pState->mnMask & WindowStateMask::State )
1675 {
1676 if ( pState->mnState & WindowStateState::Minimized )
1677 mnShowState = SW_SHOWMINIMIZED;
1678 else if ( pState->mnState & WindowStateState::Maximized )
1679 {
1680 mnShowState = SW_SHOWMAXIMIZED;
1681 bUpdateHiddenFramePos = true;
1682 }
1683 else if ( pState->mnState & WindowStateState::Normal )
1684 mnShowState = SW_SHOWNORMAL;
1685 }
1686 }
1687 }
1688 else
1689 {
1690 if ( pState->mnMask & WindowStateMask::State )
1691 {
1692 if ( pState->mnState & WindowStateState::Minimized )
1693 {
1694 if ( pState->mnState & WindowStateState::Maximized )
1695 aPlacement.flags |= WPF_RESTORETOMAXIMIZED;
1696 aPlacement.showCmd = SW_SHOWMINIMIZED;
1697 }
1698 else if ( pState->mnState & WindowStateState::Maximized )
1699 aPlacement.showCmd = SW_SHOWMAXIMIZED;
1700 else if ( pState->mnState & WindowStateState::Normal )
1701 aPlacement.showCmd = SW_RESTORE;
1702 }
1703 }
1704
1705 // if a window is neither minimized nor maximized or need not be
1706 // positioned visibly (that is in visible state), do not use
1707 // SetWindowPlacement since it calculates including the TaskBar
1708 if ( !IsIconic( mhWnd ) && !IsZoomed( mhWnd ) &&
1709 (!bVisible || (aPlacement.showCmd == SW_RESTORE)) )
1710 {
1711 if( bUpdateHiddenFramePos )
1712 {
1713 RECT aStateRect;
1714 aStateRect.left = nX;
1715 aStateRect.top = nY;
1716 aStateRect.right = nX+nWidth;
1717 aStateRect.bottom = nY+nHeight;
1718 // #96084 set a useful internal window size because
1719 // the window will not be maximized (and the size updated) before show()
1720 SetMaximizedFrameGeometry( mhWnd, this, &aStateRect );
1721 SetWindowPos( mhWnd, nullptr,
1722 maGeometry.nX, maGeometry.nY, maGeometry.nWidth, maGeometry.nHeight,
1723 SWP_NOZORDER | SWP_NOACTIVATE | nPosSize );
1724 }
1725 else
1726 SetWindowPos( mhWnd, nullptr,
1727 nX, nY, nWidth, nHeight,
1728 SWP_NOZORDER | SWP_NOACTIVATE | nPosSize );
1729 }
1730 else
1731 {
1732 if( !(nPosSize & (SWP_NOMOVE|SWP_NOSIZE)) )
1733 {
1734 aPlacement.rcNormalPosition.left = nX-nScreenX;
1735 aPlacement.rcNormalPosition.top = nY-nScreenY;
1736 aPlacement.rcNormalPosition.right = nX+nWidth-nScreenX;
1737 aPlacement.rcNormalPosition.bottom = nY+nHeight-nScreenY;
1738 }
1739 SetWindowPlacement( mhWnd, &aPlacement );
1740 }
1741
1742 if( !(nPosSize & SWP_NOMOVE) )
1743 mbDefPos = false; // window was positioned
1744 }
1745
1746 bool WinSalFrame::GetWindowState( SalFrameState* pState )
1747 {
1748 if ( maState.mnWidth && maState.mnHeight )
1749 {
1750 *pState = maState;
1751 // #94144# allow Minimize again, should be masked out when read from configuration
1752 // 91625 - Don't save minimize
1753 //if ( !(pState->mnState & WindowStateState::Maximized) )
1754 if ( !(pState->mnState & (WindowStateState::Minimized | WindowStateState::Maximized)) )
1755 pState->mnState |= WindowStateState::Normal;
1756 return true;
1757 }
1758
1759 return false;
1760 }
1761
1762 void WinSalFrame::SetScreenNumber( unsigned int nNewScreen )
1763 {
1764 WinSalSystem* pSys = static_cast<WinSalSystem*>(ImplGetSalSystem());
1765 if( pSys )
1766 {
1767 const std::vector<WinSalSystem::DisplayMonitor>& rMonitors =
1768 pSys->getMonitors();
1769 size_t nMon = rMonitors.size();
1770 if( nNewScreen < nMon )
1771 {
1772 Point aOldMonPos, aNewMonPos( rMonitors[nNewScreen].m_aArea.TopLeft() );
1773 Point aCurPos( maGeometry.nX, maGeometry.nY );
1774 for( size_t i = 0; i < nMon; i++ )
1775 {
1776 if( rMonitors[i].m_aArea.IsInside( aCurPos ) )
1777 {
1778 aOldMonPos = rMonitors[i].m_aArea.TopLeft();
1779 break;
1780 }
1781 }
1782 mnDisplay = nNewScreen;
1783 maGeometry.nDisplayScreenNumber = nNewScreen;
1784 SetPosSize( aNewMonPos.X() + (maGeometry.nX - aOldMonPos.X()),
1785 aNewMonPos.Y() + (maGeometry.nY - aOldMonPos.Y()),
1786 0, 0,
1787 SAL_FRAME_POSSIZE_X | SAL_FRAME_POSSIZE_Y );
1788 }
1789 }
1790 }
1791
1792 void WinSalFrame::SetApplicationID( const OUString &rApplicationID )
1793 {
1794 // http://msdn.microsoft.com/en-us/library/windows/desktop/dd378430(v=vs.85).aspx
1795 // A window's properties must be removed before the window is closed.
1796
1797 IPropertyStore *pps;
1798 HRESULT hr = SHGetPropertyStoreForWindow(mhWnd, IID_PPV_ARGS(&pps));
1799 if (SUCCEEDED(hr))
1800 {
1801 PROPVARIANT pv;
1802 if (!rApplicationID.isEmpty())
1803 {
1804 hr = InitPropVariantFromString(o3tl::toW(rApplicationID.getStr()), &pv);
1805 mbPropertiesStored = true;
1806 }
1807 else
1808 // if rApplicationID we remove the property from the window, if present
1809 PropVariantInit(&pv);
1810
1811 if (SUCCEEDED(hr))
1812 {
1813 hr = pps->SetValue(PKEY_AppUserModel_ID, pv);
1814 PropVariantClear(&pv);
1815 }
1816 pps->Release();
1817 }
1818 }
1819
1820 void WinSalFrame::ShowFullScreen( bool bFullScreen, sal_Int32 nDisplay )
1821 {
1822 if ( (mbFullScreen == bFullScreen) && (!bFullScreen || (mnDisplay == nDisplay)) )
1823 return;
1824
1825 mbFullScreen = bFullScreen;
1826 mnDisplay = nDisplay;
1827
1828 if ( bFullScreen )
1829 {
1830 // to hide the Windows taskbar
1831 DWORD nExStyle = GetWindowExStyle( mhWnd );
1832 if ( nExStyle & WS_EX_TOOLWINDOW )
1833 {
1834 mbFullScreenToolWin = true;
1835 nExStyle &= ~WS_EX_TOOLWINDOW;
1836 SetWindowExStyle( mhWnd, nExStyle );
1837 }
1838 // save old position
1839 GetWindowRect( mhWnd, &maFullScreenRect );
1840
1841 // save show state
1842 mnFullScreenShowState = mnShowState;
1843 if ( !(GetWindowStyle( mhWnd ) & WS_VISIBLE) )
1844 mnShowState = SW_SHOW;
1845
1846 // Save caption state.
1847 mbFullScreenCaption = mbCaption;
1848 if (mbCaption)
1849 {
1850 DWORD nStyle = GetWindowStyle(mhWnd);
1851 SetWindowStyle(mhWnd, nStyle & ~WS_CAPTION);
1852 mbCaption = false;
1853 }
1854
1855 // set window to screen size
1856 ImplSalFrameFullScreenPos( this, true );
1857 }
1858 else
1859 {
1860 // when the ShowState has to be reset, hide the window first to
1861 // reduce flicker
1862 bool bVisible = (GetWindowStyle( mhWnd ) & WS_VISIBLE) != 0;
1863 if ( bVisible && (mnShowState != mnFullScreenShowState) )
1864 ShowWindow( mhWnd, SW_HIDE );
1865
1866 if ( mbFullScreenToolWin )
1867 SetWindowExStyle( mhWnd, GetWindowExStyle( mhWnd ) | WS_EX_TOOLWINDOW );
1868 mbFullScreenToolWin = false;
1869
1870 // Restore caption state.
1871 if (mbFullScreenCaption)
1872 {
1873 DWORD nStyle = GetWindowStyle(mhWnd);
1874 SetWindowStyle(mhWnd, nStyle | WS_CAPTION);
1875 }
1876 mbCaption = mbFullScreenCaption;
1877
1878 SetWindowPos( mhWnd, nullptr,
1879 maFullScreenRect.left,
1880 maFullScreenRect.top,
1881 maFullScreenRect.right-maFullScreenRect.left,
1882 maFullScreenRect.bottom-maFullScreenRect.top,
1883 SWP_NOZORDER | SWP_NOACTIVATE );
1884
1885 // restore show state
1886 if ( mnShowState != mnFullScreenShowState )
1887 {
1888 mnShowState = mnFullScreenShowState;
1889 if ( bVisible )
1890 {
1891 mbInShow = true;
1892 ShowWindow( mhWnd, mnShowState );
1893 mbInShow = false;
1894 UpdateWindow( mhWnd );
1895 }
1896 }
1897 }
1898 }
1899
1900 void WinSalFrame::StartPresentation( bool bStart )
1901 {
1902 if ( mbPresentation == bStart )
1903 return;
1904
1905 mbPresentation = bStart;
1906
1907 SalData* pSalData = GetSalData();
1908 if ( bStart )
1909 {
1910 // turn off screen-saver when in Presentation mode
1911 SystemParametersInfoW( SPI_GETSCREENSAVEACTIVE, 0,
1912 &(pSalData->mbScrSvrEnabled), 0 );
1913 if ( pSalData->mbScrSvrEnabled )
1914 SystemParametersInfoW( SPI_SETSCREENSAVEACTIVE, FALSE, nullptr, 0 );
1915 }
1916 else
1917 {
1918 // turn on screen-saver
1919 if ( pSalData->mbScrSvrEnabled )
1920 SystemParametersInfoW( SPI_SETSCREENSAVEACTIVE, pSalData->mbScrSvrEnabled, nullptr, 0 );
1921 }
1922 }
1923
1924 void WinSalFrame::SetAlwaysOnTop( bool bOnTop )
1925 {
1926 HWND hWnd;
1927 if ( bOnTop )
1928 hWnd = HWND_TOPMOST;
1929 else
1930 hWnd = HWND_NOTOPMOST;
1931 SetWindowPos( mhWnd, hWnd, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE );
1932 }
1933
1934 static bool EnableAttachThreadInputHack()
1935 {
1936 OUString aBootstrapUri;
1937 if (osl_getProcessWorkingDir(&aBootstrapUri.pData) != osl_Process_E_None)
1938 return false;
1939 aBootstrapUri += "/bootstrap.ini";
1940
1941 OUString aSystemFileName;
1942 if (osl::FileBase::getSystemPathFromFileURL(aBootstrapUri, aSystemFileName) != osl::FileBase::E_None)
1943 return false;
1944 if (aSystemFileName.getLength() > MAX_PATH)
1945 return false;
1946
1947 // this uses the Boost ini parser, instead of tools::Config, as we already use it to read other
1948 // values from bootstrap.ini in desktop/win32/source/loader.cxx, because that watchdog process
1949 // can't access LO libs. This way the handling is consistent.
1950 try
1951 {
1952 boost::property_tree::ptree pt;
1953 std::ifstream aFile(o3tl::toW(aSystemFileName.getStr()));
1954 boost::property_tree::ini_parser::read_ini(aFile, pt);
1955 const bool bEnabled = pt.get("Win32.EnableAttachThreadInputHack", false);
1956 SAL_WARN_IF(bEnabled, "vcl", "AttachThreadInput hack is enabled. Watch out for deadlocks!");
1957 return bEnabled;
1958 }
1959 catch (...)
1960 {
1961 return false;
1962 }
1963 }
1964
1965 static void ImplSalToTop( HWND hWnd, SalFrameToTop nFlags )
1966 {
1967 static const bool bEnableAttachThreadInputHack = EnableAttachThreadInputHack();
1968
1969 WinSalFrame* pToTopFrame = GetWindowPtr( hWnd );
1970 if( pToTopFrame && (pToTopFrame->mnStyle & SalFrameStyleFlags::SYSTEMCHILD) )
1971 BringWindowToTop( hWnd );
1972
1973 if ( nFlags & SalFrameToTop::ForegroundTask )
1974 {
1975 // LO used to always call AttachThreadInput here, which resulted in deadlocks
1976 // in some installations for unknown reasons!
1977 if (bEnableAttachThreadInputHack)
1978 {
1979 // This magic code is necessary to connect the input focus of the
1980 // current window thread and the thread which owns the window that
1981 // should be the new foreground window.
1982 HWND hCurrWnd = GetForegroundWindow();
1983 DWORD myThreadID = GetCurrentThreadId();
1984 DWORD currThreadID = GetWindowThreadProcessId(hCurrWnd,nullptr);
1985 AttachThreadInput(myThreadID, currThreadID, TRUE);
1986 SetForegroundWindow_Impl(hWnd);
1987 AttachThreadInput(myThreadID, currThreadID, FALSE);
1988 }
1989 else
1990 SetForegroundWindow_Impl(hWnd);
1991 }
1992
1993 if ( nFlags & SalFrameToTop::RestoreWhenMin )
1994 {
1995 HWND hIconicWnd = hWnd;
1996 while ( hIconicWnd )
1997 {
1998 if ( IsIconic( hIconicWnd ) )
1999 {
2000 WinSalFrame* pFrame = GetWindowPtr( hIconicWnd );
2001 if ( pFrame )
2002 {
2003 if ( GetWindowPtr( hWnd )->mbRestoreMaximize )
2004 ShowWindow( hIconicWnd, SW_MAXIMIZE );
2005 else
2006 ShowWindow( hIconicWnd, SW_RESTORE );
2007 }
2008 else
2009 ShowWindow( hIconicWnd, SW_RESTORE );
2010 }
2011
2012 hIconicWnd = ::GetParent( hIconicWnd );
2013 }
2014 }
2015
2016 if ( !IsIconic( hWnd ) && IsWindowVisible( hWnd ) )
2017 {
2018 SetFocus( hWnd );
2019
2020 // Windows sometimes incorrectly reports to have the focus;
2021 // thus make sure to really get the focus
2022 if ( ::GetFocus() == hWnd )
2023 SetForegroundWindow_Impl( hWnd );
2024 }
2025 }
2026
2027 void WinSalFrame::ToTop( SalFrameToTop nFlags )
2028 {
2029 nFlags &= ~SalFrameToTop::GrabFocus; // this flag is not needed on win32
2030 // Post this Message to the window, because this only works
2031 // in the thread of the window, which has create this window.
2032 // We post this message to avoid deadlocks
2033 if ( GetSalData()->mnAppThreadId != GetCurrentThreadId() )
2034 {
2035 bool const ret = PostMessageW( mhWnd, SAL_MSG_TOTOP, static_cast<WPARAM>(nFlags), 0 );
2036 SAL_WARN_IF(!ret, "vcl", "ERROR: PostMessage() failed!");
2037 }
2038 else
2039 ImplSalToTop( mhWnd, nFlags );
2040 }
2041
2042 void WinSalFrame::SetPointer( PointerStyle ePointerStyle )
2043 {
2044 struct ImplPtrData
2045 {
2046 HCURSOR mhCursor;
2047 LPCTSTR mnSysId;
2048 UINT mnOwnId;
2049 };
2050
2051 static o3tl::enumarray<PointerStyle, ImplPtrData> aImplPtrTab =
2052 {
2053 ImplPtrData{ nullptr, IDC_ARROW, 0 }, // POINTER_ARROW
2054 { nullptr, nullptr, SAL_RESID_POINTER_NULL }, // POINTER_NULL
2055 { nullptr, IDC_WAIT, 0 }, // POINTER_WAIT
2056 { nullptr, IDC_IBEAM, 0 }, // POINTER_TEXT
2057 { nullptr, IDC_HELP, 0 }, // POINTER_HELP
2058 { nullptr, IDC_CROSS, 0 }, // POINTER_CROSS
2059 { nullptr, IDC_SIZEALL, 0 }, // POINTER_MOVE
2060 { nullptr, IDC_SIZENS, 0 }, // POINTER_NSIZE
2061 { nullptr, IDC_SIZENS, 0 }, // POINTER_SSIZE
2062 { nullptr, IDC_SIZEWE, 0 }, // POINTER_WSIZE
2063 { nullptr, IDC_SIZEWE, 0 }, // POINTER_ESIZE
2064 { nullptr, IDC_SIZENWSE, 0 }, // POINTER_NWSIZE
2065 { nullptr, IDC_SIZENESW, 0 }, // POINTER_NESIZE
2066 { nullptr, IDC_SIZENESW, 0 }, // POINTER_SWSIZE
2067 { nullptr, IDC_SIZENWSE, 0 }, // POINTER_SESIZE
2068 { nullptr, IDC_SIZENS, 0 }, // POINTER_WINDOW_NSIZE
2069 { nullptr, IDC_SIZENS, 0 }, // POINTER_WINDOW_SSIZE
2070 { nullptr, IDC_SIZEWE, 0 }, // POINTER_WINDOW_WSIZE
2071 { nullptr, IDC_SIZEWE, 0 }, // POINTER_WINDOW_ESIZE
2072 { nullptr, IDC_SIZENWSE, 0 }, // POINTER_WINDOW_NWSIZE
2073 { nullptr, IDC_SIZENESW, 0 }, // POINTER_WINDOW_NESIZE
2074 { nullptr, IDC_SIZENESW, 0 }, // POINTER_WINDOW_SWSIZE
2075 { nullptr, IDC_SIZENWSE, 0 }, // POINTER_WINDOW_SESIZE
2076 { nullptr, IDC_SIZEWE, 0 }, // POINTER_HSPLIT
2077 { nullptr, IDC_SIZENS, 0 }, // POINTER_VSPLIT
2078 { nullptr, IDC_SIZEWE, 0 }, // POINTER_HSIZEBAR
2079 { nullptr, IDC_SIZENS, 0 }, // POINTER_VSIZEBAR
2080 { nullptr, IDC_HAND, 0 }, // POINTER_HAND
2081 { nullptr, IDC_HAND, 0 }, // POINTER_REFHAND
2082 { nullptr, IDC_PEN, 0 }, // POINTER_PEN
2083 { nullptr, nullptr, SAL_RESID_POINTER_MAGNIFY }, // POINTER_MAGNIFY
2084 { nullptr, nullptr, SAL_RESID_POINTER_FILL }, // POINTER_FILL
2085 { nullptr, nullptr, SAL_RESID_POINTER_ROTATE }, // POINTER_ROTATE
2086 { nullptr, nullptr, SAL_RESID_POINTER_HSHEAR }, // POINTER_HSHEAR
2087 { nullptr, nullptr, SAL_RESID_POINTER_VSHEAR }, // POINTER_VSHEAR
2088 { nullptr, nullptr, SAL_RESID_POINTER_MIRROR }, // POINTER_MIRROR
2089 { nullptr, nullptr, SAL_RESID_POINTER_CROOK }, // POINTER_CROOK
2090 { nullptr, nullptr, SAL_RESID_POINTER_CROP }, // POINTER_CROP
2091 { nullptr, nullptr, SAL_RESID_POINTER_MOVEPOINT }, // POINTER_MOVEPOINT
2092 { nullptr, nullptr, SAL_RESID_POINTER_MOVEBEZIERWEIGHT }, // POINTER_MOVEBEZIERWEIGHT
2093 { nullptr, nullptr, SAL_RESID_POINTER_MOVEDATA }, // POINTER_MOVEDATA
2094 { nullptr, nullptr, SAL_RESID_POINTER_COPYDATA }, // POINTER_COPYDATA
2095 { nullptr, nullptr, SAL_RESID_POINTER_LINKDATA }, // POINTER_LINKDATA
2096 { nullptr, nullptr, SAL_RESID_POINTER_MOVEDATALINK }, // POINTER_MOVEDATALINK
2097 { nullptr, nullptr, SAL_RESID_POINTER_COPYDATALINK }, // POINTER_COPYDATALINK
2098 { nullptr, nullptr, SAL_RESID_POINTER_MOVEFILE }, // POINTER_MOVEFILE
2099 { nullptr, nullptr, SAL_RESID_POINTER_COPYFILE }, // POINTER_COPYFILE
2100 { nullptr, nullptr, SAL_RESID_POINTER_LINKFILE }, // POINTER_LINKFILE
2101 { nullptr, nullptr, SAL_RESID_POINTER_MOVEFILELINK }, // POINTER_MOVEFILELINK
2102 { nullptr, nullptr, SAL_RESID_POINTER_COPYFILELINK }, // POINTER_COPYFILELINK
2103 { nullptr, nullptr, SAL_RESID_POINTER_MOVEFILES }, // POINTER_MOVEFILES
2104 { nullptr, nullptr, SAL_RESID_POINTER_COPYFILES }, // POINTER_COPYFILES
2105 { nullptr, IDC_NO, 0 }, // POINTER_NOTALLOWED
2106 { nullptr, nullptr, SAL_RESID_POINTER_DRAW_LINE }, // POINTER_DRAW_LINE
2107 { nullptr, nullptr, SAL_RESID_POINTER_DRAW_RECT }, // POINTER_DRAW_RECT
2108 { nullptr, nullptr, SAL_RESID_POINTER_DRAW_POLYGON }, // POINTER_DRAW_POLYGON
2109 { nullptr, nullptr, SAL_RESID_POINTER_DRAW_BEZIER }, // POINTER_DRAW_BEZIER
2110 { nullptr, nullptr, SAL_RESID_POINTER_DRAW_ARC }, // POINTER_DRAW_ARC
2111 { nullptr, nullptr, SAL_RESID_POINTER_DRAW_PIE }, // POINTER_DRAW_PIE
2112 { nullptr, nullptr, SAL_RESID_POINTER_DRAW_CIRCLECUT }, // POINTER_DRAW_CIRCLECUT
2113 { nullptr, nullptr, SAL_RESID_POINTER_DRAW_ELLIPSE }, // POINTER_DRAW_ELLIPSE
2114 { nullptr, nullptr, SAL_RESID_POINTER_DRAW_FREEHAND }, // POINTER_DRAW_FREEHAND
2115 { nullptr, nullptr, SAL_RESID_POINTER_DRAW_CONNECT }, // POINTER_DRAW_CONNECT
2116 { nullptr, nullptr, SAL_RESID_POINTER_DRAW_TEXT }, // POINTER_DRAW_TEXT
2117 { nullptr, nullptr, SAL_RESID_POINTER_DRAW_CAPTION }, // POINTER_DRAW_CAPTION
2118 { nullptr, nullptr, SAL_RESID_POINTER_CHART }, // POINTER_CHART
2119 { nullptr, nullptr, SAL_RESID_POINTER_DETECTIVE }, // POINTER_DETECTIVE
2120 { nullptr, nullptr, SAL_RESID_POINTER_PIVOT_COL }, // POINTER_PIVOT_COL
2121 { nullptr, nullptr, SAL_RESID_POINTER_PIVOT_ROW }, // POINTER_PIVOT_ROW
2122 { nullptr, nullptr, SAL_RESID_POINTER_PIVOT_FIELD }, // POINTER_PIVOT_FIELD
2123 { nullptr, nullptr, SAL_RESID_POINTER_CHAIN }, // POINTER_CHAIN
2124 { nullptr, nullptr, SAL_RESID_POINTER_CHAIN_NOTALLOWED }, // POINTER_CHAIN_NOTALLOWED
2125 { nullptr, nullptr, SAL_RESID_POINTER_AUTOSCROLL_N }, // POINTER_AUTOSCROLL_N
2126 { nullptr, nullptr, SAL_RESID_POINTER_AUTOSCROLL_S }, // POINTER_AUTOSCROLL_S
2127 { nullptr, nullptr, SAL_RESID_POINTER_AUTOSCROLL_W }, // POINTER_AUTOSCROLL_W
2128 { nullptr, nullptr, SAL_RESID_POINTER_AUTOSCROLL_E }, // POINTER_AUTOSCROLL_E
2129 { nullptr, nullptr, SAL_RESID_POINTER_AUTOSCROLL_NW }, // POINTER_AUTOSCROLL_NW
2130 { nullptr, nullptr, SAL_RESID_POINTER_AUTOSCROLL_NE }, // POINTER_AUTOSCROLL_NE
2131 { nullptr, nullptr, SAL_RESID_POINTER_AUTOSCROLL_SW }, // POINTER_AUTOSCROLL_SW
2132 { nullptr, nullptr, SAL_RESID_POINTER_AUTOSCROLL_SE }, // POINTER_AUTOSCROLL_SE
2133 { nullptr, nullptr, SAL_RESID_POINTER_AUTOSCROLL_NS }, // POINTER_AUTOSCROLL_NS
2134 { nullptr, nullptr, SAL_RESID_POINTER_AUTOSCROLL_WE }, // POINTER_AUTOSCROLL_WE
2135 { nullptr, nullptr, SAL_RESID_POINTER_AUTOSCROLL_NSWE }, // POINTER_AUTOSCROLL_NSWE
2136 { nullptr, nullptr, SAL_RESID_POINTER_TEXT_VERTICAL }, // POINTER_TEXT_VERTICAL
2137 { nullptr, nullptr, SAL_RESID_POINTER_PIVOT_DELETE }, // POINTER_PIVOT_DELETE
2138
2139 // #i32329#
2140 { nullptr, nullptr, SAL_RESID_POINTER_TAB_SELECT_S }, // POINTER_TAB_SELECT_S
2141 { nullptr, nullptr, SAL_RESID_POINTER_TAB_SELECT_E }, // POINTER_TAB_SELECT_E
2142 { nullptr, nullptr, SAL_RESID_POINTER_TAB_SELECT_SE }, // POINTER_TAB_SELECT_SE
2143 { nullptr, nullptr, SAL_RESID_POINTER_TAB_SELECT_W }, // POINTER_TAB_SELECT_W
2144 { nullptr, nullptr, SAL_RESID_POINTER_TAB_SELECT_SW }, // POINTER_TAB_SELECT_SW
2145
2146 { nullptr, nullptr, SAL_RESID_POINTER_HIDEWHITESPACE }, // POINTER_HIDEWHITESPACE
2147 { nullptr, nullptr, SAL_RESID_POINTER_SHOWWHITESPACE } // POINTER_UNHIDEWHITESPACE
2148 };
2149
2150 // Mousepointer loaded ?
2151 if ( !aImplPtrTab[ePointerStyle].mhCursor )
2152 {
2153 if ( aImplPtrTab[ePointerStyle].mnOwnId )
2154 aImplPtrTab[ePointerStyle].mhCursor = ImplLoadSalCursor( aImplPtrTab[ePointerStyle].mnOwnId );
2155 else
2156 aImplPtrTab[ePointerStyle].mhCursor = LoadCursor( nullptr, aImplPtrTab[ePointerStyle].mnSysId );
2157 }
2158
2159 // change the mouse pointer if different
2160 if ( mhCursor != aImplPtrTab[ePointerStyle].mhCursor )
2161 {
2162 mhCursor = aImplPtrTab[ePointerStyle].mhCursor;
2163 SetCursor( mhCursor );
2164 }
2165 }
2166
2167 void WinSalFrame::CaptureMouse( bool bCapture )
2168 {
2169 // Send this Message to the window, because CaptureMouse() only work
2170 // in the thread of the window, which has create this window
2171 int nMsg;
2172 if ( bCapture )
2173 nMsg = SAL_MSG_CAPTUREMOUSE;
2174 else
2175 nMsg = SAL_MSG_RELEASEMOUSE;
2176 SendMessageW( mhWnd, nMsg, 0, 0 );
2177 }
2178
2179 void WinSalFrame::SetPointerPos( tools::Long nX, tools::Long nY )
2180 {
2181 POINT aPt;
2182 aPt.x = static_cast<int>(nX);
2183 aPt.y = static_cast<int>(nY);
2184 ClientToScreen( mhWnd, &aPt );
2185 SetCursorPos( aPt.x, aPt.y );
2186 }
2187
2188 void WinSalFrame::Flush()
2189 {
2190 if(mpLocalGraphics)
2191 mpLocalGraphics->Flush();
2192 if(mpThreadGraphics)
2193 mpThreadGraphics->Flush();
2194 GdiFlush();
2195 }
2196
2197 static void ImplSalFrameSetInputContext( HWND hWnd, const SalInputContext* pContext )
2198 {
2199 WinSalFrame* pFrame = GetWindowPtr( hWnd );
2200 bool bIME(pContext->mnOptions & InputContextFlags::Text);
2201 if ( bIME )
2202 {
2203 if ( !pFrame->mbIME )
2204 {
2205 pFrame->mbIME = true;
2206
2207 if ( pFrame->mhDefIMEContext )
2208 {
2209 ImmAssociateContext( pFrame->mhWnd, pFrame->mhDefIMEContext );
2210 UINT nImeProps = ImmGetProperty( GetKeyboardLayout( 0 ), IGP_PROPERTY );
2211 pFrame->mbSpezIME = (nImeProps & IME_PROP_SPECIAL_UI) != 0;
2212 pFrame->mbAtCursorIME = (nImeProps & IME_PROP_AT_CARET) != 0;
2213 pFrame->mbHandleIME = !pFrame->mbSpezIME;
2214 }
2215 }
2216
2217 // When the application can't handle IME messages, then the
2218 // System should handle the IME handling
2219 if ( !(pContext->mnOptions & InputContextFlags::ExtText) )
2220 pFrame->mbHandleIME = false;
2221
2222 // Set the Font for IME Handling
2223 if ( pContext->mpFont )
2224 {
2225 HIMC hIMC = ImmGetContext( pFrame->mhWnd );
2226 if ( hIMC )
2227 {
2228 LOGFONTW aLogFont;
2229 HDC hDC = GetDC( pFrame->mhWnd );
2230 // In case of vertical writing, always append a '@' to the
2231 // Windows font name, not only if such a Windows font really is
2232 // available (bTestVerticalAvail == false in the below call):
2233 // The Windows IME's candidates window seems to always use a
2234 // font that has all necessary glyphs, not necessarily the one
2235 // specified by this font name; but it seems to decide whether
2236 // to use that font's horizontal or vertical variant based on a
2237 // '@' in front of this font name.
2238 ImplGetLogFontFromFontSelect(hDC, pContext->mpFont->GetFontSelectPattern(),
2239 nullptr, aLogFont);
2240 ReleaseDC( pFrame->mhWnd, hDC );
2241 ImmSetCompositionFontW( hIMC, &aLogFont );
2242 ImmReleaseContext( pFrame->mhWnd, hIMC );
2243 }
2244 }
2245 }
2246 else
2247 {
2248 if ( pFrame->mbIME )
2249 {
2250 pFrame->mbIME = false;
2251 pFrame->mbHandleIME = false;
2252 ImmAssociateContext( pFrame->mhWnd, nullptr );
2253 }
2254 }
2255 }
2256
2257 void WinSalFrame::SetInputContext( SalInputContext* pContext )
2258 {
2259 // Must be called in the main thread!
2260 SendMessageW( mhWnd, SAL_MSG_SETINPUTCONTEXT, 0, reinterpret_cast<LPARAM>(pContext) );
2261 }
2262
2263 static void ImplSalFrameEndExtTextInput( HWND hWnd, EndExtTextInputFlags nFlags )
2264 {
2265 HIMC hIMC = ImmGetContext( hWnd );
2266 if ( hIMC )
2267 {
2268 DWORD nIndex;
2269 if ( nFlags & EndExtTextInputFlags::Complete )
2270 nIndex = CPS_COMPLETE;
2271 else
2272 nIndex = CPS_CANCEL;
2273
2274 ImmNotifyIME( hIMC, NI_COMPOSITIONSTR, nIndex, 0 );
2275 ImmReleaseContext( hWnd, hIMC );
2276 }
2277 }
2278
2279 void WinSalFrame::EndExtTextInput( EndExtTextInputFlags nFlags )
2280 {
2281 // Must be called in the main thread!
2282 SendMessageW( mhWnd, SAL_MSG_ENDEXTTEXTINPUT, static_cast<WPARAM>(nFlags), 0 );
2283 }
2284
2285 static void ImplGetKeyNameText( LONG lParam, sal_Unicode* pBuf,
2286 UINT& rCount, UINT nMaxSize,
2287 const char* pReplace )
2288 {
2289 static_assert( sizeof( WCHAR ) == sizeof( sal_Unicode ), "must be the same size" );
2290
2291 static const int nMaxKeyLen = 350;
2292 WCHAR aKeyBuf[ nMaxKeyLen ];
2293 int nKeyLen = 0;
2294 if ( lParam )
2295 {
2296 OUString aLang = Application::GetSettings().GetUILanguageTag().getLanguage();
2297 OUString aRet;
2298
2299 aRet = ::vcl_sal::getKeysReplacementName( aLang, lParam );
2300 if( aRet.isEmpty() )
2301 {
2302 nKeyLen = GetKeyNameTextW( lParam, aKeyBuf, nMaxKeyLen );
2303 SAL_WARN_IF( nKeyLen > nMaxKeyLen, "vcl", "Invalid key name length!" );
2304 if( nKeyLen > nMaxKeyLen )
2305 nKeyLen = 0;
2306 else if( nKeyLen > 0 )
2307 {
2308 // Capitalize just the first letter of key names
2309 CharLowerBuffW( aKeyBuf, nKeyLen );
2310
2311 bool bUpper = true;
2312 for( WCHAR *pW=aKeyBuf, *pE=pW+nKeyLen; pW < pE; ++pW )
2313 {
2314 if( bUpper )
2315 CharUpperBuffW( pW, 1 );
2316 bUpper = (*pW=='+') || (*pW=='-') || (*pW==' ') || (*pW=='.');
2317 }
2318 }
2319 }
2320 else
2321 {
2322 nKeyLen = aRet.getLength();
2323 wcscpy( aKeyBuf, o3tl::toW( aRet.getStr() ));
2324 }
2325 }
2326
2327 if ( (nKeyLen > 0) || pReplace )
2328 {
2329 if( (rCount > 0) && (rCount < nMaxSize) )
2330 {
2331 pBuf[rCount] = '+';
2332 rCount++;
2333 }
2334
2335 if( nKeyLen > 0 )
2336 {
2337 WCHAR *pW = aKeyBuf, *pE = aKeyBuf + nKeyLen;
2338 while ((pW < pE) && *pW && (rCount < nMaxSize))
2339 pBuf[rCount++] = *pW++;
2340 }
2341 else // fall back to provided default name
2342 {
2343 while( *pReplace && (rCount < nMaxSize) )
2344 {
2345 pBuf[rCount] = *pReplace;
2346 rCount++;
2347 pReplace++;
2348 }
2349 }
2350 }
2351 else
2352 rCount = 0;
2353 }
2354
2355 OUString WinSalFrame::GetKeyName( sal_uInt16 nKeyCode )
2356 {
2357 static const UINT nMaxKeyLen = 350;
2358 sal_Unicode aKeyBuf[ nMaxKeyLen ];
2359 UINT nKeyBufLen = 0;
2360 UINT nSysCode = 0;
2361
2362 if ( nKeyCode & KEY_MOD1 )
2363 {
2364 nSysCode = MapVirtualKeyW( VK_CONTROL, 0 );
2365 nSysCode = (nSysCode << 16) | ((sal_uLong(1)) << 25);
2366 ImplGetKeyNameText( nSysCode, aKeyBuf, nKeyBufLen, nMaxKeyLen, "Ctrl" );
2367 }
2368
2369 if ( nKeyCode & KEY_MOD2 )
2370 {
2371 nSysCode = MapVirtualKeyW( VK_MENU, 0 );
2372 nSysCode = (nSysCode << 16) | ((sal_uLong(1)) << 25);
2373 ImplGetKeyNameText( nSysCode, aKeyBuf, nKeyBufLen, nMaxKeyLen, "Alt" );
2374 }
2375
2376 if ( nKeyCode & KEY_SHIFT )
2377 {
2378 nSysCode = MapVirtualKeyW( VK_SHIFT, 0 );
2379 nSysCode = (nSysCode << 16) | ((sal_uLong(1)) << 25);
2380 ImplGetKeyNameText( nSysCode, aKeyBuf, nKeyBufLen, nMaxKeyLen, "Shift" );
2381 }
2382
2383 sal_uInt16 nCode = nKeyCode & 0x0FFF;
2384 sal_uLong nSysCode2 = 0;
2385 const char* pReplace = nullptr;
2386 sal_Unicode cSVCode = 0;
2387 char aFBuf[4];
2388 nSysCode = 0;
2389
2390 if ( (nCode >= KEY_0) && (nCode <= KEY_9) )
2391 cSVCode = '0' + (nCode - KEY_0);
2392 else if ( (nCode >= KEY_A) && (nCode <= KEY_Z) )
2393 cSVCode = 'A' + (nCode - KEY_A);
2394 else if ( (nCode >= KEY_F1) && (nCode <= KEY_F26) )
2395 {
2396 nSysCode = VK_F1 + (nCode - KEY_F1);
2397 aFBuf[0] = 'F';
2398 if (nCode <= KEY_F9)
2399 {
2400 aFBuf[1] = sal::static_int_cast<char>('1' + (nCode - KEY_F1));
2401 aFBuf[2] = 0;
2402 }
2403 else if (nCode <= KEY_F19)
2404 {
2405 aFBuf[1] = '1';
2406 aFBuf[2] = sal::static_int_cast<char>('0' + (nCode - KEY_F10));
2407 aFBuf[3] = 0;
2408 }
2409 else
2410 {
2411 aFBuf[1] = '2';
2412 aFBuf[2] = sal::static_int_cast<char>('0' + (nCode - KEY_F20));
2413 aFBuf[3] = 0;
2414 }
2415 pReplace = aFBuf;
2416 }
2417 else
2418 {
2419 switch ( nCode )
2420 {
2421 case KEY_DOWN:
2422 nSysCode = VK_DOWN;
2423 nSysCode2 = ((sal_uLong(1)) << 24);
2424 pReplace = "Down";
2425 break;
2426 case KEY_UP:
2427 nSysCode = VK_UP;
2428 nSysCode2 = ((sal_uLong(1)) << 24);
2429 pReplace = "Up";
2430 break;
2431 case KEY_LEFT:
2432 nSysCode = VK_LEFT;
2433 nSysCode2 = ((sal_uLong(1)) << 24);
2434 pReplace = "Left";
2435 break;
2436 case KEY_RIGHT:
2437 nSysCode = VK_RIGHT;
2438 nSysCode2 = ((sal_uLong(1)) << 24);
2439 pReplace = "Right";
2440 break;
2441 case KEY_HOME:
2442 nSysCode = VK_HOME;
2443 nSysCode2 = ((sal_uLong(1)) << 24);
2444 pReplace = "Home";
2445 break;
2446 case KEY_END:
2447 nSysCode = VK_END;
2448 nSysCode2 = ((sal_uLong(1)) << 24);
2449 pReplace = "End";
2450 break;
2451 case KEY_PAGEUP:
2452 nSysCode = VK_PRIOR;
2453 nSysCode2 = ((sal_uLong(1)) << 24);
2454 pReplace = "Page Up";
2455 break;
2456 case KEY_PAGEDOWN:
2457 nSysCode = VK_NEXT;
2458 nSysCode2 = ((sal_uLong(1)) << 24);
2459 pReplace = "Page Down";
2460 break;
2461 case KEY_RETURN:
2462 nSysCode = VK_RETURN;
2463 pReplace = "Enter";
2464 break;
2465 case KEY_ESCAPE:
2466 nSysCode = VK_ESCAPE;
2467 pReplace = "Escape";
2468 break;
2469 case KEY_TAB:
2470 nSysCode = VK_TAB;
2471 pReplace = "Tab";
2472 break;
2473 case KEY_BACKSPACE:
2474 nSysCode = VK_BACK;
2475 pReplace = "Backspace";
2476 break;
2477 case KEY_SPACE:
2478 nSysCode = VK_SPACE;
2479 pReplace = "Space";
2480 break;
2481 case KEY_INSERT:
2482 nSysCode = VK_INSERT;
2483 nSysCode2 = ((sal_uLong(1)) << 24);
2484 pReplace = "Insert";
2485 break;
2486 case KEY_DELETE:
2487 nSysCode = VK_DELETE;
2488 nSysCode2 = ((sal_uLong(1)) << 24);
2489 pReplace = "Delete";
2490 break;
2491
2492 case KEY_ADD:
2493 cSVCode = '+';
2494 break;
2495 case KEY_SUBTRACT:
2496 cSVCode = '-';
2497 break;
2498 case KEY_MULTIPLY:
2499 cSVCode = '*';
2500 break;
2501 case KEY_DIVIDE:
2502 cSVCode = '/';
2503 break;
2504 case KEY_POINT:
2505 cSVCode = '.';
2506 break;
2507 case KEY_COMMA:
2508 cSVCode = ',';
2509 break;
2510 case KEY_LESS:
2511 cSVCode = '<';
2512 break;
2513 case KEY_GREATER:
2514 cSVCode = '>';
2515 break;
2516 case KEY_EQUAL:
2517 cSVCode = '=';
2518 break;
2519 case KEY_SEMICOLON:
2520 cSVCode = ';';
2521 break;
2522 case KEY_QUOTERIGHT:
2523 cSVCode = '\'';
2524 break;
2525 case KEY_BRACKETLEFT:
2526 cSVCode = '[';
2527 break;
2528 case KEY_BRACKETRIGHT:
2529 cSVCode = ']';
2530 break;
2531 }
2532 }
2533
2534 if ( nSysCode )
2535 {
2536 nSysCode = MapVirtualKeyW( nSysCode, 0 );
2537 if ( nSysCode )
2538 nSysCode = (nSysCode << 16) | nSysCode2;
2539 ImplGetKeyNameText( nSysCode, aKeyBuf, nKeyBufLen, nMaxKeyLen, pReplace );
2540 }
2541 else
2542 {
2543 if ( cSVCode )
2544 {
2545 if ( nKeyBufLen > 0 )
2546 aKeyBuf[ nKeyBufLen++ ] = '+';
2547 if( nKeyBufLen < nMaxKeyLen )
2548 aKeyBuf[ nKeyBufLen++ ] = cSVCode;
2549 }
2550 }
2551
2552 if( !nKeyBufLen )
2553 return OUString();
2554
2555 return OUString( aKeyBuf, sal::static_int_cast< sal_uInt16 >(nKeyBufLen) );
2556 }
2557
2558 static Color ImplWinColorToSal( COLORREF nColor )
2559 {
2560 return Color( GetRValue( nColor ), GetGValue( nColor ), GetBValue( nColor ) );
2561 }
2562
2563 static void ImplSalUpdateStyleFontW( HDC hDC, const LOGFONTW& rLogFont, vcl::Font& rFont )
2564 {
2565 ImplSalLogFontToFontW( hDC, rLogFont, rFont );
2566
2567 // On Windows 9x, Windows NT we get sometimes very small sizes
2568 // (for example for the small Caption height).
2569 // So if it is MS Sans Serif, a none scalable font we use
2570 // 8 Point as the minimum control height, in all other cases
2571 // 6 Point is the smallest one
2572 if ( rFont.GetFontHeight() < 8 )
2573 {
2574 if ( rtl_ustr_compareIgnoreAsciiCase( o3tl::toU(rLogFont.lfFaceName), o3tl::toU(L"MS Sans Serif") ) == 0 )
2575 rFont.SetFontHeight( 8 );
2576 else if ( rFont.GetFontHeight() < 6 )
2577 rFont.SetFontHeight( 6 );
2578 }
2579 }
2580
2581 static tools::Long ImplW2I( const wchar_t* pStr )
2582 {
2583 long n = 0;
2584 int nSign = 1;
2585
2586 if ( *pStr == '-' )
2587 {
2588 nSign = -1;
2589 pStr++;
2590 }
2591
2592 while( (*pStr >= 48) && (*pStr <= 57) )
2593 {
2594 n *= 10;
2595 n += ((*pStr) - 48);
2596 pStr++;
2597 }
2598
2599 n *= nSign;
2600
2601 return n;
2602 }
2603
2604 void WinSalFrame::UpdateSettings( AllSettings& rSettings )
2605 {
2606 MouseSettings aMouseSettings = rSettings.GetMouseSettings();
2607 aMouseSettings.SetDoubleClickTime( GetDoubleClickTime() );
2608 aMouseSettings.SetDoubleClickWidth( GetSystemMetrics( SM_CXDOUBLECLK ) );
2609 aMouseSettings.SetDoubleClickHeight( GetSystemMetrics( SM_CYDOUBLECLK ) );
2610 tools::Long nDragWidth = GetSystemMetrics( SM_CXDRAG );
2611 tools::Long nDragHeight = GetSystemMetrics( SM_CYDRAG );
2612 if ( nDragWidth )
2613 aMouseSettings.SetStartDragWidth( nDragWidth );
2614 if ( nDragHeight )
2615 aMouseSettings.SetStartDragHeight( nDragHeight );
2616 HKEY hRegKey;
2617 if ( RegOpenKeyW( HKEY_CURRENT_USER,
2618 L"Control Panel\\Desktop",
2619 &hRegKey ) == ERROR_SUCCESS )
2620 {
2621 wchar_t aValueBuf[10];
2622 DWORD nValueSize = sizeof( aValueBuf );
2623 DWORD nType;
2624 if ( RegQueryValueExW( hRegKey, L"MenuShowDelay", nullptr,
2625 &nType, reinterpret_cast<LPBYTE>(aValueBuf), &nValueSize ) == ERROR_SUCCESS )
2626 {
2627 if ( nType == REG_SZ )
2628 aMouseSettings.SetMenuDelay( static_cast<sal_uLong>(ImplW2I( aValueBuf )) );
2629 }
2630
2631 RegCloseKey( hRegKey );
2632 }
2633
2634 StyleSettings aStyleSettings = rSettings.GetStyleSettings();
2635
2636 aStyleSettings.SetScrollBarSize( GetSystemMetrics( SM_CXVSCROLL ) );
2637 aStyleSettings.SetSpinSize( GetSystemMetrics( SM_CXVSCROLL ) );
2638 UINT blinkTime = GetCaretBlinkTime();
2639 aStyleSettings.SetCursorBlinkTime(
2640 blinkTime == 0 || blinkTime == INFINITE // 0 indicates error
2641 ? STYLE_CURSOR_NOBLINKTIME : blinkTime );
2642 aStyleSettings.SetFloatTitleHeight( GetSystemMetrics( SM_CYSMCAPTION ) );
2643 aStyleSettings.SetTitleHeight( GetSystemMetrics( SM_CYCAPTION ) );
2644 aStyleSettings.SetActiveBorderColor( ImplWinColorToSal( GetSysColor( COLOR_ACTIVEBORDER ) ) );
2645 aStyleSettings.SetDeactiveBorderColor( ImplWinColorToSal( GetSysColor( COLOR_INACTIVEBORDER ) ) );
2646 aStyleSettings.SetDeactiveColor( ImplWinColorToSal( GetSysColor( COLOR_GRADIENTINACTIVECAPTION ) ) );
2647 aStyleSettings.SetFaceColor( ImplWinColorToSal( GetSysColor( COLOR_3DFACE ) ) );
2648 aStyleSettings.SetInactiveTabColor( aStyleSettings.GetFaceColor() );
2649 aStyleSettings.SetLightColor( ImplWinColorToSal( GetSysColor( COLOR_3DHILIGHT ) ) );
2650 aStyleSettings.SetLightBorderColor( ImplWinColorToSal( GetSysColor( COLOR_3DLIGHT ) ) );
2651 aStyleSettings.SetShadowColor( ImplWinColorToSal( GetSysColor( COLOR_3DSHADOW ) ) );
2652 aStyleSettings.SetDarkShadowColor( ImplWinColorToSal( GetSysColor( COLOR_3DDKSHADOW ) ) );
2653 aStyleSettings.SetHelpColor( ImplWinColorToSal( GetSysColor( COLOR_INFOBK ) ) );
2654 aStyleSettings.SetHelpTextColor( ImplWinColorToSal( GetSysColor( COLOR_INFOTEXT ) ) );
2655
2656 Color aControlTextColor(ImplWinColorToSal(GetSysColor(COLOR_BTNTEXT)));
2657
2658 aStyleSettings.SetDialogColor(aStyleSettings.GetFaceColor());
2659 aStyleSettings.SetDialogTextColor(aControlTextColor);
2660
2661 aStyleSettings.SetDefaultButtonTextColor(aControlTextColor);
2662 aStyleSettings.SetButtonTextColor(aControlTextColor);
2663 aStyleSettings.SetDefaultActionButtonTextColor(aControlTextColor);
2664 aStyleSettings.SetActionButtonTextColor(aControlTextColor);
2665 aStyleSettings.SetFlatButtonTextColor(aControlTextColor);
2666 aStyleSettings.SetDefaultButtonRolloverTextColor(aControlTextColor);
2667 aStyleSettings.SetButtonRolloverTextColor(aControlTextColor);
2668 aStyleSettings.SetDefaultActionButtonRolloverTextColor(aControlTextColor);
2669 aStyleSettings.SetActionButtonRolloverTextColor(aControlTextColor);
2670 aStyleSettings.SetFlatButtonRolloverTextColor(aControlTextColor);
2671 aStyleSettings.SetDefaultButtonPressedRolloverTextColor(aControlTextColor);
2672 aStyleSettings.SetButtonPressedRolloverTextColor(aControlTextColor);
2673 aStyleSettings.SetDefaultActionButtonPressedRolloverTextColor(aControlTextColor);
2674 aStyleSettings.SetActionButtonPressedRolloverTextColor(aControlTextColor);
2675 aStyleSettings.SetFlatButtonPressedRolloverTextColor(aControlTextColor);
2676
2677 aStyleSettings.SetTabTextColor(aControlTextColor);
2678 aStyleSettings.SetTabRolloverTextColor(aControlTextColor);
2679 aStyleSettings.SetTabHighlightTextColor(aControlTextColor);
2680
2681 aStyleSettings.SetRadioCheckTextColor( ImplWinColorToSal( GetSysColor( COLOR_WINDOWTEXT ) ) );
2682 aStyleSettings.SetGroupTextColor( aStyleSettings.GetRadioCheckTextColor() );
2683 aStyleSettings.SetLabelTextColor( aStyleSettings.GetRadioCheckTextColor() );
2684 aStyleSettings.SetWindowColor( ImplWinColorToSal( GetSysColor( COLOR_WINDOW ) ) );
2685 aStyleSettings.SetActiveTabColor( aStyleSettings.GetWindowColor() );
2686 aStyleSettings.SetWindowTextColor( ImplWinColorToSal( GetSysColor( COLOR_WINDOWTEXT ) ) );
2687 aStyleSettings.SetToolTextColor( ImplWinColorToSal( GetSysColor( COLOR_WINDOWTEXT ) ) );
2688 aStyleSettings.SetFieldColor( aStyleSettings.GetWindowColor() );
2689 aStyleSettings.SetFieldTextColor( aStyleSettings.GetWindowTextColor() );
2690 aStyleSettings.SetFieldRolloverTextColor( aStyleSettings.GetFieldTextColor() );
2691 aStyleSettings.SetHighlightColor( ImplWinColorToSal( GetSysColor( COLOR_HIGHLIGHT ) ) );
2692 aStyleSettings.SetHighlightTextColor( ImplWinColorToSal( GetSysColor( COLOR_HIGHLIGHTTEXT ) ) );
2693 aStyleSettings.SetMenuHighlightColor( aStyleSettings.GetHighlightColor() );
2694 aStyleSettings.SetMenuHighlightTextColor( aStyleSettings.GetHighlightTextColor() );
2695
2696 ImplSVData* pSVData = ImplGetSVData();
2697 pSVData->maNWFData.mnMenuFormatBorderX = 0;
2698 pSVData->maNWFData.mnMenuFormatBorderY = 0;
2699 pSVData->maNWFData.maMenuBarHighlightTextColor = COL_TRANSPARENT;
2700 GetSalData()->mbThemeMenuSupport = false;
2701 if (officecfg::Office::Common::Accessibility::AutoDetectSystemHC::get())
2702 {
2703 aStyleSettings.SetShadowColor( ImplWinColorToSal( GetSysColor( COLOR_ACTIVEBORDER ) ) );
2704 aStyleSettings.SetWorkspaceColor( ImplWinColorToSal( GetSysColor( COLOR_MENU ) ) );
2705 }
2706 aStyleSettings.SetMenuColor( ImplWinColorToSal( GetSysColor( COLOR_MENU ) ) );
2707 aStyleSettings.SetMenuBarColor( aStyleSettings.GetMenuColor() );
2708 aStyleSettings.SetMenuBarRolloverColor( aStyleSettings.GetHighlightColor() );
2709 aStyleSettings.SetMenuBorderColor( aStyleSettings.GetLightBorderColor() ); // overridden below for flat menus
2710 aStyleSettings.SetUseFlatBorders( false );
2711 aStyleSettings.SetUseFlatMenus( false );
2712 aStyleSettings.SetMenuTextColor( ImplWinColorToSal( GetSysColor( COLOR_MENUTEXT ) ) );
2713 if ( std::optional<Color> aColor = aStyleSettings.GetPersonaMenuBarTextColor() )
2714 {
2715 aStyleSettings.SetMenuBarTextColor( *aColor );
2716 aStyleSettings.SetMenuBarRolloverTextColor( *aColor );
2717 }
2718 else
2719 {
2720 aStyleSettings.SetMenuBarTextColor( ImplWinColorToSal( GetSysColor( COLOR_MENUTEXT ) ) );
2721 aStyleSettings.SetMenuBarRolloverTextColor( ImplWinColorToSal( GetSysColor( COLOR_HIGHLIGHTTEXT ) ) );
2722 }
2723 aStyleSettings.SetMenuBarHighlightTextColor(aStyleSettings.GetMenuHighlightTextColor());
2724 aStyleSettings.SetActiveColor( ImplWinColorToSal( GetSysColor( COLOR_ACTIVECAPTION ) ) );
2725 aStyleSettings.SetActiveTextColor( ImplWinColorToSal( GetSysColor( COLOR_CAPTIONTEXT ) ) );
2726 aStyleSettings.SetDeactiveColor( ImplWinColorToSal( GetSysColor( COLOR_INACTIVECAPTION ) ) );
2727 aStyleSettings.SetDeactiveTextColor( ImplWinColorToSal( GetSysColor( COLOR_INACTIVECAPTIONTEXT ) ) );
2728 BOOL bFlatMenus = FALSE;
2729 SystemParametersInfoW( SPI_GETFLATMENU, 0, &bFlatMenus, 0);
2730 if( bFlatMenus )
2731 {
2732 aStyleSettings.SetUseFlatMenus( true );
2733 aStyleSettings.SetMenuBarColor( ImplWinColorToSal( GetSysColor( COLOR_MENUBAR ) ) );
2734 aStyleSettings.SetMenuHighlightColor( ImplWinColorToSal( GetSysColor( COLOR_MENUHILIGHT ) ) );
2735 aStyleSettings.SetMenuBarRolloverColor( ImplWinColorToSal( GetSysColor( COLOR_MENUHILIGHT ) ) );
2736 aStyleSettings.SetMenuBorderColor( ImplWinColorToSal( GetSysColor( COLOR_3DSHADOW ) ) );
2737
2738 // flat borders for our controls etc. as well in this mode (ie, no 3d borders)
2739 // this is not active in the classic style appearance
2740 aStyleSettings.SetUseFlatBorders( true );
2741 }
2742 aStyleSettings.SetCheckedColorSpecialCase( );
2743
2744 // caret width
2745 DWORD nCaretWidth = 2;
2746 if( SystemParametersInfoW( SPI_GETCARETWIDTH, 0, &nCaretWidth, 0 ) )
2747 aStyleSettings.SetCursorSize( nCaretWidth );
2748
2749 // High contrast
2750 HIGHCONTRAST hc;
2751 hc.cbSize = sizeof( HIGHCONTRAST );
2752 if( SystemParametersInfoW( SPI_GETHIGHCONTRAST, hc.cbSize, &hc, 0 )
2753 && (hc.dwFlags & HCF_HIGHCONTRASTON) )
2754 aStyleSettings.SetHighContrastMode( true );
2755 else
2756 aStyleSettings.SetHighContrastMode( false );
2757
2758 // Query Fonts
2759 vcl::Font aMenuFont = aStyleSettings.GetMenuFont();
2760 vcl::Font aTitleFont = aStyleSettings.GetTitleFont();
2761 vcl::Font aFloatTitleFont = aStyleSettings.GetFloatTitleFont();
2762 vcl::Font aHelpFont = aStyleSettings.GetHelpFont();
2763 vcl::Font aAppFont = aStyleSettings.GetAppFont();
2764 vcl::Font aIconFont = aStyleSettings.GetIconFont();
2765 HDC hDC = GetDC( nullptr );
2766 NONCLIENTMETRICSW aNonClientMetrics;
2767 aNonClientMetrics.cbSize = sizeof( aNonClientMetrics );
2768 if ( SystemParametersInfoW( SPI_GETNONCLIENTMETRICS, sizeof( aNonClientMetrics ), &aNonClientMetrics, 0 ) )
2769 {
2770 ImplSalUpdateStyleFontW( hDC, aNonClientMetrics.lfMenuFont, aMenuFont );
2771 ImplSalUpdateStyleFontW( hDC, aNonClientMetrics.lfCaptionFont, aTitleFont );
2772 ImplSalUpdateStyleFontW( hDC, aNonClientMetrics.lfSmCaptionFont, aFloatTitleFont );
2773 ImplSalUpdateStyleFontW( hDC, aNonClientMetrics.lfStatusFont, aHelpFont );
2774 ImplSalUpdateStyleFontW( hDC, aNonClientMetrics.lfMessageFont, aAppFont );
2775
2776 LOGFONTW aLogFont;
2777 if ( SystemParametersInfoW( SPI_GETICONTITLELOGFONT, 0, &aLogFont, 0 ) )
2778 ImplSalUpdateStyleFontW( hDC, aLogFont, aIconFont );
2779 }
2780
2781 ReleaseDC( nullptr, hDC );
2782
2783 aStyleSettings.SetToolbarIconSize(ToolbarIconSize::Large);
2784
2785 aStyleSettings.BatchSetFonts( aAppFont, aAppFont );
2786
2787 aStyleSettings.SetMenuFont( aMenuFont );
2788 aStyleSettings.SetTitleFont( aTitleFont );
2789 aStyleSettings.SetFloatTitleFont( aFloatTitleFont );
2790 aStyleSettings.SetHelpFont( aHelpFont );
2791 aStyleSettings.SetIconFont( aIconFont );
2792
2793 if ( aAppFont.GetWeight() > WEIGHT_NORMAL )
2794 aAppFont.SetWeight( WEIGHT_NORMAL );
2795 aStyleSettings.SetToolFont( aAppFont );
2796 aStyleSettings.SetTabFont( aAppFont );
2797
2798 BOOL bDragFull;
2799 if ( SystemParametersInfoW( SPI_GETDRAGFULLWINDOWS, 0, &bDragFull, 0 ) )
2800 {
2801 DragFullOptions nDragFullOptions = aStyleSettings.GetDragFullOptions();
2802 if ( bDragFull )
2803 nDragFullOptions |= DragFullOptions::WindowMove | DragFullOptions::WindowSize | DragFullOptions::Docking | DragFullOptions::Split;
2804 else
2805 nDragFullOptions &= ~DragFullOptions(DragFullOptions::WindowMove | DragFullOptions::WindowSize | DragFullOptions::Docking | DragFullOptions::Split);
2806 aStyleSettings.SetDragFullOptions( nDragFullOptions );
2807 }
2808
2809 if ( RegOpenKeyW( HKEY_CURRENT_USER,
2810 L"Control Panel\\International\\Calendars\\TwoDigitYearMax",
2811 &hRegKey ) == ERROR_SUCCESS )
2812 {
2813 wchar_t aValueBuf[10];
2814 DWORD nValue;
2815 DWORD nValueSize = sizeof( aValueBuf );
2816 DWORD nType;
2817 if ( RegQueryValueExW( hRegKey, L"1", nullptr,
2818 &nType, reinterpret_cast<LPBYTE>(aValueBuf), &nValueSize ) == ERROR_SUCCESS )
2819 {
2820 if ( nType == REG_SZ )
2821 {
2822 nValue = static_cast<sal_uLong>(ImplW2I( aValueBuf ));
2823 if ( (nValue > 1000) && (nValue < 10000) )
2824 {
2825 std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create());
2826 officecfg::Office::Common::DateFormat::TwoDigitYear::set(static_cast<sal_Int32>(nValue-99), batch);
2827 batch->commit();
2828 }
2829 }
2830 }
2831
2832 RegCloseKey( hRegKey );
2833 }
2834
2835 rSettings.SetMouseSettings( aMouseSettings );
2836 rSettings.SetStyleSettings( aStyleSettings );
2837
2838 // now apply the values from theming, if available
2839 WinSalGraphics::updateSettingsNative( rSettings );
2840 }
2841
2842 const SystemEnvData* WinSalFrame::GetSystemData() const
2843 {
2844 return &maSysData;
2845 }
2846
2847 void WinSalFrame::Beep()
2848 {
2849 // a simple beep
2850 MessageBeep( 0 );
2851 }
2852
2853 SalFrame::SalPointerState WinSalFrame::GetPointerState()
2854 {
2855 SalPointerState aState;
2856 aState.mnState = 0;
2857
2858 if ( GetKeyState( VK_LBUTTON ) & 0x8000 )
2859 aState.mnState |= MOUSE_LEFT;
2860 if ( GetKeyState( VK_MBUTTON ) & 0x8000 )
2861 aState.mnState |= MOUSE_MIDDLE;
2862 if ( GetKeyState( VK_RBUTTON ) & 0x8000 )
2863 aState.mnState |= MOUSE_RIGHT;
2864 if ( GetKeyState( VK_SHIFT ) & 0x8000 )
2865 aState.mnState |= KEY_SHIFT;
2866 if ( GetKeyState( VK_CONTROL ) & 0x8000 )
2867 aState.mnState |= KEY_MOD1;
2868 if ( GetKeyState( VK_MENU ) & 0x8000 )
2869 aState.mnState |= KEY_MOD2;
2870
2871 POINT pt;
2872 GetCursorPos( &pt );
2873
2874 aState.maPos = Point( pt.x - maGeometry.nX, pt.y - maGeometry.nY );
2875 return aState;
2876 }
2877
2878 KeyIndicatorState WinSalFrame::GetIndicatorState()
2879 {
2880 KeyIndicatorState aState = KeyIndicatorState::NONE;
2881 if (::GetKeyState(VK_CAPITAL))
2882 aState |= KeyIndicatorState::CAPSLOCK;
2883
2884 if (::GetKeyState(VK_NUMLOCK))
2885 aState |= KeyIndicatorState::NUMLOCK;
2886
2887 if (::GetKeyState(VK_SCROLL))
2888 aState |= KeyIndicatorState::SCROLLLOCK;
2889
2890 return aState;
2891 }
2892
2893 void WinSalFrame::SimulateKeyPress( sal_uInt16 nKeyCode )
2894 {
2895 BYTE nVKey = 0;
2896 switch (nKeyCode)
2897 {
2898 case KEY_CAPSLOCK:
2899 nVKey = VK_CAPITAL;
2900 break;
2901 }
2902
2903 if (nVKey > 0 && nVKey < 255)
2904 {
2905 ::keybd_event(nVKey, 0x45, KEYEVENTF_EXTENDEDKEY, 0);
2906 ::keybd_event(nVKey, 0x45, KEYEVENTF_EXTENDEDKEY|KEYEVENTF_KEYUP, 0);
2907 }
2908 }
2909
2910 void WinSalFrame::ResetClipRegion()
2911 {
2912 SetWindowRgn( mhWnd, nullptr, TRUE );
2913 }
2914
2915 void WinSalFrame::BeginSetClipRegion( sal_uInt32 nRects )
2916 {
2917 if( mpClipRgnData )
2918 delete [] reinterpret_cast<BYTE*>(mpClipRgnData);
2919 sal_uLong nRectBufSize = sizeof(RECT)*nRects;
2920 mpClipRgnData = reinterpret_cast<RGNDATA*>(new BYTE[sizeof(RGNDATA)-1+nRectBufSize]);
2921 mpClipRgnData->rdh.dwSize = sizeof( RGNDATAHEADER );
2922 mpClipRgnData->rdh.iType = RDH_RECTANGLES;
2923 mpClipRgnData->rdh.nCount = nRects;
2924 mpClipRgnData->rdh.nRgnSize = nRectBufSize;
2925 SetRectEmpty( &(mpClipRgnData->rdh.rcBound) );
2926 mpNextClipRect = reinterpret_cast<RECT*>(&(mpClipRgnData->Buffer));
2927 mbFirstClipRect = true;
2928 }
2929
2930 void WinSalFrame::UnionClipRegion( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight )
2931 {
2932 if( ! mpClipRgnData )
2933 return;
2934
2935 RECT* pRect = mpNextClipRect;
2936 RECT* pBoundRect = &(mpClipRgnData->rdh.rcBound);
2937 tools::Long nRight = nX + nWidth;
2938 tools::Long nBottom = nY + nHeight;
2939
2940 if ( mbFirstClipRect )
2941 {
2942 pBoundRect->left = nX;
2943 pBoundRect->top = nY;
2944 pBoundRect->right = nRight;
2945 pBoundRect->bottom = nBottom;
2946 mbFirstClipRect = false;
2947 }
2948 else
2949 {
2950 if ( nX < pBoundRect->left )
2951 pBoundRect->left = static_cast<int>(nX);
2952
2953 if ( nY < pBoundRect->top )
2954 pBoundRect->top = static_cast<int>(nY);
2955
2956 if ( nRight > pBoundRect->right )
2957 pBoundRect->right = static_cast<int>(nRight);
2958
2959 if ( nBottom > pBoundRect->bottom )
2960 pBoundRect->bottom = static_cast<int>(nBottom);
2961 }
2962
2963 pRect->left = static_cast<int>(nX);
2964 pRect->top = static_cast<int>(nY);
2965 pRect->right = static_cast<int>(nRight);
2966 pRect->bottom = static_cast<int>(nBottom);
2967 if( (mpNextClipRect - reinterpret_cast<RECT*>(&mpClipRgnData->Buffer)) < static_cast<int>(mpClipRgnData->rdh.nCount) )
2968 mpNextClipRect++;
2969 }
2970
2971 void WinSalFrame::EndSetClipRegion()
2972 {
2973 if( ! mpClipRgnData )
2974 return;
2975
2976 HRGN hRegion;
2977
2978 // create region from accumulated rectangles
2979 if ( mpClipRgnData->rdh.nCount == 1 )
2980 {
2981 RECT* pRect = &(mpClipRgnData->rdh.rcBound);
2982 hRegion = CreateRectRgn( pRect->left, pRect->top,
2983 pRect->right, pRect->bottom );
2984 }
2985 else
2986 {
2987 sal_uLong nSize = mpClipRgnData->rdh.nRgnSize+sizeof(RGNDATAHEADER);
2988 hRegion = ExtCreateRegion( nullptr, nSize, mpClipRgnData );
2989 }
2990 delete [] reinterpret_cast<BYTE*>(mpClipRgnData);
2991 mpClipRgnData = nullptr;
2992
2993 SAL_WARN_IF( !hRegion, "vcl", "WinSalFrame::EndSetClipRegion() - Can't create ClipRegion" );
2994 if( hRegion )
2995 {
2996 RECT aWindowRect;
2997 GetWindowRect( mhWnd, &aWindowRect );
2998 POINT aPt;
2999 aPt.x=0;
3000 aPt.y=0;
3001 ClientToScreen( mhWnd, &aPt );
3002 OffsetRgn( hRegion, aPt.x - aWindowRect.left, aPt.y - aWindowRect.top );
3003
3004 if( SetWindowRgn( mhWnd, hRegion, TRUE ) == 0 )
3005 DeleteObject( hRegion );
3006 }
3007 }
3008
3009 static bool ImplHandleMouseMsg( HWND hWnd, UINT nMsg,
3010 WPARAM wParam, LPARAM lParam )
3011 {
3012 WinSalFrame* pFrame = GetWindowPtr( hWnd );
3013 if ( !pFrame )
3014 return false;
3015
3016 if( nMsg == WM_LBUTTONDOWN || nMsg == WM_MBUTTONDOWN || nMsg == WM_RBUTTONDOWN )
3017 {
3018 // #103168# post again if async focus has not arrived yet
3019 // hopefully we will not receive the corresponding button up before this
3020 // button down arrives again
3021 vcl::Window *pWin = pFrame->GetWindow();
3022 if( pWin && pWin->ImplGetWindowImpl()->mpFrameData->mnFocusId )
3023 {
3024 bool const ret = PostMessageW( hWnd, nMsg, wParam, lParam );
3025 SAL_WARN_IF(!ret, "vcl", "ERROR: PostMessage() failed!");
3026 return true;
3027 }
3028 }
3029 SalMouseEvent aMouseEvt;
3030 bool nRet;
3031 SalEvent nEvent = SalEvent::NONE;
3032 bool bCall = true;
3033
3034 aMouseEvt.mnX = static_cast<short>(LOWORD( lParam ));
3035 aMouseEvt.mnY = static_cast<short>(HIWORD( lParam ));
3036 aMouseEvt.mnCode = 0;
3037 aMouseEvt.mnTime = GetMessageTime();
3038
3039 // Use GetKeyState(), as some Logitech mouse drivers do not check
3040 // KeyState when simulating double-click with center mouse button
3041
3042 if ( GetKeyState( VK_LBUTTON ) & 0x8000 )
3043 aMouseEvt.mnCode |= MOUSE_LEFT;
3044 if ( GetKeyState( VK_MBUTTON ) & 0x8000 )
3045 aMouseEvt.mnCode |= MOUSE_MIDDLE;
3046 if ( GetKeyState( VK_RBUTTON ) & 0x8000 )
3047 aMouseEvt.mnCode |= MOUSE_RIGHT;
3048 if ( GetKeyState( VK_SHIFT ) & 0x8000 )
3049 aMouseEvt.mnCode |= KEY_SHIFT;
3050 if ( GetKeyState( VK_CONTROL ) & 0x8000 )
3051 aMouseEvt.mnCode |= KEY_MOD1;
3052 if ( GetKeyState( VK_MENU ) & 0x8000 )
3053 aMouseEvt.mnCode |= KEY_MOD2;
3054
3055 switch ( nMsg )
3056 {
3057 case WM_MOUSEMOVE:
3058 {
3059 // As the mouse events are not collected correctly when
3060 // pressing modifier keys (as interrupted by KeyEvents)
3061 // we do this here ourselves
3062 if ( aMouseEvt.mnCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2) )
3063 {
3064 MSG aTempMsg;
3065 if ( PeekMessageW( &aTempMsg, hWnd, WM_MOUSEFIRST, WM_MOUSELAST, PM_NOREMOVE | PM_NOYIELD ) )
3066 {
3067 if ( (aTempMsg.message == WM_MOUSEMOVE) &&
3068 (aTempMsg.wParam == wParam) )
3069 return true;
3070 }
3071 }
3072
3073 SalData* pSalData = GetSalData();
3074 // Test for MouseLeave
3075 if ( pSalData->mhWantLeaveMsg && (pSalData->mhWantLeaveMsg != hWnd) )
3076 SendMessageW( pSalData->mhWantLeaveMsg, SAL_MSG_MOUSELEAVE, 0, GetMessagePos() );
3077
3078 pSalData->mhWantLeaveMsg = hWnd;
3079 // Start MouseLeave-Timer
3080 if ( !pSalData->mpMouseLeaveTimer )
3081 {
3082 pSalData->mpMouseLeaveTimer = new AutoTimer;
3083 pSalData->mpMouseLeaveTimer->SetDebugName( "ImplHandleMouseMsg SalData::mpMouseLeaveTimer" );
3084 pSalData->mpMouseLeaveTimer->SetTimeout( SAL_MOUSELEAVE_TIMEOUT );
3085 pSalData->mpMouseLeaveTimer->Start();
3086 // We don't need to set a timeout handler, because we test
3087 // for mouseleave in the timeout callback
3088 }
3089 aMouseEvt.mnButton = 0;
3090 nEvent = SalEvent::MouseMove;
3091 }
3092 break;
3093
3094 case WM_NCMOUSEMOVE:
3095 case SAL_MSG_MOUSELEAVE:
3096 {
3097 SalData* pSalData = GetSalData();
3098 if ( pSalData->mhWantLeaveMsg == hWnd )
3099 {
3100 // Mouse-Coordinates are relative to the screen
3101 POINT aPt;
3102 aPt.x = static_cast<short>(LOWORD(lParam));
3103 aPt.y = static_cast<short>(HIWORD(lParam));
3104 ScreenToClient(hWnd, &aPt);
3105 if (const auto& pHelpWin = ImplGetSVHelpData().mpHelpWin)
3106 {
3107 const tools::Rectangle& rHelpRect = pHelpWin->GetHelpArea();
3108 if (rHelpRect.IsInside(Point(aPt.x, aPt.y)))
3109 {
3110 // We have entered a tooltip (help window). Don't call the handler here; it
3111 // would launch the sequence "Mouse leaves the Control->Control redraws->
3112 // Help window gets destroyed->Mouse enters the Control->Control redraws",
3113 // which takes CPU and may flicker. Just destroy the help window and pretend
3114 // we are still over the original window.
3115 ImplDestroyHelpWindow(true);
3116 bCall = false;
3117 break;
3118 }
3119 }
3120 pSalData->mhWantLeaveMsg = nullptr;
3121 if ( pSalData->mpMouseLeaveTimer )
3122 {
3123 delete pSalData->mpMouseLeaveTimer;
3124 pSalData->mpMouseLeaveTimer = nullptr;
3125 }
3126 aMouseEvt.mnX = aPt.x;
3127 aMouseEvt.mnY = aPt.y;
3128 aMouseEvt.mnButton = 0;
3129 nEvent = SalEvent::MouseLeave;
3130 }
3131 else
3132 bCall = false;
3133 }
3134 break;
3135
3136 case WM_LBUTTONDOWN:
3137 aMouseEvt.mnButton = MOUSE_LEFT;
3138 nEvent = SalEvent::MouseButtonDown;
3139 break;
3140
3141 case WM_MBUTTONDOWN:
3142 aMouseEvt.mnButton = MOUSE_MIDDLE;
3143 nEvent = SalEvent::MouseButtonDown;
3144 break;
3145
3146 case WM_RBUTTONDOWN:
3147 aMouseEvt.mnButton = MOUSE_RIGHT;
3148 nEvent = SalEvent::MouseButtonDown;
3149 break;
3150
3151 case WM_LBUTTONUP:
3152 aMouseEvt.mnButton = MOUSE_LEFT;
3153 nEvent = SalEvent::MouseButtonUp;
3154 break;
3155
3156 case WM_MBUTTONUP:
3157 aMouseEvt.mnButton = MOUSE_MIDDLE;
3158 nEvent = SalEvent::MouseButtonUp;
3159 break;
3160
3161 case WM_RBUTTONUP:
3162 aMouseEvt.mnButton = MOUSE_RIGHT;
3163 nEvent = SalEvent::MouseButtonUp;
3164 break;
3165 }
3166
3167 // check if this window was destroyed - this might happen if we are the help window
3168 // and sent a mouse leave message to the application which killed the help window, ie ourselves
3169 if( !IsWindow( hWnd ) )
3170 return false;
3171
3172 if ( bCall )
3173 {
3174 if ( nEvent == SalEvent::MouseButtonDown )
3175 UpdateWindow( hWnd );
3176
3177 if( AllSettings::GetLayoutRTL() )
3178 aMouseEvt.mnX = pFrame->maGeometry.nWidth-1-aMouseEvt.mnX;
3179
3180 nRet = pFrame->CallCallback( nEvent, &aMouseEvt );
3181 if ( nMsg == WM_MOUSEMOVE )
3182 SetCursor( pFrame->mhCursor );
3183 }
3184 else
3185 nRet = false;
3186
3187 return nRet;
3188 }
3189
3190 static bool ImplHandleMouseActivateMsg( HWND hWnd )
3191 {
3192 WinSalFrame* pFrame = GetWindowPtr( hWnd );
3193 if ( !pFrame )
3194 return false;
3195
3196 if ( pFrame->mbFloatWin )
3197 return true;
3198
3199 return pFrame->CallCallback( SalEvent::MouseActivate, nullptr );
3200 }
3201
3202 static bool ImplHandleWheelMsg( HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam )
3203 {
3204 DBG_ASSERT( nMsg == WM_MOUSEWHEEL ||
3205 nMsg == WM_MOUSEHWHEEL,
3206 "ImplHandleWheelMsg() called with no wheel mouse event" );
3207
3208 ImplSalYieldMutexAcquireWithWait();
3209
3210 bool nRet = false;
3211 WinSalFrame* pFrame = GetWindowPtr( hWnd );
3212 if ( pFrame )
3213 {
3214 WORD nWinModCode = LOWORD( wParam );
3215 POINT aWinPt;
3216 aWinPt.x = static_cast<short>(LOWORD( lParam ));
3217 aWinPt.y = static_cast<short>(HIWORD( lParam ));
3218 ScreenToClient( hWnd, &aWinPt );
3219
3220 SalWheelMouseEvent aWheelEvt;
3221 aWheelEvt.mnTime = GetMessageTime();
3222 aWheelEvt.mnX = aWinPt.x;
3223 aWheelEvt.mnY = aWinPt.y;
3224 aWheelEvt.mnCode = 0;
3225 aWheelEvt.mnDelta = static_cast<short>(HIWORD( wParam ));
3226 aWheelEvt.mnNotchDelta = aWheelEvt.mnDelta/WHEEL_DELTA;
3227 if( aWheelEvt.mnNotchDelta == 0 )
3228 {
3229 if( aWheelEvt.mnDelta > 0 )
3230 aWheelEvt.mnNotchDelta = 1;
3231 else if( aWheelEvt.mnDelta < 0 )
3232 aWheelEvt.mnNotchDelta = -1;
3233 }
3234
3235 if( nMsg == WM_MOUSEWHEEL )
3236 {
3237 if ( aSalShlData.mnWheelScrollLines == WHEEL_PAGESCROLL )
3238 aWheelEvt.mnScrollLines = SAL_WHEELMOUSE_EVENT_PAGESCROLL;
3239 else
3240 aWheelEvt.mnScrollLines = aSalShlData.mnWheelScrollLines;
3241 aWheelEvt.mbHorz = false;
3242 }
3243 else
3244 {
3245 aWheelEvt.mnScrollLines = aSalShlData.mnWheelScrollChars;
3246 aWheelEvt.mbHorz = true;
3247
3248 // fdo#36380 - seems horiz scrolling has swapped direction
3249 aWheelEvt.mnDelta *= -1;
3250 aWheelEvt.mnNotchDelta *= -1;
3251 }
3252
3253 if ( nWinModCode & MK_SHIFT )
3254 aWheelEvt.mnCode |= KEY_SHIFT;
3255 if ( nWinModCode & MK_CONTROL )
3256 aWheelEvt.mnCode |= KEY_MOD1;
3257 if ( GetKeyState( VK_MENU ) & 0x8000 )
3258 aWheelEvt.mnCode |= KEY_MOD2;
3259
3260 if( AllSettings::GetLayoutRTL() )
3261 aWheelEvt.mnX = pFrame->maGeometry.nWidth-1-aWheelEvt.mnX;
3262
3263 nRet = pFrame->CallCallback( SalEvent::WheelMouse, &aWheelEvt );
3264 }
3265
3266 ImplSalYieldMutexRelease();
3267
3268 return nRet;
3269 }
3270
3271 static sal_uInt16 ImplSalGetKeyCode( WPARAM wParam )
3272 {
3273 sal_uInt16 nKeyCode;
3274
3275 // convert KeyCode
3276 if ( wParam < KEY_TAB_SIZE )
3277 nKeyCode = aImplTranslateKeyTab[wParam];
3278 else
3279 {
3280 SalData* pSalData = GetSalData();
3281 std::map< UINT, sal_uInt16 >::const_iterator it = pSalData->maVKMap.find( static_cast<UINT>(wParam) );
3282 if( it != pSalData->maVKMap.end() )
3283 nKeyCode = it->second;
3284 else
3285 nKeyCode = 0;
3286 }
3287
3288 return nKeyCode;
3289 }
3290
3291 static void ImplUpdateInputLang( WinSalFrame* pFrame )
3292 {
3293 UINT nLang = LOWORD( GetKeyboardLayout( 0 ) );
3294 if ( nLang && nLang != pFrame->mnInputLang )
3295 {
3296 // keep input lang up-to-date
3297 pFrame->mnInputLang = nLang;
3298 }
3299
3300 // We are on Windows NT so we use Unicode FrameProcs and get
3301 // Unicode charcodes directly from Windows no need to set up a
3302 // code page
3303 return;
3304 }
3305
3306 static sal_Unicode ImplGetCharCode( WinSalFrame* pFrame, WPARAM nCharCode )
3307 {
3308 ImplUpdateInputLang( pFrame );
3309
3310 // We are on Windows NT so we use Unicode FrameProcs and we
3311 // get Unicode charcodes directly from Windows
3312 return static_cast<sal_Unicode>(nCharCode);
3313 }
3314
3315 LanguageType WinSalFrame::GetInputLanguage()
3316 {
3317 if( !mnInputLang )
3318 ImplUpdateInputLang( this );
3319
3320 if( !mnInputLang )
3321 return LANGUAGE_DONTKNOW;
3322 else
3323 return LanguageType(mnInputLang);
3324 }
3325
3326 bool WinSalFrame::MapUnicodeToKeyCode( sal_Unicode aUnicode, LanguageType aLangType, vcl::KeyCode& rKeyCode )
3327 {
3328 bool bRet = false;
3329 sal_IntPtr nLangType = static_cast<sal_uInt16>(aLangType);
3330 // just use the passed language identifier, do not try to load additional keyboard support
3331 HKL hkl = reinterpret_cast<HKL>(nLangType);
3332
3333 if( hkl )
3334 {
3335 SHORT scan = VkKeyScanExW( aUnicode, hkl );
3336 if( LOWORD(scan) == 0xFFFF )
3337 // keyboard not loaded or key cannot be mapped
3338 bRet = false;
3339 else
3340 {
3341 BYTE vkeycode = LOBYTE(scan);
3342 BYTE shiftstate = HIBYTE(scan);
3343
3344 // Last argument is set to false, because there's no decision made
3345 // yet which key should be assigned to MOD3 modifier on Windows.
3346 // Windows key - user's can be confused, because it should display
3347 // Windows menu (applies to both left/right key)
3348 // Menu key - this key is used to display context menu
3349 // AltGr key - probably it has no sense
3350 rKeyCode = vcl::KeyCode( ImplSalGetKeyCode( vkeycode ),
3351 (shiftstate & 0x01) != 0, // shift
3352 (shiftstate & 0x02) != 0, // ctrl
3353 (shiftstate & 0x04) != 0, // alt
3354 false );
3355 bRet = true;
3356 }
3357 }
3358
3359 return bRet;
3360 }
3361
3362 static bool ImplHandleKeyMsg( HWND hWnd, UINT nMsg,
3363 WPARAM wParam, LPARAM lParam, LRESULT& rResult )
3364 {
3365 static bool bIgnoreCharMsg = false;
3366 static WPARAM nDeadChar = 0;
3367 static WPARAM nLastVKChar = 0;
3368 static sal_uInt16 nLastChar = 0;
3369 static ModKeyFlags nLastModKeyCode = ModKeyFlags::NONE;
3370 static bool bWaitForModKeyRelease = false;
3371 sal_uInt16 nRepeat = LOWORD( lParam )-1;
3372 sal_uInt16 nModCode = 0;
3373
3374 // this key might have been relayed by SysChild and thus
3375 // may not be processed twice
3376 GetSalData()->mnSalObjWantKeyEvt = 0;
3377
3378 if ( nMsg == WM_DEADCHAR )
3379 {
3380 nDeadChar = wParam;
3381 return false;
3382 }
3383
3384 WinSalFrame* pFrame = GetWindowPtr( hWnd );
3385 if ( !pFrame )
3386 return false;
3387
3388 // reset the background mode for each text input,
3389 // as some tools such as RichWin may have changed it
3390 if ( pFrame->mpLocalGraphics &&
3391 pFrame->mpLocalGraphics->getHDC() )
3392 SetBkMode( pFrame->mpLocalGraphics->getHDC(), TRANSPARENT );
3393
3394 // determine modifiers
3395 if ( GetKeyState( VK_SHIFT ) & 0x8000 )
3396 nModCode |= KEY_SHIFT;
3397 if ( GetKeyState( VK_CONTROL ) & 0x8000 )
3398 nModCode |= KEY_MOD1;
3399 if (GetKeyState(VK_MENU) & 0x8000)
3400 nModCode |= KEY_MOD2;
3401
3402 if ( (nMsg == WM_CHAR) || (nMsg == WM_SYSCHAR) )
3403 {
3404 nDeadChar = 0;
3405
3406 if ( bIgnoreCharMsg )
3407 {
3408 bIgnoreCharMsg = false;
3409 // #101635# if zero is returned here for WM_SYSCHAR (ALT+<key>) Windows will beep
3410 // because this 'hotkey' was not processed -> better return 1
3411 // except for Alt-SPACE which should always open the sysmenu (#104616#)
3412
3413 // also return zero if a system menubar is available that might process this hotkey
3414 // this also applies to the OLE inplace embedding where we are a child window
3415 if( (GetWindowStyle( hWnd ) & WS_CHILD) || GetMenu( hWnd ) || (wParam == 0x20) )
3416 return false;
3417 else
3418 return true;
3419 }
3420
3421 // ignore backspace as a single key, so that
3422 // we do not get problems for combinations w/ a DeadKey
3423 if ( wParam == 0x08 ) // BACKSPACE
3424 return false;
3425
3426 // only "free flying" WM_CHAR messages arrive here, that are
3427 // created by typing an ALT-NUMPAD combination
3428 SalKeyEvent aKeyEvt;
3429
3430 if ( (wParam >= '0') && (wParam <= '9') )
3431 aKeyEvt.mnCode = sal::static_int_cast<sal_uInt16>(KEYGROUP_NUM + wParam - '0');
3432 else if ( (wParam >= 'A') && (wParam <= 'Z') )
3433 aKeyEvt.mnCode = sal::static_int_cast<sal_uInt16>(KEYGROUP_ALPHA + wParam - 'A');
3434 else if ( (wParam >= 'a') && (wParam <= 'z') )
3435 aKeyEvt.mnCode = sal::static_int_cast<sal_uInt16>(KEYGROUP_ALPHA + wParam - 'a');
3436 else if ( wParam == 0x0D ) // RETURN
3437 aKeyEvt.mnCode = KEY_RETURN;
3438 else if ( wParam == 0x1B ) // ESCAPE
3439 aKeyEvt.mnCode = KEY_ESCAPE;
3440 else if ( wParam == 0x09 ) // TAB
3441 aKeyEvt.mnCode = KEY_TAB;
3442 else if ( wParam == 0x20 ) // SPACE
3443 aKeyEvt.mnCode = KEY_SPACE;
3444 else
3445 aKeyEvt.mnCode = 0;
3446
3447 aKeyEvt.mnCode |= nModCode;
3448 aKeyEvt.mnCharCode = ImplGetCharCode( pFrame, wParam );
3449 aKeyEvt.mnRepeat = nRepeat;
3450 nLastChar = 0;
3451 nLastVKChar = 0;
3452 bool nRet = pFrame->CallCallback( SalEvent::KeyInput, &aKeyEvt );
3453 pFrame->CallCallback( SalEvent::KeyUp, &aKeyEvt );
3454 return nRet;
3455 }
3456 // #i11583#, MCD, 2003-01-13, Support for WM_UNICHAR & Keyman 6.0; addition begins
3457 else if( nMsg == WM_UNICHAR )
3458 {
3459 // If Windows is asking if we accept WM_UNICHAR, return TRUE
3460 if(wParam == UNICODE_NOCHAR)
3461 {
3462 rResult = TRUE; // ssa: this will actually return TRUE to windows
3463 return true; // ...but this will only avoid calling the defwindowproc
3464 }
3465
3466 SalKeyEvent aKeyEvt;
3467 aKeyEvt.mnCode = nModCode; // Or should it be 0? - as this is always a character returned
3468 aKeyEvt.mnRepeat = 0;
3469
3470 if( wParam >= Uni_SupplementaryPlanesStart )
3471 {
3472 // character is supplementary char in UTF-32 format - must be converted to UTF-16 supplementary pair
3473 // sal_Unicode ch = (sal_Unicode) Uni_UTF32ToSurrogate1(wParam);
3474 nLastChar = 0;
3475 nLastVKChar = 0;
3476 pFrame->CallCallback( SalEvent::KeyInput, &aKeyEvt );
3477 pFrame->CallCallback( SalEvent::KeyUp, &aKeyEvt );
3478 wParam = static_cast<sal_Unicode>(Uni_UTF32ToSurrogate2( wParam ));
3479 }
3480
3481 aKeyEvt.mnCharCode = static_cast<sal_Unicode>(wParam);
3482
3483 nLastChar = 0;
3484 nLastVKChar = 0;
3485 bool nRet = pFrame->CallCallback( SalEvent::KeyInput, &aKeyEvt );
3486 pFrame->CallCallback( SalEvent::KeyUp, &aKeyEvt );
3487
3488 return nRet;
3489 }
3490 // MCD, 2003-01-13, Support for WM_UNICHAR & Keyman 6.0; addition ends
3491 else
3492 {
3493 // for shift, control and menu we issue a KeyModChange event
3494 if ( (wParam == VK_SHIFT) || (wParam == VK_CONTROL) || (wParam == VK_MENU) )
3495 {
3496 SalKeyModEvent aModEvt;
3497 aModEvt.mbDown = false; // auto-accelerator feature not supported here.
3498 aModEvt.mnCode = nModCode;
3499 aModEvt.mnModKeyCode = ModKeyFlags::NONE; // no command events will be sent if this member is 0
3500
3501 ModKeyFlags tmpCode = ModKeyFlags::NONE;
3502 if( GetKeyState( VK_LSHIFT ) & 0x8000 )
3503 tmpCode |= ModKeyFlags::LeftShift;
3504 if( GetKeyState( VK_RSHIFT ) & 0x8000 )
3505 tmpCode |= ModKeyFlags::RightShift;
3506 if( GetKeyState( VK_LCONTROL ) & 0x8000 )
3507 tmpCode |= ModKeyFlags::LeftMod1;
3508 if( GetKeyState( VK_RCONTROL ) & 0x8000 )
3509 tmpCode |= ModKeyFlags::RightMod1;
3510 if( GetKeyState( VK_LMENU ) & 0x8000 )
3511 tmpCode |= ModKeyFlags::LeftMod2;
3512 if( GetKeyState( VK_RMENU ) & 0x8000 )
3513 tmpCode |= ModKeyFlags::RightMod2;
3514
3515 if( tmpCode < nLastModKeyCode )
3516 {
3517 aModEvt.mnModKeyCode = nLastModKeyCode;
3518 nLastModKeyCode = ModKeyFlags::NONE;
3519 bWaitForModKeyRelease = true;
3520 }
3521 else
3522 {
3523 if( !bWaitForModKeyRelease )
3524 nLastModKeyCode = tmpCode;
3525 }
3526
3527 if( tmpCode == ModKeyFlags::NONE )
3528 bWaitForModKeyRelease = false;
3529
3530 return pFrame->CallCallback( SalEvent::KeyModChange, &aModEvt );
3531 }
3532 else
3533 {
3534 SalKeyEvent aKeyEvt;
3535 SalEvent nEvent;
3536 MSG aCharMsg;
3537 bool bCharPeek = false;
3538 UINT nCharMsg = WM_CHAR;
3539 bool bKeyUp = (nMsg == WM_KEYUP) || (nMsg == WM_SYSKEYUP);
3540
3541 nLastModKeyCode = ModKeyFlags::NONE; // make sure no modkey messages are sent if they belong to a hotkey (see above)
3542 aKeyEvt.mnCharCode = 0;
3543 aKeyEvt.mnCode = ImplSalGetKeyCode( wParam );
3544 if ( !bKeyUp )
3545 {
3546 // check for charcode
3547 // Get the related WM_CHAR message using PeekMessage, if available.
3548 // The WM_CHAR message is always at the beginning of the
3549 // message queue. Also it is made certain that there is always only
3550 // one WM_CHAR message in the queue.
3551 bCharPeek = PeekMessageW( &aCharMsg, hWnd,
3552 WM_CHAR, WM_CHAR, PM_NOREMOVE | PM_NOYIELD );
3553 if ( bCharPeek && (nDeadChar == aCharMsg.wParam) )
3554 {
3555 bCharPeek = false;
3556 nDeadChar = 0;
3557
3558 if ( wParam == VK_BACK )
3559 {
3560 PeekMessageW( &aCharMsg, hWnd,
3561 nCharMsg, nCharMsg, PM_REMOVE | PM_NOYIELD );
3562 return false;
3563 }
3564 }
3565 else
3566 {
3567 if ( !bCharPeek )
3568 {
3569 bCharPeek = PeekMessageW( &aCharMsg, hWnd,
3570 WM_SYSCHAR, WM_SYSCHAR, PM_NOREMOVE | PM_NOYIELD );
3571 nCharMsg = WM_SYSCHAR;
3572 }
3573 }
3574 if ( bCharPeek )
3575 aKeyEvt.mnCharCode = ImplGetCharCode( pFrame, aCharMsg.wParam );
3576 else
3577 aKeyEvt.mnCharCode = 0;
3578
3579 nLastChar = aKeyEvt.mnCharCode;
3580 nLastVKChar = wParam;
3581 }
3582 else
3583 {
3584 if ( wParam == nLastVKChar )
3585 {
3586 aKeyEvt.mnCharCode = nLastChar;
3587 nLastChar = 0;
3588 nLastVKChar = 0;
3589 }
3590 }
3591
3592 if ( aKeyEvt.mnCode || aKeyEvt.mnCharCode )
3593 {
3594 if ( bKeyUp )
3595 nEvent = SalEvent::KeyUp;
3596 else
3597 nEvent = SalEvent::KeyInput;
3598
3599 aKeyEvt.mnCode |= nModCode;
3600 aKeyEvt.mnRepeat = nRepeat;
3601
3602 if ((nModCode & (KEY_MOD1 | KEY_MOD2)) == (KEY_MOD1 | KEY_MOD2) &&
3603 aKeyEvt.mnCharCode)
3604 {
3605 // this is actually AltGr and should not be handled as Alt
3606 aKeyEvt.mnCode &= ~(KEY_MOD1 | KEY_MOD2);
3607 }
3608
3609 bIgnoreCharMsg = bCharPeek;
3610 bool nRet = pFrame->CallCallback( nEvent, &aKeyEvt );
3611 // independent part only reacts on keyup but Windows does not send
3612 // keyup for VK_HANJA
3613 if( aKeyEvt.mnCode == KEY_HANGUL_HANJA )
3614 nRet = pFrame->CallCallback( SalEvent::KeyUp, &aKeyEvt );
3615
3616 bIgnoreCharMsg = false;
3617
3618 // char-message, then remove or ignore
3619 if ( bCharPeek )
3620 {
3621 nDeadChar = 0;
3622 if ( nRet )
3623 {
3624 PeekMessageW( &aCharMsg, hWnd,
3625 nCharMsg, nCharMsg, PM_REMOVE | PM_NOYIELD );
3626 }
3627 else
3628 bIgnoreCharMsg = true;
3629 }
3630
3631 return nRet;
3632 }
3633 else
3634 return false;
3635 }
3636 }
3637 }
3638
3639 bool ImplHandleSalObjKeyMsg( HWND hWnd, UINT nMsg,
3640 WPARAM wParam, LPARAM lParam )
3641 {
3642 if ( (nMsg == WM_KEYDOWN) || (nMsg == WM_KEYUP) )
3643 {
3644 WinSalFrame* pFrame = GetWindowPtr( hWnd );
3645 if ( !pFrame )
3646 return false;
3647
3648 sal_uInt16 nRepeat = LOWORD( lParam )-1;
3649 sal_uInt16 nModCode = 0;
3650
3651 // determine modifiers
3652 if ( GetKeyState( VK_SHIFT ) & 0x8000 )
3653 nModCode |= KEY_SHIFT;
3654 if ( GetKeyState( VK_CONTROL ) & 0x8000 )
3655 nModCode |= KEY_MOD1;
3656 if ( GetKeyState( VK_MENU ) & 0x8000 )
3657 nModCode |= KEY_MOD2;
3658
3659 if ( (wParam != VK_SHIFT) && (wParam != VK_CONTROL) && (wParam != VK_MENU) )
3660 {
3661 SalKeyEvent aKeyEvt;
3662 SalEvent nEvent;
3663
3664 // convert KeyCode
3665 aKeyEvt.mnCode = ImplSalGetKeyCode( wParam );
3666 aKeyEvt.mnCharCode = 0;
3667
3668 if ( aKeyEvt.mnCode )
3669 {
3670 if (nMsg == WM_KEYUP)
3671 nEvent = SalEvent::KeyUp;
3672 else
3673 nEvent = SalEvent::KeyInput;
3674
3675 aKeyEvt.mnCode |= nModCode;
3676 aKeyEvt.mnRepeat = nRepeat;
3677 bool nRet = pFrame->CallCallback( nEvent, &aKeyEvt );
3678 return nRet;
3679 }
3680 else
3681 return false;
3682 }
3683 }
3684
3685 return false;
3686 }
3687
3688 bool ImplHandleSalObjSysCharMsg( HWND hWnd, WPARAM wParam, LPARAM lParam )
3689 {
3690 WinSalFrame* pFrame = GetWindowPtr( hWnd );
3691 if ( !pFrame )
3692 return false;
3693
3694 sal_uInt16 nRepeat = LOWORD( lParam )-1;
3695 sal_uInt16 nModCode = 0;
3696 sal_uInt16 cKeyCode = static_cast<sal_uInt16>(wParam);
3697
3698 // determine modifiers
3699 if ( GetKeyState( VK_SHIFT ) & 0x8000 )
3700 nModCode |= KEY_SHIFT;
3701 if ( GetKeyState( VK_CONTROL ) & 0x8000 )
3702 nModCode |= KEY_MOD1;
3703 nModCode |= KEY_MOD2;
3704
3705 // assemble KeyEvent
3706 SalKeyEvent aKeyEvt;
3707 if ( (cKeyCode >= 48) && (cKeyCode <= 57) )
3708 aKeyEvt.mnCode = KEY_0+(cKeyCode-48);
3709 else if ( (cKeyCode >= 65) && (cKeyCode <= 90) )
3710 aKeyEvt.mnCode = KEY_A+(cKeyCode-65);
3711 else if ( (cKeyCode >= 97) && (cKeyCode <= 122) )
3712 aKeyEvt.mnCode = KEY_A+(cKeyCode-97);
3713 else
3714 aKeyEvt.mnCode = 0;
3715 aKeyEvt.mnCode |= nModCode;
3716 aKeyEvt.mnCharCode = ImplGetCharCode( pFrame, cKeyCode );
3717 aKeyEvt.mnRepeat = nRepeat;
3718 bool nRet = pFrame->CallCallback( SalEvent::KeyInput, &aKeyEvt );
3719 pFrame->CallCallback( SalEvent::KeyUp, &aKeyEvt );
3720 return nRet;
3721 }
3722
3723 namespace {
3724
3725 enum class DeferPolicy
3726 {
3727 Blocked,
3728 Allowed
3729 };
3730
3731 }
3732
3733 // Remember to release the solar mutex on success!
3734 static WinSalFrame* ProcessOrDeferMessage( HWND hWnd, INT nMsg, WPARAM pWParam = 0,
3735 DeferPolicy eCanDefer = DeferPolicy::Allowed )
3736 {
3737 bool bFailedCondition = false, bGotMutex = false;
3738 WinSalFrame* pFrame = nullptr;
3739
3740 if ( DeferPolicy::Blocked == eCanDefer )
3741 assert( (DeferPolicy::Blocked == eCanDefer) && (nMsg == 0) && (pWParam == 0) );
3742 else
3743 assert( (DeferPolicy::Allowed == eCanDefer) && (nMsg != 0) );
3744
3745 if ( DeferPolicy::Blocked == eCanDefer )
3746 {
3747 ImplSalYieldMutexAcquireWithWait();
3748 bGotMutex = true;
3749 }
3750 else if ( !(bGotMutex = ImplSalYieldMutexTryToAcquire()) )
3751 bFailedCondition = true;
3752
3753 if ( !bFailedCondition )
3754 {
3755 pFrame = GetWindowPtr( hWnd );
3756 bFailedCondition = pFrame == nullptr;
3757 }
3758
3759 if ( bFailedCondition )
3760 {
3761 if ( bGotMutex )
3762 ImplSalYieldMutexRelease();
3763 if ( DeferPolicy::Allowed == eCanDefer )
3764 {
3765 bool const ret = PostMessageW(hWnd, nMsg, pWParam, 0);
3766 SAL_WARN_IF(!ret, "vcl", "ERROR: PostMessage() failed!");
3767 }
3768 }
3769
3770 return pFrame;
3771 }
3772
3773 namespace {
3774
3775 enum class PostedState
3776 {
3777 IsPosted,
3778 IsInitial
3779 };
3780
3781 }
3782
3783 static bool ImplHandlePostPaintMsg( HWND hWnd, RECT* pRect,
3784 PostedState eProcessed = PostedState::IsPosted )
3785 {
3786 RECT* pMsgRect;
3787 if ( PostedState::IsInitial == eProcessed )
3788 {
3789 pMsgRect = new RECT;
3790 CopyRect( pMsgRect, pRect );
3791 }
3792 else
3793 pMsgRect = pRect;
3794
3795 WinSalFrame* pFrame = ProcessOrDeferMessage( hWnd, SAL_MSG_POSTPAINT,
3796 reinterpret_cast<WPARAM>(pMsgRect) );
3797 if ( pFrame )
3798 {
3799 SalPaintEvent aPEvt( pRect->left, pRect->top, pRect->right-pRect->left, pRect->bottom-pRect->top );
3800 pFrame->CallCallback( SalEvent::Paint, &aPEvt );
3801 ImplSalYieldMutexRelease();
3802 if ( PostedState::IsPosted == eProcessed )
3803 delete pRect;
3804 }
3805
3806 return (pFrame != nullptr);
3807 }
3808
3809 static bool ImplHandlePaintMsg( HWND hWnd )
3810 {
3811 bool bPaintSuccessful = false;
3812
3813 // even without the Yield mutex, we can still change the clip region,
3814 // because other threads don't use the Yield mutex
3815 // --> see AcquireGraphics()
3816
3817 WinSalFrame* pFrame = GetWindowPtr( hWnd );
3818 if ( pFrame )
3819 {
3820 // clip region must be set, as we don't get a proper
3821 // bounding rectangle otherwise
3822 WinSalGraphics *pGraphics = pFrame->mpLocalGraphics;
3823 bool bHasClipRegion = pGraphics &&
3824 pGraphics->getHDC() && pGraphics->getRegion();
3825 if ( bHasClipRegion )
3826 SelectClipRgn( pGraphics->getHDC(), nullptr );
3827
3828 // according to Windows documentation one shall check first if
3829 // there really is a paint-region
3830 RECT aUpdateRect;
3831 PAINTSTRUCT aPs;
3832 bool bHasPaintRegion = GetUpdateRect( hWnd, nullptr, FALSE );
3833 if ( bHasPaintRegion )
3834 {
3835 // call BeginPaint/EndPaint to query the paint rect and use
3836 // this information in the (deferred) paint
3837 BeginPaint( hWnd, &aPs );
3838 CopyRect( &aUpdateRect, &aPs.rcPaint );
3839 }
3840
3841 // reset clip region
3842 if ( bHasClipRegion )
3843 SelectClipRgn( pGraphics->getHDC(), pGraphics->getRegion() );
3844
3845 // try painting
3846 if ( bHasPaintRegion )
3847 {
3848 bPaintSuccessful = ImplHandlePostPaintMsg(
3849 hWnd, &aUpdateRect, PostedState::IsInitial );
3850 EndPaint( hWnd, &aPs );
3851 }
3852 else // if there is nothing to paint, the paint is successful
3853 bPaintSuccessful = true;
3854 }
3855
3856 return bPaintSuccessful;
3857 }
3858
3859 static void SetMaximizedFrameGeometry( HWND hWnd, WinSalFrame* pFrame, RECT* pParentRect )
3860 {
3861 // calculate and set frame geometry of a maximized window - useful if the window is still hidden
3862
3863 // dualmonitor support:
3864 // Get screensize of the monitor with the mouse pointer
3865
3866 RECT aRectMouse;
3867 if( ! pParentRect )
3868 {
3869 POINT pt;
3870 GetCursorPos( &pt );
3871 aRectMouse.left = pt.x;
3872 aRectMouse.top = pt.y;
3873 aRectMouse.right = pt.x+2;
3874 aRectMouse.bottom = pt.y+2;
3875 pParentRect = &aRectMouse;
3876 }
3877
3878 RECT aRect;
3879 ImplSalGetWorkArea( hWnd, &aRect, pParentRect );
3880
3881 // a maximized window has no other borders than the caption
3882 pFrame->maGeometry.nLeftDecoration = pFrame->maGeometry.nRightDecoration = pFrame->maGeometry.nBottomDecoration = 0;
3883 pFrame->maGeometry.nTopDecoration = pFrame->mbCaption ? GetSystemMetrics( SM_CYCAPTION ) : 0;
3884
3885 aRect.top += pFrame->maGeometry.nTopDecoration;
3886 pFrame->maGeometry.nX = aRect.left;
3887 pFrame->maGeometry.nY = aRect.top;
3888 pFrame->maGeometry.nWidth = aRect.right - aRect.left;
3889 pFrame->maGeometry.nHeight = aRect.bottom - aRect.top;
3890 }
3891
3892 static void UpdateFrameGeometry( HWND hWnd, WinSalFrame* pFrame )
3893 {
3894 if( !pFrame )
3895 return;
3896
3897 RECT aRect;
3898 GetWindowRect( hWnd, &aRect );
3899 pFrame->maGeometry.nX = 0;
3900 pFrame->maGeometry.nY = 0;
3901 pFrame->maGeometry.nWidth = 0;
3902 pFrame->maGeometry.nHeight = 0;
3903 pFrame->maGeometry.nLeftDecoration = 0;
3904 pFrame->maGeometry.nTopDecoration = 0;
3905 pFrame->maGeometry.nRightDecoration = 0;
3906 pFrame->maGeometry.nBottomDecoration = 0;
3907 pFrame->maGeometry.nDisplayScreenNumber = 0;
3908
3909 if ( IsIconic( hWnd ) )
3910 return;
3911
3912 POINT aPt;
3913 aPt.x=0;
3914 aPt.y=0;
3915 ClientToScreen(hWnd, &aPt);
3916 int cx = aPt.x - aRect.left;
3917 pFrame->maGeometry.nTopDecoration = aPt.y - aRect.top;
3918
3919 pFrame->maGeometry.nLeftDecoration = cx;
3920 pFrame->maGeometry.nRightDecoration = cx;
3921
3922 pFrame->maGeometry.nX = aPt.x;
3923 pFrame->maGeometry.nY = aPt.y;
3924
3925 RECT aInnerRect;
3926 GetClientRect( hWnd, &aInnerRect );
3927 if( aInnerRect.right )
3928 {
3929 // improve right decoration
3930 aPt.x=aInnerRect.right;
3931 aPt.y=aInnerRect.top;
3932 ClientToScreen(hWnd, &aPt);
3933 pFrame->maGeometry.nRightDecoration = aRect.right - aPt.x;
3934 }
3935 if( aInnerRect.bottom ) // may be zero if window was not shown yet
3936 pFrame->maGeometry.nBottomDecoration += aRect.bottom - aPt.y - aInnerRect.bottom;
3937 else
3938 // bottom border is typically the same as left/right
3939 pFrame->maGeometry.nBottomDecoration = pFrame->maGeometry.nLeftDecoration;
3940
3941 int nWidth = aRect.right - aRect.left
3942 - pFrame->maGeometry.nRightDecoration - pFrame->maGeometry.nLeftDecoration;
3943 int nHeight = aRect.bottom - aRect.top
3944 - pFrame->maGeometry.nBottomDecoration - pFrame->maGeometry.nTopDecoration;
3945 // clamp to zero
3946 pFrame->maGeometry.nHeight = nHeight < 0 ? 0 : nHeight;
3947 pFrame->maGeometry.nWidth = nWidth < 0 ? 0 : nWidth;
3948 pFrame->updateScreenNumber();
3949 }
3950
3951 static void ImplCallMoveHdl( HWND hWnd )
3952 {
3953 WinSalFrame* pFrame = GetWindowPtr( hWnd );
3954 if ( pFrame )
3955 {
3956 pFrame->CallCallback( SalEvent::Move, nullptr );
3957 // to avoid doing Paint twice by VCL and SAL
3958 //if ( IsWindowVisible( hWnd ) && !pFrame->mbInShow )
3959 // UpdateWindow( hWnd );
3960 }
3961 }
3962
3963 static void ImplCallClosePopupsHdl( HWND hWnd )
3964 {
3965 WinSalFrame* pFrame = GetWindowPtr( hWnd );
3966 if ( pFrame )
3967 {
3968 pFrame->CallCallback( SalEvent::ClosePopups, nullptr );
3969 }
3970 }
3971
3972 static void ImplHandleMoveMsg( HWND hWnd )
3973 {
3974 WinSalFrame* pFrame = ProcessOrDeferMessage( hWnd, SAL_MSG_POSTMOVE );
3975 if ( pFrame )
3976 {
3977 UpdateFrameGeometry( hWnd, pFrame );
3978
3979 if ( GetWindowStyle( hWnd ) & WS_VISIBLE )
3980 pFrame->mbDefPos = false;
3981
3982 // protect against recursion
3983 if ( !pFrame->mbInMoveMsg )
3984 {
3985 // adjust window again for FullScreenMode
3986 pFrame->mbInMoveMsg = true;
3987 if ( pFrame->mbFullScreen )
3988 ImplSalFrameFullScreenPos( pFrame );
3989 pFrame->mbInMoveMsg = false;
3990 }
3991
3992 // save state
3993 ImplSaveFrameState( pFrame );
3994
3995 // Call Hdl
3996 //#93851 if we call this handler, VCL floating windows are not updated correctly
3997 ImplCallMoveHdl( hWnd );
3998
3999 ImplSalYieldMutexRelease();
4000 }
4001 }
4002
4003 static void ImplCallSizeHdl( HWND hWnd )
4004 {
4005 // as Windows can send these messages also, we have to use
4006 // the Solar semaphore
4007 WinSalFrame* pFrame = ProcessOrDeferMessage( hWnd, SAL_MSG_POSTCALLSIZE );
4008 if ( pFrame )
4009 {
4010 pFrame->CallCallback( SalEvent::Resize, nullptr );
4011 // to avoid double Paints by VCL and SAL
4012 if ( IsWindowVisible( hWnd ) && !pFrame->mbInShow )
4013 UpdateWindow( hWnd );
4014
4015 ImplSalYieldMutexRelease();
4016 }
4017 }
4018
4019 static void ImplHandleSizeMsg( HWND hWnd, WPARAM wParam, LPARAM lParam )
4020 {
4021 if ( (wParam != SIZE_MAXSHOW) && (wParam != SIZE_MAXHIDE) )
4022 {
4023 WinSalFrame* pFrame = GetWindowPtr( hWnd );
4024 if ( pFrame )
4025 {
4026 UpdateFrameGeometry( hWnd, pFrame );
4027
4028 pFrame->mnWidth = static_cast<int>(LOWORD(lParam));
4029 pFrame->mnHeight = static_cast<int>(HIWORD(lParam));
4030 // save state
4031 ImplSaveFrameState( pFrame );
4032 // Call Hdl
4033 ImplCallSizeHdl( hWnd );
4034
4035 WinSalTimer* pTimer = static_cast<WinSalTimer*>( ImplGetSVData()->maSchedCtx.mpSalTimer );
4036 if ( pTimer )
4037 pTimer->SetForceRealTimer( true );
4038 }
4039 }
4040 }
4041
4042 static void ImplHandleFocusMsg( HWND hWnd )
4043 {
4044 WinSalFrame* pFrame = ProcessOrDeferMessage( hWnd, SAL_MSG_POSTFOCUS );
4045 if ( pFrame )
4046 {
4047 if ( !WinSalFrame::mbInReparent )
4048 {
4049 bool bGotFocus = ::GetFocus() == hWnd;
4050 if ( bGotFocus )
4051 {
4052 if ( IsWindowVisible( hWnd ) && !pFrame->mbInShow )
4053 UpdateWindow( hWnd );
4054
4055 // do we support IME?
4056 if ( pFrame->mbIME && pFrame->mhDefIMEContext )
4057 {
4058 UINT nImeProps = ImmGetProperty( GetKeyboardLayout( 0 ), IGP_PROPERTY );
4059
4060 pFrame->mbSpezIME = (nImeProps & IME_PROP_SPECIAL_UI) != 0;
4061 pFrame->mbAtCursorIME = (nImeProps & IME_PROP_AT_CARET) != 0;
4062 pFrame->mbHandleIME = !pFrame->mbSpezIME;
4063 }
4064 }
4065 pFrame->CallCallback( bGotFocus ? SalEvent::GetFocus : SalEvent::LoseFocus, nullptr );
4066 }
4067 ImplSalYieldMutexRelease();
4068 }
4069 }
4070
4071 static void ImplHandleCloseMsg( HWND hWnd )
4072 {
4073 WinSalFrame* pFrame = ProcessOrDeferMessage( hWnd, WM_CLOSE );
4074 if ( pFrame )
4075 {
4076 pFrame->CallCallback( SalEvent::Close, nullptr );
4077 ImplSalYieldMutexRelease();
4078 }
4079 }
4080
4081 static bool ImplHandleShutDownMsg( HWND hWnd )
4082 {
4083 bool nRet = false;
4084 WinSalFrame* pFrame = ProcessOrDeferMessage( hWnd, 0, 0, DeferPolicy::Blocked );
4085 if ( pFrame )
4086 {
4087 nRet = pFrame->CallCallback( SalEvent::Shutdown, nullptr );
4088 ImplSalYieldMutexRelease();
4089 }
4090 return nRet;
4091 }
4092
4093 static void ImplHandleSettingsChangeMsg( HWND hWnd, UINT nMsg,
4094 WPARAM wParam, LPARAM lParam )
4095 {
4096 SalEvent nSalEvent = SalEvent::SettingsChanged;
4097
4098 if ( nMsg == WM_DEVMODECHANGE )
4099 nSalEvent = SalEvent::PrinterChanged;
4100 else if ( nMsg == WM_DISPLAYCHANGE )
4101 nSalEvent = SalEvent::DisplayChanged;
4102 else if ( nMsg == WM_FONTCHANGE )
4103 nSalEvent = SalEvent::FontChanged;
4104 else if ( nMsg == WM_WININICHANGE )
4105 {
4106 if ( lParam )
4107 {
4108 if ( ImplSalWICompareAscii( reinterpret_cast<const wchar_t*>(lParam), "devices" ) == 0 )
4109 nSalEvent = SalEvent::PrinterChanged;
4110 }
4111 }
4112
4113 if ( nMsg == WM_SETTINGCHANGE )
4114 {
4115 if ( wParam == SPI_SETWHEELSCROLLLINES )
4116 aSalShlData.mnWheelScrollLines = ImplSalGetWheelScrollLines();
4117 else if( wParam == SPI_SETWHEELSCROLLCHARS )
4118 aSalShlData.mnWheelScrollChars = ImplSalGetWheelScrollChars();
4119 }
4120
4121 if ( WM_SYSCOLORCHANGE == nMsg && GetSalData()->mhDitherPal )
4122 ImplUpdateSysColorEntries();
4123
4124 WinSalFrame* pFrame = ProcessOrDeferMessage( hWnd, 0, 0, DeferPolicy::Blocked );
4125 if ( pFrame )
4126 {
4127 if ( (nMsg == WM_DISPLAYCHANGE) || (nMsg == WM_WININICHANGE) )
4128 {
4129 if ( pFrame->mbFullScreen )
4130 ImplSalFrameFullScreenPos( pFrame );
4131 }
4132
4133 pFrame->CallCallback( nSalEvent, nullptr );
4134 ImplSalYieldMutexRelease();
4135 }
4136 }
4137
4138 static void ImplHandleUserEvent( HWND hWnd, LPARAM lParam )
4139 {
4140 WinSalFrame* pFrame = ProcessOrDeferMessage( hWnd, 0, 0, DeferPolicy::Blocked );
4141 if ( pFrame )
4142 {
4143 pFrame->CallCallback( SalEvent::UserEvent, reinterpret_cast<void*>(lParam) );
4144 ImplSalYieldMutexRelease();
4145 }
4146 }
4147
4148 static void ImplHandleForcePalette( HWND hWnd )
4149 {
4150 SalData* pSalData = GetSalData();
4151 HPALETTE hPal = pSalData->mhDitherPal;
4152 if ( hPal )
4153 {
4154 WinSalFrame* pFrame = ProcessOrDeferMessage( hWnd, SAL_MSG_FORCEPALETTE );
4155 if ( pFrame && pFrame->mpLocalGraphics && pFrame->mpLocalGraphics->getHDC() )
4156 {
4157 WinSalGraphics* pGraphics = pFrame->mpLocalGraphics;
4158 if (pGraphics->getDefPal())
4159 {
4160 SelectPalette( pGraphics->getHDC(), hPal, FALSE );
4161 if ( RealizePalette( pGraphics->getHDC() ) )
4162 {
4163 InvalidateRect( hWnd, nullptr, FALSE );
4164 UpdateWindow( hWnd );
4165 pFrame->CallCallback( SalEvent::DisplayChanged, nullptr );
4166 }
4167 }
4168 }
4169 if ( pFrame )
4170 ImplSalYieldMutexRelease();
4171 }
4172 }
4173
4174 static LRESULT ImplHandlePalette( bool bFrame, HWND hWnd, UINT nMsg,
4175 WPARAM wParam, LPARAM lParam, bool& rDef )
4176 {
4177 SalData* pSalData = GetSalData();
4178 HPALETTE hPal = pSalData->mhDitherPal;
4179 if ( !hPal )
4180 return 0;
4181
4182 rDef = false;
4183 if ( pSalData->mbInPalChange )
4184 return 0;
4185
4186 if ( (nMsg == WM_PALETTECHANGED) || (nMsg == SAL_MSG_POSTPALCHANGED) )
4187 {
4188 if ( reinterpret_cast<HWND>(wParam) == hWnd )
4189 return 0;
4190 }
4191
4192 bool bReleaseMutex = false;
4193 if ( (nMsg == WM_QUERYNEWPALETTE) || (nMsg == WM_PALETTECHANGED) )
4194 {
4195 // as Windows can send these messages also, we have to use
4196 // the Solar semaphore
4197 if ( ImplSalYieldMutexTryToAcquire() )
4198 bReleaseMutex = true;
4199 else if ( nMsg == WM_QUERYNEWPALETTE )
4200 {
4201 bool const ret = PostMessageW(hWnd, SAL_MSG_POSTQUERYNEWPAL, wParam, lParam);
4202 SAL_WARN_IF(!ret, "vcl", "ERROR: PostMessage() failed!");
4203 }
4204 else /* ( nMsg == WM_PALETTECHANGED ) */
4205 {
4206 bool const ret = PostMessageW(hWnd, SAL_MSG_POSTPALCHANGED, wParam, lParam);
4207 SAL_WARN_IF(!ret, "vcl", "ERROR: PostMessage() failed!");
4208 }
4209 }
4210
4211 WinSalVirtualDevice*pTempVD;
4212 WinSalFrame* pTempFrame;
4213 WinSalGraphics* pGraphics;
4214 HDC hDC;
4215 HPALETTE hOldPal;
4216 UINT nCols;
4217 bool bStdDC;
4218 bool bUpdate;
4219
4220 pSalData->mbInPalChange = true;
4221
4222 // reset all palettes in VirDevs and Frames
4223 pTempVD = pSalData->mpFirstVD;
4224 while ( pTempVD )
4225 {
4226 pGraphics = pTempVD->getGraphics();
4227 if ( pGraphics->getDefPal() )
4228 {
4229 SelectPalette( pGraphics->getHDC(),
4230 pGraphics->getDefPal(),
4231 TRUE );
4232 }
4233 pTempVD = pTempVD->getNext();
4234 }
4235 pTempFrame = pSalData->mpFirstFrame;
4236 while ( pTempFrame )
4237 {
4238 pGraphics = pTempFrame->mpLocalGraphics;
4239 if ( pGraphics && pGraphics->getHDC() && pGraphics->getDefPal() )
4240 {
4241 SelectPalette( pGraphics->getHDC(),
4242 pGraphics->getDefPal(),
4243 TRUE );
4244 }
4245 pTempFrame = pTempFrame->mpNextFrame;
4246 }
4247
4248 // re-initialize palette
4249 WinSalFrame* pFrame = nullptr;
4250 if ( bFrame )
4251 pFrame = GetWindowPtr( hWnd );
4252 if ( pFrame && pFrame->mpLocalGraphics && pFrame->mpLocalGraphics->getHDC() )
4253 {
4254 hDC = pFrame->mpLocalGraphics->getHDC();
4255 bStdDC = true;
4256 }
4257 else
4258 {
4259 hDC = GetDC( hWnd );
4260 bStdDC = false;
4261 }
4262 UnrealizeObject( hPal );
4263 hOldPal = SelectPalette( hDC, hPal, TRUE );
4264 nCols = RealizePalette( hDC );
4265 bUpdate = nCols != 0;
4266 if ( !bStdDC )
4267 {
4268 SelectPalette( hDC, hOldPal, TRUE );
4269 ReleaseDC( hWnd, hDC );
4270 }
4271
4272 // reset all palettes in VirDevs and Frames
4273 pTempVD = pSalData->mpFirstVD;
4274 while ( pTempVD )
4275 {
4276 pGraphics = pTempVD->getGraphics();
4277 if ( pGraphics->getDefPal() )
4278 {
4279 SelectPalette( pGraphics->getHDC(), hPal, TRUE );
4280 RealizePalette( pGraphics->getHDC() );
4281 }
4282 pTempVD = pTempVD->getNext();
4283 }
4284 pTempFrame = pSalData->mpFirstFrame;
4285 while ( pTempFrame )
4286 {
4287 if ( pTempFrame != pFrame )
4288 {
4289 pGraphics = pTempFrame->mpLocalGraphics;
4290 if ( pGraphics && pGraphics->getHDC() && pGraphics->getDefPal() )
4291 {
4292 SelectPalette( pGraphics->getHDC(), hPal, TRUE );
4293 if ( RealizePalette( pGraphics->getHDC() ) )
4294 bUpdate = true;
4295 }
4296 }
4297 pTempFrame = pTempFrame->mpNextFrame;
4298 }
4299
4300 // if colors changed, update the window
4301 if ( bUpdate )
4302 {
4303 pTempFrame = pSalData->mpFirstFrame;
4304 while ( pTempFrame )
4305 {
4306 pGraphics = pTempFrame->mpLocalGraphics;
4307 if ( pGraphics && pGraphics->getHDC() && pGraphics->getDefPal() )
4308 {
4309 InvalidateRect( pTempFrame->mhWnd, nullptr, FALSE );
4310 UpdateWindow( pTempFrame->mhWnd );
4311 pTempFrame->CallCallback( SalEvent::DisplayChanged, nullptr );
4312 }
4313 pTempFrame = pTempFrame->mpNextFrame;
4314 }
4315 }
4316
4317 pSalData->mbInPalChange = false;
4318
4319 if ( bReleaseMutex )
4320 ImplSalYieldMutexRelease();
4321
4322 if ( nMsg == WM_PALETTECHANGED )
4323 return 0;
4324 else
4325 return nCols;
4326 }
4327
4328 static bool ImplHandleMinMax( HWND hWnd, LPARAM lParam )
4329 {
4330 bool bRet = false;
4331
4332 if ( ImplSalYieldMutexTryToAcquire() )
4333 {
4334 WinSalFrame* pFrame = GetWindowPtr( hWnd );
4335 if ( pFrame )
4336 {
4337 MINMAXINFO* pMinMax = reinterpret_cast<MINMAXINFO*>(lParam);
4338
4339 if ( pFrame->mbFullScreen )
4340 {
4341 int nX;
4342 int nY;
4343 int nDX;
4344 int nDY;
4345 ImplSalCalcFullScreenSize( pFrame, nX, nY, nDX, nDY );
4346
4347 if ( pMinMax->ptMaxPosition.x > nX )
4348 pMinMax->ptMaxPosition.x = nX;
4349 if ( pMinMax->ptMaxPosition.y > nY )
4350 pMinMax->ptMaxPosition.y = nY;
4351
4352 if ( pMinMax->ptMaxSize.x < nDX )
4353 pMinMax->ptMaxSize.x = nDX;
4354 if ( pMinMax->ptMaxSize.y < nDY )
4355 pMinMax->ptMaxSize.y = nDY;
4356 if ( pMinMax->ptMaxTrackSize.x < nDX )
4357 pMinMax->ptMaxTrackSize.x = nDX;
4358 if ( pMinMax->ptMaxTrackSize.y < nDY )
4359 pMinMax->ptMaxTrackSize.y = nDY;
4360
4361 pMinMax->ptMinTrackSize.x = nDX;
4362 pMinMax->ptMinTrackSize.y = nDY;
4363
4364 bRet = true;
4365 }
4366
4367 if ( pFrame->mnMinWidth || pFrame->mnMinHeight )
4368 {
4369 int nWidth = pFrame->mnMinWidth;
4370 int nHeight = pFrame->mnMinHeight;
4371
4372 ImplSalAddBorder( pFrame, nWidth, nHeight );
4373
4374 if ( pMinMax->ptMinTrackSize.x < nWidth )
4375 pMinMax->ptMinTrackSize.x = nWidth;
4376 if ( pMinMax->ptMinTrackSize.y < nHeight )
4377 pMinMax->ptMinTrackSize.y = nHeight;
4378 }
4379
4380 if ( pFrame->mnMaxWidth || pFrame->mnMaxHeight )
4381 {
4382 int nWidth = pFrame->mnMaxWidth;
4383 int nHeight = pFrame->mnMaxHeight;
4384
4385 ImplSalAddBorder( pFrame, nWidth, nHeight );
4386
4387 if( nWidth > 0 && nHeight > 0 ) // protect against int overflow due to INT_MAX initialisation
4388 {
4389 if ( pMinMax->ptMaxTrackSize.x > nWidth )
4390 pMinMax->ptMaxTrackSize.x = nWidth;
4391 if ( pMinMax->ptMaxTrackSize.y > nHeight )
4392 pMinMax->ptMaxTrackSize.y = nHeight;
4393 }
4394 }
4395 }
4396
4397 ImplSalYieldMutexRelease();
4398 }
4399
4400 return bRet;
4401 }
4402
4403 // retrieves the SalMenuItem pointer from a hMenu
4404 // the pointer is stored in every item, so if no position
4405 // is specified we just use the first item (ie, pos=0)
4406 // if bByPosition is false then nPos denotes a menu id instead of a position
4407 static WinSalMenuItem* ImplGetSalMenuItem( HMENU hMenu, UINT nPos, bool bByPosition=true )
4408 {
4409 MENUITEMINFOW mi = {};
4410 mi.cbSize = sizeof( mi );
4411 mi.fMask = MIIM_DATA;
4412 if( !GetMenuItemInfoW( hMenu, nPos, bByPosition, &mi) )
4413 SAL_WARN("vcl", "GetMenuItemInfoW failed: " << WindowsErrorString(GetLastError()));
4414
4415 return reinterpret_cast<WinSalMenuItem *>(mi.dwItemData);
4416 }
4417
4418 // returns the index of the currently selected item if any or -1
4419 static int ImplGetSelectedIndex( HMENU hMenu )
4420 {
4421 MENUITEMINFOW mi = {};
4422 mi.cbSize = sizeof( mi );
4423 mi.fMask = MIIM_STATE;
4424 int n = GetMenuItemCount( hMenu );
4425 if( n != -1 )
4426 {
4427 for(int i=0; i<n; i++ )
4428 {
4429 if( !GetMenuItemInfoW( hMenu, i, TRUE, &mi) )
4430 SAL_WARN( "vcl", "GetMenuItemInfoW failed: " << WindowsErrorString( GetLastError() ) );
4431 else
4432 {
4433 if( mi.fState & MFS_HILITE )
4434 return i;
4435 }
4436 }
4437 }
4438 return -1;
4439 }
4440
4441 static LRESULT ImplMenuChar( HWND, WPARAM wParam, LPARAM lParam )
4442 {
4443 LRESULT nRet = MNC_IGNORE;
4444 HMENU hMenu = reinterpret_cast<HMENU>(lParam);
4445 OUString aMnemonic( "&" + OUStringChar(static_cast<sal_Unicode>(LOWORD(wParam))) );
4446 aMnemonic = aMnemonic.toAsciiLowerCase(); // we only have ascii mnemonics
4447
4448 // search the mnemonic in the current menu
4449 int nItemCount = GetMenuItemCount( hMenu );
4450 int nFound = 0;
4451 int idxFound = -1;
4452 int idxSelected = ImplGetSelectedIndex( hMenu );
4453 int idx = idxSelected != -1 ? idxSelected+1 : 0; // if duplicate mnemonics cycle through menu
4454 for( int i=0; i< nItemCount; i++, idx++ )
4455 {
4456 WinSalMenuItem* pSalMenuItem = ImplGetSalMenuItem( hMenu, idx % nItemCount );
4457 if( !pSalMenuItem )
4458 continue;
4459 OUString aStr = pSalMenuItem->mText;
4460 aStr = aStr.toAsciiLowerCase();
4461 if( aStr.indexOf( aMnemonic ) != -1 )
4462 {
4463 if( idxFound == -1 )
4464 idxFound = idx % nItemCount;
4465 if( nFound++ )
4466 break; // duplicate found
4467 }
4468 }
4469 if( nFound == 1 )
4470 nRet = MAKELRESULT( idxFound, MNC_EXECUTE );
4471 else
4472 // duplicate mnemonics, just select the next occurrence
4473 nRet = MAKELRESULT( idxFound, MNC_SELECT );
4474
4475 return nRet;
4476 }
4477
4478 static LRESULT ImplMeasureItem( HWND hWnd, WPARAM wParam, LPARAM lParam )
4479 {
4480 LRESULT nRet = 0;
4481 if( !wParam )
4482 {
4483 // request was sent by a menu
4484 nRet = 1;
4485 MEASUREITEMSTRUCT *pMI = reinterpret_cast<LPMEASUREITEMSTRUCT>(lParam);
4486 if( pMI->CtlType != ODT_MENU )
4487 return 0;
4488
4489 WinSalMenuItem *pSalMenuItem = reinterpret_cast<WinSalMenuItem *>(pMI->itemData);
4490 if( !pSalMenuItem )
4491 return 0;
4492
4493 HDC hdc = GetDC( hWnd );
4494 SIZE strSize;
4495
4496 NONCLIENTMETRICSW ncm = {};
4497 ncm.cbSize = sizeof( ncm );
4498 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS, 0, &ncm, 0 );
4499
4500 // Assume every menu item can be default and printed bold
4501 //ncm.lfMenuFont.lfWeight = FW_BOLD;
4502
4503 HFONT hfntOld = static_cast<HFONT>(SelectObject(hdc, CreateFontIndirectW( &ncm.lfMenuFont )));
4504
4505 // menu text and accelerator
4506 OUString aStr(pSalMenuItem->mText);
4507 if( pSalMenuItem->mAccelText.getLength() )
4508 {
4509 aStr += " " + pSalMenuItem->mAccelText;
4510 }
4511 GetTextExtentPoint32W( hdc, o3tl::toW(aStr.getStr()),
4512 aStr.getLength(), &strSize );
4513
4514 // image
4515 Size bmpSize( 16, 16 );
4516 //if( !!pSalMenuItem->maBitmap )
4517 // bmpSize = pSalMenuItem->maBitmap.GetSizePixel();
4518
4519 // checkmark
4520 Size checkSize( GetSystemMetrics( SM_CXMENUCHECK ), GetSystemMetrics( SM_CYMENUCHECK ) );
4521
4522 pMI->itemWidth = checkSize.Width() + 3 + bmpSize.Width() + 3 + strSize.cx;
4523 pMI->itemHeight = std::max( std::max( checkSize.Height(), bmpSize.Height() ), tools::Long(strSize.cy) );
4524 pMI->itemHeight += 4;
4525
4526 DeleteObject( SelectObject(hdc, hfntOld) );
4527 ReleaseDC( hWnd, hdc );
4528 }
4529
4530 return nRet;
4531 }
4532
4533 static LRESULT ImplDrawItem(HWND, WPARAM wParam, LPARAM lParam )
4534 {
4535 LRESULT nRet = 0;
4536 if( !wParam )
4537 {
4538 // request was sent by a menu
4539 nRet = 1;
4540 DRAWITEMSTRUCT *pDI = reinterpret_cast<LPDRAWITEMSTRUCT>(lParam);
4541 if( pDI->CtlType != ODT_MENU )
4542 return 0;
4543
4544 WinSalMenuItem *pSalMenuItem = reinterpret_cast<WinSalMenuItem *>(pDI->itemData);
4545 if( !pSalMenuItem )
4546 return 0;
4547
4548 COLORREF clrPrevText, clrPrevBkgnd;
4549 HFONT hfntOld;
4550 HBRUSH hbrOld;
4551 bool fChecked = (pDI->itemState & ODS_CHECKED);
4552 bool fSelected = (pDI->itemState & ODS_SELECTED);
4553 bool fDisabled = (pDI->itemState & (ODS_DISABLED | ODS_GRAYED));
4554
4555 // Set the appropriate foreground and background colors.
4556 RECT aRect = pDI->rcItem;
4557
4558 if ( fDisabled )
4559 clrPrevText = SetTextColor( pDI->hDC, GetSysColor( COLOR_GRAYTEXT ) );
4560 else
4561 clrPrevText = SetTextColor( pDI->hDC, GetSysColor( fSelected ? COLOR_HIGHLIGHTTEXT : COLOR_MENUTEXT ) );
4562
4563 DWORD colBackground = GetSysColor( fSelected ? COLOR_HIGHLIGHT : COLOR_MENU );
4564 clrPrevBkgnd = SetBkColor( pDI->hDC, colBackground );
4565
4566 hbrOld = static_cast<HBRUSH>(SelectObject( pDI->hDC, CreateSolidBrush( GetBkColor( pDI->hDC ) ) ));
4567
4568 // Fill background
4569 if(!PatBlt( pDI->hDC, aRect.left, aRect.top, aRect.right-aRect.left, aRect.bottom-aRect.top, PATCOPY ))
4570 SAL_WARN("vcl", "PatBlt failed: " << WindowsErrorString(GetLastError()));
4571
4572 int lineHeight = aRect.bottom-aRect.top;
4573
4574 int x = aRect.left;
4575 int y = aRect.top;
4576
4577 int checkWidth = GetSystemMetrics( SM_CXMENUCHECK );
4578 int checkHeight = GetSystemMetrics( SM_CYMENUCHECK );
4579 if( fChecked )
4580 {
4581 RECT r;
4582 r.left = 0;
4583 r.top = 0;
4584 r.right = checkWidth;
4585 r.bottom = checkWidth;
4586 HDC memDC = CreateCompatibleDC( pDI->hDC );
4587 HBITMAP memBmp = CreateCompatibleBitmap( pDI->hDC, checkWidth, checkHeight );
4588 HBITMAP hOldBmp = static_cast<HBITMAP>(SelectObject( memDC, memBmp ));
4589 DrawFrameControl( memDC, &r, DFC_MENU, DFCS_MENUCHECK );
4590 BitBlt( pDI->hDC, x, y+(lineHeight-checkHeight)/2, checkWidth, checkHeight, memDC, 0, 0, SRCAND );
4591 DeleteObject( SelectObject( memDC, hOldBmp ) );
4592 DeleteDC( memDC );
4593 }
4594 x += checkWidth+3;
4595
4596 //Size bmpSize = aBitmap.GetSizePixel();
4597 Size bmpSize(16, 16);
4598 if( !!pSalMenuItem->maBitmap )
4599 {
4600 Bitmap aBitmap( pSalMenuItem->maBitmap );
4601
4602 // set transparent pixels to background color
4603 if( fDisabled )
4604 colBackground = RGB(255,255,255);
4605 aBitmap.Replace( COL_LIGHTMAGENTA,
4606 Color( GetRValue(colBackground),GetGValue(colBackground),GetBValue(colBackground) ));
4607
4608 WinSalBitmap* pSalBmp = static_cast<WinSalBitmap*>(aBitmap.ImplGetSalBitmap().get());
4609 HGLOBAL hDrawDIB = pSalBmp->ImplGethDIB();
4610
4611 if( hDrawDIB )
4612 {
4613 PBITMAPINFO pBI = static_cast<PBITMAPINFO>(GlobalLock( hDrawDIB ));
4614 PBYTE pBits = reinterpret_cast<PBYTE>(pBI) + pBI->bmiHeader.biSize +
4615 WinSalBitmap::ImplGetDIBColorCount( hDrawDIB ) * sizeof( RGBQUAD );
4616
4617 HBITMAP hBmp = CreateDIBitmap( pDI->hDC, &pBI->bmiHeader, CBM_INIT, pBits, pBI, DIB_RGB_COLORS );
4618 GlobalUnlock( hDrawDIB );
4619
4620 HBRUSH hbrIcon = CreateSolidBrush( GetSysColor( COLOR_GRAYTEXT ) );
4621 DrawStateW( pDI->hDC, hbrIcon, nullptr, reinterpret_cast<LPARAM>(hBmp), WPARAM(0),
4622 x, y+(lineHeight-bmpSize.Height())/2, bmpSize.Width(), bmpSize.Height(),
4623 DST_BITMAP | (fDisabled ? (fSelected ? DSS_MONO : DSS_DISABLED) : DSS_NORMAL) );
4624
4625 DeleteObject( hbrIcon );
4626 DeleteObject( hBmp );
4627 }
4628
4629 }
4630 x += bmpSize.Width() + 3;
4631 aRect.left = x;
4632
4633 NONCLIENTMETRICSW ncm = {};
4634 ncm.cbSize = sizeof( ncm );
4635 SystemParametersInfoW( SPI_GETNONCLIENTMETRICS, 0, &ncm, 0 );
4636
4637 // Print default menu entry with bold font
4638 //if ( pDI->itemState & ODS_DEFAULT )
4639 // ncm.lfMenuFont.lfWeight = FW_BOLD;
4640
4641 hfntOld = static_cast<HFONT>(SelectObject(pDI->hDC, CreateFontIndirectW( &ncm.lfMenuFont )));
4642
4643 SIZE strSize;
4644 OUString aStr( pSalMenuItem->mText );
4645 GetTextExtentPoint32W( pDI->hDC, o3tl::toW(aStr.getStr()),
4646 aStr.getLength(), &strSize );
4647
4648 if(!DrawStateW( pDI->hDC, nullptr, nullptr,
4649 reinterpret_cast<LPARAM>(aStr.getStr()),
4650 WPARAM(0), aRect.left, aRect.top + (lineHeight - strSize.cy)/2, 0, 0,
4651 DST_PREFIXTEXT | (fDisabled && !fSelected ? DSS_DISABLED : DSS_NORMAL) ) )
4652 SAL_WARN("vcl", "DrawStateW failed: " << WindowsErrorString(GetLastError()));
4653
4654 if( pSalMenuItem->mAccelText.getLength() )
4655 {
4656 SIZE strSizeA;
4657 aStr = pSalMenuItem->mAccelText;
4658 GetTextExtentPoint32W( pDI->hDC, o3tl::toW(aStr.getStr()),
4659 aStr.getLength(), &strSizeA );
4660 TEXTMETRICW tm;
4661 GetTextMetricsW( pDI->hDC, &tm );
4662
4663 // position the accelerator string to the right but leave space for the
4664 // (potential) submenu arrow (tm.tmMaxCharWidth)
4665 if(!DrawStateW( pDI->hDC, nullptr, nullptr,
4666 reinterpret_cast<LPARAM>(aStr.getStr()),
4667 WPARAM(0), aRect.right-strSizeA.cx-tm.tmMaxCharWidth, aRect.top + (lineHeight - strSizeA.cy)/2, 0, 0,
4668 DST_TEXT | (fDisabled && !fSelected ? DSS_DISABLED : DSS_NORMAL) ) )
4669 SAL_WARN("vcl", "DrawStateW failed: " << WindowsErrorString(GetLastError()));
4670 }
4671
4672 // Restore the original font and colors.
4673 DeleteObject( SelectObject( pDI->hDC, hbrOld ) );
4674 DeleteObject( SelectObject( pDI->hDC, hfntOld) );
4675 SetTextColor(pDI->hDC, clrPrevText);
4676 SetBkColor(pDI->hDC, clrPrevBkgnd);
4677 }
4678 return nRet;
4679 }
4680
4681 static bool ImplHandleMenuActivate( HWND hWnd, WPARAM wParam, LPARAM )
4682 {
4683 // Menu activation
4684 WinSalFrame* pFrame = GetWindowPtr( hWnd );
4685 if ( !pFrame )
4686 return false;
4687
4688 HMENU hMenu = reinterpret_cast<HMENU>(wParam);
4689 // WORD nPos = LOWORD (lParam);
4690 // bool bWindowMenu = (bool) HIWORD(lParam);
4691
4692 // Send activate and deactivate together, so we have not keep track of opened menus
4693 // this will be enough to have the menus updated correctly
4694 SalMenuEvent aMenuEvt;
4695 WinSalMenuItem *pSalMenuItem = ImplGetSalMenuItem( hMenu, 0 );
4696 if( pSalMenuItem )
4697 aMenuEvt.mpMenu = pSalMenuItem->mpMenu;
4698 else
4699 aMenuEvt.mpMenu = nullptr;
4700
4701 bool nRet = pFrame->CallCallback( SalEvent::MenuActivate, &aMenuEvt );
4702 if( nRet )
4703 nRet = pFrame->CallCallback( SalEvent::MenuDeactivate, &aMenuEvt );
4704 if( nRet )
4705 pFrame->mLastActivatedhMenu = hMenu;
4706
4707 return nRet;
4708 }
4709
4710 static bool ImplHandleMenuSelect( HWND hWnd, WPARAM wParam, LPARAM lParam )
4711 {
4712 // Menu selection
4713 WinSalFrame* pFrame = GetWindowPtr( hWnd );
4714 if ( !pFrame )
4715 return false;
4716
4717 WORD nId = LOWORD(wParam); // menu item or submenu index
4718 WORD nFlags = HIWORD(wParam);
4719 HMENU hMenu = reinterpret_cast<HMENU>(lParam);
4720
4721 // check if we have to process the message
4722 if( !GetSalData()->IsKnownMenuHandle( hMenu ) )
4723 return false;
4724
4725 bool bByPosition = false;
4726 if( nFlags & MF_POPUP )
4727 bByPosition = true;
4728
4729 bool nRet = false;
4730 if ( hMenu && !pFrame->mLastActivatedhMenu )
4731 {
4732 // we never activated a menu (ie, no WM_INITMENUPOPUP has occurred yet)
4733 // which means this must be the menubar -> send activation/deactivation
4734 SalMenuEvent aMenuEvt;
4735 WinSalMenuItem *pSalMenuItem = ImplGetSalMenuItem( hMenu, nId, bByPosition );
4736 if( pSalMenuItem )
4737 aMenuEvt.mpMenu = pSalMenuItem->mpMenu;
4738 else
4739 aMenuEvt.mpMenu = nullptr;
4740
4741 nRet = pFrame->CallCallback( SalEvent::MenuActivate, &aMenuEvt );
4742 if( nRet )
4743 nRet = pFrame->CallCallback( SalEvent::MenuDeactivate, &aMenuEvt );
4744 if( nRet )
4745 pFrame->mLastActivatedhMenu = hMenu;
4746 }
4747
4748 if( !hMenu && nFlags == 0xFFFF )
4749 {
4750 // all menus are closed, reset activation logic
4751 pFrame->mLastActivatedhMenu = nullptr;
4752 }
4753
4754 if( hMenu )
4755 {
4756 // hMenu must be saved, as it is not passed in WM_COMMAND which always occurs after a selection
4757 // if a menu is closed due to a command selection then hMenu is NULL, but WM_COMMAND comes later
4758 // so we must not overwrite it in this case
4759 pFrame->mSelectedhMenu = hMenu;
4760
4761 // send highlight event
4762 if( nFlags & MF_POPUP )
4763 {
4764 // submenu selected
4765 // wParam now carries an index instead of an id -> retrieve id
4766 MENUITEMINFOW mi = {};
4767 mi.cbSize = sizeof( mi );
4768 mi.fMask = MIIM_ID;
4769 if( GetMenuItemInfoW( hMenu, LOWORD(wParam), TRUE, &mi) )
4770 nId = sal::static_int_cast<WORD>(mi.wID);
4771 }
4772
4773 SalMenuEvent aMenuEvt;
4774 aMenuEvt.mnId = nId;
4775 WinSalMenuItem *pSalMenuItem = ImplGetSalMenuItem( hMenu, nId, false );
4776 if( pSalMenuItem )
4777 aMenuEvt.mpMenu = pSalMenuItem->mpMenu;
4778 else
4779 aMenuEvt.mpMenu = nullptr;
4780
4781 nRet = pFrame->CallCallback( SalEvent::MenuHighlight, &aMenuEvt );
4782 }
4783
4784 return nRet;
4785 }
4786
4787 static bool ImplHandleCommand( HWND hWnd, WPARAM wParam, LPARAM )
4788 {
4789 WinSalFrame* pFrame = GetWindowPtr( hWnd );
4790 if ( !pFrame )
4791 return false;
4792
4793 bool nRet = false;
4794 if( !HIWORD(wParam) )
4795 {
4796 // Menu command
4797 WORD nId = LOWORD(wParam);
4798 if( nId ) // zero for separators
4799 {
4800 SalMenuEvent aMenuEvt;
4801 aMenuEvt.mnId = nId;
4802 WinSalMenuItem *pSalMenuItem = ImplGetSalMenuItem( pFrame->mSelectedhMenu, nId, false );
4803 if( pSalMenuItem )
4804 aMenuEvt.mpMenu = pSalMenuItem->mpMenu;
4805 else
4806 aMenuEvt.mpMenu = nullptr;
4807
4808 nRet = pFrame->CallCallback( SalEvent::MenuCommand, &aMenuEvt );
4809 }
4810 }
4811 return nRet;
4812 }
4813
4814 static bool ImplHandleSysCommand( HWND hWnd, WPARAM wParam, LPARAM lParam )
4815 {
4816 WinSalFrame* pFrame = GetWindowPtr( hWnd );
4817 if ( !pFrame )
4818 return false;
4819
4820 WPARAM nCommand = wParam & 0xFFF0;
4821
4822 if ( pFrame->mbFullScreen )
4823 {
4824 bool bMaximize = IsZoomed( pFrame->mhWnd );
4825 bool bMinimize = IsIconic( pFrame->mhWnd );
4826 if ( (nCommand == SC_SIZE) ||
4827 (!bMinimize && (nCommand == SC_MOVE)) ||
4828 (!bMaximize && (nCommand == SC_MAXIMIZE)) ||
4829 (bMaximize && (nCommand == SC_RESTORE)) )
4830 {
4831 return true;
4832 }
4833 }
4834
4835 if ( nCommand == SC_MOVE )
4836 {
4837 WinSalTimer* pTimer = static_cast<WinSalTimer*>( ImplGetSVData()->maSchedCtx.mpSalTimer );
4838 if ( pTimer )
4839 pTimer->SetForceRealTimer( true );
4840 }
4841
4842 if ( nCommand == SC_KEYMENU )
4843 {
4844 // do not process SC_KEYMENU if we have a native menu
4845 // Windows should handle this
4846 if( GetMenu( hWnd ) )
4847 return false;
4848
4849 // Process here KeyMenu events only for Alt to activate the MenuBar,
4850 // or if a SysChild window is in focus, as Alt-key-combinations are
4851 // only processed via this event
4852 if ( !LOWORD( lParam ) )
4853 {
4854 // Only trigger if no other key is pressed.
4855 // Contrary to Docu the CharCode is delivered with the x-coordinate
4856 // that is pressed in addition.
4857 // Also 32 for space, 99 for c, 100 for d, ...
4858 // As this is not documented, we check the state of the space-bar
4859 if ( GetKeyState( VK_SPACE ) & 0x8000 )
4860 return false;
4861
4862 // to avoid activating the MenuBar for Alt+MouseKey
4863 if ( (GetKeyState( VK_LBUTTON ) & 0x8000) ||
4864 (GetKeyState( VK_RBUTTON ) & 0x8000) ||
4865 (GetKeyState( VK_MBUTTON ) & 0x8000) ||
4866 (GetKeyState( VK_SHIFT ) & 0x8000) )
4867 return true;
4868
4869 SalKeyEvent aKeyEvt;
4870 aKeyEvt.mnCode = KEY_MENU;
4871 aKeyEvt.mnCharCode = 0;
4872 aKeyEvt.mnRepeat = 0;
4873 bool nRet = pFrame->CallCallback( SalEvent::KeyInput, &aKeyEvt );
4874 pFrame->CallCallback( SalEvent::KeyUp, &aKeyEvt );
4875 return nRet;
4876 }
4877 else
4878 {
4879 // check if a SysChild is in focus
4880 HWND hFocusWnd = ::GetFocus();
4881 if ( hFocusWnd && ImplFindSalObject( hFocusWnd ) )
4882 {
4883 char cKeyCode = static_cast<char>(static_cast<unsigned char>(LOWORD( lParam )));
4884 // LowerCase
4885 if ( (cKeyCode >= 65) && (cKeyCode <= 90) )
4886 cKeyCode += 32;
4887 // We only accept 0-9 and A-Z; all other keys have to be
4888 // processed by the SalObj hook
4889 if ( ((cKeyCode >= 48) && (cKeyCode <= 57)) ||
4890 ((cKeyCode >= 97) && (cKeyCode <= 122)) )
4891 {
4892 sal_uInt16 nModCode = 0;
4893 if ( GetKeyState( VK_SHIFT ) & 0x8000 )
4894 nModCode |= KEY_SHIFT;
4895 if ( GetKeyState( VK_CONTROL ) & 0x8000 )
4896 nModCode |= KEY_MOD1;
4897 nModCode |= KEY_MOD2;
4898
4899 SalKeyEvent aKeyEvt;
4900 if ( (cKeyCode >= 48) && (cKeyCode <= 57) )
4901 aKeyEvt.mnCode = KEY_0+(cKeyCode-48);
4902 else
4903 aKeyEvt.mnCode = KEY_A+(cKeyCode-97);
4904 aKeyEvt.mnCode |= nModCode;
4905 aKeyEvt.mnCharCode = cKeyCode;
4906 aKeyEvt.mnRepeat = 0;
4907 bool nRet = pFrame->CallCallback( SalEvent::KeyInput, &aKeyEvt );
4908 pFrame->CallCallback( SalEvent::KeyUp, &aKeyEvt );
4909 return nRet;
4910 }
4911 }
4912 }
4913 }
4914
4915 return false;
4916 }
4917
4918 static void ImplHandleInputLangChange( HWND hWnd, WPARAM, LPARAM lParam )
4919 {
4920 ImplSalYieldMutexAcquireWithWait();
4921
4922 // check if we support IME
4923 WinSalFrame* pFrame = GetWindowPtr( hWnd );
4924
4925 if ( !pFrame )
4926 return;
4927
4928 if ( pFrame->mbIME && pFrame->mhDefIMEContext )
4929 {
4930 HKL hKL = reinterpret_cast<HKL>(lParam);
4931 UINT nImeProps = ImmGetProperty( hKL, IGP_PROPERTY );
4932
4933 pFrame->mbSpezIME = (nImeProps & IME_PROP_SPECIAL_UI) != 0;
4934 pFrame->mbAtCursorIME = (nImeProps & IME_PROP_AT_CARET) != 0;
4935 pFrame->mbHandleIME = !pFrame->mbSpezIME;
4936 }
4937
4938 // trigger input language and codepage update
4939 UINT nLang = pFrame->mnInputLang;
4940 ImplUpdateInputLang( pFrame );
4941
4942 // notify change
4943 if( nLang != pFrame->mnInputLang )
4944 pFrame->CallCallback( SalEvent::InputLanguageChange, nullptr );
4945
4946 // reinit spec. keys
4947 GetSalData()->initKeyCodeMap();
4948
4949 ImplSalYieldMutexRelease();
4950 }
4951
4952 static void ImplUpdateIMECursorPos( WinSalFrame* pFrame, HIMC hIMC )
4953 {
4954 COMPOSITIONFORM aForm = {};
4955
4956 // get cursor position and from it calculate default position
4957 // for the composition window
4958 SalExtTextInputPosEvent aPosEvt;
4959 pFrame->CallCallback( SalEvent::ExtTextInputPos, &aPosEvt );
4960 if ( (aPosEvt.mnX == -1) && (aPosEvt.mnY == -1) )
4961 aForm.dwStyle |= CFS_DEFAULT;
4962 else
4963 {
4964 aForm.dwStyle |= CFS_POINT;
4965 aForm.ptCurrentPos.x = aPosEvt.mnX;
4966 aForm.ptCurrentPos.y = aPosEvt.mnY;
4967 }
4968 ImmSetCompositionWindow( hIMC, &aForm );
4969
4970 // Because not all IME's use this values, we create
4971 // a Windows caret to force the Position from the IME
4972 if ( GetFocus() == pFrame->mhWnd )
4973 {
4974 CreateCaret( pFrame->mhWnd, nullptr,
4975 aPosEvt.mnWidth, aPosEvt.mnHeight );
4976 SetCaretPos( aPosEvt.mnX, aPosEvt.mnY );
4977 }
4978 }
4979
4980 static bool ImplHandleIMEStartComposition( HWND hWnd )
4981 {
4982 bool bDef = true;
4983
4984 ImplSalYieldMutexAcquireWithWait();
4985
4986 WinSalFrame* pFrame = GetWindowPtr( hWnd );
4987 if ( pFrame )
4988 {
4989 HIMC hIMC = ImmGetContext( hWnd );
4990 if ( hIMC )
4991 {
4992 ImplUpdateIMECursorPos( pFrame, hIMC );
4993 ImmReleaseContext( hWnd, hIMC );
4994 }
4995
4996 if ( pFrame->mbHandleIME )
4997 {
4998 if ( pFrame->mbAtCursorIME )
4999 bDef = false;
5000 }
5001 }
5002
5003 ImplSalYieldMutexRelease();
5004
5005 return bDef;
5006 }
5007
5008 static bool ImplHandleIMECompositionInput( WinSalFrame* pFrame,
5009 HIMC hIMC, LPARAM lParam )
5010 {
5011 bool bDef = true;
5012
5013 // Init Event
5014 SalExtTextInputEvent aEvt;
5015 aEvt.mpTextAttr = nullptr;
5016 aEvt.mnCursorPos = 0;
5017 aEvt.mnCursorFlags = 0;
5018
5019 // If we get a result string, then we handle this input
5020 if ( lParam & GCS_RESULTSTR )
5021 {
5022 bDef = false;
5023
5024 LONG nTextLen = ImmGetCompositionStringW( hIMC, GCS_RESULTSTR, nullptr, 0 ) / sizeof( WCHAR );
5025 if ( nTextLen >= 0 )
5026 {
5027 auto pTextBuf = std::make_unique<WCHAR[]>(nTextLen);
5028 ImmGetCompositionStringW( hIMC, GCS_RESULTSTR, pTextBuf.get(), nTextLen*sizeof( WCHAR ) );
5029 aEvt.maText = OUString( o3tl::toU(pTextBuf.get()), static_cast<sal_Int32>(nTextLen) );
5030 }
5031
5032 aEvt.mnCursorPos = aEvt.maText.getLength();
5033 pFrame->CallCallback( SalEvent::ExtTextInput, &aEvt );
5034 pFrame->CallCallback( SalEvent::EndExtTextInput, nullptr );
5035 ImplUpdateIMECursorPos( pFrame, hIMC );
5036 }
5037
5038 // If the IME doesn't support OnSpot input, then there is nothing to do
5039 if ( !pFrame->mbAtCursorIME )
5040 return !bDef;
5041
5042 // If we get new Composition data, then we handle this new input
5043 if ( (lParam & (GCS_COMPSTR | GCS_COMPATTR)) ||
5044 ((lParam & GCS_CURSORPOS) && !(lParam & GCS_RESULTSTR)) )
5045 {
5046 bDef = false;
5047
5048 ExtTextInputAttr* pSalAttrAry = nullptr;
5049 LONG nTextLen = ImmGetCompositionStringW( hIMC, GCS_COMPSTR, nullptr, 0 ) / sizeof( WCHAR );
5050 if ( nTextLen > 0 )
5051 {
5052 {
5053 auto pTextBuf = std::make_unique<WCHAR[]>(nTextLen);
5054 ImmGetCompositionStringW( hIMC, GCS_COMPSTR, pTextBuf.get(), nTextLen*sizeof( WCHAR ) );
5055 aEvt.maText = OUString( o3tl::toU(pTextBuf.get()), static_cast<sal_Int32>(nTextLen) );
5056 }
5057
5058 std::unique_ptr<BYTE[]> pAttrBuf;
5059 LONG nAttrLen = ImmGetCompositionStringW( hIMC, GCS_COMPATTR, nullptr, 0 );
5060 if ( nAttrLen > 0 )
5061 {
5062 pAttrBuf.reset(new BYTE[nAttrLen]);
5063 ImmGetCompositionStringW( hIMC, GCS_COMPATTR, pAttrBuf.get(), nAttrLen );
5064 }
5065
5066 if ( pAttrBuf )
5067 {
5068 sal_Int32 nTextLen2 = aEvt.maText.getLength();
5069 pSalAttrAry = new ExtTextInputAttr[nTextLen2];
5070 memset( pSalAttrAry, 0, nTextLen2*sizeof( sal_uInt16 ) );
5071 for( sal_Int32 i = 0; (i < nTextLen2) && (i < nAttrLen); i++ )
5072 {
5073 BYTE nWinAttr = pAttrBuf.get()[i];
5074 ExtTextInputAttr nSalAttr;
5075 if ( nWinAttr == ATTR_TARGET_CONVERTED )
5076 {
5077 nSalAttr = ExtTextInputAttr::BoldUnderline;
5078 aEvt.mnCursorFlags |= EXTTEXTINPUT_CURSOR_INVISIBLE;
5079 }
5080 else if ( nWinAttr == ATTR_CONVERTED )
5081 nSalAttr = ExtTextInputAttr::DashDotUnderline;
5082 else if ( nWinAttr == ATTR_TARGET_NOTCONVERTED )
5083 nSalAttr = ExtTextInputAttr::Highlight;
5084 else if ( nWinAttr == ATTR_INPUT_ERROR )
5085 nSalAttr = ExtTextInputAttr::RedText | ExtTextInputAttr::DottedUnderline;
5086 else /* ( nWinAttr == ATTR_INPUT ) */
5087 nSalAttr = ExtTextInputAttr::DottedUnderline;
5088 pSalAttrAry[i] = nSalAttr;
5089 }
5090
5091 aEvt.mpTextAttr = pSalAttrAry;
5092 }
5093 }
5094
5095 // Only when we get new composition data, we must send this event
5096 if ( (nTextLen > 0) || !(lParam & GCS_RESULTSTR) )
5097 {
5098 // End the mode, if the last character is deleted
5099 if ( !nTextLen && !pFrame->mbCandidateMode )
5100 {
5101 pFrame->CallCallback( SalEvent::ExtTextInput, &aEvt );
5102 pFrame->CallCallback( SalEvent::EndExtTextInput, nullptr );
5103 }
5104 else
5105 {
5106 // Because Cursor-Position and DeltaStart never updated
5107 // from the korean input engine, we must handle this here
5108 if ( lParam & CS_INSERTCHAR )
5109 {
5110 aEvt.mnCursorPos = nTextLen;
5111 if ( aEvt.mnCursorPos && (lParam & CS_NOMOVECARET) )
5112 aEvt.mnCursorPos--;
5113 }
5114 else
5115 aEvt.mnCursorPos = LOWORD( ImmGetCompositionStringW( hIMC, GCS_CURSORPOS, nullptr, 0 ) );
5116
5117 if ( pFrame->mbCandidateMode )
5118 aEvt.mnCursorFlags |= EXTTEXTINPUT_CURSOR_INVISIBLE;
5119 if ( lParam & CS_NOMOVECARET )
5120 aEvt.mnCursorFlags |= EXTTEXTINPUT_CURSOR_OVERWRITE;
5121
5122 pFrame->CallCallback( SalEvent::ExtTextInput, &aEvt );
5123 }
5124 ImplUpdateIMECursorPos( pFrame, hIMC );
5125 }
5126
5127 if ( pSalAttrAry )
5128 delete [] pSalAttrAry;
5129 }
5130
5131 return !bDef;
5132 }
5133
5134 static bool ImplHandleIMEComposition( HWND hWnd, LPARAM lParam )
5135 {
5136 bool bDef = true;
5137 ImplSalYieldMutexAcquireWithWait();
5138
5139 WinSalFrame* pFrame = GetWindowPtr( hWnd );
5140 if ( pFrame && (!lParam || (lParam & GCS_RESULTSTR)) )
5141 {
5142 // reset the background mode for each text input,
5143 // as some tools such as RichWin may have changed it
5144 if ( pFrame->mpLocalGraphics &&
5145 pFrame->mpLocalGraphics->getHDC() )
5146 SetBkMode( pFrame->mpLocalGraphics->getHDC(), TRANSPARENT );
5147 }
5148
5149 if ( pFrame && pFrame->mbHandleIME )
5150 {
5151 if ( !lParam )
5152 {
5153 SalExtTextInputEvent aEvt;
5154 aEvt.mpTextAttr = nullptr;
5155 aEvt.mnCursorPos = 0;
5156 aEvt.mnCursorFlags = 0;
5157 pFrame->CallCallback( SalEvent::ExtTextInput, &aEvt );
5158 pFrame->CallCallback( SalEvent::EndExtTextInput, nullptr );
5159 }
5160 else if ( lParam & (GCS_RESULTSTR | GCS_COMPSTR | GCS_COMPATTR | GCS_CURSORPOS) )
5161 {
5162 HIMC hIMC = ImmGetContext( hWnd );
5163 if ( hIMC )
5164 {
5165 if ( ImplHandleIMECompositionInput( pFrame, hIMC, lParam ) )
5166 bDef = false;
5167
5168 ImmReleaseContext( hWnd, hIMC );
5169 }
5170 }
5171 }
5172
5173 ImplSalYieldMutexRelease();
5174 return bDef;
5175 }
5176
5177 static bool ImplHandleIMEEndComposition( HWND hWnd )
5178 {
5179 bool bDef = true;
5180
5181 ImplSalYieldMutexAcquireWithWait();
5182
5183 WinSalFrame* pFrame = GetWindowPtr( hWnd );
5184 if ( pFrame && pFrame->mbHandleIME )
5185 {
5186 if ( pFrame->mbAtCursorIME )
5187 bDef = false;
5188 }
5189
5190 ImplSalYieldMutexRelease();
5191
5192 return bDef;
5193 }
5194
5195 static bool ImplHandleAppCommand( HWND hWnd, LPARAM lParam, LRESULT & nRet )
5196 {
5197 MediaCommand nCommand;
5198 switch( GET_APPCOMMAND_LPARAM(lParam) )
5199 {
5200 case APPCOMMAND_MEDIA_CHANNEL_DOWN: nCommand = MediaCommand::ChannelDown; break;
5201 case APPCOMMAND_MEDIA_CHANNEL_UP: nCommand = MediaCommand::ChannelUp; break;
5202 case APPCOMMAND_MEDIA_NEXTTRACK: nCommand = MediaCommand::NextTrack; break;
5203 case APPCOMMAND_MEDIA_PAUSE: nCommand = MediaCommand::Pause; break;
5204 case APPCOMMAND_MEDIA_PLAY: nCommand = MediaCommand::Play; break;
5205 case APPCOMMAND_MEDIA_PLAY_PAUSE: nCommand = MediaCommand::PlayPause; break;
5206 case APPCOMMAND_MEDIA_PREVIOUSTRACK: nCommand = MediaCommand::PreviousTrack; break;
5207 case APPCOMMAND_MEDIA_RECORD: nCommand = MediaCommand::Record; break;
5208 case APPCOMMAND_MEDIA_REWIND: nCommand = MediaCommand::Rewind; break;
5209 case APPCOMMAND_MEDIA_STOP: nCommand = MediaCommand::Stop; break;
5210 case APPCOMMAND_MIC_ON_OFF_TOGGLE: nCommand = MediaCommand::MicOnOffToggle; break;
5211 case APPCOMMAND_MICROPHONE_VOLUME_DOWN: nCommand = MediaCommand::MicrophoneVolumeDown; break;
5212 case APPCOMMAND_MICROPHONE_VOLUME_MUTE: nCommand = MediaCommand::MicrophoneVolumeMute; break;
5213 case APPCOMMAND_MICROPHONE_VOLUME_UP: nCommand = MediaCommand::MicrophoneVolumeUp; break;
5214 case APPCOMMAND_VOLUME_DOWN: nCommand = MediaCommand::VolumeDown; break;
5215 case APPCOMMAND_VOLUME_MUTE: nCommand = MediaCommand::VolumeMute; break;
5216 case APPCOMMAND_VOLUME_UP: nCommand = MediaCommand::VolumeUp; break;
5217 default:
5218 return false;
5219 }
5220
5221 WinSalFrame* pFrame = GetWindowPtr( hWnd );
5222 vcl::Window *pWindow = pFrame ? pFrame->GetWindow() : nullptr;
5223
5224 if( pWindow )
5225 {
5226 const Point aPoint;
5227 CommandMediaData aMediaData(nCommand);
5228 CommandEvent aCEvt( aPoint, CommandEventId::Media, false, &aMediaData );
5229 NotifyEvent aNCmdEvt( MouseNotifyEvent::COMMAND, pWindow, &aCEvt );
5230
5231 if ( !ImplCallPreNotify( aNCmdEvt ) )
5232 {
5233 pWindow->Command( aCEvt );
5234 nRet = 1;
5235 return !aMediaData.GetPassThroughToOS();
5236 }
5237 }
5238
5239 return false;
5240 }
5241
5242 static void ImplHandleIMENotify( HWND hWnd, WPARAM wParam )
5243 {
5244 if ( wParam == WPARAM(IMN_OPENCANDIDATE) )
5245 {
5246 ImplSalYieldMutexAcquireWithWait();
5247
5248 WinSalFrame* pFrame = GetWindowPtr( hWnd );
5249 if ( pFrame && pFrame->mbHandleIME &&
5250 pFrame->mbAtCursorIME )
5251 {
5252 // we want to hide the cursor
5253 pFrame->mbCandidateMode = true;
5254 ImplHandleIMEComposition( hWnd, GCS_CURSORPOS );
5255
5256 HWND hWnd2 = pFrame->mhWnd;
5257 HIMC hIMC = ImmGetContext( hWnd2 );
5258 if ( hIMC )
5259 {
5260 LONG nBufLen = ImmGetCompositionStringW( hIMC, GCS_COMPSTR, nullptr, 0 );
5261 if ( nBufLen >= 1 )
5262 {
5263 SalExtTextInputPosEvent aPosEvt;
5264 pFrame->CallCallback( SalEvent::ExtTextInputPos, &aPosEvt );
5265
5266 // Vertical !!!
5267 CANDIDATEFORM aForm;
5268 aForm.dwIndex = 0;
5269 aForm.dwStyle = CFS_EXCLUDE;
5270 aForm.ptCurrentPos.x = aPosEvt.mnX;
5271 aForm.ptCurrentPos.y = aPosEvt.mnY+1;
5272 aForm.rcArea.left = aPosEvt.mnX;
5273 aForm.rcArea.top = aPosEvt.mnY;
5274 aForm.rcArea.right = aForm.rcArea.left+aPosEvt.mnExtWidth+1;
5275 aForm.rcArea.bottom = aForm.rcArea.top+aPosEvt.mnHeight+1;
5276 ImmSetCandidateWindow( hIMC, &aForm );
5277 }
5278
5279 ImmReleaseContext( hWnd2, hIMC );
5280 }
5281 }
5282
5283 ImplSalYieldMutexRelease();
5284 }
5285 else if ( wParam == WPARAM(IMN_CLOSECANDIDATE) )
5286 {
5287 ImplSalYieldMutexAcquireWithWait();
5288 WinSalFrame* pFrame = GetWindowPtr( hWnd );
5289 if ( pFrame )
5290 pFrame->mbCandidateMode = false;
5291 ImplSalYieldMutexRelease();
5292 }
5293 }
5294
5295 static bool
5296 ImplHandleGetObject(HWND hWnd, LPARAM lParam, WPARAM wParam, LRESULT & nRet)
5297 {
5298 if (!Application::GetSettings().GetMiscSettings().GetEnableATToolSupport())
5299 {
5300 // IA2 should be enabled automatically
5301 AllSettings aSettings = Application::GetSettings();
5302 MiscSettings aMisc = aSettings.GetMiscSettings();
5303 aMisc.SetEnableATToolSupport(true);
5304 // The above is enough, since aMisc changes the same shared ImplMiscData as used in global
5305 // settings, so no need to call aSettings.SetMiscSettings and Application::SetSettings
5306
5307 if (!Application::GetSettings().GetMiscSettings().GetEnableATToolSupport())
5308 return false; // locked down somehow ?
5309 }
5310
5311 ImplSVData* pSVData = ImplGetSVData();
5312
5313 // Make sure to launch Accessibility only the following criteria are satisfied
5314 // to avoid RFT interrupts regular accessibility processing
5315 if ( !pSVData->mxAccessBridge.is() )
5316 {
5317 if( !InitAccessBridge() )
5318 return false;
5319 }
5320
5321 uno::Reference< accessibility::XMSAAService > xMSAA( pSVData->mxAccessBridge, uno::UNO_QUERY );
5322 if ( xMSAA.is() )
5323 {
5324 sal_Int32 lParam32 = static_cast<sal_Int32>(lParam);
5325 sal_uInt32 wParam32 = static_cast<sal_uInt32>(wParam);
5326
5327 // mhOnSetTitleWnd not set to reasonable value anywhere...
5328 if ( lParam32 == OBJID_CLIENT )
5329 {
5330 nRet = xMSAA->getAccObjectPtr(
5331 reinterpret_cast<sal_Int64>(hWnd), lParam32, wParam32);
5332 if (nRet != 0)
5333 return true;
5334 }
5335 }
5336 return false;
5337 }
5338
5339 static LRESULT ImplHandleIMEReconvertString( HWND hWnd, LPARAM lParam )
5340 {
5341 WinSalFrame* pFrame = GetWindowPtr( hWnd );
5342 LPRECONVERTSTRING pReconvertString = reinterpret_cast<LPRECONVERTSTRING>(lParam);
5343 LRESULT nRet = 0;
5344 SalSurroundingTextRequestEvent aEvt;
5345 aEvt.maText.clear();
5346 aEvt.mnStart = aEvt.mnEnd = 0;
5347
5348 UINT nImeProps = ImmGetProperty( GetKeyboardLayout( 0 ), IGP_SETCOMPSTR );
5349 if( (nImeProps & SCS_CAP_SETRECONVERTSTRING) == 0 )
5350 {
5351 // This IME does not support reconversion.
5352 return 0;
5353 }
5354
5355 if( !pReconvertString )
5356 {
5357 // The first call for reconversion.
5358 pFrame->CallCallback( SalEvent::StartReconversion, nullptr );
5359
5360 // Retrieve the surrounding text from the focused control.
5361 pFrame->CallCallback( SalEvent::SurroundingTextRequest, &aEvt );
5362
5363 if( aEvt.maText.isEmpty())
5364 {
5365 return 0;
5366 }
5367
5368 nRet = sizeof(RECONVERTSTRING) + (aEvt.maText.getLength() + 1) * sizeof(WCHAR);
5369 }
5370 else
5371 {
5372 // The second call for reconversion.
5373
5374 // Retrieve the surrounding text from the focused control.
5375 pFrame->CallCallback( SalEvent::SurroundingTextRequest, &aEvt );
5376 nRet = sizeof(RECONVERTSTRING) + (aEvt.maText.getLength() + 1) * sizeof(WCHAR);
5377
5378 pReconvertString->dwStrOffset = sizeof(RECONVERTSTRING);
5379 pReconvertString->dwStrLen = aEvt.maText.getLength();
5380 pReconvertString->dwCompStrOffset = aEvt.mnStart * sizeof(WCHAR);
5381 pReconvertString->dwCompStrLen = aEvt.mnEnd - aEvt.mnStart;
5382 pReconvertString->dwTargetStrOffset = pReconvertString->dwCompStrOffset;
5383 pReconvertString->dwTargetStrLen = pReconvertString->dwCompStrLen;
5384
5385 memcpy( pReconvertString + 1, aEvt.maText.getStr(), (aEvt.maText.getLength() + 1) * sizeof(WCHAR) );
5386 }
5387
5388 // just return the required size of buffer to reconvert.
5389 return nRet;
5390 }
5391
5392 static LRESULT ImplHandleIMEConfirmReconvertString( HWND hWnd, LPARAM lParam )
5393 {
5394 WinSalFrame* pFrame = GetWindowPtr( hWnd );
5395 LPRECONVERTSTRING pReconvertString = reinterpret_cast<LPRECONVERTSTRING>(lParam);
5396 SalSurroundingTextRequestEvent aEvt;
5397 aEvt.maText.clear();
5398 aEvt.mnStart = aEvt.mnEnd = 0;
5399
5400 pFrame->CallCallback( SalEvent::SurroundingTextRequest, &aEvt );
5401
5402 sal_uLong nTmpStart = pReconvertString->dwCompStrOffset / sizeof(WCHAR);
5403 sal_uLong nTmpEnd = nTmpStart + pReconvertString->dwCompStrLen;
5404
5405 if( nTmpStart != aEvt.mnStart || nTmpEnd != aEvt.mnEnd )
5406 {
5407 SalSurroundingTextSelectionChangeEvent aSelEvt { nTmpStart, nTmpEnd };
5408 pFrame->CallCallback( SalEvent::SurroundingTextSelectionChange, &aSelEvt );
5409 }
5410
5411 return TRUE;
5412 }
5413
5414 static LRESULT ImplHandleIMEQueryCharPosition( HWND hWnd, LPARAM lParam ) {
5415 WinSalFrame* pFrame = GetWindowPtr( hWnd );
5416 PIMECHARPOSITION pQueryCharPosition = reinterpret_cast<PIMECHARPOSITION>(lParam);
5417 if ( pQueryCharPosition->dwSize < sizeof(IMECHARPOSITION) )
5418 return FALSE;
5419
5420 SalQueryCharPositionEvent aEvt;
5421 aEvt.mbValid = false;
5422 aEvt.mnCharPos = pQueryCharPosition->dwCharPos;
5423
5424 pFrame->CallCallback( SalEvent::QueryCharPosition, &aEvt );
5425
5426 if ( !aEvt.mbValid )
5427 return FALSE;
5428
5429 if ( aEvt.mbVertical )
5430 {
5431 // For vertical writing, the base line is left edge of the rectangle
5432 // and the target position is top-right corner.
5433 pQueryCharPosition->pt.x = aEvt.mnCursorBoundX + aEvt.mnCursorBoundWidth;
5434 pQueryCharPosition->pt.y = aEvt.mnCursorBoundY;
5435 pQueryCharPosition->cLineHeight = aEvt.mnCursorBoundWidth;
5436 }
5437 else
5438 {
5439 // For horizontal writing, the base line is the bottom edge of the rectangle.
5440 // and the target position is top-left corner.
5441 pQueryCharPosition->pt.x = aEvt.mnCursorBoundX;
5442 pQueryCharPosition->pt.y = aEvt.mnCursorBoundY;
5443 pQueryCharPosition->cLineHeight = aEvt.mnCursorBoundHeight;
5444 }
5445
5446 // Currently not supported but many IMEs usually ignore them.
5447 pQueryCharPosition->rcDocument.left = 0;
5448 pQueryCharPosition->rcDocument.top = 0;
5449 pQueryCharPosition->rcDocument.right = 0;
5450 pQueryCharPosition->rcDocument.bottom = 0;
5451
5452 return TRUE;
5453 }
5454
5455 void SalTestMouseLeave()
5456 {
5457 SalData* pSalData = GetSalData();
5458
5459 if ( pSalData->mhWantLeaveMsg && !::GetCapture() )
5460 {
5461 POINT aPt;
5462 GetCursorPos( &aPt );
5463 if ( pSalData->mhWantLeaveMsg != WindowFromPoint( aPt ) )
5464 SendMessageW( pSalData->mhWantLeaveMsg, SAL_MSG_MOUSELEAVE, 0, MAKELPARAM( aPt.x, aPt.y ) );
5465 }
5466 }
5467
5468 static bool ImplSalWheelMousePos( HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam ,
5469 LRESULT& rResult )
5470 {
5471 POINT aPt;
5472 POINT aScreenPt;
5473 aScreenPt.x = static_cast<short>(LOWORD( lParam ));
5474 aScreenPt.y = static_cast<short>(HIWORD( lParam ));
5475 // find child window that is at this position
5476 HWND hChildWnd;
5477 HWND hWheelWnd = hWnd;
5478 do
5479 {
5480 hChildWnd = hWheelWnd;
5481 aPt = aScreenPt;
5482 ScreenToClient( hChildWnd, &aPt );
5483 hWheelWnd = ChildWindowFromPointEx( hChildWnd, aPt, CWP_SKIPINVISIBLE | CWP_SKIPTRANSPARENT );
5484 }
5485 while ( hWheelWnd && (hWheelWnd != hChildWnd) );
5486 if ( hWheelWnd && (hWheelWnd != hWnd) &&
5487 (hWheelWnd != ::GetFocus()) && IsWindowEnabled( hWheelWnd ) )
5488 {
5489 rResult = SendMessageW( hWheelWnd, nMsg, wParam, lParam );
5490 return false;
5491 }
5492
5493 return true;
5494 }
5495
5496 static LRESULT CALLBACK SalFrameWndProc( HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam, bool& rDef )
5497 {
5498 LRESULT nRet = 0;
5499 static bool bInWheelMsg = false;
5500 static bool bInQueryEnd = false;
5501
5502 SAL_INFO("vcl.gdi.wndproc", "SalFrameWndProc(nMsg=" << nMsg << ", wParam=" << wParam << ", lParam=" << lParam << ")");
5503
5504 // By WM_CREATE we connect the frame with the window handle
5505 if ( nMsg == WM_CREATE )
5506 {
5507 // Save Window-Instance in Windowhandle
5508 // Can also be used for the A-Version, because the struct
5509 // to access lpCreateParams is the same structure
5510 CREATESTRUCTW* pStruct = reinterpret_cast<CREATESTRUCTW*>(lParam);
5511 WinSalFrame* pFrame = static_cast<WinSalFrame*>(pStruct->lpCreateParams);
5512 if ( pFrame != nullptr )
5513 {
5514 SetWindowPtr( hWnd, pFrame );
5515 // Set HWND already here, as data might be used already
5516 // when messages are being sent by CreateWindow()
5517 pFrame->mhWnd = hWnd;
5518 pFrame->maSysData.hWnd = hWnd;
5519 }
5520 return 0;
5521 }
5522
5523 ImplSVData* pSVData = ImplGetSVData();
5524 // #i72707# TODO: the mbDeInit check will not be needed
5525 // once all windows that are not properly closed on exit got fixed
5526 if( pSVData->mbDeInit )
5527 return 0;
5528
5529 if ( WM_USER_SYSTEM_WINDOW_ACTIVATED == nMsg )
5530 {
5531 ImplHideSplash();
5532 return 0;
5533 }
5534
5535 switch( nMsg )
5536 {
5537 case WM_MOUSEMOVE:
5538 case WM_LBUTTONDOWN:
5539 case WM_MBUTTONDOWN:
5540 case WM_RBUTTONDOWN:
5541 case WM_LBUTTONUP:
5542 case WM_MBUTTONUP:
5543 case WM_RBUTTONUP:
5544 case WM_NCMOUSEMOVE:
5545 case SAL_MSG_MOUSELEAVE:
5546 ImplSalYieldMutexAcquireWithWait();
5547 rDef = !ImplHandleMouseMsg( hWnd, nMsg, wParam, lParam );
5548 ImplSalYieldMutexRelease();
5549 break;
5550
5551 case WM_NCLBUTTONDOWN:
5552 case WM_NCMBUTTONDOWN:
5553 case WM_NCRBUTTONDOWN:
5554 ImplSalYieldMutexAcquireWithWait();
5555 ImplCallClosePopupsHdl( hWnd ); // close popups...
5556 ImplSalYieldMutexRelease();
5557 break;
5558
5559 case WM_MOUSEACTIVATE:
5560 if ( LOWORD( lParam ) == HTCLIENT )
5561 {
5562 ImplSalYieldMutexAcquireWithWait();
5563 nRet = LRESULT(ImplHandleMouseActivateMsg( hWnd ));
5564 ImplSalYieldMutexRelease();
5565 if ( nRet )
5566 {
5567 nRet = MA_NOACTIVATE;
5568 rDef = false;
5569 }
5570 }
5571 break;
5572
5573 case WM_KEYDOWN:
5574 case WM_KEYUP:
5575 case WM_DEADCHAR:
5576 case WM_CHAR:
5577 case WM_UNICHAR: // MCD, 2003-01-13, Support for WM_UNICHAR & Keyman 6.0
5578 case WM_SYSKEYDOWN:
5579 case WM_SYSKEYUP:
5580 case WM_SYSCHAR:
5581 ImplSalYieldMutexAcquireWithWait();
5582 rDef = !ImplHandleKeyMsg( hWnd, nMsg, wParam, lParam, nRet );
5583 ImplSalYieldMutexRelease();
5584 break;
5585
5586 case WM_MOUSEWHEEL:
5587 case WM_MOUSEHWHEEL:
5588 // protect against recursion, in case the message is returned
5589 // by IE or the external window
5590 if ( !bInWheelMsg )
5591 {
5592 bInWheelMsg = true;
5593 rDef = !ImplHandleWheelMsg( hWnd, nMsg, wParam, lParam );
5594 // If we did not process the message, re-check if here is a
5595 // connected (?) window that we have to notify.
5596 if ( rDef )
5597 rDef = ImplSalWheelMousePos( hWnd, nMsg, wParam, lParam, nRet );
5598 bInWheelMsg = false;
5599 }
5600 break;
5601
5602 case WM_COMMAND:
5603 ImplSalYieldMutexAcquireWithWait();
5604 rDef = !ImplHandleCommand( hWnd, wParam, lParam );
5605 ImplSalYieldMutexRelease();
5606 break;
5607
5608 case WM_INITMENUPOPUP:
5609 ImplSalYieldMutexAcquireWithWait();
5610 rDef = !ImplHandleMenuActivate( hWnd, wParam, lParam );
5611 ImplSalYieldMutexRelease();
5612 break;
5613
5614 case WM_MENUSELECT:
5615 ImplSalYieldMutexAcquireWithWait();
5616 rDef = !ImplHandleMenuSelect( hWnd, wParam, lParam );
5617 ImplSalYieldMutexRelease();
5618 break;
5619
5620 case WM_SYSCOMMAND:
5621 ImplSalYieldMutexAcquireWithWait();
5622 nRet = LRESULT(ImplHandleSysCommand( hWnd, wParam, lParam ));
5623 ImplSalYieldMutexRelease();
5624 if ( nRet )
5625 rDef = false;
5626 break;
5627
5628 case WM_MENUCHAR:
5629 nRet = ImplMenuChar( hWnd, wParam, lParam );
5630 if( nRet )
5631 rDef = false;
5632 break;
5633
5634 case WM_MEASUREITEM:
5635 nRet = ImplMeasureItem(hWnd, wParam, lParam);
5636 if( nRet )
5637 rDef = false;
5638 break;
5639
5640 case WM_DRAWITEM:
5641 nRet = ImplDrawItem(hWnd, wParam, lParam);
5642 if( nRet )
5643 rDef = false;
5644 break;
5645
5646 case WM_MOVE:
5647 case SAL_MSG_POSTMOVE:
5648 ImplHandleMoveMsg( hWnd );
5649 rDef = false;
5650 break;
5651 case WM_SIZE:
5652 ImplHandleSizeMsg( hWnd, wParam, lParam );
5653 rDef = false;
5654 break;
5655 case SAL_MSG_POSTCALLSIZE:
5656 ImplCallSizeHdl( hWnd );
5657 rDef = false;
5658 break;
5659
5660 case WM_GETMINMAXINFO:
5661 if ( ImplHandleMinMax( hWnd, lParam ) )
5662 rDef = false;
5663 break;
5664
5665 case WM_ERASEBKGND:
5666 nRet = 1;
5667 rDef = false;
5668 break;
5669 case WM_PAINT:
5670 ImplHandlePaintMsg( hWnd );
5671 rDef = false;
5672 break;
5673 case SAL_MSG_POSTPAINT:
5674 ImplHandlePostPaintMsg( hWnd, reinterpret_cast<RECT*>(wParam) );
5675 rDef = false;
5676 break;
5677
5678 case SAL_MSG_FORCEPALETTE:
5679 ImplHandleForcePalette( hWnd );
5680 rDef = false;
5681 break;
5682
5683 case WM_QUERYNEWPALETTE:
5684 case SAL_MSG_POSTQUERYNEWPAL:
5685 nRet = ImplHandlePalette( true, hWnd, nMsg, wParam, lParam, rDef );
5686 break;
5687
5688 case WM_ACTIVATE:
5689 // Getting activated, we also want to set our palette.
5690 // We do this in Activate, so that other external child windows
5691 // can overwrite our palette. Thus our palette is set only once
5692 // and not recursively, as at all other places it is set only as
5693 // the background palette.
5694 if ( LOWORD( wParam ) != WA_INACTIVE )
5695 SendMessageW( hWnd, SAL_MSG_FORCEPALETTE, 0, 0 );
5696 break;
5697
5698 case WM_ENABLE:
5699 // #95133# a system dialog is opened/closed, using our app window as parent
5700 {
5701 WinSalFrame* pFrame = GetWindowPtr( hWnd );
5702 vcl::Window *pWin = nullptr;
5703 if( pFrame )
5704 pWin = pFrame->GetWindow();
5705
5706 if( !wParam )
5707 {
5708 pSVData->maAppData.mnModalMode++;
5709
5710 ImplHideSplash();
5711 if( pWin )
5712 {
5713 pWin->EnableInput( false, nullptr );
5714 pWin->IncModalCount(); // #106303# support frame based modal count
5715 }
5716 }
5717 else
5718 {
5719 ImplGetSVData()->maAppData.mnModalMode--;
5720 if( pWin )
5721 {
5722 pWin->EnableInput( true, nullptr );
5723 pWin->DecModalCount(); // #106303# support frame based modal count
5724 }
5725 }
5726 }
5727 break;
5728
5729 case WM_KILLFOCUS:
5730 DestroyCaret();
5731 [[fallthrough]];
5732 case WM_SETFOCUS:
5733 case SAL_MSG_POSTFOCUS:
5734 ImplHandleFocusMsg( hWnd );
5735 rDef = false;
5736 break;
5737
5738 case WM_CLOSE:
5739 ImplHandleCloseMsg( hWnd );
5740 rDef = false;
5741 break;
5742
5743 case WM_QUERYENDSESSION:
5744 if( !bInQueryEnd )
5745 {
5746 // handle queryendsession only once
5747 bInQueryEnd = true;
5748 nRet = LRESULT(!ImplHandleShutDownMsg( hWnd ));
5749 rDef = false;
5750
5751 // Issue #16314#: ImplHandleShutDownMsg causes a PostMessage in case of allowing shutdown.
5752 // This posted message was never processed and cause Windows XP to hang after log off
5753 // if there are multiple sessions and the current session wasn't the first one started.
5754 // So if shutdown is allowed we assume that a post message was done and retrieve all
5755 // messages in the message queue and dispatch them before we return control to the system.
5756
5757 if ( nRet )
5758 {
5759 SolarMutexGuard aGuard;
5760 while ( Application::Reschedule( true ) );
5761 }
5762 }
5763 else
5764 {
5765 ImplSalYieldMutexAcquireWithWait();
5766 ImplSalYieldMutexRelease();
5767 rDef = true;
5768 }
5769 break;
5770
5771 case WM_ENDSESSION:
5772 if( !wParam )
5773 bInQueryEnd = false; // no shutdown: allow query again
5774 nRet = FALSE;
5775 rDef = false;
5776 break;
5777
5778 case WM_DISPLAYCHANGE:
5779 case WM_SETTINGCHANGE:
5780 case WM_DEVMODECHANGE:
5781 case WM_FONTCHANGE:
5782 case WM_SYSCOLORCHANGE:
5783 case WM_TIMECHANGE:
5784 ImplHandleSettingsChangeMsg( hWnd, nMsg, wParam, lParam );
5785 break;
5786
5787 case WM_THEMECHANGED:
5788 GetSalData()->mbThemeChanged = true;
5789 break;
5790
5791 case SAL_MSG_USEREVENT:
5792 ImplHandleUserEvent( hWnd, lParam );
5793 rDef = false;
5794 break;
5795
5796 case SAL_MSG_CAPTUREMOUSE:
5797 SetCapture( hWnd );
5798 rDef = false;
5799 break;
5800 case SAL_MSG_RELEASEMOUSE:
5801 if ( ::GetCapture() == hWnd )
5802 ReleaseCapture();
5803 rDef = false;
5804 break;
5805 case SAL_MSG_TOTOP:
5806 ImplSalToTop( hWnd, static_cast<SalFrameToTop>(wParam) );
5807 rDef = false;
5808 break;
5809 case SAL_MSG_SHOW:
5810 ImplSalShow( hWnd, static_cast<bool>(wParam), static_cast<bool>(lParam) );
5811 rDef = false;
5812 break;
5813 case SAL_MSG_SETINPUTCONTEXT:
5814 ImplSalFrameSetInputContext( hWnd, reinterpret_cast<const SalInputContext*>(lParam) );
5815 rDef = false;
5816 break;
5817 case SAL_MSG_ENDEXTTEXTINPUT:
5818 ImplSalFrameEndExtTextInput( hWnd, static_cast<EndExtTextInputFlags>(wParam) );
5819 rDef = false;
5820 break;
5821
5822 case WM_INPUTLANGCHANGE:
5823 ImplHandleInputLangChange( hWnd, wParam, lParam );
5824 break;
5825
5826 case WM_IME_CHAR:
5827 // #103487#, some IMEs (eg, those that do not work onspot)
5828 // may send WM_IME_CHAR instead of WM_IME_COMPOSITION
5829 // we just handle it like a WM_CHAR message - seems to work fine
5830 ImplSalYieldMutexAcquireWithWait();
5831 rDef = !ImplHandleKeyMsg( hWnd, WM_CHAR, wParam, lParam, nRet );
5832 ImplSalYieldMutexRelease();
5833 break;
5834
5835 case WM_IME_STARTCOMPOSITION:
5836 rDef = ImplHandleIMEStartComposition( hWnd );
5837 break;
5838
5839 case WM_IME_COMPOSITION:
5840 rDef = ImplHandleIMEComposition( hWnd, lParam );
5841 break;
5842
5843 case WM_IME_ENDCOMPOSITION:
5844 rDef = ImplHandleIMEEndComposition( hWnd );
5845 break;
5846
5847 case WM_IME_NOTIFY:
5848 ImplHandleIMENotify( hWnd, wParam );
5849 break;
5850
5851 case WM_GETOBJECT:
5852 ImplSalYieldMutexAcquireWithWait();
5853 if ( ImplHandleGetObject( hWnd, lParam, wParam, nRet ) )
5854 {
5855 rDef = false;
5856 }
5857 ImplSalYieldMutexRelease();
5858 break;
5859
5860 case WM_APPCOMMAND:
5861 if( ImplHandleAppCommand( hWnd, lParam, nRet ) )
5862 {
5863 rDef = false;
5864 }
5865 break;
5866 case WM_IME_REQUEST:
5867 if ( static_cast<sal_uIntPtr>(wParam) == IMR_RECONVERTSTRING )
5868 {
5869 nRet = ImplHandleIMEReconvertString( hWnd, lParam );
5870 rDef = false;
5871 }
5872 else if( static_cast<sal_uIntPtr>(wParam) == IMR_CONFIRMRECONVERTSTRING )
5873 {
5874 nRet = ImplHandleIMEConfirmReconvertString( hWnd, lParam );
5875 rDef = false;
5876 }
5877 else if ( static_cast<sal_uIntPtr>(wParam) == IMR_QUERYCHARPOSITION )
5878 {
5879 if ( ImplSalYieldMutexTryToAcquire() )
5880 {
5881 nRet = ImplHandleIMEQueryCharPosition( hWnd, lParam );
5882 ImplSalYieldMutexRelease();
5883 }
5884 else
5885 nRet = FALSE;
5886 rDef = false;
5887 }
5888 break;
5889 }
5890
5891 return nRet;
5892 }
5893
5894 LRESULT CALLBACK SalFrameWndProcW( HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam )
5895 {
5896 bool bDef = true;
5897 LRESULT nRet = 0;
5898 __try
5899 {
5900 nRet = SalFrameWndProc( hWnd, nMsg, wParam, lParam, bDef );
5901 }
5902 __except(WinSalInstance::WorkaroundExceptionHandlingInUSER32Lib(GetExceptionCode(), GetExceptionInformation()))
5903 {
5904 }
5905
5906 if ( bDef )
5907 nRet = DefWindowProcW( hWnd, nMsg, wParam, lParam );
5908 return nRet;
5909 }
5910
5911 bool ImplHandleGlobalMsg( HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam, LRESULT& rlResult )
5912 {
5913 // handle all messages concerning all frames so they get processed only once
5914 // Must work for Unicode and none Unicode
5915 bool bResult = false;
5916 if ( (nMsg == WM_PALETTECHANGED) || (nMsg == SAL_MSG_POSTPALCHANGED) )
5917 {
5918 bResult = true;
5919 rlResult = ImplHandlePalette( false, hWnd, nMsg, wParam, lParam, bResult );
5920 }
5921 else if( nMsg == WM_DISPLAYCHANGE )
5922 {
5923 WinSalSystem* pSys = static_cast<WinSalSystem*>(ImplGetSalSystem());
5924 if( pSys )
5925 pSys->clearMonitors();
5926 bResult = (pSys != nullptr);
5927 }
5928 return bResult;
5929 }
5930
5931 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE