xref: /trunk/main/vcl/os2/source/app/salinst.cxx (revision 1ecadb572e7010ff3b3382ad9bf179dbc6efadbb) 
1 /*************************************************************************
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * Copyright 2000, 2010 Oracle and/or its affiliates.
6  *
7  * OpenOffice.org - a multi-platform office productivity suite
8  *
9  * This file is part of OpenOffice.org.
10  *
11  * OpenOffice.org is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License version 3
13  * only, as published by the Free Software Foundation.
14  *
15  * OpenOffice.org is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License version 3 for more details
19  * (a copy is included in the LICENSE file that accompanied this code).
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * version 3 along with OpenOffice.org.  If not, see
23  * <http://www.openoffice.org/license.html>
24  * for a copy of the LGPLv3 License.
25  *
26  ************************************************************************/
27 
28 #define INCL_DOSMISC
29 #define INCL_DOSMODULEMGR
30 #define INCL_DOSPROCESS
31 
32 #include <string.h>
33 #include <svpm.h>
34 #include <process.h>
35 
36 #define _SV_SALINST_CXX
37 
38 #ifndef _VOS_MUTEX_HXX
39 #include <vos/mutex.hxx>
40 #endif
41 #include <tools/debug.hxx>
42 
43 #ifndef _SV_SALIDS_HRC
44 #include <salids.hrc>
45 #endif
46 #include <vcl/apptypes.hxx>
47 #include <saldata.hxx>
48 #include <salinst.h>
49 #include <salframe.h>
50 #include <salobj.h>
51 #include <saltimer.h>
52 #include <salbmp.h>
53 #include <vcl/salimestatus.hxx>
54 #include <vcl/timer.hxx>
55 #include <tools/solarmutex.hxx>
56 
57 // =======================================================================
58 
59 void SalAbort( const XubString& rErrorText )
60 {
61     ImplFreeSalGDI();
62 
63     if( !rErrorText.Len() )
64         fprintf( stderr, "Application Error " );
65     else
66         fprintf( stderr, "%s ",
67             ByteString( rErrorText, gsl_getSystemTextEncoding() ).GetBuffer() );
68     abort();
69 }
70 
71 // =======================================================================
72 
73 ULONG GetCurrentThreadId()
74 {
75     PTIB pptib = NULL;
76     PPIB pppib = NULL;
77 
78     DosGetInfoBlocks( &pptib, &pppib );
79     return pptib->tib_ptib2->tib2_ultid;
80 }
81 
82 // =======================================================================
83 
84 MRESULT EXPENTRY SalComWndProc( HWND hWnd, ULONG nMsg, MPARAM nMP1, MPARAM nMP2 );
85 
86 // =======================================================================
87 
88 class SalYieldMutex : public vos::OMutex
89 {
90 public:
91     Os2SalInstance*         mpInstData;
92     ULONG                   mnCount;
93     ULONG                   mnThreadId;
94 
95 public:
96                             SalYieldMutex( Os2SalInstance* pInstData );
97 
98     virtual void SAL_CALL       acquire();
99     virtual void SAL_CALL       release();
100     virtual sal_Bool SAL_CALL   tryToAcquire();
101 
102     ULONG                   GetAcquireCount( ULONG nThreadId );
103 };
104 
105 // -----------------------------------------------------------------------
106 
107 SalYieldMutex::SalYieldMutex( Os2SalInstance* pInstData )
108 {
109     mpInstData  = pInstData;
110     mnCount     = 0;
111     mnThreadId  = 0;
112 }
113 
114 // -----------------------------------------------------------------------
115 
116 void SalYieldMutex::acquire()
117 {
118     OMutex::acquire();
119     mnCount++;
120     mnThreadId = GetCurrentThreadId();
121 }
122 
123 // -----------------------------------------------------------------------
124 
125 void SalYieldMutex::release()
126 {
127     ULONG nThreadId = GetCurrentThreadId();
128     if ( mnThreadId != nThreadId )
129         OMutex::release();
130     else
131     {
132         SalData* pSalData = GetSalData();
133         if ( pSalData->mnAppThreadId != nThreadId )
134         {
135             if ( mnCount == 1 )
136             {
137                 mpInstData->mpSalWaitMutex->acquire();
138                 if ( mpInstData->mnYieldWaitCount )
139                     WinPostMsg( mpInstData->mhComWnd, SAL_MSG_RELEASEWAITYIELD, 0, 0 );
140                 mnThreadId = 0;
141                 mnCount--;
142                 OMutex::release();
143                 mpInstData->mpSalWaitMutex->release();
144             }
145             else
146             {
147                 mnCount--;
148                 OMutex::release();
149             }
150         }
151         else
152         {
153             if ( mnCount == 1 )
154                 mnThreadId = 0;
155             mnCount--;
156             OMutex::release();
157         }
158     }
159 }
160 
161 // -----------------------------------------------------------------------
162 
163 sal_Bool SalYieldMutex::tryToAcquire()
164 {
165     if ( OMutex::tryToAcquire() )
166     {
167         mnCount++;
168         mnThreadId = GetCurrentThreadId();
169         return sal_True;
170     }
171     else
172         return sal_False;
173 }
174 
175 // -----------------------------------------------------------------------
176 
177 ULONG SalYieldMutex::GetAcquireCount( ULONG nThreadId )
178 {
179     if ( nThreadId == mnThreadId )
180         return mnCount;
181     else
182         return 0;
183 }
184 
185 // -----------------------------------------------------------------------
186 
187 void ImplSalYieldMutexAcquireWithWait()
188 {
189     Os2SalInstance* pInst = GetSalData()->mpFirstInstance;
190     if ( !pInst )
191         return;
192 
193     // If we are the main thread, then we must wait with wait, because
194     // in if we don't reschedule, then we create deadlocks if a Windows
195     // Function is called from another thread. If we arn't the main thread,
196     // than we call qcquire directly.
197     ULONG nThreadId = GetCurrentThreadId();
198     SalData* pSalData = GetSalData();
199     if ( pSalData->mnAppThreadId == nThreadId )
200     {
201         // Wenn wir den Mutex nicht bekommen, muessen wir solange
202         // warten, bis wir Ihn bekommen
203         BOOL bAcquire = FALSE;
204         do
205         {
206             if ( pInst->mpSalYieldMutex->tryToAcquire() )
207                 bAcquire = TRUE;
208             else
209             {
210                 pInst->mpSalWaitMutex->acquire();
211                 if ( pInst->mpSalYieldMutex->tryToAcquire() )
212                 {
213                     bAcquire = TRUE;
214                     pInst->mpSalWaitMutex->release();
215                 }
216                 else
217                 {
218                     pInst->mnYieldWaitCount++;
219                     pInst->mpSalWaitMutex->release();
220                     QMSG aTmpMsg;
221                     WinGetMsg( pSalData->mhAB, &aTmpMsg, pInst->mhComWnd, SAL_MSG_RELEASEWAITYIELD, SAL_MSG_RELEASEWAITYIELD );
222                     pInst->mnYieldWaitCount--;
223                     if ( pInst->mnYieldWaitCount )
224                         WinPostMsg( pInst->mhComWnd, SAL_MSG_RELEASEWAITYIELD, 0 , 0 );
225                 }
226             }
227         }
228         while ( !bAcquire );
229     }
230     else
231         pInst->mpSalYieldMutex->acquire();
232 }
233 
234 // -----------------------------------------------------------------------
235 
236 BOOL ImplSalYieldMutexTryToAcquire()
237 {
238     Os2SalInstance* pInst = GetSalData()->mpFirstInstance;
239     if ( pInst )
240         return pInst->mpSalYieldMutex->tryToAcquire();
241     else
242         return FALSE;
243 }
244 
245 // -----------------------------------------------------------------------
246 
247 void ImplSalYieldMutexAcquire()
248 {
249     Os2SalInstance* pInst = GetSalData()->mpFirstInstance;
250     if ( pInst )
251         pInst->mpSalYieldMutex->acquire();
252 }
253 
254 // -----------------------------------------------------------------------
255 
256 void ImplSalYieldMutexRelease()
257 {
258     Os2SalInstance* pInst = GetSalData()->mpFirstInstance;
259     if ( pInst )
260         pInst->mpSalYieldMutex->release();
261 }
262 
263 // -----------------------------------------------------------------------
264 
265 ULONG ImplSalReleaseYieldMutex()
266 {
267     Os2SalInstance* pInst = GetSalData()->mpFirstInstance;
268     if ( !pInst )
269         return 0;
270 
271     SalYieldMutex*  pYieldMutex = pInst->mpSalYieldMutex;
272     ULONG           nCount = pYieldMutex->GetAcquireCount( GetCurrentThreadId() );
273     ULONG           n = nCount;
274     while ( n )
275     {
276         pYieldMutex->release();
277         n--;
278     }
279 
280     return nCount;
281 }
282 
283 // -----------------------------------------------------------------------
284 
285 void ImplSalAcquireYieldMutex( ULONG nCount )
286 {
287     Os2SalInstance* pInst = GetSalData()->mpFirstInstance;
288     if ( !pInst )
289         return;
290 
291     SalYieldMutex*  pYieldMutex = pInst->mpSalYieldMutex;
292     while ( nCount )
293     {
294         pYieldMutex->acquire();
295         nCount--;
296     }
297 }
298 
299 // -----------------------------------------------------------------------
300 
301 bool Os2SalInstance::CheckYieldMutex()
302 {
303     bool bRet = true;
304     SalData*    pSalData = GetSalData();
305     ULONG       nCurThreadId = GetCurrentThreadId();
306     if ( pSalData->mnAppThreadId != nCurThreadId )
307     {
308         if ( pSalData->mpFirstInstance )
309         {
310             SalYieldMutex* pYieldMutex = pSalData->mpFirstInstance->mpSalYieldMutex;
311             if ( pYieldMutex->mnThreadId != nCurThreadId )
312             {
313                 bRet = false;
314             }
315         }
316     }
317     else
318     {
319         if ( pSalData->mpFirstInstance )
320         {
321             SalYieldMutex* pYieldMutex = pSalData->mpFirstInstance->mpSalYieldMutex;
322             if ( pYieldMutex->mnThreadId != nCurThreadId )
323             {
324                 bRet = false;
325             }
326         }
327     }
328     return bRet;
329 }
330 
331 // =======================================================================
332 
333 void InitSalData()
334 {
335     SalData* pSalData = new SalData;
336     memset( pSalData, 0, sizeof( SalData ) );
337     SetSalData( pSalData );
338 }
339 
340 // -----------------------------------------------------------------------
341 
342 void DeInitSalData()
343 {
344     SalData* pSalData = GetSalData();
345     if ( pSalData->mpFontMetrics )
346         delete pSalData->mpFontMetrics;
347     delete pSalData;
348     SetSalData( NULL );
349 }
350 
351 // -----------------------------------------------------------------------
352 
353 void InitSalMain()
354 {
355     PPIB pib;
356     PTIB tib;
357     HAB hAB;
358     HMQ hMQ;
359     SalData* pData = GetAppSalData();
360 #if OSL_DEBUG_LEVEL>0
361 printf("InitSalMain\n");
362 #endif
363 
364     // morph application to PM
365     DosGetInfoBlocks(&tib, &pib);
366     // Change flag from VIO to PM:
367     if (pib->pib_ultype==2) pib->pib_ultype = 3;
368 
369     // create anchor block
370     hAB = WinInitialize( 0 );
371     if ( !hAB )
372         return;
373 
374     // create message queue
375     hMQ = WinCreateMsgQueue( hAB, 60 );
376     if ( !hMQ )
377     {
378         WinTerminate( hAB );
379         return;
380     }
381 
382     if ( pData ) // Im AppServer NULL
383     {
384         // Ankerblock und Messagequeue merken
385         pData->mhAB = hAB;
386         pData->mhMQ = hMQ;
387     }
388 
389 }
390 
391 void DeInitSalMain()
392 {
393 #if OSL_DEBUG_LEVEL>0
394 printf("DeInitSalMain\n");
395 #endif
396 
397     SalData* pData = GetAppSalData();
398     // destroy message queue and anchor block
399     WinDestroyMsgQueue( pData->mhMQ );
400     WinTerminate( pData->mhAB );
401 
402 }
403 
404 // -----------------------------------------------------------------------
405 
406 SalInstance* CreateSalInstance()
407 {
408     SalData*        pSalData = GetSalData();
409 
410     // determine the os2 version
411     ULONG nMayor;
412     ULONG nMinor;
413     DosQuerySysInfo( QSV_VERSION_MAJOR, QSV_VERSION_MAJOR, &nMayor, sizeof( nMayor ) );
414     DosQuerySysInfo( QSV_VERSION_MINOR, QSV_VERSION_MINOR, &nMinor, sizeof( nMinor ) );
415     aSalShlData.mnVersion = (USHORT)(nMayor*10 + nMinor);
416 
417     pSalData->mnAppThreadId = GetCurrentThreadId();
418 
419     // register frame class
420     if ( !WinRegisterClass( pSalData->mhAB, (PSZ)SAL_FRAME_CLASSNAME,
421                             (PFNWP)SalFrameWndProc, CS_MOVENOTIFY /* 17/08 CS_HITTEST | CS_MOVENOTIFY */,
422                             SAL_FRAME_WNDEXTRA ) )
423     {
424         return NULL;
425     }
426     // register subframe class
427     if ( !WinRegisterClass( pSalData->mhAB, (PSZ)SAL_SUBFRAME_CLASSNAME,
428                             (PFNWP)SalFrameWndProc, CS_SAVEBITS| CS_MOVENOTIFY,
429                             SAL_FRAME_WNDEXTRA ) )
430     {
431         return NULL;
432     }
433     // register object class
434     if ( !WinRegisterClass( pSalData->mhAB, (PSZ)SAL_COM_CLASSNAME,
435                             (PFNWP)SalComWndProc, 0, 0 ))
436     {
437         return NULL;
438     }
439 
440     HWND hComWnd = WinCreateWindow( HWND_OBJECT, (PCSZ)SAL_COM_CLASSNAME,
441                                     (PCSZ)"", 0, 0, 0, 0, 0,
442                                     HWND_OBJECT, HWND_TOP,
443                                     222, NULL, NULL);
444     if ( !hComWnd )
445         return NULL;
446 
447 #if OSL_DEBUG_LEVEL>0
448     debug_printf("CreateSalInstance hComWnd %x\n", hComWnd);
449 #endif
450     Os2SalInstance* pInst = new Os2SalInstance;
451 
452     // init instance (only one instance in this version !!!)
453     pSalData->mpFirstInstance   = pInst;
454     pInst->mhAB     = pSalData->mhAB;
455     pInst->mhMQ     = pSalData->mhMQ;
456     pInst->mnArgc   = pSalData->mnArgc;
457     pInst->mpArgv   = pSalData->mpArgv;
458     pInst->mhComWnd = hComWnd;
459 
460     // AppIcon ermitteln
461     ImplLoadSalIcon( SAL_RESID_ICON_DEFAULT, pInst->mhAppIcon);
462 
463     // init static GDI Data
464     ImplInitSalGDI();
465 
466     return pInst;
467 }
468 
469 // -----------------------------------------------------------------------
470 
471 void DestroySalInstance( SalInstance* pInst )
472 {
473     SalData* pSalData = GetSalData();
474 
475     //  (only one instance in this version !!!)
476     ImplFreeSalGDI();
477 
478 #ifdef ENABLE_IME
479     // IME-Daten freigeben
480     if ( pSalData->mpIMEData )
481         ImplReleaseSALIMEData();
482 #endif
483 
484     // reset instance
485     if ( pSalData->mpFirstInstance == pInst )
486         pSalData->mpFirstInstance = NULL;
487 
488     delete pInst;
489 }
490 
491 // -----------------------------------------------------------------------
492 
493 Os2SalInstance::Os2SalInstance()
494 {
495     mhComWnd                = 0;
496     mpSalYieldMutex         = new SalYieldMutex( this );
497     mpSalWaitMutex          = new vos::OMutex;
498     mnYieldWaitCount         = 0;
499     mpSalYieldMutex->acquire();
500     ::tools::SolarMutex::SetSolarMutex( mpSalYieldMutex );
501 }
502 
503 // -----------------------------------------------------------------------
504 
505 Os2SalInstance::~Os2SalInstance()
506 {
507     ::tools::SolarMutex::SetSolarMutex( 0 );
508     mpSalYieldMutex->release();
509     delete mpSalYieldMutex;
510     delete mpSalWaitMutex;
511     WinDestroyWindow( mhComWnd);
512 }
513 
514 // -----------------------------------------------------------------------
515 
516 vos::IMutex* Os2SalInstance::GetYieldMutex()
517 {
518     return mpSalYieldMutex;
519 }
520 // -----------------------------------------------------------------------
521 
522 ULONG Os2SalInstance::ReleaseYieldMutex()
523 {
524     return ImplSalReleaseYieldMutex();
525 }
526 
527 // -----------------------------------------------------------------------
528 
529 void Os2SalInstance::AcquireYieldMutex( ULONG nCount )
530 {
531     ImplSalAcquireYieldMutex( nCount );
532 }
533 
534 // -----------------------------------------------------------------------
535 
536 static void ImplSalYield( BOOL bWait, BOOL bHandleAllCurrentEvents )
537 {
538     QMSG            aMsg;
539     bool bWasMsg = false, bOneEvent = false;
540     bool bQuit = false;
541 
542     Os2SalInstance* pInst = GetSalData()->mpFirstInstance;
543     int nMaxEvents = bHandleAllCurrentEvents ? 100 : 1;
544     do
545     {
546         if ( WinPeekMsg( pInst->mhAB, &aMsg, 0, 0, 0, PM_REMOVE ) )
547         {
548             WinDispatchMsg( pInst->mhAB, &aMsg );
549             bOneEvent = bWasMsg = true;
550             if (aMsg.msg == WM_QUIT)
551                 bQuit = true;
552         }
553         else
554             bOneEvent = false;
555     } while( --nMaxEvents && bOneEvent );
556 
557     if ( bWait && ! bWasMsg )
558     {
559         if ( WinGetMsg( pInst->mhAB, &aMsg, 0, 0, 0 ) )
560             WinDispatchMsg( pInst->mhAB, &aMsg );
561         else
562             bQuit = true;
563     }
564 
565     if (bQuit)
566     {
567         ImplSalYieldMutexAcquireWithWait();
568         Os2SalFrame*   pFrame = GetSalData()->mpFirstFrame;
569         if ( pFrame )
570         {
571             if (pFrame->CallCallback( SALEVENT_SHUTDOWN, 0 ))
572                 WinCancelShutdown( pFrame->mhAB, FALSE );
573         }
574         ImplSalYieldMutexRelease();
575     }
576 
577 }
578 
579 // -----------------------------------------------------------------------
580 
581 void Os2SalInstance::Yield( bool bWait, bool bHandleAllCurrentEvents )
582 {
583     SalYieldMutex*  pYieldMutex = mpSalYieldMutex;
584     SalData*        pSalData = GetSalData();
585     ULONG           nCurThreadId = GetCurrentThreadId();
586     ULONG           nCount = pYieldMutex->GetAcquireCount( nCurThreadId );
587     ULONG           n = nCount;
588     while ( n )
589     {
590         pYieldMutex->release();
591         n--;
592     }
593     if ( pSalData->mnAppThreadId != nCurThreadId )
594     {
595         // #97739# A SendMessage call blocks until the called thread (here: the main thread)
596         // returns. During a yield however, messages are processed in the main thread that might
597         // result in a new message loop due to opening a dialog. Thus, SendMessage would not
598         // return which will block this thread!
599         // Solution: just give up the time slice and hope that messages are processed
600         // by the main thread anyway (where all windows are created)
601         // If the mainthread is not currently handling messages, then our SendMessage would
602         // also do nothing, so this seems to be reasonable.
603 
604         // #i18883# only sleep if potential deadlock scenario, ie, when a dialog is open
605         if( ImplGetSVData()->maAppData.mnModalMode )
606             DosSleep(1);
607         else
608             WinSendMsg( mhComWnd, SAL_MSG_THREADYIELD, (MPARAM)bWait, (MPARAM)bHandleAllCurrentEvents );
609 
610         n = nCount;
611         while ( n )
612         {
613             pYieldMutex->acquire();
614             n--;
615         }
616     }
617     else
618     {
619         ImplSalYield( bWait, bHandleAllCurrentEvents );
620 
621         n = nCount;
622         while ( n )
623         {
624             ImplSalYieldMutexAcquireWithWait();
625             n--;
626         }
627     }
628 }
629 
630 // -----------------------------------------------------------------------
631 
632 MRESULT EXPENTRY SalComWndProc( HWND hWnd, ULONG nMsg,
633                                 MPARAM nMP1, MPARAM nMP2 )
634 {
635     //debug_printf( "SalComWndProc hWnd 0x%x nMsg %d\n", hWnd, nMsg);
636 
637     switch ( nMsg )
638     {
639         case SAL_MSG_PRINTABORTJOB:
640             //ImplSalPrinterAbortJobAsync( (HDC)wParam );
641             break;
642         case SAL_MSG_THREADYIELD:
643             ImplSalYield( (bool)nMP1, (bool) nMP2);
644             return 0;
645         // If we get this message, because another GetMessage() call
646         // has recieved this message, we must post this message to
647         // us again, because in the other case we wait forever.
648         case SAL_MSG_RELEASEWAITYIELD:
649             {
650             Os2SalInstance* pInst = GetSalData()->mpFirstInstance;
651             if ( pInst && pInst->mnYieldWaitCount )
652                 WinPostMsg( hWnd, SAL_MSG_RELEASEWAITYIELD, nMP1, nMP2 );
653             }
654             return 0;
655         case SAL_MSG_STARTTIMER:
656             ImplSalStartTimer( (ULONG)nMP2, FALSE);
657             return 0;
658         case SAL_MSG_CREATEFRAME:
659             return (MRESULT)ImplSalCreateFrame( GetSalData()->mpFirstInstance, (HWND)nMP2, (ULONG)nMP1 );
660         case SAL_MSG_DESTROYFRAME:
661             delete (SalFrame*)nMP2;
662             return 0;
663         case SAL_MSG_DESTROYHWND:
664             //We only destroy the native window here. We do NOT destroy the SalFrame contained
665             //in the structure (GetWindowPtr()).
666             if (WinDestroyWindow((HWND)nMP2) == 0)
667             {
668                 OSL_ENSURE(0, "DestroyWindow failed!");
669                 //Failure: We remove the SalFrame from the window structure. So we avoid that
670                 // the window structure may contain an invalid pointer, once the SalFrame is deleted.
671                SetWindowPtr((HWND)nMP2, 0);
672             }
673             return 0;
674         case SAL_MSG_CREATEOBJECT:
675             return (MRESULT)ImplSalCreateObject( GetSalData()->mpFirstInstance, (Os2SalFrame*)(ULONG)nMP2 );
676         case SAL_MSG_DESTROYOBJECT:
677             delete (SalObject*)nMP2;
678             return 0;
679         case SAL_MSG_CREATESOUND:
680             //return (MRESULT)((Os2SalSound*)nMP2)->ImplCreate();
681             return 0;
682         case SAL_MSG_DESTROYSOUND:
683             //((Os2SalSound*)nMP2)->ImplDestroy();
684             return 0;
685         case SAL_MSG_POSTTIMER:
686             SalTimerProc( 0, 0, SALTIMERPROC_RECURSIVE, (ULONG)nMP2 );
687             break;
688         case WM_TIMER:
689             SalTimerProc( hWnd, 0, 0, 0 );
690             break;
691     }
692 
693     return WinDefWindowProc( hWnd, nMsg, nMP1, nMP2 );
694 }
695 
696 // -----------------------------------------------------------------------
697 
698 bool Os2SalInstance::AnyInput( USHORT nType )
699 {
700     SalData* pSalData = GetSalData();
701     QMSG    aQMSG;
702 
703     if ( (nType & (INPUT_ANY)) == INPUT_ANY )
704     {
705         // Any Input
706         if ( WinPeekMsg( pSalData->mhAB, &aQMSG, 0, 0, 0, PM_NOREMOVE ) )
707             return TRUE;
708     }
709     else
710     {
711         if ( nType & INPUT_MOUSE )
712         {
713             // Test auf Mouseinput
714             if ( WinPeekMsg( pSalData->mhAB, &aQMSG, 0,
715                              WM_MOUSEFIRST, WM_MOUSELAST, PM_NOREMOVE ) )
716                 return TRUE;
717         }
718 
719         if ( nType & INPUT_KEYBOARD )
720         {
721             // Test auf Keyinput
722             if ( WinPeekMsg( pSalData->mhAB, &aQMSG, 0,
723                              WM_CHAR, WM_CHAR, PM_NOREMOVE ) )
724                 return !(SHORT1FROMMP( aQMSG.mp1 ) & KC_KEYUP);
725         }
726 
727         if ( nType & INPUT_PAINT )
728         {
729             // Test auf Paintinput
730             if ( WinPeekMsg( pSalData->mhAB, &aQMSG, 0,
731                              WM_PAINT, WM_PAINT, PM_NOREMOVE ) )
732                 return TRUE;
733         }
734 
735         if ( nType & INPUT_TIMER )
736         {
737             // Test auf Timerinput
738             if ( WinPeekMsg( pSalData->mhAB, &aQMSG, 0,
739                              WM_TIMER, WM_TIMER, PM_NOREMOVE ) )
740                 return TRUE;
741         }
742 
743         if ( nType & INPUT_OTHER )
744         {
745             // Test auf sonstigen Input
746             if ( WinPeekMsg( pSalData->mhAB, &aQMSG, 0, 0, 0, PM_NOREMOVE ) )
747                 return TRUE;
748         }
749     }
750 
751     return FALSE;
752 }
753 
754 // -----------------------------------------------------------------------
755 
756 SalFrame* Os2SalInstance::CreateChildFrame( SystemParentData* pSystemParentData, ULONG nSalFrameStyle )
757 {
758     // Um auf Main-Thread umzuschalten
759     return (SalFrame*)WinSendMsg( mhComWnd, SAL_MSG_CREATEFRAME, (MPARAM)nSalFrameStyle, (MPARAM)pSystemParentData->hWnd );
760 }
761 
762 // -----------------------------------------------------------------------
763 
764 SalFrame* Os2SalInstance::CreateFrame( SalFrame* pParent, ULONG nSalFrameStyle )
765 {
766     // Um auf Main-Thread umzuschalten
767     HWND mhWndClient;
768 //31/05/06 YD use client as owner(parent) so positioning will not need to
769 // take care of borders and captions
770     if ( pParent )
771         mhWndClient = static_cast<Os2SalFrame*>(pParent)->mhWndClient;
772     else
773         mhWndClient = 0;
774     return (SalFrame*)WinSendMsg( mhComWnd, SAL_MSG_CREATEFRAME, (MPARAM)nSalFrameStyle, (MPARAM)mhWndClient );
775 }
776 
777 
778 // -----------------------------------------------------------------------
779 
780 void Os2SalInstance::DestroyFrame( SalFrame* pFrame )
781 {
782     WinSendMsg( mhComWnd, SAL_MSG_DESTROYFRAME, 0, (MPARAM)pFrame );
783 }
784 
785 // -----------------------------------------------------------------------
786 
787 SalObject* Os2SalInstance::CreateObject( SalFrame* pParent,
788                                          SystemWindowData* /*pWindowData*/, // SystemWindowData meaningless on Windows
789                                          BOOL /*bShow*/ )
790 {
791     // Um auf Main-Thread umzuschalten
792     return (SalObject*)WinSendMsg( mhComWnd, SAL_MSG_CREATEOBJECT, 0, (MPARAM)pParent );
793 }
794 
795 
796 // -----------------------------------------------------------------------
797 
798 void Os2SalInstance::DestroyObject( SalObject* pObject )
799 {
800     WinSendMsg( mhComWnd, SAL_MSG_DESTROYOBJECT, 0, (MPARAM)pObject );
801 }
802 
803 // -----------------------------------------------------------------------
804 
805 void* Os2SalInstance::GetConnectionIdentifier( ConnectionIdentifierType& rReturnedType, int& rReturnedBytes )
806 {
807     rReturnedBytes  = 1;
808     rReturnedType   = AsciiCString;
809     return (void*) "";
810 }
811 
812 void Os2SalInstance::AddToRecentDocumentList(const rtl::OUString& /*rFileUrl*/, const rtl::OUString& /*rMimeType*/)
813 {
814 }
815 
816 // -----------------------------------------------------------------------
817 
818 SalTimer* Os2SalInstance::CreateSalTimer()
819 {
820     return new Os2SalTimer();
821 }
822 
823 // -----------------------------------------------------------------------
824 
825 SalBitmap* Os2SalInstance::CreateSalBitmap()
826 {
827     return new Os2SalBitmap();
828 }
829 
830 // -----------------------------------------------------------------------
831 
832 class Os2ImeStatus : public SalI18NImeStatus
833 {
834   public:
835     Os2ImeStatus() {}
836     virtual ~Os2ImeStatus() {}
837 
838     // asks whether there is a status window available
839     // to toggle into menubar
840     virtual bool canToggle() { return false; }
841     virtual void toggle() {}
842 };
843 
844 SalI18NImeStatus* Os2SalInstance::CreateI18NImeStatus()
845 {
846     return new Os2ImeStatus();
847 }
848 
849 // -----------------------------------------------------------------------
850 
851 const ::rtl::OUString& SalGetDesktopEnvironment()
852 {
853     static ::rtl::OUString aDesktopEnvironment( RTL_CONSTASCII_USTRINGPARAM( "OS/2" ) );
854     return aDesktopEnvironment;
855 }
856 
857 SalSession* Os2SalInstance::CreateSalSession()
858 {
859     return NULL;
860 }
861 
862