xref: /aoo4110/main/vcl/os2/source/window/salframe.cxx (revision b1cdbd2c)
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 #define VCL_OS2
28 #include <svpm.h>
29 
30 #include <string.h>
31 
32 #include <tools/svwin.h>
33 
34 // =======================================================================
35 
36 #define _SV_SALFRAME_CXX
37 
38 #ifndef DEBUG_HXX
39 #include <tools/debug.hxx>
40 #endif
41 
42 #define private public
43 
44 #include "os2/sallang.hxx"
45 #include "os2/salids.hrc"
46 #include "os2/saldata.hxx"
47 #include "os2/salinst.h"
48 #include "os2/salgdi.h"
49 #include "os2/salframe.h"
50 #include "os2/saltimer.h"
51 
52 #include <vcl/timer.hxx>
53 #include <vcl/settings.hxx>
54 #include <vcl/keycodes.hxx>
55 
56 #if OSL_DEBUG_LEVEL>10
57 extern "C" int debug_printf(const char *f, ...);
58 
59 static sal_Bool _bCapture;
60 
61 #else
62 #define debug_printf( ...) { 1; }
63 #endif
64 
65 // =======================================================================
66 
67 #undef WinEnableMenuItem
68 #define WinEnableMenuItem(hwndMenu,id,fEnable) \
69     ((PM_BOOL)WinSendMsg (hwndMenu, MM_SETITEMATTR, MPFROM2SHORT (id, TRUE), \
70 		       MPFROM2SHORT (MIA_DISABLED, \
71 				     ((USHORT)(fEnable) ? 0 : MIA_DISABLED))))
72 
73 // =======================================================================
74 
75 HPOINTER ImplLoadPointer( ULONG nId );
76 
77 static void SetMaximizedFrameGeometry( HWND hWnd, Os2SalFrame* pFrame );
78 static void UpdateFrameGeometry( HWND hWnd, Os2SalFrame* pFrame );
79 static void ImplSalCalcFrameSize( HWND hWnd,
80                                   LONG& nFrameX, LONG& nFrameY, LONG& nCaptionY );
81 static void ImplSalCalcFrameSize( const Os2SalFrame* pFrame,
82                                   LONG& nFrameX, LONG& nFrameY, LONG& nCaptionY );
83 MRESULT EXPENTRY SalFrameSubClassWndProc( HWND hWnd, ULONG nMsg,
84                                   MPARAM nMP1, MPARAM nMP2 );
85 
86 // =======================================================================
87 
88 static LanguageType eImplKeyboardLanguage = LANGUAGE_DONTKNOW;
89 sal_Bool Os2SalFrame::mbInReparent = FALSE;
90 ULONG Os2SalFrame::mnInputLang = 0;
91 
92 // =======================================================================
93 
94 // define a new flag
95 #define SWP_CENTER			(SWP_NOAUTOCLOSE<<4)
96 #define SWP_SHOWMAXIMIZED	(SWP_ACTIVATE | SWP_SHOW | SWP_MAXIMIZE)
97 #define SWP_SHOWMINIMIZED	(SWP_ACTIVATE | SWP_SHOW | SWP_MINIMIZE)
98 #define SWP_SHOWNORMAL		(SWP_ACTIVATE | SWP_SHOW | SWP_RESTORE)
99 
100 static LONG nScreenHeight  = WinQuerySysValue( HWND_DESKTOP, SV_CYSCREEN);
101 static LONG nScreenWidth   = WinQuerySysValue( HWND_DESKTOP, SV_CXSCREEN );
102 
_WinQueryWindowRect(HWND hwnd,PRECTL prclDest)103 sal_Bool APIENTRY _WinQueryWindowRect( HWND hwnd, PRECTL prclDest)
104 {
105 	sal_Bool rc = WinQueryWindowRect( hwnd, prclDest);
106 	ULONG tmp = prclDest->yBottom;
107 	prclDest->yBottom = prclDest->yTop;
108 	prclDest->yTop = tmp;
109 	return rc;
110 }
111 
_WinQueryPointerPos(HWND hwndDesktop,PPOINTL pptl)112 sal_Bool APIENTRY _WinQueryPointerPos (HWND hwndDesktop, PPOINTL pptl)
113 {
114 	sal_Bool rc = WinQueryPointerPos( hwndDesktop, pptl);
115 	pptl->y = nScreenHeight - pptl->y;
116 	return rc;
117 }
118 
_WinQueryWindowPos(Os2SalFrame * pFrame,PSWP pswp)119 sal_Bool APIENTRY _WinQueryWindowPos( Os2SalFrame* pFrame, PSWP pswp)
120 {
121 	SWP swpOwner;
122 	sal_Bool rc = WinQueryWindowPos( pFrame->mhWndFrame, pswp);
123 
124 #if OSL_DEBUG_LEVEL>1
125 	debug_printf( "> WinQueryWindowPos hwnd %x at %d,%d (%dx%d)\n",
126 					pFrame->mhWndFrame, pswp->x, pswp->y, pswp->cx, pswp->cy);
127 #endif
128 
129 	Os2SalFrame* pParentFrame = pFrame->mpParentFrame;
130 
131 	//YD adjust to owner coordinates
132 	if ( pParentFrame )
133 	{
134 		POINTL ptlOwner = {0};
135 
136 		// coords are relative to screen, map to parent frame client area
137 		ptlOwner.x = pswp->x;
138 		ptlOwner.y = pswp->y;
139 		WinMapWindowPoints( HWND_DESKTOP, pParentFrame->mhWndClient, &ptlOwner, 1);
140 		pswp->x = ptlOwner.x;
141 		pswp->y = ptlOwner.y;
142 		// get parent client area size
143 		WinQueryWindowPos( pParentFrame->mhWndClient, &swpOwner);
144 	} else
145 	{
146 		// no owner info, use DESKTOP????
147 		swpOwner.cx = nScreenWidth;
148 		swpOwner.cy = nScreenHeight;
149 	}
150 
151 	// invert Y coordinate
152 	pswp->y = swpOwner.cy - (pswp->y + pswp->cy);
153 
154 #if OSL_DEBUG_LEVEL>1
155 	debug_printf( "< WinQueryWindowPos hwnd %x at %d,%d (%dx%d)\n",
156 					pFrame->mhWndFrame, pswp->x, pswp->y, pswp->cx, pswp->cy);
157 #endif
158 	return rc;
159 }
160 
_WinSetWindowPos(Os2SalFrame * pFrame,HWND hwndInsertBehind,LONG x,LONG y,LONG cx,LONG cy,ULONG fl)161 sal_Bool APIENTRY _WinSetWindowPos( Os2SalFrame* pFrame, HWND hwndInsertBehind, LONG x, LONG y,
162     LONG cx, LONG cy, ULONG fl)
163 {
164 	SWP 	swpOwner = {0};
165 	POINTL 	ptlOwner = {0};
166 	HWND	hParent = NULL;
167 
168 #if OSL_DEBUG_LEVEL>1
169 	debug_printf( ">WinSetWindowPos hwnd %x at %d,%d (%dx%d) fl 0x%08x\n",
170 					pFrame->mhWndFrame, x, y, cx, cy, fl);
171 #endif
172 
173 	// first resize window if requested
174 	if ( (fl & SWP_SIZE) ) {
175 		ULONG	flag = SWP_SIZE;
176 		LONG	nX = 0, nY = 0;
177 		LONG	frameFrameX, frameFrameY, frameCaptionY;
178 
179 		ImplSalCalcFrameSize( pFrame, frameFrameX, frameFrameY, frameCaptionY );
180 		// if we change y size, we need to move the window down
181 		// because os2 window origin is lower left corner
182 		if (pFrame->maGeometry.nHeight != cy) {
183 			SWP		aSWP;
184 			WinQueryWindowPos( pFrame->mhWndFrame, &aSWP);
185 			nX = aSWP.x;
186 			nY = aSWP.y - (cy + 2*frameFrameY + frameCaptionY - aSWP.cy);
187 			flag |= SWP_MOVE;
188 		}
189 		WinSetWindowPos( pFrame->mhWndFrame, NULL, nX, nY,
190 			cx+2*frameFrameX, cy+2*frameFrameY+frameCaptionY, flag);
191 		fl = fl & ~SWP_SIZE;
192 	}
193 	else // otherwise get current size
194 	{
195 		SWP swp = {0};
196 		WinQueryWindowPos( pFrame->mhWndClient, &swp);
197 		cx = swp.cx;
198 		cy = swp.cy;
199 	}
200 
201 	// get parent window handle
202 	Os2SalFrame* pParentFrame = pFrame->mpParentFrame;
203 
204 	// use desktop if parent is not defined
205 	hParent = pParentFrame ? pParentFrame->mhWndClient : HWND_DESKTOP;
206 	// if parent is not visible, use desktop as reference
207 	hParent = WinIsWindowVisible( hParent) ? hParent : HWND_DESKTOP;
208 
209 	WinQueryWindowPos( hParent, &swpOwner);
210 
211 	//YD adjust to owner coordinates only when moving and not centering
212 	//if (!(fl & SWP_CENTER) && (fl & SWP_MOVE))
213 	if ((fl & SWP_MOVE))
214 	{
215 
216 		// if SWP_CENTER is specified, change position to parent center
217 		if (fl & SWP_CENTER) {
218 			ptlOwner.x = (swpOwner.cx - cx) / 2;
219 			ptlOwner.y = (swpOwner.cy - cy) / 2;
220 #if OSL_DEBUG_LEVEL>0
221 			debug_printf( "_WinSetWindowPos SWP_CENTER\n");
222 #endif
223 			fl = fl & ~SWP_CENTER;
224 		} else {
225 			// coords are relative to parent frame client area, map to screen
226 			// map Y to OS/2 system coordinates
227 			ptlOwner.x = x;
228 			ptlOwner.y = swpOwner.cy - (y + cy);
229 
230 #if OSL_DEBUG_LEVEL>0
231 			debug_printf( "_WinSetWindowPos owner 0x%x at %d,%d (%dx%d) OS2\n",
232 				hParent, ptlOwner.x, ptlOwner.y, swpOwner.cx, swpOwner.cy);
233 #endif
234 		}
235 		// map from client area to screen
236 		WinMapWindowPoints( hParent, HWND_DESKTOP, &ptlOwner, 1);
237 		x = ptlOwner.x;
238 		y = ptlOwner.y;
239 
240 #if OSL_DEBUG_LEVEL>0
241 		debug_printf( "_WinSetWindowPos owner 0x%x at %d,%d (%dx%d) MAPPED OS2\n",
242 			hParent, ptlOwner.x, ptlOwner.y, swpOwner.cx, swpOwner.cy);
243 #endif
244 	}
245 
246 #if OSL_DEBUG_LEVEL>0
247 	debug_printf( "<WinSetWindowPos hwnd %x at %d,%d (%dx%d) fl=%x\n",
248 					pFrame->mhWndFrame, x, y, cx, cy, fl);
249 #endif
250 	return WinSetWindowPos( pFrame->mhWndFrame, hwndInsertBehind, x, y, 0, 0, fl);
251 }
252 
253 // =======================================================================
254 
255 #if OSL_DEBUG_LEVEL > 0
dumpWindowInfo(char * fnc,HWND hwnd)256 static void dumpWindowInfo( char* fnc, HWND hwnd)
257 {
258 	SWP aSWP;
259 	HWND	hwnd2;
260 	char	szTitle[256];
261 
262 #if 0
263 	_WinQueryWindowPos( hwnd, &aSWP );
264 	strcpy(szTitle,"");
265 	WinQueryWindowText(hwnd, sizeof(szTitle), szTitle);
266 	debug_printf( "%s: window %08x at %d,%d (size %dx%d) '%s'\n", fnc, hwnd,
267 				aSWP.x, aSWP.y, aSWP.cx, aSWP.cy, szTitle);
268 	hwnd2 = WinQueryWindow(hwnd, QW_PARENT);
269 	_WinQueryWindowPos( hwnd2, &aSWP );
270 	strcpy(szTitle,"");
271 	WinQueryWindowText(hwnd2, sizeof(szTitle), szTitle);
272 	debug_printf( "%s: parent %08x at %d,%d (size %dx%d) '%s'\n", fnc, hwnd2,
273 				aSWP.x, aSWP.y, aSWP.cx, aSWP.cy, szTitle);
274 	hwnd2 = WinQueryWindow(hwnd, QW_OWNER);
275 	_WinQueryWindowPos( hwnd2, &aSWP );
276 	strcpy(szTitle,"");
277 	WinQueryWindowText(hwnd2, sizeof(szTitle), szTitle);
278 	debug_printf( "%s: owner %08x at %d,%d (size %dx%d) '%s'\n", fnc, hwnd2,
279 				aSWP.x, aSWP.y, aSWP.cx, aSWP.cy, szTitle);
280 #endif
281 }
282 #endif
283 
284 // =======================================================================
285 
286 #ifdef ENABLE_IME
287 
288 struct ImplSalIMEProc
289 {
290     ULONG       nOrd;
291     PFN*        pProc;
292 };
293 
294 #define SAL_IME_PROC_COUNT          12
295 
296 // -----------------------------------------------------------------------
297 
GetSalIMEData()298 static SalIMEData* GetSalIMEData()
299 {
300     SalData* pSalData = GetSalData();
301 
302     if ( !pSalData->mbIMEInit )
303     {
304         pSalData->mbIMEInit = TRUE;
305 
306         HMODULE hMod = 0;
307         if ( 0 == DosLoadModule( NULL, 0, "OS2IM", &hMod ) )
308         {
309             SalIMEData*     pIMEData = new SalIMEData;
310             sal_Bool            bError = FALSE;
311             ImplSalIMEProc  aProcAry[SAL_IME_PROC_COUNT] =
312             {
313             { 101, (PFN*)&(pIMEData->mpAssocIME) },
314             { 104, (PFN*)&(pIMEData->mpGetIME) },
315             { 106, (PFN*)&(pIMEData->mpReleaseIME) },
316             { 117, (PFN*)&(pIMEData->mpSetConversionFont) },
317             { 144, (PFN*)&(pIMEData->mpSetConversionFontSize) },
318             { 118, (PFN*)&(pIMEData->mpGetConversionString) },
319             { 122, (PFN*)&(pIMEData->mpGetResultString) },
320             { 115, (PFN*)&(pIMEData->mpSetCandidateWin) },
321             { 130, (PFN*)&(pIMEData->mpQueryIMEProperty) },
322             { 131, (PFN*)&(pIMEData->mpRequestIME) },
323             { 128, (PFN*)&(pIMEData->mpSetIMEMode) },
324             { 127, (PFN*)&(pIMEData->mpQueryIMEMode) }
325             };
326 
327             pIMEData->mhModIME = hMod;
328             for ( USHORT i = 0; i < SAL_IME_PROC_COUNT; i++ )
329             {
330                 if ( 0 != DosQueryProcAddr( pIMEData->mhModIME, aProcAry[i].nOrd, 0, aProcAry[i].pProc ) )
331                 {
332                     bError = TRUE;
333                     break;
334                 }
335             }
336 
337             if ( bError )
338             {
339                 DosFreeModule( pIMEData->mhModIME );
340                 delete pIMEData;
341             }
342             else
343                 pSalData->mpIMEData = pIMEData;
344         }
345     }
346 
347     return pSalData->mpIMEData;
348 }
349 
350 // -----------------------------------------------------------------------
351 
ImplReleaseSALIMEData()352 void ImplReleaseSALIMEData()
353 {
354     SalData* pSalData = GetSalData();
355 
356     if ( pSalData->mpIMEData )
357     {
358         DosFreeModule( pSalData->mpIMEData->mhModIME );
359         delete pSalData->mpIMEData;
360     }
361 }
362 
363 #endif
364 
365 // =======================================================================
366 
ImplSaveFrameState(Os2SalFrame * pFrame)367 static void ImplSaveFrameState( Os2SalFrame* pFrame )
368 {
369     // Position, Groesse und Status fuer GetWindowState() merken
370     if ( !pFrame->mbFullScreen )
371     {
372         SWP aSWP;
373         sal_Bool bVisible = WinIsWindowVisible( pFrame->mhWndFrame);
374 
375         // Query actual state (maState uses screen coords)
376         WinQueryWindowPos( pFrame->mhWndFrame, &aSWP );
377 
378         if ( aSWP.fl & SWP_MINIMIZE )
379         {
380 #if OSL_DEBUG_LEVEL>0
381 			debug_printf("Os2SalFrame::GetWindowState %08x SAL_FRAMESTATE_MINIMIZED\n",
382 					pFrame->mhWndFrame);
383 #endif
384             pFrame->maState.mnState |= SAL_FRAMESTATE_MINIMIZED;
385             if ( bVisible )
386                 pFrame->mnShowState = SWP_SHOWMAXIMIZED;
387         }
388         else if ( aSWP.fl & SWP_MAXIMIZE )
389         {
390 #if OSL_DEBUG_LEVEL>0
391 			debug_printf("Os2SalFrame::GetWindowState %08x SAL_FRAMESTATE_MAXIMIZED\n",
392 					pFrame->mhWndFrame);
393 #endif
394             pFrame->maState.mnState &= ~SAL_FRAMESTATE_MINIMIZED;
395             pFrame->maState.mnState |= SAL_FRAMESTATE_MAXIMIZED;
396             if ( bVisible )
397                 pFrame->mnShowState = SWP_SHOWMINIMIZED;
398             pFrame->mbRestoreMaximize = TRUE;
399         }
400         else
401         {
402 			LONG nFrameX, nFrameY, nCaptionY;
403 			ImplSalCalcFrameSize( pFrame, nFrameX, nFrameY, nCaptionY );
404 			// to be consistent with Unix, the frame state is without(!) decoration
405 			long nTopDeco = nFrameY + nCaptionY;
406 			long nLeftDeco = nFrameX;
407 			long nBottomDeco = nFrameY;
408 			long nRightDeco = nFrameX;
409 
410             pFrame->maState.mnState &= ~(SAL_FRAMESTATE_MINIMIZED | SAL_FRAMESTATE_MAXIMIZED);
411             // subtract decoration, store screen coords
412             pFrame->maState.mnX      = aSWP.x+nLeftDeco;
413             pFrame->maState.mnY      = nScreenHeight - (aSWP.y+aSWP.cy)+nTopDeco;
414             pFrame->maState.mnWidth  = aSWP.cx-nLeftDeco-nRightDeco;
415             pFrame->maState.mnHeight = aSWP.cy-nTopDeco-nBottomDeco;
416 #if OSL_DEBUG_LEVEL>0
417 			debug_printf("Os2SalFrame::GetWindowState %08x (%dx%d) at %d,%d VCL\n",
418 					pFrame->mhWndFrame,
419 					pFrame->maState.mnWidth,pFrame->maState.mnHeight,pFrame->maState.mnX,pFrame->maState.mnY);
420 #endif
421             if ( bVisible )
422                 pFrame->mnShowState = SWP_SHOWNORMAL;
423             pFrame->mbRestoreMaximize = FALSE;
424 			//debug_printf( "ImplSaveFrameState: window %08x at %d,%d (size %dx%d)\n",
425 			//	pFrame->mhWndFrame,
426 			//	pFrame->maState.mnX, pFrame->maState.mnY, pFrame->maState.mnWidth, pFrame->maState.mnHeight);
427         }
428     }
429 }
430 
431 // -----------------------------------------------------------------------
432 
ImplSalCallbackDummy(void *,SalFrame *,USHORT,const void *)433 long ImplSalCallbackDummy( void*, SalFrame*, USHORT, const void* )
434 {
435     return 0;
436 }
437 
438 // -----------------------------------------------------------------------
439 
ImplSalCalcFrameSize(HWND hWnd,LONG & nFrameX,LONG & nFrameY,LONG & nCaptionY)440 static void ImplSalCalcFrameSize( HWND hWnd,
441                                   LONG& nFrameX, LONG& nFrameY, LONG& nCaptionY )
442 {
443     Os2SalFrame* pFrame = GetWindowPtr( hWnd );
444     if ( !pFrame )
445         return;
446 	return ImplSalCalcFrameSize( pFrame, nFrameX, nFrameY, nCaptionY );
447 }
448 
ImplSalCalcFrameSize(const Os2SalFrame * pFrame,LONG & nFrameX,LONG & nFrameY,LONG & nCaptionY)449 static void ImplSalCalcFrameSize( const Os2SalFrame* pFrame,
450                                   LONG& nFrameX, LONG& nFrameY, LONG& nCaptionY )
451 {
452     if ( pFrame->mbSizeBorder )
453     {
454         nFrameX = WinQuerySysValue( HWND_DESKTOP, SV_CXSIZEBORDER );
455         nFrameY = WinQuerySysValue( HWND_DESKTOP, SV_CYSIZEBORDER );
456     }
457     else if ( pFrame->mbFixBorder )
458     {
459         nFrameX = WinQuerySysValue( HWND_DESKTOP, SV_CXDLGFRAME );
460         nFrameY = WinQuerySysValue( HWND_DESKTOP, SV_CYDLGFRAME );
461     }
462     else if ( pFrame->mbBorder )
463     {
464         nFrameX = WinQuerySysValue( HWND_DESKTOP, SV_CXBORDER );
465         nFrameY = WinQuerySysValue( HWND_DESKTOP, SV_CYBORDER );
466     }
467     else
468     {
469         nFrameX = 0;
470         nFrameY = 0;
471     }
472     if ( pFrame->mbCaption )
473         nCaptionY = WinQuerySysValue( HWND_DESKTOP, SV_CYTITLEBAR );
474     else
475         nCaptionY = 0;
476 
477 #if OSL_DEBUG_LEVEL>0
478 	//if (_bCapture)
479 		debug_printf("ImplSalCalcFrameSize 0x%08x x=%d y=%d t=%d\n", pFrame->mhWndFrame, nFrameX, nFrameY, nCaptionY);
480 #endif
481 }
482 
483 // -----------------------------------------------------------------------
484 
ImplSalCalcFullScreenSize(const Os2SalFrame * pFrame,LONG & rX,LONG & rY,LONG & rDX,LONG & rDY)485 static void ImplSalCalcFullScreenSize( const Os2SalFrame* pFrame,
486                                        LONG& rX, LONG& rY, LONG& rDX, LONG& rDY )
487 {
488     // set window to screen size
489     LONG nFrameX, nFrameY, nCaptionY;
490     LONG rScreenDX = WinQuerySysValue( HWND_DESKTOP, SV_CXSCREEN );
491     LONG rScreenDY = WinQuerySysValue( HWND_DESKTOP, SV_CYSCREEN );
492 
493     // Framegroessen berechnen
494     ImplSalCalcFrameSize( pFrame, nFrameX, nFrameY, nCaptionY );
495 
496     rX  = -nFrameX;
497     rY  = -(nFrameY+nCaptionY);
498     rDX = rScreenDX+(nFrameX*2);
499     rDY = rScreenDY+(nFrameY*2)+nCaptionY;
500 }
501 
502 // -----------------------------------------------------------------------
503 
ImplSalFrameFullScreenPos(Os2SalFrame * pFrame,sal_Bool bAlways=FALSE)504 static void ImplSalFrameFullScreenPos( Os2SalFrame* pFrame, sal_Bool bAlways = FALSE )
505 {
506     SWP aSWP;
507     _WinQueryWindowPos( pFrame, &aSWP );
508     if ( bAlways || !(aSWP.fl & SWP_MINIMIZE) )
509     {
510         // set window to screen size
511         LONG nX;
512         LONG nY;
513         LONG nWidth;
514         LONG nHeight;
515         ImplSalCalcFullScreenSize( pFrame, nX, nY, nWidth, nHeight );
516         _WinSetWindowPos( pFrame, 0,
517                          nX, nY, nWidth, nHeight,
518                          SWP_MOVE | SWP_SIZE );
519     }
520 }
521 
522 // -----------------------------------------------------------------------
523 
524 // Uebersetzungstabelle von System-Keycodes in StarView-Keycodes
525 #define KEY_TAB_SIZE     (VK_ENDDRAG+1)
526 
527 static USHORT aImplTranslateKeyTab[KEY_TAB_SIZE] =
528 {
529     // StarView-Code      System-Code                         Index
530     0,                    //                                  0x00
531     0,                    // VK_BUTTON1                       0x01
532     0,                    // VK_BUTTON2                       0x02
533     0,                    // VK_BUTTON3                       0x03
534     0,                    // VK_BREAK                         0x04
535     KEY_BACKSPACE,        // VK_BACKSPACE                     0x05
536     KEY_TAB,              // VK_TAB                           0x06
537     KEY_TAB,              // VK_BACKTAB                       0x07
538     KEY_RETURN,           // VK_NEWLINE                       0x08
539     0,                    // VK_SHIFT                         0x09
540     0,                    // VK_CTRL                          0x0A
541     0,                    // VK_ALT                           0x0B
542     0,                    // VK_ALTGRAF                       0x0C
543     0,                    // VK_PAUSE                         0x0D
544     0,                    // VK_CAPSLOCK                      0x0E
545     KEY_ESCAPE,           // VK_ESC                           0x0F
546     KEY_SPACE,            // VK_SPACE                         0x10
547     KEY_PAGEUP,           // VK_PAGEUP                        0x11
548     KEY_PAGEDOWN,         // VK_PAGEDOWN                      0x12
549     KEY_END,              // VK_END                           0x13
550     KEY_HOME,             // VK_HOME                          0x14
551     KEY_LEFT,             // VK_LEFT                          0x15
552     KEY_UP,               // VK_UP                            0x16
553     KEY_RIGHT,            // VK_RIGHT                         0x17
554     KEY_DOWN,             // VK_DOWN                          0x18
555     0,                    // VK_PRINTSCRN                     0x19
556     KEY_INSERT,           // VK_INSERT                        0x1A
557     KEY_DELETE,           // VK_DELETE                        0x1B
558     0,                    // VK_SCRLLOCK                      0x1C
559     0,                    // VK_NUMLOCK                       0x1D
560     KEY_RETURN,           // VK_ENTER                         0x1E
561     0,                    // VK_SYSRQ                         0x1F
562     KEY_F1,               // VK_F1                            0x20
563     KEY_F2,               // VK_F2                            0x21
564     KEY_F3,               // VK_F3                            0x22
565     KEY_F4,               // VK_F4                            0x23
566     KEY_F5,               // VK_F5                            0x24
567     KEY_F6,               // VK_F6                            0x25
568     KEY_F7,               // VK_F7                            0x26
569     KEY_F8,               // VK_F8                            0x27
570     KEY_F9,               // VK_F9                            0x28
571     KEY_F10,              // VK_F10                           0x29
572     KEY_F11,              // VK_F11                           0x2A
573     KEY_F12,              // VK_F12                           0x2B
574     KEY_F13,              // VK_F13                           0x2C
575     KEY_F14,              // VK_F14                           0x2D
576     KEY_F15,              // VK_F15                           0x2E
577     KEY_F16,              // VK_F16                           0x2F
578     KEY_F17,              // VK_F17                           0x30
579     KEY_F18,              // VK_F18                           0x31
580     KEY_F19,              // VK_F19                           0x32
581     KEY_F20,              // VK_F20                           0x33
582     KEY_F21,              // VK_F21                           0x34
583     KEY_F22,              // VK_F22                           0x35
584     KEY_F23,              // VK_F23                           0x36
585     KEY_F24,              // VK_F24                           0x37
586     0                     // VK_ENDDRAG                       0x38
587 };
588 
589 // =======================================================================
590 
ImplSalCreateFrame(Os2SalInstance * pInst,HWND hWndParent,ULONG nSalFrameStyle)591 SalFrame* ImplSalCreateFrame( Os2SalInstance* pInst, HWND hWndParent, ULONG nSalFrameStyle )
592 {
593     SalData*    	pSalData = GetSalData();
594     Os2SalFrame*   	pFrame = new Os2SalFrame;
595     HWND        	hWndFrame;
596     HWND        	hWndClient;
597     ULONG    		nFrameFlags = FCF_NOBYTEALIGN | FCF_SCREENALIGN;
598     ULONG    		nFrameStyle = 0;
599     ULONG    		nClientStyle = WS_CLIPSIBLINGS;
600     sal_Bool        	bSubFrame = FALSE;
601 
602 #if OSL_DEBUG_LEVEL>0
603     debug_printf(">ImplSalCreateFrame hWndParent 0x%x, nSalFrameStyle 0x%x\n", hWndParent, nSalFrameStyle);
604 #endif
605 
606 	if ( hWndParent )
607 	{
608 		bSubFrame = TRUE;
609 		pFrame->mbNoIcon = TRUE;
610 	}
611 
612     // determine creation data (bei Moveable nehmen wir DLG-Border, damit
613     // es besser aussieht)
614     if ( nSalFrameStyle & SAL_FRAME_STYLE_CLOSEABLE )
615         nFrameFlags |= FCF_CLOSEBUTTON;
616 
617 	if ( nSalFrameStyle & SAL_FRAME_STYLE_MOVEABLE ) {
618 		pFrame->mbCaption = TRUE;
619 		nFrameStyle = WS_ANIMATE;
620 		nFrameFlags |= FCF_SYSMENU | FCF_TITLEBAR | FCF_DLGBORDER;
621 		if ( !hWndParent )
622 			nFrameFlags |= FCF_MINBUTTON;
623 
624 		if ( nSalFrameStyle & SAL_FRAME_STYLE_SIZEABLE )
625 		{
626 			pFrame->mbSizeBorder = TRUE;
627 			nFrameFlags |= FCF_SIZEBORDER;
628 			if ( !hWndParent )
629 				nFrameFlags |= FCF_MAXBUTTON;
630 		}
631 		else
632 			pFrame->mbFixBorder = TRUE;
633 
634 		// add task list style if not a tool window
635 		if ( !(nSalFrameStyle & SAL_FRAME_STYLE_TOOLWINDOW) ) {
636 			nFrameFlags |= FCF_TASKLIST;
637 		}
638 	}
639 
640 	if( nSalFrameStyle & SAL_FRAME_STYLE_TOOLWINDOW )
641 	{
642 		pFrame->mbNoIcon = TRUE;
643 		// YD gives small caption -> nExSysStyle |= WS_EX_TOOLWINDOW;
644 	}
645 
646     if ( nSalFrameStyle & SAL_FRAME_STYLE_FLOAT )
647     {
648         //nExSysStyle |= WS_EX_TOOLWINDOW;
649         pFrame->mbFloatWin = TRUE;
650     }
651     //if( nSalFrameStyle & SAL_FRAME_STYLE_TOOLTIP )
652     //    nExSysStyle |= WS_EX_TOPMOST;
653 
654     // init frame data
655     pFrame->mnStyle = nSalFrameStyle;
656 
657     // determine show style
658     pFrame->mnShowState = SWP_SHOWNORMAL;
659 
660     // create frame
661 	//YD FIXME this is a potential bug with multiple threads and cuncurrent
662 	//window creation, because this field is accessed in
663 	//WM_CREATE to get window data,
664     pSalData->mpCreateFrame = pFrame;
665 
666 	//YD FIXME if SAL_FRAME_CHILD is specified, use hWndParent as parent handle...
667     hWndFrame = WinCreateStdWindow( HWND_DESKTOP, nFrameStyle, &nFrameFlags,
668 					(PSZ)(bSubFrame ? SAL_SUBFRAME_CLASSNAME : SAL_FRAME_CLASSNAME),
669 					NULL,
670 					nClientStyle, 0, 0, &hWndClient );
671     debug_printf("ImplSalCreateFrame hWndParent 0x%x, hWndFrame 0x%x, hWndClient 0x%x\n", hWndParent, hWndFrame, hWndClient);
672     if ( !hWndFrame )
673     {
674         delete pFrame;
675         return NULL;
676     }
677 
678     // Parent setzen (Owner)
679     if ( hWndParent != 0 && hWndParent != HWND_DESKTOP )
680         WinSetOwner( hWndFrame, hWndParent );
681 
682     Os2SalFrame* pParentFrame = GetWindowPtr( hWndParent );
683     if ( pParentFrame )
684 		pFrame->mpParentFrame = pParentFrame;
685 
686     // since os2 windows always have a close button, always set icon
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 
Os2SalFrame()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 
~Os2SalFrame()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 
ImplWinGetDC(HWND hWnd)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 
GetGraphics()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 
ReleaseGraphics(SalGraphics *)908 void Os2SalFrame::ReleaseGraphics( SalGraphics* )
909 {
910     mbGraphics = FALSE;
911 }
912 
913 // -----------------------------------------------------------------------
914 
PostEvent(void * pData)915 sal_Bool Os2SalFrame::PostEvent( void* pData )
916 {
917     return (sal_Bool)WinPostMsg( mhWndClient, SAL_MSG_USEREVENT, 0, (MPARAM)pData );
918 }
919 
920 // -----------------------------------------------------------------------
921 
SetTitle(const XubString & rTitle)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 
SetIcon(USHORT nIcon)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 
GetParent() const955 SalFrame* Os2SalFrame::GetParent() const
956 {
957 	//debug_printf("Os2SalFrame::GetParent\n");
958     return GetWindowPtr( WinQueryWindow(mhWndFrame, QW_OWNER) );
959 }
960 
961 // -----------------------------------------------------------------------
962 
ImplSalShow(HWND hWnd,ULONG bVisible,ULONG bNoActivate)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 
SetExtendedFrameStyle(SalExtStyle nExtStyle)1006 void Os2SalFrame::SetExtendedFrameStyle( SalExtStyle nExtStyle )
1007 {
1008 }
1009 
1010 // -----------------------------------------------------------------------
1011 
Show(sal_Bool bVisible,sal_Bool bNoActivate)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 
Enable(sal_Bool bEnable)1025 void Os2SalFrame::Enable( sal_Bool bEnable )
1026 {
1027     WinEnableWindow( mhWndFrame, bEnable );
1028 }
1029 
1030 // -----------------------------------------------------------------------
1031 
SetMinClientSize(long nWidth,long nHeight)1032 void Os2SalFrame::SetMinClientSize( long nWidth, long nHeight )
1033 {
1034     debug_printf("Os2SalFrame::SetMinClientSize\n");
1035     mnMinWidth  = nWidth;
1036     mnMinHeight = nHeight;
1037 }
1038 
SetMaxClientSize(long nWidth,long nHeight)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 
SetPosSize(long nX,long nY,long nWidth,long nHeight,USHORT nFlags)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 
SetParent(SalFrame * pNewParent)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 
SetPluginParent(SystemParentData * pNewParent)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 
GetWorkArea(RECTL & rRect)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 
GetWorkArea(Rectangle & rRect)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 
GetClientSize(long & rWidth,long & rHeight)1212 void Os2SalFrame::GetClientSize( long& rWidth, long& rHeight )
1213 {
1214     rWidth  = maGeometry.nWidth;
1215     rHeight = maGeometry.nHeight;
1216 }
1217 
1218 // -----------------------------------------------------------------------
1219 
SetWindowState(const SalFrameState * pState)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 
GetWindowState(SalFrameState * pState)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 
SetScreenNumber(unsigned int nNewScreen)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
DrawMenuBar()1428 void Os2SalFrame::DrawMenuBar()
1429 {
1430 }
1431 
SetMenu(SalMenu * pSalMenu)1432 void Os2SalFrame::SetMenu( SalMenu* pSalMenu )
1433 {
1434 }
1435 
1436 // -----------------------------------------------------------------------
1437 
ShowFullScreen(sal_Bool bFullScreen,sal_Int32 nDisplay)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 
StartPresentation(sal_Bool bStart)1465 void Os2SalFrame::StartPresentation( sal_Bool bStart )
1466 {
1467     // SysSetObjectData("<WP_DESKTOP>","Autolockup=no"); oder OS2.INI: PM_Lockup
1468 }
1469 
1470 // -----------------------------------------------------------------------
1471 
SetAlwaysOnTop(sal_Bool bOnTop)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 
ImplSalToTop(HWND hWnd,ULONG nFlags)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 
ToTop(USHORT nFlags)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 
SetPointer(PointerStyle ePointerStyle)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 
CaptureMouse(sal_Bool bCapture)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 
SetPointerPos(long nX,long nY)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 
Flush()1700 void Os2SalFrame::Flush()
1701 {
1702 }
1703 
1704 // -----------------------------------------------------------------------
1705 
Sync()1706 void Os2SalFrame::Sync()
1707 {
1708 }
1709 
1710 // -----------------------------------------------------------------------
1711 
SetInputContext(SalInputContext * pContext)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 
EndExtTextInput(USHORT nFlags)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 
GetKeyName(USHORT nCode)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 
GetSymbolKeyName(const XubString &,USHORT nKeyCode)1937 XubString Os2SalFrame::GetSymbolKeyName( const XubString&, USHORT nKeyCode )
1938 {
1939     return GetKeyName( nKeyCode );
1940 }
1941 
1942 // -----------------------------------------------------------------------
1943 
ImplOS2ColorToSal(long nOS2Color)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 
ImplMouseSysValueToSAL(int iSysValue,USHORT & rCode,USHORT & rClicks,sal_Bool & rDown)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 
ImplSalIsSameColor(const Color & rColor1,const Color & rColor2)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 
ImplOS2NameFontToVCLFont(const char * pFontName,Font & rFont)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 
UpdateSettings(AllSettings & rSettings)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 
SnapShot()2280 SalBitmap* Os2SalFrame::SnapShot()
2281 {
2282 debug_printf("Os2SalFrame::SnapShot\n");
2283 return NULL;
2284 }
2285 
2286 // -----------------------------------------------------------------------
2287 
GetSystemData() const2288 const SystemEnvData* Os2SalFrame::GetSystemData() const
2289 {
2290     return &maSysData;
2291 }
2292 
2293 // -----------------------------------------------------------------------
2294 
Beep(SoundType eSoundType)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 
GetPointerState()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 
SetBackgroundBitmap(SalBitmap *)2347 void Os2SalFrame::SetBackgroundBitmap( SalBitmap* )
2348 {
2349 }
2350 
2351 // -----------------------------------------------------------------------
2352 
SalTestMouseLeave()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 
ImplHandleMouseMsg(HWND hWnd,UINT nMsg,MPARAM nMP1,MPARAM nMP2)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 
ImplHandleWheelMsg(HWND hWnd,UINT nMsg,MPARAM nMP1,MPARAM nMP2)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 
ImplSalGetKeyCode(Os2SalFrame * pFrame,MPARAM aMP1,MPARAM aMP2)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 
ImplUpdateInputLang(Os2SalFrame * pFrame)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 
ImplGetCharCode(Os2SalFrame * pFrame,USHORT nKeyFlags,sal_Char nCharCode,UCHAR nScanCode)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 
GetInputLanguage()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 
MapUnicodeToKeyCode(sal_Unicode,LanguageType,KeyCode &)2732 sal_Bool Os2SalFrame::MapUnicodeToKeyCode( sal_Unicode , LanguageType , KeyCode& )
2733 {
2734     // not supported yet
2735     return FALSE;
2736 }
2737 
2738 // -----------------------------------------------------------------------
2739 
ImplConvertKey(Os2SalFrame * pFrame,MPARAM aMP1,MPARAM aMP2)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 
ImplHandleKeyMsg(HWND hWnd,UINT nMsg,MPARAM nMP1,MPARAM nMP2)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 
ImplHandlePaintMsg(HWND hWnd)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 
ImplHandlePaintMsg2(HWND hWnd,RECTL * pRect)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 
SetMaximizedFrameGeometry(HWND hWnd,Os2SalFrame * pFrame)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 
UpdateFrameGeometry(HWND hWnd,Os2SalFrame * pFrame)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 
ImplHandleMoveMsg(HWND hWnd)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 
ImplHandleSizeMsg(HWND hWnd,MPARAM nMP2)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 
ImplHandleFocusMsg(Os2SalFrame * pFrame,MPARAM nMP2)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 
ImplHandleCloseMsg(HWND hWnd)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 
ImplHandleUserEvent(HWND hWnd,MPARAM nMP2)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 
SalImplHandleProcessMenu(Os2SalFrame * pFrame,ULONG nMsg,MPARAM nMP1,MPARAM nMP2)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 
ImplHandleInputLangChange(HWND hWnd)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 
ImplHandleIMEStartConversion(Os2SalFrame * pFrame)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 
ImplHandleIMEConversion(Os2SalFrame * pFrame,MPARAM nMP2Param)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 
ImplHandleIMEEndConversion(Os2SalFrame * pFrame)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 
ImplHandleIMEOpenCandidate(Os2SalFrame * pFrame)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 
ImplHandleIMECloseCandidate(Os2SalFrame * pFrame)3446 inline void ImplHandleIMECloseCandidate( Os2SalFrame* pFrame )
3447 {
3448     pFrame->mbCandidateMode = FALSE;
3449 }
3450 
3451 #endif
3452 
3453 // -----------------------------------------------------------------------
3454 
SalFrameWndProc(HWND hWnd,ULONG nMsg,MPARAM nMP1,MPARAM nMP2)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 
ResetClipRegion()3726 void Os2SalFrame::ResetClipRegion()
3727 {
3728 }
3729 
BeginSetClipRegion(ULONG)3730 void Os2SalFrame::BeginSetClipRegion( ULONG )
3731 {
3732 }
3733 
UnionClipRegion(long,long,long,long)3734 void Os2SalFrame::UnionClipRegion( long, long, long, long )
3735 {
3736 }
3737 
EndSetClipRegion()3738 void Os2SalFrame::EndSetClipRegion()
3739 {
3740 }
3741 
3742 // -----------------------------------------------------------------------
3743 
SalFrameSubClassWndProc(HWND hWnd,ULONG nMsg,MPARAM nMP1,MPARAM nMP2)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