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