1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_toolkit.hxx"
26 #include <com/sun/star/beans/PropertyAttribute.hpp>
27
28 #ifndef _SVWIN_HXX
29 #include <tools/svwin.h>
30 #endif
31 #include <stdio.h>
32 #include <com/sun/star/awt/ImageScaleMode.hpp>
33 #include <com/sun/star/awt/WindowAttribute.hpp>
34 #include <com/sun/star/awt/VclWindowPeerAttribute.hpp>
35 #include <com/sun/star/awt/WindowClass.hpp>
36 #include <com/sun/star/awt/MessageBoxButtons.hpp>
37 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
38 #include <com/sun/star/lang/SystemDependent.hpp>
39 #include <com/sun/star/awt/FocusEvent.hpp>
40 #include <com/sun/star/awt/KeyEvent.hpp>
41 #include <com/sun/star/awt/KeyModifier.hpp>
42 #include <com/sun/star/lang/EventObject.hpp>
43 #include <com/sun/star/uno/Reference.hxx>
44 #include <com/sun/star/uno/Sequence.hxx>
45 #include <com/sun/star/uno/XInterface.hpp>
46 #include <com/sun/star/beans/NamedValue.hpp>
47 #include <cppuhelper/typeprovider.hxx>
48 #include <osl/conditn.hxx>
49 #include <rtl/memory.h>
50 #include <rtl/uuid.h>
51 #include <rtl/process.h>
52
53 #ifdef WNT
54 #include <tools/prewin.h>
55 #include <windows.h>
56 #include <tools/postwin.h>
57 #elif defined ( OS2 )
58 #include <svpm.h>
59 #elif (defined QUARTZ)
60 #include "premac.h"
61 #include <Cocoa/Cocoa.h>
62 #include "postmac.h"
63 #endif
64 #include <vcl/sysdata.hxx>
65
66 #include <toolkit/awt/vclxwindows.hxx>
67 #include <toolkit/awt/vclxsystemdependentwindow.hxx>
68 #include <toolkit/awt/vclxregion.hxx>
69 #include <toolkit/awt/vclxtoolkit.hxx>
70 #include <toolkit/awt/vclxtabpagecontainer.hxx>
71 #include <toolkit/awt/vclxtabpagemodel.hxx>
72
73 #include <toolkit/awt/animatedimagespeer.hxx>
74 #include <toolkit/awt/vclxtopwindow.hxx>
75 #include <toolkit/awt/vclxwindow.hxx>
76 #include <toolkit/helper/vclunohelper.hxx>
77 #include <toolkit/helper/unowrapper.hxx>
78 #include <toolkit/helper/servicenames.hxx>
79
80
81 #include <toolkit/helper/macros.hxx>
82 #include <toolkit/helper/convert.hxx>
83 #include <vcl/unohelp.hxx>
84 #include <vcl/btndlg.hxx>
85 #ifndef _SV_BUTTON_HXX
86 #include <vcl/button.hxx>
87 #endif
88 #include <vcl/combobox.hxx>
89 #include <vcl/ctrl.hxx>
90 #include <vcl/dialog.hxx>
91 #include <vcl/dockingarea.hxx>
92 #include <vcl/dockwin.hxx>
93 #include <vcl/edit.hxx>
94 #include <vcl/field.hxx>
95 #include <vcl/fixed.hxx>
96 #include <vcl/floatwin.hxx>
97 #include <vcl/group.hxx>
98 #include <vcl/imgctrl.hxx>
99 #include <vcl/longcurr.hxx>
100 #include <vcl/lstbox.hxx>
101 #include <vcl/menubtn.hxx>
102 #include <vcl/morebtn.hxx>
103 #include <vcl/msgbox.hxx>
104 #include <vcl/scrbar.hxx>
105 #include <vcl/spin.hxx>
106 #include <vcl/split.hxx>
107 #include <vcl/splitwin.hxx>
108 #include <vcl/status.hxx>
109 #include <vcl/svapp.hxx>
110 #include <vcl/syschild.hxx>
111 #include <vcl/tabctrl.hxx>
112 #include <vcl/tabdlg.hxx>
113 #include <vcl/tabpage.hxx>
114 #include <vcl/toolbox.hxx>
115 #include <vcl/virdev.hxx>
116 #include <vcl/window.hxx>
117 #include <vcl/wrkwin.hxx>
118 #include <vcl/throbber.hxx>
119 #include "toolkit/awt/vclxspinbutton.hxx"
120
121 #include <tools/debug.hxx>
122 #include <comphelper/processfactory.hxx>
123
124 namespace css = ::com::sun::star;
125
126 #define VCLWINDOW_FRAMEWINDOW 0x1000
127 #define VCLWINDOW_SYSTEMCHILDWINDOW 0x1001
128
129 #if (defined WNT)
130 #define SYSTEM_DEPENDENT_TYPE ::com::sun::star::lang::SystemDependent::SYSTEM_WIN32
131 #elif (defined OS2)
132 #define SYSTEM_DEPENDENT_TYPE ::com::sun::star::lang::SystemDependent::SYSTEM_OS2
133 #elif (defined QUARTZ)
134 #define SYSTEM_DEPENDENT_TYPE ::com::sun::star::lang::SystemDependent::SYSTEM_MAC
135 #elif (defined UNX)
136 #define SYSTEM_DEPENDENT_TYPE ::com::sun::star::lang::SystemDependent::SYSTEM_XWINDOW
137 #endif
138
ImplGetWinBits(sal_uInt32 nComponentAttribs,sal_uInt16 nCompType)139 TOOLKIT_DLLPUBLIC WinBits ImplGetWinBits( sal_uInt32 nComponentAttribs, sal_uInt16 nCompType )
140 {
141 WinBits nWinBits = 0;
142
143 sal_Bool bMessBox = sal_False;
144 if ( ( nCompType == WINDOW_INFOBOX ) ||
145 ( nCompType == WINDOW_MESSBOX ) ||
146 ( nCompType == WINDOW_QUERYBOX ) ||
147 ( nCompType == WINDOW_WARNINGBOX ) ||
148 ( nCompType == WINDOW_ERRORBOX ) )
149 {
150 bMessBox = sal_True;
151 }
152
153 bool bDecoratedWindow = false;
154 if ( bMessBox
155 || ( nCompType == WINDOW_DIALOG )
156 || ( nCompType == WINDOW_MODELESSDIALOG )
157 || ( nCompType == WINDOW_MODALDIALOG )
158 || ( nCompType == WINDOW_SYSTEMDIALOG )
159 || ( nCompType == WINDOW_PATHDIALOG )
160 || ( nCompType == WINDOW_FILEDIALOG )
161 || ( nCompType == WINDOW_PRINTERSETUPDIALOG )
162 || ( nCompType == WINDOW_PRINTDIALOG )
163 || ( nCompType == WINDOW_COLORDIALOG )
164 || ( nCompType == WINDOW_FONTDIALOG )
165 || ( nCompType == WINDOW_DOCKINGWINDOW )
166 || ( nCompType == WINDOW_TABDIALOG )
167 || ( nCompType == WINDOW_BUTTONDIALOG )
168 || ( nCompType == WINDOW_SYSTEMCHILDWINDOW )
169 )
170 {
171 bDecoratedWindow = true;
172 }
173
174 if( nComponentAttribs & ::com::sun::star::awt::WindowAttribute::BORDER )
175 nWinBits |= WB_BORDER;
176 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::NOBORDER )
177 nWinBits |= WB_NOBORDER;
178 if( nComponentAttribs & ::com::sun::star::awt::WindowAttribute::SIZEABLE )
179 nWinBits |= WB_SIZEABLE;
180 if( nComponentAttribs & ::com::sun::star::awt::WindowAttribute::MOVEABLE )
181 nWinBits |= WB_MOVEABLE;
182 if( nComponentAttribs & ::com::sun::star::awt::WindowAttribute::CLOSEABLE )
183 nWinBits |= WB_CLOSEABLE;
184 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::HSCROLL )
185 nWinBits |= WB_HSCROLL;
186 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::VSCROLL )
187 nWinBits |= WB_VSCROLL;
188 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::LEFT )
189 nWinBits |= WB_LEFT;
190 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::CENTER )
191 nWinBits |= WB_CENTER;
192 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::RIGHT )
193 nWinBits |= WB_RIGHT;
194 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::SPIN )
195 nWinBits |= WB_SPIN;
196 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::SORT )
197 nWinBits |= WB_SORT;
198 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::DROPDOWN )
199 nWinBits |= WB_DROPDOWN;
200 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::DEFBUTTON )
201 nWinBits |= WB_DEFBUTTON;
202 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::READONLY )
203 nWinBits |= WB_READONLY;
204 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::CLIPCHILDREN )
205 nWinBits |= WB_CLIPCHILDREN;
206 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::GROUP )
207 nWinBits |= WB_GROUP;
208 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::NOLABEL ) //added for issue79712
209 nWinBits |= WB_NOLABEL;
210
211 // These bits are not uniqe
212 if ( bMessBox )
213 {
214 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::OK )
215 nWinBits |= WB_OK;
216 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::OK_CANCEL )
217 nWinBits |= WB_OK_CANCEL;
218 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::YES_NO )
219 nWinBits |= WB_YES_NO;
220 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::YES_NO_CANCEL )
221 nWinBits |= WB_YES_NO_CANCEL;
222 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::RETRY_CANCEL )
223 nWinBits |= WB_RETRY_CANCEL;
224 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::DEF_OK )
225 nWinBits |= WB_DEF_OK;
226 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::DEF_CANCEL )
227 nWinBits |= WB_DEF_CANCEL;
228 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::DEF_RETRY )
229 nWinBits |= WB_DEF_RETRY;
230 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::DEF_YES )
231 nWinBits |= WB_DEF_YES;
232 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::DEF_NO )
233 nWinBits |= WB_DEF_NO;
234 }
235 if ( nCompType == WINDOW_MULTILINEEDIT )
236 {
237 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::AUTOHSCROLL )
238 nWinBits |= WB_AUTOHSCROLL;
239 if( nComponentAttribs & ::com::sun::star::awt::VclWindowPeerAttribute::AUTOVSCROLL )
240 nWinBits |= WB_AUTOVSCROLL;
241 }
242
243
244 if ( bDecoratedWindow )
245 {
246 if( nComponentAttribs & ::com::sun::star::awt::WindowAttribute::NODECORATION )
247 {
248 // No decoration removes several window attributes and must
249 // set WB_NOBORDER!
250 nWinBits &= ~WB_BORDER;
251 nWinBits &= ~WB_SIZEABLE;
252 nWinBits &= ~WB_MOVEABLE;
253 nWinBits &= ~WB_CLOSEABLE;
254 nWinBits |= WB_NOBORDER;
255 }
256 }
257
258 return nWinBits;
259 }
260
261 struct ComponentInfo
262 {
263 const char* pName;
264 WindowType nWinType;
265 };
266
267 static ComponentInfo __FAR_DATA aComponentInfos [] =
268 {
269 { "buttondialog", WINDOW_BUTTONDIALOG },
270 { "cancelbutton", WINDOW_CANCELBUTTON },
271 { "checkbox", WINDOW_CHECKBOX },
272 { "combobox", WINDOW_COMBOBOX },
273 { "control", WINDOW_CONTROL },
274 { "currencybox", WINDOW_CURRENCYBOX },
275 { "currencyfield", WINDOW_CURRENCYFIELD },
276 { "datebox", WINDOW_DATEBOX },
277 { "datefield", WINDOW_DATEFIELD },
278 { "dialog", WINDOW_DIALOG },
279 { "dockingarea", WINDOW_DOCKINGAREA },
280 { "dockingwindow", WINDOW_DOCKINGWINDOW },
281 { "edit", WINDOW_EDIT },
282 { "errorbox", WINDOW_ERRORBOX },
283 { "fixedbitmap", WINDOW_FIXEDBITMAP },
284 { "fixedimage", WINDOW_FIXEDIMAGE },
285 { "fixedline", WINDOW_FIXEDLINE },
286 { "fixedtext", WINDOW_FIXEDTEXT },
287 { "floatingwindow", WINDOW_FLOATINGWINDOW },
288 { "framewindow", VCLWINDOW_FRAMEWINDOW },
289 { "groupbox", WINDOW_GROUPBOX },
290 { "helpbutton", WINDOW_HELPBUTTON },
291 { "imagebutton", WINDOW_IMAGEBUTTON },
292 { "imageradiobutton", WINDOW_IMAGERADIOBUTTON },
293 { "infobox", WINDOW_INFOBOX },
294 { "listbox", WINDOW_LISTBOX },
295 { "longcurrencybox", WINDOW_LONGCURRENCYBOX },
296 { "longcurrencyfield", WINDOW_LONGCURRENCYFIELD },
297 { "menubutton", WINDOW_MENUBUTTON },
298 { "messbox", WINDOW_MESSBOX },
299 { "metricbox", WINDOW_METRICBOX },
300 { "metricfield", WINDOW_METRICFIELD },
301 { "modaldialog", WINDOW_MODALDIALOG },
302 { "modelessdialog", WINDOW_MODELESSDIALOG },
303 { "morebutton", WINDOW_MOREBUTTON },
304 { "multilineedit", WINDOW_MULTILINEEDIT },
305 { "multilistbox", WINDOW_MULTILISTBOX },
306 { "numericbox", WINDOW_NUMERICBOX },
307 { "numericfield", WINDOW_NUMERICFIELD },
308 { "okbutton", WINDOW_OKBUTTON },
309 { "patternbox", WINDOW_PATTERNBOX },
310 { "patternfield", WINDOW_PATTERNFIELD },
311 { "pushbutton", WINDOW_PUSHBUTTON },
312 { "querybox", WINDOW_QUERYBOX },
313 { "radiobutton", WINDOW_RADIOBUTTON },
314 { "scrollbar", WINDOW_SCROLLBAR },
315 { "scrollbarbox", WINDOW_SCROLLBARBOX },
316 { "animatedimages", WINDOW_CONTROL },
317 { "spinbutton", WINDOW_SPINBUTTON },
318 { "spinfield", WINDOW_SPINFIELD },
319 { "splitter", WINDOW_SPLITTER },
320 { "splitwindow", WINDOW_SPLITWINDOW },
321 { "statusbar", WINDOW_STATUSBAR },
322 { "systemchildwindow", VCLWINDOW_SYSTEMCHILDWINDOW },
323 { "tabcontrol", WINDOW_TABCONTROL },
324 { "tabdialog", WINDOW_TABDIALOG },
325 { "tabpage", WINDOW_TABPAGE },
326 { "timebox", WINDOW_TIMEBOX },
327 { "timefield", WINDOW_TIMEFIELD },
328 { "toolbox", WINDOW_TOOLBOX },
329 { "tristatebox", WINDOW_TRISTATEBOX },
330 { "warningbox", WINDOW_WARNINGBOX },
331 { "window", WINDOW_WINDOW },
332 { "workwindow", WINDOW_WORKWINDOW },
333 { "tabpagecontainer", WINDOW_CONTROL },
334 { "tabpagemodel", WINDOW_TABPAGE }
335 };
336
337 extern "C"
338 {
339 static int
340 #if defined( WNT )
341 __cdecl
342 #endif
343 #if defined( ICC ) && defined( OS2 )
344 _Optlink
345 #endif
ComponentInfoCompare(const void * pFirst,const void * pSecond)346 ComponentInfoCompare( const void* pFirst, const void* pSecond)
347 {
348 return( strcmp( ((ComponentInfo*)pFirst)->pName,
349 ((ComponentInfo*)pSecond)->pName ) );
350 }
351 }
352
ImplGetComponentType(const String & rServiceName)353 sal_uInt16 ImplGetComponentType( const String& rServiceName )
354 {
355 static sal_Bool bSorted = sal_False;
356 if( !bSorted )
357 {
358 qsort( (void*) aComponentInfos,
359 sizeof( aComponentInfos ) / sizeof( ComponentInfo ),
360 sizeof( ComponentInfo ),
361 ComponentInfoCompare );
362 bSorted = sal_True;
363 }
364
365
366 ComponentInfo aSearch;
367 ByteString aServiceName( rServiceName, gsl_getSystemTextEncoding() );
368 aServiceName.ToLowerAscii();
369 if ( aServiceName.Len() )
370 aSearch.pName = aServiceName.GetBuffer();
371 else
372 aSearch.pName = "window";
373
374 ComponentInfo* pInf = (ComponentInfo*) bsearch( &aSearch,
375 (void*) aComponentInfos,
376 sizeof( aComponentInfos ) / sizeof( ComponentInfo ),
377 sizeof( ComponentInfo ),
378 ComponentInfoCompare );
379
380 return pInf ? pInf->nWinType : 0;
381 }
382
383
384 namespace
385 {
386 struct MessageBoxTypeInfo
387 {
388 css::awt::MessageBoxType eType;
389 const sal_Char *pName;
390 sal_Int32 nLen;
391 };
392
393 static MessageBoxTypeInfo aMessageBoxTypeInfo[] =
394 {
395 { css::awt::MessageBoxType_MESSAGEBOX, RTL_CONSTASCII_STRINGPARAM("messbox") },
396 { css::awt::MessageBoxType_INFOBOX, RTL_CONSTASCII_STRINGPARAM("infobox") },
397 { css::awt::MessageBoxType_WARNINGBOX, RTL_CONSTASCII_STRINGPARAM("warningbox") },
398 { css::awt::MessageBoxType_ERRORBOX, RTL_CONSTASCII_STRINGPARAM("errorbox") },
399 { css::awt::MessageBoxType_QUERYBOX, RTL_CONSTASCII_STRINGPARAM("querybox") },
400 { css::awt::MessageBoxType_MAKE_FIXED_SIZE, 0, 0 }
401 };
402
lcl_convertMessageBoxType(rtl::OUString & sType,css::awt::MessageBoxType eType)403 static bool lcl_convertMessageBoxType(
404 rtl::OUString &sType,
405 css::awt::MessageBoxType eType )
406 {
407 const MessageBoxTypeInfo *pMap = aMessageBoxTypeInfo;
408 css::awt::MessageBoxType eVal = css::awt::MessageBoxType_MAKE_FIXED_SIZE;
409
410 while ( pMap->pName )
411 {
412 if ( pMap->eType == eType )
413 {
414 eVal = eType;
415 sType = rtl::OUString( pMap->pName, pMap->nLen, RTL_TEXTENCODING_ASCII_US );
416 break;
417 }
418 pMap++;
419 }
420
421 return ( eVal != css::awt::MessageBoxType_MAKE_FIXED_SIZE );
422 }
423 }
424
425 // ----------------------------------------------------
426 // class VCLXToolkit
427 // ----------------------------------------------------
428
429 static sal_Int32 nVCLToolkitInstanceCount = 0;
430 static sal_Bool bInitedByVCLToolkit = sal_False;
431 //static cppu::OInterfaceContainerHelper * pToolkits = 0;
432
getInitMutex()433 static osl::Mutex & getInitMutex()
434 {
435 static osl::Mutex * pM;
436 if( !pM )
437 {
438 osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
439 if( !pM )
440 {
441 static osl::Mutex aMutex;
442 pM = &aMutex;
443 }
444 }
445 return *pM;
446 }
447
getInitCondition()448 static osl::Condition & getInitCondition()
449 {
450 static osl::Condition * pC = 0;
451 if( !pC )
452 {
453 osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
454 if( !pC )
455 {
456 static osl::Condition aCondition;
457 pC = &aCondition;
458 }
459 }
460 return *pC;
461 }
462
463 struct ToolkitThreadData
464 {
465 VCLXToolkit * pTk;
466 ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xSMgr;
467
ToolkitThreadDataToolkitThreadData468 ToolkitThreadData( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > & rSMgr, VCLXToolkit * pTk_ )
469 : pTk( pTk_ )
470 , xSMgr( rSMgr )
471 {
472 }
473 };
474
475 extern "C"
476 {
ToolkitWorkerFunction(void * pArgs)477 static void SAL_CALL ToolkitWorkerFunction( void* pArgs )
478 {
479 ToolkitThreadData * pTTD = (ToolkitThreadData *)pArgs;
480 bInitedByVCLToolkit = InitVCL( pTTD->xSMgr );
481 if( bInitedByVCLToolkit )
482 {
483 UnoWrapper* pUnoWrapper = new UnoWrapper( pTTD->pTk );
484 Application::SetUnoWrapper( pUnoWrapper );
485 }
486 getInitCondition().set();
487 if( bInitedByVCLToolkit )
488 {
489 {
490 osl::Guard< vos::IMutex > aGuard( Application::GetSolarMutex() );
491 Application::Execute();
492 }
493 try
494 {
495 pTTD->pTk->dispose();
496 }
497 catch( com::sun::star::uno::Exception & )
498 {
499 }
500 /*
501 if( pToolkits )
502 {
503 cppu::OInterfaceIteratorHelper aIt( *pToolkits );
504 ::com::sun::star::uno::XInterface * pI;
505 while( pI = aIt.next() )
506 ((::com::sun::star::lang::XComponent *)pI)->dispose();
507
508 // delete toolkit container
509 osl::Guard< osl::Mutex > aGuard( getInitMutex() );
510 delete pToolkits;
511 pToolkits = 0;
512 }
513 */
514 DeInitVCL();
515 }
516 else
517 {
518 JoinMainLoopThread();
519 }
520 delete pTTD;
521 }
522 }
523
524 // contructor, which might initialize VCL
VCLXToolkit(const::com::sun::star::uno::Reference<::com::sun::star::lang::XMultiServiceFactory> & rSMgr)525 VCLXToolkit::VCLXToolkit( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > & rSMgr ):
526 cppu::WeakComponentImplHelper7<
527 ::com::sun::star::awt::XToolkit,
528 ::com::sun::star::lang::XServiceInfo,
529 ::com::sun::star::awt::XSystemChildFactory,
530 ::com::sun::star::awt::XMessageBoxFactory,
531 ::com::sun::star::awt::XDataTransferProviderAccess,
532 ::com::sun::star::awt::XExtendedToolkit,
533 ::com::sun::star::awt::XReschedule>( GetMutex() ),
534 m_aTopWindowListeners(rBHelper.rMutex),
535 m_aKeyHandlers(rBHelper.rMutex),
536 m_aFocusListeners(rBHelper.rMutex),
537 m_aEventListenerLink(LINK(this, VCLXToolkit, eventListenerHandler)),
538 m_aKeyListenerLink(LINK(this, VCLXToolkit, keyListenerHandler)),
539 m_bEventListener(false),
540 m_bKeyListener(false)
541 {
542 hSvToolsLib = NULL;
543 fnSvtCreateWindow = NULL;
544
545 osl::Guard< osl::Mutex > aGuard( getInitMutex() );
546 nVCLToolkitInstanceCount++;
547 if( ( nVCLToolkitInstanceCount == 1 ) && ( !Application::IsInMain() ) )
548 {
549 // setup execute thread
550 CreateMainLoopThread( ToolkitWorkerFunction, new ToolkitThreadData( rSMgr, this ) );
551 getInitCondition().wait();
552 /*
553 if( bInitedByVCLToolkit )
554 {
555 // insert in disposing list
556 if( !pToolkits )
557 pToolkits = new cppu::OInterfaceContainerHelper( getInitMutex() );
558 pToolkits->addInterface( (::com::sun::star::lang::XComponent *)this );
559 }
560 */
561 }
562 }
563
~VCLXToolkit()564 VCLXToolkit::~VCLXToolkit()
565 {
566 }
567
568
disposing()569 void SAL_CALL VCLXToolkit::disposing()
570 {
571 if ( hSvToolsLib )
572 {
573 osl_unloadModule( hSvToolsLib );
574 hSvToolsLib = NULL;
575 fnSvtCreateWindow = NULL;
576 }
577
578 {
579 osl::Guard< osl::Mutex > aGuard( getInitMutex() );
580 if( --nVCLToolkitInstanceCount == 0 )
581 {
582 if( bInitedByVCLToolkit )
583 {
584 Application::Quit();
585 JoinMainLoopThread();
586 bInitedByVCLToolkit = sal_False;
587 }
588 }
589 }
590
591 if (m_bEventListener)
592 {
593 ::Application::RemoveEventListener(m_aEventListenerLink);
594 m_bEventListener = false;
595 }
596 if (m_bKeyListener)
597 {
598 ::Application::RemoveKeyListener(m_aKeyListenerLink);
599 m_bKeyListener = false;
600 }
601 ::css::lang::EventObject aEvent(
602 static_cast< ::cppu::OWeakObject * >(this));
603 m_aTopWindowListeners.disposeAndClear(aEvent);
604 m_aKeyHandlers.disposeAndClear(aEvent);
605 m_aFocusListeners.disposeAndClear(aEvent);
606
607 /*
608 osl::Guard< osl::Mutex > aGuard( getInitMutex() );
609 // insert in disposing list
610 if( pToolkits )
611 {
612 // remove from the disposing list
613 pToolkits->removeInterface( (::com::sun::star::lang::XComponent *)this );
614 }
615 */
616 }
617
618
getDesktopWindow()619 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > VCLXToolkit::getDesktopWindow( ) throw(::com::sun::star::uno::RuntimeException)
620 {
621 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > xRef;
622 // 07/00: AppWindow doesn't exist anymore...
623 return xRef;
624 }
625
getWorkArea()626 ::com::sun::star::awt::Rectangle VCLXToolkit::getWorkArea( ) throw(::com::sun::star::uno::RuntimeException)
627 {
628 ::com::sun::star::awt::Rectangle aRect;
629 // 07/00: AppWindow doesn't exist anymore...
630 return aRect;
631 }
632
createWindow(const::com::sun::star::awt::WindowDescriptor & rDescriptor)633 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > VCLXToolkit::createWindow( const ::com::sun::star::awt::WindowDescriptor& rDescriptor ) throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException)
634 {
635 #ifdef WNT
636 CEnableAccessInterface e;
637 #endif
638 return ImplCreateWindow( rDescriptor, WinBits(0) );
639 }
640
createScreenCompatibleDevice(sal_Int32 Width,sal_Int32 Height)641 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XDevice > VCLXToolkit::createScreenCompatibleDevice( sal_Int32 Width, sal_Int32 Height ) throw(::com::sun::star::uno::RuntimeException)
642 {
643 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
644
645 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XDevice > xRef;
646 VCLXVirtualDevice* pVDev = new VCLXVirtualDevice;
647
648 osl::Guard< vos::IMutex > aSolarGuard( Application::GetSolarMutex() );
649
650 VirtualDevice* pV = new VirtualDevice;
651 pV->SetOutputSizePixel( Size( Width, Height ) );
652 pVDev->SetVirtualDevice( pV );
653
654 xRef = pVDev;
655 return xRef;
656 }
657
createRegion()658 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XRegion > VCLXToolkit::createRegion( ) throw(::com::sun::star::uno::RuntimeException)
659 {
660 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
661
662 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XRegion > xRef = new VCLXRegion;
663 return xRef;
664 }
665
ImplCreateWindow(VCLXWindow ** ppNewComp,const::com::sun::star::awt::WindowDescriptor & rDescriptor,Window * pParent,WinBits nWinBits)666 Window* VCLXToolkit::ImplCreateWindow( VCLXWindow** ppNewComp,
667 const ::com::sun::star::awt::WindowDescriptor& rDescriptor,
668 Window* pParent, WinBits nWinBits )
669 {
670 String aServiceName( rDescriptor.WindowServiceName );
671 aServiceName.ToLowerAscii();
672
673 Window* pNewWindow = NULL;
674 sal_uInt16 nType = ImplGetComponentType( aServiceName );
675
676 if ( !pParent )
677 {
678 // Wenn die Component einen Parent braucht, dann NULL zurueckgeben,
679 // spaeter mal ::com::sun::star::uno::Exception...
680 sal_Bool bException = sal_True;
681 if ( ( nType == WINDOW_DIALOG )
682 || ( nType == WINDOW_MODALDIALOG )
683 || ( nType == WINDOW_MODELESSDIALOG )
684 || ( nType == WINDOW_MESSBOX )
685 || ( nType == WINDOW_INFOBOX )
686 || ( nType == WINDOW_WARNINGBOX )
687 || ( nType == WINDOW_ERRORBOX )
688 || ( nType == WINDOW_QUERYBOX )
689 )
690 bException = sal_False;
691 else if ( ( nType == WINDOW_WINDOW ) ||
692 ( nType == WINDOW_WORKWINDOW ) ||
693 ( nType == VCLWINDOW_FRAMEWINDOW ) )
694 {
695 if ( rDescriptor.Type == ::com::sun::star::awt::WindowClass_TOP )
696 bException = sal_False;
697 }
698
699 if ( bException )
700 {
701 *ppNewComp = NULL;
702 return NULL;
703 }
704 }
705
706 if ( nType )
707 {
708 vos::OGuard aVclGuard( Application::GetSolarMutex() );
709 switch ( (WindowType)nType )
710 {
711 case WINDOW_CANCELBUTTON:
712 pNewWindow = new CancelButton( pParent, nWinBits );
713 *ppNewComp = new VCLXButton;
714 break;
715 case WINDOW_CHECKBOX:
716 pNewWindow = new CheckBox( pParent, nWinBits );
717 *ppNewComp = new VCLXCheckBox;
718 break;
719 case WINDOW_COMBOBOX:
720 pNewWindow = new ComboBox( pParent, nWinBits|WB_AUTOHSCROLL );
721 ((ComboBox*)pNewWindow)->EnableAutoSize( sal_False );
722 *ppNewComp = new VCLXComboBox;
723 break;
724 case WINDOW_CURRENCYBOX:
725 pNewWindow = new CurrencyBox( pParent, nWinBits );
726 break;
727 case WINDOW_CURRENCYFIELD:
728 pNewWindow = new CurrencyField( pParent, nWinBits );
729 static_cast<CurrencyField*>(pNewWindow)->EnableEmptyFieldValue( sal_True );
730 *ppNewComp = new VCLXNumericField;
731 ((VCLXFormattedSpinField*)*ppNewComp)->SetFormatter( (FormatterBase*)(CurrencyField*)pNewWindow );
732 break;
733 case WINDOW_DATEBOX:
734 pNewWindow = new DateBox( pParent, nWinBits );
735 break;
736 case WINDOW_DATEFIELD:
737 pNewWindow = new DateField( pParent, nWinBits );
738 static_cast<DateField*>(pNewWindow)->EnableEmptyFieldValue( sal_True );
739 *ppNewComp = new VCLXDateField;
740 ((VCLXFormattedSpinField*)*ppNewComp)->SetFormatter( (FormatterBase*)(DateField*)pNewWindow );
741 break;
742 case WINDOW_DOCKINGAREA:
743 pNewWindow = new DockingAreaWindow( pParent );
744 break;
745 case WINDOW_MULTILINEEDIT:
746 case WINDOW_EDIT:
747 pNewWindow = new Edit( pParent, nWinBits );
748 *ppNewComp = new VCLXEdit;
749 break;
750 case WINDOW_ERRORBOX:
751 pNewWindow = new ErrorBox( pParent, nWinBits, String() );
752 *ppNewComp = new VCLXMessageBox;
753 break;
754 case WINDOW_FIXEDBITMAP:
755 pNewWindow = new FixedBitmap( pParent, nWinBits );
756 break;
757 case WINDOW_FIXEDIMAGE:
758 pNewWindow = new ImageControl( pParent, nWinBits );
759 *ppNewComp = new VCLXImageControl;
760 break;
761 case WINDOW_FIXEDLINE:
762 pNewWindow = new FixedLine( pParent, nWinBits );
763 break;
764 case WINDOW_FIXEDTEXT:
765 pNewWindow = new FixedText( pParent, nWinBits );
766 *ppNewComp = new VCLXFixedText;
767 break;
768 case WINDOW_FLOATINGWINDOW:
769 pNewWindow = new FloatingWindow( pParent, nWinBits );
770 break;
771 case WINDOW_GROUPBOX:
772 pNewWindow = new GroupBox( pParent, nWinBits );
773 break;
774 case WINDOW_HELPBUTTON:
775 pNewWindow = new HelpButton( pParent, nWinBits );
776 *ppNewComp = new VCLXButton;
777 break;
778 case WINDOW_IMAGEBUTTON:
779 pNewWindow = new ImageButton( pParent, nWinBits );
780 *ppNewComp = new VCLXButton;
781 break;
782 case WINDOW_IMAGERADIOBUTTON:
783 pNewWindow = new ImageRadioButton( pParent, nWinBits );
784 *ppNewComp = new VCLXButton;
785 break;
786 case WINDOW_INFOBOX:
787 pNewWindow = new InfoBox( pParent, String() );
788 *ppNewComp = new VCLXMessageBox;
789 break;
790 case WINDOW_LISTBOX:
791 pNewWindow = new ListBox( pParent, nWinBits|WB_SIMPLEMODE|WB_AUTOHSCROLL );
792 ((ListBox*)pNewWindow)->EnableAutoSize( sal_False );
793 *ppNewComp = new VCLXListBox;
794 break;
795 case WINDOW_LONGCURRENCYBOX:
796 pNewWindow = new LongCurrencyBox( pParent, nWinBits );
797 break;
798 case WINDOW_LONGCURRENCYFIELD:
799 pNewWindow = new LongCurrencyField( pParent, nWinBits );
800 *ppNewComp = new VCLXCurrencyField;
801 ((VCLXFormattedSpinField*)*ppNewComp)->SetFormatter( (FormatterBase*)(LongCurrencyField*)pNewWindow );
802 break;
803 case WINDOW_MENUBUTTON:
804 pNewWindow = new MenuButton( pParent, nWinBits );
805 *ppNewComp = new VCLXButton;
806 break;
807 case WINDOW_MESSBOX:
808 pNewWindow = new MessBox( pParent, nWinBits, String(), String() );
809 *ppNewComp = new VCLXMessageBox;
810 break;
811 case WINDOW_METRICBOX:
812 pNewWindow = new MetricBox( pParent, nWinBits );
813 break;
814 case WINDOW_METRICFIELD:
815 pNewWindow = new MetricField( pParent, nWinBits );
816 *ppNewComp = new VCLXMetricField;
817 ((VCLXFormattedSpinField*)*ppNewComp)->SetFormatter( (FormatterBase*)(MetricField*)pNewWindow );
818 break;
819 case WINDOW_DIALOG:
820 case WINDOW_MODALDIALOG:
821 case WINDOW_MODELESSDIALOG:
822 {
823 // Modal/Modeless nur durch Show/Execute
824 if ( (pParent == NULL ) && ( rDescriptor.ParentIndex == -1 ) )
825 pParent = DIALOG_NO_PARENT;
826 pNewWindow = new Dialog( pParent, nWinBits );
827 // #i70217# Don't always create a new component object. It's possible that VCL has called
828 // GetComponentInterface( sal_True ) in the Dialog ctor itself (see Window::IsTopWindow() )
829 // which creates a component object.
830 css::uno::Reference< css::awt::XWindowPeer > xWinPeer = pNewWindow->GetComponentInterface( sal_False );
831 if ( xWinPeer.is() )
832 *ppNewComp = dynamic_cast< VCLXDialog* >( xWinPeer.get() );
833 else
834 *ppNewComp = new VCLXDialog;
835 }
836 break;
837 case WINDOW_MOREBUTTON:
838 pNewWindow = new MoreButton( pParent, nWinBits );
839 *ppNewComp = new VCLXButton;
840 break;
841 case WINDOW_MULTILISTBOX:
842 pNewWindow = new MultiListBox( pParent, nWinBits );
843 *ppNewComp = new VCLXListBox;
844 break;
845 case WINDOW_NUMERICBOX:
846 pNewWindow = new NumericBox( pParent, nWinBits );
847 break;
848 case WINDOW_NUMERICFIELD:
849 pNewWindow = new NumericField( pParent, nWinBits );
850 static_cast<NumericField*>(pNewWindow)->EnableEmptyFieldValue( sal_True );
851 *ppNewComp = new VCLXNumericField;
852 ((VCLXFormattedSpinField*)*ppNewComp)->SetFormatter( (FormatterBase*)(NumericField*)pNewWindow );
853 break;
854 case WINDOW_OKBUTTON:
855 pNewWindow = new OKButton( pParent, nWinBits );
856 *ppNewComp = new VCLXButton;
857 break;
858 case WINDOW_PATTERNBOX:
859 pNewWindow = new PatternBox( pParent, nWinBits );
860 break;
861 case WINDOW_PATTERNFIELD:
862 pNewWindow = new PatternField( pParent, nWinBits );
863 *ppNewComp = new VCLXPatternField;
864 ((VCLXFormattedSpinField*)*ppNewComp)->SetFormatter( (FormatterBase*)(PatternField*)pNewWindow );
865 break;
866 case WINDOW_PUSHBUTTON:
867 pNewWindow = new PushButton( pParent, nWinBits );
868 *ppNewComp = new VCLXButton;
869 break;
870 case WINDOW_QUERYBOX:
871 pNewWindow = new QueryBox( pParent, nWinBits, String() );
872 *ppNewComp = new VCLXMessageBox;
873 break;
874 case WINDOW_RADIOBUTTON:
875 pNewWindow = new RadioButton( pParent, nWinBits );
876 *ppNewComp = new VCLXRadioButton;
877
878 // by default, disable RadioCheck
879 // Since the VCLXRadioButton really cares for it's RadioCheck settings, this is important:
880 // if we enable it, the VCLXRadioButton will use RadioButton::Check instead of RadioButton::SetState
881 // This leads to a strange behaviour if the control is newly created: when settings the initial
882 // state to "checked", the RadioButton::Check (called because RadioCheck=sal_True) will uncheck
883 // _all_other_ radio buttons in the same group. However, at this moment the grouping of the controls
884 // is not really valid: the controls are grouped after they have been created, but we're still in
885 // the creation process, so the RadioButton::Check relies on invalid grouping information.
886 // 07.08.2001 - #87254# - frank.schoenheit@sun.com
887 static_cast<RadioButton*>(pNewWindow)->EnableRadioCheck( sal_False );
888 break;
889 case WINDOW_SCROLLBAR:
890 pNewWindow = new ScrollBar( pParent, nWinBits );
891 *ppNewComp = new VCLXScrollBar;
892 break;
893 case WINDOW_SCROLLBARBOX:
894 pNewWindow = new ScrollBarBox( pParent, nWinBits );
895 break;
896 case WINDOW_SPINBUTTON:
897 pNewWindow = new SpinButton( pParent, nWinBits );
898 *ppNewComp = new ::toolkit::VCLXSpinButton;
899 break;
900 case WINDOW_SPINFIELD:
901 pNewWindow = new SpinField( pParent, nWinBits );
902 *ppNewComp = new VCLXNumericField;
903 break;
904 case WINDOW_SPLITTER:
905 pNewWindow = new Splitter( pParent, nWinBits );
906 break;
907 case WINDOW_SPLITWINDOW:
908 pNewWindow = new SplitWindow( pParent, nWinBits );
909 break;
910 case WINDOW_STATUSBAR:
911 pNewWindow = new StatusBar( pParent, nWinBits );
912 break;
913 case VCLWINDOW_SYSTEMCHILDWINDOW:
914 pNewWindow = new SystemChildWindow( pParent, nWinBits );
915 *ppNewComp = new VCLXSystemDependentWindow();
916 break;
917 case WINDOW_TABCONTROL:
918 pNewWindow = new TabControl( pParent, nWinBits );
919 *ppNewComp = new VCLXTabPageContainer;
920 break;
921 case WINDOW_TABDIALOG:
922 pNewWindow = new TabDialog( pParent, nWinBits );
923 break;
924 case WINDOW_TABPAGE:
925 /*
926 if ( rDescriptor.WindowServiceName.equalsIgnoreAsciiCase(
927 ::rtl::OUString::createFromAscii("tabpagemodel") ) )
928 {
929 pNewWindow = new TabControl( pParent, nWinBits );
930 *ppNewComp = new VCLXTabPageContainer;
931 }
932 else
933 */
934 {
935 pNewWindow = new TabPage( pParent, nWinBits );
936 *ppNewComp = new VCLXTabPage;
937 }
938 break;
939 case WINDOW_TIMEBOX:
940 pNewWindow = new TimeBox( pParent, nWinBits );
941 break;
942 case WINDOW_TIMEFIELD:
943 pNewWindow = new TimeField( pParent, nWinBits );
944 static_cast<TimeField*>(pNewWindow)->EnableEmptyFieldValue( sal_True );
945 *ppNewComp = new VCLXTimeField;
946 ((VCLXFormattedSpinField*)*ppNewComp)->SetFormatter( (FormatterBase*)(TimeField*)pNewWindow );
947 break;
948 case WINDOW_TOOLBOX:
949 pNewWindow = new ToolBox( pParent, nWinBits );
950 *ppNewComp = new VCLXToolBox;
951 break;
952 case WINDOW_TRISTATEBOX:
953 pNewWindow = new TriStateBox( pParent, nWinBits );
954 break;
955 case WINDOW_WARNINGBOX:
956 pNewWindow = new WarningBox( pParent, nWinBits, String() );
957 *ppNewComp = new VCLXMessageBox;
958 break;
959 case WINDOW_WORKWINDOW:
960 case WINDOW_WINDOW:
961 case VCLWINDOW_FRAMEWINDOW:
962 case WINDOW_DOCKINGWINDOW:
963 if ( rDescriptor.Type == ::com::sun::star::awt::WindowClass_TOP )
964 {
965 if (nType == WINDOW_DOCKINGWINDOW )
966 pNewWindow = new DockingWindow( pParent, nWinBits );
967 else
968 {
969 if ((pParent == NULL) && rDescriptor.Parent.is())
970 {
971 // try to get a system dependent window handle
972 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XSystemDependentWindowPeer > xSystemDepParent(rDescriptor.Parent, ::com::sun::star::uno::UNO_QUERY);
973
974 if (xSystemDepParent.is())
975 {
976 sal_Int8 processID[16];
977
978 rtl_getGlobalProcessId( (sal_uInt8*)processID );
979
980 ::com::sun::star::uno::Sequence<sal_Int8> processIdSeq(processID, 16);
981
982 ::com::sun::star::uno::Any anyHandle = xSystemDepParent->getWindowHandle(processIdSeq, SYSTEM_DEPENDENT_TYPE);
983
984 // use sal_Int64 here to accomodate all int types
985 // uno::Any shift operator whill upcast if necessary
986 sal_Int64 nWindowHandle = 0;
987 sal_Bool bXEmbed = sal_False;
988
989 bool bUseParentData = true;
990 if( ! (anyHandle >>= nWindowHandle) )
991 {
992 css::uno::Sequence< css::beans::NamedValue > aProps;
993 if( anyHandle >>= aProps )
994 {
995 const int nProps = aProps.getLength();
996 const css::beans::NamedValue* pProps = aProps.getConstArray();
997 for( int i = 0; i < nProps; i++ )
998 {
999 if( pProps[i].Name.equalsAscii( "WINDOW" ) )
1000 pProps[i].Value >>= nWindowHandle;
1001 else if( pProps[i].Name.equalsAscii( "XEMBED" ) )
1002 pProps[i].Value >>= bXEmbed;
1003 }
1004 }
1005 else
1006 bUseParentData = false;
1007 }
1008
1009 if( bUseParentData )
1010 {
1011 SystemParentData aParentData;
1012 aParentData.nSize = sizeof( aParentData );
1013 #if defined QUARTZ
1014 aParentData.pView = reinterpret_cast<NSView*>(nWindowHandle);
1015 #elif defined UNX
1016 aParentData.aWindow = nWindowHandle;
1017 aParentData.bXEmbedSupport = bXEmbed;
1018 #elif defined WNT
1019 aParentData.hWnd = reinterpret_cast<HWND>(nWindowHandle);
1020 #elif defined OS2
1021 aParentData.hWnd = (HWND)nWindowHandle;
1022 #endif
1023 pNewWindow = new WorkWindow( &aParentData );
1024 }
1025 }
1026 }
1027
1028 if (!pNewWindow)
1029 pNewWindow = new WorkWindow( pParent, nWinBits );
1030 }
1031
1032 *ppNewComp = new VCLXTopWindow( pNewWindow->GetType() == WINDOW_WORKWINDOW );
1033 }
1034 else if ( rDescriptor.Type == ::com::sun::star::awt::WindowClass_CONTAINER )
1035 {
1036 if (nType == WINDOW_DOCKINGWINDOW )
1037 pNewWindow = new DockingWindow( pParent, nWinBits );
1038 else
1039 pNewWindow = new Window( pParent, nWinBits );
1040 *ppNewComp = new VCLXContainer;
1041 }
1042 else
1043 {
1044 if (nType == WINDOW_DOCKINGWINDOW )
1045 pNewWindow = new DockingWindow( pParent, nWinBits );
1046 else
1047 pNewWindow = new Window( pParent, nWinBits );
1048 *ppNewComp = new VCLXWindow;
1049 }
1050 break;
1051 case WINDOW_CONTROL:
1052 if ( rDescriptor.WindowServiceName.equalsIgnoreAsciiCase(
1053 ::rtl::OUString::createFromAscii("tabpagecontainer") ) )
1054 {
1055 pNewWindow = new TabControl( pParent, nWinBits );
1056 *ppNewComp = new VCLXTabPageContainer;
1057 }
1058 else if ( aServiceName.EqualsAscii( "animatedimages" ) )
1059 {
1060 pNewWindow = new Throbber( pParent, nWinBits );
1061 *ppNewComp = new ::toolkit::AnimatedImagesPeer;
1062 }
1063 break;
1064 default:
1065 OSL_ENSURE( false, "VCLXToolkit::ImplCreateWindow: unknown window type!" );
1066 break;
1067 }
1068 }
1069
1070 return pNewWindow;
1071 }
1072
thisModule()1073 extern "C" { static void SAL_CALL thisModule() {} }
1074
ImplCreateWindow(const css::awt::WindowDescriptor & rDescriptor,WinBits nForceWinBits)1075 css::uno::Reference< css::awt::XWindowPeer > VCLXToolkit::ImplCreateWindow(
1076 const css::awt::WindowDescriptor& rDescriptor,
1077 WinBits nForceWinBits )
1078 {
1079 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
1080
1081 osl::Guard< vos::IMutex > aSolarGuard( Application::GetSolarMutex() );
1082
1083 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > xRef;
1084
1085 Window* pParent = NULL;
1086 if ( rDescriptor.Parent.is() )
1087 {
1088 VCLXWindow* pParentComponent = VCLXWindow::GetImplementation( rDescriptor.Parent );
1089
1090 // #103939# Don't through assertion, may be it's a system dependend window, used in ImplCreateWindow.
1091 // DBG_ASSERT( pParentComponent, "ParentComponent not valid" );
1092
1093 if ( pParentComponent )
1094 pParent = pParentComponent->GetWindow();
1095 }
1096
1097 WinBits nWinBits = ImplGetWinBits( rDescriptor.WindowAttributes,
1098 ImplGetComponentType( rDescriptor.WindowServiceName ) );
1099 nWinBits |= nForceWinBits;
1100
1101 VCLXWindow* pNewComp = NULL;
1102
1103 Window* pNewWindow = NULL;
1104 // Try to create the window with SvTools
1105 // (do this _before_ creating it on our own: The old mechanism (extended toolkit in SvTools) did it this way,
1106 // and we need to stay compatible)
1107 // try to load the lib
1108 if ( !fnSvtCreateWindow && !hSvToolsLib )
1109 {
1110 ::rtl::OUString aLibName = ::vcl::unohelper::CreateLibraryName( "svt", sal_True );
1111 hSvToolsLib = osl_loadModuleRelative(
1112 &thisModule, aLibName.pData, SAL_LOADMODULE_DEFAULT );
1113 if ( hSvToolsLib )
1114 {
1115 ::rtl::OUString aFunctionName( RTL_CONSTASCII_USTRINGPARAM( "CreateWindow" ) );
1116 fnSvtCreateWindow = (FN_SvtCreateWindow)osl_getFunctionSymbol( hSvToolsLib, aFunctionName.pData );
1117 }
1118 }
1119 // ask the SvTool creation function
1120 if ( fnSvtCreateWindow )
1121 pNewWindow = fnSvtCreateWindow( &pNewComp, &rDescriptor, pParent, nWinBits );
1122
1123 // if SvTools could not provide a window, create it ourself
1124 if ( !pNewWindow )
1125 pNewWindow = ImplCreateWindow( &pNewComp, rDescriptor, pParent, nWinBits );
1126
1127 DBG_ASSERT( pNewWindow, "createWindow: Unknown Component!" );
1128 DBG_ASSERTWARNING( pNewComp, "createWindow: No special Interface!" );
1129
1130 if ( pNewWindow )
1131 {
1132 pNewWindow->SetCreatedWithToolkit( sal_True );
1133 //pNewWindow->SetPosPixel( Point() ); // do not force (0,0) position, keep default pos instead
1134
1135 if ( rDescriptor.WindowAttributes & ::com::sun::star::awt::WindowAttribute::MINSIZE )
1136 {
1137 pNewWindow->SetSizePixel( Size() );
1138 }
1139 else if ( rDescriptor.WindowAttributes & ::com::sun::star::awt::WindowAttribute::FULLSIZE )
1140 {
1141 if ( pParent )
1142 pNewWindow->SetSizePixel( pParent->GetOutputSizePixel() );
1143 }
1144 else if ( !VCLUnoHelper::IsZero( rDescriptor.Bounds ) )
1145 {
1146 Rectangle aRect = VCLRectangle( rDescriptor.Bounds );
1147 pNewWindow->SetPosSizePixel( aRect.TopLeft(), aRect.GetSize() );
1148 }
1149
1150 if ( !pNewComp )
1151 {
1152 // Default-Interface
1153 xRef = pNewWindow->GetComponentInterface( sal_True );
1154 }
1155 else
1156 {
1157 pNewComp->SetCreatedWithToolkit( sal_True );
1158 xRef = pNewComp;
1159 pNewWindow->SetComponentInterface( xRef );
1160 }
1161 DBG_ASSERT( pNewWindow->GetComponentInterface( sal_False ) == xRef,
1162 "VCLXToolkit::createWindow: did #133706# resurge?" );
1163
1164 if ( rDescriptor.WindowAttributes & ::com::sun::star::awt::WindowAttribute::SHOW )
1165 pNewWindow->Show();
1166 }
1167
1168 return xRef;
1169 }
1170
createWindows(const::com::sun::star::uno::Sequence<::com::sun::star::awt::WindowDescriptor> & rDescriptors)1171 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > > VCLXToolkit::createWindows( const ::com::sun::star::uno::Sequence< ::com::sun::star::awt::WindowDescriptor >& rDescriptors ) throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException)
1172 {
1173 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
1174
1175 sal_uInt32 nComponents = rDescriptors.getLength();
1176 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > > aSeq( nComponents );
1177 for ( sal_uInt32 n = 0; n < nComponents; n++ )
1178 {
1179 ::com::sun::star::awt::WindowDescriptor aDescr = rDescriptors.getConstArray()[n];
1180
1181 if ( aDescr.ParentIndex == (-1) )
1182 aDescr.Parent = NULL;
1183 else if ( ( aDescr.ParentIndex >= 0 ) && ( aDescr.ParentIndex < (short)n ) )
1184 aDescr.Parent = aSeq.getConstArray()[aDescr.ParentIndex];
1185 aSeq.getArray()[n] = createWindow( aDescr );
1186 }
1187 return aSeq;
1188 }
1189
1190 // ::com::sun::star::awt::XSystemChildFactory
createSystemChild(const::com::sun::star::uno::Any & Parent,const::com::sun::star::uno::Sequence<sal_Int8> &,sal_Int16 nSystemType)1191 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > VCLXToolkit::createSystemChild( const ::com::sun::star::uno::Any& Parent, const ::com::sun::star::uno::Sequence< sal_Int8 >& /*ProcessId*/, sal_Int16 nSystemType ) throw(::com::sun::star::uno::RuntimeException)
1192 {
1193 Window* pChildWindow = NULL;
1194 if ( nSystemType == SYSTEM_DEPENDENT_TYPE )
1195 {
1196 // use sal_Int64 here to accomodate all int types
1197 // uno::Any shift operator whill upcast if necessary
1198 sal_Int64 nWindowHandle = 0;
1199 sal_Bool bXEmbed = sal_False;
1200
1201 bool bUseParentData = true;
1202 if( ! (Parent >>= nWindowHandle) )
1203 {
1204 css::uno::Sequence< css::beans::NamedValue > aProps;
1205 if( Parent >>= aProps )
1206 {
1207 const int nProps = aProps.getLength();
1208 const css::beans::NamedValue* pProps = aProps.getConstArray();
1209 for( int i = 0; i < nProps; i++ )
1210 {
1211 if( pProps[i].Name.equalsAscii( "WINDOW" ) )
1212 pProps[i].Value >>= nWindowHandle;
1213 else if( pProps[i].Name.equalsAscii( "XEMBED" ) )
1214 pProps[i].Value >>= bXEmbed;
1215 }
1216 }
1217 else
1218 bUseParentData = false;
1219 }
1220
1221 if( bUseParentData )
1222 {
1223 SystemParentData aParentData;
1224 aParentData.nSize = sizeof( aParentData );
1225 #if defined QUARTZ
1226 aParentData.pView = reinterpret_cast<NSView*>(nWindowHandle);
1227 #elif defined UNX
1228 aParentData.aWindow = nWindowHandle;
1229 aParentData.bXEmbedSupport = bXEmbed;
1230 #elif defined WNT
1231 aParentData.hWnd = reinterpret_cast<HWND>(nWindowHandle);
1232 #elif defined OS2
1233 aParentData.hWnd = (HWND)nWindowHandle;
1234 #endif
1235 osl::Guard< vos::IMutex > aGuard( Application::GetSolarMutex() );
1236 try
1237 {
1238 pChildWindow = new WorkWindow( &aParentData );
1239 }
1240 catch ( ::com::sun::star::uno::RuntimeException & rEx )
1241 {
1242 // system child window could not be created
1243 OSL_TRACE(
1244 "VCLXToolkit::createSystemChild: caught %s\n",
1245 ::rtl::OUStringToOString(
1246 rEx.Message, RTL_TEXTENCODING_UTF8).getStr());
1247 pChildWindow = NULL;
1248 }
1249 }
1250 }
1251 else if (nSystemType == com::sun::star::lang::SystemDependent::SYSTEM_JAVA)
1252 {
1253 osl::Guard< vos::IMutex > aGuard(Application::GetSolarMutex());
1254 pChildWindow = new WorkWindow(0, Parent);
1255 }
1256
1257 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > xPeer;
1258 if ( pChildWindow )
1259 {
1260 VCLXTopWindow* pPeer = new VCLXTopWindow(true);
1261 osl::Guard< vos::IMutex > aGuard( Application::GetSolarMutex() );
1262 pPeer->SetWindow( pChildWindow );
1263 xPeer = pPeer;
1264 }
1265
1266 return xPeer;
1267 }
1268
1269 // ::com::sun::star::awt::XMessageBoxFactory
createMessageBox(const::com::sun::star::uno::Reference<::com::sun::star::awt::XWindowPeer> & aParent,::com::sun::star::awt::MessageBoxType eType,::sal_Int32 aButtons,const::rtl::OUString & aTitle,const::rtl::OUString & aMessage)1270 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XMessageBox > SAL_CALL VCLXToolkit::createMessageBox(
1271 const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer >& aParent,
1272 ::com::sun::star::awt::MessageBoxType eType,
1273 ::sal_Int32 aButtons,
1274 const ::rtl::OUString& aTitle,
1275 const ::rtl::OUString& aMessage ) throw (::com::sun::star::uno::RuntimeException)
1276 {
1277 ::com::sun::star::awt::WindowDescriptor aDescriptor;
1278
1279 sal_Int32 nWindowAttributes = css::awt::WindowAttribute::BORDER|css::awt::WindowAttribute::MOVEABLE|css::awt::WindowAttribute::CLOSEABLE;
1280
1281 // Map button definitions to window attributes
1282 if (( aButtons & 0x0000ffffL ) == css::awt::MessageBoxButtons::BUTTONS_OK )
1283 nWindowAttributes |= css::awt::VclWindowPeerAttribute::OK;
1284 else if (( aButtons & 0x0000ffffL ) == css::awt::MessageBoxButtons::BUTTONS_OK_CANCEL )
1285 nWindowAttributes |= css::awt::VclWindowPeerAttribute::OK_CANCEL;
1286 else if (( aButtons & 0x0000ffffL ) == css::awt::MessageBoxButtons::BUTTONS_YES_NO )
1287 nWindowAttributes |= css::awt::VclWindowPeerAttribute::YES_NO;
1288 else if (( aButtons & 0x0000ffffL ) == css::awt::MessageBoxButtons::BUTTONS_YES_NO_CANCEL )
1289 nWindowAttributes |= css::awt::VclWindowPeerAttribute::YES_NO_CANCEL;
1290 else if (( aButtons & 0x0000ffffL ) == css::awt::MessageBoxButtons::BUTTONS_RETRY_CANCEL )
1291 nWindowAttributes |= css::awt::VclWindowPeerAttribute::RETRY_CANCEL;
1292
1293 // Map default button definitions to window attributes
1294 if (sal_Int32( aButtons & 0xffff0000L ) == css::awt::MessageBoxButtons::DEFAULT_BUTTON_OK )
1295 nWindowAttributes |= css::awt::VclWindowPeerAttribute::DEF_OK;
1296 else if (sal_Int32( aButtons & 0xffff0000L ) == css::awt::MessageBoxButtons::DEFAULT_BUTTON_CANCEL )
1297 nWindowAttributes |= css::awt::VclWindowPeerAttribute::DEF_CANCEL;
1298 else if (sal_Int32( aButtons & 0xffff0000L ) == css::awt::MessageBoxButtons::DEFAULT_BUTTON_YES )
1299 nWindowAttributes |= css::awt::VclWindowPeerAttribute::DEF_YES;
1300 else if (sal_Int32( aButtons & 0xffff0000L ) == css::awt::MessageBoxButtons::DEFAULT_BUTTON_NO )
1301 nWindowAttributes |= css::awt::VclWindowPeerAttribute::DEF_NO;
1302 else if (sal_Int32( aButtons & 0xffff0000L ) == css::awt::MessageBoxButtons::DEFAULT_BUTTON_RETRY )
1303 nWindowAttributes |= css::awt::VclWindowPeerAttribute::DEF_RETRY;
1304
1305 // No more bits for VclWindowPeerAttribute possible. Mapping must be
1306 // done explicitly using VCL methods
1307 WinBits nAddWinBits( 0 );
1308 if (( aButtons & 0x0000ffffL ) == css::awt::MessageBoxButtons::BUTTONS_ABORT_IGNORE_RETRY )
1309 nAddWinBits |= WB_ABORT_RETRY_IGNORE;
1310 if ( sal_Int32( aButtons & 0xffff0000L ) == css::awt::MessageBoxButtons::DEFAULT_BUTTON_IGNORE )
1311 nAddWinBits |= WB_DEF_IGNORE;
1312
1313 rtl::OUString aType;
1314 lcl_convertMessageBoxType( aType, eType );
1315
1316 aDescriptor.Type = css::awt::WindowClass_MODALTOP;
1317 aDescriptor.WindowServiceName = aType;
1318 aDescriptor.ParentIndex = -1;
1319 aDescriptor.Parent = aParent;
1320 aDescriptor.WindowAttributes = nWindowAttributes;
1321 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XMessageBox > xMsgBox(
1322 ImplCreateWindow( aDescriptor, nAddWinBits ), css::uno::UNO_QUERY );
1323 css::uno::Reference< css::awt::XWindow > xWindow( xMsgBox, css::uno::UNO_QUERY );
1324 if ( xMsgBox.is() && xWindow.is() )
1325 {
1326 Window * pWindow = VCLUnoHelper::GetWindow( xWindow );
1327 if ( pWindow )
1328 {
1329 osl::Guard< vos::IMutex > aGuard(Application::GetSolarMutex());
1330 xMsgBox->setCaptionText( aTitle );
1331 xMsgBox->setMessageText( aMessage );
1332 }
1333 }
1334
1335 return xMsgBox;
1336 }
1337
getDragGestureRecognizer(const::com::sun::star::uno::Reference<::com::sun::star::awt::XWindow> & window)1338 ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDragGestureRecognizer > SAL_CALL VCLXToolkit::getDragGestureRecognizer( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow >& window ) throw(::com::sun::star::uno::RuntimeException)
1339 {
1340 Window * pWindow = VCLUnoHelper::GetWindow( window );
1341
1342 if( pWindow )
1343 return pWindow->GetDragGestureRecognizer();
1344
1345 return ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDragGestureRecognizer >();
1346 }
1347
getDragSource(const::com::sun::star::uno::Reference<::com::sun::star::awt::XWindow> & window)1348 ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDragSource > SAL_CALL VCLXToolkit::getDragSource( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow >& window ) throw(::com::sun::star::uno::RuntimeException)
1349 {
1350 Window * pWindow = VCLUnoHelper::GetWindow( window );
1351
1352 if( pWindow )
1353 return pWindow->GetDragSource();
1354
1355 return ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDragSource >();
1356 }
1357
getDropTarget(const::com::sun::star::uno::Reference<::com::sun::star::awt::XWindow> & window)1358 ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDropTarget > SAL_CALL VCLXToolkit::getDropTarget( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow >& window ) throw(::com::sun::star::uno::RuntimeException)
1359 {
1360 Window * pWindow = VCLUnoHelper::GetWindow( window );
1361
1362 if( pWindow )
1363 return pWindow->GetDropTarget();
1364
1365 return ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDropTarget >();
1366 }
1367
getClipboard(const::rtl::OUString & clipboardName)1368 ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::clipboard::XClipboard > SAL_CALL VCLXToolkit::getClipboard( const ::rtl::OUString& clipboardName ) throw(::com::sun::star::uno::RuntimeException)
1369 {
1370 if( clipboardName.getLength() == 0 )
1371 {
1372 if( !mxClipboard.is() )
1373 {
1374 ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xFactory = ::comphelper::getProcessServiceFactory();
1375 if ( xFactory.is() )
1376 {
1377 // remember clipboard here
1378 mxClipboard = ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::clipboard::XClipboard > (
1379 xFactory->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.datatransfer.clipboard.SystemClipboard" ) ), ::com::sun::star::uno::UNO_QUERY );
1380 }
1381 }
1382
1383 return mxClipboard;
1384 }
1385
1386 else if( clipboardName.equals( ::rtl::OUString::createFromAscii("Selection") ) )
1387 {
1388 return mxSelection;
1389 }
1390
1391 return ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::clipboard::XClipboard >();
1392 }
1393
1394 // XServiceInfo
getImplementationName()1395 ::rtl::OUString VCLXToolkit::getImplementationName() throw(::com::sun::star::uno::RuntimeException)
1396 {
1397 return rtl::OUString::createFromAscii( "stardiv.Toolkit.VCLXToolkit" );
1398 }
1399
supportsService(const::rtl::OUString & rServiceName)1400 sal_Bool VCLXToolkit::supportsService( const ::rtl::OUString& rServiceName ) throw(::com::sun::star::uno::RuntimeException)
1401 {
1402 ::osl::MutexGuard aGuard( GetMutex() );
1403
1404 ::com::sun::star::uno::Sequence< ::rtl::OUString > aSNL = getSupportedServiceNames();
1405 const ::rtl::OUString* pArray = aSNL.getConstArray();
1406 const ::rtl::OUString* pArrayEnd = aSNL.getConstArray();
1407 for (; pArray != pArrayEnd; ++pArray )
1408 if( *pArray == rServiceName )
1409 break;
1410
1411 return pArray != pArrayEnd;
1412 }
1413
getSupportedServiceNames()1414 ::com::sun::star::uno::Sequence< ::rtl::OUString > VCLXToolkit::getSupportedServiceNames() throw(::com::sun::star::uno::RuntimeException)
1415 {
1416 ::rtl::OUString aServiceName( ::rtl::OUString::createFromAscii( szServiceName2_Toolkit ) );
1417 return ::com::sun::star::uno::Sequence< ::rtl::OUString >( &aServiceName, 1);
1418 }
1419
1420 // css::awt::XExtendedToolkit:
1421
1422 // virtual
getTopWindowCount()1423 ::sal_Int32 SAL_CALL VCLXToolkit::getTopWindowCount()
1424 throw (::css::uno::RuntimeException)
1425 {
1426 return static_cast< ::sal_Int32 >(::Application::GetTopWindowCount());
1427 // XXX numeric overflow
1428 }
1429
1430 // virtual
1431 ::css::uno::Reference< ::css::awt::XTopWindow > SAL_CALL
getTopWindow(::sal_Int32 nIndex)1432 VCLXToolkit::getTopWindow(::sal_Int32 nIndex)
1433 throw (::css::uno::RuntimeException)
1434 {
1435 ::Window * p = ::Application::GetTopWindow(static_cast< long >(nIndex));
1436 // XXX numeric overflow
1437 return ::css::uno::Reference< ::css::awt::XTopWindow >(
1438 p == 0 ? 0 : static_cast< ::css::awt::XWindow * >(p->GetWindowPeer()),
1439 ::css::uno::UNO_QUERY);
1440 }
1441
1442 // virtual
1443 ::css::uno::Reference< ::css::awt::XTopWindow > SAL_CALL
getActiveTopWindow()1444 VCLXToolkit::getActiveTopWindow() throw (::css::uno::RuntimeException)
1445 {
1446 ::Window * p = ::Application::GetActiveTopWindow();
1447 return ::css::uno::Reference< ::css::awt::XTopWindow >(
1448 p == 0 ? 0 : static_cast< ::css::awt::XWindow * >(p->GetWindowPeer()),
1449 ::css::uno::UNO_QUERY);
1450 }
1451
1452 // virtual
addTopWindowListener(::css::uno::Reference<::css::awt::XTopWindowListener> const & rListener)1453 void SAL_CALL VCLXToolkit::addTopWindowListener(
1454 ::css::uno::Reference< ::css::awt::XTopWindowListener > const & rListener)
1455 throw (::css::uno::RuntimeException)
1456 {
1457 OSL_ENSURE(rListener.is(), "Null rListener");
1458 ::osl::ClearableMutexGuard aGuard(rBHelper.rMutex);
1459 if (rBHelper.bDisposed || rBHelper.bInDispose)
1460 {
1461 aGuard.clear();
1462 rListener->disposing(
1463 ::css::lang::EventObject(
1464 static_cast< ::cppu::OWeakObject * >(this)));
1465 }
1466 else if (m_aTopWindowListeners.addInterface(rListener) == 1
1467 && !m_bEventListener)
1468 {
1469 m_bEventListener = true;
1470 ::Application::AddEventListener(m_aEventListenerLink);
1471 }
1472 }
1473
1474 // virtual
removeTopWindowListener(::css::uno::Reference<::css::awt::XTopWindowListener> const & rListener)1475 void SAL_CALL VCLXToolkit::removeTopWindowListener(
1476 ::css::uno::Reference< ::css::awt::XTopWindowListener > const & rListener)
1477 throw (::css::uno::RuntimeException)
1478 {
1479 ::osl::MutexGuard aGuard(rBHelper.rMutex);
1480 if (!(rBHelper.bDisposed || rBHelper.bInDispose)
1481 && m_aTopWindowListeners.removeInterface(rListener) == 0
1482 && m_aFocusListeners.getLength() == 0 && m_bEventListener)
1483 {
1484 ::Application::RemoveEventListener(m_aEventListenerLink);
1485 m_bEventListener = false;
1486 }
1487 }
1488
1489 // virtual
addKeyHandler(::css::uno::Reference<::css::awt::XKeyHandler> const & rHandler)1490 void SAL_CALL VCLXToolkit::addKeyHandler(
1491 ::css::uno::Reference< ::css::awt::XKeyHandler > const & rHandler)
1492 throw (::css::uno::RuntimeException)
1493 {
1494 OSL_ENSURE(rHandler.is(), "Null rHandler");
1495 ::osl::ClearableMutexGuard aGuard(rBHelper.rMutex);
1496 if (rBHelper.bDisposed || rBHelper.bInDispose)
1497 {
1498 aGuard.clear();
1499 rHandler->disposing(
1500 ::css::lang::EventObject(
1501 static_cast< ::cppu::OWeakObject * >(this)));
1502 }
1503 else if (m_aKeyHandlers.addInterface(rHandler) == 1 && !m_bKeyListener)
1504 {
1505 m_bKeyListener = true;
1506 ::Application::AddKeyListener(m_aKeyListenerLink);
1507 }
1508 }
1509
1510 // virtual
removeKeyHandler(::css::uno::Reference<::css::awt::XKeyHandler> const & rHandler)1511 void SAL_CALL VCLXToolkit::removeKeyHandler(
1512 ::css::uno::Reference< ::css::awt::XKeyHandler > const & rHandler)
1513 throw (::css::uno::RuntimeException)
1514 {
1515 ::osl::MutexGuard aGuard(rBHelper.rMutex);
1516 if (!(rBHelper.bDisposed || rBHelper.bInDispose)
1517 && m_aKeyHandlers.removeInterface(rHandler) == 0 && m_bKeyListener)
1518 {
1519 ::Application::RemoveKeyListener(m_aKeyListenerLink);
1520 m_bKeyListener = false;
1521 }
1522 }
1523
1524 // virtual
addFocusListener(::css::uno::Reference<::css::awt::XFocusListener> const & rListener)1525 void SAL_CALL VCLXToolkit::addFocusListener(
1526 ::css::uno::Reference< ::css::awt::XFocusListener > const & rListener)
1527 throw (::css::uno::RuntimeException)
1528 {
1529 OSL_ENSURE(rListener.is(), "Null rListener");
1530 ::osl::ClearableMutexGuard aGuard(rBHelper.rMutex);
1531 if (rBHelper.bDisposed || rBHelper.bInDispose)
1532 {
1533 aGuard.clear();
1534 rListener->disposing(
1535 ::css::lang::EventObject(
1536 static_cast< ::cppu::OWeakObject * >(this)));
1537 }
1538 else if (m_aFocusListeners.addInterface(rListener) == 1
1539 && !m_bEventListener)
1540 {
1541 m_bEventListener = true;
1542 ::Application::AddEventListener(m_aEventListenerLink);
1543 }
1544 }
1545
1546 // virtual
removeFocusListener(::css::uno::Reference<::css::awt::XFocusListener> const & rListener)1547 void SAL_CALL VCLXToolkit::removeFocusListener(
1548 ::css::uno::Reference< ::css::awt::XFocusListener > const & rListener)
1549 throw (::css::uno::RuntimeException)
1550 {
1551 ::osl::MutexGuard aGuard(rBHelper.rMutex);
1552 if (!(rBHelper.bDisposed || rBHelper.bInDispose)
1553 && m_aFocusListeners.removeInterface(rListener) == 0
1554 && m_aTopWindowListeners.getLength() == 0 && m_bEventListener)
1555 {
1556 ::Application::RemoveEventListener(m_aEventListenerLink);
1557 m_bEventListener = false;
1558 }
1559 }
1560
1561 // virtual
fireFocusGained(::com::sun::star::uno::Reference<::com::sun::star::uno::XInterface> const &)1562 void SAL_CALL VCLXToolkit::fireFocusGained(
1563 ::com::sun::star::uno::Reference<
1564 ::com::sun::star::uno::XInterface > const &)
1565 throw (::com::sun::star::uno::RuntimeException)
1566 {
1567 }
1568
1569 // virtual
fireFocusLost(::com::sun::star::uno::Reference<::com::sun::star::uno::XInterface> const &)1570 void SAL_CALL VCLXToolkit::fireFocusLost(
1571 ::com::sun::star::uno::Reference<
1572 ::com::sun::star::uno::XInterface > const &)
1573 throw (::com::sun::star::uno::RuntimeException)
1574 {
1575 }
1576
1577
IMPL_LINK(VCLXToolkit,eventListenerHandler,::VclSimpleEvent const *,pEvent)1578 IMPL_LINK(VCLXToolkit, eventListenerHandler, ::VclSimpleEvent const *, pEvent)
1579 {
1580 switch (pEvent->GetId())
1581 {
1582 case VCLEVENT_WINDOW_SHOW:
1583 callTopWindowListeners(
1584 pEvent, &::css::awt::XTopWindowListener::windowOpened);
1585 break;
1586 case VCLEVENT_WINDOW_HIDE:
1587 callTopWindowListeners(
1588 pEvent, &::css::awt::XTopWindowListener::windowClosed);
1589 break;
1590 case VCLEVENT_WINDOW_ACTIVATE:
1591 callTopWindowListeners(
1592 pEvent, &::css::awt::XTopWindowListener::windowActivated);
1593 break;
1594 case VCLEVENT_WINDOW_DEACTIVATE:
1595 callTopWindowListeners(
1596 pEvent, &::css::awt::XTopWindowListener::windowDeactivated);
1597 break;
1598 case VCLEVENT_WINDOW_CLOSE:
1599 callTopWindowListeners(
1600 pEvent, &::css::awt::XTopWindowListener::windowClosing);
1601 break;
1602 case VCLEVENT_WINDOW_GETFOCUS:
1603 callFocusListeners(pEvent, true);
1604 break;
1605 case VCLEVENT_WINDOW_LOSEFOCUS:
1606 callFocusListeners(pEvent, false);
1607 break;
1608 case VCLEVENT_WINDOW_MINIMIZE:
1609 callTopWindowListeners(
1610 pEvent, &::css::awt::XTopWindowListener::windowMinimized);
1611 break;
1612 case VCLEVENT_WINDOW_NORMALIZE:
1613 callTopWindowListeners(
1614 pEvent, &::css::awt::XTopWindowListener::windowNormalized);
1615 break;
1616 }
1617 return 0;
1618 }
1619
IMPL_LINK(VCLXToolkit,keyListenerHandler,::VclSimpleEvent const *,pEvent)1620 IMPL_LINK(VCLXToolkit, keyListenerHandler, ::VclSimpleEvent const *, pEvent)
1621 {
1622 switch (pEvent->GetId())
1623 {
1624 case VCLEVENT_WINDOW_KEYINPUT:
1625 return callKeyHandlers(pEvent, true);
1626 case VCLEVENT_WINDOW_KEYUP:
1627 return callKeyHandlers(pEvent, false);
1628 }
1629 return 0;
1630 }
1631
callTopWindowListeners(::VclSimpleEvent const * pEvent,void (SAL_CALL::css::awt::XTopWindowListener::* pFn)(::css::lang::EventObject const &))1632 void VCLXToolkit::callTopWindowListeners(
1633 ::VclSimpleEvent const * pEvent,
1634 void (SAL_CALL ::css::awt::XTopWindowListener::* pFn)(
1635 ::css::lang::EventObject const &))
1636 {
1637 ::Window * pWindow
1638 = static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow();
1639 if (pWindow->IsTopWindow())
1640 {
1641 ::css::uno::Sequence< ::css::uno::Reference< ::css::uno::XInterface > >
1642 aListeners(m_aTopWindowListeners.getElements());
1643 if (aListeners.hasElements())
1644 {
1645 ::css::lang::EventObject aAwtEvent(
1646 static_cast< ::css::awt::XWindow * >(pWindow->GetWindowPeer()));
1647 for (::sal_Int32 i = 0; i < aListeners.getLength(); ++i)
1648 {
1649 ::css::uno::Reference< ::css::awt::XTopWindowListener >
1650 xListener(aListeners[i], ::css::uno::UNO_QUERY);
1651 try
1652 {
1653 (xListener.get()->*pFn)(aAwtEvent);
1654 }
1655 catch (::css::uno::RuntimeException & rEx)
1656 {
1657 OSL_TRACE(
1658 "VCLXToolkit::callTopWindowListeners: caught %s\n",
1659 ::rtl::OUStringToOString(
1660 rEx.Message, RTL_TEXTENCODING_UTF8).getStr());
1661 }
1662 }
1663 }
1664 }
1665 }
1666
callKeyHandlers(::VclSimpleEvent const * pEvent,bool bPressed)1667 long VCLXToolkit::callKeyHandlers(::VclSimpleEvent const * pEvent,
1668 bool bPressed)
1669 {
1670 ::css::uno::Sequence< ::css::uno::Reference< ::css::uno::XInterface > >
1671 aHandlers(m_aKeyHandlers.getElements());
1672
1673 if (aHandlers.hasElements())
1674 {
1675 ::Window * pWindow = static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow();
1676
1677 // See implementation in vclxwindow.cxx for mapping between VCL and UNO AWT event
1678 ::KeyEvent * pKeyEvent = static_cast< ::KeyEvent * >(
1679 static_cast< ::VclWindowEvent const * >(pEvent)->GetData());
1680 ::css::awt::KeyEvent aAwtEvent(
1681 static_cast< ::css::awt::XWindow * >(pWindow->GetWindowPeer()),
1682 (pKeyEvent->GetKeyCode().IsShift()
1683 ? ::css::awt::KeyModifier::SHIFT : 0)
1684 | (pKeyEvent->GetKeyCode().IsMod1()
1685 ? ::css::awt::KeyModifier::MOD1 : 0)
1686 | (pKeyEvent->GetKeyCode().IsMod2()
1687 ? ::css::awt::KeyModifier::MOD2 : 0)
1688 | (pKeyEvent->GetKeyCode().IsMod3()
1689 ? ::css::awt::KeyModifier::MOD3 : 0),
1690 pKeyEvent->GetKeyCode().GetCode(), pKeyEvent->GetCharCode(),
1691 sal::static_int_cast< sal_Int16 >(
1692 pKeyEvent->GetKeyCode().GetFunction()));
1693 for (::sal_Int32 i = 0; i < aHandlers.getLength(); ++i)
1694 {
1695 ::css::uno::Reference< ::css::awt::XKeyHandler > xHandler(
1696 aHandlers[i], ::css::uno::UNO_QUERY);
1697 try
1698 {
1699 if ((bPressed ? xHandler->keyPressed(aAwtEvent)
1700 : xHandler->keyReleased(aAwtEvent)))
1701 return 1;
1702 }
1703 catch (::css::uno::RuntimeException & rEx)
1704 {
1705 OSL_TRACE(
1706 "VCLXToolkit::callKeyHandlers: caught %s\n",
1707 ::rtl::OUStringToOString(
1708 rEx.Message, RTL_TEXTENCODING_UTF8).getStr());
1709 }
1710 }
1711 }
1712 return 0;
1713 }
1714
callFocusListeners(::VclSimpleEvent const * pEvent,bool bGained)1715 void VCLXToolkit::callFocusListeners(::VclSimpleEvent const * pEvent,
1716 bool bGained)
1717 {
1718 ::Window * pWindow
1719 = static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow();
1720 if (pWindow->IsTopWindow())
1721 {
1722 ::css::uno::Sequence< ::css::uno::Reference< ::css::uno::XInterface > >
1723 aListeners(m_aFocusListeners.getElements());
1724 if (aListeners.hasElements())
1725 {
1726 // Ignore the interior of compound controls when determining the
1727 // window that gets the focus next (see implementation in
1728 // vclxwindow.cxx for mapping between VCL and UNO AWT event):
1729 ::css::uno::Reference< css::uno::XInterface > xNext;
1730 ::Window * pFocus = ::Application::GetFocusWindow();
1731 for (::Window * p = pFocus; p != 0; p = p->GetParent())
1732 if (!p->IsCompoundControl())
1733 {
1734 pFocus = p;
1735 break;
1736 }
1737 if (pFocus != 0)
1738 xNext = pFocus->GetComponentInterface(true);
1739 ::css::awt::FocusEvent aAwtEvent(
1740 static_cast< ::css::awt::XWindow * >(pWindow->GetWindowPeer()),
1741 pWindow->GetGetFocusFlags(), xNext, false);
1742 for (::sal_Int32 i = 0; i < aListeners.getLength(); ++i)
1743 {
1744 ::css::uno::Reference< ::css::awt::XFocusListener > xListener(
1745 aListeners[i], ::css::uno::UNO_QUERY);
1746 try
1747 {
1748 bGained ? xListener->focusGained(aAwtEvent)
1749 : xListener->focusLost(aAwtEvent);
1750 }
1751 catch (::css::uno::RuntimeException & rEx)
1752 {
1753 OSL_TRACE(
1754 "VCLXToolkit::callFocusListeners: caught %s\n",
1755 ::rtl::OUStringToOString(
1756 rEx.Message, RTL_TEXTENCODING_UTF8).getStr());
1757 }
1758 }
1759 }
1760 }
1761 }
1762
1763 // css::awt::XReschedule:
1764
reschedule()1765 void SAL_CALL VCLXToolkit::reschedule()
1766 throw (::com::sun::star::uno::RuntimeException)
1767 {
1768 Application::Reschedule(true);
1769 }
1770
1771