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