1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 #define INCL_DOS 25 #define INCL_PM 26 #define INCL_WIN 27 #include <svpm.h> 28 29 #include <string.h> 30 31 #include <tools/svwin.h> 32 33 // ======================================================================= 34 35 #define _SV_SALFRAME_CXX 36 37 #ifndef DEBUG_HXX 38 #include <tools/debug.hxx> 39 #endif 40 41 #define private public 42 43 #include "os2/sallang.hxx" 44 #include "os2/salids.hrc" 45 #include "os2/saldata.hxx" 46 #include "os2/salinst.h" 47 #include "os2/salgdi.h" 48 #include "os2/salframe.h" 49 #include "os2/saltimer.h" 50 51 #include <vcl/timer.hxx> 52 #include <vcl/settings.hxx> 53 #include <vcl/keycodes.hxx> 54 55 #if OSL_DEBUG_LEVEL>10 56 extern "C" int debug_printf(const char *f, ...); 57 58 static sal_Bool _bCapture; 59 60 #else 61 #define debug_printf( ...) { 1; } 62 #endif 63 64 // ======================================================================= 65 66 #undef WinEnableMenuItem 67 #define WinEnableMenuItem(hwndMenu,id,fEnable) \ 68 ((PM_BOOL)WinSendMsg (hwndMenu, MM_SETITEMATTR, MPFROM2SHORT (id, TRUE), \ 69 MPFROM2SHORT (MIA_DISABLED, \ 70 ((USHORT)(fEnable) ? 0 : MIA_DISABLED)))) 71 72 // ======================================================================= 73 74 HPOINTER ImplLoadPointer( ULONG nId ); 75 76 static void SetMaximizedFrameGeometry( HWND hWnd, Os2SalFrame* pFrame ); 77 static void UpdateFrameGeometry( HWND hWnd, Os2SalFrame* pFrame ); 78 static void ImplSalCalcFrameSize( HWND hWnd, 79 LONG& nFrameX, LONG& nFrameY, LONG& nCaptionY ); 80 static void ImplSalCalcFrameSize( const Os2SalFrame* pFrame, 81 LONG& nFrameX, LONG& nFrameY, LONG& nCaptionY ); 82 MRESULT EXPENTRY SalFrameSubClassWndProc( HWND hWnd, ULONG nMsg, 83 MPARAM nMP1, MPARAM nMP2 ); 84 85 // ======================================================================= 86 87 static LanguageType eImplKeyboardLanguage = LANGUAGE_DONTKNOW; 88 sal_Bool Os2SalFrame::mbInReparent = FALSE; 89 ULONG Os2SalFrame::mnInputLang = 0; 90 91 // ======================================================================= 92 93 // define a new flag 94 #define SWP_CENTER (SWP_NOAUTOCLOSE<<4) 95 #define SWP_SHOWMAXIMIZED (SWP_ACTIVATE | SWP_SHOW | SWP_MAXIMIZE) 96 #define SWP_SHOWMINIMIZED (SWP_ACTIVATE | SWP_SHOW | SWP_MINIMIZE) 97 #define SWP_SHOWNORMAL (SWP_ACTIVATE | SWP_SHOW | SWP_RESTORE) 98 99 static LONG nScreenHeight = WinQuerySysValue( HWND_DESKTOP, SV_CYSCREEN); 100 static LONG nScreenWidth = WinQuerySysValue( HWND_DESKTOP, SV_CXSCREEN ); 101 102 sal_Bool APIENTRY _WinQueryWindowRect( HWND hwnd, PRECTL prclDest) 103 { 104 sal_Bool rc = WinQueryWindowRect( hwnd, prclDest); 105 ULONG tmp = prclDest->yBottom; 106 prclDest->yBottom = prclDest->yTop; 107 prclDest->yTop = tmp; 108 return rc; 109 } 110 111 sal_Bool APIENTRY _WinQueryPointerPos (HWND hwndDesktop, PPOINTL pptl) 112 { 113 sal_Bool rc = WinQueryPointerPos( hwndDesktop, pptl); 114 pptl->y = nScreenHeight - pptl->y; 115 return rc; 116 } 117 118 sal_Bool APIENTRY _WinQueryWindowPos( Os2SalFrame* pFrame, PSWP pswp) 119 { 120 SWP swpOwner; 121 sal_Bool rc = WinQueryWindowPos( pFrame->mhWndFrame, pswp); 122 123 #if OSL_DEBUG_LEVEL>1 124 debug_printf( "> WinQueryWindowPos hwnd %x at %d,%d (%dx%d)\n", 125 pFrame->mhWndFrame, pswp->x, pswp->y, pswp->cx, pswp->cy); 126 #endif 127 128 Os2SalFrame* pParentFrame = pFrame->mpParentFrame; 129 130 //YD adjust to owner coordinates 131 if ( pParentFrame ) 132 { 133 POINTL ptlOwner = {0}; 134 135 // coords are relative to screen, map to parent frame client area 136 ptlOwner.x = pswp->x; 137 ptlOwner.y = pswp->y; 138 WinMapWindowPoints( HWND_DESKTOP, pParentFrame->mhWndClient, &ptlOwner, 1); 139 pswp->x = ptlOwner.x; 140 pswp->y = ptlOwner.y; 141 // get parent client area size 142 WinQueryWindowPos( pParentFrame->mhWndClient, &swpOwner); 143 } else 144 { 145 // no owner info, use DESKTOP???? 146 swpOwner.cx = nScreenWidth; 147 swpOwner.cy = nScreenHeight; 148 } 149 150 // invert Y coordinate 151 pswp->y = swpOwner.cy - (pswp->y + pswp->cy); 152 153 #if OSL_DEBUG_LEVEL>1 154 debug_printf( "< WinQueryWindowPos hwnd %x at %d,%d (%dx%d)\n", 155 pFrame->mhWndFrame, pswp->x, pswp->y, pswp->cx, pswp->cy); 156 #endif 157 return rc; 158 } 159 160 sal_Bool APIENTRY _WinSetWindowPos( Os2SalFrame* pFrame, HWND hwndInsertBehind, LONG x, LONG y, 161 LONG cx, LONG cy, ULONG fl) 162 { 163 SWP swpOwner = {0}; 164 POINTL ptlOwner = {0}; 165 HWND hParent = NULL; 166 167 #if OSL_DEBUG_LEVEL>1 168 debug_printf( ">WinSetWindowPos hwnd %x at %d,%d (%dx%d) fl 0x%08x\n", 169 pFrame->mhWndFrame, x, y, cx, cy, fl); 170 #endif 171 172 // first resize window if requested 173 if ( (fl & SWP_SIZE) ) { 174 ULONG flag = SWP_SIZE; 175 LONG nX = 0, nY = 0; 176 LONG frameFrameX, frameFrameY, frameCaptionY; 177 178 ImplSalCalcFrameSize( pFrame, frameFrameX, frameFrameY, frameCaptionY ); 179 // if we change y size, we need to move the window down 180 // because os2 window origin is lower left corner 181 if (pFrame->maGeometry.nHeight != cy) { 182 SWP aSWP; 183 WinQueryWindowPos( pFrame->mhWndFrame, &aSWP); 184 nX = aSWP.x; 185 nY = aSWP.y - (cy + 2*frameFrameY + frameCaptionY - aSWP.cy); 186 flag |= SWP_MOVE; 187 } 188 WinSetWindowPos( pFrame->mhWndFrame, NULL, nX, nY, 189 cx+2*frameFrameX, cy+2*frameFrameY+frameCaptionY, flag); 190 fl = fl & ~SWP_SIZE; 191 } 192 else // otherwise get current size 193 { 194 SWP swp = {0}; 195 WinQueryWindowPos( pFrame->mhWndClient, &swp); 196 cx = swp.cx; 197 cy = swp.cy; 198 } 199 200 // get parent window handle 201 Os2SalFrame* pParentFrame = pFrame->mpParentFrame; 202 203 // use desktop if parent is not defined 204 hParent = pParentFrame ? pParentFrame->mhWndClient : HWND_DESKTOP; 205 // if parent is not visible, use desktop as reference 206 hParent = WinIsWindowVisible( hParent) ? hParent : HWND_DESKTOP; 207 208 WinQueryWindowPos( hParent, &swpOwner); 209 210 //YD adjust to owner coordinates only when moving and not centering 211 //if (!(fl & SWP_CENTER) && (fl & SWP_MOVE)) 212 if ((fl & SWP_MOVE)) 213 { 214 215 // if SWP_CENTER is specified, change position to parent center 216 if (fl & SWP_CENTER) { 217 ptlOwner.x = (swpOwner.cx - cx) / 2; 218 ptlOwner.y = (swpOwner.cy - cy) / 2; 219 #if OSL_DEBUG_LEVEL>0 220 debug_printf( "_WinSetWindowPos SWP_CENTER\n"); 221 #endif 222 fl = fl & ~SWP_CENTER; 223 } else { 224 // coords are relative to parent frame client area, map to screen 225 // map Y to OS/2 system coordinates 226 ptlOwner.x = x; 227 ptlOwner.y = swpOwner.cy - (y + cy); 228 229 #if OSL_DEBUG_LEVEL>0 230 debug_printf( "_WinSetWindowPos owner 0x%x at %d,%d (%dx%d) OS2\n", 231 hParent, ptlOwner.x, ptlOwner.y, swpOwner.cx, swpOwner.cy); 232 #endif 233 } 234 // map from client area to screen 235 WinMapWindowPoints( hParent, HWND_DESKTOP, &ptlOwner, 1); 236 x = ptlOwner.x; 237 y = ptlOwner.y; 238 239 #if OSL_DEBUG_LEVEL>0 240 debug_printf( "_WinSetWindowPos owner 0x%x at %d,%d (%dx%d) MAPPED OS2\n", 241 hParent, ptlOwner.x, ptlOwner.y, swpOwner.cx, swpOwner.cy); 242 #endif 243 } 244 245 #if OSL_DEBUG_LEVEL>0 246 debug_printf( "<WinSetWindowPos hwnd %x at %d,%d (%dx%d) fl=%x\n", 247 pFrame->mhWndFrame, x, y, cx, cy, fl); 248 #endif 249 return WinSetWindowPos( pFrame->mhWndFrame, hwndInsertBehind, x, y, 0, 0, fl); 250 } 251 252 // ======================================================================= 253 254 #if OSL_DEBUG_LEVEL > 0 255 static void dumpWindowInfo( char* fnc, HWND hwnd) 256 { 257 SWP aSWP; 258 HWND hwnd2; 259 char szTitle[256]; 260 261 #if 0 262 _WinQueryWindowPos( hwnd, &aSWP ); 263 strcpy(szTitle,""); 264 WinQueryWindowText(hwnd, sizeof(szTitle), szTitle); 265 debug_printf( "%s: window %08x at %d,%d (size %dx%d) '%s'\n", fnc, hwnd, 266 aSWP.x, aSWP.y, aSWP.cx, aSWP.cy, szTitle); 267 hwnd2 = WinQueryWindow(hwnd, QW_PARENT); 268 _WinQueryWindowPos( hwnd2, &aSWP ); 269 strcpy(szTitle,""); 270 WinQueryWindowText(hwnd2, sizeof(szTitle), szTitle); 271 debug_printf( "%s: parent %08x at %d,%d (size %dx%d) '%s'\n", fnc, hwnd2, 272 aSWP.x, aSWP.y, aSWP.cx, aSWP.cy, szTitle); 273 hwnd2 = WinQueryWindow(hwnd, QW_OWNER); 274 _WinQueryWindowPos( hwnd2, &aSWP ); 275 strcpy(szTitle,""); 276 WinQueryWindowText(hwnd2, sizeof(szTitle), szTitle); 277 debug_printf( "%s: owner %08x at %d,%d (size %dx%d) '%s'\n", fnc, hwnd2, 278 aSWP.x, aSWP.y, aSWP.cx, aSWP.cy, szTitle); 279 #endif 280 } 281 #endif 282 283 // ======================================================================= 284 285 #ifdef ENABLE_IME 286 287 struct ImplSalIMEProc 288 { 289 ULONG nOrd; 290 PFN* pProc; 291 }; 292 293 #define SAL_IME_PROC_COUNT 12 294 295 // ----------------------------------------------------------------------- 296 297 static SalIMEData* GetSalIMEData() 298 { 299 SalData* pSalData = GetSalData(); 300 301 if ( !pSalData->mbIMEInit ) 302 { 303 pSalData->mbIMEInit = TRUE; 304 305 HMODULE hMod = 0; 306 if ( 0 == DosLoadModule( NULL, 0, "OS2IM", &hMod ) ) 307 { 308 SalIMEData* pIMEData = new SalIMEData; 309 sal_Bool bError = FALSE; 310 ImplSalIMEProc aProcAry[SAL_IME_PROC_COUNT] = 311 { 312 { 101, (PFN*)&(pIMEData->mpAssocIME) }, 313 { 104, (PFN*)&(pIMEData->mpGetIME) }, 314 { 106, (PFN*)&(pIMEData->mpReleaseIME) }, 315 { 117, (PFN*)&(pIMEData->mpSetConversionFont) }, 316 { 144, (PFN*)&(pIMEData->mpSetConversionFontSize) }, 317 { 118, (PFN*)&(pIMEData->mpGetConversionString) }, 318 { 122, (PFN*)&(pIMEData->mpGetResultString) }, 319 { 115, (PFN*)&(pIMEData->mpSetCandidateWin) }, 320 { 130, (PFN*)&(pIMEData->mpQueryIMEProperty) }, 321 { 131, (PFN*)&(pIMEData->mpRequestIME) }, 322 { 128, (PFN*)&(pIMEData->mpSetIMEMode) }, 323 { 127, (PFN*)&(pIMEData->mpQueryIMEMode) } 324 }; 325 326 pIMEData->mhModIME = hMod; 327 for ( USHORT i = 0; i < SAL_IME_PROC_COUNT; i++ ) 328 { 329 if ( 0 != DosQueryProcAddr( pIMEData->mhModIME, aProcAry[i].nOrd, 0, aProcAry[i].pProc ) ) 330 { 331 bError = TRUE; 332 break; 333 } 334 } 335 336 if ( bError ) 337 { 338 DosFreeModule( pIMEData->mhModIME ); 339 delete pIMEData; 340 } 341 else 342 pSalData->mpIMEData = pIMEData; 343 } 344 } 345 346 return pSalData->mpIMEData; 347 } 348 349 // ----------------------------------------------------------------------- 350 351 void ImplReleaseSALIMEData() 352 { 353 SalData* pSalData = GetSalData(); 354 355 if ( pSalData->mpIMEData ) 356 { 357 DosFreeModule( pSalData->mpIMEData->mhModIME ); 358 delete pSalData->mpIMEData; 359 } 360 } 361 362 #endif 363 364 // ======================================================================= 365 366 static void ImplSaveFrameState( Os2SalFrame* pFrame ) 367 { 368 // Position, Groesse und Status fuer GetWindowState() merken 369 if ( !pFrame->mbFullScreen ) 370 { 371 SWP aSWP; 372 sal_Bool bVisible = WinIsWindowVisible( pFrame->mhWndFrame); 373 374 // Query actual state (maState uses screen coords) 375 WinQueryWindowPos( pFrame->mhWndFrame, &aSWP ); 376 377 if ( aSWP.fl & SWP_MINIMIZE ) 378 { 379 #if OSL_DEBUG_LEVEL>0 380 debug_printf("Os2SalFrame::GetWindowState %08x SAL_FRAMESTATE_MINIMIZED\n", 381 pFrame->mhWndFrame); 382 #endif 383 pFrame->maState.mnState |= SAL_FRAMESTATE_MINIMIZED; 384 if ( bVisible ) 385 pFrame->mnShowState = SWP_SHOWMAXIMIZED; 386 } 387 else if ( aSWP.fl & SWP_MAXIMIZE ) 388 { 389 #if OSL_DEBUG_LEVEL>0 390 debug_printf("Os2SalFrame::GetWindowState %08x SAL_FRAMESTATE_MAXIMIZED\n", 391 pFrame->mhWndFrame); 392 #endif 393 pFrame->maState.mnState &= ~SAL_FRAMESTATE_MINIMIZED; 394 pFrame->maState.mnState |= SAL_FRAMESTATE_MAXIMIZED; 395 if ( bVisible ) 396 pFrame->mnShowState = SWP_SHOWMINIMIZED; 397 pFrame->mbRestoreMaximize = TRUE; 398 } 399 else 400 { 401 LONG nFrameX, nFrameY, nCaptionY; 402 ImplSalCalcFrameSize( pFrame, nFrameX, nFrameY, nCaptionY ); 403 // to be consistent with Unix, the frame state is without(!) decoration 404 long nTopDeco = nFrameY + nCaptionY; 405 long nLeftDeco = nFrameX; 406 long nBottomDeco = nFrameY; 407 long nRightDeco = nFrameX; 408 409 pFrame->maState.mnState &= ~(SAL_FRAMESTATE_MINIMIZED | SAL_FRAMESTATE_MAXIMIZED); 410 // subtract decoration, store screen coords 411 pFrame->maState.mnX = aSWP.x+nLeftDeco; 412 pFrame->maState.mnY = nScreenHeight - (aSWP.y+aSWP.cy)+nTopDeco; 413 pFrame->maState.mnWidth = aSWP.cx-nLeftDeco-nRightDeco; 414 pFrame->maState.mnHeight = aSWP.cy-nTopDeco-nBottomDeco; 415 #if OSL_DEBUG_LEVEL>0 416 debug_printf("Os2SalFrame::GetWindowState %08x (%dx%d) at %d,%d VCL\n", 417 pFrame->mhWndFrame, 418 pFrame->maState.mnWidth,pFrame->maState.mnHeight,pFrame->maState.mnX,pFrame->maState.mnY); 419 #endif 420 if ( bVisible ) 421 pFrame->mnShowState = SWP_SHOWNORMAL; 422 pFrame->mbRestoreMaximize = FALSE; 423 //debug_printf( "ImplSaveFrameState: window %08x at %d,%d (size %dx%d)\n", 424 // pFrame->mhWndFrame, 425 // pFrame->maState.mnX, pFrame->maState.mnY, pFrame->maState.mnWidth, pFrame->maState.mnHeight); 426 } 427 } 428 } 429 430 // ----------------------------------------------------------------------- 431 432 long ImplSalCallbackDummy( void*, SalFrame*, USHORT, const void* ) 433 { 434 return 0; 435 } 436 437 // ----------------------------------------------------------------------- 438 439 static void ImplSalCalcFrameSize( HWND hWnd, 440 LONG& nFrameX, LONG& nFrameY, LONG& nCaptionY ) 441 { 442 Os2SalFrame* pFrame = GetWindowPtr( hWnd ); 443 if ( !pFrame ) 444 return; 445 return ImplSalCalcFrameSize( pFrame, nFrameX, nFrameY, nCaptionY ); 446 } 447 448 static void ImplSalCalcFrameSize( const Os2SalFrame* pFrame, 449 LONG& nFrameX, LONG& nFrameY, LONG& nCaptionY ) 450 { 451 if ( pFrame->mbSizeBorder ) 452 { 453 nFrameX = WinQuerySysValue( HWND_DESKTOP, SV_CXSIZEBORDER ); 454 nFrameY = WinQuerySysValue( HWND_DESKTOP, SV_CYSIZEBORDER ); 455 } 456 else if ( pFrame->mbFixBorder ) 457 { 458 nFrameX = WinQuerySysValue( HWND_DESKTOP, SV_CXDLGFRAME ); 459 nFrameY = WinQuerySysValue( HWND_DESKTOP, SV_CYDLGFRAME ); 460 } 461 else if ( pFrame->mbBorder ) 462 { 463 nFrameX = WinQuerySysValue( HWND_DESKTOP, SV_CXBORDER ); 464 nFrameY = WinQuerySysValue( HWND_DESKTOP, SV_CYBORDER ); 465 } 466 else 467 { 468 nFrameX = 0; 469 nFrameY = 0; 470 } 471 if ( pFrame->mbCaption ) 472 nCaptionY = WinQuerySysValue( HWND_DESKTOP, SV_CYTITLEBAR ); 473 else 474 nCaptionY = 0; 475 476 #if OSL_DEBUG_LEVEL>0 477 //if (_bCapture) 478 debug_printf("ImplSalCalcFrameSize 0x%08x x=%d y=%d t=%d\n", pFrame->mhWndFrame, nFrameX, nFrameY, nCaptionY); 479 #endif 480 } 481 482 // ----------------------------------------------------------------------- 483 484 static void ImplSalCalcFullScreenSize( const Os2SalFrame* pFrame, 485 LONG& rX, LONG& rY, LONG& rDX, LONG& rDY ) 486 { 487 // set window to screen size 488 LONG nFrameX, nFrameY, nCaptionY; 489 LONG rScreenDX = WinQuerySysValue( HWND_DESKTOP, SV_CXSCREEN ); 490 LONG rScreenDY = WinQuerySysValue( HWND_DESKTOP, SV_CYSCREEN ); 491 492 // Framegroessen berechnen 493 ImplSalCalcFrameSize( pFrame, nFrameX, nFrameY, nCaptionY ); 494 495 rX = -nFrameX; 496 rY = -(nFrameY+nCaptionY); 497 rDX = rScreenDX+(nFrameX*2); 498 rDY = rScreenDY+(nFrameY*2)+nCaptionY; 499 } 500 501 // ----------------------------------------------------------------------- 502 503 static void ImplSalFrameFullScreenPos( Os2SalFrame* pFrame, sal_Bool bAlways = FALSE ) 504 { 505 SWP aSWP; 506 _WinQueryWindowPos( pFrame, &aSWP ); 507 if ( bAlways || !(aSWP.fl & SWP_MINIMIZE) ) 508 { 509 // set window to screen size 510 LONG nX; 511 LONG nY; 512 LONG nWidth; 513 LONG nHeight; 514 ImplSalCalcFullScreenSize( pFrame, nX, nY, nWidth, nHeight ); 515 _WinSetWindowPos( pFrame, 0, 516 nX, nY, nWidth, nHeight, 517 SWP_MOVE | SWP_SIZE ); 518 } 519 } 520 521 // ----------------------------------------------------------------------- 522 523 // Uebersetzungstabelle von System-Keycodes in StarView-Keycodes 524 #define KEY_TAB_SIZE (VK_ENDDRAG+1) 525 526 static USHORT aImplTranslateKeyTab[KEY_TAB_SIZE] = 527 { 528 // StarView-Code System-Code Index 529 0, // 0x00 530 0, // VK_BUTTON1 0x01 531 0, // VK_BUTTON2 0x02 532 0, // VK_BUTTON3 0x03 533 0, // VK_BREAK 0x04 534 KEY_BACKSPACE, // VK_BACKSPACE 0x05 535 KEY_TAB, // VK_TAB 0x06 536 KEY_TAB, // VK_BACKTAB 0x07 537 KEY_RETURN, // VK_NEWLINE 0x08 538 0, // VK_SHIFT 0x09 539 0, // VK_CTRL 0x0A 540 0, // VK_ALT 0x0B 541 0, // VK_ALTGRAF 0x0C 542 0, // VK_PAUSE 0x0D 543 0, // VK_CAPSLOCK 0x0E 544 KEY_ESCAPE, // VK_ESC 0x0F 545 KEY_SPACE, // VK_SPACE 0x10 546 KEY_PAGEUP, // VK_PAGEUP 0x11 547 KEY_PAGEDOWN, // VK_PAGEDOWN 0x12 548 KEY_END, // VK_END 0x13 549 KEY_HOME, // VK_HOME 0x14 550 KEY_LEFT, // VK_LEFT 0x15 551 KEY_UP, // VK_UP 0x16 552 KEY_RIGHT, // VK_RIGHT 0x17 553 KEY_DOWN, // VK_DOWN 0x18 554 0, // VK_PRINTSCRN 0x19 555 KEY_INSERT, // VK_INSERT 0x1A 556 KEY_DELETE, // VK_DELETE 0x1B 557 0, // VK_SCRLLOCK 0x1C 558 0, // VK_NUMLOCK 0x1D 559 KEY_RETURN, // VK_ENTER 0x1E 560 0, // VK_SYSRQ 0x1F 561 KEY_F1, // VK_F1 0x20 562 KEY_F2, // VK_F2 0x21 563 KEY_F3, // VK_F3 0x22 564 KEY_F4, // VK_F4 0x23 565 KEY_F5, // VK_F5 0x24 566 KEY_F6, // VK_F6 0x25 567 KEY_F7, // VK_F7 0x26 568 KEY_F8, // VK_F8 0x27 569 KEY_F9, // VK_F9 0x28 570 KEY_F10, // VK_F10 0x29 571 KEY_F11, // VK_F11 0x2A 572 KEY_F12, // VK_F12 0x2B 573 KEY_F13, // VK_F13 0x2C 574 KEY_F14, // VK_F14 0x2D 575 KEY_F15, // VK_F15 0x2E 576 KEY_F16, // VK_F16 0x2F 577 KEY_F17, // VK_F17 0x30 578 KEY_F18, // VK_F18 0x31 579 KEY_F19, // VK_F19 0x32 580 KEY_F20, // VK_F20 0x33 581 KEY_F21, // VK_F21 0x34 582 KEY_F22, // VK_F22 0x35 583 KEY_F23, // VK_F23 0x36 584 KEY_F24, // VK_F24 0x37 585 0 // VK_ENDDRAG 0x38 586 }; 587 588 // ======================================================================= 589 590 SalFrame* ImplSalCreateFrame( Os2SalInstance* pInst, HWND hWndParent, ULONG nSalFrameStyle ) 591 { 592 SalData* pSalData = GetSalData(); 593 Os2SalFrame* pFrame = new Os2SalFrame; 594 HWND hWndFrame; 595 HWND hWndClient; 596 ULONG nFrameFlags = FCF_NOBYTEALIGN | FCF_SCREENALIGN; 597 ULONG nFrameStyle = 0; 598 ULONG nClientStyle = WS_CLIPSIBLINGS; 599 sal_Bool bSubFrame = FALSE; 600 601 #if OSL_DEBUG_LEVEL>0 602 debug_printf(">ImplSalCreateFrame hWndParent 0x%x, nSalFrameStyle 0x%x\n", hWndParent, nSalFrameStyle); 603 #endif 604 605 if ( hWndParent ) 606 { 607 bSubFrame = TRUE; 608 pFrame->mbNoIcon = TRUE; 609 } 610 611 // determine creation data (bei Moveable nehmen wir DLG-Border, damit 612 // es besser aussieht) 613 if ( nSalFrameStyle & SAL_FRAME_STYLE_CLOSEABLE ) 614 nFrameFlags |= FCF_CLOSEBUTTON; 615 616 if ( nSalFrameStyle & SAL_FRAME_STYLE_MOVEABLE ) { 617 pFrame->mbCaption = TRUE; 618 nFrameStyle = WS_ANIMATE; 619 nFrameFlags |= FCF_SYSMENU | FCF_TITLEBAR | FCF_DLGBORDER; 620 if ( !hWndParent ) 621 nFrameFlags |= FCF_MINBUTTON; 622 623 if ( nSalFrameStyle & SAL_FRAME_STYLE_SIZEABLE ) 624 { 625 pFrame->mbSizeBorder = TRUE; 626 nFrameFlags |= FCF_SIZEBORDER; 627 if ( !hWndParent ) 628 nFrameFlags |= FCF_MAXBUTTON; 629 } 630 else 631 pFrame->mbFixBorder = TRUE; 632 633 // add task list style if not a tool window 634 if ( !(nSalFrameStyle & SAL_FRAME_STYLE_TOOLWINDOW) ) { 635 nFrameFlags |= FCF_TASKLIST; 636 } 637 } 638 639 if( nSalFrameStyle & SAL_FRAME_STYLE_TOOLWINDOW ) 640 { 641 pFrame->mbNoIcon = TRUE; 642 // YD gives small caption -> nExSysStyle |= WS_EX_TOOLWINDOW; 643 } 644 645 if ( nSalFrameStyle & SAL_FRAME_STYLE_FLOAT ) 646 { 647 //nExSysStyle |= WS_EX_TOOLWINDOW; 648 pFrame->mbFloatWin = TRUE; 649 } 650 //if( nSalFrameStyle & SAL_FRAME_STYLE_TOOLTIP ) 651 // nExSysStyle |= WS_EX_TOPMOST; 652 653 // init frame data 654 pFrame->mnStyle = nSalFrameStyle; 655 656 // determine show style 657 pFrame->mnShowState = SWP_SHOWNORMAL; 658 659 // create frame 660 //YD FIXME this is a potential bug with multiple threads and cuncurrent 661 //window creation, because this field is accessed in 662 //WM_CREATE to get window data, 663 pSalData->mpCreateFrame = pFrame; 664 665 //YD FIXME if SAL_FRAME_CHILD is specified, use hWndParent as parent handle... 666 hWndFrame = WinCreateStdWindow( HWND_DESKTOP, nFrameStyle, &nFrameFlags, 667 (PSZ)(bSubFrame ? SAL_SUBFRAME_CLASSNAME : SAL_FRAME_CLASSNAME), 668 NULL, 669 nClientStyle, 0, 0, &hWndClient ); 670 debug_printf("ImplSalCreateFrame hWndParent 0x%x, hWndFrame 0x%x, hWndClient 0x%x\n", hWndParent, hWndFrame, hWndClient); 671 if ( !hWndFrame ) 672 { 673 delete pFrame; 674 return NULL; 675 } 676 677 // Parent setzen (Owner) 678 if ( hWndParent != 0 && hWndParent != HWND_DESKTOP ) 679 WinSetOwner( hWndFrame, hWndParent ); 680 681 Os2SalFrame* pParentFrame = GetWindowPtr( hWndParent ); 682 if ( pParentFrame ) 683 pFrame->mpParentFrame = pParentFrame; 684 685 // Icon setzen (YD win32 does it in the class registration) 686 if ( nFrameFlags & FCF_MINBUTTON ) 687 WinSendMsg( hWndFrame, WM_SETICON, (MPARAM)pInst->mhAppIcon, (MPARAM)0 ); 688 689 // If we have an Window with an Caption Bar and without 690 // an MaximizeBox, we change the SystemMenu 691 if ( (nFrameFlags & (FCF_TITLEBAR | FCF_MAXBUTTON)) == (FCF_TITLEBAR) ) 692 { 693 HWND hSysMenu = WinWindowFromID( hWndFrame, FID_SYSMENU ); 694 if ( hSysMenu ) 695 { 696 if ( !(nFrameFlags & (FCF_MINBUTTON | FCF_MAXBUTTON)) ) 697 WinEnableMenuItem(hSysMenu, SC_RESTORE, FALSE); 698 if ( !(nFrameFlags & FCF_MINBUTTON) ) 699 WinEnableMenuItem(hSysMenu, SC_MINIMIZE, FALSE); 700 if ( !(nFrameFlags & FCF_MAXBUTTON) ) 701 WinEnableMenuItem(hSysMenu, SC_MAXIMIZE, FALSE); 702 if ( !(nFrameFlags & FCF_SIZEBORDER) ) 703 WinEnableMenuItem(hSysMenu, SC_SIZE, FALSE); 704 } 705 } 706 if ( (nFrameFlags & FCF_SYSMENU) && !(nSalFrameStyle & SAL_FRAME_STYLE_CLOSEABLE) ) 707 { 708 HWND hSysMenu = WinWindowFromID( hWndFrame, FID_SYSMENU ); 709 if ( hSysMenu ) 710 { 711 WinEnableMenuItem(hSysMenu, SC_CLOSE, FALSE); 712 } 713 } 714 715 // ticket#124 subclass frame window: we need to intercept TRACK message 716 aSalShlData.mpFrameProc = WinSubclassWindow( hWndFrame, SalFrameSubClassWndProc); 717 718 // init OS/2 frame data 719 pFrame->mhAB = pInst->mhAB; 720 721 // YD 18/08 under OS/2, invisible frames have size 0,0 at 0,0, so 722 // we need to set an initial size/position manually 723 SWP aSWP; 724 memset( &aSWP, 0, sizeof( aSWP ) ); 725 WinQueryTaskSizePos( pInst->mhAB, 0, &aSWP ); 726 WinSetWindowPos( hWndFrame, NULL, aSWP.x, aSWP.y, aSWP.cx, aSWP.cy, 727 SWP_MOVE | SWP_SIZE); 728 729 #ifdef ENABLE_IME 730 // Input-Context einstellen 731 SalIMEData* pIMEData = GetSalIMEData(); 732 if ( pIMEData ) 733 { 734 pFrame->mhIMEContext = 0; 735 if ( 0 != pIMEData->mpAssocIME( hWndClient, pFrame->mhIMEContext, &pFrame->mhDefIMEContext ) ) 736 pFrame->mhDefIMEContext = 0; 737 } 738 else 739 { 740 pFrame->mhIMEContext = 0; 741 pFrame->mhDefIMEContext = 0; 742 } 743 #endif 744 745 RECTL rectl; 746 _WinQueryWindowRect( hWndClient, &rectl ); 747 pFrame->mnWidth = rectl.xRight; 748 pFrame->mnHeight = rectl.yBottom; 749 debug_printf( "ImplSalCreateFrame %dx%d\n", pFrame->mnWidth, pFrame->mnHeight); 750 ImplSaveFrameState( pFrame ); 751 pFrame->mbDefPos = TRUE; 752 753 UpdateFrameGeometry( hWndFrame, pFrame ); 754 755 if( pFrame->mnShowState == SWP_SHOWMAXIMIZED ) 756 { 757 // #96084 set a useful internal window size because 758 // the window will not be maximized (and the size updated) before show() 759 SetMaximizedFrameGeometry( hWndFrame, pFrame ); 760 } 761 762 #if OSL_DEBUG_LEVEL > 1 763 dumpWindowInfo( "<ImplSalCreateFrame (exit)", hWndFrame); 764 #endif 765 766 return pFrame; 767 } 768 769 // ======================================================================= 770 771 Os2SalFrame::Os2SalFrame() 772 { 773 SalData* pSalData = GetSalData(); 774 775 mbGraphics = NULL; 776 mhPointer = WinQuerySysPointer( HWND_DESKTOP, SPTR_ARROW, FALSE ); 777 mpGraphics = NULL; 778 mpInst = NULL; 779 mbFullScreen = FALSE; 780 mbAllwayOnTop = FALSE; 781 mbVisible = FALSE; 782 mbMinHide = FALSE; 783 mbInShow = FALSE; 784 mbRestoreMaximize = FALSE; 785 mbInMoveMsg = FALSE; 786 mbInSizeMsg = FALSE; 787 mbDefPos = TRUE; 788 mbOverwriteState = TRUE; 789 mbHandleIME = FALSE; 790 mbConversionMode = FALSE; 791 mbCandidateMode = FALSE; 792 mbCaption = FALSE; 793 //mhDefIMEContext = 0; 794 mpGraphics = NULL; 795 mnShowState = SWP_SHOWNORMAL; 796 mnWidth = 0; 797 mnHeight = 0; 798 mnMinWidth = 0; 799 mnMinHeight = 0; 800 mnMaxWidth = SHRT_MAX; 801 mnMaxHeight = SHRT_MAX; 802 mnInputLang = 0; 803 mnKeyboardHandle = 0; 804 mbGraphics = FALSE; 805 mbCaption = FALSE; 806 mbBorder = FALSE; 807 mbFixBorder = FALSE; 808 mbSizeBorder = FALSE; 809 mbFullScreen = FALSE; 810 //mbPresentation = FALSE; 811 mbInShow = FALSE; 812 mbRestoreMaximize = FALSE; 813 mbInMoveMsg = FALSE; 814 mbInSizeMsg = FALSE; 815 //mbFullScreenToolWin = FALSE; 816 mbDefPos = TRUE; 817 mbOverwriteState = TRUE; 818 //mbIME = FALSE; 819 mbHandleIME = FALSE; 820 //mbSpezIME = FALSE; 821 //mbAtCursorIME = FALSE; 822 mbCandidateMode = FALSE; 823 mbFloatWin = FALSE; 824 mbNoIcon = FALSE; 825 //mSelectedhMenu = 0; 826 //mLastActivatedhMenu = 0; 827 mpParentFrame = NULL; 828 829 memset( &maState, 0, sizeof( SalFrameState ) ); 830 maSysData.nSize = sizeof( SystemEnvData ); 831 memset( &maGeometry, 0, sizeof( maGeometry ) ); 832 833 // insert frame in framelist 834 mpNextFrame = pSalData->mpFirstFrame; 835 pSalData->mpFirstFrame = this; 836 } 837 838 // ----------------------------------------------------------------------- 839 840 Os2SalFrame::~Os2SalFrame() 841 { 842 SalData* pSalData = GetSalData(); 843 844 // destroy DC 845 if ( mpGraphics ) 846 { 847 ImplSalDeInitGraphics( mpGraphics ); 848 WinReleasePS( mpGraphics->mhPS ); 849 delete mpGraphics; 850 } 851 852 // destroy system frame 853 WinDestroyWindow( mhWndFrame ); 854 855 // remove frame from framelist 856 if ( this == pSalData->mpFirstFrame ) 857 pSalData->mpFirstFrame = mpNextFrame; 858 else 859 { 860 Os2SalFrame* pTempFrame = pSalData->mpFirstFrame; 861 while ( pTempFrame->mpNextFrame != this ) 862 pTempFrame = pTempFrame->mpNextFrame; 863 864 pTempFrame->mpNextFrame = mpNextFrame; 865 } 866 } 867 868 // ----------------------------------------------------------------------- 869 870 static HDC ImplWinGetDC( HWND hWnd ) 871 { 872 HDC hDC = WinQueryWindowDC( hWnd ); 873 if ( !hDC ) 874 hDC = WinOpenWindowDC( hWnd ); 875 return hDC; 876 } 877 878 // ----------------------------------------------------------------------- 879 880 SalGraphics* Os2SalFrame::GetGraphics() 881 { 882 if ( mbGraphics ) 883 return NULL; 884 885 if ( !mpGraphics ) 886 { 887 SalData* pSalData = GetSalData(); 888 mpGraphics = new Os2SalGraphics; 889 mpGraphics->mhPS = WinGetPS( mhWndClient ); 890 mpGraphics->mhDC = ImplWinGetDC( mhWndClient ); 891 mpGraphics->mhWnd = mhWndClient; 892 mpGraphics->mnHeight = mnHeight; 893 mpGraphics->mbPrinter = FALSE; 894 mpGraphics->mbVirDev = FALSE; 895 mpGraphics->mbWindow = TRUE; 896 mpGraphics->mbScreen = TRUE; 897 ImplSalInitGraphics( mpGraphics ); 898 mbGraphics = TRUE; 899 } 900 else 901 mbGraphics = TRUE; 902 903 return mpGraphics; 904 } 905 906 // ----------------------------------------------------------------------- 907 908 void Os2SalFrame::ReleaseGraphics( SalGraphics* ) 909 { 910 mbGraphics = FALSE; 911 } 912 913 // ----------------------------------------------------------------------- 914 915 sal_Bool Os2SalFrame::PostEvent( void* pData ) 916 { 917 return (sal_Bool)WinPostMsg( mhWndClient, SAL_MSG_USEREVENT, 0, (MPARAM)pData ); 918 } 919 920 // ----------------------------------------------------------------------- 921 922 void Os2SalFrame::SetTitle( const XubString& rTitle ) 923 { 924 // set window title 925 ByteString title( rTitle, gsl_getSystemTextEncoding() ); 926 debug_printf("Os2SalFrame::SetTitle %x '%s'\n", mhWndFrame, title.GetBuffer() ); 927 WinSetWindowText( mhWndFrame, title.GetBuffer() ); 928 } 929 930 // ----------------------------------------------------------------------- 931 932 void Os2SalFrame::SetIcon( USHORT nIcon ) 933 { 934 debug_printf("Os2SalFrame::SetIcon\n"); 935 936 // If we have a window without an Icon (for example a dialog), ignore this call 937 if ( mbNoIcon ) 938 return; 939 940 // 0 means default (class) icon 941 HPOINTER hIcon = NULL; 942 if ( !nIcon ) 943 nIcon = 1; 944 945 ImplLoadSalIcon( nIcon, hIcon ); 946 947 DBG_ASSERT( hIcon , "Os2SalFrame::SetIcon(): Could not load icon !" ); 948 949 // Icon setzen 950 WinSendMsg( mhWndFrame, WM_SETICON, (MPARAM)hIcon, (MPARAM)0 ); 951 } 952 953 // ----------------------------------------------------------------------- 954 955 SalFrame* Os2SalFrame::GetParent() const 956 { 957 //debug_printf("Os2SalFrame::GetParent\n"); 958 return GetWindowPtr( WinQueryWindow(mhWndFrame, QW_OWNER) ); 959 } 960 961 // ----------------------------------------------------------------------- 962 963 static void ImplSalShow( HWND hWnd, ULONG bVisible, ULONG bNoActivate ) 964 { 965 Os2SalFrame* pFrame = GetWindowPtr( hWnd ); 966 if ( !pFrame ) 967 return; 968 969 if ( bVisible ) 970 { 971 pFrame->mbDefPos = FALSE; 972 pFrame->mbOverwriteState = TRUE; 973 pFrame->mbInShow = TRUE; 974 975 #if OSL_DEBUG_LEVEL > 0 976 debug_printf( "ImplSalShow hwnd %x visible flag %d, no activate: flag %d\n", hWnd, bVisible, bNoActivate); 977 #endif 978 979 if( bNoActivate ) 980 WinSetWindowPos(hWnd, NULL, 0, 0, 0, 0, SWP_SHOW); 981 else 982 WinSetWindowPos(hWnd, NULL, 0, 0, 0, 0, pFrame->mnShowState); 983 984 pFrame->mbInShow = FALSE; 985 986 // Direct Paint only, if we get the SolarMutx 987 if ( ImplSalYieldMutexTryToAcquire() ) 988 { 989 WinUpdateWindow( hWnd ); 990 ImplSalYieldMutexRelease(); 991 } 992 } 993 else 994 { 995 #if OSL_DEBUG_LEVEL > 0 996 debug_printf( "ImplSalShow hwnd %x HIDE\n"); 997 #endif 998 WinSetWindowPos(hWnd, NULL, 0, 0, 0, 0, SWP_HIDE); 999 } 1000 } 1001 1002 1003 // ----------------------------------------------------------------------- 1004 1005 1006 void Os2SalFrame::SetExtendedFrameStyle( SalExtStyle nExtStyle ) 1007 { 1008 } 1009 1010 // ----------------------------------------------------------------------- 1011 1012 void Os2SalFrame::Show( sal_Bool bVisible, sal_Bool bNoActivate ) 1013 { 1014 // Post this Message to the window, because this only works 1015 // in the thread of the window, which has create this window. 1016 // We post this message to avoid deadlocks 1017 if ( GetSalData()->mnAppThreadId != GetCurrentThreadId() ) 1018 WinPostMsg( mhWndFrame, SAL_MSG_SHOW, (MPARAM)bVisible, (MPARAM)bNoActivate ); 1019 else 1020 ImplSalShow( mhWndFrame, bVisible, bNoActivate ); 1021 } 1022 1023 // ----------------------------------------------------------------------- 1024 1025 void Os2SalFrame::Enable( sal_Bool bEnable ) 1026 { 1027 WinEnableWindow( mhWndFrame, bEnable ); 1028 } 1029 1030 // ----------------------------------------------------------------------- 1031 1032 void Os2SalFrame::SetMinClientSize( long nWidth, long nHeight ) 1033 { 1034 debug_printf("Os2SalFrame::SetMinClientSize\n"); 1035 mnMinWidth = nWidth; 1036 mnMinHeight = nHeight; 1037 } 1038 1039 void Os2SalFrame::SetMaxClientSize( long nWidth, long nHeight ) 1040 { 1041 debug_printf("Os2SalFrame::SetMaxClientSize\n"); 1042 mnMaxWidth = nWidth; 1043 mnMaxHeight = nHeight; 1044 } 1045 1046 // ----------------------------------------------------------------------- 1047 1048 void Os2SalFrame::SetPosSize( long nX, long nY, long nWidth, long nHeight, 1049 USHORT nFlags ) 1050 { 1051 // calculation frame size 1052 USHORT nEvent = 0; 1053 ULONG nPosFlags = 0; 1054 1055 #if OSL_DEBUG_LEVEL > 0 1056 //dumpWindowInfo( "-Os2SalFrame::SetPosSize", mhWndFrame); 1057 debug_printf( ">Os2SalFrame::SetPosSize go to %d,%d (%dx%d) VCL\n",nX,nY,nWidth,nHeight); 1058 #endif 1059 1060 SWP aSWP; 1061 _WinQueryWindowPos( this, &aSWP ); 1062 sal_Bool bVisible = WinIsWindowVisible( mhWndFrame ); 1063 if ( !bVisible ) 1064 { 1065 if ( mbFloatWin ) 1066 mnShowState = SWP_SHOW; 1067 else 1068 mnShowState = SWP_SHOWNORMAL; 1069 } 1070 else 1071 { 1072 if ( (aSWP.fl & SWP_MINIMIZE) || (aSWP.fl & SWP_MAXIMIZE) ) 1073 WinSetWindowPos(mhWndFrame, NULL, 0, 0, 0, 0, SWP_RESTORE ); 1074 } 1075 1076 if ( (nFlags & (SAL_FRAME_POSSIZE_X | SAL_FRAME_POSSIZE_Y)) ) { 1077 nPosFlags |= SWP_MOVE; 1078 #if OSL_DEBUG_LEVEL > 0 1079 debug_printf( "-Os2SalFrame::SetPosSize MOVE to %d,%d\n", nX, nY); 1080 #endif 1081 //DBG_ASSERT( nX && nY, " Windowposition of (0,0) requested!" ); 1082 nEvent = SALEVENT_MOVE; 1083 } 1084 1085 if ( (nFlags & (SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT)) ) { 1086 nPosFlags |= SWP_SIZE; 1087 #if OSL_DEBUG_LEVEL > 0 1088 debug_printf( "-Os2SalFrame::SetPosSize SIZE to %d,%d\n", nWidth,nHeight); 1089 #endif 1090 nEvent = (nEvent == SALEVENT_MOVE) ? SALEVENT_MOVERESIZE : SALEVENT_RESIZE; 1091 } 1092 1093 // Default-Position, dann zentrieren, ansonsten Position beibehalten 1094 if ( mbDefPos && !(nPosFlags & SWP_MOVE)) 1095 { 1096 // calculate bottom left corner of frame 1097 mbDefPos = FALSE; 1098 nPosFlags |= SWP_MOVE | SWP_CENTER; 1099 nEvent = SALEVENT_MOVERESIZE; 1100 #if OSL_DEBUG_LEVEL > 10 1101 debug_printf( "-Os2SalFrame::SetPosSize CENTER\n"); 1102 debug_printf( "-Os2SalFrame::SetPosSize default position to %d,%d\n", nX, nY); 1103 #endif 1104 } 1105 1106 // Adjust Window in the screen 1107 sal_Bool bCheckOffScreen = TRUE; 1108 1109 // but don't do this for floaters or ownerdraw windows that are currently moved interactively 1110 if( (mnStyle & SAL_FRAME_STYLE_FLOAT) && !(mnStyle & SAL_FRAME_STYLE_OWNERDRAWDECORATION) ) 1111 bCheckOffScreen = FALSE; 1112 1113 if( mnStyle & SAL_FRAME_STYLE_OWNERDRAWDECORATION ) 1114 { 1115 // may be the window is currently being moved (mouse is captured), then no check is required 1116 if( mhWndClient == WinQueryCapture( HWND_DESKTOP) ) 1117 bCheckOffScreen = FALSE; 1118 else 1119 bCheckOffScreen = TRUE; 1120 } 1121 1122 if( bCheckOffScreen ) 1123 { 1124 if ( nX+nWidth > nScreenWidth ) 1125 nX = nScreenWidth - nWidth; 1126 if ( nY+nHeight > nScreenHeight ) 1127 nY = nScreenHeight - nHeight; 1128 if ( nX < 0 ) 1129 nX = 0; 1130 if ( nY < 0 ) 1131 nY = 0; 1132 } 1133 1134 // bring floating windows always to top 1135 // do not change zorder, otherwise tooltips will bring main window to top (ticket:14) 1136 //if( (mnStyle & SAL_FRAME_STYLE_FLOAT) ) 1137 // nPosFlags |= SWP_ZORDER; // do not change z-order 1138 1139 // set new position 1140 _WinSetWindowPos( this, HWND_TOP, nX, nY, nWidth, nHeight, nPosFlags); // | SWP_RESTORE 1141 1142 UpdateFrameGeometry( mhWndFrame, this ); 1143 1144 // Notification -- really ??? 1145 if( nEvent ) 1146 CallCallback( nEvent, NULL ); 1147 1148 #if OSL_DEBUG_LEVEL > 0 1149 dumpWindowInfo( "<Os2SalFrame::SetPosSize (exit)", mhWndFrame); 1150 #endif 1151 1152 } 1153 1154 // ----------------------------------------------------------------------- 1155 1156 void Os2SalFrame::SetParent( SalFrame* pNewParent ) 1157 { 1158 APIRET rc; 1159 #if OSL_DEBUG_LEVEL>0 1160 debug_printf("Os2SalFrame::SetParent mhWndFrame 0x%08x to 0x%08x\n", 1161 static_cast<Os2SalFrame*>(this)->mhWndFrame, 1162 static_cast<Os2SalFrame*>(pNewParent)->mhWndClient); 1163 #endif 1164 Os2SalFrame::mbInReparent = TRUE; 1165 //rc = WinSetParent(static_cast<Os2SalFrame*>(this)->mhWndFrame, 1166 // static_cast<Os2SalFrame*>(pNewParent)->mhWndClient, TRUE); 1167 rc = WinSetOwner(static_cast<Os2SalFrame*>(this)->mhWndFrame, 1168 static_cast<Os2SalFrame*>(pNewParent)->mhWndClient); 1169 mpParentFrame = static_cast<Os2SalFrame*>(pNewParent); 1170 Os2SalFrame::mbInReparent = FALSE; 1171 } 1172 1173 bool Os2SalFrame::SetPluginParent( SystemParentData* pNewParent ) 1174 { 1175 APIRET rc; 1176 if ( pNewParent->hWnd == 0 ) 1177 { 1178 pNewParent->hWnd = HWND_DESKTOP; 1179 } 1180 1181 Os2SalFrame::mbInReparent = TRUE; 1182 rc = WinSetOwner(static_cast<Os2SalFrame*>(this)->mhWndFrame, 1183 pNewParent->hWnd); 1184 Os2SalFrame::mbInReparent = FALSE; 1185 return true; 1186 } 1187 1188 1189 // ----------------------------------------------------------------------- 1190 1191 void Os2SalFrame::GetWorkArea( RECTL &rRect ) 1192 { 1193 rRect.xLeft = rRect.yTop = 0; 1194 rRect.xRight = WinQuerySysValue( HWND_DESKTOP, SV_CXSCREEN )-1; 1195 rRect.yBottom = WinQuerySysValue( HWND_DESKTOP, SV_CYSCREEN )-1; 1196 } 1197 1198 // ----------------------------------------------------------------------- 1199 1200 void Os2SalFrame::GetWorkArea( Rectangle &rRect ) 1201 { 1202 RECTL aRect; 1203 GetWorkArea( aRect); 1204 rRect.nLeft = aRect.xLeft; 1205 rRect.nRight = aRect.xRight; // win -1; 1206 rRect.nTop = aRect.yTop; 1207 rRect.nBottom = aRect.yBottom; // win -1; 1208 } 1209 1210 // ----------------------------------------------------------------------- 1211 1212 void Os2SalFrame::GetClientSize( long& rWidth, long& rHeight ) 1213 { 1214 rWidth = maGeometry.nWidth; 1215 rHeight = maGeometry.nHeight; 1216 } 1217 1218 // ----------------------------------------------------------------------- 1219 1220 void Os2SalFrame::SetWindowState( const SalFrameState* pState ) 1221 { 1222 LONG nX; 1223 LONG nY; 1224 LONG nWidth; 1225 LONG nHeight; 1226 ULONG nPosSize = 0; 1227 1228 #if OSL_DEBUG_LEVEL>0 1229 debug_printf("Os2SalFrame::SetWindowState\n"); 1230 debug_printf("Os2SalFrame::SetWindowState %08x (%dx%d) at %d,%d VCL\n", 1231 mhWndFrame, 1232 pState->mnWidth,pState->mnHeight,pState->mnX,pState->mnY); 1233 #endif 1234 1235 sal_Bool bVisible = WinIsWindowVisible( mhWndFrame ); 1236 1237 // get screen coordinates 1238 SWP aSWP; 1239 WinQueryWindowPos( mhWndFrame, &aSWP ); 1240 LONG nFrameX, nFrameY, nCaptionY; 1241 ImplSalCalcFrameSize( this, nFrameX, nFrameY, nCaptionY ); 1242 1243 long nTopDeco = nFrameY + nCaptionY; 1244 long nLeftDeco = nFrameX; 1245 long nBottomDeco = nFrameY; 1246 long nRightDeco = nFrameX; 1247 1248 // Fenster-Position/Groesse in den Bildschirm einpassen 1249 if ((pState->mnMask & (SAL_FRAMESTATE_MASK_X | SAL_FRAMESTATE_MASK_Y)) ) 1250 nPosSize |= SWP_MOVE; 1251 if ((pState->mnMask & (SAL_FRAMESTATE_MASK_WIDTH | SAL_FRAMESTATE_MASK_HEIGHT)) ) 1252 nPosSize |= SWP_SIZE; 1253 1254 if ( pState->mnMask & SAL_FRAMESTATE_MASK_X ) 1255 nX = (int)pState->mnX - nLeftDeco; 1256 else 1257 nX = aSWP.x; 1258 1259 // keep Y inverted since height is still unknown, will invert later 1260 if ( pState->mnMask & SAL_FRAMESTATE_MASK_Y ) 1261 nY = (int)pState->mnY - nTopDeco; 1262 else 1263 nY = nScreenHeight - (aSWP.y+aSWP.cy); 1264 1265 if ( pState->mnMask & SAL_FRAMESTATE_MASK_WIDTH ) 1266 nWidth = (int)pState->mnWidth + nLeftDeco + nRightDeco; 1267 else 1268 nWidth = aSWP.cx; 1269 if ( pState->mnMask & SAL_FRAMESTATE_MASK_HEIGHT ) 1270 nHeight = (int)pState->mnHeight + nTopDeco + nBottomDeco; 1271 else 1272 nHeight = aSWP.cy; 1273 1274 #if OSL_DEBUG_LEVEL>0 1275 debug_printf("Os2SalFrame::SetWindowState (%dx%d) at %d,%d\n", nWidth,nHeight,nX,nY); 1276 #endif 1277 1278 // Adjust Window in the screen: 1279 // if it does not fit into the screen do nothing, ie default pos/size will be used 1280 // if there is an overlap with the screen border move the window while keeping its size 1281 1282 //if( nWidth > nScreenWidth || nHeight > nScreenHeight ) 1283 // nPosSize |= (SWP_NOMOVE | SWP_NOSIZE); 1284 1285 if ( nX+nWidth > nScreenWidth ) 1286 nX = (nScreenWidth) - nWidth; 1287 if ( nY+nHeight > nScreenHeight ) 1288 nY = (nScreenHeight) - nHeight; 1289 if ( nX < 0 ) 1290 nX = 0; 1291 if ( nY < 0 ) 1292 nY = 0; 1293 1294 // Restore-Position setzen 1295 SWP aPlacement; 1296 WinQueryWindowPos( mhWndFrame, &aPlacement ); 1297 1298 // Status setzen 1299 bVisible = WinIsWindowVisible( mhWndFrame); 1300 sal_Bool bUpdateHiddenFramePos = FALSE; 1301 if ( !bVisible ) 1302 { 1303 aPlacement.fl = SWP_HIDE; 1304 1305 if ( mbOverwriteState ) 1306 { 1307 if ( pState->mnMask & SAL_FRAMESTATE_MASK_STATE ) 1308 { 1309 if ( pState->mnState & SAL_FRAMESTATE_MINIMIZED ) 1310 mnShowState = SWP_SHOWMINIMIZED; 1311 else if ( pState->mnState & SAL_FRAMESTATE_MAXIMIZED ) 1312 { 1313 mnShowState = SWP_SHOWMAXIMIZED; 1314 bUpdateHiddenFramePos = TRUE; 1315 } 1316 else if ( pState->mnState & SAL_FRAMESTATE_NORMAL ) 1317 mnShowState = SWP_SHOWNORMAL; 1318 } 1319 } 1320 } 1321 else 1322 { 1323 if ( pState->mnMask & SAL_FRAMESTATE_MASK_STATE ) 1324 { 1325 if ( pState->mnState & SAL_FRAMESTATE_MINIMIZED ) 1326 { 1327 //if ( pState->mnState & SAL_FRAMESTATE_MAXIMIZED ) 1328 // aPlacement.flags |= WPF_RESTORETOMAXIMIZED; 1329 aPlacement.fl = SWP_SHOWMINIMIZED; 1330 } 1331 else if ( pState->mnState & SAL_FRAMESTATE_MAXIMIZED ) 1332 aPlacement.fl = SWP_SHOWMAXIMIZED; 1333 else if ( pState->mnState & SAL_FRAMESTATE_NORMAL ) 1334 aPlacement.fl = SWP_RESTORE; 1335 } 1336 } 1337 1338 // Wenn Fenster nicht minimiert/maximiert ist oder nicht optisch 1339 // umgesetzt werden muss, dann SetWindowPos() benutzen, da 1340 // SetWindowPlacement() die TaskBar mit einrechnet 1341 if ( !(aPlacement.fl & SWP_MINIMIZE) 1342 && !( aPlacement.fl & SWP_MAXIMIZE ) 1343 && (!bVisible || (aPlacement.fl == SWP_RESTORE)) ) 1344 { 1345 if( bUpdateHiddenFramePos ) 1346 { 1347 // #96084 set a useful internal window size because 1348 // the window will not be maximized (and the size updated) before show() 1349 SetMaximizedFrameGeometry( mhWndFrame, this ); 1350 } 1351 else 1352 WinSetWindowPos( mhWndFrame, 0, nX, 1353 nScreenHeight - (nY+nHeight), nWidth, nHeight, nPosSize); 1354 } 1355 else 1356 { 1357 if( (nPosSize & (SWP_MOVE|SWP_SIZE)) ) 1358 { 1359 aPlacement.x = nX; 1360 aPlacement.y = nScreenHeight-(nY+nHeight); 1361 aPlacement.cx = nWidth; 1362 aPlacement.cy = nHeight; 1363 } 1364 WinSetWindowPos( mhWndFrame, 0, aPlacement.x, aPlacement.y, 1365 aPlacement.cx, aPlacement.cy, aPlacement.fl ); 1366 } 1367 1368 #if OSL_DEBUG_LEVEL>0 1369 debug_printf("Os2SalFrame::SetWindowState DONE\n"); 1370 #endif 1371 } 1372 1373 // ----------------------------------------------------------------------- 1374 1375 sal_Bool Os2SalFrame::GetWindowState( SalFrameState* pState ) 1376 { 1377 if ( maState.mnWidth && maState.mnHeight ) 1378 { 1379 *pState = maState; 1380 // #94144# allow Minimize again, should be masked out when read from configuration 1381 // 91625 - Don't save minimize 1382 //if ( !(pState->mnState & SAL_FRAMESTATE_MAXIMIZED) ) 1383 if ( !(pState->mnState & (SAL_FRAMESTATE_MINIMIZED | SAL_FRAMESTATE_MAXIMIZED)) ) 1384 pState->mnState |= SAL_FRAMESTATE_NORMAL; 1385 return TRUE; 1386 } 1387 1388 return FALSE; 1389 } 1390 1391 // ----------------------------------------------------------------------- 1392 1393 void Os2SalFrame::SetScreenNumber( unsigned int nNewScreen ) 1394 { 1395 #if 0 1396 WinSalSystem* pSys = static_cast<WinSalSystem*>(ImplGetSalSystem()); 1397 if( pSys ) 1398 { 1399 const std::vector<WinSalSystem::DisplayMonitor>& rMonitors = 1400 pSys->getMonitors(); 1401 size_t nMon = rMonitors.size(); 1402 if( nNewScreen < nMon ) 1403 { 1404 Point aOldMonPos, aNewMonPos( rMonitors[nNewScreen].m_aArea.TopLeft() ); 1405 Point aCurPos( maGeometry.nX, maGeometry.nY ); 1406 for( size_t i = 0; i < nMon; i++ ) 1407 { 1408 if( rMonitors[i].m_aArea.IsInside( aCurPos ) ) 1409 { 1410 aOldMonPos = rMonitors[i].m_aArea.TopLeft(); 1411 break; 1412 } 1413 } 1414 mnDisplay = nNewScreen; 1415 maGeometry.nScreenNumber = nNewScreen; 1416 SetPosSize( aNewMonPos.X() + (maGeometry.nX - aOldMonPos.X()), 1417 aNewMonPos.Y() + (maGeometry.nY - aOldMonPos.Y()), 1418 0, 0, 1419 SAL_FRAME_POSSIZE_X | SAL_FRAME_POSSIZE_Y ); 1420 } 1421 } 1422 #endif 1423 } 1424 1425 // ----------------------------------------------------------------------- 1426 1427 // native menu implementation - currently empty 1428 void Os2SalFrame::DrawMenuBar() 1429 { 1430 } 1431 1432 void Os2SalFrame::SetMenu( SalMenu* pSalMenu ) 1433 { 1434 } 1435 1436 // ----------------------------------------------------------------------- 1437 1438 void Os2SalFrame::ShowFullScreen( sal_Bool bFullScreen, sal_Int32 nDisplay ) 1439 { 1440 if ( mbFullScreen == bFullScreen ) 1441 return; 1442 1443 mbFullScreen = bFullScreen; 1444 if ( bFullScreen ) 1445 { 1446 // save old position 1447 memset( &maFullScreenRect, 0, sizeof( SWP ) ); 1448 _WinQueryWindowPos( this, &maFullScreenRect ); 1449 1450 // set window to screen size 1451 ImplSalFrameFullScreenPos( this, TRUE ); 1452 } 1453 else 1454 { 1455 _WinSetWindowPos( this, 1456 0, 1457 maFullScreenRect.x, maFullScreenRect.y, 1458 maFullScreenRect.cx, maFullScreenRect.cy, 1459 SWP_MOVE | SWP_SIZE ); 1460 } 1461 } 1462 1463 // ----------------------------------------------------------------------- 1464 1465 void Os2SalFrame::StartPresentation( sal_Bool bStart ) 1466 { 1467 // SysSetObjectData("<WP_DESKTOP>","Autolockup=no"); oder OS2.INI: PM_Lockup 1468 } 1469 1470 // ----------------------------------------------------------------------- 1471 1472 void Os2SalFrame::SetAlwaysOnTop( sal_Bool bOnTop ) 1473 { 1474 mbAllwayOnTop = bOnTop; 1475 #if 0 1476 HWND hWnd; 1477 if ( bOnTop ) 1478 hWnd = HWND_TOPMOST; 1479 else 1480 hWnd = HWND_NOTOPMOST; 1481 SetWindowPos( mhWnd, hWnd, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE ); 1482 #endif 1483 } 1484 1485 1486 // ----------------------------------------------------------------------- 1487 1488 static void ImplSalToTop( HWND hWnd, ULONG nFlags ) 1489 { 1490 Os2SalFrame* pFrame = GetWindowPtr( hWnd ); 1491 #if OSL_DEBUG_LEVEL>0 1492 debug_printf("ImplSalToTop hWnd %08x, nFlags %x\n", hWnd, nFlags); 1493 #endif 1494 1495 // if window is minimized, first restore it 1496 SWP aSWP; 1497 WinQueryWindowPos( hWnd, &aSWP ); 1498 if ( aSWP.fl & SWP_MINIMIZE ) 1499 WinSetWindowPos( hWnd, NULL, 0, 0, 0, 0, SWP_RESTORE ); 1500 1501 if ( nFlags & SAL_FRAME_TOTOP_FOREGROUNDTASK ) 1502 WinSetWindowPos( pFrame->mhWndFrame, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE | SWP_ZORDER); 1503 1504 if ( nFlags & SAL_FRAME_TOTOP_RESTOREWHENMIN ) 1505 { 1506 ULONG nStyle; 1507 if ( pFrame->mbRestoreMaximize ) 1508 nStyle = SWP_MAXIMIZE; 1509 else 1510 nStyle = SWP_RESTORE; 1511 1512 WinSetWindowPos( pFrame->mhWndFrame, NULL, 0, 0, 0, 0, nStyle ); 1513 } 1514 WinSetFocus( HWND_DESKTOP, pFrame->mhWndClient ); 1515 } 1516 1517 // ----------------------------------------------------------------------- 1518 1519 void Os2SalFrame::ToTop( USHORT nFlags ) 1520 { 1521 nFlags &= ~SAL_FRAME_TOTOP_GRABFOCUS; // this flag is not needed on win32 1522 // Post this Message to the window, because this only works 1523 // in the thread of the window, which has create this window. 1524 // We post this message to avoid deadlocks 1525 if ( GetSalData()->mnAppThreadId != GetCurrentThreadId() ) 1526 WinPostMsg( mhWndFrame, SAL_MSG_TOTOP, (MPARAM)nFlags, 0 ); 1527 else 1528 ImplSalToTop( mhWndFrame, nFlags ); 1529 } 1530 1531 // ----------------------------------------------------------------------- 1532 1533 void Os2SalFrame::SetPointer( PointerStyle ePointerStyle ) 1534 { 1535 struct ImplPtrData 1536 { 1537 HPOINTER mhPointer; 1538 ULONG mnSysId; 1539 ULONG mnOwnId; 1540 }; 1541 1542 static ImplPtrData aImplPtrTab[POINTER_COUNT] = 1543 { 1544 { 0, SPTR_ARROW, 0 }, // POINTER_ARROW 1545 { 0, 0, SAL_RESID_POINTER_NULL }, // POINTER_NULL 1546 { 0, SPTR_WAIT, 0 }, // POINTER_WAIT 1547 { 0, SPTR_TEXT, 0 }, // POINTER_BEAM 1548 { 0, 0, SAL_RESID_POINTER_HELP }, // POINTER_HELP 1549 { 0, 0, SAL_RESID_POINTER_CROSS }, // POINTER_CROSS 1550 { 0, 0, SAL_RESID_POINTER_MOVE }, // POINTER_MOVE 1551 { 0, SPTR_SIZENS, 0 }, // POINTER_NSIZE 1552 { 0, SPTR_SIZENS, 0 }, // POINTER_SSIZE 1553 { 0, SPTR_SIZEWE, 0 }, // POINTER_WSIZE 1554 { 0, SPTR_SIZEWE, 0 }, // POINTER_ESIZE 1555 { 0, SPTR_SIZENWSE, 0 }, // POINTER_NWSIZE 1556 { 0, SPTR_SIZENESW, 0 }, // POINTER_NESIZE 1557 { 0, SPTR_SIZENESW, 0 }, // POINTER_SWSIZE 1558 { 0, SPTR_SIZENWSE, 0 }, // POINTER_SESIZE 1559 { 0, SPTR_SIZENS, 0 }, // POINTER_WINDOW_NSIZE 1560 { 0, SPTR_SIZENS, 0 }, // POINTER_WINDOW_SSIZE 1561 { 0, SPTR_SIZEWE, 0 }, // POINTER_WINDOW_WSIZE 1562 { 0, SPTR_SIZEWE, 0 }, // POINTER_WINDOW_ESIZE 1563 { 0, SPTR_SIZENWSE, 0 }, // POINTER_WINDOW_NWSIZE 1564 { 0, SPTR_SIZENESW, 0 }, // POINTER_WINDOW_NESIZE 1565 { 0, SPTR_SIZENESW, 0 }, // POINTER_WINDOW_SWSIZE 1566 { 0, SPTR_SIZENWSE, 0 }, // POINTER_WINDOW_SESIZE 1567 { 0, 0, SAL_RESID_POINTER_HSPLIT }, // POINTER_HSPLIT 1568 { 0, 0, SAL_RESID_POINTER_VSPLIT }, // POINTER_VSPLIT 1569 { 0, 0, SAL_RESID_POINTER_HSIZEBAR }, // POINTER_HSIZEBAR 1570 { 0, 0, SAL_RESID_POINTER_VSIZEBAR }, // POINTER_VSIZEBAR 1571 { 0, 0, SAL_RESID_POINTER_HAND }, // POINTER_HAND 1572 { 0, 0, SAL_RESID_POINTER_REFHAND }, // POINTER_REFHAND 1573 { 0, 0, SAL_RESID_POINTER_PEN }, // POINTER_PEN 1574 { 0, 0, SAL_RESID_POINTER_MAGNIFY }, // POINTER_MAGNIFY 1575 { 0, 0, SAL_RESID_POINTER_FILL }, // POINTER_FILL 1576 { 0, 0, SAL_RESID_POINTER_ROTATE }, // POINTER_ROTATE 1577 { 0, 0, SAL_RESID_POINTER_HSHEAR }, // POINTER_HSHEAR 1578 { 0, 0, SAL_RESID_POINTER_VSHEAR }, // POINTER_VSHEAR 1579 { 0, 0, SAL_RESID_POINTER_MIRROR }, // POINTER_MIRROR 1580 { 0, 0, SAL_RESID_POINTER_CROOK }, // POINTER_CROOK 1581 { 0, 0, SAL_RESID_POINTER_CROP }, // POINTER_CROP 1582 { 0, 0, SAL_RESID_POINTER_MOVEPOINT }, // POINTER_MOVEPOINT 1583 { 0, 0, SAL_RESID_POINTER_MOVEBEZIERWEIGHT }, // POINTER_MOVEBEZIERWEIGHT 1584 { 0, 0, SAL_RESID_POINTER_MOVEDATA }, // POINTER_MOVEDATA 1585 { 0, 0, SAL_RESID_POINTER_COPYDATA }, // POINTER_COPYDATA 1586 { 0, 0, SAL_RESID_POINTER_LINKDATA }, // POINTER_LINKDATA 1587 { 0, 0, SAL_RESID_POINTER_MOVEDATALINK }, // POINTER_MOVEDATALINK 1588 { 0, 0, SAL_RESID_POINTER_COPYDATALINK }, // POINTER_COPYDATALINK 1589 { 0, 0, SAL_RESID_POINTER_MOVEFILE }, // POINTER_MOVEFILE 1590 { 0, 0, SAL_RESID_POINTER_COPYFILE }, // POINTER_COPYFILE 1591 { 0, 0, SAL_RESID_POINTER_LINKFILE }, // POINTER_LINKFILE 1592 { 0, 0, SAL_RESID_POINTER_MOVEFILELINK }, // POINTER_MOVEFILELINK 1593 { 0, 0, SAL_RESID_POINTER_COPYFILELINK }, // POINTER_COPYFILELINK 1594 { 0, 0, SAL_RESID_POINTER_MOVEFILES }, // POINTER_MOVEFILES 1595 { 0, 0, SAL_RESID_POINTER_COPYFILES }, // POINTER_COPYFILES 1596 { 0, SPTR_ILLEGAL, 0 }, // POINTER_NOTALLOWED 1597 { 0, 0, SAL_RESID_POINTER_DRAW_LINE }, // POINTER_DRAW_LINE 1598 { 0, 0, SAL_RESID_POINTER_DRAW_RECT }, // POINTER_DRAW_RECT 1599 { 0, 0, SAL_RESID_POINTER_DRAW_POLYGON }, // POINTER_DRAW_POLYGON 1600 { 0, 0, SAL_RESID_POINTER_DRAW_BEZIER }, // POINTER_DRAW_BEZIER 1601 { 0, 0, SAL_RESID_POINTER_DRAW_ARC }, // POINTER_DRAW_ARC 1602 { 0, 0, SAL_RESID_POINTER_DRAW_PIE }, // POINTER_DRAW_PIE 1603 { 0, 0, SAL_RESID_POINTER_DRAW_CIRCLECUT }, // POINTER_DRAW_CIRCLECUT 1604 { 0, 0, SAL_RESID_POINTER_DRAW_ELLIPSE }, // POINTER_DRAW_ELLIPSE 1605 { 0, 0, SAL_RESID_POINTER_DRAW_FREEHAND }, // POINTER_DRAW_FREEHAND 1606 { 0, 0, SAL_RESID_POINTER_DRAW_CONNECT }, // POINTER_DRAW_CONNECT 1607 { 0, 0, SAL_RESID_POINTER_DRAW_TEXT }, // POINTER_DRAW_TEXT 1608 { 0, 0, SAL_RESID_POINTER_DRAW_CAPTION }, // POINTER_DRAW_CAPTION 1609 { 0, 0, SAL_RESID_POINTER_CHART }, // POINTER_CHART 1610 { 0, 0, SAL_RESID_POINTER_DETECTIVE }, // POINTER_DETECTIVE 1611 { 0, 0, SAL_RESID_POINTER_PIVOT_COL }, // POINTER_PIVOT_COL 1612 { 0, 0, SAL_RESID_POINTER_PIVOT_ROW }, // POINTER_PIVOT_ROW 1613 { 0, 0, SAL_RESID_POINTER_PIVOT_FIELD }, // POINTER_PIVOT_FIELD 1614 { 0, 0, SAL_RESID_POINTER_CHAIN }, // POINTER_CHAIN 1615 { 0, 0, SAL_RESID_POINTER_CHAIN_NOTALLOWED }, // POINTER_CHAIN_NOTALLOWED 1616 { 0, 0, SAL_RESID_POINTER_TIMEEVENT_MOVE }, // POINTER_TIMEEVENT_MOVE 1617 { 0, 0, SAL_RESID_POINTER_TIMEEVENT_SIZE }, // POINTER_TIMEEVENT_SIZE 1618 { 0, 0, SAL_RESID_POINTER_AUTOSCROLL_N }, // POINTER_AUTOSCROLL_N 1619 { 0, 0, SAL_RESID_POINTER_AUTOSCROLL_S }, // POINTER_AUTOSCROLL_S 1620 { 0, 0, SAL_RESID_POINTER_AUTOSCROLL_W }, // POINTER_AUTOSCROLL_W 1621 { 0, 0, SAL_RESID_POINTER_AUTOSCROLL_E }, // POINTER_AUTOSCROLL_E 1622 { 0, 0, SAL_RESID_POINTER_AUTOSCROLL_NW }, // POINTER_AUTOSCROLL_NW 1623 { 0, 0, SAL_RESID_POINTER_AUTOSCROLL_NE }, // POINTER_AUTOSCROLL_NE 1624 { 0, 0, SAL_RESID_POINTER_AUTOSCROLL_SW }, // POINTER_AUTOSCROLL_SW 1625 { 0, 0, SAL_RESID_POINTER_AUTOSCROLL_SE }, // POINTER_AUTOSCROLL_SE 1626 { 0, 0, SAL_RESID_POINTER_AUTOSCROLL_NS }, // POINTER_AUTOSCROLL_NS 1627 { 0, 0, SAL_RESID_POINTER_AUTOSCROLL_WE }, // POINTER_AUTOSCROLL_WE 1628 { 0, 0, SAL_RESID_POINTER_AUTOSCROLL_NSWE }, // POINTER_AUTOSCROLL_NSWE 1629 { 0, 0, SAL_RESID_POINTER_AIRBRUSH }, // POINTER_AIRBRUSH 1630 { 0, 0, SAL_RESID_POINTER_TEXT_VERTICAL }, // POINTER_TEXT_VERTICAL 1631 { 0, 0, SAL_RESID_POINTER_PIVOT_DELETE }, // POINTER_PIVOT_DELETE 1632 1633 // --> FME 2004-07-30 #i32329# Enhanced table selection 1634 { 0, 0, SAL_RESID_POINTER_TAB_SELECT_S }, // POINTER_TAB_SELECT_S 1635 { 0, 0, SAL_RESID_POINTER_TAB_SELECT_E }, // POINTER_TAB_SELECT_E 1636 { 0, 0, SAL_RESID_POINTER_TAB_SELECT_SE }, // POINTER_TAB_SELECT_SE 1637 { 0, 0, SAL_RESID_POINTER_TAB_SELECT_W }, // POINTER_TAB_SELECT_W 1638 { 0, 0, SAL_RESID_POINTER_TAB_SELECT_SW }, // POINTER_TAB_SELECT_SW 1639 // <-- 1640 1641 // --> FME 2004-08-16 #i20119# Paintbrush tool 1642 { 0, 0, SAL_RESID_POINTER_PAINTBRUSH } // POINTER_PAINTBRUSH 1643 // <-- 1644 }; 1645 1646 #if POINTER_COUNT != 94 1647 #error New Pointer must be defined! 1648 #endif 1649 1650 //debug_printf("Os2SalFrame::SetPointer\n"); 1651 1652 // Mousepointer loaded ? 1653 if ( !aImplPtrTab[ePointerStyle].mhPointer ) 1654 { 1655 if ( aImplPtrTab[ePointerStyle].mnOwnId ) 1656 aImplPtrTab[ePointerStyle].mhPointer = ImplLoadSalCursor( (ULONG)aImplPtrTab[ePointerStyle].mnOwnId ); 1657 else 1658 aImplPtrTab[ePointerStyle].mhPointer = WinQuerySysPointer( HWND_DESKTOP, aImplPtrTab[ePointerStyle].mnSysId, FALSE ); 1659 } 1660 if (aImplPtrTab[ePointerStyle].mhPointer == 0) { 1661 debug_printf( "SetPointer ePointerStyle %d unknown\n", ePointerStyle); 1662 aImplPtrTab[ePointerStyle].mhPointer = SPTR_ICONERROR; 1663 } 1664 1665 // Unterscheidet sich der Mauspointer, dann den neuen setzen 1666 if ( mhPointer != aImplPtrTab[ePointerStyle].mhPointer ) 1667 { 1668 mhPointer = aImplPtrTab[ePointerStyle].mhPointer; 1669 WinSetPointer( HWND_DESKTOP, mhPointer ); 1670 } 1671 } 1672 1673 // ----------------------------------------------------------------------- 1674 1675 void Os2SalFrame::CaptureMouse( sal_Bool bCapture ) 1676 { 1677 #if OSL_DEBUG_LEVEL>10 1678 _bCapture=bCapture; 1679 debug_printf("Os2SalFrame::CaptureMouse bCapture %d\n", bCapture); 1680 #endif 1681 if ( bCapture ) 1682 WinSetCapture( HWND_DESKTOP, mhWndClient ); 1683 else 1684 WinSetCapture( HWND_DESKTOP, 0 ); 1685 } 1686 1687 // ----------------------------------------------------------------------- 1688 1689 void Os2SalFrame::SetPointerPos( long nX, long nY ) 1690 { 1691 POINTL aPt; 1692 aPt.x = nX; 1693 aPt.y = mnHeight - nY - 1; // convert sal coords to sys 1694 WinMapWindowPoints( mhWndClient, HWND_DESKTOP, &aPt, 1 ); 1695 WinSetPointerPos( HWND_DESKTOP, aPt.x, aPt.y ); 1696 } 1697 1698 // ----------------------------------------------------------------------- 1699 1700 void Os2SalFrame::Flush() 1701 { 1702 } 1703 1704 // ----------------------------------------------------------------------- 1705 1706 void Os2SalFrame::Sync() 1707 { 1708 } 1709 1710 // ----------------------------------------------------------------------- 1711 1712 void Os2SalFrame::SetInputContext( SalInputContext* pContext ) 1713 { 1714 #ifdef ENABLE_IME 1715 SalIMEData* pIMEData = GetSalIMEData(); 1716 if ( pIMEData ) 1717 { 1718 HWND hWnd = mhWndClient; 1719 HIMI hIMI = 0; 1720 pIMEData->mpGetIME( hWnd, &hIMI ); 1721 if ( hIMI ) 1722 { 1723 ULONG nInputMode; 1724 ULONG nConversionMode; 1725 if ( 0 == pIMEData->mpQueryIMEMode( hIMI, &nInputMode, &nConversionMode ) ) 1726 { 1727 if ( pContext->mnOptions & SAL_INPUTCONTEXT_TEXT ) 1728 { 1729 nInputMode &= ~IMI_IM_IME_DISABLE; 1730 if ( pContext->mnOptions & SAL_INPUTCONTEXT_EXTTEXTINPUT_OFF ) 1731 nInputMode &= ~IMI_IM_IME_ON; 1732 // !!! Da derzeit ueber das OS2-IME-UI der IME-Mode nicht einschaltbar ist !!! 1733 // if ( SAL_INPUTCONTEXT_EXTTEXTINPUT_ON ) 1734 nInputMode |= IMI_IM_IME_ON; 1735 } 1736 else 1737 nInputMode |= IMI_IM_IME_DISABLE; 1738 pIMEData->mpSetIMEMode( hIMI, nInputMode, nConversionMode ); 1739 } 1740 1741 pIMEData->mpReleaseIME( hWnd, hIMI ); 1742 } 1743 } 1744 #endif 1745 } 1746 1747 // ----------------------------------------------------------------------- 1748 #if 0 1749 void Os2SalFrame::UpdateExtTextInputArea() 1750 { 1751 #ifdef ENABLE_IME 1752 #endif 1753 } 1754 #endif 1755 1756 // ----------------------------------------------------------------------- 1757 1758 void Os2SalFrame::EndExtTextInput( USHORT nFlags ) 1759 { 1760 #ifdef ENABLE_IME 1761 SalIMEData* pIMEData = GetSalIMEData(); 1762 if ( pIMEData ) 1763 { 1764 HWND hWnd = mhWndClient; 1765 HIMI hIMI = 0; 1766 pIMEData->mpGetIME( hWnd, &hIMI ); 1767 if ( hIMI ) 1768 { 1769 ULONG nIndex; 1770 if ( nFlags & SAL_FRAME_ENDEXTTEXTINPUT_COMPLETE ) 1771 nIndex = CNV_COMPLETE; 1772 else 1773 nIndex = CNV_CANCEL; 1774 1775 pIMEData->mpRequestIME( hIMI, REQ_CONVERSIONSTRING, nIndex, 0 ); 1776 pIMEData->mpReleaseIME( hWnd, hIMI ); 1777 } 1778 } 1779 #endif 1780 } 1781 1782 // ----------------------------------------------------------------------- 1783 1784 XubString Os2SalFrame::GetKeyName( USHORT nCode ) 1785 { 1786 if ( eImplKeyboardLanguage == LANGUAGE_DONTKNOW ) 1787 eImplKeyboardLanguage = MsLangId::getSystemLanguage(); 1788 1789 XubString aKeyCode; 1790 XubString aCode; 1791 const sal_Unicode** pLangTab = ImplGetLangTab( eImplKeyboardLanguage ); 1792 1793 if ( nCode & KEY_SHIFT ) 1794 aKeyCode = pLangTab[LSTR_KEY_SHIFT]; 1795 1796 if ( nCode & KEY_MOD1 ) 1797 { 1798 if ( aKeyCode.Len() == 0 ) 1799 aKeyCode = pLangTab[LSTR_KEY_CTRL]; 1800 else 1801 { 1802 aKeyCode += '+'; 1803 aKeyCode += pLangTab[LSTR_KEY_CTRL]; 1804 } 1805 } 1806 1807 if ( nCode & KEY_MOD2 ) 1808 { 1809 if ( aKeyCode.Len() == 0 ) 1810 aKeyCode = pLangTab[LSTR_KEY_ALT]; 1811 else 1812 { 1813 aKeyCode += '+'; 1814 aKeyCode += pLangTab[LSTR_KEY_ALT]; 1815 } 1816 } 1817 1818 USHORT nKeyCode = nCode & 0x0FFF; 1819 if ( (nKeyCode >= KEY_0) && (nKeyCode <= KEY_9) ) 1820 aCode = sal::static_int_cast<sal_Char>('0' + (nKeyCode - KEY_0)); 1821 else if ( (nKeyCode >= KEY_A) && (nKeyCode <= KEY_Z) ) 1822 aCode = sal::static_int_cast<sal_Char>('A' + (nKeyCode - KEY_A)); 1823 else if ( (nKeyCode >= KEY_F1) && (nKeyCode <= KEY_F26) ) 1824 { 1825 aCode += 'F'; 1826 if ( (nKeyCode >= KEY_F1) && (nKeyCode <= KEY_F9) ) 1827 { 1828 aCode += sal::static_int_cast<sal_Char>('1' + (nKeyCode - KEY_F1)); 1829 } 1830 else if ( (nKeyCode >= KEY_F10) && (nKeyCode <= KEY_F19) ) 1831 { 1832 aCode += '1'; 1833 aCode += sal::static_int_cast<sal_Char>('0' + (nKeyCode - KEY_F10)); 1834 } 1835 else 1836 { 1837 aCode += '2'; 1838 aCode += sal::static_int_cast<sal_Char>('0' + (nKeyCode - KEY_F20)); 1839 } 1840 } 1841 else 1842 { 1843 switch ( nKeyCode ) 1844 { 1845 case KEY_DOWN: 1846 aCode = pLangTab[LSTR_KEY_DOWN]; 1847 break; 1848 case KEY_UP: 1849 aCode = pLangTab[LSTR_KEY_UP]; 1850 break; 1851 case KEY_LEFT: 1852 aCode = pLangTab[LSTR_KEY_LEFT]; 1853 break; 1854 case KEY_RIGHT: 1855 aCode = pLangTab[LSTR_KEY_RIGHT]; 1856 break; 1857 case KEY_HOME: 1858 aCode = pLangTab[LSTR_KEY_HOME]; 1859 break; 1860 case KEY_END: 1861 aCode = pLangTab[LSTR_KEY_END]; 1862 break; 1863 case KEY_PAGEUP: 1864 aCode = pLangTab[LSTR_KEY_PAGEUP]; 1865 break; 1866 case KEY_PAGEDOWN: 1867 aCode = pLangTab[LSTR_KEY_PAGEDOWN]; 1868 break; 1869 case KEY_RETURN: 1870 aCode = pLangTab[LSTR_KEY_RETURN]; 1871 break; 1872 case KEY_ESCAPE: 1873 aCode = pLangTab[LSTR_KEY_ESC]; 1874 break; 1875 case KEY_TAB: 1876 aCode = pLangTab[LSTR_KEY_TAB]; 1877 break; 1878 case KEY_BACKSPACE: 1879 aCode = pLangTab[LSTR_KEY_BACKSPACE]; 1880 break; 1881 case KEY_SPACE: 1882 aCode = pLangTab[LSTR_KEY_SPACE]; 1883 break; 1884 case KEY_INSERT: 1885 aCode = pLangTab[LSTR_KEY_INSERT]; 1886 break; 1887 case KEY_DELETE: 1888 aCode = pLangTab[LSTR_KEY_DELETE]; 1889 break; 1890 1891 case KEY_ADD: 1892 aCode += '+'; 1893 break; 1894 case KEY_SUBTRACT: 1895 aCode += '-'; 1896 break; 1897 case KEY_MULTIPLY: 1898 aCode += '*'; 1899 break; 1900 case KEY_DIVIDE: 1901 aCode += '/'; 1902 break; 1903 case KEY_POINT: 1904 aCode += '.'; 1905 break; 1906 case KEY_COMMA: 1907 aCode += ','; 1908 break; 1909 case KEY_LESS: 1910 aCode += '<'; 1911 break; 1912 case KEY_GREATER: 1913 aCode += '>'; 1914 break; 1915 case KEY_EQUAL: 1916 aCode += '='; 1917 break; 1918 } 1919 } 1920 1921 if ( aCode.Len() ) 1922 { 1923 if ( aKeyCode.Len() == 0 ) 1924 aKeyCode = aCode; 1925 else 1926 { 1927 aKeyCode += '+'; 1928 aKeyCode += aCode; 1929 } 1930 } 1931 1932 return aKeyCode; 1933 } 1934 1935 // ----------------------------------------------------------------------- 1936 1937 XubString Os2SalFrame::GetSymbolKeyName( const XubString&, USHORT nKeyCode ) 1938 { 1939 return GetKeyName( nKeyCode ); 1940 } 1941 1942 // ----------------------------------------------------------------------- 1943 1944 inline long ImplOS2ColorToSal( long nOS2Color ) 1945 { 1946 return MAKE_SALCOLOR( (PM_BYTE)( nOS2Color>>16), (PM_BYTE)(nOS2Color>>8), (PM_BYTE)nOS2Color ); 1947 } 1948 1949 // ----------------------------------------------------------------------- 1950 1951 static USHORT ImplMouseSysValueToSAL( int iSysValue, USHORT& rCode, USHORT& rClicks, sal_Bool& rDown ) 1952 { 1953 LONG lValue = WinQuerySysValue( HWND_DESKTOP, iSysValue ); 1954 1955 rCode = 0; 1956 rClicks = 1; 1957 rDown = TRUE; 1958 1959 switch ( lValue & 0xFFFF ) 1960 { 1961 case WM_BUTTON1UP: 1962 case WM_BUTTON1CLICK: 1963 rCode = MOUSE_LEFT; 1964 rDown = FALSE; 1965 break; 1966 case WM_BUTTON1DOWN: 1967 case WM_BUTTON1MOTIONSTART: 1968 rCode = MOUSE_LEFT; 1969 break; 1970 case WM_BUTTON1DBLCLK: 1971 rCode = MOUSE_LEFT; 1972 rClicks = 2; 1973 break; 1974 1975 case WM_BUTTON2UP: 1976 case WM_BUTTON2CLICK: 1977 rCode = MOUSE_RIGHT; 1978 rDown = FALSE; 1979 break; 1980 case WM_BUTTON2DOWN: 1981 case WM_BUTTON2MOTIONSTART: 1982 rCode = MOUSE_RIGHT; 1983 break; 1984 case WM_BUTTON2DBLCLK: 1985 rCode = MOUSE_RIGHT; 1986 rClicks = 2; 1987 break; 1988 1989 case WM_BUTTON3UP: 1990 case WM_BUTTON3CLICK: 1991 rCode = MOUSE_MIDDLE; 1992 rDown = FALSE; 1993 break; 1994 case WM_BUTTON3DOWN: 1995 case WM_BUTTON3MOTIONSTART: 1996 rCode = MOUSE_MIDDLE; 1997 break; 1998 case WM_BUTTON3DBLCLK: 1999 rCode = MOUSE_MIDDLE; 2000 rClicks = 2; 2001 break; 2002 } 2003 2004 if ( !rCode ) 2005 return FALSE; 2006 2007 lValue = (lValue & 0xFFFF0000) >> 16; 2008 if ( lValue != 0xFFFF ) 2009 { 2010 if ( lValue & KC_SHIFT ) 2011 rCode |= KEY_SHIFT; 2012 if ( lValue & KC_CTRL ) 2013 rCode |= KEY_MOD1; 2014 if ( lValue & KC_ALT ) 2015 rCode |= KEY_MOD2; 2016 } 2017 2018 return TRUE; 2019 } 2020 2021 // ----------------------------------------------------------------------- 2022 2023 static sal_Bool ImplSalIsSameColor( const Color& rColor1, const Color& rColor2 ) 2024 { 2025 ULONG nWrong = 0; 2026 nWrong += Abs( (short)rColor1.GetRed()-(short)rColor2.GetRed() ); 2027 nWrong += Abs( (short)rColor1.GetGreen()-(short)rColor2.GetGreen() ); 2028 nWrong += Abs( (short)rColor1.GetBlue()-(short)rColor2.GetBlue() ); 2029 return (nWrong < 30); 2030 } 2031 2032 // ----------------------------------------------------------------------- 2033 2034 static sal_Bool ImplOS2NameFontToVCLFont( const char* pFontName, Font& rFont ) 2035 { 2036 char aNumBuf[10]; 2037 int nNumBufLen = 0; 2038 2039 while ( *pFontName && (*pFontName != '.') && 2040 (nNumBufLen < sizeof(aNumBuf)-1) ) 2041 { 2042 aNumBuf[nNumBufLen] = *pFontName; 2043 nNumBufLen++; 2044 pFontName++; 2045 } 2046 aNumBuf[nNumBufLen] = '\0'; 2047 2048 pFontName++; 2049 while ( *pFontName == ' ' ) 2050 pFontName++; 2051 2052 int nFontHeight = atoi( aNumBuf ); 2053 int nFontNameLen = strlen( pFontName ); 2054 if ( nFontHeight && nFontNameLen ) 2055 { 2056 rFont.SetFamily( FAMILY_DONTKNOW ); 2057 rFont.SetWeight( WEIGHT_NORMAL ); 2058 rFont.SetItalic( ITALIC_NONE ); 2059 // search for a style embedded in the name, e.g. 'WarpSans Bold' 2060 // because we need to split the style from the family name 2061 if (strstr( pFontName, " Bold") 2062 || strstr( pFontName, " Italic") 2063 || strstr( pFontName, "-Normal")) 2064 { 2065 char* fontName = strdup( pFontName); 2066 char* style = strstr( fontName, " Bold"); 2067 if (style) 2068 rFont.SetWeight( WEIGHT_BOLD ); 2069 2070 if (!style) 2071 style = strstr( fontName, " Italic"); 2072 if (style) 2073 rFont.SetItalic( ITALIC_NORMAL ); 2074 2075 if (!style) 2076 style = strstr( fontName, "-Normal"); 2077 // store style, skip whitespace char 2078 rFont.SetStyleName( ::rtl::OStringToOUString ( style+1, gsl_getSystemTextEncoding()) ); 2079 // truncate name 2080 *style = 0; 2081 // store family name 2082 rFont.SetName( ::rtl::OStringToOUString ( fontName, gsl_getSystemTextEncoding()) ); 2083 free( fontName); 2084 } 2085 else 2086 { 2087 rFont.SetName( ::rtl::OStringToOUString (pFontName, gsl_getSystemTextEncoding()) ); 2088 rFont.SetStyleName( ::rtl::OStringToOUString ("", gsl_getSystemTextEncoding()) ); 2089 } 2090 2091 rFont.SetSize( Size( 0, nFontHeight ) ); 2092 return TRUE; 2093 } 2094 else 2095 return FALSE; 2096 } 2097 2098 // ----------------------------------------------------------------------- 2099 2100 void Os2SalFrame::UpdateSettings( AllSettings& rSettings ) 2101 { 2102 static char aControlPanel[] = "PM_ControlPanel"; 2103 static char aSystemFonts[] = "PM_SystemFonts"; 2104 char aDummyStr[] = ""; 2105 2106 // --- Mouse setting --- 2107 USHORT nCode; 2108 USHORT nClicks; 2109 sal_Bool bDown; 2110 MouseSettings aMouseSettings = rSettings.GetMouseSettings(); 2111 aMouseSettings.SetDoubleClickTime( WinQuerySysValue( HWND_DESKTOP, SV_DBLCLKTIME ) ); 2112 if ( ImplMouseSysValueToSAL( SV_BEGINDRAG, nCode, nClicks, bDown ) ) 2113 aMouseSettings.SetStartDragCode( nCode ); 2114 if ( ImplMouseSysValueToSAL( SV_CONTEXTMENU, nCode, nClicks, bDown ) ) 2115 { 2116 aMouseSettings.SetContextMenuCode( nCode ); 2117 aMouseSettings.SetContextMenuClicks( nClicks ); 2118 aMouseSettings.SetContextMenuDown( bDown ); 2119 } 2120 aMouseSettings.SetButtonStartRepeat( WinQuerySysValue( HWND_DESKTOP, SV_FIRSTSCROLLRATE ) ); 2121 aMouseSettings.SetButtonRepeat( WinQuerySysValue( HWND_DESKTOP, SV_SCROLLRATE ) ); 2122 rSettings.SetMouseSettings( aMouseSettings ); 2123 2124 // --- Style settings --- 2125 StyleSettings aStyleSettings = rSettings.GetStyleSettings(); 2126 // General settings 2127 LONG nDisplayTime = PrfQueryProfileInt( HINI_PROFILE, (PSZ)aControlPanel, (PSZ)"LogoDisplayTime", -1 ); 2128 ULONG nSalDisplayTime; 2129 if ( nDisplayTime < 0 ) 2130 nSalDisplayTime = LOGO_DISPLAYTIME_STARTTIME; 2131 else if ( !nDisplayTime ) 2132 nSalDisplayTime = LOGO_DISPLAYTIME_NOLOGO; 2133 else 2134 nSalDisplayTime = (ULONG)nDisplayTime; 2135 aStyleSettings.SetLogoDisplayTime( nSalDisplayTime ); 2136 2137 aStyleSettings.SetCursorBlinkTime( WinQuerySysValue( HWND_DESKTOP, SV_CURSORRATE ) ); 2138 ULONG nDragFullOptions = aStyleSettings.GetDragFullOptions(); 2139 if ( WinQuerySysValue( HWND_DESKTOP, SV_DYNAMICDRAG ) ) 2140 nDragFullOptions |= DRAGFULL_OPTION_WINDOWMOVE | DRAGFULL_OPTION_WINDOWSIZE | DRAGFULL_OPTION_DOCKING | DRAGFULL_OPTION_SPLIT; 2141 else 2142 nDragFullOptions &= ~(DRAGFULL_OPTION_WINDOWMOVE | DRAGFULL_OPTION_WINDOWSIZE | DRAGFULL_OPTION_DOCKING | DRAGFULL_OPTION_SPLIT); 2143 aStyleSettings.SetDragFullOptions( nDragFullOptions ); 2144 2145 // Size settings 2146 aStyleSettings.SetScrollBarSize( WinQuerySysValue( HWND_DESKTOP, SV_CYHSCROLL ) ); 2147 aStyleSettings.SetTitleHeight( WinQuerySysValue( HWND_DESKTOP, SV_CYTITLEBAR ) ); 2148 2149 // Color settings 2150 aStyleSettings.SetFaceColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_BUTTONMIDDLE, 0 ) ) ); 2151 aStyleSettings.SetInactiveTabColor( aStyleSettings.GetFaceColor() ); 2152 aStyleSettings.SetLightColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_BUTTONLIGHT, 0 ) ) ); 2153 aStyleSettings.SetLightBorderColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_BUTTONMIDDLE, 0 ) ) ); 2154 aStyleSettings.SetShadowColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_BUTTONDARK, 0 ) ) ); 2155 aStyleSettings.SetDarkShadowColor( Color( COL_BLACK ) ); 2156 aStyleSettings.SetDialogColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_DIALOGBACKGROUND, 0 ) ) ); 2157 aStyleSettings.SetButtonTextColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_MENUTEXT, 0 ) ) ); 2158 aStyleSettings.SetActiveColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_ACTIVETITLE, 0 ) ) ); 2159 aStyleSettings.SetActiveTextColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_ACTIVETITLETEXT, 0 ) ) ); 2160 aStyleSettings.SetActiveBorderColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_ACTIVEBORDER, 0 ) ) ); 2161 aStyleSettings.SetDeactiveColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_INACTIVETITLE, 0 ) ) ); 2162 aStyleSettings.SetDeactiveTextColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_INACTIVETITLETEXT, 0 ) ) ); 2163 aStyleSettings.SetDeactiveBorderColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_INACTIVEBORDER, 0 ) ) ); 2164 aStyleSettings.SetMenuColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_MENU, 0 ) ) ); 2165 aStyleSettings.SetMenuTextColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_MENUTEXT, 0 ) ) ); 2166 aStyleSettings.SetMenuBarTextColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_MENUTEXT, 0 ) ) ); 2167 aStyleSettings.SetDialogTextColor( aStyleSettings.GetButtonTextColor() ); 2168 aStyleSettings.SetRadioCheckTextColor( aStyleSettings.GetButtonTextColor() ); 2169 aStyleSettings.SetGroupTextColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_WINDOWSTATICTEXT, 0 ) ) ); 2170 aStyleSettings.SetLabelTextColor( aStyleSettings.GetGroupTextColor() ); 2171 aStyleSettings.SetInfoTextColor( aStyleSettings.GetGroupTextColor() ); 2172 aStyleSettings.SetWindowColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_WINDOW, 0 ) ) ); 2173 aStyleSettings.SetActiveTabColor( aStyleSettings.GetWindowColor() ); 2174 aStyleSettings.SetWindowTextColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_WINDOWTEXT, 0 ) ) ); 2175 aStyleSettings.SetFieldColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_ENTRYFIELD, 0 ) ) ); 2176 aStyleSettings.SetFieldTextColor( aStyleSettings.GetWindowTextColor() ); 2177 aStyleSettings.SetDisableColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_MENUDISABLEDTEXT, 0 ) ) ); 2178 aStyleSettings.SetHighlightColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_HILITEBACKGROUND, 0 ) ) ); 2179 aStyleSettings.SetHighlightTextColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_HILITEFOREGROUND, 0 ) ) ); 2180 Color aMenuHighColor = ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_MENUHILITEBGND, 0 ) ); 2181 if ( ImplSalIsSameColor( aMenuHighColor, aStyleSettings.GetMenuColor() ) ) 2182 { 2183 aStyleSettings.SetMenuHighlightColor( Color( COL_BLUE ) ); 2184 aStyleSettings.SetMenuHighlightTextColor( Color( COL_WHITE ) ); 2185 } 2186 else 2187 { 2188 aStyleSettings.SetMenuHighlightColor( aMenuHighColor ); 2189 aStyleSettings.SetMenuHighlightTextColor( ImplOS2ColorToSal( WinQuerySysColor( HWND_DESKTOP, SYSCLR_MENUHILITE, 0 ) ) ); 2190 } 2191 // Checked-Color berechnen 2192 Color aColor1 = aStyleSettings.GetFaceColor(); 2193 Color aColor2 = aStyleSettings.GetLightColor(); 2194 PM_BYTE nRed = (PM_BYTE)(((USHORT)aColor1.GetRed() + (USHORT)aColor2.GetRed())/2); 2195 PM_BYTE nGreen = (PM_BYTE)(((USHORT)aColor1.GetGreen() + (USHORT)aColor2.GetGreen())/2); 2196 PM_BYTE nBlue = (PM_BYTE)(((USHORT)aColor1.GetBlue() + (USHORT)aColor2.GetBlue())/2); 2197 aStyleSettings.SetCheckedColor( Color( nRed, nGreen, nBlue ) ); 2198 2199 // Fonts updaten 2200 Font aFont; 2201 char aFontNameBuf[255]; 2202 aFont = aStyleSettings.GetMenuFont(); 2203 if ( PrfQueryProfileString( HINI_PROFILE, (PSZ)aSystemFonts, (PSZ)"Menus", aDummyStr, aFontNameBuf, sizeof( aFontNameBuf ) ) > 5 ) 2204 { 2205 if ( ImplOS2NameFontToVCLFont( aFontNameBuf, aFont ) ) { 2206 #if 0 2207 // Add Workplace Sans if not already listed 2208 if ( aFont.GetName().Search( (sal_Unicode*)L"WorkPlace Sans" ) == STRING_NOTFOUND ) 2209 { 2210 XubString aFontName = aFont.GetName(); 2211 aFontName.Insert( (sal_Unicode*)L"WorkPlace Sans;", 0 ); 2212 aFont.SetName( aFontName ); 2213 aFont.SetSize( Size( 0, 9 ) ); 2214 } 2215 #endif 2216 aStyleSettings.SetMenuFont( aFont ); 2217 } 2218 } 2219 aFont = aStyleSettings.GetIconFont(); 2220 if ( PrfQueryProfileString( HINI_PROFILE, (PSZ)aSystemFonts, (PSZ)"IconText", aDummyStr, aFontNameBuf, sizeof( aFontNameBuf ) ) > 5 ) 2221 { 2222 if ( ImplOS2NameFontToVCLFont( aFontNameBuf, aFont ) ) 2223 aStyleSettings.SetIconFont( aFont ); 2224 } 2225 aFont = aStyleSettings.GetTitleFont(); 2226 if ( PrfQueryProfileString( HINI_PROFILE, (PSZ)aSystemFonts, (PSZ)"WindowTitles", aDummyStr, aFontNameBuf, sizeof( aFontNameBuf ) ) > 5 ) 2227 { 2228 if ( ImplOS2NameFontToVCLFont( aFontNameBuf, aFont ) ) 2229 { 2230 // Add Workplace Sans if not already listed 2231 if ( aFont.GetName().Search( (sal_Unicode*)L"WorkPlace Sans" ) == STRING_NOTFOUND ) 2232 { 2233 XubString aFontName = aFont.GetName(); 2234 aFontName.Insert( (sal_Unicode*)L"WorkPlace Sans;", 0 ); 2235 aFont.SetName( aFontName ); 2236 aFont.SetSize( Size( 0, 9 ) ); 2237 aFont.SetWeight( WEIGHT_BOLD ); 2238 aFont.SetItalic( ITALIC_NONE ); 2239 } 2240 aStyleSettings.SetTitleFont( aFont ); 2241 aStyleSettings.SetFloatTitleFont( aFont ); 2242 } 2243 } 2244 aFont = aStyleSettings.GetAppFont(); 2245 if ( PrfQueryProfileString( HINI_PROFILE, (PSZ)aSystemFonts, (PSZ)"WindowText", aDummyStr, aFontNameBuf, sizeof( aFontNameBuf ) ) > 5 ) 2246 { 2247 if ( ImplOS2NameFontToVCLFont( aFontNameBuf, aFont ) ) 2248 { 2249 Font aHelpFont = aFont; 2250 aHelpFont.SetName( (sal_Unicode*)L"Helv;WarpSans" ); 2251 aHelpFont.SetSize( Size( 0, 8 ) ); 2252 aHelpFont.SetWeight( WEIGHT_NORMAL ); 2253 aHelpFont.SetItalic( ITALIC_NONE ); 2254 aStyleSettings.SetHelpFont( aHelpFont ); 2255 2256 // Add Workplace Sans if not already listed 2257 if ( aFont.GetName().Search( (sal_Unicode*)L"WorkPlace Sans" ) == STRING_NOTFOUND ) 2258 { 2259 XubString aFontName = aFont.GetName(); 2260 aFontName.Insert( (sal_Unicode*)L"WorkPlace Sans;", 0 ); 2261 aFont.SetName( aFontName ); 2262 aFont.SetSize( Size( 0, 9 ) ); 2263 } 2264 aStyleSettings.SetAppFont( aFont ); 2265 aStyleSettings.SetToolFont( aFont ); 2266 aStyleSettings.SetLabelFont( aFont ); 2267 aStyleSettings.SetInfoFont( aFont ); 2268 aStyleSettings.SetRadioCheckFont( aFont ); 2269 aStyleSettings.SetPushButtonFont( aFont ); 2270 aStyleSettings.SetFieldFont( aFont ); 2271 aStyleSettings.SetGroupFont( aFont ); 2272 } 2273 } 2274 2275 rSettings.SetStyleSettings( aStyleSettings ); 2276 } 2277 2278 // ----------------------------------------------------------------------- 2279 2280 SalBitmap* Os2SalFrame::SnapShot() 2281 { 2282 debug_printf("Os2SalFrame::SnapShot\n"); 2283 return NULL; 2284 } 2285 2286 // ----------------------------------------------------------------------- 2287 2288 const SystemEnvData* Os2SalFrame::GetSystemData() const 2289 { 2290 return &maSysData; 2291 } 2292 2293 // ----------------------------------------------------------------------- 2294 2295 void Os2SalFrame::Beep( SoundType eSoundType ) 2296 { 2297 static ULONG aImplSoundTab[5] = 2298 { 2299 WA_NOTE, // SOUND_DEFAULT 2300 WA_NOTE, // SOUND_INFO 2301 WA_WARNING, // SOUND_WARNING 2302 WA_ERROR, // SOUND_ERROR 2303 WA_NOTE // SOUND_QUERY 2304 }; 2305 2306 #if 0 2307 #if SOUND_COUNT != 5 2308 #error New Sound must be defined! 2309 #endif 2310 #endif 2311 2312 debug_printf("Os2SalFrame::Beep %d\n", eSoundType); 2313 WinAlarm( HWND_DESKTOP, aImplSoundTab[eSoundType] ); 2314 } 2315 2316 // ----------------------------------------------------------------------- 2317 2318 SalFrame::SalPointerState Os2SalFrame::GetPointerState() 2319 { 2320 SalPointerState aState; 2321 aState.mnState = 0; 2322 2323 // MausModus feststellen und setzen 2324 if ( WinGetKeyState( HWND_DESKTOP, VK_BUTTON1 ) & 0x8000 ) 2325 aState.mnState |= MOUSE_LEFT; 2326 if ( WinGetKeyState( HWND_DESKTOP, VK_BUTTON2 ) & 0x8000 ) 2327 aState.mnState |= MOUSE_RIGHT; 2328 if ( WinGetKeyState( HWND_DESKTOP, VK_BUTTON3 ) & 0x8000 ) 2329 aState.mnState |= MOUSE_MIDDLE; 2330 // Modifier-Tasten setzen 2331 if ( WinGetKeyState( HWND_DESKTOP, VK_SHIFT ) & 0x8000 ) 2332 aState.mnState |= KEY_SHIFT; 2333 if ( WinGetKeyState( HWND_DESKTOP, VK_CTRL ) & 0x8000 ) 2334 aState.mnState |= KEY_MOD1; 2335 if ( WinGetKeyState( HWND_DESKTOP, VK_ALT ) & 0x8000 ) 2336 aState.mnState |= KEY_MOD2; 2337 2338 POINTL pt; 2339 _WinQueryPointerPos( HWND_DESKTOP, &pt ); 2340 2341 aState.maPos = Point( pt.x - maGeometry.nX, pt.y - maGeometry.nY ); 2342 return aState; 2343 } 2344 2345 // ----------------------------------------------------------------------- 2346 2347 void Os2SalFrame::SetBackgroundBitmap( SalBitmap* ) 2348 { 2349 } 2350 2351 // ----------------------------------------------------------------------- 2352 2353 void SalTestMouseLeave() 2354 { 2355 SalData* pSalData = GetSalData(); 2356 2357 if ( pSalData->mhWantLeaveMsg && !::WinQueryCapture( HWND_DESKTOP ) ) 2358 { 2359 POINTL aPt; 2360 WinQueryPointerPos( HWND_DESKTOP, &aPt ); 2361 if ( pSalData->mhWantLeaveMsg != WinWindowFromPoint( HWND_DESKTOP, &aPt, TRUE ) ) 2362 WinSendMsg( pSalData->mhWantLeaveMsg, SAL_MSG_MOUSELEAVE, 0, MPFROM2SHORT( aPt.x, aPt.y ) ); 2363 } 2364 } 2365 2366 // ----------------------------------------------------------------------- 2367 2368 static long ImplHandleMouseMsg( HWND hWnd, 2369 UINT nMsg, MPARAM nMP1, MPARAM nMP2 ) 2370 { 2371 SalMouseEvent aMouseEvt; 2372 long nRet; 2373 USHORT nEvent; 2374 sal_Bool bCall = TRUE; 2375 USHORT nFlags = SHORT2FROMMP( nMP2 ); 2376 Os2SalFrame* pFrame = GetWindowPtr( hWnd ); 2377 if ( !pFrame ) 2378 return 0; 2379 2380 aMouseEvt.mnX = (short)SHORT1FROMMP( nMP1 ); 2381 aMouseEvt.mnY = pFrame->mnHeight - (short)SHORT2FROMMP( nMP1 ) - 1; 2382 aMouseEvt.mnCode = 0; 2383 aMouseEvt.mnTime = WinQueryMsgTime( pFrame->mhAB ); 2384 2385 // MausModus feststellen und setzen 2386 if ( WinGetKeyState( HWND_DESKTOP, VK_BUTTON1 ) & 0x8000 ) 2387 aMouseEvt.mnCode |= MOUSE_LEFT; 2388 if ( WinGetKeyState( HWND_DESKTOP, VK_BUTTON2 ) & 0x8000 ) 2389 aMouseEvt.mnCode |= MOUSE_RIGHT; 2390 if ( WinGetKeyState( HWND_DESKTOP, VK_BUTTON3 ) & 0x8000 ) 2391 aMouseEvt.mnCode |= MOUSE_MIDDLE; 2392 // Modifier-Tasten setzen 2393 if ( WinGetKeyState( HWND_DESKTOP, VK_SHIFT ) & 0x8000 ) 2394 aMouseEvt.mnCode |= KEY_SHIFT; 2395 if ( WinGetKeyState( HWND_DESKTOP, VK_CTRL ) & 0x8000 ) 2396 aMouseEvt.mnCode |= KEY_MOD1; 2397 if ( WinGetKeyState( HWND_DESKTOP, VK_ALT ) & 0x8000 ) 2398 aMouseEvt.mnCode |= KEY_MOD2; 2399 2400 switch ( nMsg ) 2401 { 2402 case WM_MOUSEMOVE: 2403 { 2404 SalData* pSalData = GetSalData(); 2405 2406 // Da bei Druecken von Modifier-Tasten die MouseEvents 2407 // nicht zusammengefast werden (da diese durch KeyEvents 2408 // unterbrochen werden), machen wir dieses hier selber 2409 if ( aMouseEvt.mnCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2) ) 2410 { 2411 QMSG aTempMsg; 2412 if ( WinPeekMsg( pSalData->mhAB, &aTempMsg, 2413 pFrame->mhWndClient, 2414 WM_MOUSEFIRST, WM_MOUSELAST, PM_NOREMOVE ) ) 2415 { 2416 if ( (aTempMsg.msg == WM_MOUSEMOVE) && 2417 (aTempMsg.mp2 == nMP2) ) 2418 return 1; 2419 } 2420 } 2421 2422 // Test for MouseLeave 2423 if ( pSalData->mhWantLeaveMsg && 2424 (pSalData->mhWantLeaveMsg != pFrame->mhWndClient) ) 2425 { 2426 POINTL aMousePoint; 2427 WinQueryMsgPos( pFrame->mhAB, &aMousePoint ); 2428 WinSendMsg( pSalData->mhWantLeaveMsg, 2429 SAL_MSG_MOUSELEAVE, 2430 0, MPFROM2SHORT( aMousePoint.x, aMousePoint.y ) ); 2431 } 2432 pSalData->mhWantLeaveMsg = pFrame->mhWndClient; 2433 // Start MouseLeave-Timer 2434 if ( !pSalData->mpMouseLeaveTimer ) 2435 { 2436 pSalData->mpMouseLeaveTimer = new AutoTimer; 2437 pSalData->mpMouseLeaveTimer->SetTimeout( SAL_MOUSELEAVE_TIMEOUT ); 2438 pSalData->mpMouseLeaveTimer->Start(); 2439 // We dont need to set a timeout handler, because we test 2440 // for mouseleave in the timeout callback 2441 } 2442 aMouseEvt.mnButton = 0; 2443 nEvent = SALEVENT_MOUSEMOVE; 2444 } 2445 break; 2446 2447 case SAL_MSG_MOUSELEAVE: 2448 { 2449 SalData* pSalData = GetSalData(); 2450 if ( pSalData->mhWantLeaveMsg == pFrame->mhWndClient ) 2451 { 2452 pSalData->mhWantLeaveMsg = 0; 2453 if ( pSalData->mpMouseLeaveTimer ) 2454 { 2455 delete pSalData->mpMouseLeaveTimer; 2456 pSalData->mpMouseLeaveTimer = NULL; 2457 } 2458 2459 // Mouse-Coordinaates are relativ to the screen 2460 POINTL aPt; 2461 aPt.x = (short)SHORT1FROMMP( nMP2 ); 2462 aPt.y = (short)SHORT2FROMMP( nMP2 ); 2463 WinMapWindowPoints( HWND_DESKTOP, pFrame->mhWndClient, &aPt, 1 ); 2464 aPt.y = pFrame->mnHeight - aPt.y - 1; 2465 aMouseEvt.mnX = aPt.x; 2466 aMouseEvt.mnY = aPt.y; 2467 aMouseEvt.mnButton = 0; 2468 nEvent = SALEVENT_MOUSELEAVE; 2469 } 2470 else 2471 bCall = FALSE; 2472 } 2473 break; 2474 2475 case WM_BUTTON1DBLCLK: 2476 case WM_BUTTON1DOWN: 2477 aMouseEvt.mnButton = MOUSE_LEFT; 2478 nEvent = SALEVENT_MOUSEBUTTONDOWN; 2479 break; 2480 2481 case WM_BUTTON2DBLCLK: 2482 case WM_BUTTON2DOWN: 2483 aMouseEvt.mnButton = MOUSE_RIGHT; 2484 nEvent = SALEVENT_MOUSEBUTTONDOWN; 2485 break; 2486 2487 case WM_BUTTON3DBLCLK: 2488 case WM_BUTTON3DOWN: 2489 aMouseEvt.mnButton = MOUSE_MIDDLE; 2490 nEvent = SALEVENT_MOUSEBUTTONDOWN; 2491 break; 2492 2493 case WM_BUTTON1UP: 2494 aMouseEvt.mnButton = MOUSE_LEFT; 2495 nEvent = SALEVENT_MOUSEBUTTONUP; 2496 break; 2497 2498 case WM_BUTTON2UP: 2499 aMouseEvt.mnButton = MOUSE_RIGHT; 2500 nEvent = SALEVENT_MOUSEBUTTONUP; 2501 break; 2502 2503 case WM_BUTTON3UP: 2504 aMouseEvt.mnButton = MOUSE_MIDDLE; 2505 nEvent = SALEVENT_MOUSEBUTTONUP; 2506 break; 2507 } 2508 2509 // check if this window was destroyed - this might happen if we are the help window 2510 // and sent a mouse leave message to the application which killed the help window, ie ourself 2511 if( !WinIsWindow( pFrame->mhAB, hWnd ) ) 2512 return 0; 2513 2514 #if OSL_DEBUG_LEVEL>10 2515 //if (_bCapture) 2516 debug_printf("ImplHandleMouseMsg mouse %d,%d\n",aMouseEvt.mnX,aMouseEvt.mnY); 2517 #endif 2518 2519 if ( bCall ) 2520 { 2521 if ( nEvent == SALEVENT_MOUSEBUTTONDOWN ) 2522 WinUpdateWindow( pFrame->mhWndClient ); 2523 2524 // --- RTL --- (mirror mouse pos) 2525 //if( Application::GetSettings().GetLayoutRTL() ) 2526 // aMouseEvt.mnX = pFrame->maGeometry.nWidth-1-aMouseEvt.mnX; 2527 2528 nRet = pFrame->CallCallback( nEvent, &aMouseEvt ); 2529 if ( nMsg == WM_MOUSEMOVE ) 2530 { 2531 WinSetPointer( HWND_DESKTOP, pFrame->mhPointer ); 2532 nRet = TRUE; 2533 } 2534 } 2535 else 2536 nRet = 0; 2537 2538 return nRet; 2539 } 2540 2541 // ----------------------------------------------------------------------- 2542 2543 static long ImplHandleWheelMsg( HWND hWnd, UINT nMsg, MPARAM nMP1, MPARAM nMP2 ) 2544 { 2545 2546 ImplSalYieldMutexAcquireWithWait(); 2547 2548 long nRet = 0; 2549 Os2SalFrame* pFrame = GetWindowPtr( hWnd ); 2550 if ( pFrame ) 2551 { 2552 2553 // Mouse-Coordinaates are relativ to the screen 2554 POINTL aPt; 2555 WinQueryMsgPos( pFrame->mhAB, &aPt ); 2556 WinMapWindowPoints( HWND_DESKTOP, pFrame->mhWndClient, &aPt, 1 ); 2557 aPt.y = pFrame->mnHeight - aPt.y - 1; 2558 2559 SalWheelMouseEvent aWheelEvt; 2560 aWheelEvt.mnTime = WinQueryMsgTime( pFrame->mhAB ); 2561 aWheelEvt.mnX = aPt.x; 2562 aWheelEvt.mnY = aPt.y; 2563 aWheelEvt.mnCode = 0; 2564 bool bNeg = (SHORT2FROMMP(nMP2) == SB_LINEDOWN || SHORT2FROMMP(nMP2) == SB_PAGEDOWN ); 2565 aWheelEvt.mnDelta = bNeg ? -120 : 120; 2566 aWheelEvt.mnNotchDelta = bNeg ? -1 : 1; 2567 if (SHORT2FROMMP(nMP2) == SB_PAGEUP || SHORT2FROMMP(nMP2) == SB_PAGEDOWN) 2568 aWheelEvt.mnScrollLines = SAL_WHEELMOUSE_EVENT_PAGESCROLL; 2569 else 2570 aWheelEvt.mnScrollLines = 1; 2571 2572 if( nMsg == WM_HSCROLL ) 2573 aWheelEvt.mbHorz = TRUE; 2574 2575 // Modifier-Tasten setzen 2576 if ( WinGetKeyState( HWND_DESKTOP, VK_SHIFT ) & 0x8000 ) 2577 aWheelEvt.mnCode |= KEY_SHIFT; 2578 if ( WinGetKeyState( HWND_DESKTOP, VK_CTRL ) & 0x8000 ) 2579 aWheelEvt.mnCode |= KEY_MOD1; 2580 if ( WinGetKeyState( HWND_DESKTOP, VK_ALT ) & 0x8000 ) 2581 aWheelEvt.mnCode |= KEY_MOD2; 2582 2583 nRet = pFrame->CallCallback( SALEVENT_WHEELMOUSE, &aWheelEvt ); 2584 } 2585 2586 ImplSalYieldMutexRelease(); 2587 2588 return nRet; 2589 } 2590 2591 2592 // ----------------------------------------------------------------------- 2593 2594 static USHORT ImplSalGetKeyCode( Os2SalFrame* pFrame, MPARAM aMP1, MPARAM aMP2 ) 2595 { 2596 USHORT nKeyFlags = SHORT1FROMMP( aMP1 ); 2597 UCHAR nCharCode = (UCHAR)SHORT1FROMMP( aMP2 ); 2598 USHORT nKeyCode = (UCHAR)SHORT2FROMMP( aMP2 ); 2599 UCHAR nScanCode = (UCHAR)CHAR4FROMMP( aMP1 ); 2600 USHORT rSVCode = 0; 2601 2602 // Ist virtueller KeyCode gesetzt und befindet sich der KeyCode in der 2603 // Tabelle, dann mappen 2604 if ( (nKeyFlags & KC_VIRTUALKEY) && (nKeyCode < KEY_TAB_SIZE) ) 2605 rSVCode = aImplTranslateKeyTab[nKeyCode]; 2606 2607 // Wenn kein KeyCode ermittelt werden konnte, versuchen wir aus dem 2608 // CharCode einen zu erzeugen 2609 if ( !rSVCode && nCharCode ) 2610 { 2611 // Bei 0-9, a-z und A-Z auch KeyCode setzen 2612 if ( (nCharCode >= '0') && (nCharCode <= '9') && (!rSVCode || !(nKeyFlags & KC_SHIFT)) ) 2613 rSVCode = KEYGROUP_NUM + (nCharCode-'0'); 2614 else if ( (nCharCode >= 'a') && (nCharCode <= 'z') ) 2615 rSVCode = KEYGROUP_ALPHA + (nCharCode-'a'); 2616 else if ( (nCharCode >= 'A') && (nCharCode <= 'Z') ) 2617 rSVCode = KEYGROUP_ALPHA + (nCharCode-'A'); 2618 else 2619 { 2620 switch ( nCharCode ) 2621 { 2622 case '+': 2623 rSVCode = KEY_ADD; 2624 break; 2625 case '-': 2626 rSVCode = KEY_SUBTRACT; 2627 break; 2628 case '*': 2629 rSVCode = KEY_MULTIPLY; 2630 break; 2631 case '/': 2632 rSVCode = KEY_DIVIDE; 2633 break; 2634 case '.': 2635 rSVCode = KEY_POINT; 2636 break; 2637 case ',': 2638 rSVCode = KEY_COMMA; 2639 break; 2640 case '<': 2641 rSVCode = KEY_LESS; 2642 break; 2643 case '>': 2644 rSVCode = KEY_GREATER; 2645 break; 2646 case '=': 2647 rSVCode = KEY_EQUAL; 2648 break; 2649 } 2650 } 2651 } 2652 2653 // "Numlock-Hack": we want to get correct keycodes from the numpad 2654 if ( (nCharCode >= '0') && (nCharCode <= '9') && !(nKeyFlags & KC_SHIFT) ) 2655 rSVCode = KEYGROUP_NUM + (nCharCode-'0'); 2656 if ( nCharCode == ',' ) 2657 rSVCode = KEY_COMMA; 2658 if ( nCharCode == '.' ) 2659 rSVCode = KEY_POINT; 2660 2661 return rSVCode; 2662 } 2663 2664 // ----------------------------------------------------------------------- 2665 2666 static void ImplUpdateInputLang( Os2SalFrame* pFrame ) 2667 { 2668 sal_Bool bLanguageChange = FALSE; 2669 ULONG nLang = 0; 2670 APIRET rc; 2671 UconvObject uconv_object = NULL; 2672 LocaleObject locale_object = NULL; 2673 UniChar *pinfo_item; 2674 2675 // we do not support change of input language while working, 2676 // so exit if already defined (mnInputLang is a static class field) 2677 if (pFrame->mnInputLang) 2678 return; 2679 2680 // get current locale 2681 rc = UniCreateLocaleObject(UNI_UCS_STRING_POINTER, (UniChar *)L"", &locale_object); 2682 // get Win32 locale id and sublanguage (hex uni string) 2683 rc = UniQueryLocaleItem(locale_object, LOCI_xWinLocale, &pinfo_item); 2684 // convert uni string to integer 2685 rc = UniStrtoul(locale_object, pinfo_item, &pinfo_item, 16, &nLang); 2686 rc = UniFreeMem(pinfo_item); 2687 #if OSL_DEBUG_LEVEL>10 2688 debug_printf("ImplUpdateInputLang nLang %04x\n", nLang); 2689 char char_buffer[256]; 2690 rc = UniCreateUconvObject((UniChar *)L"", &uconv_object); 2691 rc = UniQueryLocaleItem(locale_object, LOCI_sKeyboard, &pinfo_item); 2692 rc = UniStrFromUcs(uconv_object, char_buffer, pinfo_item, sizeof(char_buffer)); 2693 debug_printf("Keyboard name is: %s\n", char_buffer ); 2694 rc = UniFreeMem(pinfo_item); 2695 #endif 2696 rc = UniFreeLocaleObject(locale_object); 2697 2698 // keep input lang up-to-date 2699 #if OSL_DEBUG_LEVEL>10 2700 debug_printf("ImplUpdateInputLang pFrame %08x lang changed from %d to %d\n", 2701 pFrame, pFrame->mnInputLang, nLang); 2702 #endif 2703 pFrame->mnInputLang = nLang; 2704 } 2705 2706 2707 static sal_Unicode ImplGetCharCode( Os2SalFrame* pFrame, USHORT nKeyFlags, 2708 sal_Char nCharCode, UCHAR nScanCode ) 2709 { 2710 ImplUpdateInputLang( pFrame ); 2711 #if OSL_DEBUG_LEVEL>10 2712 debug_printf("ImplGetCharCode nCharCode %c, %04x\n", nCharCode, nCharCode); 2713 #endif 2714 return OUString( &nCharCode, 1, gsl_getSystemTextEncoding()).toChar(); 2715 } 2716 2717 // ----------------------------------------------------------------------- 2718 2719 LanguageType Os2SalFrame::GetInputLanguage() 2720 { 2721 if( !mnInputLang ) 2722 ImplUpdateInputLang( this ); 2723 2724 if( !mnInputLang ) 2725 return LANGUAGE_DONTKNOW; 2726 else 2727 return (LanguageType) mnInputLang; 2728 } 2729 2730 // ----------------------------------------------------------------------- 2731 2732 sal_Bool Os2SalFrame::MapUnicodeToKeyCode( sal_Unicode , LanguageType , KeyCode& ) 2733 { 2734 // not supported yet 2735 return FALSE; 2736 } 2737 2738 // ----------------------------------------------------------------------- 2739 2740 static sal_Unicode ImplConvertKey( Os2SalFrame* pFrame, MPARAM aMP1, MPARAM aMP2 ) 2741 { 2742 USHORT nKeyFlags = SHORT1FROMMP( aMP1 ); 2743 UCHAR nCharCode = (UCHAR)SHORT1FROMMP( aMP2 ); 2744 USHORT nKeyCode = (UCHAR)SHORT2FROMMP( aMP2 ); 2745 UCHAR nScanCode = (UCHAR)CHAR4FROMMP( aMP1 ); 2746 sal_Unicode rSVCharCode = 0; 2747 2748 // Ist Character-Code gesetzt 2749 // !!! Bei CTRL/ALT ist KC_CHAR nicht gesetzt, jedoch moechten wir 2750 // !!! dann auch einen CharCode und machen die Behandlung deshalb 2751 // !!! selber 2752 if ( (nKeyFlags & KC_CHAR) || (nKeyFlags & KC_CTRL) || (nKeyFlags & KC_ALT) ) 2753 rSVCharCode = ImplGetCharCode( pFrame, nKeyFlags, nCharCode, nScanCode); 2754 2755 // ret unicode 2756 return rSVCharCode; 2757 } 2758 2759 // ----------------------------------------------------------------------- 2760 2761 static long ImplHandleKeyMsg( HWND hWnd, 2762 UINT nMsg, MPARAM nMP1, MPARAM nMP2 ) 2763 { 2764 static USHORT nLastOS2KeyChar = 0; 2765 static sal_Unicode nLastChar = 0; 2766 USHORT nRepeat = CHAR3FROMMP( nMP1 ) - 1; 2767 SHORT nFlags = SHORT1FROMMP( nMP1 ); 2768 USHORT nModCode = 0; 2769 USHORT nSVCode = 0; 2770 USHORT nOS2KeyCode = (UCHAR)SHORT2FROMMP( nMP2 ); 2771 sal_Unicode nSVCharCode = 0; 2772 long nRet = 0; 2773 2774 Os2SalFrame* pFrame = GetWindowPtr( hWnd ); 2775 if ( !pFrame ) 2776 return 0; 2777 2778 // determine modifiers 2779 if ( nFlags & KC_SHIFT ) 2780 nModCode |= KEY_SHIFT; 2781 if ( nFlags & KC_CTRL ) 2782 nModCode |= KEY_MOD1; 2783 if ( nFlags & KC_ALT ) 2784 nModCode |= KEY_MOD2; 2785 2786 // Bei Shift, Control und Alt schicken wir einen KeyModChange-Event 2787 if ( (nOS2KeyCode == VK_SHIFT) || (nOS2KeyCode == VK_CTRL) || 2788 (nOS2KeyCode == VK_ALT) || (nOS2KeyCode == VK_ALTGRAF) ) 2789 { 2790 SalKeyModEvent aModEvt; 2791 aModEvt.mnTime = WinQueryMsgTime( pFrame->mhAB ); 2792 aModEvt.mnCode = nModCode; 2793 #if OSL_DEBUG_LEVEL>10 2794 debug_printf("SALEVENT_KEYMODCHANGE\n"); 2795 #endif 2796 nRet = pFrame->CallCallback( SALEVENT_KEYMODCHANGE, &aModEvt ); 2797 } 2798 else 2799 { 2800 nSVCode = ImplSalGetKeyCode( pFrame, nMP1, nMP2 ); 2801 nSVCharCode = ImplConvertKey( pFrame, nMP1, nMP2 ); 2802 #if OSL_DEBUG_LEVEL>10 2803 debug_printf("nSVCode %04x nSVCharCode %04x\n",nSVCode,nSVCharCode ); 2804 #endif 2805 2806 // Fuer Java muessen wir bei KeyUp einen CharCode liefern 2807 if ( nFlags & KC_KEYUP ) 2808 { 2809 if ( !nSVCharCode ) 2810 { 2811 if ( nLastOS2KeyChar == nOS2KeyCode ) 2812 { 2813 nSVCharCode = nLastChar; 2814 nLastOS2KeyChar = 0; 2815 nLastChar = 0; 2816 } 2817 } 2818 else 2819 { 2820 nLastOS2KeyChar = 0; 2821 nLastChar = 0; 2822 } 2823 } 2824 else 2825 { 2826 nLastOS2KeyChar = nOS2KeyCode; 2827 nLastChar = nSVCharCode; 2828 } 2829 2830 if ( nSVCode || nSVCharCode ) 2831 { 2832 SalKeyEvent aKeyEvt; 2833 aKeyEvt.mnCode = nSVCode; 2834 aKeyEvt.mnTime = WinQueryMsgTime( pFrame->mhAB ); 2835 aKeyEvt.mnCode |= nModCode; 2836 aKeyEvt.mnCharCode = nSVCharCode; 2837 aKeyEvt.mnRepeat = nRepeat; 2838 2839 #if OSL_DEBUG_LEVEL>10 2840 debug_printf( (nFlags & KC_KEYUP) ? "SALEVENT_KEYUP\n" : "SALEVENT_KEYINPUT\n"); 2841 #endif 2842 nRet = pFrame->CallCallback( (nFlags & KC_KEYUP) ? SALEVENT_KEYUP : SALEVENT_KEYINPUT, 2843 &aKeyEvt ); 2844 } 2845 } 2846 2847 return nRet; 2848 } 2849 2850 // ----------------------------------------------------------------------- 2851 2852 static bool ImplHandlePaintMsg( HWND hWnd ) 2853 { 2854 sal_Bool bMutex = FALSE; 2855 2856 if ( ImplSalYieldMutexTryToAcquire() ) 2857 bMutex = TRUE; 2858 2859 // if we don't get the mutex, we can also change the clip region, 2860 // because other threads doesn't use the mutex from the main 2861 // thread --> see GetGraphics() 2862 2863 Os2SalFrame* pFrame = GetWindowPtr( hWnd ); 2864 if ( pFrame ) 2865 { 2866 // Laut Window-Doku soll man erst abfragen, ob ueberhaupt eine 2867 // Paint-Region anliegt 2868 if ( WinQueryUpdateRect( hWnd, NULL ) ) 2869 { 2870 // Call BeginPaint/EndPaint to query the rect and send 2871 // this Notofication to rect 2872 HPS hPS; 2873 RECTL aUpdateRect; 2874 hPS = WinBeginPaint( hWnd, NULLHANDLE, &aUpdateRect ); 2875 WinEndPaint( hPS ); 2876 2877 // Paint 2878 if ( bMutex ) 2879 { 2880 SalPaintEvent aPEvt( aUpdateRect.xLeft, pFrame->mnHeight - aUpdateRect.yTop, aUpdateRect.xRight- aUpdateRect.xLeft, aUpdateRect.yTop - aUpdateRect.yBottom ); 2881 2882 pFrame->CallCallback( SALEVENT_PAINT, &aPEvt ); 2883 } 2884 else 2885 { 2886 RECTL* pRect = new RECTL; 2887 WinCopyRect( pFrame->mhAB, pRect, &aUpdateRect ); 2888 WinPostMsg( hWnd, SAL_MSG_POSTPAINT, (MPARAM)pRect, 0 ); 2889 } 2890 } 2891 } 2892 2893 if ( bMutex ) 2894 ImplSalYieldMutexRelease(); 2895 2896 return bMutex ? true : false; 2897 } 2898 2899 // ----------------------------------------------------------------------- 2900 2901 static void ImplHandlePaintMsg2( HWND hWnd, RECTL* pRect ) 2902 { 2903 // Paint 2904 if ( ImplSalYieldMutexTryToAcquire() ) 2905 { 2906 Os2SalFrame* pFrame = GetWindowPtr( hWnd ); 2907 if ( pFrame ) 2908 { 2909 SalPaintEvent aPEvt( pRect->xLeft, pFrame->mnHeight - pRect->yTop, pRect->xRight - pRect->xLeft, pRect->yTop - pRect->yBottom ); 2910 pFrame->CallCallback( SALEVENT_PAINT, &aPEvt ); 2911 } 2912 ImplSalYieldMutexRelease(); 2913 delete pRect; 2914 } 2915 else 2916 WinPostMsg( hWnd, SAL_MSG_POSTPAINT, (MPARAM)pRect, 0 ); 2917 } 2918 2919 // ----------------------------------------------------------------------- 2920 2921 static void SetMaximizedFrameGeometry( HWND hWnd, Os2SalFrame* pFrame ) 2922 { 2923 // calculate and set frame geometry of a maximized window - useful if the window is still hidden 2924 2925 RECTL aRect; 2926 pFrame->GetWorkArea( aRect); 2927 2928 // a maximized window has no other borders than the caption 2929 pFrame->maGeometry.nLeftDecoration = pFrame->maGeometry.nRightDecoration = pFrame->maGeometry.nBottomDecoration = 0; 2930 pFrame->maGeometry.nTopDecoration = pFrame->mbCaption ? WinQuerySysValue( HWND_DESKTOP, SV_CYTITLEBAR ) : 0; 2931 2932 aRect.yTop += pFrame->maGeometry.nTopDecoration; 2933 pFrame->maGeometry.nX = aRect.xLeft; 2934 pFrame->maGeometry.nY = aRect.yBottom; 2935 pFrame->maGeometry.nWidth = aRect.xRight - aRect.xLeft + 1; 2936 pFrame->maGeometry.nHeight = aRect.yBottom - aRect.yTop + 1; 2937 } 2938 2939 static void UpdateFrameGeometry( HWND hWnd, Os2SalFrame* pFrame ) 2940 { 2941 if( !pFrame ) 2942 return; 2943 2944 //SalFrame has a 2945 //maGeometry member that holds absolute screen positions (and needs to be 2946 //updated if the window is moved by the way). 2947 2948 // reset data 2949 memset(&pFrame->maGeometry, 0, sizeof(SalFrameGeometry) ); 2950 2951 SWP swp; 2952 LONG nFrameX, nFrameY, nCaptionY; 2953 2954 // get frame size 2955 WinQueryWindowPos(pFrame->mhWndFrame, &swp); 2956 if (swp.fl & SWP_MINIMIZE) 2957 return; 2958 2959 // map from client area to screen 2960 ImplSalCalcFrameSize( pFrame, nFrameX, nFrameY, nCaptionY); 2961 pFrame->maGeometry.nTopDecoration = nFrameY + nCaptionY; 2962 pFrame->maGeometry.nLeftDecoration = nFrameX; 2963 pFrame->maGeometry.nRightDecoration = nFrameX; 2964 pFrame->maGeometry.nBottomDecoration = nFrameY; 2965 2966 // position of client area, not of frame corner! 2967 pFrame->maGeometry.nX = swp.x + nFrameX; 2968 pFrame->maGeometry.nY = nScreenHeight - (swp.y + swp.cy) + nFrameY + nCaptionY; 2969 2970 int nWidth = swp.cx - pFrame->maGeometry.nRightDecoration - pFrame->maGeometry.nLeftDecoration; 2971 int nHeight = swp.cy - pFrame->maGeometry.nBottomDecoration - pFrame->maGeometry.nTopDecoration; 2972 2973 // clamp to zero 2974 pFrame->maGeometry.nHeight = nHeight < 0 ? 0 : nHeight; 2975 pFrame->maGeometry.nWidth = nWidth < 0 ? 0 : nWidth; 2976 #if OSL_DEBUG_LEVEL>0 2977 debug_printf( "UpdateFrameGeometry: hwnd %x, frame %x at %d,%d (%dx%d)\n", 2978 hWnd, pFrame->mhWndFrame, 2979 pFrame->maGeometry.nX, pFrame->maGeometry.nY, 2980 pFrame->maGeometry.nWidth,pFrame->maGeometry.nHeight); 2981 #endif 2982 } 2983 2984 // ----------------------------------------------------------------------- 2985 2986 static void ImplHandleMoveMsg( HWND hWnd) 2987 { 2988 if ( ImplSalYieldMutexTryToAcquire() ) 2989 { 2990 Os2SalFrame* pFrame = GetWindowPtr( hWnd ); 2991 if ( pFrame ) 2992 { 2993 UpdateFrameGeometry( hWnd, pFrame ); 2994 2995 if ( WinIsWindowVisible( hWnd )) 2996 pFrame->mbDefPos = FALSE; 2997 2998 // Gegen moegliche Rekursionen sichern 2999 if ( !pFrame->mbInMoveMsg ) 3000 { 3001 // Fenster im FullScreenModus wieder einpassen 3002 pFrame->mbInMoveMsg = TRUE; 3003 if ( pFrame->mbFullScreen ) 3004 ImplSalFrameFullScreenPos( pFrame ); 3005 pFrame->mbInMoveMsg = FALSE; 3006 } 3007 3008 // Status merken 3009 ImplSaveFrameState( pFrame ); 3010 3011 // Call Hdl 3012 //#93851 if we call this handler, VCL floating windows are not updated correctly 3013 //ImplCallMoveHdl( hWnd ); 3014 3015 } 3016 3017 ImplSalYieldMutexRelease(); 3018 } 3019 else 3020 WinPostMsg( hWnd, SAL_MSG_POSTMOVE, 0, 0 ); 3021 } 3022 3023 // ----------------------------------------------------------------------- 3024 3025 static void ImplHandleSizeMsg( HWND hWnd, MPARAM nMP2 ) 3026 { 3027 Os2SalFrame* pFrame = GetWindowPtr( hWnd ); 3028 if ( pFrame ) 3029 { 3030 UpdateFrameGeometry( hWnd, pFrame ); 3031 pFrame->mbDefPos = FALSE; 3032 pFrame->mnWidth = (short)SHORT1FROMMP( nMP2 ); 3033 pFrame->mnHeight = (short)SHORT2FROMMP( nMP2 ); 3034 if ( pFrame->mpGraphics ) 3035 pFrame->mpGraphics->mnHeight = (int)SHORT2FROMMP(nMP2); 3036 // Status merken 3037 ImplSaveFrameState( pFrame ); 3038 pFrame->CallCallback( SALEVENT_RESIZE, 0 ); 3039 if ( WinIsWindowVisible( pFrame->mhWndFrame ) && !pFrame->mbInShow ) 3040 WinUpdateWindow( pFrame->mhWndClient ); 3041 } 3042 } 3043 3044 // ----------------------------------------------------------------------- 3045 3046 static long ImplHandleFocusMsg( Os2SalFrame* pFrame, MPARAM nMP2 ) 3047 { 3048 if ( pFrame && !Os2SalFrame::mbInReparent ) 3049 { 3050 if ( SHORT1FROMMP( nMP2 ) ) 3051 { 3052 if ( WinIsWindowVisible( pFrame->mhWndFrame ) && !pFrame->mbInShow ) 3053 WinUpdateWindow( pFrame->mhWndClient ); 3054 return pFrame->CallCallback( SALEVENT_GETFOCUS, 0 ); 3055 } 3056 else 3057 { 3058 return pFrame->CallCallback( SALEVENT_LOSEFOCUS, 0 ); 3059 } 3060 } 3061 } 3062 3063 // ----------------------------------------------------------------------- 3064 3065 static void ImplHandleCloseMsg( HWND hWnd ) 3066 { 3067 if ( ImplSalYieldMutexTryToAcquire() ) 3068 { 3069 Os2SalFrame* pFrame = GetWindowPtr( hWnd ); 3070 if ( pFrame ) 3071 { 3072 pFrame->CallCallback( SALEVENT_CLOSE, 0 ); 3073 } 3074 3075 ImplSalYieldMutexRelease(); 3076 } 3077 else 3078 WinPostMsg( hWnd, WM_CLOSE, 0, 0 ); 3079 } 3080 3081 // ----------------------------------------------------------------------- 3082 3083 inline void ImplHandleUserEvent( HWND hWnd, MPARAM nMP2 ) 3084 { 3085 ImplSalYieldMutexAcquireWithWait(); 3086 Os2SalFrame* pFrame = GetWindowPtr( hWnd ); 3087 if ( pFrame ) 3088 { 3089 pFrame->CallCallback( SALEVENT_USEREVENT, (void*)nMP2 ); 3090 } 3091 ImplSalYieldMutexRelease(); 3092 } 3093 3094 // ----------------------------------------------------------------------- 3095 3096 static int SalImplHandleProcessMenu( Os2SalFrame* pFrame, ULONG nMsg, MPARAM nMP1, MPARAM nMP2) 3097 { 3098 long nRet = 0; 3099 debug_printf("SalImplHandleProcessMenu\n"); 3100 #if 0 3101 DWORD err=0; 3102 if( !HIWORD(wParam) ) 3103 { 3104 // Menu command 3105 WORD nId = LOWORD(wParam); 3106 if( nId ) // zero for separators 3107 { 3108 SalMenuEvent aMenuEvt; 3109 aMenuEvt.mnId = nId; 3110 WinSalMenuItem *pSalMenuItem = ImplGetSalMenuItem( pFrame->mSelectedhMenu, nId, FALSE ); 3111 if( pSalMenuItem ) 3112 aMenuEvt.mpMenu = pSalMenuItem->mpMenu; 3113 else 3114 aMenuEvt.mpMenu = NULL; 3115 3116 nRet = pFrame->CallCallback( SALEVENT_MENUCOMMAND, &aMenuEvt ); 3117 } 3118 } 3119 #endif 3120 //return (nRet != 0); 3121 return (nRet == 0); 3122 } 3123 3124 // ----------------------------------------------------------------------- 3125 3126 static void ImplHandleInputLangChange( HWND hWnd ) 3127 { 3128 ImplSalYieldMutexAcquireWithWait(); 3129 3130 // Feststellen, ob wir IME unterstuetzen 3131 Os2SalFrame* pFrame = GetWindowPtr( hWnd ); 3132 #if 0 3133 if ( pFrame && pFrame->mbIME && pFrame->mhDefIMEContext ) 3134 { 3135 HWND hWnd = pFrame->mhWnd; 3136 HKL hKL = (HKL)lParam; 3137 UINT nImeProps = ImmGetProperty( hKL, IGP_PROPERTY ); 3138 3139 pFrame->mbSpezIME = (nImeProps & IME_PROP_SPECIAL_UI) != 0; 3140 pFrame->mbAtCursorIME = (nImeProps & IME_PROP_AT_CARET) != 0; 3141 pFrame->mbHandleIME = !pFrame->mbSpezIME; 3142 } 3143 #endif 3144 3145 // trigger input language and codepage update 3146 UINT nLang = pFrame->mnInputLang; 3147 ImplUpdateInputLang( pFrame ); 3148 debug_printf("ImplHandleInputLangChange new language 0x%04x\n",pFrame->mnInputLang); 3149 3150 // notify change 3151 if( nLang != pFrame->mnInputLang ) 3152 pFrame->CallCallback( SALEVENT_INPUTLANGUAGECHANGE, 0 ); 3153 3154 ImplSalYieldMutexRelease(); 3155 } 3156 3157 // ----------------------------------------------------------------------- 3158 3159 #ifdef ENABLE_IME 3160 3161 static long ImplHandleIMEStartConversion( Os2SalFrame* pFrame ) 3162 { 3163 long nRet = FALSE; 3164 SalIMEData* pIMEData = GetSalIMEData(); 3165 if ( pIMEData ) 3166 { 3167 HWND hWnd = pFrame->mhWndClient; 3168 HIMI hIMI = 0; 3169 pIMEData->mpGetIME( hWnd, &hIMI ); 3170 if ( hIMI ) 3171 { 3172 ULONG nProp; 3173 if ( 0 != pIMEData->mpQueryIMEProperty( hIMI, QIP_PROPERTY, &nProp ) ) 3174 pFrame->mbHandleIME = FALSE; 3175 else 3176 { 3177 pFrame->mbHandleIME = !(nProp & PRP_SPECIALUI); 3178 3179 } 3180 if ( pFrame->mbHandleIME ) 3181 { 3182 /* Windows-Code, der noch nicht angepasst wurde !!! 3183 // Cursor-Position ermitteln und aus der die Default-Position fuer 3184 // das Composition-Fenster berechnen 3185 SalCursorPosEvent aCursorPosEvt; 3186 pFrame->CallCallback( pFrame->mpInst, pFrame, 3187 SALEVENT_CURSORPOS, (void*)&aCursorPosEvt ); 3188 COMPOSITIONFORM aForm; 3189 memset( &aForm, 0, sizeof( aForm ) ); 3190 if ( !aCursorPosEvt.mnWidth || !aCursorPosEvt.mnHeight ) 3191 aForm.dwStyle |= CFS_DEFAULT; 3192 else 3193 { 3194 aForm.dwStyle |= CFS_POINT; 3195 aForm.ptCurrentPos.x = aCursorPosEvt.mnX; 3196 aForm.ptCurrentPos.y = aCursorPosEvt.mnY; 3197 } 3198 ImmSetCompositionWindow( hIMC, &aForm ); 3199 3200 // Den InputContect-Font ermitteln und diesem dem Composition-Fenster 3201 // bekannt machen 3202 */ 3203 3204 pFrame->mbConversionMode = TRUE; 3205 pFrame->CallCallback( SALEVENT_STARTEXTTEXTINPUT, (void*)NULL ); 3206 nRet = TRUE; 3207 } 3208 3209 pIMEData->mpReleaseIME( hWnd, hIMI ); 3210 } 3211 } 3212 3213 return nRet; 3214 } 3215 3216 // ----------------------------------------------------------------------- 3217 3218 static long ImplHandleIMEConversion( Os2SalFrame* pFrame, MPARAM nMP2Param ) 3219 { 3220 long nRet = FALSE; 3221 SalIMEData* pIMEData = GetSalIMEData(); 3222 if ( pIMEData ) 3223 { 3224 HWND hWnd = pFrame->mhWndClient; 3225 HIMI hIMI = 0; 3226 ULONG nMP2 = (ULONG)nMP2Param; 3227 pIMEData->mpGetIME( hWnd, &hIMI ); 3228 if ( hIMI ) 3229 { 3230 if ( nMP2 & (IMR_RESULT_RESULTSTRING | 3231 IMR_CONV_CONVERSIONSTRING | IMR_CONV_CONVERSIONATTR | 3232 IMR_CONV_CURSORPOS | IMR_CONV_CURSORATTR) ) 3233 { 3234 SalExtTextInputEvent aEvt; 3235 aEvt.mnTime = WinQueryMsgTime( pFrame->mhAB ); 3236 aEvt.mpTextAttr = NULL; 3237 aEvt.mnCursorPos = 0; 3238 aEvt.mnDeltaStart = 0; 3239 aEvt.mbOnlyCursor = FALSE; 3240 aEvt.mbCursorVisible = TRUE; 3241 3242 ULONG nBufLen = 0; 3243 xub_Unicode* pBuf = NULL; 3244 ULONG nAttrBufLen = 0; 3245 PM_BYTE* pAttrBuf = NULL; 3246 sal_Bool bLastCursor = FALSE; 3247 if ( nMP2 & IMR_RESULT_RESULTSTRING ) 3248 { 3249 pIMEData->mpGetResultString( hIMI, IMR_RESULT_RESULTSTRING, 0, &nBufLen ); 3250 if ( nBufLen > 0 ) 3251 { 3252 pBuf = new xub_Unicode[nBufLen]; 3253 pIMEData->mpGetResultString( hIMI, IMR_RESULT_RESULTSTRING, pBuf, &nBufLen ); 3254 } 3255 3256 bLastCursor = TRUE; 3257 aEvt.mbCursorVisible = TRUE; 3258 } 3259 else if ( nMP2 & (IMR_CONV_CONVERSIONSTRING | IMR_CONV_CONVERSIONATTR | 3260 IMR_CONV_CURSORPOS | IMR_CONV_CURSORATTR) ) 3261 { 3262 pIMEData->mpGetConversionString( hIMI, IMR_CONV_CONVERSIONSTRING, 0, &nBufLen ); 3263 if ( nBufLen > 0 ) 3264 { 3265 pBuf = new xub_Unicode[nBufLen]; 3266 pIMEData->mpGetConversionString( hIMI, IMR_CONV_CONVERSIONSTRING, pBuf, &nBufLen ); 3267 } 3268 3269 pIMEData->mpGetConversionString( hIMI, IMR_CONV_CONVERSIONATTR, 0, &nAttrBufLen ); 3270 if ( nAttrBufLen > 0 ) 3271 { 3272 pAttrBuf = new PM_BYTE[nAttrBufLen]; 3273 pIMEData->mpGetConversionString( hIMI, IMR_CONV_CONVERSIONATTR, pAttrBuf, &nAttrBufLen ); 3274 } 3275 3276 /* !!! Wir bekommen derzeit nur falsche Daten, deshalb zeigen wir derzeit 3277 !!! auch keine Cursor an 3278 ULONG nTempBufLen; 3279 ULONG nCursorPos = 0; 3280 ULONG nCursorAttr = 0; 3281 ULONG nChangePos = 0; 3282 nTempBufLen = sizeof( ULONG ); 3283 pIMEData->mpGetConversionString( hIMI, IMR_CONV_CURSORPOS, &nCursorPos, &nTempBufLen ); 3284 nTempBufLen = sizeof( ULONG ); 3285 pIMEData->mpGetConversionString( hIMI, IMR_CONV_CURSORATTR, &nCursorAttr, &nTempBufLen ); 3286 nTempBufLen = sizeof( ULONG ); 3287 pIMEData->mpGetConversionString( hIMI, IMR_CONV_CHANGESTART, &nChangePos, &nTempBufLen ); 3288 3289 aEvt.mnCursorPos = nCursorPos; 3290 aEvt.mnDeltaStart = nChangePos; 3291 if ( nCursorAttr & CP_CURSORATTR_INVISIBLE ) 3292 aEvt.mbCursorVisible = FALSE; 3293 */ 3294 aEvt.mnCursorPos = 0; 3295 aEvt.mnDeltaStart = 0; 3296 aEvt.mbCursorVisible = FALSE; 3297 3298 if ( (nMP2 == IMR_CONV_CURSORPOS) || 3299 (nMP2 == IMR_CONV_CURSORATTR) ) 3300 aEvt.mbOnlyCursor = TRUE; 3301 } 3302 3303 USHORT* pSalAttrAry = NULL; 3304 if ( pBuf ) 3305 { 3306 aEvt.maText = XubString( pBuf, (USHORT)nBufLen ); 3307 delete [] pBuf; 3308 if ( pAttrBuf ) 3309 { 3310 USHORT nTextLen = aEvt.maText.Len(); 3311 if ( nTextLen ) 3312 { 3313 pSalAttrAry = new USHORT[nTextLen]; 3314 memset( pSalAttrAry, 0, nTextLen*sizeof( USHORT ) ); 3315 for ( USHORT i = 0; (i < nTextLen) && (i < nAttrBufLen); i++ ) 3316 { 3317 PM_BYTE nOS2Attr = pAttrBuf[i]; 3318 USHORT nSalAttr; 3319 if ( nOS2Attr == CP_ATTR_TARGET_CONVERTED ) 3320 nSalAttr = SAL_EXTTEXTINPUT_ATTR_TARGETCONVERTED | SAL_EXTTEXTINPUT_ATTR_UNDERLINE | SAL_EXTTEXTINPUT_ATTR_HIGHLIGHT; 3321 else if ( nOS2Attr == CP_ATTR_CONVERTED ) 3322 nSalAttr = SAL_EXTTEXTINPUT_ATTR_CONVERTED | SAL_EXTTEXTINPUT_ATTR_DASHDOTUNDERLINE; 3323 else if ( nOS2Attr == CP_ATTR_TARGET_NOTCONVERTED ) 3324 nSalAttr = SAL_EXTTEXTINPUT_ATTR_TARGETNOTCONVERTED | SAL_EXTTEXTINPUT_ATTR_DOTTEDUNDERLINE; 3325 else if ( nOS2Attr == CP_ATTR_INPUT_ERROR ) 3326 nSalAttr = SAL_EXTTEXTINPUT_ATTR_INPUTERROR | SAL_EXTTEXTINPUT_ATTR_REDTEXT | SAL_EXTTEXTINPUT_ATTR_DOTTEDUNDERLINE; 3327 else /* ( nOS2Attr == CP_ATTR_INPUT ) */ 3328 nSalAttr = SAL_EXTTEXTINPUT_ATTR_INPUT | SAL_EXTTEXTINPUT_ATTR_DOTTEDUNDERLINE; 3329 pSalAttrAry[i] = nSalAttr; 3330 } 3331 aEvt.mpTextAttr = pSalAttrAry; 3332 } 3333 delete [] pAttrBuf; 3334 } 3335 if ( bLastCursor ) 3336 aEvt.mnCursorPos = aEvt.maText.Len(); 3337 } 3338 3339 pIMEData->mpReleaseIME( hWnd, hIMI ); 3340 3341 // Handler rufen und wenn wir ein Attribute-Array haben, danach 3342 // wieder zerstoeren 3343 pFrame->CallCallback( SALEVENT_EXTTEXTINPUT, (void*)&aEvt ); 3344 if ( pSalAttrAry ) 3345 delete [] pSalAttrAry; 3346 } 3347 else 3348 pIMEData->mpReleaseIME( hWnd, hIMI ); 3349 } 3350 3351 nRet = TRUE; 3352 } 3353 3354 return nRet; 3355 } 3356 3357 // ----------------------------------------------------------------------- 3358 3359 inline long ImplHandleIMEEndConversion( Os2SalFrame* pFrame ) 3360 { 3361 pFrame->mbConversionMode = FALSE; 3362 pFrame->CallCallback( SALEVENT_ENDEXTTEXTINPUT, (void*)NULL ); 3363 return TRUE; 3364 } 3365 3366 // ----------------------------------------------------------------------- 3367 3368 static void ImplHandleIMEOpenCandidate( Os2SalFrame* pFrame ) 3369 { 3370 pFrame->mbCandidateMode = TRUE; 3371 3372 long nRet = FALSE; 3373 SalIMEData* pIMEData = GetSalIMEData(); 3374 if ( pIMEData ) 3375 { 3376 HWND hWnd = pFrame->mhWndClient; 3377 HIMI hIMI = 0; 3378 pIMEData->mpGetIME( hWnd, &hIMI ); 3379 if ( hIMI ) 3380 { 3381 ULONG nBufLen = 0; 3382 pIMEData->mpGetConversionString( hIMI, IMR_CONV_CONVERSIONSTRING, 0, &nBufLen ); 3383 if ( nBufLen > 0 ) 3384 { 3385 /* !!! Wir bekommen derzeit nur falsche Daten steht der Cursor immer bei 0 3386 ULONG nTempBufLen = sizeof( ULONG ); 3387 ULONG nCursorPos = 0; 3388 pIMEData->mpGetConversionString( hIMI, IMR_CONV_CURSORPOS, &nCursorPos, &nTempBufLen ); 3389 */ 3390 ULONG nCursorPos = 0; 3391 3392 SalExtTextInputPosEvent aEvt; 3393 aEvt.mnTime = WinQueryMsgTime( pFrame->mhAB ); 3394 aEvt.mnFirstPos = nCursorPos; 3395 aEvt.mnChars = nBufLen-nCursorPos; 3396 aEvt.mpPosAry = new SalExtCharPos[aEvt.mnChars]; 3397 memset( aEvt.mpPosAry, 0, aEvt.mnChars*sizeof(SalExtCharPos) ); 3398 3399 pFrame->CallCallback( SALEVENT_EXTTEXTINPUTPOS, (void*)&aEvt ); 3400 3401 long nMinLeft = aEvt.mpPosAry[0].mnX; 3402 long nMinTop = aEvt.mpPosAry[0].mnY; 3403 long nMaxBottom = aEvt.mpPosAry[0].mnY+aEvt.mpPosAry[0].mnHeight; 3404 long nMaxRight = nMinLeft; 3405 USHORT i = 0; 3406 while ( i < aEvt.mnChars ) 3407 { 3408 // Solange wir uns auf der gleichen Zeile bewegen, 3409 // ermitteln wir die Rechteck-Grenzen 3410 if ( !aEvt.mpPosAry[i].mnHeight || 3411 (aEvt.mpPosAry[i].mnY < nMaxBottom-1) ) 3412 { 3413 if ( aEvt.mpPosAry[i].mnX < nMinLeft ) 3414 nMinLeft = aEvt.mpPosAry[i].mnX; 3415 if ( aEvt.mpPosAry[i].mnX+aEvt.mpPosAry[0].mnWidth > nMaxRight ) 3416 nMaxRight = aEvt.mpPosAry[i].mnX+aEvt.mpPosAry[0].mnWidth; 3417 if ( aEvt.mpPosAry[i].mnY < nMinTop ) 3418 nMinTop = aEvt.mpPosAry[i].mnY; 3419 i++; 3420 } 3421 else 3422 break; 3423 } 3424 3425 CANDIDATEPOS aForm; 3426 aForm.ulIndex = 0; 3427 aForm.ulStyle = CPS_EXCLUDE; 3428 aForm.ptCurrentPos.x = aEvt.mpPosAry[0].mnX; 3429 aForm.ptCurrentPos.y = pFrame->mnHeight - (nMaxBottom+1) - 1; 3430 aForm.rcArea.xLeft = nMinLeft; 3431 aForm.rcArea.yBottom = pFrame->mnHeight - nMaxBottom - 1; 3432 aForm.rcArea.xRight = nMaxRight+1; 3433 aForm.rcArea.yTop = pFrame->mnHeight - nMinTop - 1; 3434 pIMEData->mpSetCandidateWin( hIMI, &aForm ); 3435 3436 delete aEvt.mpPosAry; 3437 } 3438 3439 pIMEData->mpReleaseIME( hWnd, hIMI ); 3440 } 3441 } 3442 } 3443 3444 // ----------------------------------------------------------------------- 3445 3446 inline void ImplHandleIMECloseCandidate( Os2SalFrame* pFrame ) 3447 { 3448 pFrame->mbCandidateMode = FALSE; 3449 } 3450 3451 #endif 3452 3453 // ----------------------------------------------------------------------- 3454 3455 MRESULT EXPENTRY SalFrameWndProc( HWND hWnd, ULONG nMsg, 3456 MPARAM nMP1, MPARAM nMP2 ) 3457 { 3458 Os2SalFrame* pFrame = (Os2SalFrame*)GetWindowPtr( hWnd ); 3459 MRESULT nRet = (MRESULT)0; 3460 sal_Bool bDef = TRUE; 3461 bool bCheckTimers= false; 3462 3463 #if OSL_DEBUG_LEVEL>10 3464 if (nMsg!=WM_TIMER && nMsg!=WM_MOUSEMOVE) 3465 debug_printf( "SalFrameWndProc hWnd 0x%x nMsg 0x%x\n", hWnd, nMsg); 3466 #endif 3467 3468 switch( nMsg ) 3469 { 3470 case WM_MOUSEMOVE: 3471 case WM_BUTTON1DOWN: 3472 case WM_BUTTON2DOWN: 3473 case WM_BUTTON3DOWN: 3474 case WM_BUTTON1DBLCLK: 3475 case WM_BUTTON2DBLCLK: 3476 case WM_BUTTON3DBLCLK: 3477 case WM_BUTTON1UP: 3478 case WM_BUTTON2UP: 3479 case WM_BUTTON3UP: 3480 case SAL_MSG_MOUSELEAVE: 3481 // ButtonUp/Down nie an die WinDefWindowProc weiterleiten, weil sonst 3482 // die Message an den Owner weitergeleitet wird 3483 ImplSalYieldMutexAcquireWithWait(); 3484 bDef = !ImplHandleMouseMsg( hWnd, nMsg, nMP1, nMP2 ); 3485 ImplSalYieldMutexRelease(); 3486 break; 3487 3488 case WM_CHAR: 3489 if ( pFrame->mbConversionMode ) 3490 bDef = FALSE; 3491 else 3492 bDef = !ImplHandleKeyMsg( hWnd, nMsg, nMP1, nMP2 ); 3493 break; 3494 3495 case WM_ERASEBACKGROUND: 3496 nRet = (MRESULT)FALSE; 3497 bDef = FALSE; 3498 break; 3499 3500 case WM_PAINT: 3501 bCheckTimers = ImplHandlePaintMsg( hWnd ); 3502 bDef = FALSE; 3503 break; 3504 case SAL_MSG_POSTPAINT: 3505 ImplHandlePaintMsg2( hWnd, (RECTL*)nMP1 ); 3506 bCheckTimers = true; 3507 bDef = FALSE; 3508 break; 3509 3510 case WM_MOVE: 3511 case SAL_MSG_POSTMOVE: 3512 ImplHandleMoveMsg( hWnd ); 3513 bDef = FALSE; 3514 break; 3515 3516 case WM_SIZE: 3517 if ( ImplSalYieldMutexTryToAcquire() ) 3518 { 3519 ImplHandleSizeMsg( hWnd, nMP2 ); 3520 ImplSalYieldMutexRelease(); 3521 } 3522 else 3523 WinPostMsg( hWnd, SAL_MSG_POSTSIZE, nMP1, nMP2 ); 3524 break; 3525 case SAL_MSG_POSTSIZE: 3526 ImplHandleSizeMsg( hWnd, nMP2 ); 3527 break; 3528 case WM_MINMAXFRAME: 3529 if ( ImplSalYieldMutexTryToAcquire() ) 3530 { 3531 PSWP pswp = (PSWP) nMP1; 3532 ImplHandleSizeMsg( hWnd, MPFROM2SHORT( pswp->cx, pswp->cy) ); 3533 ImplSalYieldMutexRelease(); 3534 } 3535 else 3536 WinPostMsg( hWnd, SAL_MSG_POSTSIZE, 0, nMP2 ); 3537 break; 3538 3539 case WM_CALCVALIDRECTS: 3540 return (MRESULT)(CVR_ALIGNLEFT | CVR_ALIGNTOP); 3541 3542 case WM_SETFOCUS: 3543 if ( ImplSalYieldMutexTryToAcquire() ) 3544 { 3545 ImplHandleFocusMsg( pFrame, nMP2 ); 3546 ImplSalYieldMutexRelease(); 3547 } 3548 else 3549 WinPostMsg( hWnd, SAL_MSG_POSTFOCUS, 0, nMP2 ); 3550 break; 3551 case SAL_MSG_POSTFOCUS: 3552 ImplHandleFocusMsg( pFrame, nMP2 ); 3553 break; 3554 3555 case WM_TRANSLATEACCEL: 3556 { 3557 // Da uns OS/2 zu viele Tasten abfaegnt, unternehmen wir etwas, 3558 // damit wir Shift+F1, Shift+F10 und Shift+Enter bekommen 3559 PQMSG pMsg = (PQMSG)nMP1; 3560 USHORT nKeyFlags = SHORT1FROMMP( pMsg->mp1 ); 3561 USHORT nKeyCode = (UCHAR)SHORT2FROMMP( pMsg->mp2 ); 3562 3563 if ( !(nKeyFlags & KC_KEYUP) && (nKeyFlags & KC_VIRTUALKEY) && 3564 (nKeyFlags & KC_SHIFT) && (nKeyCode != VK_ESC) ) 3565 return (MRESULT)FALSE; 3566 3567 if ( nKeyCode == VK_F1 ) 3568 return (MRESULT)FALSE; 3569 } 3570 break; 3571 3572 case WM_CREATE: 3573 { 3574 HWND hWndFrame = WinQueryWindow(hWnd, QW_PARENT); 3575 if (hWndFrame == 0) 3576 debug_printf(" WARNING NULL FRAME!!\n"); 3577 SalData* pSalData = GetSalData(); 3578 // Window-Instanz am Windowhandle speichern 3579 pFrame = pSalData->mpCreateFrame; 3580 pSalData->mpCreateFrame = NULL; 3581 SetWindowPtr( hWnd, pFrame ); 3582 SetWindowPtr( hWndFrame, pFrame); 3583 // HWND schon hier setzen, da schon auf den Instanzdaten 3584 // gearbeitet werden kann, wenn Messages waehrend 3585 // CreateWindow() gesendet werden 3586 pFrame->mhWndClient = hWnd; 3587 pFrame->mhWndFrame = hWndFrame; 3588 pFrame->maSysData.hWnd = hWnd; 3589 } 3590 break; 3591 3592 case WM_CLOSE: 3593 ImplHandleCloseMsg( hWnd ); 3594 bDef = FALSE; 3595 break; 3596 3597 case WM_SYSVALUECHANGED: 3598 if ( pFrame->mbFullScreen ) 3599 ImplSalFrameFullScreenPos( pFrame ); 3600 // kein break, da der Rest auch noch verarbeitet werden soll 3601 case PL_ALTERED: 3602 case WM_SYSCOLORCHANGE: 3603 ImplSalYieldMutexAcquire(); 3604 pFrame->CallCallback( SALEVENT_SETTINGSCHANGED, 0 ); 3605 ImplSalYieldMutexRelease(); 3606 break; 3607 3608 case SAL_MSG_USEREVENT: 3609 ImplHandleUserEvent( hWnd, nMP2 ); 3610 bDef = FALSE; 3611 break; 3612 case SAL_MSG_TOTOP: 3613 ImplSalToTop( hWnd, (ULONG)nMP1 ); 3614 bDef = FALSE; 3615 break; 3616 case SAL_MSG_SHOW: 3617 ImplSalShow( hWnd, (ULONG)nMP1, (ULONG)nMP2 ); 3618 bDef = FALSE; 3619 break; 3620 3621 case WM_KBDLAYERCHANGED: 3622 debug_printf("hWnd 0x%08x WM_KBDLAYERCHANGED\n", hWnd); 3623 ImplHandleInputLangChange( hWnd ); 3624 break; 3625 3626 case WM_HSCROLL: 3627 case WM_VSCROLL: 3628 ImplHandleWheelMsg( hWnd, nMsg, nMP1, nMP2 ); 3629 bDef = FALSE; 3630 break; 3631 3632 case WM_COMMAND: 3633 case SAL_MSG_SYSPROCESSMENU: 3634 if ( SalImplHandleProcessMenu( pFrame, nMsg, nMP1, nMP2 ) ) 3635 { 3636 bDef = FALSE; 3637 nRet = (MRESULT)1; 3638 } 3639 break; 3640 3641 #ifdef ENABLE_IME 3642 case WM_IMEREQUEST: 3643 if ( (ULONG)nMP1 == IMR_CONVRESULT ) 3644 { 3645 if ( pFrame->mbHandleIME ) 3646 { 3647 // Nur im Conversionmodus akzeptieren wir den IME-Input 3648 if ( pFrame->mbConversionMode ) 3649 { 3650 ImplSalYieldMutexAcquire(); 3651 if ( ImplHandleIMEConversion( pFrame, nMP2 ) ) 3652 { 3653 bDef = FALSE; 3654 nRet = (MRESULT)TRUE; 3655 } 3656 ImplSalYieldMutexRelease(); 3657 } 3658 } 3659 } 3660 else if ( (ULONG)nMP1 == IMR_CANDIDATE ) 3661 { 3662 if ( pFrame->mbHandleIME ) 3663 { 3664 ImplSalYieldMutexAcquire(); 3665 if ( (ULONG)nMP2 & IMR_CANDIDATE_SHOW ) 3666 ImplHandleIMEOpenCandidate( pFrame ); 3667 else if ( (ULONG)nMP2 & IMR_CANDIDATE_HIDE ) 3668 ImplHandleIMECloseCandidate( pFrame ); 3669 ImplSalYieldMutexRelease(); 3670 } 3671 } 3672 break; 3673 3674 case WM_IMENOTIFY: 3675 if ( (ULONG)nMP1 == IMN_STARTCONVERSION ) 3676 { 3677 ImplSalYieldMutexAcquire(); 3678 if ( ImplHandleIMEStartConversion( pFrame ) ) 3679 { 3680 bDef = FALSE; 3681 nRet = (MRESULT)TRUE; 3682 } 3683 ImplSalYieldMutexRelease(); 3684 } 3685 else if ( (ULONG)nMP1 == IMN_ENDCONVERSION ) 3686 { 3687 if ( pFrame->mbHandleIME ) 3688 { 3689 ImplSalYieldMutexAcquire(); 3690 if ( ImplHandleIMEEndConversion( pFrame ) ) 3691 { 3692 bDef = FALSE; 3693 nRet = (MRESULT)TRUE; 3694 } 3695 ImplSalYieldMutexRelease(); 3696 } 3697 } 3698 break; 3699 #endif 3700 } 3701 3702 if( bCheckTimers ) 3703 { 3704 SalData* pSalData = GetSalData(); 3705 if( pSalData->mnNextTimerTime ) 3706 { 3707 ULONG nCurTime; 3708 DosQuerySysInfo( QSV_MS_COUNT, QSV_MS_COUNT, (PVOID)&nCurTime, sizeof(ULONG)); 3709 if( pSalData->mnNextTimerTime < nCurTime ) 3710 { 3711 QMSG aMsg; 3712 if (!WinPeekMsg( pFrame->mhAB, &aMsg, 0, WM_PAINT, WM_PAINT, PM_NOREMOVE ) ) 3713 WinPostMsg( pSalData->mpFirstInstance->mhComWnd, SAL_MSG_POSTTIMER, 0, (MPARAM)nCurTime ); 3714 } 3715 } 3716 } 3717 3718 if ( bDef ) 3719 nRet = WinDefWindowProc( hWnd, nMsg, nMP1, nMP2 ); 3720 3721 return nRet; 3722 } 3723 3724 // ----------------------------------------------------------------------- 3725 3726 void Os2SalFrame::ResetClipRegion() 3727 { 3728 } 3729 3730 void Os2SalFrame::BeginSetClipRegion( ULONG ) 3731 { 3732 } 3733 3734 void Os2SalFrame::UnionClipRegion( long, long, long, long ) 3735 { 3736 } 3737 3738 void Os2SalFrame::EndSetClipRegion() 3739 { 3740 } 3741 3742 // ----------------------------------------------------------------------- 3743 3744 MRESULT EXPENTRY SalFrameSubClassWndProc( HWND hWnd, ULONG nMsg, 3745 MPARAM nMP1, MPARAM nMP2 ) 3746 { 3747 MRESULT mReturn = 0L; 3748 3749 // ticket#124 min size of 132 px is too much 3750 if (nMsg == WM_QUERYTRACKINFO) { 3751 PTRACKINFO pti; 3752 // first, let PM initialize TRACKINFO 3753 mReturn = aSalShlData.mpFrameProc( hWnd, nMsg, nMP1, nMP2 ); 3754 // now change default min size 3755 pti = (PTRACKINFO) nMP2; 3756 pti->ptlMinTrackSize.x = 64L; 3757 // now return to PM 3758 return mReturn; 3759 } 3760 3761 return aSalShlData.mpFrameProc( hWnd, nMsg, nMP1, nMP2 ); 3762 } 3763 3764 // ----------------------------------------------------------------------- 3765