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 // MARKER(update_precomp.py): autogen include statement, do not remove
23 #include "precompiled_automation.hxx"
24 #include <com/sun/star/frame/XFramesSupplier.hpp>
25 #include <com/sun/star/frame/XDispatch.hpp>
26 #include <com/sun/star/frame/XDispatchProvider.hpp>
27 #include <com/sun/star/util/XURLTransformer.hpp>
28 #include <comphelper/processfactory.hxx>
29 #include <comphelper/uieventslogger.hxx>
30
31 #include <tools/wintypes.hxx>
32 #include <vcl/dialog.hxx>
33 #include <vcl/button.hxx>
34 #include <vcl/menubtn.hxx>
35 #include <svtools/svtreebx.hxx>
36 #include <svtools/brwbox.hxx>
37 #include <vcl/msgbox.hxx>
38 #include <vcl/dockwin.hxx>
39 #include <vcl/floatwin.hxx>
40 #include <vcl/lstbox.hxx>
41 #include <vcl/combobox.hxx>
42 #include <vcl/morebtn.hxx>
43 #include <vcl/field.hxx>
44 #include <vcl/toolbox.hxx>
45 #include <vcl/tabctrl.hxx>
46 #include <vcl/tabpage.hxx>
47 #include <vcl/menu.hxx>
48 #include <vcl/status.hxx>
49 #include <svtools/prgsbar.hxx>
50 #include <svtools/editbrowsebox.hxx>
51 #include <vcl/splitwin.hxx>
52 #include <vcl/group.hxx>
53 #include <vcl/fixed.hxx>
54 #include <vcl/wrkwin.hxx>
55 #include <osl/diagnose.h>
56 #include <svtools/valueset.hxx>
57 #include <svtools/roadmap.hxx>
58 #include <svtools/table/tablecontrol.hxx>
59 #include <svtools/table/tablecontrolinterface.hxx>
60 #include <svl/poolitem.hxx>
61 #include <svtools/extensionlistbox.hxx>
62 #include <svtools/svtdata.hxx>
63 #include <tools/time.hxx>
64 #include <svtools/stringtransfer.hxx>
65 #include <tools/stream.hxx>
66 #include <tools/fsys.hxx>
67 #include <svl/stritem.hxx>
68 #include <svtools/ttprops.hxx>
69 #include <basic/ttstrhlp.hxx>
70 #include <basic/dispdefs.hxx>
71 #include <basic/sbuno.hxx>
72 #include <vos/socket.hxx>
73 #include <svl/pickerhistory.hxx>
74 #include <com/sun/star/util/XCancellable.hpp>
75 #include <sot/storage.hxx>
76 #include <sot/storinfo.hxx>
77 #include "statemnt.hxx"
78 #include "scmdstrm.hxx"
79 #include "retstrm.hxx"
80 #if OSL_DEBUG_LEVEL > 1
81 #include "editwin.hxx"
82 #endif
83 #include "rcontrol.hxx"
84 #include <automation/communi.hxx>
85 #include "testtool.hxx"
86 #include "profiler.hxx"
87 #include "recorder.hxx"
88 #include "testtool.hrc"
89 #include <basic/svtmsg.hrc>
90 #include <algorithm>
91 #include <vcl/dibtools.hxx>
92
93 using namespace com::sun::star::frame;
94 using namespace com::sun::star::uno;
95 //using namespace com::sun::star::util; geht wegen Color nicht
96 using namespace com::sun::star::beans;
97 using namespace svt;
98 //using namespace svt::table;
99
100
101 #ifndef SBX_VALUE_DECL_DEFINED
102 #define SBX_VALUE_DECL_DEFINED
103 SV_DECL_REF(SbxValue)
104 #endif
105 SV_IMPL_REF(SbxValue)
106
107 CommunicationLink *StatementFlow::pCommLink = NULL;
108 sal_Bool StatementFlow::bUseIPC = sal_True;
109 sal_Bool StatementFlow::bSending = sal_False;
110 ImplRemoteControl *StatementFlow::pRemoteControl = NULL;
111
112 sal_uInt16 StatementCommand::nDirPos = 0;
113 Dir *StatementCommand::pDir = NULL;
114 pfunc_osl_printDebugMessage StatementCommand::pOriginal_osl_DebugMessageFunc = NULL;
115
116
117 #define RESET_APPLICATION_TO_BACKING_WINDOW
118
119
120 #define SET_WINP_CLOSING(pWin) \
121 pWindowWaitPointer = pWin; \
122 aWindowWaitUId = pControl->GetUniqueOrHelpId(); \
123 aWindowWaitOldHelpId = pWin->GetHelpId(); \
124 aWindowWaitOldUniqueId = pWin->GetUniqueId(); \
125 pWin->SetHelpId( rtl::OString("TT_Win_is_closing_HID") ); \
126 pWin->SetUniqueId( rtl::OString("TT_Win_is_closing_UID") );
127
128 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
129
StatementFlow(StatementList * pAfterThis,sal_uInt16 nArtP)130 StatementFlow::StatementFlow( StatementList *pAfterThis, sal_uInt16 nArtP )
131 : nArt(nArtP)
132 , nParams(0)
133 , nSNr1(0)
134 , nLNr1(0)
135 , aString1()
136 , bBool1(sal_False)
137 {
138 QueStatement( pAfterThis );
139 }
140
StatementFlow(sal_uLong nServiceId,SCmdStream * pCmdIn,ImplRemoteControl * pRC)141 StatementFlow::StatementFlow( sal_uLong nServiceId, SCmdStream *pCmdIn, ImplRemoteControl *pRC )
142 : nArt(0)
143 , nParams(0)
144 , nSNr1(0)
145 , nLNr1(0)
146 , aString1()
147 , bBool1(sal_False)
148 {
149 QueStatement( NULL );
150 bUseIPC = (nServiceId == SI_IPCCommandBlock);
151 pRemoteControl = pRC;
152 pCmdIn->Read( nArt );
153 pCmdIn->Read( nParams );
154
155 if( nParams & PARAM_USHORT_1 ) pCmdIn->Read( nSNr1 );
156 if( nParams & PARAM_ULONG_1 ) pCmdIn->Read( nLNr1 );
157 if( nParams & PARAM_STR_1 ) pCmdIn->Read( aString1 );
158 if( nParams & PARAM_BOOL_1 ) pCmdIn->Read( bBool1 ); // sollte nie auftreten!!
159
160 #if OSL_DEBUG_LEVEL > 1
161 m_pDbgWin->AddText( "Reading FlowControl: " );
162 m_pDbgWin->AddText( String::CreateFromInt32( nArt ) );
163 m_pDbgWin->AddText( " Params:" );
164 if( nParams & PARAM_USHORT_1 ) {m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nSNr1 ) );}
165 if( nParams & PARAM_ULONG_1 ) {m_pDbgWin->AddText( " l1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
166 if( nParams & PARAM_STR_1 ) {m_pDbgWin->AddText( " s1:" );m_pDbgWin->AddText( aString1 );}
167 if( nParams & PARAM_BOOL_1 ) {m_pDbgWin->AddText( " b2:" );m_pDbgWin->AddText( bBool1 ? "TRUE" : "FALSE" );}
168 m_pDbgWin->AddText( "\n" );
169 #endif
170 }
171
SendViaSocket()172 void StatementFlow::SendViaSocket()
173 {
174 if ( bSending )
175 {
176 #if OSL_DEBUG_LEVEL > 1
177 m_pDbgWin->AddText( "SendViaSocket called recursively. Aborted!!!\n" );
178 #endif
179 DBG_ERROR("SendViaSocket called recursively. Aborted!!!");
180 return;
181 }
182 bSending = sal_True;
183 if ( pCommLink )
184 {
185 if ( !pCommLink->TransferDataStream( pRet->GetStream() ) ) // tritt ein Fehler auf, so wird sofort gel�scht ...
186 pCommLink = NULL;
187 }
188 else
189 {
190 // Macht nix. Wenn das Basic nicht mehr da ist, ist sowiso alles egal
191 DBG_ERROR("Cannot send results to TestTool");
192 }
193
194 pRet->Reset();
195 bSending = sal_False;
196 IsError = sal_False;
197 }
198
Execute()199 sal_Bool StatementFlow::Execute()
200 {
201 #if OSL_DEBUG_LEVEL > 1
202 m_pDbgWin->AddText( "Executing Flow: " );
203 m_pDbgWin->AddText( String::CreateFromInt32( nArt ) );
204 m_pDbgWin->AddText( "\n" );
205 #endif
206 switch ( nArt )
207 {
208 case F_EndCommandBlock:
209 {
210
211 if ( !bUseIPC )
212 {
213 // bBool1 wurde im CTOR auf sal_False initialisiert
214 if ( !bBool1 ) // also erster Durchlauf
215 {
216 pRemoteControl->pRetStream = pRet->GetStream();
217 bBool1 = sal_True; // wurde im CTOR auf sal_False initialisiert
218 nRetryCount = nRetryCount * 4;
219 }
220 if ( pRemoteControl->pRetStream && (nRetryCount--) ) // also solange nicht abgeholt
221 {
222 return sal_False; // Bitte einmal vom Callstack runter
223 }
224 }
225
226 }
227 break;
228 }
229
230 Advance();
231 switch ( nArt )
232 {
233 case F_EndCommandBlock:
234 if ( !bUseIPC )
235 { // wird oben abgehandelt
236 pRet->Reset();
237 IsError = sal_False;
238 }
239 else
240 SendViaSocket();
241
242 break;
243
244 case F_Sequence:
245
246 pRet->GenReturn(RET_Sequence,nLNr1);
247 #if OSL_DEBUG_LEVEL > 1
248 m_pDbgWin->AddText( "Sending Sequence Nr: " );
249 m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );
250 m_pDbgWin->AddText( "\n" );
251 #endif
252
253 break;
254 // case RET_:
255 default:
256 DBG_ERROR( "Unknown Flowcontrol" );
257 break;
258 }
259
260 delete this;
261 return sal_True;
262 }
263
264 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
265
266 // neue Hilfsfunktion, die stetig erweitert werden muss
ImpGetRType(Window * pWin)267 static short ImpGetRType( Window *pWin )
268 {
269 short nRT = C_NoType;
270 WindowType eRT = pWin->GetType();
271 switch( eRT ) {
272 case WINDOW_WINDOW: nRT = C_Window ; break;
273
274 case WINDOW_TABCONTROL: nRT = C_TabControl ; break;
275 case WINDOW_RADIOBUTTON: nRT = C_RadioButton ; break;
276 case WINDOW_CHECKBOX: nRT = C_CheckBox ; break;
277 case WINDOW_TRISTATEBOX: nRT = C_TriStateBox ; break;
278 case WINDOW_EDIT: nRT = C_Edit ; break;
279 case WINDOW_MULTILINEEDIT: nRT = C_MultiLineEdit ; break;
280 case WINDOW_MULTILISTBOX: nRT = C_MultiListBox ; break;
281 case WINDOW_LISTBOX: nRT = C_ListBox ; break;
282 case WINDOW_COMBOBOX: nRT = C_ComboBox ; break;
283 case WINDOW_PUSHBUTTON: nRT = C_PushButton ; break;
284 case WINDOW_SPINFIELD: nRT = C_SpinField ; break;
285 case WINDOW_PATTERNFIELD: nRT = C_PatternField ; break;
286 case WINDOW_NUMERICFIELD: nRT = C_NumericField ; break;
287 case WINDOW_METRICFIELD: nRT = C_MetricField ; break;
288 case WINDOW_CURRENCYFIELD: nRT = C_CurrencyField ; break;
289 case WINDOW_DATEFIELD: nRT = C_DateField ; break;
290 case WINDOW_TIMEFIELD: nRT = C_TimeField ; break;
291 case WINDOW_IMAGERADIOBUTTON: nRT = C_ImageRadioButton ; break;
292 case WINDOW_NUMERICBOX: nRT = C_NumericBox ; break;
293 case WINDOW_METRICBOX: nRT = C_MetricBox ; break;
294 case WINDOW_CURRENCYBOX: nRT = C_CurrencyBox ; break;
295 case WINDOW_DATEBOX: nRT = C_DateBox ; break;
296 case WINDOW_TIMEBOX: nRT = C_TimeBox ; break;
297 case WINDOW_IMAGEBUTTON: nRT = C_ImageButton ; break;
298 case WINDOW_MENUBUTTON: nRT = C_MenuButton ; break;
299 case WINDOW_MOREBUTTON: nRT = C_MoreButton ; break;
300
301
302 case WINDOW_TABPAGE: nRT = C_TabPage; break;
303 case WINDOW_MODALDIALOG: nRT = C_ModalDlg; break;
304 case WINDOW_FLOATINGWINDOW: nRT = C_FloatWin; break;
305 case WINDOW_MODELESSDIALOG: nRT = C_ModelessDlg; break;
306 case WINDOW_WORKWINDOW: nRT = C_WorkWin; break;
307 case WINDOW_DOCKINGWINDOW: nRT = C_DockingWin; break;
308
309 case WINDOW_MESSBOX: nRT = C_MessBox; break;
310 case WINDOW_INFOBOX: nRT = C_InfoBox; break;
311 case WINDOW_WARNINGBOX: nRT = C_WarningBox; break;
312 case WINDOW_ERRORBOX: nRT = C_ErrorBox; break;
313 case WINDOW_QUERYBOX: nRT = C_QueryBox; break;
314 #if 0 //ifndef VCL
315 case WINDOW_FILEDIALOG: nRT = C_FileDlg; break;
316 case WINDOW_PATHDIALOG: nRT = C_PathDlg; break;
317 case WINDOW_PRINTDIALOG: nRT = C_PrintDlg; break;
318 case WINDOW_PRINTERSETUPDIALOG: nRT = C_PrinterSetupDlg;break;
319 case WINDOW_COLORDIALOG: nRT = C_ColorDlg; break;
320 #endif
321 case WINDOW_TABDIALOG: nRT = C_TabDlg; break;
322 // case WINDOW_TABDIALOG: nRT = C_SingleTabDlg; break;
323
324 case WINDOW_PATTERNBOX: nRT = C_PatternBox; break;
325 case WINDOW_TOOLBOX: nRT = C_ToolBox; break;
326 // Gibts nicht case WINDOW_VALUESET: nRT = C_ValueSet; break;
327 case WINDOW_CONTROL: nRT = C_Control; break;
328 case WINDOW_OKBUTTON: nRT = C_OkButton; break;
329 case WINDOW_CANCELBUTTON: nRT = C_CancelButton; break;
330 case WINDOW_BUTTONDIALOG: nRT = C_ButtonDialog; break;
331 case WINDOW_TREELISTBOX: nRT = C_TreeListBox; break;
332
333 case WINDOW_DIALOG: nRT = C_Dialog; break;
334 }
335 return nRT;
336 }
337
338 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
339
StatementSlot(SCmdStream * pCmdIn)340 StatementSlot::StatementSlot( SCmdStream *pCmdIn )
341 : pItemArr(NULL)
342 {
343 QueStatement( NULL );
344 pCmdIn->Read( nFunctionId );
345 #if OSL_DEBUG_LEVEL > 1
346 m_pDbgWin->AddText( "Reading Slot: " );
347 m_pDbgWin->AddText( String::CreateFromInt32( nFunctionId ) );
348 m_pDbgWin->AddText( "\n" );
349 #endif
350 pCmdIn->Read( nAnzahl );
351 if ( nAnzahl )
352 {
353 switch ( pCmdIn->GetNextType() )
354 {
355 case BinUSHORT: // use old calling method
356 {
357 nAnzahl++;
358 pItemArr = new SfxPoolItem*[nAnzahl];
359 for (sal_uInt16 i = 0 ; i+1 < nAnzahl ; i++)
360 pCmdIn->Read( pItemArr[i] );
361 pItemArr[nAnzahl-1] = NULL;
362 }
363 break;
364 case BinString: // new Method
365 {
366 aArgs.realloc(nAnzahl);
367 PropertyValue* pArg = aArgs.getArray();
368 for (sal_uInt16 i = 0 ; i < nAnzahl ; i++)
369 pCmdIn->Read( pArg[i] );
370 }
371 break;
372 }
373 }
374 }
375
376 // Constructor for UnoSlot
StatementSlot()377 StatementSlot::StatementSlot()
378 : nAnzahl( 0 )
379 , pItemArr(NULL)
380 , nFunctionId( 0 )
381 , bMenuClosed(sal_False)
382 {}
383
StatementSlot(sal_uLong nSlot,SfxPoolItem * pItem)384 StatementSlot::StatementSlot( sal_uLong nSlot, SfxPoolItem* pItem )
385 : pItemArr(NULL)
386 , bMenuClosed(sal_False)
387 {
388 QueStatement( NULL );
389 nFunctionId = sal_uInt16(nSlot);
390 #if OSL_DEBUG_LEVEL > 1
391 m_pDbgWin->AddText( "Reading Slot: " );
392 m_pDbgWin->AddText( String::CreateFromInt32( nFunctionId ) );
393 m_pDbgWin->AddText( "\n" );
394 #endif
395 if ( pItem )
396 {
397 nAnzahl = 2;
398 pItemArr = new SfxPoolItem*[2];
399 pItemArr[0] = pItem;
400 pItemArr[1] = NULL;
401 }
402 else
403 nAnzahl = 0;
404 }
405
~StatementSlot()406 StatementSlot::~StatementSlot()
407 {
408 if (nAnzahl)
409 {
410 if ( pItemArr )
411 {
412 for (sal_uInt16 i = 0 ; i+1 < nAnzahl ; i++)
413 delete pItemArr[i];
414 delete[] pItemArr;
415 }
416
417 aArgs.realloc( 0 );
418 }
419 }
420
AddReferer()421 void StatementSlot::AddReferer()
422 {
423 HACK( "only to test!" );
424 // because slot 6102 /*SID_VERB_START*/ crashes when called with Property Referer
425 // We return to the previous behavior (which was a bug realy) of not adding this Property to calls which have no properties at all
426 // according to MBA most likely this Property can be removed at all and is maybe only needed for Slots with URLs
427 if ( !nAnzahl )
428 return;
429
430 PropertyValue* pArg;
431
432 nAnzahl++;
433 aArgs.realloc(nAnzahl);
434 pArg = aArgs.getArray();
435 pArg[nAnzahl-1].Name = rtl::OUString::createFromAscii("Referer");
436 pArg[nAnzahl-1].Value <<= ::rtl::OUString::createFromAscii("private:user");
437
438 nAnzahl++;
439 aArgs.realloc(nAnzahl);
440 pArg = aArgs.getArray();
441 pArg[nAnzahl-1].Name = rtl::OUString::createFromAscii("SynchronMode");
442 pArg[nAnzahl-1].Value <<= sal_Bool( sal_True );
443 }
444
445 class SlotStatusListener : public cppu::WeakImplHelper1< XStatusListener >
446 {
447 public:
448 SlotStatusListener();
449
450 // XStatusListener
451 virtual void SAL_CALL statusChanged( const ::com::sun::star::frame::FeatureStateEvent& Event ) throw (::com::sun::star::uno::RuntimeException);
452 // XEventListener
453 virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source ) throw (::com::sun::star::uno::RuntimeException);
454
455 // local Members
456 sal_Bool bDisposed;
457 sal_Bool bEnabled;
458 };
459 /*
460 struct FeatureStateEvent : public ::com::sun::star::lang::EventObject
461 ::com::sun::star::util::URL FeatureURL;
462 ::rtl::OUString FeatureDescriptor;
463 sal_Bool IsEnabled;
464 sal_Bool Requery;
465 ::com::sun::star::uno::Any State;
466
467 ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > Source;
468 */
469
SlotStatusListener()470 SlotStatusListener::SlotStatusListener()
471 : bDisposed( sal_False )
472 , bEnabled( sal_True )
473 {}
474
475 // XStatusListener
statusChanged(const::com::sun::star::frame::FeatureStateEvent & Event)476 void SAL_CALL SlotStatusListener::statusChanged( const ::com::sun::star::frame::FeatureStateEvent& Event ) throw (::com::sun::star::uno::RuntimeException)
477 {
478 // DBG_ERROR1("FeatureURL: %s", ByteString( String( Event.FeatureURL.Complete ), RTL_TEXTENCODING_UTF8 ).GetBuffer() );
479 // DBG_ERROR1("FeatureDescriptor: %s", ByteString( String( Event.FeatureDescriptor ), RTL_TEXTENCODING_UTF8 ).GetBuffer() );
480 bEnabled = Event.IsEnabled;
481 // DBG_ASSERT( Event.IsEnabled, "Not enabled" );
482 // DBG_ASSERT( !Event.Requery, "Requery" );
483 }
484
485 // XEventListener
disposing(const::com::sun::star::lang::EventObject &)486 void SAL_CALL SlotStatusListener::disposing( const ::com::sun::star::lang::EventObject& ) throw (::com::sun::star::uno::RuntimeException)
487 {
488 bDisposed = sal_True;
489 }
490
Execute()491 sal_Bool StatementSlot::Execute()
492 {
493 if ( IsError )
494 {
495 #if OSL_DEBUG_LEVEL > 1
496 m_pDbgWin->AddText( "Skipping Slot: " );
497 m_pDbgWin->AddText( String::CreateFromInt32( nFunctionId ) );
498 m_pDbgWin->AddText( "\n" );
499 #endif
500
501 Advance();
502 delete this;
503 return sal_True;
504 }
505
506 InitProfile();
507 #if OSL_DEBUG_LEVEL > 1
508 m_pDbgWin->AddText( "Executing Slot: " );
509 m_pDbgWin->AddText( String::CreateFromInt32( nFunctionId ) );
510 m_pDbgWin->AddText( "\n" );
511 #endif
512
513 PopupMenu *pPopup = NULL;
514 MenuBar *pMenuBar = NULL;
515 Menu *pMenu;
516
517 GetCurrentMenues( pPopup, pMenuBar, pMenu );
518 if ( pPopup )
519 {
520 if ( !bMenuClosed )
521 {
522 pPopup->EndExecute(0);
523 aSubMenuId1 = 0;
524 aSubMenuId2 = 0;
525 aSubMenuId3 = 0;
526 pMenuWindow = NULL;
527 bMenuClosed = sal_True;
528 #if OSL_DEBUG_LEVEL > 1
529 m_pDbgWin->AddText( "Closed contextmenu\n" );
530 #endif
531 return sal_False;
532 }
533 else if ( nRetryCount-- )
534 {
535 #if OSL_DEBUG_LEVEL > 1
536 m_pDbgWin->AddText( "Waiting for contextmenu to close\n" );
537 #endif
538 return sal_False;
539 }
540 else
541 ReportError( GEN_RES_STR0( S_MENU_NOT_CLOSING ) );
542 }
543
544 Advance();
545
546 if ( !IsError )
547 {
548 if ( ( nAnzahl == 0 && !getenv("OLDSLOTHANDLING") ) || aArgs.hasElements() )
549 { // trying to call slots via uno
550 AddReferer();
551 if ( !aUnoUrl.Len() )
552 aUnoUrl = CUniString("slot:").Append( String::CreateFromInt32( nFunctionId ) );
553 ::com::sun::star::util::URL aTargetURL;
554 aTargetURL.Complete = aUnoUrl;
555 Reference < XFramesSupplier > xDesktop = Reference < XFramesSupplier >( ::comphelper::getProcessServiceFactory()->createInstance( CUniString("com.sun.star.frame.Desktop") ), UNO_QUERY );
556 Reference < XFrame > xFrame;
557
558 if ( xDesktop.is() )
559 {
560 xFrame = xDesktop->getActiveFrame();
561 if ( !xFrame.is() )
562 {
563 Reference < XFrames > xFrames;
564 xFrames = xDesktop->getFrames();
565 if ( xFrames.is() && xFrames->getCount() > 0 )
566 {
567 Any aFrame = xFrames->getByIndex( xFrames->getCount() -1 );
568 aFrame >>= xFrame;
569 }
570 }
571 if ( !xFrame.is() )
572 {
573 if ( GetFirstDocFrame() )
574 GetFirstDocFrame()->ToTop();
575 xFrame = xDesktop->getActiveFrame();
576 }
577 }
578
579 if ( xFrame.is() )
580 xDesktop = Reference < XFramesSupplier >( xFrame, UNO_QUERY );
581 else
582 xDesktop.clear();
583
584 while ( xDesktop.is() && xDesktop->getActiveFrame().is() )
585 {
586 xFrame = xDesktop->getActiveFrame();
587 #if OSL_DEBUG_LEVEL > 1
588 ::rtl::OUString aName;
589 if ( xFrame.is() )
590 aName = xFrame->getName();
591 #endif
592 xDesktop = Reference < XFramesSupplier >( xFrame, UNO_QUERY );
593 }
594
595 if ( !xFrame.is() )
596 ReportError( GEN_RES_STR1( S_UNO_URL_EXECUTE_FAILED_NO_FRAME, aTargetURL.Complete ) );
597 else
598 {
599 Reference < ::com::sun::star::util::XURLTransformer > xTrans( ::comphelper::getProcessServiceFactory()->createInstance( CUniString("com.sun.star.util.URLTransformer" )), UNO_QUERY );
600 xTrans->parseStrict( aTargetURL );
601
602 Reference < XDispatchProvider > xProv( xFrame, UNO_QUERY );
603 Reference < XDispatch > xDisp;
604 while ( xProv.is() && !xDisp.is() )
605 {
606 xDisp = xProv->queryDispatch( aTargetURL, ::rtl::OUString(), 0 );
607 if ( !xDisp.is() )
608 {
609 xFrame = Reference < XFrame > ( xFrame->getCreator(), UNO_QUERY );
610 xProv = Reference < XDispatchProvider > ( xFrame, UNO_QUERY );
611 }
612 }
613
614 if ( xDisp.is() )
615 {
616 Reference < XStatusListener > xListener = ( XStatusListener* )new SlotStatusListener;
617 xDisp->addStatusListener( xListener, aTargetURL );
618 if ( static_cast< SlotStatusListener* >(xListener.get())->bEnabled )
619 {
620 if ( bIsSlotInExecute )
621 ReportError( GEN_RES_STR0( S_SLOT_IN_EXECUTE ) );
622 else
623 {
624 bIsSlotInExecute = sal_True;
625 xDisp->dispatch( aTargetURL, aArgs );
626 bIsSlotInExecute = sal_False;
627 }
628 }
629 else
630 ReportError( GEN_RES_STR1( S_UNO_URL_EXECUTE_FAILED_DISABLED, aTargetURL.Complete ) );
631 xDisp->removeStatusListener( xListener, aTargetURL );
632 }
633 else
634 ReportError( GEN_RES_STR1( S_UNO_URL_EXECUTE_FAILED_NO_DISPATCHER, aTargetURL.Complete ) );
635 }
636 }
637 else
638 {
639 DirectLog( S_QAError, GEN_RES_STR0( S_DEPRECATED ) );
640 if ( !pTTProperties )
641 pTTProperties = new TTProperties();
642
643 switch ( pTTProperties->ExecuteFunction( nFunctionId, pItemArr, EXECUTEMODE_DIALOGASYNCHRON | nUseBindings ) )
644 {
645 case TT_PR_ERR_NODISPATCHER:
646 {
647 ReportError( rtl::OString::valueOf((sal_Int32)nFunctionId), GEN_RES_STR0( S_SID_EXECUTE_FAILED_NO_DISPATCHER ) );
648 }
649 break;
650 case TT_PR_ERR_NOEXECUTE:
651 {
652 ReportError( rtl::OString::valueOf((sal_Int32)nFunctionId), GEN_RES_STR0( S_SID_EXECUTE_FAILED ) );
653 }
654 break;
655 }
656 }
657 }
658
659
660 /* Neues Verfahren ab 334!
661 Neue Methode zum einstellen, da� Modale Dialoge immer Asynchron aufgerufen werden
662 und echter Returnwert, ob Slot geklappt hat
663 und Testen ob Slot �berhaupt durch UI aufgerufen werden kann */
664
665
666 SendProfile( SlotString( nFunctionId ) );
667 delete this;
668 return sal_True;
669 }
670
671 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
672
StatementUnoSlot(SCmdStream * pIn)673 StatementUnoSlot::StatementUnoSlot(SCmdStream *pIn)
674 {
675 QueStatement( NULL );
676
677 pIn->Read( aUnoUrl );
678
679 #if OSL_DEBUG_LEVEL > 1
680 StatementList::m_pDbgWin->AddText( "UnoUrl:" );
681 StatementList::m_pDbgWin->AddText( aUnoUrl );
682 StatementList::m_pDbgWin->AddText( "\n" );
683 #endif
684
685 }
686
687 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
688
StatementCommand(StatementList * pAfterThis,sal_uInt16 MethodId,sal_uInt16 Params,sal_uInt16 Nr1)689 StatementCommand::StatementCommand( StatementList *pAfterThis, sal_uInt16 MethodId, sal_uInt16 Params, sal_uInt16 Nr1 )
690 : nMethodId( MethodId )
691 , nParams(Params)
692 , nNr1(Nr1)
693 , nNr2(0)
694 , nNr3(0)
695 , nNr4(0)
696 , nLNr1(0)
697 , aString1()
698 , aString2()
699 , bBool1(sal_False)
700 , bBool2(sal_False)
701 {
702 QueStatement( pAfterThis );
703
704 #if OSL_DEBUG_LEVEL > 1
705 m_pDbgWin->AddText( "Directly adding Conmmand:" );
706 m_pDbgWin->AddText( " Methode: " );
707 m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
708 m_pDbgWin->AddText( " Params:" );
709 if( nParams & PARAM_USHORT_1 ) {m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr1 ) );}
710 if( nParams & PARAM_USHORT_2 ) {m_pDbgWin->AddText( " n2:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr2 ) );}
711 if( nParams & PARAM_USHORT_3 ) {m_pDbgWin->AddText( " n3:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr3 ) );}
712 if( nParams & PARAM_USHORT_4 ) {m_pDbgWin->AddText( " n4:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr4 ) );}
713 if( nParams & PARAM_ULONG_1 ) {m_pDbgWin->AddText( " nl1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
714 if( nParams & PARAM_STR_1 ) {m_pDbgWin->AddText( " s1:" );m_pDbgWin->AddText( aString1 );}
715 if( nParams & PARAM_STR_2 ) {m_pDbgWin->AddText( " s2:" );m_pDbgWin->AddText( aString2 );}
716 if( nParams & PARAM_BOOL_1 ) {m_pDbgWin->AddText( " b1:" );m_pDbgWin->AddText( bBool1 ? "TRUE" : "FALSE" );}
717 if( nParams & PARAM_BOOL_2 ) {m_pDbgWin->AddText( " b2:" );m_pDbgWin->AddText( bBool2 ? "TRUE" : "FALSE" );}
718 m_pDbgWin->AddText( "\n" );
719 #endif
720 }
721
722
StatementCommand(SCmdStream * pCmdIn)723 StatementCommand::StatementCommand( SCmdStream *pCmdIn )
724 : nMethodId(0)
725 , nParams(0)
726 , nNr1(0)
727 , nNr2(0)
728 , nNr3(0)
729 , nNr4(0)
730 , nLNr1(0)
731 , aString1()
732 , aString2()
733 , bBool1(sal_False)
734 , bBool2(sal_False)
735 {
736 QueStatement( NULL );
737 pCmdIn->Read( nMethodId );
738 pCmdIn->Read( nParams );
739
740 if( nParams & PARAM_USHORT_1 ) pCmdIn->Read( nNr1 );
741 if( nParams & PARAM_USHORT_2 ) pCmdIn->Read( nNr2 );
742 if( nParams & PARAM_USHORT_3 ) pCmdIn->Read( nNr3 );
743 if( nParams & PARAM_USHORT_4 ) pCmdIn->Read( nNr4 );
744 if( nParams & PARAM_ULONG_1 ) pCmdIn->Read( nLNr1 );
745 if( nParams & PARAM_STR_1 ) pCmdIn->Read( aString1 );
746 if( nParams & PARAM_STR_2 ) pCmdIn->Read( aString2 );
747 if( nParams & PARAM_BOOL_1 ) pCmdIn->Read( bBool1 );
748 if( nParams & PARAM_BOOL_2 ) pCmdIn->Read( bBool2 );
749
750 #if OSL_DEBUG_LEVEL > 1
751 m_pDbgWin->AddText( "Reading Conmmand:" );
752 m_pDbgWin->AddText( " Methode: " );
753 m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
754 m_pDbgWin->AddText( " Params:" );
755 if( nParams & PARAM_USHORT_1 ) {m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr1 ) );}
756 if( nParams & PARAM_USHORT_2 ) {m_pDbgWin->AddText( " n2:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr2 ) );}
757 if( nParams & PARAM_USHORT_3 ) {m_pDbgWin->AddText( " n3:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr3 ) );}
758 if( nParams & PARAM_USHORT_4 ) {m_pDbgWin->AddText( " n4:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr4 ) );}
759 if( nParams & PARAM_ULONG_1 ) {m_pDbgWin->AddText( " nl1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
760 if( nParams & PARAM_STR_1 ) {m_pDbgWin->AddText( " s1:" );m_pDbgWin->AddText( aString1 );}
761 if( nParams & PARAM_STR_2 ) {m_pDbgWin->AddText( " s2:" );m_pDbgWin->AddText( aString2 );}
762 if( nParams & PARAM_BOOL_1 ) {m_pDbgWin->AddText( " b1:" );m_pDbgWin->AddText( bBool1 ? "TRUE" : "FALSE" );}
763 if( nParams & PARAM_BOOL_2 ) {m_pDbgWin->AddText( " b2:" );m_pDbgWin->AddText( bBool2 ? "TRUE" : "FALSE" );}
764 m_pDbgWin->AddText( "\n" );
765 #endif
766
767 if ( nMethodId == RC_AppAbort )
768 {
769 #if OSL_DEBUG_LEVEL > 1
770 m_pDbgWin->AddText( "*Deleting all Commands:\n" );
771 #endif
772 bReadingCommands = sal_False;
773 while ( StatementList::pFirst != this ) // Alles L�schen au�er mich selbst
774 {
775 StatementList *pDeQue = StatementList::pFirst;
776 pDeQue->Advance();
777 delete pDeQue;
778 }
779 bReadingCommands = sal_True;
780 #if OSL_DEBUG_LEVEL > 1
781 m_pDbgWin->AddText( "*Done deleting all Commands:\n" );
782 #endif
783 }
784
785 }
786
WriteControlData(Window * pBase,sal_uLong nConf,sal_Bool bFirst)787 void StatementCommand::WriteControlData( Window *pBase, sal_uLong nConf, sal_Bool bFirst )
788 {
789
790 if ( IsDialog(pBase) && !bFirst )
791 return;
792
793 if ( bFirst )
794 pRet->GenReturn ( RET_WinInfo, rtl::OString(), (comm_ULONG)nConf | DH_MODE_DATA_VALID, UniString(), sal_True );
795
796 if ( bFirst )
797 {
798 if ( pBase->GetType() == WINDOW_WINDOW && pBase->GetParent() && pBase->GetParent()->GetType() == WINDOW_CONTROL &&
799 dynamic_cast< svt::table::TableControl* > ( pBase->GetParent() ) )
800 pBase = pBase->GetParent();
801 }
802
803 { // Klammerung, so da� der String nicht w�hrend der Rekursion bestehen bleibt
804 String aName;
805 sal_Bool bSkip = sal_False;
806
807 switch ( pBase->GetType() )
808 {
809 case WINDOW_RADIOBUTTON:
810 case WINDOW_CHECKBOX:
811 case WINDOW_TRISTATEBOX:
812 case WINDOW_PUSHBUTTON:
813 case WINDOW_OKBUTTON:
814 case WINDOW_CANCELBUTTON:
815 case WINDOW_IMAGERADIOBUTTON:
816 case WINDOW_IMAGEBUTTON:
817 case WINDOW_MENUBUTTON:
818 case WINDOW_MOREBUTTON:
819 case WINDOW_TABPAGE:
820 case WINDOW_MODALDIALOG:
821 case WINDOW_FLOATINGWINDOW:
822 case WINDOW_MODELESSDIALOG:
823 case WINDOW_WORKWINDOW:
824 case WINDOW_DOCKINGWINDOW:
825 case WINDOW_CONTROL:
826
827 case WINDOW_FILEDIALOG:
828 case WINDOW_PATHDIALOG:
829 case WINDOW_PRINTDIALOG:
830 case WINDOW_PRINTERSETUPDIALOG:
831 case WINDOW_COLORDIALOG:
832 case WINDOW_TABDIALOG:
833
834 case WINDOW_BUTTONDIALOG:
835
836 case WINDOW_MENUBARWINDOW:
837 aName = pBase->GetText().EraseAllChars('~');
838 break;
839
840 case WINDOW_EDIT:
841 case WINDOW_MULTILINEEDIT:
842 case WINDOW_MULTILISTBOX:
843 case WINDOW_LISTBOX:
844 case WINDOW_COMBOBOX:
845 case WINDOW_SPINFIELD:
846 case WINDOW_PATTERNFIELD:
847 case WINDOW_NUMERICFIELD:
848 case WINDOW_METRICFIELD:
849 case WINDOW_CURRENCYFIELD:
850 case WINDOW_DATEFIELD:
851 case WINDOW_TIMEFIELD:
852 case WINDOW_NUMERICBOX:
853 case WINDOW_METRICBOX:
854 case WINDOW_CURRENCYBOX:
855 case WINDOW_DATEBOX:
856 case WINDOW_TIMEBOX:
857 case WINDOW_PATTERNBOX:
858 case WINDOW_TOOLBOX:
859 aName = pBase->GetQuickHelpText();
860 break;
861
862 case WINDOW_MESSBOX:
863 case WINDOW_INFOBOX:
864 case WINDOW_WARNINGBOX:
865 case WINDOW_ERRORBOX:
866 case WINDOW_QUERYBOX:
867 aName = ((MessBox*)pBase)->GetMessText();
868 break;
869
870 default:
871 if ( pBase->GetUniqueOrHelpId().isEmpty() && !( nConf & DH_MODE_ALLWIN ) )
872 bSkip = sal_True;
873 break;
874 }
875
876 if ( !bSkip )
877 {
878 if ( aName.Len() == 0 )
879 aName = pBase->GetQuickHelpText();
880 if ( aName.Len() == 0 )
881 aName = pBase->GetHelpText();
882 if ( aName.Len() == 0 )
883 aName = pBase->GetText();
884
885
886 String aTypeSuffix;
887 if ( pBase->GetType() == WINDOW_CONTROL )
888 {
889 if ( dynamic_cast< EditBrowseBox* >(pBase) )
890 aTypeSuffix.AppendAscii( "/BrowseBox", 10 );
891 else if ( dynamic_cast< ValueSet* >(pBase) )
892 aTypeSuffix.AppendAscii( "/ValueSet", 9 );
893 else if ( dynamic_cast< ORoadmap* >(pBase) )
894 aTypeSuffix.AppendAscii( "/RoadMap", 8 );
895 else if ( dynamic_cast< IExtensionListBox* >(pBase) )
896 aTypeSuffix.AppendAscii( "/ExtensionListBox" );
897 else if ( dynamic_cast< svt::table::TableControl* >(pBase) )
898 aTypeSuffix.AppendAscii( "/TableControl" );
899 else
900 aTypeSuffix.AppendAscii( "/Unknown", 8 );
901 }
902
903 rtl::OString aId = pBase->GetUniqueOrHelpId();
904 pRet->GenReturn ( RET_WinInfo, aId, (comm_ULONG)pBase->GetType(),
905 TypeString(pBase->GetType()).Append(aTypeSuffix).AppendAscii(": ").Append(aName), sal_False );
906
907
908 if ( pBase->GetType() == WINDOW_TOOLBOX ) // Buttons und Controls auf Toolboxen.
909 {
910 ToolBox *pTB = ((ToolBox*)pBase);
911 sal_uInt16 i;
912 for ( i = 0; i < pTB->GetItemCount() ; i++ )
913 {
914 aName = String();
915 // if ( aName.Len() == 0 )
916 // aName = pTB->GetQuickHelpText();
917 if ( aName.Len() == 0 )
918 aName = pTB->GetHelpText( pTB->GetItemId( i ) );
919 if ( aName.Len() == 0 )
920 aName = pTB->GetItemText( pTB->GetItemId( i ) );
921
922 Window *pItemWin;
923 pItemWin = pTB->GetItemWindow( pTB->GetItemId( i ) );
924 if ( pTB->GetItemType( i ) == TOOLBOXITEM_BUTTON && ( !pItemWin || !pItemWin->IsVisible() ) )
925 {
926 if ( pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
927 pRet->GenReturn ( RET_WinInfo, Str2Id(pTB->GetItemCommand(pTB->GetItemId( i ))), (comm_ULONG)WINDOW_BUTTON,
928 TypeString(WINDOW_BUTTON).AppendAscii(": ").Append(aName), sal_False );
929 if ( !pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
930 pRet->GenReturn ( RET_WinInfo, pTB->GetHelpId(pTB->GetItemId( i )), (comm_ULONG)WINDOW_BUTTON,
931 TypeString(WINDOW_BUTTON).AppendAscii(": ").Append(aName), sal_False );
932 }
933 else
934 {
935 if ( pItemWin )
936 {
937 if ( pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
938 pRet->GenReturn ( RET_WinInfo, Str2Id(pTB->GetItemCommand(pTB->GetItemId( i ))), (comm_ULONG)pItemWin->GetType(),
939 TypeString(pItemWin->GetType()).AppendAscii(": ").Append(aName), sal_False );
940 if ( !pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
941 pRet->GenReturn ( RET_WinInfo, pTB->GetHelpId(pTB->GetItemId( i )), (comm_ULONG)pItemWin->GetType(),
942 TypeString(pItemWin->GetType()).AppendAscii(": ").Append(aName), sal_False );
943 sal_uInt16 ii;
944 for( ii = 0 ; ii < pItemWin->GetChildCount(); ii++ )
945 WriteControlData( pItemWin->GetChild(ii), nConf, sal_False );
946 }
947 else
948 {
949 if ( nConf & DH_MODE_ALLWIN )
950 {
951 String aToolBoxItemType;
952 switch ( pTB->GetItemType( i ) )
953 {
954 case TOOLBOXITEM_DONTKNOW:
955 aToolBoxItemType.AssignAscii("TOOLBOXITEM_DONTKNOW");
956 break;
957 case TOOLBOXITEM_BUTTON:
958 aToolBoxItemType.AssignAscii("TOOLBOXITEM_BUTTON");
959 break;
960 case TOOLBOXITEM_SPACE:
961 aToolBoxItemType.AssignAscii("TOOLBOXITEM_SPACE");
962 break;
963 case TOOLBOXITEM_SEPARATOR:
964 aToolBoxItemType.AssignAscii("TOOLBOXITEM_SEPARATOR");
965 break;
966 case TOOLBOXITEM_BREAK:
967 aToolBoxItemType.AssignAscii("TOOLBOXITEM_BREAK");
968 break;
969 default:
970 DBG_ERROR1( "Unknown TOOLBOXITEM %i", pTB->GetItemType( i ) );
971 }
972 if ( pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
973 pRet->GenReturn ( RET_WinInfo, Str2Id( pTB->GetItemCommand(pTB->GetItemId( i )) ), (comm_ULONG)WINDOW_BASE,
974 aToolBoxItemType.AppendAscii(": ").Append(aName), sal_False );
975 if ( !pTB->GetItemCommand(pTB->GetItemId( i )).Len() || ( nConf & DH_MODE_ALLWIN ) )
976 pRet->GenReturn ( RET_WinInfo, pTB->GetHelpId(pTB->GetItemId( i )), (comm_ULONG)WINDOW_BASE,
977 aToolBoxItemType.AppendAscii(": ").Append(aName), sal_False );
978 }
979 }
980 }
981 }
982
983 return; // ToolBox ist hier schon komplett abgehandelt.
984 }
985
986
987 if ( pBase->GetType() == WINDOW_BUTTONDIALOG // Buttons auf Buttondialogen mit ID
988 || pBase->GetType() == WINDOW_MESSBOX
989 || pBase->GetType() == WINDOW_INFOBOX
990 || pBase->GetType() == WINDOW_WARNINGBOX
991 || pBase->GetType() == WINDOW_ERRORBOX
992 || pBase->GetType() == WINDOW_QUERYBOX )
993 {
994 ButtonDialog *pBD = ((ButtonDialog*)pBase);
995 sal_uInt16 i;
996 for ( i = 0; i < pBD->GetButtonCount() ; i++ )
997 {
998 aName = String();
999 if ( aName.Len() == 0 )
1000 aName = pBD->GetPushButton( pBD->GetButtonId(i) )->GetText();
1001 ByteString aID;
1002 switch ( pBD->GetButtonId(i) )
1003 {
1004 case BUTTONID_OK:
1005 aID.Assign("Ok");
1006 break;
1007 case BUTTONID_CANCEL:
1008 aID.Assign("Cancel");
1009 break;
1010 case BUTTONID_YES:
1011 aID.Assign("Yes");
1012 break;
1013 case BUTTONID_NO:
1014 aID.Assign("No");
1015 break;
1016 case BUTTONID_RETRY:
1017 aID.Assign("Retry");
1018 break;
1019 case BUTTONID_HELP:
1020 aID.Assign("Help");
1021 break;
1022 default:
1023 aID = ByteString::CreateFromInt32( pBD->GetButtonId(i) );
1024 break;
1025 }
1026
1027 pRet->GenReturn ( RET_WinInfo, aID, (comm_ULONG)pBD->GetPushButton( pBD->GetButtonId(i) )->GetType(), // So da� der Text angezeigt wird!
1028 TypeString(pBD->GetPushButton( pBD->GetButtonId(i) )->GetType()).AppendAscii(": ").Append(aName)
1029 .AppendAscii(" ButtonId = ").AppendAscii( aID.GetBuffer() ), sal_False );
1030 }
1031
1032 return; // ButtonDialog ist hier schon komplett abgehandelt.
1033 }
1034
1035
1036 Menu* pMenu = GetMatchingMenu( pBase );
1037
1038 if ( pMenu ) // Menus
1039 {
1040 sal_uInt16 i;
1041 for ( i = 0; i < pMenu->GetItemCount() ; i++ )
1042 {
1043 sal_uInt16 nID = pMenu->GetItemId( i );
1044
1045 aName = String();
1046 if ( aName.Len() == 0 )
1047 aName = pMenu->GetHelpText( nID );
1048 if ( aName.Len() == 0 )
1049 aName = pMenu->GetItemText( nID );
1050
1051
1052 if ( pMenu->GetItemType( i ) == MENUITEM_STRING || pMenu->GetItemType( i ) == MENUITEM_IMAGE || pMenu->GetItemType( i ) == MENUITEM_STRINGIMAGE || (nConf & DH_MODE_ALLWIN) )
1053 {
1054 String aMenuItemType;
1055 switch ( pMenu->GetItemType( i ) )
1056 {
1057 case MENUITEM_STRING:
1058 aMenuItemType.AssignAscii("MENUITEM_STRING");
1059 break;
1060 case MENUITEM_STRINGIMAGE:
1061 aMenuItemType.AssignAscii("MENUITEM_STRINGIMAGE");
1062 break;
1063 case MENUITEM_IMAGE:
1064 aMenuItemType.AssignAscii("MENUITEM_IMAGE");
1065 break;
1066 case MENUITEM_SEPARATOR:
1067 aMenuItemType.AssignAscii("MENUITEM_SEPARATOR");
1068 break;
1069 case MENUITEM_DONTKNOW:
1070 aMenuItemType.AssignAscii("MENUITEM_DONTKNOW");
1071 break;
1072 default:
1073 DBG_ERROR1( "Unknown MENUITEM %i", pMenu->GetItemType( i ) );
1074 }
1075 if ( pMenu->GetItemCommand(nID).Len() || ( nConf & DH_MODE_ALLWIN ) )
1076 pRet->GenReturn ( RET_WinInfo, Str2Id( pMenu->GetItemCommand(nID) ), (comm_ULONG)0,
1077 aMenuItemType.AppendAscii(": ").Append(aName), sal_False );
1078 if ( !pMenu->GetItemCommand(nID).Len() || ( nConf & DH_MODE_ALLWIN ) )
1079 pRet->GenReturn ( RET_WinInfo, rtl::OString::valueOf( (sal_Int32)nID ), (comm_ULONG)0,
1080 aMenuItemType.AppendAscii(": ").Append(aName), sal_False );
1081 }
1082 }
1083
1084 return; // Menu ist hier schon komplett abgehandelt.
1085 }
1086 }
1087 }
1088
1089 for( sal_uInt16 i = 0 ; i < pBase->GetChildCount(); i++ )
1090 WriteControlData( pBase->GetChild(i), nConf, sal_False );
1091 }
1092
1093 class SysWinContainer : public WorkWindow
1094 {
1095 private:
1096 ToolBox *pClientWin;
1097 DockingWindow *pDock;
1098 public:
1099 SysWinContainer( ToolBox *pClient );
1100 ~SysWinContainer();
1101 virtual void Resize();
1102 virtual void Resizing( Size& rSize );
1103 };
1104
SysWinContainer(ToolBox * pClient)1105 SysWinContainer::SysWinContainer( ToolBox *pClient )
1106 : WorkWindow( NULL, WB_BORDER | WB_SIZEMOVE | WB_CLOSEABLE )
1107 , pClientWin( pClient )
1108 {
1109 pDock = new DockingWindow( this );
1110 pClientWin->SetParent( pDock );
1111 pClientWin->SetFloatingMode( sal_False );
1112 SetText( pClient->GetText() );
1113 SetPosPixel( Point( 1,40 ) );
1114 Resize();
1115 pDock->Show();
1116 EnableAlwaysOnTop();
1117 Show();
1118 }
1119
~SysWinContainer()1120 SysWinContainer::~SysWinContainer()
1121 {
1122 delete pDock;
1123 }
1124
Resize()1125 void SysWinContainer::Resize()
1126 {
1127 Size aSize( GetOutputSizePixel() );
1128 Resizing( aSize );
1129 // aSize = pClientWin->GetSizePixel();
1130 // aSize = pClientWin->CalcWindowSizePixel();
1131 if ( aSize != GetSizePixel() )
1132 {
1133 SetOutputSizePixel( aSize );
1134 pDock->SetSizePixel( aSize );
1135 pClientWin->SetSizePixel( aSize );
1136 }
1137 }
1138
Resizing(Size & rSize)1139 void SysWinContainer::Resizing( Size& rSize )
1140 {
1141 Size aSize;
1142 Size aBestSize;
1143 sal_uInt16 i;
1144 sal_Bool bHasValue = sal_False;
1145 sal_uLong nBestValue = 0;
1146 sal_uLong nThisValue;
1147 for ( i=1 ; i<=1 ; i++ )
1148 {
1149 aSize = pClientWin->CalcWindowSizePixel( i );
1150 nThisValue = Abs( aSize.Width() - rSize.Width() ) + Abs( aSize.Height() - rSize.Height() );
1151 if ( !bHasValue || ( nThisValue < nBestValue ) )
1152 {
1153 nBestValue = nThisValue;
1154 aBestSize = aSize;
1155 bHasValue = sal_True;
1156 }
1157 }
1158 rSize = aBestSize;
1159 }
1160
1161
1162 class DisplayHidWin : public ToolBox
1163 {
1164 Edit *pEdit;
1165 Size aMinEditSize;
1166 sal_uInt16 nLastItemID;
1167 sal_Bool bIsDraging;
1168 sal_Bool bIsPermanentDraging;
1169 void SetDraging( sal_Bool bNewDraging );
1170 Image *pShow, *pShow2;
1171 sal_Bool bConfigChanged;
1172 void EnableButtons( sal_uLong nConf );
1173
1174 sal_uLong nEventHookID;
stub_VCLEventHookProc(NotifyEvent & rEvt,void * pData)1175 static long stub_VCLEventHookProc( NotifyEvent& rEvt, void* pData )
1176 {
1177 return ((DisplayHidWin*)pData)->VCLEventHook( rEvt );
1178 }
1179
1180 long VCLEventHook( NotifyEvent& rEvt );
1181 Window *pLastMouseMoveWin;
1182
1183 SysWinContainer *pContainer;
1184
1185 // aborting by pressing shist twice
1186 sal_Bool bOldShift;
1187 Time aLatest;
1188 sal_uInt16 nShiftCount;
1189
1190 public:
1191 DisplayHidWin();
1192 ~DisplayHidWin();
1193
1194 virtual void Tracking( const TrackingEvent& rTEvt );
1195 virtual void Click();
1196 virtual void Select();
1197 virtual void SetText( const XubString& rStr );
1198
SetDisplayText(const String & aNewText)1199 void SetDisplayText( const String &aNewText ){ pEdit->SetText(aNewText); }
GetDisplayText() const1200 String GetDisplayText() const { return pEdit->GetText(); }
IsDisplayTextModified() const1201 sal_Bool IsDisplayTextModified() const { return pEdit->IsModified(); }
ClearDisplayTextModified() const1202 void ClearDisplayTextModified() const { pEdit->ClearModifyFlag(); }
1203
1204 void SetConfig( sal_uLong nConf );
1205 sal_uLong GetConfig();
1206
IsConfigChanged()1207 sal_Bool IsConfigChanged() { return bConfigChanged; }
ConfigSent()1208 void ConfigSent() { bConfigChanged = sal_False; }
1209
IsSendData()1210 sal_Bool IsSendData() { return GetItemState( TT_SEND_DATA ) == STATE_CHECK; }
1211 // sal_Bool IsAllWin() { return GetItemState( TT_ALLWIN ) == STATE_CHECK; }
1212
IsDraging()1213 sal_Bool IsDraging() { return bIsDraging; }
1214
LastMouseMoveWin()1215 Window* LastMouseMoveWin() { return pLastMouseMoveWin; }
1216 };
1217
DisplayHidWin()1218 DisplayHidWin::DisplayHidWin()
1219 : ToolBox( StatementList::GetFirstDocFrame(), TTProperties::GetSvtResId(DisplayHidToolBox) )
1220 , bIsDraging( sal_False )
1221 , bIsPermanentDraging( sal_False )
1222 , pShow( NULL )
1223 , pShow2( NULL )
1224 , pLastMouseMoveWin( NULL )
1225 , bOldShift( 0 )
1226 , nShiftCount( 0 )
1227 {
1228 SetOutStyle( TOOLBOX_STYLE_HANDPOINTER | TOOLBOX_STYLE_FLAT );
1229 pEdit = new Edit( this, WB_CENTER | WB_BORDER );
1230 aMinEditSize = GetItemRect( TT_OUTPUT ).GetSize();
1231 /**/ aMinEditSize=Size(20,20);
1232 aMinEditSize.Width() *= 12;
1233 pEdit->SetSizePixel( aMinEditSize );
1234 pEdit->Show();
1235 SetItemWindow( TT_OUTPUT, pEdit );
1236 Resize();
1237 pContainer = new SysWinContainer( this );
1238 nEventHookID = Application::AddEventHook( stub_VCLEventHookProc, this );
1239 }
1240
~DisplayHidWin()1241 DisplayHidWin::~DisplayHidWin()
1242 {
1243 Application::RemoveEventHook( nEventHookID );
1244 Hide(); // so GetFirstDocFrame won't return ourselves (needed for SOPlayer)
1245 SetParent( StatementList::GetFirstDocFrame() );
1246 delete pContainer;
1247 delete pEdit;
1248 }
1249
SetDraging(sal_Bool bNewDraging)1250 void DisplayHidWin::SetDraging( sal_Bool bNewDraging )
1251 {
1252 if ( !pShow )
1253 pShow = new Image( GetItemImage( TT_SHOW ) );
1254 if ( !pShow2 )
1255 pShow2 = new Image( Bitmap( TTProperties::GetSvtResId( TT_SHOW2 ) ) );
1256
1257 if ( bNewDraging )
1258 SetItemImage( TT_SHOW, *pShow2 );
1259 else
1260 SetItemImage( TT_SHOW, *pShow );
1261
1262 bIsDraging = bNewDraging;
1263 }
1264
EnableButtons(sal_uLong nConf)1265 void DisplayHidWin::EnableButtons( sal_uLong nConf )
1266 {
1267 sal_Bool bSend = sal_Bool(nConf & DH_MODE_SEND_DATA);
1268 EnableItem( TT_ALLWIN, bSend );
1269 EnableItem( TT_KURZNAME, bSend );
1270 EnableItem( TT_LANGNAME, bSend );
1271 }
1272
Tracking(const TrackingEvent & rTEvt)1273 void DisplayHidWin::Tracking( const TrackingEvent& rTEvt )
1274 {
1275 // if ( nLastItemID == TT_SHOW && GetItemState( TT_SHOW ) == STATE_NOCHECK && ( rTEvt.IsTrackingEnded() || rTEvt.IsTrackingCanceled() ) )
1276 // SetDraging( sal_False );
1277 if ( nLastItemID == TT_SHOW && GetItemState( TT_SHOW ) == STATE_NOCHECK )
1278 EndTracking( ENDTRACK_CANCEL );
1279 ToolBox::Tracking( rTEvt);
1280 }
1281
Click()1282 void DisplayHidWin::Click()
1283 {
1284 nLastItemID = GetCurItemId();
1285 if ( nLastItemID == TT_SHOW )
1286 {
1287 SetDraging( sal_True );
1288 }
1289 ToolBox::Click();
1290 }
1291
Select()1292 void DisplayHidWin::Select()
1293 {
1294 if ( GetItemState( GetCurItemId() ) == STATE_NOCHECK )
1295 {
1296 SetItemState( GetCurItemId(), STATE_CHECK );
1297 if ( GetCurItemId() == TT_SHOW )
1298 {
1299 bIsPermanentDraging = sal_True;
1300 SetDraging( sal_True );
1301 }
1302 }
1303 else
1304 {
1305 SetItemState( GetCurItemId(), STATE_NOCHECK );
1306 if ( GetCurItemId() == TT_SHOW )
1307 {
1308 bIsPermanentDraging = sal_False;
1309 SetDraging( sal_False );
1310 }
1311 }
1312 if ( GetCurItemId() == TT_SEND_DATA )
1313 {
1314 EnableButtons( GetConfig() );
1315 }
1316 }
1317
SetConfig(sal_uLong nConf)1318 void DisplayHidWin::SetConfig( sal_uLong nConf )
1319 {
1320 SetItemState( TT_KURZNAME, ( nConf & DH_MODE_KURZNAME ) ? STATE_CHECK : STATE_NOCHECK );
1321 SetItemState( TT_LANGNAME, ( nConf & DH_MODE_LANGNAME ) ? STATE_CHECK : STATE_NOCHECK );
1322 SetItemState( TT_ALLWIN, ( nConf & DH_MODE_ALLWIN ) ? STATE_CHECK : STATE_NOCHECK );
1323 SetItemState( TT_SEND_DATA, ( nConf & DH_MODE_SEND_DATA ) ? STATE_CHECK : STATE_NOCHECK );
1324 EnableButtons( nConf );
1325 }
1326
GetConfig()1327 sal_uLong DisplayHidWin::GetConfig()
1328 {
1329 sal_uLong nConf = 0;
1330 if ( GetItemState( TT_KURZNAME ) == STATE_CHECK )
1331 nConf |= DH_MODE_KURZNAME;
1332 if ( GetItemState( TT_LANGNAME ) == STATE_CHECK )
1333 nConf |= DH_MODE_LANGNAME;
1334 if ( GetItemState( TT_ALLWIN ) == STATE_CHECK )
1335 nConf |= DH_MODE_ALLWIN;
1336 if ( IsSendData() )
1337 nConf |= DH_MODE_SEND_DATA;
1338
1339 return nConf;
1340 }
1341
SetText(const XubString & rStr)1342 void DisplayHidWin::SetText( const XubString& rStr )
1343 {
1344 pContainer->SetText( rStr );
1345 }
1346
VCLEventHook(NotifyEvent & rEvt)1347 long DisplayHidWin::VCLEventHook( NotifyEvent& rEvt )
1348 {
1349 if ( EVENT_MOUSEMOVE == rEvt.GetType() )
1350 {
1351 pLastMouseMoveWin = rEvt.GetWindow();
1352
1353 // check if abort with pressing shift twice
1354 MouseEvent* pMEvt = (MouseEvent*)rEvt.GetMouseEvent();
1355
1356 if ( ( pMEvt->IsShift() && !bOldShift ) ) // Shift pressed
1357 {
1358 if ( aLatest < Time() )
1359 {
1360 nShiftCount = 0;
1361 aLatest = Time()+Time( 0, 0, 0, 50 );
1362 }
1363 nShiftCount++;
1364 }
1365 if ( ( !pMEvt->IsShift() && bOldShift ) ) // Shift released
1366 {
1367 nShiftCount++;
1368 if ( nShiftCount == 4 && aLatest > Time() )
1369 {
1370 bIsPermanentDraging = sal_False;
1371 SetDraging( sal_False );
1372 SetItemState( TT_SHOW, STATE_NOCHECK );
1373 }
1374 }
1375 bOldShift = pMEvt->IsShift();
1376 }
1377 if ( ( ( EVENT_MOUSEBUTTONUP == rEvt.GetType() && rEvt.GetMouseEvent()->GetButtons() == MOUSE_LEFT) || ( EVENT_MOUSEMOVE == rEvt.GetType() && !rEvt.GetMouseEvent()->GetButtons() ) )
1378 && IsDraging() && !bIsPermanentDraging )
1379 SetDraging( sal_False );
1380 return 0;
1381 }
1382
1383
DisplayHID()1384 sal_Bool StatementCommand::DisplayHID()
1385 {
1386 // Return sal_True -> reexecute command
1387
1388 if ( !bBool2 ) // Wird auf sal_False initialisiert
1389 {
1390 bBool2 = sal_True; // Wir sind initialisiert.
1391 GetTTSettings()->pDisplayInstance = this; // Und haben die Macht (Alle anderen beenden sich)
1392
1393 if ( !(nParams & PARAM_ULONG_1) )
1394 {
1395 if( GetTTSettings()->pDisplayHidWin ) // Nichts ver�ndern
1396 nLNr1 = GetTTSettings()->pDisplayHidWin->GetConfig();
1397 else // Beim ersten Aufruf wollen wir alles richtig einstellen
1398 nLNr1 = DH_MODE_KURZNAME | DH_MODE_LANGNAME;
1399
1400 if( ((nParams & PARAM_BOOL_1) && bBool1) )
1401 nLNr1 |= DH_MODE_SEND_DATA;
1402 else
1403 nLNr1 &= ( ~DH_MODE_SEND_DATA );
1404 }
1405
1406 if ( GetTTSettings()->pDisplayHidWin )
1407 GetTTSettings()->pDisplayHidWin->SetConfig( nLNr1 );
1408 }
1409
1410 if ( GetTTSettings()->pDisplayInstance && GetTTSettings()->pDisplayInstance != this )
1411 {
1412 DBG_WARNING("Mehrere DisplayHID am laufen");
1413 return sal_False; // Noch eine andere Instanz macht das gleiche!
1414 }
1415
1416 if ( !GetTTSettings()->pDisplayHidWin )
1417 {
1418 GetTTSettings()->pDisplayHidWin = new DisplayHidWin();
1419 GetTTSettings()->aOriginalCaption = GetTTSettings()->pDisplayHidWin->GetText();
1420 GetTTSettings()->pDisplayHidWin->Show();
1421 if ( bBool1 )
1422 nLNr1 |= DH_MODE_SEND_DATA;
1423 GetTTSettings()->pDisplayHidWin->SetConfig( nLNr1 );
1424
1425 GetTTSettings()->Old = NULL;
1426 GetTTSettings()->Act = NULL;
1427 GetTTSettings()->pDisplayInstance = this;
1428 }
1429 else
1430 {
1431 GetTTSettings()->pDisplayHidWin->GetWindow( WINDOW_OVERLAP )->Enable( sal_True, sal_True );
1432 GetTTSettings()->pDisplayHidWin->GetWindow( WINDOW_OVERLAP )->EnableInput( sal_True, sal_True );
1433 }
1434
1435
1436 if ( GetTTSettings()->pDisplayHidWin->IsVisible() && !bDying )
1437 {
1438
1439 if ( GetTTSettings()->pDisplayHidWin->IsDraging() )
1440 {
1441
1442
1443 #define HIGHLIGHT_WIN( WinPtr ) \
1444 { \
1445 Color aLineColMem = WinPtr->GetLineColor(); \
1446 WinPtr->SetLineColor( Color( COL_WHITE ) ); \
1447 Color aFillColMem = WinPtr->GetFillColor(); \
1448 WinPtr->SetFillColor( Color( COL_LIGHTRED ) ); \
1449 RasterOp aROp = WinPtr->GetRasterOp(); \
1450 WinPtr->SetRasterOp( ROP_XOR ); \
1451 Size aSz = WinPtr->PixelToLogic( WinPtr->GetSizePixel() );\
1452 sal_uLong nMaxCornerRadius = WinPtr->PixelToLogic( Point( 80, 0 ) ).X();\
1453 sal_uLong iCorner = std::max ((sal_uLong) 8, (sal_uLong) std::min( nMaxCornerRadius, (sal_uLong) std::min((sal_uLong) (aSz.Width() / 6), (sal_uLong)(aSz.Height() / 6))));\
1454 WinPtr->DrawRect(Rectangle(Point(),aSz), iCorner, iCorner);\
1455 WinPtr->SetLineColor( aLineColMem ); \
1456 WinPtr->SetFillColor( aFillColMem ); \
1457 WinPtr->SetRasterOp( aROp ); \
1458 }
1459
1460
1461 #define SET_WIN( WinPtr ) \
1462 if ( StatementList::WinPtrValid(WinPtr) ) \
1463 { \
1464 HIGHLIGHT_WIN ( WinPtr ); \
1465 }
1466
1467 #define RESET_WIN( WinPtr ) \
1468 if ( StatementList::WinPtrValid(WinPtr) ) \
1469 { \
1470 WinPtr->Invalidate( INVALIDATE_NOTRANSPARENT ); \
1471 WinPtr->Update(); \
1472 }
1473
1474
1475 GetTTSettings()->Old = GetTTSettings()->Act;
1476 // GetTTSettings()->Act = GetMouseWin();
1477 GetTTSettings()->Act = GetTTSettings()->pDisplayHidWin->LastMouseMoveWin();
1478
1479 if ( !StatementList::WinPtrValid ( GetTTSettings()->Old ) )
1480 GetTTSettings()->Old = NULL;
1481 if ( !StatementList::WinPtrValid ( GetTTSettings()->Act ) )
1482 GetTTSettings()->Act = NULL;
1483
1484 if ( GetTTSettings()->Act && GetTTSettings()->Act->GetType() == WINDOW_BORDERWINDOW )
1485 GetTTSettings()->Act = GetTTSettings()->Act->GetWindow( WINDOW_CLIENT );
1486
1487 if ( GetTTSettings()->Act != GetTTSettings()->Old )
1488 {
1489 if ( GetTTSettings()->Old )
1490 {
1491 RESET_WIN(GetTTSettings()->Old);
1492 }
1493 if ( GetTTSettings()->Act )
1494 {
1495 SET_WIN(GetTTSettings()->Act);
1496 GetTTSettings()->pDisplayHidWin->SetDisplayText( Id2Str(GetTTSettings()->Act->GetUniqueOrHelpId()).AppendAscii(" WinType: ")
1497 .Append(UniString::CreateFromInt64(GetTTSettings()->Act->GetType())).AppendAscii(" ").Append(GetTTSettings()->Act->GetText()));
1498 if ( GetTTSettings()->Act && !GetTTSettings()->Act->GetUniqueId().equals( GetTTSettings()->Act->GetHelpId() ) )
1499 GetTTSettings()->pDisplayHidWin->SetText(UniString( TTProperties::GetSvtResId( TT_ALTERNATE_CAPTION ) ).AppendAscii(GetTTSettings()->Act->GetHelpId().getStr()));
1500 else
1501 GetTTSettings()->pDisplayHidWin->SetText( GetTTSettings()->aOriginalCaption );
1502 }
1503 else
1504 GetTTSettings()->pDisplayHidWin->SetDisplayText(CUniString("Kein Window/Control gefunden"));
1505 }
1506 else if ( GetTTSettings()->Act )
1507 {
1508 // SET_WIN(GetTTSettings()->Act);
1509 // allow setting a HelpID manually (just enter the ID in the displayHID Window and terminate it by |
1510 if ( GetTTSettings()->pDisplayHidWin->IsDisplayTextModified() && GetTTSettings()->pDisplayHidWin->GetDisplayText().GetTokenCount( '|' ) > 1 )
1511 {
1512 GetTTSettings()->Act->SetUniqueId( Str2Id( GetTTSettings()->pDisplayHidWin->GetDisplayText().GetToken( '|' ) ) );
1513 GetTTSettings()->pDisplayHidWin->ClearDisplayTextModified();
1514 }
1515 }
1516 /* if ( Application::GetLastInputInterval() > 5000 ) // 5 Sekunden lang nix geschehen
1517 {
1518 GetTTSettings()->pDisplayHidWin->ToTop( TOTOP_NOGRABFOCUS );
1519 }
1520 */
1521 if ( GetTTSettings()->pDisplayHidWin->IsSendData() /*&& bBool2*/ && GetTTSettings()->Act )
1522 {
1523 if ( !StatementFlow::bSending )
1524 { // Normalerweise syncronisierung �ber Protokoll. Hier ist das aber asyncron!!!
1525 WriteControlData( GetTTSettings()->Act, GetTTSettings()->pDisplayHidWin->GetConfig() );
1526 new StatementFlow( this, F_EndCommandBlock ); // Kommando zum Senden erzeugen und in que eintragen
1527 }
1528 }
1529 } //if ( GetTTSettings()->pDisplayHidWin->IsDraging() )
1530 else
1531 {
1532 if ( GetTTSettings()->Act )
1533 {
1534 RESET_WIN(GetTTSettings()->Act);
1535 GetTTSettings()->Act = NULL;
1536 }
1537 }
1538
1539 if ( pFirst == this ) // Sollte immer so sein, aber besser isses
1540 if ( pNext ) // Befehle warten auf Ausf�hrung
1541 { // An Ende neu einsortieren
1542 Advance();
1543 QueStatement( NULL );
1544 }
1545 // { // Ersten und 2. austauschen.
1546 // pFirst = pNext;
1547 // pNext = pNext->pNext;
1548 // pFirst->pNext = this;
1549 // }
1550
1551 }
1552 else
1553 {
1554 delete GetTTSettings()->pDisplayHidWin;
1555 GetTTSettings()->pDisplayHidWin = NULL;
1556 GetTTSettings()->pDisplayInstance = NULL;
1557 }
1558
1559 return GetTTSettings()->pDisplayHidWin != NULL;
1560 }
1561
1562 class TranslateWin : public WorkWindow
1563 {
1564 private:
1565 DECL_LINK( DoAccept, PushButton* );
1566 DECL_LINK( DoNext, PushButton* );
1567 DECL_LINK( DoSelect, PushButton* );
1568 DECL_LINK( DoRestore, PushButton* );
1569 DECL_LINK( TranslationChanged, Edit* );
1570 DECL_LINK( ShowInplace, Timer* );
1571
1572 Timer InplaceTimer;
1573
1574 // virtual void MouseButtonUp( const MouseEvent& rMEvt );
1575 // virtual void MouseMove( const MouseEvent& rMEvt );
1576
1577 PushButton PushButtonTT_PB_NEXT;
1578 GroupBox GroupBoxTT_GB_TRANSLATION;
1579 Edit EditTT_E_NEW;
1580 GroupBox GroupBoxTT_GB_COMMENT;
1581 Edit EditTT_E_COMMENT;
1582 PushButton PushButtonTT_PB_ACCEPT;
1583 FixedText FixedTextTT_FT_OLD;
1584 PushButton PushButtonTT_PB_SELECT;
1585 PushButton PushButtonTT_PB_RESTORE;
1586
1587 Window *Old;
1588 Window *Act;
1589 Window *pTranslateWin;
1590 sal_Bool bSelecting;
1591
1592 sal_Bool bAvailable;
1593 sal_Bool bNext;
1594
1595 sal_Bool TestChangedDataSaved();
1596
1597
1598 sal_uLong nEventHookID;
stub_VCLEventHookProc(NotifyEvent & rEvt,void * pData)1599 static long stub_VCLEventHookProc( NotifyEvent& rEvt, void* pData )
1600 {
1601 return ((TranslateWin*)pData)->VCLEventHook( rEvt );
1602 }
1603
1604 long VCLEventHook( NotifyEvent& rEvt );
1605
1606 public:
1607 TranslateWin();
1608 ~TranslateWin();
1609
1610 static String MarkShortcutErrors( Window* pBase, sal_Bool bMark );
1611
IsTranslationAvailable()1612 sal_Bool IsTranslationAvailable(){ return bAvailable; }
IsNextDialog()1613 sal_Bool IsNextDialog(){ return bNext; }
ResetNextDialog()1614 void ResetNextDialog(){ bNext = sal_False; }
1615
GetTranslationWindow()1616 Window* GetTranslationWindow(){ return pTranslateWin; }
GetOriginalText()1617 String GetOriginalText(){ return FixedTextTT_FT_OLD.GetText(); }
GetTranslationText()1618 String GetTranslationText(){ return EditTT_E_NEW.GetText(); }
GetComment()1619 String GetComment(){ return EditTT_E_COMMENT.GetText(); }
1620
1621 void EnableTranslation();
1622 };
1623
TranslateWin()1624 TranslateWin::TranslateWin()
1625 : WorkWindow( NULL, TTProperties::GetSvtResId( TT_INLINE_TRANSLATION ) )
1626 , PushButtonTT_PB_NEXT( this, TTProperties::GetSvtResId( TT_PB_NEXT ) )
1627 , GroupBoxTT_GB_TRANSLATION( this, TTProperties::GetSvtResId( TT_GB_TRANSLATION ) )
1628 , EditTT_E_NEW( this, TTProperties::GetSvtResId( TT_E_NEW ) )
1629 , GroupBoxTT_GB_COMMENT( this, TTProperties::GetSvtResId( TT_GB_COMMENT ) )
1630 , EditTT_E_COMMENT( this, TTProperties::GetSvtResId( TT_E_COMMENT ) )
1631 , PushButtonTT_PB_ACCEPT( this, TTProperties::GetSvtResId( TT_PB_ACCEPT ) )
1632 , FixedTextTT_FT_OLD( this, TTProperties::GetSvtResId( TT_FT_OLD ) )
1633 , PushButtonTT_PB_SELECT( this, TTProperties::GetSvtResId( TT_PB_SELECT ) )
1634 , PushButtonTT_PB_RESTORE( this, TTProperties::GetSvtResId( TT_PB_RESTORE ) )
1635 , Old( NULL )
1636 , Act( NULL )
1637 , pTranslateWin( NULL )
1638 , bSelecting( sal_False )
1639 , bAvailable( sal_False )
1640 , bNext( sal_False )
1641 {
1642 FreeResource();
1643 PushButtonTT_PB_NEXT.SetClickHdl( LINK( this, TranslateWin, DoNext ) );
1644 PushButtonTT_PB_ACCEPT.SetClickHdl( LINK( this, TranslateWin, DoAccept ) );
1645 PushButtonTT_PB_SELECT.SetClickHdl( LINK( this, TranslateWin, DoSelect ) );
1646 PushButtonTT_PB_RESTORE.SetClickHdl( LINK( this, TranslateWin, DoRestore ) );
1647 EditTT_E_NEW.SetModifyHdl( LINK( this, TranslateWin, TranslationChanged ) );
1648 InplaceTimer.SetTimeout( 250 );
1649 InplaceTimer.SetTimeoutHdl( LINK( this, TranslateWin, ShowInplace ) );
1650 EnableAlwaysOnTop();
1651 nEventHookID = Application::AddEventHook( stub_VCLEventHookProc, this );
1652 }
1653
~TranslateWin()1654 TranslateWin::~TranslateWin()
1655 {
1656 Application::RemoveEventHook( nEventHookID );
1657 }
1658
TestChangedDataSaved()1659 sal_Bool TranslateWin::TestChangedDataSaved()
1660 {
1661 if ( ( EditTT_E_NEW.GetText().CompareTo( FixedTextTT_FT_OLD.GetText() ) != COMPARE_EQUAL
1662 || EditTT_E_COMMENT.GetText().Len() )
1663 && PushButtonTT_PB_ACCEPT.IsEnabled() )
1664 {
1665 return MessBox( this, TTProperties::GetSvtResId( TT_DISCARD_CHANGED_DATA ) ).Execute() == RET_YES;
1666 }
1667 else
1668 return sal_True;
1669 }
1670
IMPL_LINK(TranslateWin,DoAccept,PushButton *,EMPTYARG)1671 IMPL_LINK( TranslateWin, DoAccept, PushButton*, EMPTYARG )
1672 {
1673 PushButtonTT_PB_SELECT.Disable();
1674 PushButtonTT_PB_NEXT.Disable();
1675 PushButtonTT_PB_RESTORE.Disable();
1676 EditTT_E_NEW.Disable();
1677 EditTT_E_COMMENT.Disable();
1678 PushButtonTT_PB_ACCEPT.Disable();
1679 bAvailable = sal_True;
1680 return 0;
1681 }
1682
IMPL_LINK(TranslateWin,DoNext,PushButton *,EMPTYARG)1683 IMPL_LINK( TranslateWin, DoNext, PushButton*, EMPTYARG )
1684 {
1685 if ( TestChangedDataSaved() )
1686 {
1687 PushButtonTT_PB_SELECT.Disable();
1688 PushButtonTT_PB_NEXT.Disable();
1689 PushButtonTT_PB_RESTORE.Disable();
1690 EditTT_E_NEW.Disable();
1691 EditTT_E_COMMENT.Disable();
1692 PushButtonTT_PB_ACCEPT.Disable();
1693 bNext = sal_True;
1694 }
1695 return 0;
1696 }
1697
IMPL_LINK(TranslateWin,DoSelect,PushButton *,EMPTYARG)1698 IMPL_LINK( TranslateWin, DoSelect, PushButton*, EMPTYARG )
1699 {
1700 if ( bSelecting )
1701 {
1702 // ReleaseMouse();
1703 bSelecting = sal_False;
1704 }
1705 else
1706 {
1707 if ( TestChangedDataSaved() )
1708 {
1709 PushButtonTT_PB_RESTORE.Disable();
1710 // CaptureMouse();
1711 bSelecting = sal_True;
1712 }
1713 }
1714 return 0;
1715 }
1716
IMPL_LINK(TranslateWin,DoRestore,PushButton *,EMPTYARG)1717 IMPL_LINK( TranslateWin, DoRestore, PushButton*, EMPTYARG )
1718 {
1719 String sTT_E_OLD( FixedTextTT_FT_OLD.GetText());
1720 sTT_E_OLD.SearchAndReplaceAll( CUniString("\\n"), CUniString("\n") );
1721 sTT_E_OLD.SearchAndReplaceAll( CUniString("\\t"), CUniString("\t") );
1722
1723 String sTT_E_NEW( EditTT_E_NEW.GetText());
1724 sTT_E_NEW.SearchAndReplaceAll( CUniString("\\n"), CUniString("\n") );
1725 sTT_E_NEW.SearchAndReplaceAll( CUniString("\\t"), CUniString("\t") );
1726
1727 if ( StatementList::WinPtrValid( pTranslateWin ) && pTranslateWin->GetText().CompareTo( sTT_E_NEW ) == COMPARE_EQUAL )
1728 { // Im ersten schritt nur in der UI zur�ck
1729 pTranslateWin->SetText( sTT_E_OLD );
1730 }
1731 else
1732 { // Im zweite Schritt auch den eingegebenen Text
1733 EditTT_E_NEW.SetText( FixedTextTT_FT_OLD.GetText() );
1734 PushButtonTT_PB_RESTORE.Disable();
1735 }
1736 if ( StatementList::WinPtrValid( pTranslateWin ) )
1737 MarkShortcutErrors( pTranslateWin->GetWindow( WINDOW_OVERLAP ), sal_True );
1738 return 0;
1739 }
1740
IMPL_LINK(TranslateWin,TranslationChanged,Edit *,pEdit)1741 IMPL_LINK( TranslateWin, TranslationChanged, Edit*, pEdit )
1742 {
1743 (void) pEdit; /* avoid warning about unused parameter */
1744 PushButtonTT_PB_RESTORE.Enable();
1745 InplaceTimer.Start();
1746 return 0;
1747 }
1748
IMPL_LINK(TranslateWin,ShowInplace,Timer *,EMPTYARG)1749 IMPL_LINK( TranslateWin, ShowInplace, Timer*, EMPTYARG )
1750 {
1751 PushButtonTT_PB_RESTORE.Enable();
1752 if ( StatementList::WinPtrValid( pTranslateWin ) )
1753 {
1754 String sTT_E_NEW( EditTT_E_NEW.GetText());
1755 // alle CRs UnQuoten
1756 sTT_E_NEW.SearchAndReplaceAll( CUniString("\\n"), CUniString("\n") );
1757 // alle TABSs UnQuoten
1758 sTT_E_NEW.SearchAndReplaceAll( CUniString("\\t"), CUniString("\t") );
1759 pTranslateWin->SetText( sTT_E_NEW );
1760
1761 MarkShortcutErrors( pTranslateWin->GetWindow( WINDOW_OVERLAP ), sal_True );
1762 }
1763 return 0;
1764 }
1765
VCLEventHook(NotifyEvent & rEvt)1766 long TranslateWin::VCLEventHook( NotifyEvent& rEvt )
1767 {
1768 if ( EVENT_MOUSEMOVE == rEvt.GetType() )
1769 {
1770 if ( bSelecting )
1771 {
1772 const MouseEvent *pMEvt = rEvt.GetMouseEvent();
1773 Old = Act;
1774 Act = rEvt.GetWindow();
1775
1776 if ( Act )
1777 {
1778 Window *pWin = Act;
1779 sal_uInt16 i;
1780 for ( i = 0 ; i < Act->GetChildCount() ; i++ )
1781 {
1782 pWin = Act->GetChild(i);
1783 Rectangle aWinPosSize( pWin->GetPosPixel(), pWin->GetSizePixel() );
1784
1785 if ( ( pWin->IsMouseTransparent() || !pWin->IsEnabled() ) && aWinPosSize.IsInside( pMEvt->GetPosPixel() ) )
1786 {
1787 Act = pWin;
1788 break;
1789 }
1790 }
1791 }
1792
1793 if ( !StatementList::WinPtrValid ( Old ) )
1794 Old = NULL;
1795
1796 if ( Act != Old )
1797 {
1798 if ( Old )
1799 {
1800 Window *pWin;
1801 if ( Old->IsMouseTransparent() && Old->GET_REAL_PARENT() )
1802 pWin = Old->GET_REAL_PARENT();
1803 else
1804 pWin = Old;
1805 RESET_WIN(pWin);
1806 }
1807 if ( Act )
1808 {
1809 SET_WIN(Act);
1810 FixedTextTT_FT_OLD.SetText( Act->GetText() );
1811 }
1812 else
1813 FixedTextTT_FT_OLD.SetText( String() );
1814 }
1815 else if ( Act )
1816 {
1817 // SET_WIN(Act);
1818 }
1819 /* if ( Application::GetLastInputInterval() > 5000 ) // 5 Sekunden lang nix geschehen
1820 {
1821 ToTop();
1822 }
1823 */
1824 } //if ( bSelecting )
1825 else
1826 {
1827 if ( Act )
1828 {
1829 if ( Act->IsMouseTransparent() && Act->GET_REAL_PARENT() )
1830 Act = Act->GET_REAL_PARENT();
1831 RESET_WIN(Act);
1832 Act = NULL;
1833 }
1834 }
1835 }
1836 else if ( EVENT_MOUSEBUTTONUP == rEvt.GetType() )
1837 {
1838 if ( bSelecting )
1839 {
1840 pTranslateWin = Act;
1841 if ( pTranslateWin )
1842 {
1843 MarkShortcutErrors( pTranslateWin->GetWindow( WINDOW_OVERLAP ), sal_True );
1844 // alle CRs quoten (NF)
1845 String sTT_E_NEW( pTranslateWin->GetText());
1846 sTT_E_NEW.SearchAndReplaceAll( CUniString("\n"), CUniString("\\n") );
1847 // alle TABSs quoten ()
1848 sTT_E_NEW.SearchAndReplaceAll( CUniString("\t"), CUniString("\\t") );
1849
1850 FixedTextTT_FT_OLD.SetText( sTT_E_NEW );
1851 EditTT_E_NEW.SetText( sTT_E_NEW );
1852 EditTT_E_NEW.Enable();
1853 EditTT_E_NEW.GrabFocus();
1854 EditTT_E_COMMENT.SetText( String() );
1855 EditTT_E_COMMENT.Enable();
1856 PushButtonTT_PB_ACCEPT.Enable();
1857 }
1858 // ReleaseMouse();
1859 bSelecting = sal_False;
1860 }
1861 }
1862
1863 return 0;
1864 }
1865
1866 #define FDS_ACTION_COLLECT 1
1867 #define FDS_ACTION_MARK 2
1868 #define FDS_ACTION_UNMARK 3
1869
1870 class FindShortcutErrors: public Search
1871 {
1872 String aShortcuts,aDoubleShortcuts;
1873 sal_uInt16 nAction;
1874 public:
1875 FindShortcutErrors();
1876 virtual sal_Bool IsWinOK( Window *pWin );
1877 void SetAction( sal_uInt16 nA );
GetDoubleShortcuts()1878 String GetDoubleShortcuts() { return aDoubleShortcuts; }
1879 };
1880
FindShortcutErrors()1881 FindShortcutErrors::FindShortcutErrors()
1882 : Search( SEARCH_NOOVERLAP | SEARCH_NO_TOPLEVEL_WIN )
1883 {
1884 SetAction( FDS_ACTION_COLLECT ); // Wir fange immer mit sammeln an, ODER??
1885 }
1886
SetAction(sal_uInt16 nA)1887 void FindShortcutErrors::SetAction( sal_uInt16 nA )
1888 {
1889 nAction = nA;
1890 if ( FDS_ACTION_COLLECT == nAction )
1891 {
1892 aShortcuts = UniString();
1893 aDoubleShortcuts = UniString();
1894 }
1895 }
1896
IsWinOK(Window * pWin)1897 sal_Bool FindShortcutErrors::IsWinOK( Window *pWin )
1898 {
1899 if ( pWin->IsReallyVisible() )
1900 {
1901 String aText = pWin->GetText();
1902 xub_StrLen nPos = aText.Search('~');
1903 String aShortcut;
1904 sal_Bool bHasAccel = sal_False;
1905 if ( nPos != STRING_NOTFOUND )
1906 {
1907 aShortcut = aText.Copy( nPos+1, 1 );
1908 aShortcut.ToLowerAscii();
1909 bHasAccel = aShortcut.Len() == 1;
1910 }
1911
1912 switch ( nAction )
1913 {
1914 case FDS_ACTION_COLLECT:
1915 {
1916 if ( aShortcuts.Search( aShortcut ) != STRING_NOTFOUND )
1917 aDoubleShortcuts += aShortcut;
1918 else
1919 aShortcuts += aShortcut;
1920 }
1921 break;
1922 case FDS_ACTION_MARK:
1923 {
1924 sal_Bool bMissing = sal_False;
1925 if ( !bHasAccel && aText.Len() ) // should there be an accelarator defined
1926 {
1927
1928 Window* pChild;
1929 pChild = pWin->GetWindow( WINDOW_CLIENT );
1930
1931 if ( (pChild->GetType() == WINDOW_RADIOBUTTON) ||
1932 (pChild->GetType() == WINDOW_IMAGERADIOBUTTON) ||
1933 (pChild->GetType() == WINDOW_CHECKBOX) ||
1934 (pChild->GetType() == WINDOW_TRISTATEBOX) ||
1935 (pChild->GetType() == WINDOW_PUSHBUTTON) )
1936 {
1937 if ( !pChild->GetText().EqualsAscii( "..." ) )
1938 bMissing = sal_True;
1939 }
1940
1941 if ( pChild->GetType() == WINDOW_FIXEDTEXT )
1942 {
1943 Window* pTempChild = pWin->GetWindow( WINDOW_NEXT );
1944 if ( pTempChild )
1945 pTempChild = pTempChild->GetWindow( WINDOW_CLIENT );
1946
1947 if ( pTempChild && pChild->GetText().Len() )
1948 {
1949 if ( (pTempChild->GetType() == WINDOW_EDIT) ||
1950 (pTempChild->GetType() == WINDOW_MULTILINEEDIT) ||
1951 (pTempChild->GetType() == WINDOW_SPINFIELD) ||
1952 (pTempChild->GetType() == WINDOW_PATTERNFIELD) ||
1953 (pTempChild->GetType() == WINDOW_NUMERICFIELD) ||
1954 (pTempChild->GetType() == WINDOW_METRICFIELD) ||
1955 (pTempChild->GetType() == WINDOW_CURRENCYFIELD) ||
1956 (pTempChild->GetType() == WINDOW_DATEFIELD) ||
1957 (pTempChild->GetType() == WINDOW_TIMEFIELD) ||
1958 (pTempChild->GetType() == WINDOW_LISTBOX) ||
1959 (pTempChild->GetType() == WINDOW_MULTILISTBOX) ||
1960 (pTempChild->GetType() == WINDOW_COMBOBOX) ||
1961 (pTempChild->GetType() == WINDOW_PATTERNBOX) ||
1962 (pTempChild->GetType() == WINDOW_NUMERICBOX) ||
1963 (pTempChild->GetType() == WINDOW_METRICBOX) ||
1964 (pTempChild->GetType() == WINDOW_CURRENCYBOX) ||
1965 (pTempChild->GetType() == WINDOW_DATEBOX) ||
1966 (pTempChild->GetType() == WINDOW_TIMEBOX) )
1967 {
1968 bMissing = sal_True;
1969 }
1970 }
1971 }
1972 }
1973
1974 if ( bHasAccel && aDoubleShortcuts.Search( aShortcut ) != STRING_NOTFOUND )
1975 {
1976 if ( pWin->GetType() == WINDOW_GROUPBOX )
1977 pWin->SetControlForeground( Color( COL_LIGHTRED ) );
1978 else
1979 {
1980 pWin->SetControlBackground();
1981 Color aCol(COL_GRAY);
1982 aCol.SetRed( 0xff );
1983 pWin->SetControlBackground( aCol );
1984 }
1985 }
1986 else if ( bMissing )
1987 {
1988 pWin->SetControlBackground();
1989 Color aCol(COL_GRAY);
1990 aCol.SetRed( 0xff );
1991 aCol.SetGreen( 0xff );
1992 pWin->SetControlBackground( aCol );
1993 }
1994 else
1995 {
1996 pWin->SetControlForeground();
1997 pWin->SetControlBackground();
1998 }
1999 }
2000 break;
2001 case FDS_ACTION_UNMARK:
2002 {
2003 pWin->SetControlForeground();
2004 pWin->SetControlBackground();
2005 }
2006 break;
2007 }
2008 }
2009 else
2010 if ( FDS_ACTION_MARK == nAction || FDS_ACTION_UNMARK == nAction )
2011 {
2012 pWin->SetControlForeground();
2013 pWin->SetControlBackground();
2014 }
2015
2016 return sal_False;
2017 }
2018
MarkShortcutErrors(Window * pBase,sal_Bool bMark)2019 String TranslateWin::MarkShortcutErrors( Window* pBase, sal_Bool bMark )
2020 {
2021 if ( pBase )
2022 {
2023 FindShortcutErrors aFinder;
2024 if ( bMark )
2025 {
2026 StatementList::SearchAllWin( pBase, aFinder, sal_True ); // collect Shortcuts first
2027 aFinder.SetAction( FDS_ACTION_MARK );
2028 }
2029 else
2030 aFinder.SetAction( FDS_ACTION_UNMARK );
2031 StatementList::SearchAllWin( pBase, aFinder, sal_True );
2032 return aFinder.GetDoubleShortcuts();
2033 }
2034 return UniString();
2035 }
2036
EnableTranslation()2037 void TranslateWin::EnableTranslation()
2038 {
2039 PushButtonTT_PB_SELECT.Enable();
2040 PushButtonTT_PB_NEXT.Enable();
2041 bAvailable = sal_False;
2042 bNext = sal_False;
2043 }
2044
Translate()2045 void StatementCommand::Translate()
2046 {
2047 // Es wurde eine initale UniqueId mitgegeben. Dann nur die dopelten Shortcuts liefern
2048 if( (nParams & PARAM_STR_1) && nLNr1 )
2049 {
2050 String aDouble;
2051 Window *pWin = SearchTree( Str2Id( aString1 ) ,sal_False );
2052 if ( pWin )
2053 {
2054 pWin = pWin->GetWindow( WINDOW_OVERLAP );
2055 aDouble = TranslateWin::MarkShortcutErrors( pWin, sal_True );
2056 }
2057 pRet->GenReturn ( RET_Value, nMethodId, aDouble );
2058 return;
2059 }
2060
2061 if ( !GetTTSettings()->pTranslateWin )
2062 {
2063 GetTTSettings()->pTranslateWin = new TranslateWin;
2064 GetTTSettings()->bToTop = sal_True;
2065 }
2066
2067 GetTTSettings()->pTranslateWin->Show();
2068 if ( GetTTSettings()->bToTop )
2069 {
2070 GetTTSettings()->pTranslateWin->ToTop();
2071 GetTTSettings()->bToTop = sal_False;
2072 }
2073
2074 // GetTTSettings()->pTranslateWin->GetWindow( WINDOW_OVERLAP )->Enable( sal_True, sal_True );
2075 GetTTSettings()->pTranslateWin->GetWindow( WINDOW_OVERLAP )->EnableInput( sal_True, sal_True );
2076
2077 if ( GetTTSettings()->pTranslateWin->IsTranslationAvailable() )
2078 {
2079 String aTranslation;
2080 Window* pTranslationWindow = GetTTSettings()->pTranslateWin->GetTranslationWindow();
2081
2082 DBG_ASSERT( pTranslationWindow, "Kein Translation Window" );
2083
2084 if ( WinPtrValid( pTranslationWindow ) )
2085 {
2086 if ( pTranslationWindow->GetType() == WINDOW_BORDERWINDOW && pTranslationWindow->GetWindow( WINDOW_CLIENT ) )
2087 {
2088 Window* pNew = pTranslationWindow->GetWindow( WINDOW_CLIENT );
2089 // Bei Dockingwindoes das kanze Geraffel von Docking Floating �berspringen
2090 while ( IsDialog( pNew ) && pNew->GetUniqueOrHelpId().isEmpty() && pNew->GetChildCount() == 1 )
2091 pNew = pNew->GetChild( 0 );
2092 pTranslationWindow = pNew;
2093 }
2094
2095 aTranslation = CUniString("0;");
2096
2097 aTranslation += Id2Str( pTranslationWindow->GetUniqueOrHelpId() );
2098 aTranslation += ';';
2099
2100 aTranslation += TypeString( pTranslationWindow->GetType() );
2101 aTranslation += ';';
2102
2103 Window* pParentDialog = pTranslationWindow;
2104 while ( pParentDialog && !IsDialog( pParentDialog ) )
2105 {
2106 pParentDialog = pParentDialog->GET_REAL_PARENT();
2107 }
2108
2109 if ( pParentDialog )
2110 {
2111 aTranslation += Id2Str(pParentDialog->GetUniqueOrHelpId());
2112 aTranslation += ';';
2113 aTranslation += TypeString( pParentDialog->GetType() );
2114 }
2115 else
2116 aTranslation.AppendAscii( "0;" ); // Zahl + leerer String
2117 aTranslation += ';';
2118
2119 aTranslation += '\"';
2120 aTranslation += GetTTSettings()->pTranslateWin->GetOriginalText();
2121 aTranslation += '\"';
2122
2123 aTranslation += ';';
2124
2125 aTranslation += '\"';
2126 aTranslation += GetTTSettings()->pTranslateWin->GetTranslationText();
2127 aTranslation += '\"';
2128
2129 aTranslation += ';';
2130
2131 aTranslation += '\"';
2132 aTranslation += GetTTSettings()->pTranslateWin->GetComment();
2133 aTranslation += '\"';
2134
2135 // alle CRs quoten (NF)
2136 aTranslation.SearchAndReplaceAll( CUniString("\n"), CUniString("\\n") );
2137 // alle TABSs quoten ()
2138 aTranslation.SearchAndReplaceAll( CUniString("\t"), CUniString("\\t") );
2139
2140 pRet->GenReturn ( RET_Value, nMethodId, aTranslation );
2141 GetTTSettings()->pTranslateWin->EnableTranslation();
2142 GetTTSettings()->bToTop = sal_True;
2143 }
2144 else
2145 {
2146 pRet->GenReturn ( RET_Value, nMethodId, String() );
2147 GetTTSettings()->pTranslateWin->EnableTranslation();
2148 ErrorBox err( GetTTSettings()->pTranslateWin, TTProperties::GetSvtResId( TT_NO_CONTROL ));
2149 err.Execute();
2150 GetTTSettings()->bToTop = sal_True;
2151 }
2152
2153 }
2154 else if ( GetTTSettings()->pTranslateWin->IsNextDialog() )
2155 {
2156 pRet->GenReturn ( RET_Value, nMethodId, CUniString("1") );
2157 GetTTSettings()->pTranslateWin->ResetNextDialog();
2158 GetTTSettings()->pTranslateWin->LoseFocus();
2159 GetTTSettings()->bToTop = sal_True;
2160 }
2161 else
2162 {
2163 GetTTSettings()->pTranslateWin->EnableTranslation();
2164 pRet->GenReturn ( RET_Value, nMethodId, String() );
2165 }
2166 }
2167
GetNextOverlap(Window * pBase)2168 Window* StatementCommand::GetNextOverlap( Window* pBase )
2169 { // Findet irgendwelche Overlap-Fenster, die schlie�bar aussehen
2170 // Eventuell mu� noch die Auswahl verfeinert werden.
2171
2172 if ( pBase->GetType() != WINDOW_BORDERWINDOW )
2173 pBase = pBase->GetWindow( WINDOW_OVERLAP );
2174
2175 Window *pControl = NULL;
2176 if ( pBase->GetWindow( WINDOW_FIRSTOVERLAP ) )
2177 {
2178 pControl = GetNextOverlap( pBase->GetWindow( WINDOW_FIRSTOVERLAP ) );
2179 }
2180
2181 if ( !pControl && pBase->GetWindow( WINDOW_NEXT ) )
2182 {
2183 pControl = GetNextOverlap( pBase->GetWindow( WINDOW_NEXT ) );
2184 }
2185
2186 if ( !pControl )
2187 {
2188 Window *pTest = pBase->GetWindow( WINDOW_CLIENT );
2189 if ( IsAccessable (pTest)
2190 && pTest->IsEnabled()
2191 && pTest->IsVisible()
2192 && ((pTest->GetStyle() & WB_CLOSEABLE ) || (pBase->GetStyle() & WB_CLOSEABLE )) )
2193 return pTest;
2194 else
2195 return NULL;
2196 }
2197 else
2198 return pControl;
2199 }
2200
GetNextRecoverWin()2201 Window* StatementCommand::GetNextRecoverWin()
2202 {
2203 // �ber die TopLevelWindows der App iterieren
2204 Window* pBase = Application::GetFirstTopLevelWindow();
2205 Window *pControl = NULL;
2206 Window* pMyFirstDocFrame = NULL;
2207 while ( pBase )
2208 {
2209 // zuerst weitere Fenster auf dem Fenster suchen und schliessen
2210 pControl = GetNextOverlap( pBase );
2211 if ( pControl && pControl->GetType() == WINDOW_HELPTEXTWINDOW )
2212 {} // skip it
2213 else
2214 {
2215 if ( pControl && pControl->IsVisible() && !IsFirstDocFrame( pControl ) && !IsIMEWin( pControl ) )
2216 {
2217 Window* pTB = pControl->GetChild( 0 );
2218 if ( pControl->GetChildCount() == 1 && pTB->GetType() == WINDOW_TOOLBOX )
2219 // return pTB;
2220 ; // do not act on floating toolboxes #i38796
2221 else
2222 return pControl;
2223 }
2224
2225 // dann das Fenster selbst Schliessen
2226 // erstes DocWin �berspringen
2227 // Assumption that Doc Windows are Borderwindows and ButtonDialog and such are not
2228 if ( pBase->IsVisible() && !IsFirstDocFrame( pBase ) && pBase->GetType() != WINDOW_BORDERWINDOW && !IsIMEWin( pBase ) )
2229 return pBase;
2230
2231 if ( !pMyFirstDocFrame && IsFirstDocFrame( pBase ) )
2232 pMyFirstDocFrame = pBase;
2233 }
2234
2235 pBase = Application::GetNextTopLevelWindow( pBase );
2236 }
2237 #ifdef RESET_APPLICATION_TO_BACKING_WINDOW
2238 // close the FirstDocFrame last, It will not be closed, but the Document inside will be closed.
2239 if ( IsDocWin( pMyFirstDocFrame ) )
2240 return pMyFirstDocFrame;
2241 #endif // def RESET_APPLICATION_TO_BACKING_WINDOW
2242
2243 return NULL;
2244 }
2245
Execute()2246 sal_Bool StatementCommand::Execute()
2247 {
2248 if ( IsError )
2249 {
2250 #if OSL_DEBUG_LEVEL > 1
2251 m_pDbgWin->AddText( "Skipping Command: " );
2252 m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
2253 m_pDbgWin->AddText( "\n" );
2254 #endif
2255
2256 Advance();
2257 delete this;
2258 return sal_True;
2259 }
2260
2261 InitProfile();
2262 #if OSL_DEBUG_LEVEL > 1
2263 m_pDbgWin->AddText( "Executing Command: " );
2264 m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
2265 m_pDbgWin->AddText( "\n" );
2266 #endif
2267
2268
2269
2270
2271
2272 #if OSL_DEBUG_LEVEL > 1
2273 #define REPORT_WIN_CLOSED(pControl, aInfo) \
2274 _REPORT_WIN_CLOSED(pControl, aInfo) \
2275 m_pDbgWin->AddText( aInfo.AppendAscii(" \"").Append( pControl->GetText() ).AppendAscii("\" geschlossen, RType = ").Append( TypeString(pControl->GetType()) ).AppendAscii(", UId = ").Append( UIdString( pControl->GetUniqueOrHelpId() ) ) );
2276 #else
2277 #define REPORT_WIN_CLOSED(pControl, aInfo) _REPORT_WIN_CLOSED(pControl, aInfo)
2278 #endif
2279
2280 #define REPORT_WIN_CLOSEDc(pControl, aInfo ) \
2281 REPORT_WIN_CLOSED(pControl, CUniString(aInfo) )
2282
2283 #define _REPORT_WIN_CLOSED(pControl, aInfo) \
2284 if ( aString1.Len() ) \
2285 aString1 += '\n'; \
2286 aString1 += aInfo; \
2287 aString1.AppendAscii(" \""); \
2288 aString1 += pControl->GetText(); \
2289 aString1.AppendAscii("\" geschlossen, RType = ");\
2290 aString1 += TypeString(pControl->GetType()); \
2291 aString1.AppendAscii(", UId = "); \
2292 aString1 += UIdString(pControl->GetUniqueOrHelpId());
2293
2294
2295 switch ( nMethodId )
2296 {
2297 case RC_AppDelay:
2298 if ( !bBool1 )
2299 {
2300 nLNr1 = Time().GetTime() + nNr1/10;
2301 bBool1 = sal_True;
2302 }
2303 if ( Time().GetTime() < long(nLNr1) ) // Aktuelle Zeit kleiner Endzeit
2304 return sal_False;
2305 break;
2306 case RC_DisplayHid:
2307 if ( DisplayHID() )
2308 return sal_False;
2309 break;
2310 case RC_ResetApplication:
2311 {
2312 if ( !bBool1 )
2313 {
2314 nRetryCount = 150; // das sollte reichen.
2315 bBool1 = sal_True; // Nur beim ersten mal!
2316 nNr1 = 1; // Welcher Button ist dran?
2317 nLNr1 = 0; // Speichern des AppWin
2318 aString1 = UniString(); // Liste der geschlossenen Fenster
2319
2320 // So da� nacher auch wieder alles auf Default steht
2321 nUseBindings = 0;
2322 bCatchGPF = sal_True;
2323 bUsePostEvents = sal_True;
2324
2325 aSubMenuId1 = 0;
2326 aSubMenuId2 = 0;
2327 aSubMenuId3 = 0;
2328 pMenuWindow = NULL;
2329 }
2330 if ( !nRetryCount )
2331 ReportError( GEN_RES_STR0( S_RESETAPPLICATION_FAILED_COMPLEX ) );
2332
2333 Window *pControl = GetNextRecoverWin();
2334
2335 if ( pControl )
2336 {
2337 bBool2 = sal_False; // flag for wait when all windows are closed
2338 pControl->GrabFocus();
2339
2340 if ( pControl->GetType() != WINDOW_DOCKINGWINDOW
2341 && pControl->GetType() != WINDOW_FLOATINGWINDOW
2342 && pControl->GetType() != WINDOW_MODELESSDIALOG
2343 && pControl->GetType() != WINDOW_WORKWINDOW
2344 && pControl->GetType() != WINDOW_TOOLBOX
2345 && pControl->GetType() != WINDOW_BORDERWINDOW
2346 && nRetryCount-- )
2347 {
2348 short nRT = ImpGetRType( pControl );
2349
2350 if ( nRT == C_TabControl && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_TABDIALOG )
2351 { // Bei Tabcontrol den zugeh�rigen Tabdialog nehmen
2352 pControl = pControl->GET_REAL_PARENT();
2353 nRT = ImpGetRType( pControl );
2354 }
2355
2356 switch( nRT )
2357 {
2358 case C_ModalDlg:
2359 case C_Dialog:
2360 case C_TabDlg:
2361 REPORT_WIN_CLOSEDc(pControl, "Dialog");
2362 SET_WINP_CLOSING(pControl);
2363 ((SystemWindow*)pControl)->Close();
2364 break;
2365 case C_WorkWin:
2366 break;
2367 case C_MessBox:
2368 case C_InfoBox:
2369 case C_WarningBox:
2370 case C_ErrorBox:
2371 case C_QueryBox:
2372 case C_ButtonDialog:
2373 {
2374 ButtonDialog* pBD = (ButtonDialog*)pControl;
2375 // nNr1 >= 10 bedeutet (Custom)-Buttons durchgehen
2376 if ( nNr1 >= 10+pBD->GetButtonCount() ) nNr1 = 1;
2377 switch( nNr1 )
2378 {
2379 case 5:
2380 if ( pBD->GetPushButton( BUTTONID_OK ) )
2381 {
2382 REPORT_WIN_CLOSEDc(pControl, "Message Box (OK)");
2383 SET_WINP_CLOSING(pControl);
2384 pBD->EndDialog(RET_OK);
2385 }
2386 nNr1 = 10; // Nochmal alle Buttons der Reihe nach
2387 break;
2388 case 4:
2389 if ( pBD->GetPushButton( BUTTONID_CANCEL ) )
2390 {
2391 REPORT_WIN_CLOSEDc(pControl, "Message Box (Cancel)");
2392 SET_WINP_CLOSING(pControl);
2393 pBD->EndDialog(RET_CANCEL);
2394 }
2395 nNr1++;
2396 break;
2397 case 3:
2398 if ( pBD->GetPushButton( BUTTONID_YES ) )
2399 {
2400 REPORT_WIN_CLOSEDc(pControl, "Message Box (Yes)");
2401 SET_WINP_CLOSING(pControl);
2402 pBD->EndDialog(RET_YES);
2403 }
2404 nNr1++;
2405 break;
2406 case 2: // BUG 48239
2407 case 1:
2408 if ( pBD->GetPushButton( BUTTONID_NO ) )
2409 {
2410 REPORT_WIN_CLOSEDc(pControl, "Message Box (No)");
2411 SET_WINP_CLOSING(pControl);
2412 pBD->EndDialog(RET_NO);
2413 }
2414 nNr1++;
2415 break;
2416 default:
2417 {
2418 sal_uInt16 nID = pBD->GetButtonId( nNr1-10 );
2419 if ( nID != BUTTONID_HELP )
2420 {
2421 REPORT_WIN_CLOSED(pControl, CUniString("Message Box (").Append( UniString::CreateFromInt32(nID) ).AppendAscii(")"));
2422 SET_WINP_CLOSING(pControl);
2423 pBD->EndDialog(nID);
2424 }
2425 nNr1++;
2426 }
2427 }
2428 break;
2429 }
2430 default:
2431 DBG_ERROR( "Unknown Windowtype" );
2432 REPORT_WIN_CLOSEDc(pControl, "Unknown Windowtype");
2433 ReportError( GEN_RES_STR0( S_RESETAPPLICATION_FAILED_UNKNOWN ), pControl->GetType() );
2434 #if OSL_DEBUG_LEVEL > 1
2435 m_pDbgWin->AddText( " Unbekannter Objekttyp aus UId" );
2436 #endif
2437 break;
2438 }
2439 return sal_False;
2440 }
2441 else
2442 {
2443 if ( (pControl->GetType() == WINDOW_DOCKINGWINDOW || pControl->GetType() == WINDOW_TOOLBOX) && nRetryCount-- )
2444 {
2445 if ( (((DockingWindow*)pControl)->GetStyle() | ((DockingWindow*)pControl)->GetFloatStyle()) & WB_CLOSEABLE )
2446 {
2447 REPORT_WIN_CLOSED(pControl, TypeString(pControl->GetType()));
2448 SET_WINP_CLOSING(pControl);
2449 ((DockingWindow*)pControl)->Close();
2450
2451 // Eigentlich nur bei TaskWindows! Hoffen wir mal, da� keine anderen DockingWindows dazwischen hauen.
2452 if ( (Window*)nLNr1 != pControl )
2453 nNr1 = 1; // Zum durchprobieren der Buttons beim Schlie�en
2454 nLNr1 = (sal_uLong)pControl;
2455
2456 return sal_False;
2457 }
2458 }
2459 if ( nRetryCount--
2460 && ( (pControl->GetType() == WINDOW_FLOATINGWINDOW)
2461 || (pControl->GetType() == WINDOW_MODELESSDIALOG)
2462 || (pControl->GetType() == WINDOW_WORKWINDOW)
2463 || (pControl->GetType() == WINDOW_BORDERWINDOW) ) )
2464 {
2465 // if ( pControl->GetStyle() & WB_CLOSEABLE )
2466 {
2467 #ifdef RESET_APPLICATION_TO_BACKING_WINDOW
2468 // Special handling for last Document; do not close the Frame, only the Document
2469 if ( GetDocWinCount() == 1 && IsDocFrame( pControl ) )
2470 {
2471 if ( IsDocWin( pControl ) )
2472 {
2473 if ( GetDocFrameMenuBar( pControl ) )
2474 {
2475 MenuBar* pMenu = GetDocFrameMenuBar( pControl );
2476 if ( pMenu->HasCloser() )
2477 {
2478 REPORT_WIN_CLOSED( pControl, TypeString(pControl->GetType()));
2479 SET_WINP_CLOSING(pControl);
2480
2481 pMenu->GetCloserHdl().Call( pMenu );
2482
2483 // nur bei TaskWindows!
2484 if ( (Window*)nLNr1 != pControl )
2485 nNr1 = 1; // Zum durchprobieren der Buttons beim Schlie�en
2486 nLNr1 = (sal_uLong)pControl;
2487
2488 return sal_False;
2489 }
2490 }
2491 }
2492 }
2493 else
2494 #endif // def RESET_APPLICATION_TO_BACKING_WINDOW
2495 {
2496 REPORT_WIN_CLOSED( pControl, TypeString(pControl->GetType()));
2497 SET_WINP_CLOSING(pControl);
2498 ((SystemWindow*)pControl)->Close();
2499
2500 // Eigentlich nur bei TaskWindows!
2501 if ( (Window*)nLNr1 != pControl )
2502 nNr1 = 1; // Zum durchprobieren der Buttons beim Schlie�en
2503 nLNr1 = (sal_uLong)pControl;
2504
2505 return sal_False;
2506 }
2507 }
2508 }
2509 }
2510 }
2511 // wait for some time if more windows show up
2512 // E.g.: Floating toolbars on a Task which was hidden by another Task before
2513 if ( !bBool2 )
2514 {
2515 nLNr1 = Time().GetTime() + 100; // 100 = 1 Second
2516 bBool2 = sal_True;
2517 }
2518 if ( Time().GetTime() < long(nLNr1) ) // Aktuelle Zeit kleiner Endzeit
2519 return sal_False;
2520 else
2521 pRet->GenReturn ( RET_Value, nMethodId, aString1);
2522 }
2523 break;
2524 case RC_WaitSlot:
2525 {
2526 if ( ! (nParams & PARAM_USHORT_1) )
2527 nNr1 = 1000; // defaults to 1000 = 1 Sec.
2528 if ( !bBool1 )
2529 {
2530 nLNr1 = Time().GetTime() + nNr1/10;
2531 bBool1 = sal_True;
2532 }
2533
2534 if ( !bIsSlotInExecute )
2535 pRet->GenReturn ( RET_Value, nMethodId, comm_USHORT(CONST_WSFinished) );
2536 else
2537 {
2538 if ( Time().GetTime() < long(nLNr1) ) // Aktuelle Zeit kleiner Endzeit
2539 return sal_False;
2540 pRet->GenReturn ( RET_Value, nMethodId, comm_USHORT(CONST_WSTimeout) );
2541 }
2542 }
2543 break;
2544 }
2545
2546
2547 Advance();
2548
2549
2550 switch ( nMethodId )
2551 {
2552 case RC_AppDelay: // Diese Befehle werden anderswo behandelt
2553 case RC_DisplayHid:
2554 case RC_ResetApplication:
2555 case RC_WaitSlot:
2556
2557 case RC_AppAbort: // Sofortiges L�schen aller Befehle
2558 break;
2559 case RC_Assert:
2560 {
2561 ByteString aAssertion( "Diese Assertion wurde vom Testtool per Befehl ausgel�st" );
2562 aAssertion = ByteString( String( aAssertion, RTL_TEXTENCODING_MS_1252 ), RTL_TEXTENCODING_UTF8 );
2563 DBG_ASSERT( !aString1.Len(), ByteString( aString1, RTL_TEXTENCODING_UTF8 ).GetBuffer() );
2564 DBG_ASSERT( aString1.Len(), aAssertion.GetBuffer() );
2565 OSL_ENSURE( !aString1.Len(), ByteString( aString1, RTL_TEXTENCODING_UTF8 ).GetBuffer() );
2566 OSL_ENSURE( aString1.Len(), aAssertion.GetBuffer() );
2567 }
2568 break;
2569 case RC_CaptureAssertions:
2570 #ifdef DBG_UTIL
2571 if( !(nParams & PARAM_BOOL_1) || bBool1 )
2572 {
2573 DBG_INSTOUTERROR( DBG_OUT_TESTTOOL );
2574 osl_setDebugMessageFunc( osl_TestToolDebugPrint );
2575 }
2576 else
2577 {
2578 DBG_INSTOUTERROR( DBG_OUT_MSGBOX );
2579 osl_setDebugMessageFunc( pOriginal_osl_DebugMessageFunc );
2580 }
2581 #endif
2582 break;
2583 case RC_Translate:
2584 Translate();
2585 break;
2586 case RC_ApplicationBusy:
2587 {
2588 sal_Bool bWait = sal_False;
2589 ReportError( GEN_RES_STR0( S_NO_ACTIVE_WINDOW ) );
2590 // if ( Application::GetAppWindow() )
2591 // bWait = Application::GetAppWindow()->IsWait();
2592 pRet->GenReturn ( RET_Value, nMethodId, bWait );
2593 break;
2594 }
2595 case RC_GetClipboard:
2596 {
2597 ::rtl::OUString aTemp;
2598 ::svt::OStringTransfer::PasteString( aTemp, GetFirstDocFrame() );
2599 pRet->GenReturn ( RET_Value, nMethodId, String( aTemp ) );
2600 }
2601 break;
2602 case RC_SetClipboard:
2603 ::svt::OStringTransfer::CopyString(aString1,GetFirstDocFrame());
2604 break;
2605 case RC_WinTree:
2606 pRet->GenReturn ( RET_Value, nMethodId, Tree( NULL, 0));
2607 break;
2608 #if OSL_DEBUG_LEVEL > 1
2609 case RC_NoDebug:
2610 m_pDbgWin->bQuiet = sal_True;
2611 m_pDbgWin->Hide();
2612 m_pDbgWin->Clear();
2613 break;
2614 case RC_Debug:
2615 m_pDbgWin->bQuiet = sal_False;
2616 m_pDbgWin->Show();
2617 break;
2618 #endif
2619 case RC_GPF:
2620 ((TabControl*)NULL)->SetCurPageId( 12345 );
2621 break;
2622 case RC_GetNextCloseWindow:
2623 {
2624 Window *pWin = GetActive( WINDOW_BASE ); // WINDOW_ANYTYPE
2625 if ( !pWin )
2626 ReportError( GEN_RES_STR0( S_NO_ACTIVE_WINDOW ) );
2627 else if ( !IsDialog(pWin) )
2628 ReportError( GEN_RES_STR0( S_NO_DIALOG_IN_GETACTIVE ) );
2629 else
2630 {
2631 pRet->GenReturn( RET_Value, nMethodId, Id2Str(pWin->GetUniqueOrHelpId()) );
2632 }
2633 }
2634 break;
2635 case RC_UseBindings:
2636 if( !(nParams & PARAM_BOOL_1) || bBool1 )
2637 nUseBindings = SFX_USE_BINDINGS;
2638 else
2639 nUseBindings = 0;
2640 break;
2641 case RC_Profile:
2642 // Bei folgenden Parametern passiert folgendes:
2643 // ein boolean=false Alles Profiling stoppen (Ergebnisse liefern)
2644 // ein boolean=true, 1-4 ints Einteilung der Zeiten in K�stchen
2645 // kein! boolean keine ints loggen jeden Befehls
2646 // kein! boolean 1 int loggen alle int Millisekunden
2647 // ein String wird in das Logfile �bernommen(sonst passiert nichts)
2648 if( !(nParams & PARAM_BOOL_1) || bBool1 )
2649 {
2650 if ( !pProfiler )
2651 {
2652 pProfiler = new TTProfiler;
2653 InitProfile();
2654 }
2655
2656 if( !(nParams & PARAM_BOOL_1) && (nParams & PARAM_USHORT_1) )
2657 { // Autoprofiling: Profile nNr
2658 if ( pProfiler->IsProfilingPerCommand() )
2659 {
2660 pProfiler->StopProfilingPerCommand();
2661 }
2662 pProfiler->StartAutoProfiling( nNr1 );
2663
2664 // Der Header ist abh�ngig vom Modus
2665 pRet->GenReturn( RET_ProfileInfo, 0, pProfiler->GetProfileHeader() );
2666 }
2667 else if ( nParams & PARAM_USHORT_1 )
2668 { // Partitioning initialisieren: Profile true [,nNr][,nNr][,nNr][,nNr]
2669 comm_ULONG nAnzahl=0;
2670 if ( nParams & PARAM_USHORT_1 ) { nAnzahl++; };
2671 if ( nParams & PARAM_USHORT_2 ) { nAnzahl++; };
2672 if ( nParams & PARAM_USHORT_3 ) { nAnzahl++; };
2673 if ( nParams & PARAM_USHORT_4 ) { nAnzahl++; };
2674
2675 // Hier werden die Parameter ans Testtool zur�ck �bertragen.
2676 // Das ist zwar etwas eigenartig, aber ansonsten m�sste man im Testtool
2677 // die einfache Struktur der Remotebefehle aufbrechen.
2678 pRet->GenReturn( RET_ProfileInfo, S_ProfileReset, nAnzahl );
2679
2680 // Und die einzelnen Grenzen
2681 if ( nParams & PARAM_USHORT_1 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder1, (comm_ULONG)nNr1 ); };
2682 if ( nParams & PARAM_USHORT_2 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder2, (comm_ULONG)nNr2 ); };
2683 if ( nParams & PARAM_USHORT_3 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder3, (comm_ULONG)nNr3 ); };
2684 if ( nParams & PARAM_USHORT_4 ) { pRet->GenReturn( RET_ProfileInfo, S_ProfileBorder4, (comm_ULONG)nNr4 ); };
2685
2686 pProfiler->StartPartitioning();
2687 }
2688 else if( nParams == PARAM_STR_1 ) // Genau ein String!
2689 { // Nur einen String ins Profiling aufnehmen
2690 aString1 += '\n';
2691 pRet->GenReturn( RET_ProfileInfo, 0, aString1 );
2692 }
2693 else
2694 { // Normales Profiling je Kommando: profile
2695 if ( pProfiler->IsAutoProfiling() )
2696 {
2697 pRet->GenReturn( RET_ProfileInfo, 0, pProfiler->GetAutoProfiling() );
2698 pProfiler->StopAutoProfiling();
2699 }
2700 pProfiler->StartProfilingPerCommand();
2701
2702 // Der Header ist abh�ngig vom Modus
2703 pRet->GenReturn( RET_ProfileInfo, 0, pProfiler->GetProfileHeader() );
2704 }
2705 }
2706 else // Profiling wieder ausschalten: Profile false
2707 if ( pProfiler )
2708 {
2709 if ( pProfiler->IsProfilingPerCommand() )
2710 pProfiler->StopProfilingPerCommand();
2711
2712 if ( pProfiler->IsAutoProfiling() )
2713 {
2714 pRet->GenReturn( RET_ProfileInfo, 0, pProfiler->GetAutoProfiling() );
2715 pProfiler->StopAutoProfiling();
2716 }
2717
2718 if ( pProfiler->IsPartitioning() )
2719 {
2720 pRet->GenReturn( RET_ProfileInfo, S_ProfileDump, (comm_ULONG)0 );
2721 pProfiler->StopPartitioning();
2722 }
2723
2724 delete pProfiler;
2725 pProfiler = NULL;
2726 }
2727 break;
2728 case RC_MenuGetItemCount:
2729 case RC_MenuGetItemId:
2730 case RC_MenuGetItemPos:
2731 case RC_MenuIsSeperator:
2732 case RC_MenuIsItemChecked:
2733 case RC_MenuIsItemEnabled:
2734 case RC_MenuGetItemText:
2735 case RC_MenuGetItemCommand:
2736 case RC_MenuHasSubMenu:
2737 case RC_MenuSelect:
2738 {
2739 PopupMenu *pPopup = NULL;
2740 MenuBar *pMenuBar = NULL;
2741 Menu *pMenu;
2742
2743 sal_uInt16 nErr = GetCurrentMenues( pPopup, pMenuBar, pMenu );
2744
2745 if ( !pMenu )
2746 {
2747 if ( nErr == 1 )
2748 ReportError( GEN_RES_STR0( S_NO_POPUP ) );
2749 else
2750 ReportError( GEN_RES_STR0( S_NO_SUBMENU ) );
2751 break;
2752 }
2753
2754 sal_uInt16 nItemCount = 0;
2755 switch ( nMethodId )
2756 {
2757 case RC_MenuGetItemCount:
2758 case RC_MenuGetItemId:
2759 case RC_MenuIsSeperator:
2760 {
2761 nItemCount = pMenu->GetItemCount();
2762 if ( pMenu->GetMenuFlags() & MENU_FLAG_HIDEDISABLEDENTRIES )
2763 { // jep, we have to adjust the count
2764 sal_Bool bLastWasSeperator = sal_True; // sal_True for Separator at the top
2765 for ( sal_uInt16 i = 0 ; i < pMenu->GetItemCount() ; i++ )
2766 {
2767 if ( !pMenu->IsItemEnabled( pMenu->GetItemId( i ) ) )
2768 nItemCount--;
2769 else
2770 {
2771 if ( pMenu->GetItemType( i ) == MENUITEM_SEPARATOR && bLastWasSeperator )
2772 nItemCount--;
2773 bLastWasSeperator = pMenu->GetItemType( i ) == MENUITEM_SEPARATOR;
2774 }
2775 }
2776 if ( bLastWasSeperator ) // Separator at bottom
2777 nItemCount--;
2778 }
2779 }
2780 break;
2781 }
2782
2783 // for certain methods calculate the physical index (reinserting the hidden entries)
2784 sal_uInt16 nPhysicalIndex = 0;
2785 switch ( nMethodId )
2786 {
2787 case RC_MenuGetItemId:
2788 case RC_MenuIsSeperator:
2789 {
2790 nPhysicalIndex = nNr1;
2791 if ( pMenu->GetMenuFlags() & MENU_FLAG_HIDEDISABLEDENTRIES )
2792 { // jep, we have to adjust the position
2793 sal_Bool bLastWasSeperator = sal_True; // sal_True for Separator at the top
2794 sal_uInt16 nVisibleCount = 0;
2795 for ( sal_uInt16 i = 0 ; i < pMenu->GetItemCount() && nVisibleCount < nNr1 ; i++ )
2796 {
2797 if ( pMenu->IsItemEnabled( pMenu->GetItemId( i ) )
2798 && !( pMenu->GetItemType( i ) == MENUITEM_SEPARATOR && bLastWasSeperator ) )
2799 {
2800 nVisibleCount++;
2801 bLastWasSeperator = pMenu->GetItemType( i ) == MENUITEM_SEPARATOR;
2802 }
2803 else
2804 nPhysicalIndex++;
2805 }
2806 DBG_ASSERT( nVisibleCount == nNr1, "Adaption of Index failed: nVisibleCount != nNr1" );
2807 }
2808 }
2809 break;
2810 }
2811
2812
2813
2814 switch ( nMethodId )
2815 {
2816 case RC_MenuGetItemCount:
2817 {
2818 pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)nItemCount );
2819 }
2820 break;
2821 case RC_MenuGetItemId:
2822 {
2823 if ( ValueOK( rtl::OString(), RcString( nMethodId ),nNr1,nItemCount) )
2824 pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)pMenu->GetItemId(nPhysicalIndex-1) );
2825 }
2826 break;
2827 case RC_MenuGetItemPos:
2828 {
2829 sal_uInt16 nLogicalPos = pMenu->GetItemPos(nNr1);
2830 if ( MENU_ITEM_NOTFOUND != nLogicalPos && pMenu->GetMenuFlags() & MENU_FLAG_HIDEDISABLEDENTRIES )
2831 { // jep, we have to adjust the position
2832 if ( !pMenu->IsItemEnabled( nNr1 ) )
2833 nLogicalPos = MENU_ITEM_NOTFOUND;
2834 else
2835 {
2836 sal_Bool bLastWasSeperator = sal_False;
2837 for ( int i = nLogicalPos ; i >= 0 ; i-- )
2838 {
2839 if ( !pMenu->IsItemEnabled( pMenu->GetItemId( sal::static_int_cast< sal_uInt16 >(i) ) ) ||
2840 ( pMenu->GetItemType( sal::static_int_cast< sal_uInt16 >(i) ) == MENUITEM_SEPARATOR && bLastWasSeperator ) )
2841 nLogicalPos--;
2842 bLastWasSeperator = pMenu->GetItemType( sal::static_int_cast< sal_uInt16 >(i) ) == MENUITEM_SEPARATOR;
2843 }
2844 }
2845 }
2846 pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)(nLogicalPos+1) );
2847 }
2848 break;
2849 case RC_MenuIsSeperator:
2850 {
2851 if ( ValueOK( rtl::OString(), RcString( nMethodId ),nNr1,nItemCount) )
2852 pRet->GenReturn ( RET_Value, nMethodId, (comm_BOOL)(pMenu->GetItemType(nPhysicalIndex-1) == MENUITEM_SEPARATOR) );
2853 }
2854 break;
2855 case RC_MenuIsItemChecked:
2856 {
2857 pRet->GenReturn ( RET_Value, nMethodId, (comm_BOOL)pMenu->IsItemChecked(nNr1) );
2858 }
2859 break;
2860 case RC_MenuIsItemEnabled:
2861 {
2862 pRet->GenReturn ( RET_Value, nMethodId, (comm_BOOL)pMenu->IsItemEnabled(nNr1) );
2863 }
2864 break;
2865 case RC_MenuGetItemText:
2866 {
2867 pRet->GenReturn ( RET_Value, nMethodId, (String)pMenu->GetItemText(nNr1) );
2868 }
2869 break;
2870 case RC_MenuGetItemCommand:
2871 {
2872 pRet->GenReturn ( RET_Value, nMethodId, (String)pMenu->GetItemCommand(nNr1) );
2873 }
2874 break;
2875 case RC_MenuHasSubMenu:
2876 {
2877 pRet->GenReturn ( RET_Value, nMethodId, (sal_Bool)(pMenu->GetPopupMenu(nNr1) != NULL) );
2878 }
2879 break;
2880 case RC_MenuSelect:
2881 {
2882 if ( pMenu->GetPopupMenu(nNr1) )
2883 {
2884 if ( !aSubMenuId1 )
2885 aSubMenuId1 = nNr1;
2886 else if ( !aSubMenuId2 )
2887 aSubMenuId2 = nNr1;
2888 else if ( !aSubMenuId3 )
2889 aSubMenuId3 = nNr1;
2890
2891 if ( pPopup )
2892 pPopup->SelectEntry(nNr1);
2893 else
2894 pMenuBar->SelectEntry(nNr1);
2895 }
2896 else
2897 {
2898 if ( pPopup )
2899 {
2900 pPopup->EndExecute(nNr1);
2901 aSubMenuId1 = 0;
2902 aSubMenuId2 = 0;
2903 aSubMenuId3 = 0;
2904 pMenuWindow = NULL;
2905 }
2906 else
2907 {
2908 pMenuBar->SelectEntry(nNr1);
2909 aSubMenuId1 = 0;
2910 aSubMenuId2 = 0;
2911 aSubMenuId3 = 0;
2912 pMenuWindow = NULL;
2913 }
2914 }
2915 }
2916 break;
2917 }
2918 }
2919 break;
2920 case RC_SetControlType:
2921 {
2922 DirectLog( S_QAError, GEN_RES_STR0( S_DEPRECATED ) );
2923 }
2924 break;
2925 case RC_Kill:
2926 case RC_RmDir:
2927 case RC_MkDir:
2928 case RC_FileCopy:
2929 case RC_Name:
2930 case RC_Dir:
2931 case RC_FileLen:
2932 case RC_FileDateTime:
2933 {
2934 long nErrorcode = FSYS_ERR_OK;
2935 switch ( nMethodId )
2936 {
2937 case RC_Kill:
2938 {
2939 DirEntry aFile( aString1 );
2940 nErrorcode = aFile.GetError();
2941 if ( FSYS_ERR_OK == nErrorcode && FileStat( aFile ).IsKind( FSYS_KIND_FILE ) )
2942 nErrorcode = aFile.Kill();
2943 else
2944 nErrorcode = FSYS_ERR_NOTAFILE;
2945 }
2946 break;
2947 case RC_RmDir:
2948 {
2949 DirEntry aDir( aString1 );
2950 nErrorcode = aDir.GetError();
2951 if ( FSYS_ERR_OK == nErrorcode && FileStat( aDir ).IsKind( FSYS_KIND_DIR ) )
2952 nErrorcode = aDir.Kill();
2953 else
2954 nErrorcode = FSYS_ERR_NOTADIRECTORY;
2955 }
2956 break;
2957 case RC_MkDir:
2958 {
2959 DirEntry aDir( aString1 );
2960 nErrorcode = aDir.GetError();
2961 if ( !nErrorcode && !aDir.MakeDir() )
2962 nErrorcode = FSYS_ERR_UNKNOWN;
2963 // Workaround f�r Bug 60693
2964 // nErrorcode = aDir.GetError();
2965 }
2966 break;
2967 case RC_FileCopy:
2968 {
2969 nErrorcode = DirEntry( aString1 ).CopyTo( DirEntry( aString2 ), FSYS_ACTION_COPYFILE );
2970 }
2971 break;
2972 case RC_Name:
2973 {
2974 nErrorcode = DirEntry( aString1 ).MoveTo( DirEntry( aString2 ) );
2975 }
2976 break;
2977 case RC_Dir:
2978 {
2979
2980 String aPath;
2981 sal_uInt16 nDirFlags = 0;
2982 // from basic/source/inc/runtime.hxx
2983 #define Sb_ATTR_NORMAL 0x0000
2984 #define Sb_ATTR_HIDDEN 0x0002
2985 #define Sb_ATTR_SYSTEM 0x0004
2986 #define Sb_ATTR_VOLUME 0x0008
2987 #define Sb_ATTR_DIRECTORY 0x0010
2988 #define Sb_ATTR_ARCHIVE 0x0020
2989 // copied from Basic and adapted basic/source/runtime/methods.cxx Revision 1.54
2990 if ( (nParams & PARAM_STR_1) )
2991 {
2992 delete pDir;
2993 pDir = NULL; // wg. Sonderbehandlung Sb_ATTR_VOLUME
2994 DirEntry aEntry( aString1 );
2995 FileStat aStat( aEntry );
2996 if(!aStat.GetError() && (aStat.GetKind() & FSYS_KIND_FILE))
2997 {
2998 // OK, only a filename
2999 // cut off path (VB4)
3000 aPath = aEntry.GetName();
3001 }
3002 else
3003 {
3004 sal_uInt16 nFlags = 0;
3005 if ( (nParams & PARAM_USHORT_1) )
3006 nDirFlags = nFlags = nNr1;
3007 else
3008 nDirFlags = nFlags = Sb_ATTR_HIDDEN | Sb_ATTR_SYSTEM | Sb_ATTR_DIRECTORY;
3009
3010 // Nur diese Bitmaske ist unter Windows erlaubt
3011 // Sb_ATTR_VOLUME wird getrennt gehandelt
3012 if( nDirFlags & Sb_ATTR_VOLUME )
3013 aPath = aEntry.GetVolume();
3014 else
3015 {
3016 // Die richtige Auswahl treffen
3017 sal_uInt16 nMode = FSYS_KIND_FILE;
3018 if( nFlags & Sb_ATTR_DIRECTORY )
3019 nMode |= FSYS_KIND_DIR;
3020 if( nFlags == Sb_ATTR_DIRECTORY )
3021 nMode = FSYS_KIND_DIR;
3022 pDir = new Dir( aEntry, (DirEntryKind) nMode );
3023 nErrorcode = pDir->GetError();
3024 nDirPos = 0;
3025 }
3026 }
3027 }
3028
3029 if( pDir )
3030 {
3031 for( ;; )
3032 {
3033 if( nDirPos >= pDir->Count() )
3034 {
3035 delete pDir;
3036 pDir = NULL;
3037 aPath.Erase();
3038 break;
3039 }
3040 DirEntry aNextEntry=(*(pDir))[nDirPos++];
3041 aPath = aNextEntry.GetName(); //Full();
3042 break;
3043 }
3044 }
3045 if ( !nErrorcode )
3046 {
3047 pRet->GenReturn ( RET_Value, nMethodId, aPath );
3048 }
3049
3050
3051
3052 /* keep old Implementation for now
3053 // neues Verzeichnis einlesen
3054 if ( (nParams & PARAM_STR_1) )
3055 {
3056 if ( pDir )
3057 {
3058 delete pDir;
3059 pDir = NULL;
3060 }
3061 DirEntryKind aDirEntryKind = FSYS_KIND_FILE | FSYS_KIND_DIR;
3062 if ( (nParams & PARAM_USHORT_1) && nNr1 )
3063 {
3064 if ( nNr1 & 16 )
3065 aDirEntryKind = FSYS_KIND_DIR;
3066 else
3067 ReportError( GEN_RES_STR0( S_SELECTION_BY_ATTRIBUTE_ONLY_DIRECTORIES ) );
3068 }
3069
3070 DirEntry aEntry( aString1 );
3071 nErrorcode = aEntry.GetError();
3072 if ( !nErrorcode )
3073 {
3074 nDirPos = 0;
3075 FileStat aFS( aEntry );
3076 if ( !aFS.IsKind( FSYS_KIND_WILD ) && !aFS.IsKind( FSYS_KIND_DIR ) && aEntry.Exists() )
3077 { // Sonderbehandlung f�r genau einen Eintrag
3078 if ( !aFS.IsKind( FSYS_KIND_DIR ) && ( aDirEntryKind == FSYS_KIND_DIR ) )
3079 pRet->GenReturn ( RET_Value, nMethodId, String() );
3080 else
3081 pRet->GenReturn ( RET_Value, nMethodId, (String)(aEntry.GetName()) );
3082
3083 break;
3084 }
3085 else
3086 {
3087 pDir = new Dir( aEntry, aDirEntryKind );
3088 nErrorcode = pDir->GetError();
3089 }
3090 }
3091 }
3092
3093 if ( !pDir )
3094 pDir = new Dir;
3095
3096 if ( !nErrorcode && ValueOK( nMethodId, GEN_RES_STR0( S_NO_MORE_FILES ), nDirPos+1, pDir->Count()+1 ) )
3097 {
3098 if ( nDirPos == pDir->Count() )
3099 pRet->GenReturn ( RET_Value, nMethodId, String() );
3100 else
3101 pRet->GenReturn ( RET_Value, nMethodId, (String)((*pDir)[ nDirPos ].GetName()) );
3102 nDirPos++;
3103 }*/
3104 }
3105 break;
3106 case RC_FileLen:
3107 {
3108 DirEntry aFile( aString1 );
3109 nErrorcode = aFile.GetError();
3110 if ( FSYS_ERR_OK == nErrorcode )
3111 {
3112 FileStat aFS( aFile );
3113 pRet->GenReturn ( RET_Value, nMethodId, static_cast<comm_ULONG>(aFS.GetSize()) ); //GetSize() sal_uLong != comm_ULONG on 64bit
3114 nErrorcode = aFS.GetError();
3115 }
3116 }
3117 break;
3118 case RC_FileDateTime:
3119 {
3120 DirEntry aFile( aString1 );
3121 nErrorcode = aFile.GetError();
3122 if ( FSYS_ERR_OK == nErrorcode )
3123 {
3124 FileStat aStat( aFile );
3125 Time aTime( aStat.TimeModified() );
3126 Date aDate( aStat.DateModified() );
3127 nErrorcode = aStat.GetError();
3128
3129 double fSerial = (double)( aDate - Date(30,12,1899) );
3130 long nSeconds = aTime.GetHour();
3131 nSeconds *= 3600;
3132 nSeconds += aTime.GetMin() * 60;
3133 nSeconds += aTime.GetSec();
3134 double nDays = ((double)nSeconds) / (double)(24.0*3600.0);
3135 fSerial += nDays;
3136
3137 SbxValueRef xValue = new SbxValue( SbxDATE );
3138 xValue->PutDate( fSerial );
3139
3140 pRet->GenReturn ( RET_Value, nMethodId, *xValue );
3141 }
3142 }
3143 break;
3144 }
3145 switch ( nErrorcode )
3146 {
3147 case FSYS_ERR_OK:
3148 break;
3149 case FSYS_ERR_MISPLACEDCHAR:
3150 {
3151 ReportError( CUniString("MISPLACEDCHAR") );
3152 }
3153 break;
3154 case FSYS_ERR_INVALIDCHAR:
3155 {
3156 ReportError( CUniString("INVALIDCHAR") );
3157 }
3158 break;
3159 case FSYS_ERR_NOTEXISTS:
3160 {
3161 ReportError( CUniString("NOTEXISTS") );
3162 }
3163 break;
3164 case FSYS_ERR_ALREADYEXISTS:
3165 {
3166 ReportError( CUniString("ALREADYEXISTS") );
3167 }
3168 break;
3169 case FSYS_ERR_NOTADIRECTORY:
3170 {
3171 ReportError( CUniString("NOTADIRECTORY") );
3172 }
3173 break;
3174 case FSYS_ERR_NOTAFILE:
3175 {
3176 ReportError( CUniString("NOTAFILE") );
3177 }
3178 break;
3179 case FSYS_ERR_INVALIDDEVICE:
3180 {
3181 ReportError( CUniString("INVALIDDEVICE") );
3182 }
3183 break;
3184 case FSYS_ERR_ACCESSDENIED:
3185 {
3186 ReportError( CUniString("ACCESSDENIED") );
3187 }
3188 break;
3189 case FSYS_ERR_LOCKVIOLATION:
3190 {
3191 ReportError( CUniString("LOCKVIOLATION") );
3192 }
3193 break;
3194 case FSYS_ERR_VOLUMEFULL:
3195 {
3196 ReportError( CUniString("VOLUMEFULL") );
3197 }
3198 break;
3199 case FSYS_ERR_ISWILDCARD:
3200 {
3201 ReportError( CUniString("ISWILDCARD") );
3202 }
3203 break;
3204 case FSYS_ERR_NOTSUPPORTED:
3205 {
3206 ReportError( CUniString("NOTSUPPORTED") );
3207 }
3208 break;
3209 case FSYS_ERR_UNKNOWN:
3210 {
3211 ReportError( CUniString("UNKNOWN") );
3212 }
3213 break;
3214 default:
3215 {
3216 ReportError( CUniString("Not an FSYS Error") );
3217 }
3218 }
3219
3220 }
3221 break;
3222 case RC_TypeKeysDelay:
3223 {
3224 if( (nParams & PARAM_BOOL_1) )
3225 {
3226 bDoTypeKeysDelay = bBool1;
3227 }
3228 else if( nParams & PARAM_USHORT_1 )
3229 {
3230 nMinTypeKeysDelay = nNr1;
3231 if( nParams & PARAM_USHORT_2 )
3232 nMaxTypeKeysDelay = nNr2;
3233 else
3234 nMaxTypeKeysDelay = nMinTypeKeysDelay;
3235 }
3236 else
3237 ReportError( GEN_RES_STR0( S_INVALID_PARAMETERS ) );
3238 }
3239 break;
3240 case RC_GetMouseStyle:
3241 {
3242 Pointer aPointer;
3243 // if ( DragManager::GetDragManager() )
3244 // aPointer = DragManager::GetDragManager()->GetDragPointer();
3245 // else
3246 {
3247 Window *pActualWin = GetMouseWin();
3248 if ( pActualWin )
3249 aPointer = pActualWin->GetPointer();
3250 else
3251 {
3252 ReportError( GEN_RES_STR1( S_POINTER_OUTSIDE_APPWIN, RcString( nMethodId ) ) );
3253 aPointer = Pointer( POINTER_NULL );
3254 }
3255 }
3256 pRet->GenReturn ( RET_Value, nMethodId, (comm_ULONG)aPointer.GetStyle() );
3257 }
3258 break;
3259 case RC_UnpackStorage:
3260 {
3261 if( (nParams & PARAM_STR_1) )
3262 {
3263 String aFileName( aString1 );
3264 DirEntry aDestPath;
3265 if( (nParams & PARAM_STR_2) )
3266 aDestPath = DirEntry( aString2 );
3267 else
3268 {
3269 aDestPath = DirEntry( aFileName );
3270 aDestPath.SetExtension( CUniString( "plaintext" ) );
3271 }
3272
3273 #if OSL_DEBUG_LEVEL > 1
3274 sal_uInt16 nEntries = Dir( aDestPath, FSYS_KIND_FILE | FSYS_KIND_DIR ).Count();
3275 (void) nEntries; /* avoid warning about unused parameter */
3276 #endif
3277 // The Count is only larger than 2 is the path is a directory which is not empty
3278 // the Count of 2 results from the "." and ".." directory
3279 if ( Dir( aDestPath, FSYS_KIND_FILE | FSYS_KIND_DIR ).Count() > 2 )
3280 DirectLog( S_QAError, GEN_RES_STR1( S_DIRECTORY_NOT_EMPTY, aDestPath.GetFull() ) );
3281
3282 SotStorageRef xStorage = new SotStorage( aFileName, STREAM_STD_READ );
3283 if ( xStorage->GetError() )
3284 ReportError( GEN_RES_STR2(S_UNPACKING_STORAGE_FAILED, aFileName, aDestPath.GetFull()) );
3285 else
3286 UnpackStorage( xStorage, aDestPath );
3287 }
3288 else
3289 ReportError( GEN_RES_STR0( S_INVALID_PARAMETERS ) );
3290 }
3291 break;
3292 case RC_CloseSysDialog:
3293 case RC_ExistsSysDialog:
3294 {
3295 if( (nParams & PARAM_USHORT_1) )
3296 {
3297 Reference < ::com::sun::star::util::XCancellable > xPicker;
3298 switch( nNr1 )
3299 {
3300 case CONST_FilePicker:
3301 {
3302 xPicker.set( Reference < ::com::sun::star::util::XCancellable >( svt::GetTopMostFilePicker(), UNO_QUERY ) );
3303 }
3304 break;
3305 case CONST_FolderPicker:
3306 {
3307 xPicker.set( Reference < ::com::sun::star::util::XCancellable >( svt::GetTopMostFolderPicker(), UNO_QUERY ) );
3308 }
3309 break;
3310 default:
3311 ReportError( GEN_RES_STR0( S_INVALID_PARAMETERS ) );
3312 }
3313 switch( nMethodId )
3314 {
3315 case RC_CloseSysDialog:
3316 {
3317 if ( xPicker.is() )
3318 xPicker->cancel();
3319 else
3320 ReportError( GEN_RES_STR0( S_INVALID_PARAMETERS ) );
3321 }
3322 break;
3323 case RC_ExistsSysDialog:
3324 {
3325 pRet->GenReturn ( RET_Value, nMethodId, (comm_BOOL)xPicker.is() );
3326 }
3327 break;
3328 default:
3329 ReportError( GEN_RES_STR0( S_INVALID_PARAMETERS ) );
3330 }
3331 }
3332 else
3333 ReportError( GEN_RES_STR0( S_INVALID_PARAMETERS ) );
3334 }
3335 break;
3336 case RC_SAXCheckWellformed:
3337 case RC_SAXReadFile:
3338
3339 case RC_SAXGetNodeType:
3340 case RC_SAXGetAttributeCount:
3341 case RC_SAXGetAttributeName:
3342 case RC_SAXGetAttributeValue:
3343 case RC_SAXGetChildCount:
3344 case RC_SAXGetElementName:
3345 case RC_SAXGetChars:
3346
3347 case RC_SAXSeekElement:
3348 case RC_SAXHasElement:
3349 case RC_SAXGetElementPath:
3350
3351 case RC_SAXRelease:
3352 {
3353 HandleSAXParser();
3354 }
3355 break;
3356 case RC_RecordMacro:
3357 {
3358 if ( ! (nParams & PARAM_BOOL_1) )
3359 bBool1 = sal_True;
3360
3361 MacroRecorder::GetMacroRecorder()->SetActionRecord( bBool1 );
3362 }
3363 break;
3364 case RC_GetDocumentCount :
3365 {
3366 pRet->GenReturn ( RET_Value, nMethodId, (comm_USHORT)GetDocWinCount() );
3367 }
3368 break;
3369 case RC_ActivateDocument :
3370 {
3371 if( nParams & PARAM_USHORT_1 )
3372 {
3373 if ( ValueOK( rtl::OString(), RcString( nMethodId ), nNr1, GetDocWinCount() ) )
3374 {
3375 Window* pWin = GetDocWin( nNr1-1 );
3376 if ( pWin )
3377 {
3378 pWin->ToTop();
3379 pWin->GrabFocus();
3380 }
3381 }
3382 }
3383 else
3384 ReportError( GEN_RES_STR0( S_INVALID_PARAMETERS ) );
3385 }
3386 break;
3387 case RC_GetSystemLanguage :
3388 {
3389 pRet->GenReturn ( RET_Value, nMethodId, (comm_USHORT)Application::GetSettings().GetLanguage() );
3390 }
3391 break;
3392 case RC_CatchGPF :
3393 {
3394 if( (nParams & PARAM_BOOL_1) )
3395 bCatchGPF = bBool1;
3396 else
3397 bCatchGPF = sal_True;
3398 }
3399 break;
3400 case RC_IsProduct :
3401 {
3402 sal_Bool bIsProduct;
3403 #ifdef DBG_UTIL
3404 bIsProduct = sal_False;
3405 #else
3406 bIsProduct = sal_True;
3407 #endif
3408 pRet->GenReturn ( RET_Value, nMethodId, (sal_Bool)bIsProduct );
3409 }
3410 break;
3411 case RC_UsePostEvents :
3412 {
3413 if( (nParams & PARAM_BOOL_1) )
3414 bUsePostEvents = bBool1;
3415 else
3416 bUsePostEvents = sal_True;
3417 }
3418 break;
3419 default:
3420 ReportError( GEN_RES_STR1( S_UNKNOWN_COMMAND, RcString( nMethodId ) ) );
3421 }
3422 SendProfile( RcString(nMethodId) );
3423 delete this;
3424 return sal_True;
3425 }
3426
3427
UnpackStorage(SotStorageRef xStorage,DirEntry & aBaseDir)3428 sal_Bool StatementCommand::UnpackStorage( SotStorageRef xStorage, DirEntry &aBaseDir )
3429 {
3430 SvStorageInfoList aList;
3431 xStorage->FillInfoList( &aList );
3432
3433 for( sal_uInt16 i = 0; i < aList.Count(); i++ )
3434 {
3435 SvStorageInfo& rInfo = aList.GetObject( i );
3436 String aName = rInfo.GetName();
3437 DirEntry aPath ( aBaseDir );
3438 aPath += DirEntry( aName );
3439 sal_Bool bIsStorage = xStorage->IsStorage( aName );
3440 if ( bIsStorage )
3441 {
3442 SotStorageRef xSubStorage = xStorage->OpenSotStorage( aName, STREAM_STD_READ );
3443 if ( xSubStorage->GetError() )
3444 {
3445 ReportError( GEN_RES_STR2(S_UNPACKING_STORAGE_FAILED, aName, aPath.GetFull()) );
3446 return sal_False;
3447 }
3448 UnpackStorage( xSubStorage, aPath );
3449 }
3450 else
3451 {
3452 if ( !aPath.MakeDir( sal_True ) )
3453 {
3454 ReportError( GEN_RES_STR1(S_CANNOT_CREATE_DIRECTORY, aPath.GetFull()) );
3455 return sal_False;
3456 }
3457 SotStorageStreamRef xStream = xStorage->OpenSotStream( aName, STREAM_STD_READ );
3458 SvFileStream aDestination( aPath.GetFull(), STREAM_STD_READWRITE | STREAM_TRUNC );
3459 (*xStream) >> aDestination;
3460 if ( aDestination.GetError() != ERRCODE_NONE )
3461 {
3462 ReportError( GEN_RES_STR2(S_UNPACKING_STORAGE_FAILED, aName, aPath.GetFull()) );
3463 return sal_False;
3464 }
3465 aDestination.Close();
3466 }
3467 }
3468 return sal_True;
3469 }
3470
3471
3472 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
3473
StatementControl(SCmdStream * pCmdIn,sal_uInt16 nControlIdType)3474 StatementControl::StatementControl( SCmdStream *pCmdIn, sal_uInt16 nControlIdType )
3475 : StatementList()
3476 , nNr1( 0 )
3477 , nNr2( 0 )
3478 , nNr3( 0 )
3479 , nNr4( 0 )
3480 , nLNr1( 0 )
3481 , aString1()
3482 , aString2()
3483 , bBool1(sal_False)
3484 , bBool2(sal_False)
3485 {
3486 QueStatement( NULL );
3487 //HELPID BACKWARD (SIControl is no longer needed)
3488 if ( nControlIdType == SIControl )
3489 {
3490 comm_ULONG nId;
3491 pCmdIn->Read( nId );
3492 aUId = rtl::OString( nId );
3493 if ( nId == 0 )
3494 aUId = UID_ACTIVE;
3495 else
3496 ReportError( aUId, GEN_RES_STR1c( S_INTERNAL_ERROR, "using numeric HelpID from old Testtool" ) );
3497 }
3498 else if ( nControlIdType == SIStringControl )
3499 {
3500 String aId;
3501 pCmdIn->Read( aId );
3502 aUId = Str2Id( aId );
3503 }
3504 else
3505 {
3506 DBG_ERROR( "Wrong ControlType" );
3507 }
3508
3509 pCmdIn->Read( nMethodId );
3510 pCmdIn->Read( nParams );
3511
3512 if( nParams & PARAM_USHORT_1 ) pCmdIn->Read( nNr1 );
3513 if( nParams & PARAM_USHORT_2 ) pCmdIn->Read( nNr2 );
3514 if( nParams & PARAM_USHORT_3 ) pCmdIn->Read( nNr3 );
3515 if( nParams & PARAM_USHORT_4 ) pCmdIn->Read( nNr4 );
3516 if( nParams & PARAM_ULONG_1 ) pCmdIn->Read( nLNr1 );
3517 if( nParams & PARAM_STR_1 ) pCmdIn->Read( aString1 );
3518 if( nParams & PARAM_STR_2 ) pCmdIn->Read( aString2 );
3519 if( nParams & PARAM_BOOL_1 ) pCmdIn->Read( bBool1 );
3520 if( nParams & PARAM_BOOL_2 ) pCmdIn->Read( bBool2 );
3521
3522 #if OSL_DEBUG_LEVEL > 1
3523 m_pDbgWin->AddText( "Reading Control: UId: " );
3524 m_pDbgWin->AddText( Id2Str( aUId ) );
3525 m_pDbgWin->AddText( " Methode: " );
3526 m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
3527 m_pDbgWin->AddText( " Params:" );
3528 if( nParams & PARAM_USHORT_1 ) {m_pDbgWin->AddText( " n1:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr1 ) );}
3529 if( nParams & PARAM_USHORT_2 ) {m_pDbgWin->AddText( " n2:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr2 ) );}
3530 if( nParams & PARAM_USHORT_3 ) {m_pDbgWin->AddText( " n3:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr3 ) );}
3531 if( nParams & PARAM_USHORT_4 ) {m_pDbgWin->AddText( " n4:" );m_pDbgWin->AddText( String::CreateFromInt32( nNr4 ) );}
3532 if( nParams & PARAM_ULONG_1 ) {m_pDbgWin->AddText( " nl1:" );m_pDbgWin->AddText( String::CreateFromInt64( nLNr1 ) );}
3533 if( nParams & PARAM_STR_1 ) {m_pDbgWin->AddText( " s1:" );m_pDbgWin->AddText( aString1 );}
3534 if( nParams & PARAM_STR_2 ) {m_pDbgWin->AddText( " s2:" );m_pDbgWin->AddText( aString2 );}
3535 /* if( nParams & PARAM_BOOL_1 ) pCmdIn->Read( bBool1 );
3536 if( nParams & PARAM_BOOL_2 ) pCmdIn->Read( bBool2 );*/
3537 m_pDbgWin->AddText( "\n" );
3538 #endif
3539 }
3540
IsDialog(Window * pWin)3541 sal_Bool IsDialog(Window *pWin)
3542 { // Alles was von SystemWindow abgeleitet ist
3543 if ( !pWin )
3544 return sal_False;
3545
3546 switch (pWin->GetType())
3547 {
3548 case WINDOW_FLOATINGWINDOW:
3549 case WINDOW_DOCKINGWINDOW:
3550 case WINDOW_MODELESSDIALOG:
3551 case WINDOW_DIALOG:
3552 case WINDOW_MODALDIALOG:
3553 case WINDOW_WORKWINDOW:
3554 case WINDOW_TABDIALOG:
3555
3556 case WINDOW_MESSBOX:
3557 case WINDOW_INFOBOX:
3558 case WINDOW_WARNINGBOX:
3559 case WINDOW_ERRORBOX:
3560 case WINDOW_QUERYBOX:
3561 case WINDOW_BUTTONDIALOG:
3562 case WINDOW_FILEDIALOG:
3563 case WINDOW_PRINTDIALOG:
3564 case WINDOW_PRINTERSETUPDIALOG:
3565
3566 // ab hier nicht ansprechbar (da nicht implementiert)
3567 case WINDOW_SYSWINDOW:
3568 case WINDOW_SYSTEMDIALOG:
3569 case WINDOW_COLORDIALOG:
3570 case WINDOW_FONTDIALOG:
3571 case WINDOW_PATHDIALOG:
3572
3573
3574 return sal_True;
3575 // break;
3576 default:
3577 return sal_False;
3578 // break;
3579 }
3580 }
3581
3582
IsAccessable(Window * pWin)3583 sal_Bool IsAccessable(Window *pWin)
3584 {
3585 if ( pWin == NULL )
3586 return sal_False;
3587
3588 return pWin->IsEnabled() && pWin->IsInputEnabled();
3589 }
3590
3591
3592
3593 // neue Hilfsfunktion
ImpGetButton(Window * pBase,WinBits nMask,WinBits nWinBits)3594 static Window*ImpGetButton( Window *pBase, WinBits nMask, WinBits nWinBits )
3595 {
3596 sal_uInt16 n = pBase->GetChildCount();
3597 for( sal_uInt16 i = 0 ; i < n; i++ ) {
3598 Window *pChild = pBase->GetChild(i);
3599 if( pChild->GetType() == WINDOW_OKBUTTON
3600 || pChild->GetType() == WINDOW_CANCELBUTTON
3601 || pChild->GetType() == WINDOW_HELPBUTTON
3602 || pChild->GetType() == WINDOW_PUSHBUTTON )
3603 if( !nMask || ( pChild->GetStyle() & nMask ) == nWinBits )
3604 return pChild;
3605 }
3606 return NULL;
3607 }
3608
ControlOK(Window * pControl,const sal_Char * cBezeichnung)3609 sal_Bool StatementControl::ControlOK( Window *pControl, const sal_Char* cBezeichnung )
3610 {
3611 if ( pControl && ( ( ( IsAccessable(pControl) || (nMethodId & M_WITH_RETURN) ) &&
3612 pControl->IsVisible() ) ||
3613 aUId.equals( UID_ACTIVE ) ) )
3614 return sal_True;
3615 else
3616 {
3617 UniString aBezeichnung( cBezeichnung, RTL_TEXTENCODING_ASCII_US );
3618 if ( aBezeichnung.Len() > 0 )
3619 {
3620 if (!pControl)
3621 ReportError( aUId, GEN_RES_STR1( S_WIN_NOT_FOUND, aBezeichnung ) );
3622 else if ( !pControl->IsVisible() )
3623 ReportError( aUId, GEN_RES_STR1( S_WIN_INVISIBLE, aBezeichnung ) );
3624 else
3625 ReportError( aUId, GEN_RES_STR1( S_WIN_DISABLED, aBezeichnung ) );
3626 }
3627 #if OSL_DEBUG_LEVEL > 1
3628 m_pDbgWin->AddText( aBezeichnung.AppendAscii(" NotFound or Disabled or Invisible") );
3629 #endif
3630
3631 return sal_False;
3632 }
3633 }
3634
3635
ValueOK(rtl::OString aId,String aBezeichnung,sal_uLong nValue,sal_uLong nMax)3636 sal_Bool StatementList::ValueOK( rtl::OString aId, String aBezeichnung, sal_uLong nValue, sal_uLong nMax )
3637 {
3638
3639 if ( nMax < nValue )
3640 {
3641 if ( aBezeichnung.Len() > 0 )
3642 ReportError( aId, GEN_RES_STR3( S_NUMBER_TOO_BIG, aBezeichnung, UniString::CreateFromInt32( nValue ), UniString::CreateFromInt32( nMax ) ) );
3643 return sal_False;
3644 }
3645 if ( nValue < 1 )
3646 {
3647 if ( aBezeichnung.Len() > 0 )
3648 ReportError( aId, GEN_RES_STR3c3( S_NUMBER_TOO_SMALL, aBezeichnung, UniString::CreateFromInt32( nValue ), "1" ) );
3649 return sal_False;
3650 }
3651 return sal_True;
3652 }
3653
GetCurrentMenues(PopupMenu * & pPopup,MenuBar * & pMenuBar,Menu * & pMenu)3654 sal_uInt16 StatementList::GetCurrentMenues( PopupMenu *&pPopup, MenuBar *&pMenuBar, Menu *&pMenu )
3655 {
3656 if ( WinPtrValid( pMenuWindow ) )
3657 pMenuBar = pMenuWindow->GetMenuBar();
3658
3659 if ( pMenuBar ) // use MenuBar as base
3660 pMenu = pMenuBar;
3661 else // use contextmenu as base
3662 {
3663 pMenu = PopupMenu::GetActivePopupMenu();
3664 pPopup = PopupMenu::GetActivePopupMenu();
3665 }
3666
3667 if ( !pMenu )
3668 return 1;
3669
3670 if ( aSubMenuId1 )
3671 {
3672 pPopup = pMenu->GetPopupMenu( aSubMenuId1 );
3673 pMenu = pPopup;
3674 }
3675
3676 if ( pMenu && aSubMenuId2 )
3677 {
3678 pPopup = pMenu->GetPopupMenu( aSubMenuId2 );
3679 pMenu = pPopup;
3680 }
3681
3682 if ( pMenu && aSubMenuId3 )
3683 {
3684 pPopup = pMenu->GetPopupMenu( aSubMenuId3 );
3685 pMenu = pPopup;
3686 }
3687
3688 return 0;
3689 }
3690
AnimateMouse(Window * pControl,TTHotSpots aWohin)3691 void StatementControl::AnimateMouse( Window *pControl, TTHotSpots aWohin )
3692 {
3693 Point aZiel;
3694
3695 switch (aWohin)
3696 {
3697 case MitteLinks:
3698 {
3699 long nHeight = pControl->GetSizePixel().Height();
3700 aZiel.X() += 5;
3701 aZiel.Y() += nHeight / 2;
3702 }
3703 break;
3704 case Mitte:
3705 {
3706 Size aSize = pControl->GetOutputSizePixel();
3707 aZiel.Move( aSize.Width() / 2, aSize.Height() / 2 );
3708 }
3709 break;
3710 case MitteOben:
3711 {
3712 long nWidth = pControl->GetSizePixel().Width();
3713 aZiel.X() += nWidth / 2;
3714 aZiel.Y() += 5;
3715 }
3716 break;
3717 }
3718 AnimateMouse( pControl, aZiel );
3719 }
3720
3721
AnimateMouse(Window * pControl,Point aWohin)3722 void StatementControl::AnimateMouse( Window *pControl, Point aWohin )
3723 {
3724 Point aAkt = pControl->GetPointerPosPixel();
3725 Point aZiel = aWohin;
3726
3727 long nSteps;
3728 Point aDiff = aAkt - aZiel;
3729
3730 if ( Abs(aDiff.X()) < Abs(aDiff.Y()) )
3731 nSteps = Abs(aDiff.Y()) / 5;
3732 else
3733 nSteps = Abs(aDiff.X()) / 5;
3734 if ( nSteps == 0 )
3735 return;
3736
3737 aDiff *= 1000;
3738 aDiff /= nSteps;
3739
3740 StatementList::bExecuting = sal_True; // Bah ist das ein ekliger Hack
3741 // Das verhindert, da� schon der n�chste Befehl ausgef�hrt wird.
3742
3743 for ( ; nSteps ; nSteps-- )
3744 {
3745 if ( Abs((aAkt - pControl->GetPointerPosPixel()).X()) > 5 ||
3746 Abs((aAkt - pControl->GetPointerPosPixel()).Y()) > 5 )
3747 nSteps = 1;
3748 aAkt = aZiel + aDiff * nSteps / 1000;
3749 pControl->SetPointerPosPixel(aAkt);
3750 SafeReschedule();
3751 }
3752 pControl->SetPointerPosPixel(aZiel);
3753 StatementList::bExecuting = sal_False; // Bah ist das ein ekliger Hack
3754 }
3755
3756
MaybeDoTypeKeysDelay(Window * pTestWindow)3757 sal_Bool StatementControl::MaybeDoTypeKeysDelay( Window *pTestWindow )
3758 {
3759 if ( bDoTypeKeysDelay )
3760 {
3761 sal_uLong nTimeWait = nMinTypeKeysDelay;
3762 if ( nMaxTypeKeysDelay != nMinTypeKeysDelay )
3763 nTimeWait += Time::GetSystemTicks() % ( nMaxTypeKeysDelay - nMinTypeKeysDelay );
3764 Timer aTimer;
3765 aTimer.SetTimeout( nTimeWait );
3766 aTimer.Start();
3767 StatementList::bExecuting = sal_True; // Bah ist das ein ekliger Hack
3768 // Das verhindert, da� schon der n�chste Befehl ausgef�hrt wird.
3769 while ( aTimer.IsActive() )
3770 {
3771 SafeReschedule( sal_True );
3772 }
3773 StatementList::bExecuting = sal_False; // Bah ist das ein ekliger Hack
3774 if ( !WinPtrValid(pTestWindow ) )
3775 {
3776 ReportError( aUId, GEN_RES_STR1( S_WINDOW_DISAPPEARED, MethodString( nMethodId ) ) );
3777 return sal_False;
3778 }
3779 }
3780 return sal_True;
3781 }
3782
HandleVisibleControls(Window * pControl)3783 sal_Bool StatementControl::HandleVisibleControls( Window *pControl )
3784 {
3785 if( pControl ) // Also auch bei Disabled nicht jedoch bei Invisible
3786 {
3787 switch( nMethodId )
3788 {
3789 case M_IsEnabled:
3790 pRet->GenReturn ( RET_Value, aUId, IsAccessable(pControl) );
3791 break;
3792 case M_IsVisible:
3793 pRet->GenReturn ( RET_Value, aUId, pControl->IsVisible() );
3794 break;
3795 case M_GetPosX:
3796 if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_FLOATINGWINDOW )
3797 pControl = pControl->GET_REAL_PARENT(); // Sonderbehandlung f�r FloatingWindows
3798 if ( pControl->GetType() == WINDOW_TABCONTROL && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_TABDIALOG )
3799 pControl = pControl->GET_REAL_PARENT(); // Sonderbehandlung f�r TabDialoge
3800 if ( pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_BORDERWINDOW )
3801 pControl = pControl->GET_REAL_PARENT(); // Sonderbehandlung f�r Border
3802 if ( (nParams & PARAM_BOOL_1) && bBool1 )
3803 pControl = pControl->GetWindow( WINDOW_OVERLAP );
3804
3805 if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_SPLITWINDOW )
3806 {
3807 Point aPos = pControl->GetPosPixel();
3808 aPos = pControl->GET_REAL_PARENT()->OutputToScreenPixel( aPos );
3809 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)aPos.X() );
3810 }
3811 else
3812 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pControl->GetPosPixel().X() );
3813 break;
3814 case M_GetPosY:
3815 if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_FLOATINGWINDOW )
3816 pControl = pControl->GET_REAL_PARENT(); // Sonderbehandlung f�r FloatingWindows
3817 if ( pControl->GetType() == WINDOW_TABCONTROL && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_TABDIALOG )
3818 pControl = pControl->GET_REAL_PARENT(); // Sonderbehandlung f�r TabDialoge
3819 if ( pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_BORDERWINDOW )
3820 pControl = pControl->GET_REAL_PARENT(); // Sonderbehandlung f�r Border
3821 if ( (nParams & PARAM_BOOL_1) && bBool1 )
3822 pControl = pControl->GetWindow( WINDOW_OVERLAP );
3823
3824 if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_SPLITWINDOW )
3825 {
3826 Point aPos = pControl->GetPosPixel();
3827 aPos = pControl->GET_REAL_PARENT()->OutputToScreenPixel( aPos );
3828 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)aPos.Y() );
3829 }
3830 else
3831 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pControl->GetPosPixel().Y() );
3832 break;
3833 case M_GetSizeX:
3834 if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_FLOATINGWINDOW )
3835 pControl = pControl->GET_REAL_PARENT(); // Sonderbehandlung f�r FloatingWindows
3836 if ( pControl->GetType() == WINDOW_TABCONTROL && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_TABDIALOG )
3837 pControl = pControl->GET_REAL_PARENT(); // Sonderbehandlung f�r TabDialoge
3838 if ( pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_BORDERWINDOW )
3839 pControl = pControl->GET_REAL_PARENT(); // Sonderbehandlung f�r Border
3840 if ( (nParams & PARAM_BOOL_1) && bBool1 )
3841 pControl = pControl->GetWindow( WINDOW_OVERLAP );
3842
3843 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pControl->GetSizePixel().Width() );
3844 break;
3845 case M_GetSizeY:
3846 if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_FLOATINGWINDOW )
3847 pControl = pControl->GET_REAL_PARENT(); // Sonderbehandlung f�r FloatingWindows
3848 if ( pControl->GetType() == WINDOW_TABCONTROL && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_TABDIALOG )
3849 pControl = pControl->GET_REAL_PARENT(); // Sonderbehandlung f�r TabDialoge
3850 if ( pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_BORDERWINDOW )
3851 pControl = pControl->GET_REAL_PARENT(); // Sonderbehandlung f�r Border
3852 if ( (nParams & PARAM_BOOL_1) && bBool1 )
3853 pControl = pControl->GetWindow( WINDOW_OVERLAP );
3854
3855 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pControl->GetSizePixel().Height() );
3856 break;
3857 case M_SnapShot:
3858 {
3859 if ( pControl->GetType() == WINDOW_DOCKINGWINDOW && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_FLOATINGWINDOW )
3860 pControl = pControl->GET_REAL_PARENT(); // Sonderbehandlung f�r FloatingWindows
3861 if ( pControl->GetType() == WINDOW_TABCONTROL && pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_TABDIALOG )
3862 pControl = pControl->GET_REAL_PARENT(); // Sonderbehandlung f�r TabDialoge
3863 if ( pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_BORDERWINDOW )
3864 pControl = pControl->GET_REAL_PARENT(); // Sonderbehandlung f�r Border
3865 if ( (nParams & PARAM_BOOL_1) && bBool1 )
3866 pControl = pControl->GetWindow( WINDOW_OVERLAP );
3867
3868 Bitmap aBmp = pControl->SnapShot();
3869 if ( pControl->GetType() == WINDOW_WORKWINDOW )
3870 {
3871 Point aStart = pControl->GetPosPixel();
3872 if ( !(nParams & PARAM_USHORT_4) )
3873 {
3874 nParams |= PARAM_USHORT_1;
3875 nParams |= PARAM_USHORT_2;
3876 nParams |= PARAM_USHORT_3;
3877 nParams |= PARAM_USHORT_4;
3878 nNr1 = (sal_uInt16)-aStart.X();
3879 nNr2 = (sal_uInt16)-aStart.Y();
3880 nNr3 = (sal_uInt16)pControl->GetSizePixel().Width() + 2*(sal_uInt16)aStart.X();
3881 nNr4 = (sal_uInt16)pControl->GetSizePixel().Height() + 2*(sal_uInt16)aStart.Y();
3882 }
3883 nNr1 = std::max((sal_uInt16)-aStart.X(),nNr1);
3884 nNr2 = std::max((sal_uInt16)-aStart.Y(),nNr2);
3885 nNr3 = std::min((sal_uInt16)(pControl->GetSizePixel().Width() + 2*(sal_uInt16)aStart.X()),nNr3);
3886 nNr4 = std::min((sal_uInt16)(pControl->GetSizePixel().Height() + 2*(sal_uInt16)aStart.Y()),nNr4);
3887 }
3888 if( nParams & PARAM_USHORT_4 )
3889 { // Zuschneiden
3890 Point aPt(-nNr1,-nNr2);
3891 Size aSz(nNr3,nNr4);
3892 VirtualDevice aVDev( *pControl );
3893
3894 aVDev.SetOutputSizePixel( aSz );
3895 aVDev.DrawBitmap( aPt, aBmp );
3896 aBmp = aVDev.GetBitmap( Point(), aSz );
3897 }
3898
3899 SvFileStream fOut;
3900 fOut.Open(aString1,STREAM_STD_WRITE);
3901 WriteDIB(aBmp, fOut, true, true);
3902 if ( fOut.GetError() )
3903 ReportError( aUId, GEN_RES_STR1( S_ERROR_SAVING_IMAGE, UniString::CreateFromInt32( fOut.GetError() ) ) );
3904 fOut.Close();
3905 }
3906 break;
3907 case M_GetFixedTextCount:
3908 {
3909 pRet->GenReturn ( RET_Value, aUId, CountWinByRT( pControl, WINDOW_FIXEDTEXT, sal_True ) );
3910 }
3911 break;
3912 case M_GetFixedText:
3913 {
3914 if( ( nParams & PARAM_USHORT_1 ) == 0 )
3915 nNr1 = 1;
3916
3917 FixedText* pFixedText = (FixedText*)GetWinByRT( pControl, WINDOW_FIXEDTEXT, sal_True, nNr1-1 );
3918 if ( pFixedText )
3919 pRet->GenReturn ( RET_Value, aUId, pFixedText->GetText() );
3920 else
3921 ValueOK(aUId, MethodString( nMethodId ),nNr1,CountWinByRT( pControl, WINDOW_FIXEDTEXT, sal_True ) );
3922 }
3923 break;
3924 case M_HasFocus:
3925 {
3926 pRet->GenReturn ( RET_Value, aUId, pControl->HasFocus() );
3927 break;
3928 }
3929 case M_GetScreenRectangle:
3930 {
3931 Rectangle aRect = bBool1 ? pControl->GetClientWindowExtentsRelative(NULL) : pControl->GetWindowExtentsRelative( NULL );
3932 pRet->GenReturn ( RET_Value, aUId,
3933 UniString::CreateFromInt32(aRect.Left()).
3934 AppendAscii(",").Append(UniString::CreateFromInt32(aRect.Top())).
3935 AppendAscii(",").Append(UniString::CreateFromInt32(aRect.GetWidth())).
3936 AppendAscii(",").Append(UniString::CreateFromInt32(aRect.GetHeight()))
3937 );
3938 }
3939 break;
3940 case M_GetHelpText:
3941 {
3942 pRet->GenReturn ( RET_Value, aUId, pControl->GetHelpText());
3943 }
3944 break;
3945 case M_GetQuickHelpText:
3946 {
3947 pRet->GenReturn ( RET_Value, aUId,pControl->GetQuickHelpText());
3948 }
3949 break;
3950 default:
3951 return sal_False;
3952 }
3953 SendProfile( UIdString( aUId ).Append('.').Append( MethodString( nMethodId ) ) );
3954 return sal_True;
3955 }
3956 return sal_False;
3957 }
3958
HandleCommonMethods(Window * pControl)3959 sal_Bool StatementControl::HandleCommonMethods( Window *pControl )
3960 {
3961 switch( nMethodId ) // Diese k�nnen an jedem Window ausgef�hrt werden
3962 {
3963 case M_Exists: // Oben schon Behandelt. Unterdr�ckt hier nur Fehler
3964 case M_NotExists:
3965 case M_IsEnabled:
3966 case M_IsVisible:
3967 case M_SnapShot:
3968 break;
3969 case M_Caption :
3970 {
3971 if ( pControl->GetText().Len() == 0 && IsDocFrame( pControl->GetWindow( WINDOW_FRAME ) ) )
3972 pRet->GenReturn ( RET_Value, aUId, pControl->GetWindow( WINDOW_FRAME )->GetText());
3973 else
3974 pRet->GenReturn ( RET_Value, aUId, pControl->GetText());
3975 }
3976 break;
3977 case M_GetRT:
3978 {
3979 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pControl->GetType() );
3980 }
3981 break;
3982 case M_TypeKeys:
3983 {
3984 if( !(nParams & PARAM_USHORT_1) ) // Anzahl wiederholungen
3985 nNr1 = 1;
3986 if( !(nParams & PARAM_BOOL_1) ) // Follow Focus
3987 bBool1 = sal_False; // so bleibt das bisherige Verhalten
3988
3989 if ( !bBool1 ) // Altes Verhalten
3990 pControl->GrabFocus();
3991 else // If focus is not inside given control we grab it once.
3992 {
3993 Window *pFocus = GetpApp()->GetFocusWindow();
3994 if ( !pFocus || !pControl->IsWindowOrChild( pFocus, sal_True ) )
3995 pControl->GrabFocus();
3996 }
3997
3998
3999 // maybe this can get removed since we are using GetPreferredKeyInputWindow()
4000 if ( pControl->GetType() == WINDOW_COMBOBOX )
4001 { // Bei COMBOBOX an das Edit direkt liefern
4002 Window *pTemp = NULL;
4003 for ( sal_uInt16 i = 0 ; i < pControl->GetChildCount() && !pTemp ; i++ )
4004 if ( pControl->GetChild( i )->GetType() == WINDOW_EDIT )
4005 pTemp = pControl->GetChild( i );
4006 if ( pTemp )
4007 pControl = pTemp;
4008 }
4009
4010 Window *pDeliverHere = pControl;
4011 for (int j = 0; j < nNr1; j++)
4012 for (xub_StrLen i = 0; i < aString1.Len(); i++)
4013 {
4014 if ( StatementList::bUsePostEvents )
4015 { // grab focus every time
4016 Window *pFocus = GetpApp()->GetFocusWindow();
4017 if ( !pFocus || !pControl->IsWindowOrChild( pFocus, sal_True ) )
4018 pControl->GrabFocus();
4019 }
4020 if ( bBool1 ) // Jedesmal das FocusWindow finden
4021 {
4022 Window *pFocus = GetpApp()->GetFocusWindow();
4023 if ( pFocus && pControl->IsWindowOrChild( pFocus, sal_True ) )
4024 pDeliverHere = pFocus;
4025 else // sonst fallback auf das Basisfenster
4026 pDeliverHere = pControl;
4027 }
4028 pDeliverHere = pDeliverHere->GetPreferredKeyInputWindow();
4029 KeyEvent aEvent;
4030 if ( ((sal_uInt16)aString1.GetChar(i)) <= 7 )
4031 {
4032 sal_uInt16 nVal = 0;
4033 switch (aString1.GetChar(i))
4034 {
4035 case 1: nVal = aString1.GetChar(i+1) + (aString1.GetChar(i+2) << 8);
4036 i += 2;
4037 break;
4038 case 3: nVal = (aString1.GetChar(i+1) << 8);
4039 i++;
4040 break;
4041 case 5: nVal = aString1.GetChar(i+1);
4042 i++;
4043 break;
4044 case 7: nVal = 0;
4045 break;
4046 }
4047 // #105672#
4048 // find out the keycode
4049 sal_uInt16 nKeygroup = nVal & KEYGROUP_TYPE;
4050 sal_uInt16 nKeyCode = nVal & KEY_CODE;
4051 sal_Unicode aCh;
4052 switch (nKeygroup)
4053 {
4054 case KEYGROUP_NUM:
4055 aCh = nKeyCode - KEY_0 + '0';
4056 break;
4057 case KEYGROUP_ALPHA:
4058 aCh = nKeyCode - KEY_A;
4059 if ( nVal & KEY_MOD1 )
4060 {}
4061 else if ( nVal & KEY_SHIFT )
4062 aCh += 'A';
4063 else
4064 aCh += 'a';
4065 break;
4066 case KEYGROUP_MISC:
4067 { // CR ESC TAB BACK
4068 ByteString aPrintableMisc("\x0d\x1b\x09\x08 **+-*/.,<>=",16);
4069 if ( nKeyCode-KEY_RETURN < aPrintableMisc.Len()
4070 && nKeyCode != KEY_INSERT && nKeyCode != KEY_DELETE )
4071 aCh = aPrintableMisc.GetChar( nKeyCode-KEY_RETURN );
4072 else
4073 aCh = 0;
4074 }
4075 break;
4076 case KEYGROUP_CURSOR:
4077 case KEYGROUP_FKEYS:
4078 default:
4079 aCh = 0;
4080 }
4081 aEvent = KeyEvent(aCh,KeyCode(nVal & 0xFFF,nVal & 0xF000));
4082 }
4083 else
4084 {
4085 // CR ESC TAB BACK
4086 String aPrintableMisc = CUniString("\x0d\x1b\x09\x08 xx+-*/.,<>=");
4087 sal_Unicode aCh = aString1.GetChar(i);
4088 if ( aCh >= 'a' && aCh <= 'z' )
4089 aEvent = KeyEvent(aCh, KeyCode(KEYGROUP_ALPHA + aCh-'a', 0));
4090 else if ( aCh >= 'A' && aCh <= 'Z' )
4091 aEvent = KeyEvent(aCh, KeyCode(KEYGROUP_ALPHA + aCh-'a', KEY_SHIFT));
4092 else if ( aCh >= '0' && aCh <= '9' )
4093 aEvent = KeyEvent(aCh, KeyCode(KEYGROUP_NUM + aCh-'0', 0));
4094 else if ( aPrintableMisc.Search(aCh) != STRING_NOTFOUND )
4095 aEvent = KeyEvent(aCh, KeyCode(KEYGROUP_MISC + (sal_uInt16)aPrintableMisc.Search(aCh), 0));
4096 else // Sollte eigentlich nicht auftreten
4097 aEvent = KeyEvent(aCh, KeyCode());
4098 }
4099 ImplKeyInput( pDeliverHere, aEvent );
4100 if ( !MaybeDoTypeKeysDelay( pControl ) )
4101 break;
4102 else
4103 SafeReschedule();SafeReschedule();SafeReschedule();
4104 }
4105 }
4106 break;
4107
4108 #define CalcMouseButton\
4109 sal_uInt16 nButton = MOUSE_LEFT;\
4110 if ( (nParams & PARAM_USHORT_3) )\
4111 {\
4112 switch ( nNr3 )\
4113 {\
4114 case 1: nButton = MOUSE_LEFT; break;\
4115 case 2: nButton = MOUSE_MIDDLE; break;\
4116 case 3: nButton = MOUSE_RIGHT; break;\
4117 }\
4118 }\
4119
4120 case M_MouseDown:
4121 {
4122 CalcMouseButton;
4123 Size aS = pControl->GetOutputSizePixel();
4124 Point aPos = Point(aS.Width() * nNr1 / 100,aS.Height() * nNr2 / 100);
4125 Window *pActualWin = pControl->FindWindow( aPos );
4126 // AnimateMouse( pControl, aPos );
4127
4128 if ( pActualWin )
4129 aPos = pActualWin->AbsoluteScreenToOutputPixel( pControl->OutputToAbsoluteScreenPixel ( aPos ) );
4130 // aPos = pActualWin->ScreenToOutputPixel( pControl->OutputToScreenPixel ( aPos ) );
4131 else
4132 pActualWin = pControl;
4133
4134 AnimateMouse( pActualWin, aPos );
4135 pActualWin->GrabFocus();
4136 MouseEvent aMEvnt(aPos,1,MOUSE_SIMPLECLICK|MOUSE_SELECT,nButton);
4137 ImplMouseButtonDown( pActualWin, aMEvnt );
4138 }
4139 break;
4140 case M_MouseUp:
4141 {
4142 CalcMouseButton;
4143 Size aS = pControl->GetOutputSizePixel();
4144 Point aPos = Point(aS.Width() * nNr1 / 100,aS.Height() * nNr2 / 100);
4145 Window *pActualWin = pControl->FindWindow( aPos );
4146
4147 if ( pActualWin )
4148 aPos = pActualWin->AbsoluteScreenToOutputPixel( pControl->OutputToAbsoluteScreenPixel ( aPos ) );
4149 // aPos = pActualWin->ScreenToOutputPixel( pControl->OutputToScreenPixel ( aPos ) );
4150 else
4151 pActualWin = pControl;
4152
4153 AnimateMouse( pActualWin, aPos );
4154 // pActualWin->GrabFocus();
4155 MouseEvent aMEvt( aPos, 1, MOUSE_SIMPLECLICK|MOUSE_SELECT, nButton );
4156 ImplMouseButtonUp( pActualWin, aMEvt );
4157 }
4158 break;
4159 case M_MouseMove:
4160 {
4161 CalcMouseButton;
4162 Size aS = pControl->GetOutputSizePixel();
4163 Point aPos = Point(aS.Width() * nNr1 / 100,aS.Height() * nNr2 / 100);
4164 Window *pActualWin = pControl->FindWindow( aPos );
4165
4166 if ( pActualWin )
4167 {
4168 aPos = pActualWin->AbsoluteScreenToOutputPixel( pControl->OutputToAbsoluteScreenPixel ( aPos ) );
4169 // aPos = pActualWin->ScreenToOutputPixel( pControl->OutputToScreenPixel ( aPos ) );
4170 }
4171 else
4172 pActualWin = pControl;
4173
4174 AnimateMouse( pActualWin, aPos );
4175 // pActualWin->GrabFocus();
4176 MouseEvent aMEvt( aPos, 0, MOUSE_SIMPLEMOVE|MOUSE_DRAGMOVE, nButton );
4177 ImplMouseMove( pActualWin, aMEvt );
4178 }
4179 break;
4180 case M_MouseDoubleClick:
4181 {
4182 CalcMouseButton;
4183 Size aS = pControl->GetOutputSizePixel();
4184 Point aPos = Point(aS.Width() * nNr1 / 100,aS.Height() * nNr2 / 100);
4185 Window *pActualWin = pControl->FindWindow( aPos );
4186
4187 if ( pActualWin )
4188 {
4189 aPos = pActualWin->AbsoluteScreenToOutputPixel( pControl->OutputToAbsoluteScreenPixel ( aPos ) );
4190 // aPos = pActualWin->ScreenToOutputPixel( pControl->OutputToScreenPixel ( aPos ) );
4191 }
4192 else
4193 pActualWin = pControl;
4194
4195 AnimateMouse( pActualWin, aPos );
4196 pActualWin->GrabFocus();
4197 MouseEvent aMEvnt;
4198 aMEvnt = MouseEvent(aPos,1,MOUSE_SIMPLECLICK|MOUSE_SELECT,nButton);
4199 ImplMouseButtonDown( pActualWin, aMEvnt );
4200 ImplMouseButtonUp ( pActualWin, aMEvnt );
4201 aMEvnt = MouseEvent(aPos,2,MOUSE_SIMPLECLICK|MOUSE_SELECT,nButton);
4202 ImplMouseButtonDown( pActualWin, aMEvnt );
4203 ImplMouseButtonUp ( pActualWin, aMEvnt );
4204 }
4205 break;
4206 case M_DisplayPercent:
4207 {
4208 ModelessDialog *pDlg = new ModelessDialog(NULL);
4209 pDlg->SetOutputSizePixel(Size(100,30));
4210
4211 Edit *pMyEd = new Edit(pDlg,WB_CENTER | WB_BORDER );
4212 pMyEd->SetSizePixel(Size(100,30));
4213 pDlg->SetText(UniString("Schlie�en", RTL_TEXTENCODING_ISO_8859_1));
4214 pDlg->Show();
4215 pMyEd->Show();
4216 sal_uLong nTime = Time().GetTime();
4217
4218 while (pDlg->IsVisible())
4219 {
4220 pDlg->ToTop();
4221 for (int i = 1 ; i<10 ; i++)
4222 SafeReschedule();
4223 Point Pos = pControl->GetPointerPosPixel();
4224 Size Siz=pControl->GetOutputSizePixel();
4225 if ( Time().GetTime() - nTime > 10 )
4226 {
4227 nTime = Time().GetTime();
4228 pMyEd->SetText(UniString::CreateFromInt32(Pos.X()*100/Siz.Width()).AppendAscii("%x").Append( UniString::CreateFromInt32(Pos.Y()*100/Siz.Height()) ).Append('%'));
4229 }
4230 }
4231
4232 delete pMyEd;
4233 delete pDlg;
4234 }
4235 break;
4236 case M_OpenContextMenu:
4237 {
4238 aSubMenuId1 = 0;
4239 aSubMenuId2 = 0;
4240 aSubMenuId3 = 0;
4241 pMenuWindow = NULL;
4242 Point aPos;
4243 ToolBox* pTB = (ToolBox*)pControl;
4244 if ( (pControl->GetType() == WINDOW_TOOLBOX) && pTB->IsMenuEnabled() )
4245 {
4246 pTB->ExecuteCustomMenu();
4247 /* Rectangle aRect = pTB->GetMenubuttonRect();
4248 AnimateMouse( pControl, aRect.Center() );
4249 MouseEvent aMEvnt(aRect.Center(),1,MOUSE_SIMPLECLICK,MOUSE_LEFT);
4250 ImplMouseButtonDown( pTB, aMEvnt );*/
4251 }
4252 else
4253 {
4254 sal_Bool bAtMousePos = ( nParams & PARAM_BOOL_1 ) && bBool1;
4255 if ( bAtMousePos )
4256 {
4257 aPos = pControl->GetPointerPosPixel();
4258 Window *pActualWin = pControl->FindWindow( aPos );
4259
4260 if ( pActualWin )
4261 {
4262 aPos = pActualWin->AbsoluteScreenToOutputPixel( pControl->OutputToAbsoluteScreenPixel ( aPos ) );
4263 // aPos = pActualWin->ScreenToOutputPixel( pControl->OutputToScreenPixel ( aPos ) );
4264 pControl = pActualWin;
4265 }
4266 }
4267 CommandEvent aEvent( aPos, COMMAND_CONTEXTMENU, bAtMousePos );
4268 ImplCommand( pControl, aEvent );
4269 }
4270 }
4271 break;
4272 case M_UseMenu:
4273 {
4274 aSubMenuId1 = 0;
4275 aSubMenuId2 = 0;
4276 aSubMenuId3 = 0;
4277 pMenuWindow = NULL;
4278
4279 while ( pControl && !( ( pControl->GetType() == WINDOW_SYSWINDOW || pControl->GetType() == WINDOW_WORKWINDOW ) && ControlOK( pControl, "" ) ) )
4280 pControl = pControl->GET_REAL_PARENT();
4281
4282 if ( pControl && ((SystemWindow*)pControl)->GetMenuBar() )
4283 pMenuWindow = ((SystemWindow*)pControl);
4284 else
4285 ReportError( GEN_RES_STR1( S_NO_MENU, MethodString( nMethodId ) ) );
4286 }
4287 break;
4288 case M_FadeIn:
4289 case M_FadeOut:
4290 case M_Pin:
4291 case M_IsFadeIn:
4292 case M_IsPin:
4293 {
4294 WindowAlign aWindowAlign = WINDOWALIGN_LEFT;
4295 if ( (nParams & PARAM_USHORT_1) )
4296 {
4297 switch ( nNr1 )
4298 {
4299 case CONST_ALIGN_LEFT:
4300 aWindowAlign = WINDOWALIGN_LEFT;
4301 break;
4302 case CONST_ALIGN_TOP:
4303 aWindowAlign = WINDOWALIGN_TOP;
4304 break;
4305 case CONST_ALIGN_RIGHT:
4306 aWindowAlign = WINDOWALIGN_RIGHT;
4307 break;
4308 case CONST_ALIGN_BOTTOM:
4309 aWindowAlign = WINDOWALIGN_BOTTOM;
4310 break;
4311 default:
4312 ReportError( aUId, GEN_RES_STR1( S_INVALID_POSITION, MethodString( nMethodId ) ) );
4313 }
4314 }
4315
4316 Window* pTemp = NULL;
4317 while ( !pTemp && pControl )
4318 {
4319 pTemp = GetFadeSplitWin( pControl, aWindowAlign );
4320 pControl = pControl->GET_REAL_PARENT();
4321 }
4322
4323 if ( !pTemp )
4324 {
4325 ReportError( aUId, GEN_RES_STR1( S_SPLITWIN_NOT_FOUND, MethodString( nMethodId ) ) );
4326 break;
4327 }
4328
4329 pControl = pTemp; // So da� wir unten ohne Fehler durchkommen
4330 SplitWindow *pSW = (SplitWindow*) pTemp;
4331
4332 // Rectangle GetAutoHideRect() const;
4333 // Rectangle GetFadeInRect() const;
4334 // Rectangle GetFadeOutRect() const;
4335
4336 switch( nMethodId )
4337 {
4338 case M_FadeIn:
4339 if ( pSW->IsFadeInButtonVisible() )
4340 pSW->FadeIn();
4341 break;
4342 case M_FadeOut:
4343 if ( pSW->IsFadeOutButtonVisible() )
4344 pSW->FadeOut();
4345 break;
4346 case M_Pin:
4347 if ( ( pSW->GetAutoHideState() && bBool1 )
4348 || ( !pSW->GetAutoHideState() && !bBool1 ) )
4349 {
4350 MouseEvent aMEvnt;
4351 Point aPt( pSW->GetAutoHideRect().Center() );
4352 aMEvnt = MouseEvent( aPt,1,MOUSE_SIMPLECLICK,MOUSE_LEFT );
4353 ImplMouseButtonDown( pControl, aMEvnt, FORCE_DIRECT_CALL );
4354 ImplMouseButtonUp ( pControl, aMEvnt, FORCE_DIRECT_CALL );
4355 }
4356 // pSW->AutoHide();
4357 break;
4358 case M_IsFadeIn:
4359 pRet->GenReturn ( RET_Value, aUId, pSW->IsFadeOutButtonVisible() );
4360 break;
4361 case M_IsPin:
4362 pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)!pSW->GetAutoHideState() );
4363 break;
4364 default:
4365 ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );
4366 }
4367 SendProfile( UIdString( aUId ).Append('.').Append( MethodString( nMethodId ) ) );
4368 }
4369 break;
4370 case M_StatusGetText:
4371 case M_StatusIsProgress:
4372 case M_StatusGetItemCount:
4373 case M_StatusGetItemId:
4374 {
4375 StatusBar *pStatus = NULL;
4376 while ( !pStatus && pControl )
4377 {
4378 pStatus = (StatusBar*)GetWinByRT( pControl, WINDOW_STATUSBAR, sal_True );
4379 pControl = pControl->GET_REAL_PARENT();
4380 }
4381
4382 if ( !pStatus )
4383 {
4384 ReportError( aUId, GEN_RES_STR1( S_NO_STATUSBAR, MethodString( nMethodId ) ) );
4385 break;
4386 }
4387
4388 switch ( nMethodId )
4389 {
4390 case M_StatusGetText:
4391 {
4392 if ( (nParams & PARAM_USHORT_1) )
4393 {
4394 if ( pStatus->AreItemsVisible() )
4395 pRet->GenReturn ( RET_Value, aUId, String(pStatus->GetItemText(nNr1)));
4396 else
4397 ReportError( aUId, GEN_RES_STR1( S_ITEMS_INVISIBLE, MethodString( nMethodId ) ) );
4398 }
4399 else
4400 {
4401 if ( pStatus->AreItemsVisible() )
4402 {
4403 if ( pStatus->GetItemCount() == 1 )
4404 {
4405 pRet->GenReturn ( RET_Value, aUId, pStatus->GetItemText( pStatus->GetItemId(0) ));
4406 }
4407 else
4408 {
4409 pRet->GenReturn ( RET_Value, aUId, String() );
4410 }
4411 }
4412 else
4413 pRet->GenReturn ( RET_Value, aUId, (String)pStatus->GetText() );
4414 }
4415 }
4416 break;
4417 case M_StatusIsProgress:
4418 {
4419 pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)pStatus->IsProgressMode() );
4420 }
4421 break;
4422 case M_StatusGetItemCount:
4423 if ( pStatus->AreItemsVisible() )
4424 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(pStatus->GetItemCount()));
4425 else
4426 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(0));
4427 break;
4428 case M_StatusGetItemId:
4429 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,pStatus->GetItemCount()) )
4430 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(pStatus->GetItemId(nNr1-1)));
4431 break;
4432 }
4433 }
4434 break;
4435 case M_HasScrollBar:
4436 case M_IsScrollBarEnabled:
4437 {
4438 if ( (nParams | PARAM_USHORT_1) != PARAM_USHORT_1 ) // so there are other params
4439 {
4440 ReportError( aUId, GEN_RES_STR0( S_INVALID_PARAMETERS ) );
4441 break;
4442 }
4443
4444 if( !(nParams & PARAM_USHORT_1) )
4445 nNr1 = CONST_ALIGN_RIGHT; // default is right Scrollbar(vertical)
4446
4447 if ( (nNr1 != CONST_ALIGN_RIGHT) && (nNr1 != CONST_ALIGN_BOTTOM) )
4448 {
4449 ReportError( aUId, GEN_RES_STR1( S_INVALID_POSITION, MethodString( nMethodId ) ) );
4450 break;
4451 }
4452
4453 ScrollBar *pScroll = NULL;
4454
4455 sal_uInt16 nSteps = 2;
4456 while ( !pScroll && pControl && nSteps-- )
4457 {
4458 pScroll = GetScrollBar( pControl, nNr1, sal_True );
4459 pControl = pControl->GET_REAL_PARENT();
4460 }
4461
4462 switch ( nMethodId )
4463 {
4464 case M_HasScrollBar:
4465 {
4466 if ( pScroll )
4467 pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)sal_True );
4468 else
4469 pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)sal_False );
4470 }
4471 break;
4472 case M_IsScrollBarEnabled:
4473 {
4474 if ( !pScroll )
4475 {
4476 ReportError( aUId, GEN_RES_STR1( S_NO_SCROLLBAR, MethodString( nMethodId ) ) );
4477 break;
4478 }
4479 pRet->GenReturn ( RET_Value, aUId, pScroll->IsEnabled() );
4480 }
4481 break;
4482 }
4483 }
4484 break;
4485 default:
4486 return sal_False;
4487 }
4488 return sal_True;
4489 }
4490
4491
Execute()4492 sal_Bool StatementControl::Execute()
4493 {
4494 Window *pControl;
4495 sal_Bool bStatementDone = sal_True;
4496
4497
4498 if ( IsError )
4499 {
4500 #if OSL_DEBUG_LEVEL > 1
4501 m_pDbgWin->AddText( "Skipping Window: " );
4502 m_pDbgWin->AddText( Id2Str( aUId ) );
4503 m_pDbgWin->AddText( " Method: " );
4504 m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
4505 m_pDbgWin->AddText( "\n" );
4506 #endif
4507 Advance();
4508 delete this;
4509 return sal_True;
4510 }
4511
4512 InitProfile();
4513 #if OSL_DEBUG_LEVEL > 1
4514 m_pDbgWin->AddText( "Executing Window: " );
4515 m_pDbgWin->AddText( Id2Str( aUId ) );
4516 m_pDbgWin->AddText( " Method: " );
4517 m_pDbgWin->AddText( String::CreateFromInt32( nMethodId ) );
4518 m_pDbgWin->AddText( "\n" );
4519 #endif
4520
4521
4522 if ( aUId.equals( UID_ACTIVE ) )
4523 pControl = GetAnyActive();
4524 else
4525 {
4526 sal_Bool bSearchButtonOnToolbox = (nParams == PARAM_NONE) && ((M_Click == nMethodId) || (M_TearOff == nMethodId) || (M_IsEnabled == nMethodId) || (M_OpenMenu == nMethodId));
4527 bSearchButtonOnToolbox |= (nParams == PARAM_USHORT_1) && (M_GetState == nMethodId);
4528 if ( nMethodId == M_TypeKeys || nMethodId == M_MouseDown
4529 || nMethodId == M_MouseUp || nMethodId == M_MouseMove
4530 || nMethodId == M_SnapShot )
4531 {
4532 pControl = NULL;
4533 if ( /*(nMethodId == M_SnapShot || nMethodId == M_TypeKeys) &&*/ !pControl )
4534 pControl = SearchTree( aUId ,bSearchButtonOnToolbox );
4535 }
4536 else
4537 pControl = SearchTree( aUId ,bSearchButtonOnToolbox );
4538 }
4539
4540
4541 if ( pControl && pControl->GetType() == WINDOW_TOOLBOX )
4542 {
4543 if ( !aUId.equals( pControl->GetUniqueOrHelpId() ) )
4544 { // Also wenn wir irgendwas auf einer Toolbox gefunden haben
4545 switch ( nMethodId )
4546 {
4547 case M_Click:
4548 case M_TearOff:
4549 case M_OpenMenu:
4550 case M_GetState:
4551 break;
4552 case M_IsEnabled:
4553 nMethodId = _M_IsEnabled; // Umlabeln, da die Behandlung essentiell anders ist!
4554 break;
4555 default:
4556 pControl = NULL;
4557 }
4558 }
4559 }
4560
4561
4562 switch ( nMethodId )
4563 {
4564 case M_Exists:
4565 case M_NotExists:
4566 Time aT;
4567 sal_uInt16 aSeconds = aT.GetMin()*60+aT.GetSec();
4568 if ( !bBool2 ) // wurde im Konstruktor auf sal_False gesetzt
4569 {
4570 bBool2 = sal_True;
4571 nNr2 = aSeconds;
4572 if( !(nParams & PARAM_USHORT_1) )
4573 nNr1 = 0; // defaultm��ig sofort zur�ck
4574 }
4575 if ( aSeconds < nNr2 ) // Falls die Stunde umgesprungen ist
4576 aSeconds += 60*60;
4577
4578 if ( /* !IsAccessable(pControl)#87019# */ !pControl || !pControl->IsVisible() )
4579 pControl = NULL;
4580 if ( ((nMethodId == M_Exists) && pControl) ||
4581 ((nMethodId == M_NotExists) && !pControl) )
4582 { // Wenn Bedingung erf�llt
4583 pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)sal_True );
4584 }
4585 else
4586 if ( aSeconds <= nNr2 + nNr1 ) // Zeit ist noch nicht abgelaufen
4587 return sal_False;
4588 else
4589 pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)sal_False );
4590
4591 Advance();
4592 delete this;
4593 return sal_True;
4594 // break;
4595 }
4596
4597
4598 short nRT = 0;
4599
4600 if( pControl ) // Das Fenster Existiert irgendwo, kann aber auch hidden sein!
4601 {
4602 nRT = ImpGetRType( pControl );
4603 #if OSL_DEBUG_LEVEL > 1
4604 m_pDbgWin->AddText( "Type is: " );
4605 m_pDbgWin->AddText( String::CreateFromInt32( nRT ) );
4606 m_pDbgWin->AddText( "\n" );
4607 #endif
4608 }
4609
4610 if ( nRT == C_Window && // Search for WorkWindow to satisfy these commands
4611 ( nMethodId == M_Close
4612 // || nMethodId == M_Size
4613 // || nMethodId == M_Move
4614 || nMethodId == M_IsMax
4615 || nMethodId == M_IsMin
4616 || nMethodId == M_IsRestore
4617 || nMethodId == M_Minimize
4618 || nMethodId == M_Maximize
4619 || nMethodId == M_Restore ) )
4620 {
4621 Window* pNewControl = pControl;
4622 while ( pNewControl && pNewControl->GetType() != WINDOW_WORKWINDOW )
4623 pNewControl = pNewControl->GET_REAL_PARENT();
4624
4625 if ( pNewControl )
4626 {
4627 pControl = pNewControl;
4628 nRT = C_WorkWin;
4629 }
4630 }
4631
4632
4633 if ( (!ControlOK( pControl, "" )) && ( nMethodId != M_SnapShot ) && (nRetryCount--))
4634 {
4635 #if OSL_DEBUG_LEVEL > 1
4636 m_pDbgWin->AddText( CUniString("Reschedule command (").Append( UniString::CreateFromInt32(nRetryCount) ).AppendAscii(")\n") );
4637 #endif
4638 return sal_False;
4639 }
4640
4641 if( ControlOK( pControl, "" ) )
4642 {
4643 if ( nMethodId == M_OpenContextMenu && !bBool2 )
4644 {
4645 pControl->GrabFocus(); // to get asyncron focus on unix
4646 bBool2 = sal_True;
4647 return sal_False;
4648 }
4649 // TODO: handle GetFocus for all Methods and Windows like this (remove part below)
4650 // See for impact of changed focus for HandleVisibleControls() (taking Snapshots might be different, possible exclude those methods)
4651 if (( (nRT == C_TreeListBox) && !bBool2 )
4652 && nMethodId != M_TypeKeys // TypeKeys macht das selbst, falls eigenes Focushandling gew�nscht
4653 && nMethodId != M_MouseDown
4654 && nMethodId != M_MouseUp
4655 && nMethodId != M_MouseMove
4656 /*&& nMethodId != M_MouseDoubleClick*/ )
4657 {
4658 if ( !pControl->HasFocus() )
4659 {
4660 pControl->GrabFocus();
4661 int i = 10;
4662 while ( i-- && !pControl->HasFocus() ) // reschedule a bit
4663 {
4664 SafeReschedule();
4665 if ( !WinPtrValid( pControl ) )
4666 return sal_False;
4667 }
4668 if ( !pControl->HasFocus() ) // to get asyncronous focus
4669 {
4670 bBool2 = sal_True;
4671 return sal_False;
4672 }
4673 }
4674 }
4675 }
4676
4677 Advance();
4678
4679 if ( HandleVisibleControls( pControl ) )
4680 {
4681 delete this;
4682 return sal_True;
4683 }
4684 if( ControlOK( pControl, "Window/Control" ) )
4685 {
4686 if (((( nRT < C_TabPage && nRT > C_TabControl )
4687 || nRT == C_PatternBox
4688 || nRT == C_ToolBox
4689 || nRT == C_ValueSet
4690 || nRT == C_Control
4691 || nRT == C_TreeListBox
4692 )
4693 || nMethodId == M_OpenContextMenu )
4694 && nMethodId != M_TypeKeys // TypeKeys macht das selbst, falls eigenes Focushandling gew�nscht
4695 && nMethodId != M_MouseDown
4696 && nMethodId != M_MouseUp
4697 && nMethodId != M_MouseMove
4698 /*&& nMethodId != M_MouseDoubleClick*/ )
4699 pControl->GrabFocus();
4700
4701 /* leads to problems because settext sets the text whereas typekeys adds to the text.
4702 if ( bDoTypeKeysDelay && nMethodId == M_SetText && ( nParams & PARAM_STR_1 ) )
4703 { // Hier wird das Statement auf ein TypeKeys umgebogen
4704 nMethodId = M_TypeKeys;
4705 nParams = PARAM_BOOL_1 | PARAM_STR_1;
4706 bBool1 = sal_True;
4707 pControl->GrabFocus();
4708 }
4709 */
4710 if ( !HandleCommonMethods( pControl ) )
4711 {
4712 switch( nRT )
4713 {
4714 case C_TabControl:
4715 switch( nMethodId )
4716 {
4717 case M_GetPageId:
4718 if ( (nParams & PARAM_USHORT_1) )
4719 {
4720 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((TabControl*)pControl)->GetPageCount() ) )
4721 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)((TabControl*)pControl)->GetPageId(nNr1-1));
4722 }
4723 else
4724 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)((TabControl*)pControl)->GetCurPageId());
4725 break;
4726 case M_GetPageCount:
4727 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)((TabControl*)pControl)->GetPageCount());
4728 break;
4729 case M_SetPageId:
4730 if (((TabControl*)pControl)->GetCurPageId())
4731 ((TabControl*)pControl)->DeactivatePage();
4732 ((TabControl*)pControl)->SetCurPageId( nNr1 );
4733 ((TabControl*)pControl)->ActivatePage();
4734 break;
4735 case M_SetPageNr:
4736 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((TabControl*)pControl)->GetPageCount() ) )
4737 {
4738 if (((TabControl*)pControl)->GetCurPageId())
4739 ((TabControl*)pControl)->DeactivatePage();
4740 ((TabControl*)pControl)->SetCurPageId( ((TabControl*)pControl)->GetPageId( nNr1-1 ) );
4741 ((TabControl*)pControl)->ActivatePage();
4742 }
4743 break;
4744 case M_GetPage:
4745 pRet->GenReturn ( RET_Value, aUId, Id2Str( ((TabControl*)pControl)->GetTabPage(((TabControl*)pControl)->GetCurPageId())->GetUniqueOrHelpId() ) );
4746 break;
4747 case M_SetPage :
4748 { // Wegen lokaler Variablen
4749 TabControl *pTControl = ((TabControl*)pControl);
4750 sal_uInt16 nActive = pTControl->GetCurPageId();
4751 sal_uInt16 i,anz;
4752 rtl::OString aID;
4753 rtl::OString aWantedID;
4754 //HELPID BACKWARD (No numbers please (remove PARAM_ULONG_1 part)
4755 if ( (nParams & PARAM_ULONG_1) )
4756 {
4757 //aWantedID = rtl::OString( nLNr1 );
4758 ReportError( aUId, GEN_RES_STR1c( S_INTERNAL_ERROR, "using numeric HelpID from old Testtool" ) );
4759 }
4760 else if ( (nParams & PARAM_STR_1) )
4761 {
4762 aWantedID = Str2Id( aString1 );
4763 }
4764 else
4765 ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );
4766
4767 i = pTControl->GetPagePos( pTControl->GetCurPageId() );
4768 for ( anz=0 ; anz < pTControl->GetPageCount() && !aID.equals( aWantedID ) ; anz++ )
4769 {
4770 pTControl->SelectTabPage( pTControl->GetPageId(i) );
4771 /*if (pTControl->GetCurPageId())
4772 pTControl->DeactivatePage();
4773 pTControl->SetCurPageId( pTControl->GetPageId(i) );
4774 pTControl->ActivatePage();*/
4775 aID = pTControl->GetTabPage(pTControl->GetCurPageId())->GetUniqueOrHelpId();
4776 i++;
4777 if ( i >= pTControl->GetPageCount() )
4778 i = 0;
4779 if ( !MaybeDoTypeKeysDelay( pTControl ) || !MaybeDoTypeKeysDelay( pTControl ) || !MaybeDoTypeKeysDelay( pTControl ) ) // 3 Mal aufrufen
4780 break;
4781 }
4782 if ( !aID.equals( aWantedID ) )
4783 {
4784 pTControl->SelectTabPage( nActive );
4785 /*if (pTControl->GetCurPageId())
4786 pTControl->DeactivatePage();
4787 pTControl->SetCurPageId( nActive );
4788 pTControl->ActivatePage();*/
4789 ReportError( aWantedID, GEN_RES_STR1( S_TABPAGE_NOT_FOUND, MethodString( nMethodId ) ) );
4790 }
4791 }
4792 break;
4793 default:
4794 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "TabControl" ) );
4795 break;
4796 }
4797 break;
4798 case C_RadioButton:
4799 case C_ImageRadioButton:
4800 switch( nMethodId )
4801 {
4802 case M_AnimateMouse :
4803 AnimateMouse( pControl, MitteLinks);
4804 break;
4805 case M_IsChecked :
4806 pRet->GenReturn ( RET_Value, aUId, ((RadioButton*)pControl)->IsChecked());
4807 break;
4808 case M_Check :
4809 ((RadioButton*)pControl)->Check();
4810 ((RadioButton*)pControl)->Click();
4811 break;
4812 default:
4813 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "RadioButton" ) );
4814 break;
4815 }
4816 break;
4817 case C_CheckBox:
4818 case C_TriStateBox:
4819 switch( nMethodId )
4820 {
4821 case M_AnimateMouse :
4822 AnimateMouse( pControl, MitteLinks);
4823 break;
4824 case M_IsChecked :
4825 pRet->GenReturn ( RET_Value, aUId, comm_BOOL( ((TriStateBox*)pControl)->GetState() == STATE_CHECK) );
4826 break;
4827 case M_IsTristate :
4828 pRet->GenReturn ( RET_Value, aUId, comm_BOOL( ((TriStateBox*)pControl)->GetState() == STATE_DONTKNOW) );
4829 break;
4830 case M_GetState :
4831 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((TriStateBox*)pControl)->GetState()));
4832 break;
4833 case M_Check :
4834 ((TriStateBox*)pControl)->SetState( STATE_CHECK );
4835 ((TriStateBox*)pControl)->Click();
4836 break;
4837 case M_UnCheck :
4838 ((TriStateBox*)pControl)->SetState( STATE_NOCHECK );
4839 ((TriStateBox*)pControl)->Click();
4840 break;
4841 case M_TriState :
4842 if ( ((TriStateBox*)pControl)->IsTriStateEnabled() )
4843 {
4844 ((TriStateBox*)pControl)->SetState( STATE_DONTKNOW );
4845 ((TriStateBox*)pControl)->Click();
4846 }
4847 else
4848 {
4849 ReportError( aUId, GEN_RES_STR0( S_TRISTATE_NOT_ALLOWED ) );
4850 }
4851 break;
4852 case M_Click :
4853 {
4854 TriStateBox *pTB = ((TriStateBox*)pControl);
4855 if ( pTB->GetState() == STATE_NOCHECK )
4856 pTB->SetState( STATE_CHECK );
4857 else if ( pTB->GetState() == STATE_CHECK )
4858 {
4859 if ( pTB->IsTriStateEnabled() )
4860 pTB->SetState( STATE_DONTKNOW );
4861 else
4862 pTB->SetState( STATE_NOCHECK );
4863 }
4864 else
4865 pTB->SetState( STATE_NOCHECK );
4866 pTB->Click();
4867 }
4868 break;
4869 default:
4870 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "TriStateBox" ) );
4871 break;
4872 }
4873 break;
4874 case C_Edit:
4875 case C_MultiLineEdit:
4876 switch( nMethodId )
4877 {
4878 case M_AnimateMouse :
4879 AnimateMouse( pControl, Mitte);
4880 break;
4881 case M_GetText :
4882 pRet->GenReturn ( RET_Value, aUId, ((Edit*)pControl)->GetText());
4883 break;
4884 case M_IsWritable:
4885 pRet->GenReturn ( RET_Value, aUId, (comm_BOOL) !((Edit*)pControl)->IsReadOnly() );
4886 break;
4887 default:
4888 if ( ! ((Edit*)pControl)->IsReadOnly() )
4889 {
4890 switch( nMethodId )
4891 {
4892 case M_SetText :
4893 ((Edit*)pControl)->SetText( aString1 );
4894 if ( nRT == C_MultiLineEdit ) // since SetModifyFlag is not virtual we have to do this
4895 ((MultiLineEdit*)pControl)->SetModifyFlag();
4896 else
4897 ((Edit*)pControl)->SetModifyFlag();
4898 ((Edit*)pControl)->Modify();
4899 if ( ((Edit*)pControl)->GetText().CompareTo(aString1) != COMPARE_EQUAL )
4900 ReportError( aUId, GEN_RES_STR1( S_ERROR_IN_SET_TEXT, MethodString( nMethodId ) ) );
4901 break;
4902 default:
4903 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "(MultiLine)Edit" ) );
4904 break;
4905 }
4906 }
4907 else
4908 ReportError( aUId, GEN_RES_STR1c( S_ATTEMPT_TO_WRITE_READONLY, "(MultiLine)Edit" ) );
4909 }
4910 break;
4911 case C_MultiListBox:
4912 case C_ListBox:
4913 switch( nMethodId )
4914 {
4915 case M_AnimateMouse :
4916 AnimateMouse( pControl, MitteOben);
4917 break;
4918 case M_GetSelCount :
4919 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((ListBox*)pControl)->GetSelectEntryCount()));
4920 break;
4921 case M_GetSelIndex :
4922 if ( ! (nParams & PARAM_USHORT_1) )
4923 {
4924 if ( ((ListBox*)pControl)->GetSelectEntryCount() == 0 )
4925 {
4926 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(0));
4927 break;
4928 }
4929 nNr1 = 1;
4930 }
4931 ValueOK(aUId, MethodString( nMethodId ),nNr1,((ListBox*)pControl)->GetSelectEntryCount());
4932 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((ListBox*)pControl)->GetSelectEntryPos(nNr1-1)) +1);
4933 break;
4934 case M_GetSelText :
4935 if ( ! (nParams & PARAM_USHORT_1) )
4936 nNr1 = 1;
4937 pRet->GenReturn ( RET_Value, aUId, ((ListBox*)pControl)->GetSelectEntry(nNr1-1));
4938 break;
4939 case M_GetItemCount :
4940 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((ListBox*)pControl)->GetEntryCount()));
4941 break;
4942 case M_GetItemText :
4943 pRet->GenReturn ( RET_Value, aUId, ((ListBox*)pControl)->GetEntry(nNr1-1));
4944 break;
4945 case M_Select:
4946 case M_MultiSelect:
4947 {
4948 sal_Bool bUnselectBeforeSelect = ( nMethodId == M_Select );
4949 sal_Bool bFehler = sal_False;
4950 if ( ! (nParams & PARAM_BOOL_1) )
4951 bBool1 = sal_True;
4952
4953 if ( nMethodId == M_MultiSelect && nRT == C_ListBox )
4954 {
4955 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "ListBox" ) );
4956 bFehler = sal_True;
4957 }
4958
4959 if ( !bBool1 && nMethodId == M_Select )
4960 {
4961 ReportError( aUId, GEN_RES_STR1( S_NO_SELECT_FALSE, MethodString( nMethodId ) ) );
4962 bFehler = sal_True;
4963 }
4964
4965 if ( !bFehler )
4966 {
4967 if( nParams & PARAM_STR_1 )
4968 {
4969 ListBox *pLB = ((ListBox*)pControl);
4970 sal_uInt16 nPos;
4971 if ( (nPos = pLB->GetEntryPos( aString1 )) == LISTBOX_ENTRY_NOTFOUND )
4972 ReportError( aUId, GEN_RES_STR2( S_ENTRY_NOT_FOUND, MethodString( nMethodId ), aString1 ) );
4973 else
4974 {
4975 if ( bUnselectBeforeSelect )
4976 pLB->SetNoSelection();
4977 pLB->SelectEntryPos( nPos, bBool1 );
4978 if ( pLB->IsEntryPosSelected( nPos ) ? !bBool1 : bBool1 ) // XOR rein mit BOOL
4979 ReportError( aUId, GEN_RES_STR2( S_METHOD_FAILED, MethodString( nMethodId ), aString1 ) );
4980 }
4981 }
4982 else
4983 {
4984 ListBox *pLB = ((ListBox*)pControl);
4985 pLB = static_cast<ListBox*>(pControl);
4986 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,pLB->GetEntryCount()) )
4987 {
4988 if ( bUnselectBeforeSelect )
4989 pLB->SetNoSelection();
4990 pLB->SelectEntryPos( nNr1-1, bBool1 );
4991 if ( pLB->IsEntryPosSelected( nNr1-1 ) ? !bBool1 : bBool1 ) // XOR rein mit BOOL
4992 ReportError( aUId, GEN_RES_STR2( S_METHOD_FAILED, MethodString( nMethodId ), UniString::CreateFromInt32( nNr1 ) ) );
4993 }
4994 }
4995 ((ListBox*)pControl)->Select();
4996 }
4997 }
4998 break;
4999 case M_SetNoSelection :
5000 ((ListBox*)pControl)->SetNoSelection();
5001 ((ListBox*)pControl)->Select();
5002 break;
5003 default:
5004 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "(Multi)ListBox" ) );
5005 break;
5006 }
5007 break;
5008 case C_ComboBox:
5009 case C_PatternBox:
5010 case C_NumericBox:
5011 case C_MetricBox:
5012 case C_CurrencyBox:
5013 case C_DateBox:
5014 case C_TimeBox:
5015 switch( nMethodId )
5016 {
5017 case M_AnimateMouse :
5018 AnimateMouse( pControl, MitteOben);
5019 break;
5020 case M_GetSelText :
5021 pRet->GenReturn ( RET_Value, aUId, ((ComboBox*)pControl)->GetText());
5022 break;
5023 case M_GetSelIndex :
5024 {
5025 sal_uInt16 nPos = ((ComboBox*)pControl)->GetEntryPos(((ComboBox*)pControl)->GetText());
5026 if ( nPos == COMBOBOX_ENTRY_NOTFOUND )
5027 nPos = 0;
5028 else
5029 nPos++;
5030 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG) nPos);
5031 }
5032 break;
5033 case M_GetItemCount :
5034 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((ComboBox*)pControl)->GetEntryCount()));
5035 break;
5036 case M_GetItemText :
5037 pRet->GenReturn ( RET_Value, aUId, ((ComboBox*)pControl)->GetEntry(nNr1-1));
5038 break;
5039 case M_IsWritable:
5040 pRet->GenReturn ( RET_Value, aUId, (comm_BOOL) !((ComboBox*)pControl)->IsReadOnly() );
5041 break;
5042 case M_Select :
5043 if( nParams & PARAM_USHORT_1 )
5044 {
5045 if ( !ValueOK(aUId, MethodString( nMethodId ),nNr1,((ComboBox*)pControl)->GetEntryCount()) )
5046 break;
5047 aString1 = ((ComboBox*)pControl)->GetEntry(nNr1-1);
5048 }
5049 else
5050 {
5051 if ( ((ComboBox*)pControl)->GetEntryPos( aString1 ) == COMBOBOX_ENTRY_NOTFOUND )
5052 {
5053 ReportError( aUId, GEN_RES_STR2( S_ENTRY_NOT_FOUND, MethodString( nMethodId ), aString1 ) );
5054 break;
5055 }
5056 }
5057
5058
5059 ((ComboBox*)pControl)->SetText( aString1 );
5060 ((ComboBox*)pControl)->SetModifyFlag();
5061 ((ComboBox*)pControl)->Modify();
5062 break;
5063 case M_SetText :
5064 if ( ! ((ComboBox*)pControl)->IsReadOnly() )
5065 {
5066 if ( ! (nParams & PARAM_STR_1) )
5067 aString1 = String();
5068 ((ComboBox*)pControl)->SetText( aString1 );
5069 ((ComboBox*)pControl)->SetModifyFlag();
5070 ((ComboBox*)pControl)->Modify();
5071 }
5072 else
5073 ReportError( aUId, GEN_RES_STR1c( S_ATTEMPT_TO_WRITE_READONLY, "ComboBox" ) );
5074 break;
5075 default:
5076 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "ComboBox" ) );
5077 break;
5078 }
5079 break;
5080 case C_PushButton:
5081 case C_OkButton:
5082 case C_CancelButton:
5083 case C_ImageButton:
5084 switch( nMethodId )
5085 {
5086 case M_AnimateMouse :
5087 AnimateMouse( pControl, Mitte);
5088 break;
5089 case M_Click :
5090 ((PushButton*)pControl)->Click();
5091 break;
5092 default:
5093 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "PushButton" ) );
5094 break;
5095 }
5096 break;
5097 case C_MoreButton:
5098 switch( nMethodId )
5099 {
5100 case M_AnimateMouse :
5101 AnimateMouse( pControl, Mitte);
5102 break;
5103 case M_IsOpen :
5104 pRet->GenReturn ( RET_Value, aUId, ((MoreButton*)pControl)->GetState());
5105 break;
5106 case M_Click :
5107 ((MoreButton*)pControl)->Click();
5108 break;
5109 case M_Open :
5110 ((MoreButton*)pControl)->SetState(sal_True);
5111 break;
5112 case M_Close :
5113 ((MoreButton*)pControl)->SetState(sal_False);
5114 break;
5115 default:
5116 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "MoreButton" ) );
5117 break;
5118 }
5119 break;
5120 case C_SpinField:
5121 case C_PatternField:
5122 case C_NumericField:
5123 case C_MetricField:
5124 case C_CurrencyField:
5125 case C_DateField:
5126 case C_TimeField:
5127 switch( nMethodId )
5128 {
5129 case M_AnimateMouse :
5130 AnimateMouse( pControl, Mitte);
5131 break;
5132 case M_GetText :
5133 pRet->GenReturn ( RET_Value, aUId, ((SpinField*)pControl)->GetText());
5134 break;
5135 case M_IsWritable:
5136 pRet->GenReturn ( RET_Value, aUId, (comm_BOOL) !((SpinField*)pControl)->IsReadOnly() );
5137 break;
5138 case M_SetText :
5139 if ( ! ((SpinField*)pControl)->IsReadOnly() )
5140 {
5141 ((SpinField*)pControl)->SetText( aString1 );
5142 ((SpinField*)pControl)->SetModifyFlag();
5143 ((SpinField*)pControl)->Modify();
5144 }
5145 else
5146 ReportError( aUId, GEN_RES_STR1c( S_ATTEMPT_TO_WRITE_READONLY, "SpinField" ) );
5147 break;
5148 case M_More :
5149 {
5150 if ( !(nParams & PARAM_USHORT_1) )
5151 nNr1 = 1;
5152 for (int i = 1; i<= nNr1; i++)
5153 {
5154 ((SpinField*)pControl)->Up();
5155 ((SpinField*)pControl)->SetModifyFlag();
5156 ((SpinField*)pControl)->Modify();
5157 }
5158 }
5159 break;
5160 case M_Less :
5161 {
5162 if ( !(nParams & PARAM_USHORT_1) )
5163 nNr1 = 1;
5164 for (int i = 1; i<= nNr1; i++)
5165 {
5166 ((SpinField*)pControl)->Down();
5167 ((SpinField*)pControl)->SetModifyFlag();
5168 ((SpinField*)pControl)->Modify();
5169 }
5170 }
5171 break;
5172 case M_ToMin :
5173 ((SpinField*)pControl)->First();
5174 ((SpinField*)pControl)->SetModifyFlag();
5175 ((SpinField*)pControl)->Modify();
5176 break;
5177 case M_ToMax :
5178 ((SpinField*)pControl)->Last();
5179 ((SpinField*)pControl)->SetModifyFlag();
5180 ((SpinField*)pControl)->Modify();
5181 break;
5182 default:
5183 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "SpinField" ) );
5184 break;
5185 }
5186 break;
5187
5188 case C_MenuButton:
5189 switch( nMethodId )
5190 {
5191 case M_AnimateMouse :
5192 AnimateMouse( pControl, Mitte);
5193 break;
5194 case M_Click :
5195 {
5196 MouseEvent aMEvnt;
5197 Point aPt( pControl->GetSizePixel().Width() / 2, pControl->GetSizePixel().Height() / 2 );
5198 aMEvnt = MouseEvent( aPt,1,MOUSE_SIMPLECLICK,MOUSE_LEFT );
5199 ImplMouseButtonDown( pControl, aMEvnt, FORCE_DIRECT_CALL );
5200 ImplMouseButtonUp ( pControl, aMEvnt, FORCE_DIRECT_CALL );
5201 }
5202 break;
5203 case M_Open :
5204 case M_OpenMenu :
5205 {
5206 MouseEvent aMEvnt;
5207 Point aPt( pControl->GetSizePixel().Width() / 2, pControl->GetSizePixel().Height() / 2 );
5208 aMEvnt = MouseEvent( aPt,1,MOUSE_SIMPLECLICK,MOUSE_LEFT );
5209 ImplMouseButtonDown( pControl, aMEvnt, FORCE_DIRECT_CALL );
5210
5211 sal_uLong nStart = Time::GetSystemTicks();
5212 sal_uLong nDelay = pControl->GetSettings().GetMouseSettings().GetActionDelay();
5213 while ( ( Time::GetSystemTicks() - nStart ) < nDelay + 100 )
5214 SafeReschedule();
5215
5216 ImplMouseButtonUp ( pControl, aMEvnt, FORCE_DIRECT_CALL );
5217
5218 aSubMenuId1 = 0;
5219 aSubMenuId2 = 0;
5220 aSubMenuId3 = 0;
5221 pMenuWindow = NULL;
5222 }
5223 break;
5224 default:
5225 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "MenuButton" ) );
5226 break;
5227 }
5228 break;
5229 case C_ToolBox:
5230 {
5231 ToolBox *pTB = ((ToolBox*)pControl);
5232 if ( !aUId.equals( pTB->GetUniqueOrHelpId() ) ) // So we found a Button on the ToolBox
5233 {
5234 if ( (nParams == PARAM_NONE) || (nParams == PARAM_USHORT_1) )
5235 { // Wir f�lschen einen Parameter
5236 nParams |= PARAM_STR_1;
5237 aString1 = Id2Str( aUId );
5238 }
5239 else
5240 ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );
5241 }
5242
5243 #define FIND_ITEM\
5244 sal_uInt16 nItemPos = 0;\
5245 sal_Bool bItemFound = sal_False;\
5246 {\
5247 rtl::OString aButtonId;\
5248 if( nParams & PARAM_STR_1 )\
5249 aButtonId = Str2Id( aString1 );\
5250 else\
5251 ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );\
5252 for ( nItemPos = 0; nItemPos < pTB->GetItemCount() && !aButtonId.equals(Str2Id( pTB->GetItemCommand(pTB->GetItemId(nItemPos)) )) &&\
5253 !aButtonId.equals(pTB->GetHelpId(pTB->GetItemId(nItemPos))) ; nItemPos++ ) {}\
5254 bItemFound = aButtonId.equals(Str2Id( pTB->GetItemCommand(pTB->GetItemId(nItemPos)) )) || aButtonId.equals(pTB->GetHelpId(pTB->GetItemId(nItemPos)));\
5255 if ( !bItemFound )\
5256 ReportError( aUId, GEN_RES_STR1( S_HELPID_ON_TOOLBOX_NOT_FOUND, MethodString( nMethodId ) ) );\
5257 else\
5258 {\
5259 if ( !pTB->IsItemEnabled( pTB->GetItemId(nItemPos) ) && nMethodId != _M_IsEnabled && nMethodId != M_GetState )\
5260 {\
5261 ReportError( aUId, GEN_RES_STR1( S_BUTTON_DISABLED_ON_TOOLBOX, MethodString( nMethodId ) ) );\
5262 bItemFound = sal_False;\
5263 }\
5264 else if ( !pTB->IsItemVisible( pTB->GetItemId(nItemPos) ) && nMethodId != M_GetState )\
5265 {\
5266 ReportError( aUId, GEN_RES_STR1( S_BUTTON_HIDDEN_ON_TOOLBOX, MethodString( nMethodId ) ) );\
5267 bItemFound = sal_False;\
5268 }\
5269 else\
5270 {\
5271 if ( pTB->IsMenuEnabled() )\
5272 { /* button is in Menu */\
5273 }\
5274 else\
5275 { /* Try the multi line way */\
5276 if ( pTB->GetItemRect(pTB->GetItemId(nItemPos)).IsEmpty() )\
5277 {\
5278 sal_uInt16 nLine = pTB->GetCurLine();\
5279 do\
5280 {\
5281 pTB->ShowLine( sal_False );\
5282 for ( int i = 1 ; i < 30 ; i++ )\
5283 SafeReschedule();\
5284 }\
5285 while ( pTB->GetCurLine() != nLine && pTB->GetItemRect(pTB->GetItemId(nItemPos)).IsEmpty() );\
5286 pTB->Invalidate( pTB->GetScrollRect() );\
5287 }\
5288 if ( pTB->GetItemRect(pTB->GetItemId(nItemPos)).IsEmpty() )\
5289 {\
5290 ReportError( aUId, GEN_RES_STR1( S_CANNOT_MAKE_BUTTON_VISIBLE_IN_TOOLBOX, MethodString( nMethodId ) ) );\
5291 bItemFound = sal_False;\
5292 }\
5293 }\
5294 }\
5295 }\
5296 }
5297
5298 switch( nMethodId )
5299 {
5300 case M_AnimateMouse :
5301 AnimateMouse( pControl, MitteLinks);
5302 break;
5303 case M_Click :
5304 {
5305 FIND_ITEM;
5306 if ( bItemFound ) // FIND_ITEM Erfolgreich
5307 {
5308 Rectangle aRect = pTB->GetItemRect(pTB->GetItemId(nItemPos));
5309 if ( aRect.IsEmpty() )
5310 {
5311 pTB->ExecuteCustomMenu();
5312 /* aRect = pTB->GetMenubuttonRect();
5313 MouseEvent aMEvnt(aRect.Center(),1,MOUSE_SIMPLECLICK,MOUSE_LEFT);
5314 ImplMouseButtonDown( pTB, aMEvnt );*/
5315
5316 aSubMenuId1 = 0;
5317 aSubMenuId2 = 0;
5318 aSubMenuId3 = 0;
5319 pMenuWindow = NULL;
5320
5321 new StatementCommand( this, RC_MenuSelect, PARAM_USHORT_1, pTB->GetItemId(nItemPos) + TOOLBOX_MENUITEM_START );
5322 }
5323 else
5324 {
5325 aRect = pTB->GetItemRect(pTB->GetItemId(nItemPos));
5326 MouseEvent aMEvnt;
5327 aMEvnt = MouseEvent(aRect.Center(),1,MOUSE_SIMPLECLICK,MOUSE_LEFT);
5328 ImplMouseButtonDown( pTB, aMEvnt, FORCE_DIRECT_CALL );
5329 ImplMouseButtonUp ( pTB, aMEvnt, FORCE_DIRECT_CALL );
5330 }
5331 }
5332 }
5333 break;
5334 case M_TearOff :
5335 {
5336 FIND_ITEM;
5337 if ( bItemFound ) // FIND_ITEM Erfolgreich
5338 {
5339 Rectangle aRect = pTB->GetItemPosDropDownRect( nItemPos );
5340 AnimateMouse( pControl, aRect.Center() );
5341 MouseEvent aMEvnt(aRect.Center(),1,MOUSE_SIMPLECLICK,MOUSE_LEFT);
5342 ImplMouseButtonDown( pTB, aMEvnt, FORCE_DIRECT_CALL );
5343
5344 Window *pWin = NULL;
5345 // Wait for the window to open.
5346 StatementList::bExecuting = sal_True; // Bah ist das ein ekliger Hack
5347 { // Das verhindert, da� schon der n�chste Befehl ausgef�hrt wird.
5348 Time aDelay;
5349 while ( !pWin && ( (pWin = GetPopupFloatingWin()) == NULL ) && ( Time() - aDelay ).GetSec() < 15 )
5350 SafeReschedule();
5351 }
5352 StatementList::bExecuting = sal_False; // Bah ist das ein ekliger Hack
5353
5354 if ( pWin && pWin->GetType() == WINDOW_FLOATINGWINDOW )
5355 {
5356 aMEvnt = MouseEvent(aRect.Center(),1,MOUSE_SIMPLECLICK,MOUSE_LEFT);
5357 ImplMouseButtonUp( pTB, aMEvnt, FORCE_DIRECT_CALL );
5358 ((FloatingWindow*)pWin)->EndPopupMode( FLOATWIN_POPUPMODEEND_TEAROFF );
5359 }
5360 else
5361 {
5362 aMEvnt = MouseEvent(Point(1,-10), 1, MOUSE_SIMPLECLICK,MOUSE_LEFT);
5363 ImplMouseButtonUp( pTB, aMEvnt, FORCE_DIRECT_CALL );
5364 ReportError( aUId, GEN_RES_STR1( S_TEAROFF_FAILED, MethodString( nMethodId ) ) );
5365 }
5366 }
5367 }
5368 break;
5369 case M_OpenMenu :
5370 {
5371 FIND_ITEM;
5372 if ( bItemFound ) // FIND_ITEM Erfolgreich
5373 {
5374 Rectangle aRect = pTB->GetItemPosDropDownRect( nItemPos );
5375 AnimateMouse( pControl, aRect.Center() );
5376 MouseEvent aMEvnt(aRect.Center(),1,MOUSE_SIMPLECLICK,MOUSE_LEFT);
5377 ImplMouseButtonDown( pTB, aMEvnt);
5378 ImplMouseButtonUp( pTB, aMEvnt);
5379
5380 // Das Fenster ist offen.
5381 aSubMenuId1 = 0;
5382 aSubMenuId2 = 0;
5383 aSubMenuId3 = 0;
5384 pMenuWindow = NULL;
5385 }
5386 }
5387 break;
5388 case _M_IsEnabled:
5389 {
5390 FIND_ITEM;
5391 if ( bItemFound ) // FIND_ITEM Erfolgreich
5392 {
5393 pRet->GenReturn ( RET_Value, aUId, pTB->IsItemEnabled( pTB->GetItemId(nItemPos) ) );
5394 }
5395 }
5396 break;
5397 case M_GetState :
5398 {
5399 FIND_ITEM;
5400 if ( bItemFound ) // FIND_ITEM Erfolgreich
5401 {
5402 if ( ValueOK( aUId, CUniString("GetState"), nNr1, 4 ) )
5403 switch (nNr1)
5404 {
5405 case 0:
5406 pRet->GenReturn ( RET_Value, aUId, Id2Str( pTB->GetHelpId(pTB->GetItemId(nItemPos)) ) );
5407 break;
5408 case 1:
5409 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTB->GetItemType(nItemPos));
5410 break;
5411 case 2:
5412 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTB->GetItemState(pTB->GetItemId(nItemPos)));
5413 break;
5414 case 3:
5415 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTB->GetItemId(nItemPos));
5416 break;
5417 case 11:
5418 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG) nItemPos + 1);
5419 break;
5420 case 12:
5421 pRet->GenReturn ( RET_Value, aUId, Id2Str(pTB->GetHelpId())); // The toolbox's help id
5422 break;
5423 case 13:
5424 {
5425 Rectangle aRect = pTB->GetItemPosRect( nItemPos );
5426 Rectangle aTBRect = pTB->GetWindowExtentsRelative( NULL );
5427 pRet->GenReturn ( RET_Value, aUId,
5428 UniString::CreateFromInt32(aRect.Left()+aTBRect.Left()).
5429 AppendAscii(",").Append(UniString::CreateFromInt32(aRect.Top()+aTBRect.Top())).
5430 AppendAscii(",").Append(UniString::CreateFromInt32(aRect.GetWidth())).
5431 AppendAscii(",").Append(UniString::CreateFromInt32(aRect.GetHeight()))
5432 );
5433 break;
5434 }
5435 default:
5436 ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );
5437 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(0));
5438 break;
5439 }
5440 }
5441 }
5442 break;
5443 case M_GetItemHelpText :
5444 if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pTB->GetItemCount() ))
5445 pRet->GenReturn ( RET_Value, aUId, (String)pTB->GetHelpText(pTB->GetItemId(nNr1-1)));
5446 break;
5447 case M_GetItemQuickHelpText :
5448 if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pTB->GetItemCount() ))
5449 pRet->GenReturn ( RET_Value, aUId, (String)pTB->GetQuickHelpText(pTB->GetItemId(nNr1-1)));
5450 break;
5451 case M_GetItemText2:
5452 if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pTB->GetItemCount() ))
5453 pRet->GenReturn ( RET_Value, aUId, (String)pTB->GetItemText(pTB->GetItemId(nNr1-1)));
5454 break;
5455 case M_GetItemText :
5456 pRet->GenReturn ( RET_Value, aUId, (String)pTB->GetItemText(nNr1));
5457 break;
5458 case M_GetText :
5459 pRet->GenReturn ( RET_Value, aUId, (String)pTB->GetText());
5460 break;
5461 case M_GetItemCount :
5462 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTB->GetItemCount());
5463 break;
5464 case M_SetNextToolBox :
5465 if ( (nParams & PARAM_STR_1) )
5466 pTB->SetNextToolBox( aString1 );
5467 else
5468 pTB->SetNextToolBox( pTB->GetNextToolBox() );
5469 pTB->NextToolBox();
5470 break;
5471 case M_GetNextToolBox :
5472 pRet->GenReturn ( RET_Value, aUId, (String)pTB->GetNextToolBox());
5473 break;
5474 case M_Dock :
5475 case M_Undock :
5476 case M_IsDocked :
5477 case M_Close:
5478 case M_Size:
5479 case M_Move:
5480 case M_IsMax:
5481 case M_Minimize:
5482 case M_Maximize:
5483 case M_Help: // Alles was unten weiterbehandelt werden soll
5484 goto DockingWin;
5485 default:
5486 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "ToolBox" ) );
5487 break;
5488 }
5489 }
5490 break;
5491
5492 case C_TreeListBox:
5493 switch( nMethodId )
5494 {
5495
5496
5497
5498 #define GET_NTH_ENTRY_LBOX( First, Next, Anzahl) \
5499 SvLBoxEntry *pThisEntry = ((SvTreeListBox*)pControl)->First(); \
5500 { \
5501 int niTemp = Anzahl; \
5502 while ( niTemp-- ) \
5503 { \
5504 pThisEntry = ((SvTreeListBox*)pControl)->Next( pThisEntry ); \
5505 } \
5506 }
5507
5508 case M_GetText : // Get the first text of the given (default=1) line
5509 { // should get removed some time
5510 SvTreeListBox *pTree = (SvTreeListBox*)pControl;
5511 SvLBoxEntry *pThisEntry = pTree->GetCurEntry();
5512 if ( ! (nParams & PARAM_USHORT_1) )
5513 nNr1 = 1;
5514 if ( pThisEntry )
5515 {
5516 SvLBoxString* pItem = NULL;
5517 sal_uInt16 nValidTextItemCount = 0;
5518 {
5519 sal_uInt16 nIndex = 0;
5520 SvLBoxItem *pMyItem;
5521 while ( ( nValidTextItemCount < nNr1 ) && nIndex < pThisEntry->ItemCount() )
5522 {
5523 pMyItem = pThisEntry->GetItem( nIndex );
5524 if ( pMyItem->IsA() == SV_ITEM_ID_LBOXSTRING )
5525 {
5526 pItem = (SvLBoxString*)pMyItem;
5527 nValidTextItemCount++;
5528 }
5529 nIndex++;
5530 }
5531 }
5532 if ( ValueOK( aUId, CUniString("GetText"), nNr1, nValidTextItemCount ) )
5533 pRet->GenReturn ( RET_Value, aUId, pItem->GetText() );
5534 }
5535 else
5536 ReportError( aUId, GEN_RES_STR2c2( S_NO_SELECTED_ENTRY, MethodString( nMethodId ), "TreeListBox" ) );
5537 }
5538 break;
5539 case M_GetSelCount :
5540 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((SvLBox*)pControl)->GetSelectionCount()));
5541 break;
5542 case M_GetItemCount :
5543 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((SvLBox*)pControl)->GetVisibleCount()) );
5544 break;
5545 case M_GetSelIndex :
5546 if ( ! (nParams & PARAM_USHORT_1) )
5547 nNr1 = 1;
5548 if ( ValueOK(aUId, CUniString("GetSelIndex"),nNr1,((SvLBox*)pControl)->GetSelectionCount()) )
5549 {
5550 nNr1--;
5551 GET_NTH_ENTRY_LBOX( FirstSelected, NextSelected, nNr1);
5552 pRet->GenReturn ( RET_Value, aUId, comm_ULONG( ((SvTreeListBox*)pControl)->GetVisiblePos( pThisEntry )) +1 );
5553 }
5554 break;
5555 case M_Select :
5556 if ( ! (nParams & PARAM_BOOL_1) )
5557 bBool1 = sal_True;
5558 if( nParams & PARAM_STR_1 )
5559 {
5560 /* ListBox *pLB = ((ListBox*)pControl);
5561 if ( pLB->GetEntryPos( aString1 ) == LISTBOX_ENTRY_NOTFOUND )
5562 ReportError( aUId, GEN_RES_STR2( S_ENTRY_NOT_FOUND, MethodString( nMethodId ), aString1 ) );
5563 else
5564 {
5565 pLB->SelectEntry( aString1, bBool1 );
5566 if ( pLB->IsEntrySelected( aString1 ) ? !bBool1 : bBool1 ) // XOR rein mit BOOL
5567 ReportError( aUId, GEN_RES_STR2( S_METHOD_FAILED, MethodString( nMethodId ), aString1 ) );
5568 }
5569 */ ReportError( aUId, GEN_RES_STR1( S_SELECT_DESELECT_VIA_STRING_NOT_IMPLEMENTED, MethodString( nMethodId ) ) );
5570 }
5571 else
5572 {
5573 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
5574 {
5575 SvLBoxEntry *pEntry = (SvLBoxEntry*)((SvTreeListBox*)pControl)->GetEntryAtVisPos( nNr1-1 );
5576 ((SvTreeListBox*)pControl)->Select ( pEntry, bBool1 );
5577 }
5578 }
5579 break;
5580 case M_Collapse :
5581 if( nParams & PARAM_STR_1 )
5582 {
5583 ReportError( aUId, GEN_RES_STR1( S_SELECT_DESELECT_VIA_STRING_NOT_IMPLEMENTED, MethodString( nMethodId ) ) );
5584 }
5585 else
5586 {
5587 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
5588 {
5589 SvLBoxEntry *pEntry = (SvLBoxEntry*)((SvTreeListBox*)pControl)->GetEntryAtVisPos( nNr1-1 );
5590 ((SvTreeListBox*)pControl)->Collapse ( pEntry );
5591 }
5592 }
5593 break;
5594 case M_Expand :
5595 if( nParams & PARAM_STR_1 )
5596 {
5597 ReportError( aUId, GEN_RES_STR1( S_SELECT_DESELECT_VIA_STRING_NOT_IMPLEMENTED, MethodString( nMethodId ) ) );
5598 }
5599 else
5600 {
5601 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
5602 {
5603 SvLBoxEntry *pEntry = (SvLBoxEntry*)((SvTreeListBox*)pControl)->GetEntryAtVisPos( nNr1-1 );
5604 ((SvTreeListBox*)pControl)->Expand ( pEntry );
5605 }
5606 }
5607 break;
5608 case M_GetSelText :
5609 if ( ! (nParams & PARAM_USHORT_1) )
5610 nNr1 = 1;
5611 if ( ! (nParams & PARAM_USHORT_2) )
5612 nNr2 = 1;
5613 if ( ValueOK(aUId, CUniString("GetSelText"),nNr1,((SvLBox*)pControl)->GetSelectionCount()) )
5614 {
5615 nNr1--;
5616 GET_NTH_ENTRY_LBOX( FirstSelected, NextSelected, nNr1);
5617 if ( ValueOK( aUId, MethodString( nMethodId ),nNr2,pThisEntry->ItemCount() ) )
5618 {
5619 SvLBoxString* pItem = NULL;
5620 if ( ! (nParams & PARAM_USHORT_2) )
5621 pItem = (SvLBoxString*)pThisEntry->GetFirstItem( SV_ITEM_ID_LBOXSTRING );
5622 else
5623 {
5624 SvLBoxItem *pMyItem = pThisEntry->GetItem( nNr2-1 );
5625 if ( pMyItem->IsA() == SV_ITEM_ID_LBOXSTRING )
5626 pItem = (SvLBoxString*)pMyItem;
5627 }
5628
5629 if ( pItem )
5630 pRet->GenReturn ( RET_Value, aUId, pItem->GetText() );
5631 else
5632 ReportError( aUId, GEN_RES_STR1( S_NO_LIST_BOX_STRING, MethodString( nMethodId ) ) );
5633 }
5634 }
5635 break;
5636 case M_GetItemText :
5637 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
5638 {
5639 SvLBoxEntry *pThisEntry = (SvLBoxEntry*)((SvTreeListBox*)pControl)->GetEntryAtVisPos( nNr1-1 );
5640 if ( ! (nParams & PARAM_USHORT_2) )
5641 nNr2 = 1;
5642 if ( ValueOK( aUId, MethodString( nMethodId ),nNr2,pThisEntry->ItemCount() ) )
5643 {
5644 SvLBoxString* pItem = NULL;
5645 if ( ! (nParams & PARAM_USHORT_2) )
5646 pItem = (SvLBoxString*)pThisEntry->GetFirstItem( SV_ITEM_ID_LBOXSTRING );
5647 else
5648 {
5649 SvLBoxItem *pMyItem = pThisEntry->GetItem( nNr2-1 );
5650 if ( pMyItem->IsA() == SV_ITEM_ID_LBOXSTRING )
5651 pItem = (SvLBoxString*)pMyItem;
5652 }
5653
5654 if ( pItem )
5655 pRet->GenReturn ( RET_Value, aUId, pItem->GetText() );
5656 else
5657 ReportError( aUId, GEN_RES_STR1( S_NO_LIST_BOX_STRING, MethodString( nMethodId ) ) );
5658 }
5659 }
5660 break;
5661 case M_IsChecked :
5662 case M_IsTristate :
5663 case M_GetState :
5664 case M_Check :
5665 case M_UnCheck :
5666 case M_TriState :
5667 {
5668 SvTreeListBox *pTree = (SvTreeListBox*)pControl;
5669 SvLBoxEntry *pThisEntry = NULL;
5670
5671 if ( ! (nParams & PARAM_USHORT_1) )
5672 {
5673 pThisEntry = pTree->GetCurEntry();
5674 if ( !pThisEntry )
5675 ReportError( aUId, GEN_RES_STR2c2( S_NO_SELECTED_ENTRY, MethodString( nMethodId ), "TreeListBox" ) );
5676 }
5677 else
5678 {
5679 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
5680 {
5681 pThisEntry = (SvLBoxEntry*)pTree->GetEntryAtVisPos( nNr1-1 );
5682 }
5683 }
5684
5685 if ( ! (nParams & PARAM_USHORT_2) )
5686 nNr2 = 1;
5687
5688 if ( pThisEntry )
5689 {
5690 if ( ValueOK( aUId, MethodString( nMethodId ),nNr2,pThisEntry->ItemCount() ) )
5691 {
5692 SvLBoxButton* pItem = NULL;
5693 if ( ! (nParams & PARAM_USHORT_2) )
5694 pItem = (SvLBoxButton*)pThisEntry->GetFirstItem( SV_ITEM_ID_LBOXBUTTON );
5695 else
5696 {
5697 SvLBoxItem *pMyItem = pThisEntry->GetItem( nNr2-1 );
5698 if ( pMyItem->IsA() == SV_ITEM_ID_LBOXBUTTON )
5699 pItem = (SvLBoxButton*)pMyItem;
5700 }
5701
5702 if ( pItem )
5703 {
5704 switch( nMethodId )
5705 {
5706 case M_IsChecked :
5707 pRet->GenReturn ( RET_Value, aUId, comm_BOOL( pItem->IsStateChecked() ) );
5708 break;
5709 case M_IsTristate :
5710 pRet->GenReturn ( RET_Value, aUId, comm_BOOL( pItem->IsStateTristate() ) );
5711 break;
5712 case M_GetState :
5713 pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pItem->GetButtonFlags() & ~SV_STATE_MASK ));
5714 break;
5715 case M_Check :
5716 if ( !pItem->IsStateChecked() )
5717 {
5718 pItem->SetStateChecked();
5719 pTree->CheckButtonHdl();
5720 pTree->InvalidateEntry( pThisEntry );
5721 }
5722 break;
5723 case M_UnCheck :
5724 if ( pItem->IsStateChecked() || pItem->IsStateTristate() )
5725 {
5726 pItem->SetStateUnchecked();
5727 pTree->CheckButtonHdl();
5728 pTree->InvalidateEntry( pThisEntry );
5729 }
5730 break;
5731 case M_TriState :
5732 if ( !pItem->IsStateTristate() )
5733 {
5734 pItem->SetStateTristate();
5735 pTree->CheckButtonHdl();
5736 pTree->InvalidateEntry( pThisEntry );
5737 }
5738 break;
5739 default:
5740 ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );
5741 break;
5742 }
5743 }
5744 else
5745 ReportError( aUId, GEN_RES_STR1( S_NO_LIST_BOX_BUTTON, MethodString( nMethodId ) ) );
5746 }
5747 }
5748 }
5749 break;
5750 case M_GetItemType :
5751 {
5752 SvTreeListBox *pTree = (SvTreeListBox*)pControl;
5753 SvLBoxEntry *pThisEntry = NULL;
5754
5755 if ( ! (nParams & PARAM_USHORT_1) )
5756 {
5757 pThisEntry = pTree->GetCurEntry();
5758 if ( !pThisEntry )
5759 ReportError( aUId, GEN_RES_STR2c2( S_NO_SELECTED_ENTRY, MethodString( nMethodId ), "TreeListBox" ) );
5760 }
5761 else
5762 {
5763 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
5764 {
5765 pThisEntry = (SvLBoxEntry*)pTree->GetEntryAtVisPos( nNr1-1 );
5766 }
5767 }
5768
5769 if ( pThisEntry )
5770 {
5771 if ( ! (nParams & PARAM_USHORT_2) )
5772 nNr2 = 1;
5773 if ( ValueOK( aUId, MethodString( nMethodId ),nNr2,pThisEntry->ItemCount() ) )
5774 {
5775 SvLBoxItem *pMyItem = pThisEntry->GetItem( nNr2-1 );
5776 comm_USHORT nType;
5777 switch ( pMyItem->IsA() )
5778 {
5779 case SV_ITEM_ID_LBOXSTRING: nType = CONST_ItemTypeText ; break;
5780 case SV_ITEM_ID_LBOXBMP: nType = CONST_ItemTypeBMP ; break;
5781 case SV_ITEM_ID_LBOXBUTTON: nType = CONST_ItemTypeCheckbox ; break;
5782 case SV_ITEM_ID_LBOXCONTEXTBMP: nType = CONST_ItemTypeContextBMP ; break;
5783 default: nType = CONST_ItemTypeUnknown;
5784 }
5785 pRet->GenReturn ( RET_Value, aUId, nType );
5786 }
5787 }
5788 }
5789 break;
5790 default:
5791 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "TreeListBox" ) );
5792 break;
5793 }
5794 break;
5795 case C_Control:
5796 {
5797 sal_uInt16 nRealControlType = 0;
5798 if ( dynamic_cast< EditBrowseBox* >(pControl) )
5799 nRealControlType = CONST_CTBrowseBox;
5800 else if ( dynamic_cast< ValueSet* >(pControl) )
5801 nRealControlType = CONST_CTValueSet;
5802 else if ( dynamic_cast< ORoadmap* >(pControl) )
5803 nRealControlType = CONST_CTORoadmap;
5804 else if ( dynamic_cast< IExtensionListBox* >(pControl) )
5805 nRealControlType = CONST_CTIExtensionListBox;
5806 else if ( dynamic_cast< ::svt::table::TableControl* >(pControl) )
5807 nRealControlType = CONST_CTTableControl;
5808 else
5809 nRealControlType = CONST_CTUnknown;
5810
5811 switch( nMethodId )
5812 {
5813 case M_AnimateMouse :
5814 AnimateMouse( pControl, MitteOben);
5815 break;
5816 default:
5817 switch( nRealControlType )
5818 {
5819 case CONST_CTBrowseBox:
5820 {
5821 EditBrowseBox* pEBBox = dynamic_cast< EditBrowseBox* >(pControl);
5822 switch( nMethodId )
5823 {
5824
5825
5826 /*
5827
5828
5829 sal_Bool MakeFieldVisible( long nRow, sal_uInt16 nColId, sal_Bool bComplete = sal_False );
5830 // access to dynamic values of cursor row
5831 String GetColumnTitle( sal_uInt16 nColumnId ) const;
5832 sal_uInt16 GetColumnId( sal_uInt16 nPos ) const;
5833 sal_uInt16 GetColumnPos( sal_uInt16 nColumnId ) const;
5834 // access and movement of cursor
5835 long GetCurRow() const { return nCurRow; }
5836 sal_uInt16 GetCurColumnId() const { return nCurColId; }
5837 sal_Bool GoToRow( long nRow );
5838 sal_Bool GoToRowAndDoNotModifySelection( long nRow );
5839 sal_Bool GoToColumnId( sal_uInt16 nColId );
5840 sal_Bool GoToRowColumnId( long nRow, sal_uInt16 nColId );
5841 // selections
5842 void SetNoSelection();
5843 void SelectAll();
5844 void SelectRow( long nRow, sal_Bool bSelect = sal_True, sal_Bool bExpand = sal_True );
5845 void SelectColumnPos( sal_uInt16 nCol, sal_Bool bSelect = sal_True )
5846 { SelectColumnPos( nCol, bSelect, sal_True); }
5847 void SelectColumnId( sal_uInt16 nColId, sal_Bool bSelect = sal_True )
5848 { SelectColumnPos( GetColumnPos(nColId), bSelect, sal_True); }
5849 long GetSelectRowCount() const;
5850 sal_uInt16 GetSelectColumnCount() const;
5851 sal_Bool IsRowSelected( long nRow ) const;
5852 sal_Bool IsColumnSelected( sal_uInt16 nColumnId ) const;
5853 long FirstSelectedRow( sal_Bool bInverse = sal_False );
5854 long LastSelectedRow( sal_Bool bInverse = sal_False );
5855 long PrevSelectedRow();
5856 long NextSelectedRow();
5857 const MultiSelection* GetSelection() const
5858 { return bMultiSelection ? uRow.pSel : 0; }
5859 void SetSelection( const MultiSelection &rSelection );
5860
5861 virtual String GetCellText(long _nRow, sal_uInt16 _nColId) const;
5862 sal_uInt16 GetColumnCount() const { return ColCount(); }
5863 protected:
5864 virtual long GetRowCount() const;
5865
5866
5867 EditBrowseBox
5868
5869 sal_Bool IsEditing() const {return aController.Is();}
5870 void InvalidateStatusCell(long nRow) {RowModified(nRow, 0);}
5871 void InvalidateHandleColumn();
5872
5873 CellControllerRef Controller() const { return aController; }
5874 sal_Int32 GetBrowserFlags() const { return m_nBrowserFlags; }
5875
5876 virtual void ActivateCell(long nRow, sal_uInt16 nCol, sal_Bool bSetCellFocus = sal_True);
5877 virtual void DeactivateCell(sal_Bool bUpdate = sal_True);
5878
5879
5880
5881 */
5882 case M_GetSelText :
5883 {
5884 pRet->GenReturn ( RET_Value, aUId, pEBBox->GetCellText( pEBBox->GetCurrRow(), pEBBox->GetColumnId( pEBBox->GetCurrColumn() )));
5885 }
5886 break;
5887 case M_GetColumnCount :
5888 {
5889 sal_uInt16 nColCount = pEBBox->GetColumnCount();
5890 comm_USHORT nUnfrozenColCount = 0;
5891 sal_uInt16 i;
5892 for ( i=0 ; i < nColCount ; i++ )
5893 {
5894 if ( !pEBBox->IsFrozen( pEBBox->GetColumnId( i ) ) )
5895 nUnfrozenColCount++;
5896 }
5897 pRet->GenReturn ( RET_Value, aUId, nUnfrozenColCount );
5898 }
5899 break;
5900 case M_GetRowCount :
5901 {
5902 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pEBBox->GetRowCount() );
5903 }
5904 break;
5905 case M_IsEditing :
5906 {
5907 CellControllerRef aControler;
5908 aControler = pEBBox->Controller();
5909 pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)aControler.Is() );
5910 }
5911 break;
5912 case M_Select :
5913 {
5914 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,pEBBox->GetRowCount() ) )
5915 {
5916 sal_uInt16 nColCount = pEBBox->GetColumnCount();
5917 comm_USHORT nUnfrozenColCount = 0;
5918 sal_uInt16 i;
5919 for ( i=0 ; i < nColCount ; i++ )
5920 {
5921 if ( !pEBBox->IsFrozen( pEBBox->GetColumnId( i ) ) )
5922 nUnfrozenColCount++;
5923 }
5924 if ( ValueOK(aUId, MethodString( nMethodId ),nNr2,nUnfrozenColCount ) )
5925 pEBBox->GoToRowColumnId( nNr1-1, pEBBox->GetColumnId( nNr2 ) );
5926 }
5927 }
5928 break;
5929
5930
5931
5932 /*
5933 case M_GetSelCount :
5934 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((SvLBox*)pControl)->GetSelectionCount()));
5935 break;
5936 case M_GetSelIndex :
5937 if ( ! (nParams & PARAM_USHORT_1) )
5938 nNr1 = 1;
5939 if ( ValueOK(aUId, CUniString("GetSelIndex"),nNr1,((SvLBox*)pControl)->GetSelectionCount()) )
5940 {
5941 nNr1--;
5942 COUNT_LBOX( FirstSelected, NextSelected, nNr1);
5943 pRet->GenReturn ( RET_Value, aUId, comm_ULONG( ((SvTreeListBox*)pControl)->GetVisiblePos( pThisEntry )) +1 );
5944 }
5945 break;
5946 case M_GetSelText :
5947 if ( ! (nParams & PARAM_USHORT_1) )
5948 nNr1 = 1;
5949 if ( ValueOK(aUId, CUniString("GetSelText"),nNr1,((SvLBox*)pControl)->GetSelectionCount()) )
5950 {
5951 nNr1--;
5952 COUNT_LBOX( FirstSelected, NextSelected, nNr1);
5953 GetFirstValidTextItem( pThisEntry );
5954 pRet->GenReturn ( RET_Value, aUId, pItem->GetText() );
5955 }
5956 break;
5957 case M_GetItemCount :
5958 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(((SvLBox*)pControl)->GetVisibleCount()) );
5959 break;
5960 case M_GetItemText :
5961 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
5962 {
5963 SvLBoxEntry *pEntry = (SvLBoxEntry*)((SvTreeListBox*)pControl)->GetEntryAtVisPos( nNr1-1 );
5964 GetFirstValidTextItem( pEntry );
5965 pRet->GenReturn ( RET_Value, aUId, pItem->GetText() );
5966 }
5967 break;
5968 case M_Select :
5969 if ( ! (nParams & PARAM_BOOL_1) )
5970 bBool1 = sal_True;
5971 if( nParams & PARAM_STR_1 )
5972 {
5973 / * ListBox *pLB = ((ListBox*)pControl);
5974 if ( pLB->GetEntryPos( aString1 ) == LISTBOX_ENTRY_NOTFOUND )
5975 ReportError( aUId, GEN_RES_STR2( S_ENTRY_NOT_FOUND, MethodString( nMethodId ), aString1 ) );
5976 else
5977 {
5978 pLB->SelectEntry( aString1, bBool1 );
5979 if ( pLB->IsEntrySelected( aString1 ) ? !bBool1 : bBool1 ) // XOR rein mit BOOL
5980 ReportError( aUId, GEN_RES_STR2( S_METHOD_FAILED, MethodString( nMethodId ), aString1 ) );
5981 }
5982 * / ReportError( aUId, GEN_RES_STR1( S_SELECT_DESELECT_VIA_STRING_NOT_IMPLEMENTED, MethodString( nMethodId ) ) );
5983 }
5984 else
5985 {
5986 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,((SvLBox*)pControl)->GetVisibleCount()) )
5987 {
5988 SvLBoxEntry *pEntry = (SvLBoxEntry*)((SvTreeListBox*)pControl)->GetEntryAtVisPos( nNr1-1 );
5989 ((SvTreeListBox*)pControl)->Select ( pEntry, bBool1 );
5990 }
5991 }
5992 break;*/
5993 default:
5994 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "EditBrowseBox" ) );
5995 break;
5996 }
5997 }
5998 break;
5999 case CONST_CTValueSet:
6000 {
6001 ValueSet *pVS = dynamic_cast< ValueSet* >(pControl);
6002 switch ( nMethodId )
6003 {
6004 case M_GetItemCount:
6005 pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pVS->GetItemCount()));
6006 break;
6007 case M_GetItemText:
6008 if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pVS->GetItemCount() ))
6009 pRet->GenReturn ( RET_Value, aUId, pVS->GetItemText( pVS->GetItemId( nNr1-1 ) ) );
6010 break;
6011 case M_Select:
6012 if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pVS->GetItemCount() ))
6013 pVS->SelectItem( pVS->GetItemId( nNr1-1 ) );
6014 break;
6015 case M_GetSelIndex :
6016 if ( pVS->IsNoSelection() )
6017 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(0));
6018 else
6019 pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pVS->GetItemPos( pVS->GetSelectItemId() ) +1));
6020 break;
6021 case M_GetSelText :
6022 if ( pVS->IsNoSelection() )
6023 pRet->GenReturn ( RET_Value, aUId, String() );
6024 else
6025 pRet->GenReturn ( RET_Value, aUId, pVS->GetItemText( pVS->GetSelectItemId() ) );
6026 break;
6027 case M_SetNoSelection :
6028 pVS->SetNoSelection();
6029 break;
6030 default:
6031 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "ValueSet" ) );
6032 break;
6033 }
6034 }
6035 break;
6036 case CONST_CTORoadmap:
6037 {
6038 ORoadmap *pRM = dynamic_cast< ORoadmap* >(pControl);
6039 switch ( nMethodId )
6040 {
6041 case M_GetItemCount:
6042 pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pRM->GetItemCount()));
6043 break;
6044 case M_GetItemText:
6045 if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pRM->GetItemCount() ))
6046 pRet->GenReturn ( RET_Value, aUId, pRM->GetRoadmapItemLabel( pRM->GetItemID( nNr1-1 ) ) );
6047 break;
6048 case M_Select:
6049 if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pRM->GetItemCount() ))
6050 {
6051 if ( pRM->IsRoadmapItemEnabled( pRM->GetItemID( nNr1-1 ) ) )
6052 pRM->SelectRoadmapItemByID( pRM->GetItemID( nNr1-1 ) );
6053 else
6054 ReportError( aUId, GEN_RES_STR1c( S_WIN_DISABLED, "RoadmapItem" ) );
6055 }
6056 break;
6057 case M_GetSelIndex :
6058 pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pRM->GetItemIndex( pRM->GetCurrentRoadmapItemID() ) +1));
6059 break;
6060 case M_GetSelText :
6061 pRet->GenReturn ( RET_Value, aUId, pRM->GetRoadmapItemLabel( pRM->GetCurrentRoadmapItemID() ) );
6062 break;
6063 case M_IsItemEnabled :
6064 if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pRM->GetItemCount() ))
6065 pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)pRM->IsRoadmapItemEnabled( pRM->GetItemID( nNr1-1 ) ) );
6066 break;
6067 default:
6068 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "RoadMap" ) );
6069 break;
6070 }
6071 }
6072 break;
6073 case CONST_CTIExtensionListBox:
6074 {
6075 IExtensionListBox *pELB = dynamic_cast< IExtensionListBox* >(pControl);
6076 switch ( nMethodId )
6077 {
6078 case M_GetItemCount:
6079 pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pELB->getItemCount()));
6080 break;
6081 case M_GetItemText:
6082 if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pELB->getItemCount() ))
6083 switch ( nNr2 )
6084 {
6085 case 1:
6086 pRet->GenReturn ( RET_Value, aUId, pELB->getItemName( nNr1 -1 ) );
6087 break;
6088 case 2:
6089 pRet->GenReturn ( RET_Value, aUId, pELB->getItemVersion( nNr1 -1 ) );
6090 break;
6091 case 3:
6092 pRet->GenReturn ( RET_Value, aUId, pELB->getItemDescription( nNr1 -1 ) );
6093 break;
6094 case 4:
6095 pRet->GenReturn ( RET_Value, aUId, pELB->getItemPublisher( nNr1 -1 ) );
6096 break;
6097 case 5:
6098 pRet->GenReturn ( RET_Value, aUId, pELB->getItemPublisherLink( nNr1 -1 ) );
6099 break;
6100 default:
6101 ValueOK( aUId, MethodString( nMethodId ).AppendAscii(" String Number"), nNr2, 5 );
6102 }
6103 break;
6104 case M_Select:
6105 if ( (nParams & PARAM_USHORT_1) )
6106 {
6107 if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pELB->getItemCount() ))
6108 {
6109 pELB->select( nNr1-1 );
6110 }
6111 }
6112 else if ( (nParams & PARAM_STR_1) )
6113 {
6114 pELB->select( aString1 );
6115 sal_Bool bSuccess = sal_True;
6116 if ( pELB->getSelIndex() == EXTENSION_LISTBOX_ENTRY_NOTFOUND )
6117 bSuccess = sal_False;
6118 else
6119 {
6120 if ( !aString1.Equals( String( pELB->getItemName( pELB->getSelIndex() ) ) ) )
6121 bSuccess = sal_False;
6122 }
6123 if ( !bSuccess )
6124 ReportError( aUId, GEN_RES_STR2( S_ENTRY_NOT_FOUND, MethodString( nMethodId ), aString1 ) );
6125 }
6126 break;
6127 case M_GetSelCount :
6128 if ( pELB->getSelIndex() == EXTENSION_LISTBOX_ENTRY_NOTFOUND )
6129 pRet->GenReturn ( RET_Value, aUId, comm_ULONG( 0 ));
6130 else
6131 pRet->GenReturn ( RET_Value, aUId, comm_ULONG( 1 ));
6132 break;
6133 case M_GetSelIndex :
6134 if ( pELB->getSelIndex() == EXTENSION_LISTBOX_ENTRY_NOTFOUND )
6135 pRet->GenReturn ( RET_Value, aUId, comm_ULONG( 0 ));
6136 else
6137 pRet->GenReturn ( RET_Value, aUId, comm_ULONG( pELB->getSelIndex() +1));
6138 break;
6139 /* xxxcase M_SetNoSelection :
6140 ((ListBox*)pControl)->SetNoSelection();
6141 ((ListBox*)pControl)->Select();
6142 break; */
6143 default:
6144 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "RoadMap" ) );
6145 break;
6146 }
6147 }
6148 break;
6149
6150 case CONST_CTTableControl:
6151 {
6152 ::svt::table::TableControl *pTC = dynamic_cast< ::svt::table::TableControl* >(pControl);
6153 switch ( nMethodId )
6154 {
6155 case M_GetItemType :
6156 {
6157 if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pTC->GetColumnCount() ) &&
6158 ValueOK( aUId, MethodString( nMethodId ), nNr2, pTC->GetRowCount() ))
6159 {
6160 ::svt::table::PTableModel pModel = pTC->GetModel();
6161 Any aCell;
6162 pModel->getCellContent( nNr1-1, nNr2-1, aCell );
6163 pRet->GenReturn ( RET_Value, aUId, String( aCell.getValueTypeName() ));
6164 }
6165 }
6166 break;
6167 case M_GetItemText :
6168 {
6169 if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pTC->GetColumnCount() ) &&
6170 ValueOK( aUId, MethodString( nMethodId ), nNr2, pTC->GetRowCount() ))
6171 {
6172 ::svt::table::PTableModel pModel = pTC->GetModel();
6173 Any aCell;
6174 pModel->getCellContent( nNr1-1, nNr2-1, aCell );
6175 /* doesn't work ATM since it gets casted to SbxDATE in VCLTestTool unfortunately
6176 SbxVariableRef xRes = new SbxVariable( SbxVARIANT );
6177 unoToSbxValue( xRes, aCell );
6178 pRet->GenReturn ( RET_Value, aUId, *xRes );*/
6179
6180 Type aType = aCell.getValueType();
6181 TypeClass eTypeClass = aType.getTypeClass();
6182 switch( eTypeClass )
6183 {
6184 /*case TypeClass_ENUM:
6185 {
6186 sal_Int32 nEnum = 0;
6187 enum2int( nEnum, aValue );
6188 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)nEnum );
6189 }
6190 break;*/
6191 case TypeClass_BOOLEAN:
6192 pRet->GenReturn ( RET_Value, aUId, *(sal_Bool*)aCell.getValue() );
6193 break;
6194 case TypeClass_CHAR:
6195 {
6196 ::rtl::OUString aContent( *(sal_Unicode*)aCell.getValue() );
6197 pRet->GenReturn ( RET_Value, aUId, aContent );
6198 }
6199 break;
6200 case TypeClass_STRING:
6201 {
6202 ::rtl::OUString aContent;
6203 aCell >>= aContent;
6204 pRet->GenReturn ( RET_Value, aUId, aContent );
6205 }
6206 break;
6207 //case TypeClass_FLOAT: break;
6208 //case TypeClass_DOUBLE: break;
6209 //case TypeClass_OCTET: break;
6210 case TypeClass_BYTE:
6211 case TypeClass_SHORT:
6212 case TypeClass_LONG:
6213 case TypeClass_HYPER:
6214 case TypeClass_UNSIGNED_LONG:
6215 case TypeClass_UNSIGNED_HYPER:
6216 {
6217 comm_ULONG val = 0;
6218 aCell >>= val;
6219 pRet->GenReturn ( RET_Value, aUId, val );
6220 }
6221 break;
6222 //case TypeClass_UNSIGNED_OCTET:break;
6223 case TypeClass_UNSIGNED_SHORT:
6224 {
6225 comm_USHORT val = 0;
6226 aCell >>= val;
6227 pRet->GenReturn ( RET_Value, aUId, val );
6228 }
6229 break;
6230 default:
6231 pRet->GenReturn ( RET_Value, aUId, comm_USHORT(0) );
6232 break;
6233 }
6234 }
6235 }
6236 break;
6237 case M_GetColumnCount :
6238 {
6239 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTC->GetColumnCount() );
6240 }
6241 break;
6242 case M_GetRowCount :
6243 {
6244 pRet->GenReturn ( RET_Value, aUId, (comm_ULONG)pTC->GetRowCount() );
6245 }
6246 break;
6247 case M_Select :
6248 {
6249 if ( ValueOK( aUId, MethodString( nMethodId ), nNr1, pTC->GetRowCount() ))
6250 {
6251 if ( pTC->GoToRow( ::svt::table::RowPos( nNr1-1 ) ) )
6252 {
6253 Size aSize( pTC->GetSizePixel() );
6254 // DirectLog( S_QAError, UniString::CreateFromInt32( aSize.Width() ).Append( UniString::CreateFromInt32( aSize.Height() ) ) );
6255 Point aPos( aSize.Width() / 2, aSize.Height() / 2 );
6256 long nStep = aSize.Height() / 4;
6257 ::svt::table::RowPos nLastPos;
6258 while ( ( nLastPos = pTC->getTableControlInterface().hitTest( aPos ).nRow ) != nNr1-1 && nStep > 0 )
6259 {
6260 if ( nLastPos > nNr1-1 || nLastPos == ROW_INVALID )
6261 aPos.Y() -= nStep;
6262 else
6263 aPos.Y() += nStep;
6264 nStep /= 2;
6265 }
6266 if ( pTC->getTableControlInterface().hitTest( aPos ).nRow == nNr1-1 )
6267 {
6268 MouseEvent aMEvnt(aPos,1,MOUSE_SIMPLECLICK|MOUSE_SELECT,MOUSE_LEFT,KEY_MOD1);
6269 pTC->getSelEngine()->SelMouseButtonDown( aMEvnt );
6270 pTC->getSelEngine()->SelMouseButtonUp( aMEvnt );
6271 if ( pTC->IsRowSelected( nNr1-1 ) )
6272 pTC->Select();
6273 }
6274 else
6275 ReportError( aUId, GEN_RES_STR2c2( S_METHOD_FAILED, MethodString( nMethodId ), "find pos" ) );
6276 }
6277 else
6278 ReportError( aUId, GEN_RES_STR2c2( S_METHOD_FAILED, MethodString( nMethodId ), "GoTo" ) );
6279 }
6280 }
6281 break;
6282 case M_GetSelCount :
6283 pRet->GenReturn ( RET_Value, aUId, comm_USHORT( pTC->GetSelectedRowCount() ));
6284 break;
6285 case M_GetSelIndex :
6286 if ( ! (nParams & PARAM_USHORT_1) )
6287 nNr1 = 1;
6288 if ( ValueOK( aUId, CUniString("GetSelIndex"), nNr1, pTC->GetSelectedRowCount() ) )
6289 pRet->GenReturn ( RET_Value, aUId, comm_USHORT( pTC->GetSelectedRowIndex( nNr1-1 ) +1 ) );
6290 break;
6291 /* case M_GetSelText :
6292 if ( ! (nParams & PARAM_USHORT_1) )
6293 nNr1 = 1;
6294 if ( ValueOK(aUId, CUniString("GetSelText"),nNr1,((SvLBox*)pControl)->GetSelectionCount()) )
6295 {
6296 nNr1--;
6297 COUNT_LBOX( FirstSelected, NextSelected, nNr1);
6298 GetFirstValidTextItem( pThisEntry );
6299 pRet->GenReturn ( RET_Value, aUId, pItem->GetText() );
6300 }
6301 break;
6302 */
6303 default:
6304 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "TableControl" ) );
6305 break;
6306 }
6307 }
6308 break;
6309
6310 case CONST_CTUnknown:
6311 ReportError( aUId, GEN_RES_STR2( S_UNKNOWN_TYPE, UniString::CreateFromInt32( nRT ), MethodString(nMethodId) ) );
6312 break;
6313 default:
6314 ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );
6315 break;
6316 }
6317 }
6318 break;
6319 }
6320 case C_Window:
6321 switch( nMethodId )
6322 {
6323 case M_AnimateMouse :
6324 AnimateMouse( pControl, MitteOben);
6325 break;
6326 default:
6327 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "Window" ) );
6328 break;
6329 }
6330 break;
6331
6332 case C_DockingWin:
6333 DockingWin:
6334 switch( nMethodId )
6335 {
6336 case M_AnimateMouse :
6337 AnimateMouse( pControl, MitteOben);
6338 break;
6339 case M_Dock :
6340 if ( ((DockingWindow*)pControl)->IsFloatingMode() )
6341 ((DockingWindow*)pControl)->SetFloatingMode(sal_False);
6342 else
6343 ReportError( aUId, GEN_RES_STR1( S_ALLOWED_ONLY_IN_FLOATING_MODE, MethodString( nMethodId ) ) );
6344 break;
6345 case M_Undock :
6346 if ( !((DockingWindow*)pControl)->IsFloatingMode() )
6347 ((DockingWindow*)pControl)->SetFloatingMode(sal_True);
6348 else
6349 ReportError( aUId, GEN_RES_STR1( S_ALLOWED_ONLY_IN_FLOATING_MODE, MethodString( nMethodId ) ) );
6350 break;
6351 case M_IsDocked :
6352 pRet->GenReturn ( RET_Value, aUId, (comm_BOOL) !((DockingWindow*)pControl)->IsFloatingMode());
6353 break;
6354 case M_Close:
6355 //aWindowWaitUId = aUId;
6356 DBG_ASSERT( aUId.equals( pControl->GetUniqueOrHelpId() ), "aUID != UniqueOrHelpId");
6357 SET_WINP_CLOSING(pControl);
6358 ((DockingWindow*)pControl)->Close();
6359 break;
6360 case M_Size:
6361 case M_Move:
6362 case M_IsMax:
6363 case M_Minimize:
6364 case M_Maximize:
6365 if ( ((DockingWindow*)pControl)->IsFloatingMode() )
6366 {
6367 Window* pFloat = ((DockingWindow*)pControl)->GetFloatingWindow();
6368 if ( !pFloat && ((DockingWindow*)pControl)->IsFloatingMode() )
6369 {
6370 if ( pControl->GET_REAL_PARENT() && pControl->GET_REAL_PARENT()->GetType() == WINDOW_FLOATINGWINDOW )
6371 pFloat = pControl->GET_REAL_PARENT();
6372 else
6373 {
6374 DBG_ERROR("FloatingMode set but Parent is no FloatingWindow");
6375 }
6376 }
6377 if ( pFloat && pFloat->GetType() == WINDOW_FLOATINGWINDOW )
6378 {
6379 pControl = pFloat;
6380 goto FloatWin;
6381 }
6382 else
6383 ReportError( aUId, GEN_RES_STR1( S_CANNOT_FIND_FLOATING_WIN, MethodString( nMethodId ) ) );
6384 }
6385 else
6386 ReportError( aUId, GEN_RES_STR1( S_ALLOWED_ONLY_IN_DOCKING_MODE, MethodString( nMethodId ) ) );
6387 break;
6388 case M_Help: // Alles was unten weiterbehandelt werden soll
6389 goto MoreDialog;
6390
6391 default:
6392 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "DockingWindow" ) );
6393 break;
6394 }
6395 break;
6396 case C_FloatWin:
6397 FloatWin:
6398 switch( nMethodId )
6399 {
6400 case M_AnimateMouse :
6401 AnimateMouse( pControl, MitteOben);
6402 break;
6403 case M_IsMax :
6404 pRet->GenReturn ( RET_Value, aUId, (comm_BOOL)!((FloatingWindow*)pControl)->IsRollUp());
6405 break;
6406 case M_Minimize :
6407 ((FloatingWindow*)pControl)->RollUp();
6408 break;
6409 case M_Maximize :
6410 ((FloatingWindow*)pControl)->RollDown();
6411 break;
6412 case M_Size:
6413 {
6414 if ( pControl->GetStyle() & WB_SIZEABLE )
6415 {
6416 Size aMin = ((FloatingWindow*)pControl)->GetMinOutputSizePixel();
6417 if ( aMin.Width() <= nNr1 && aMin.Height() <= nNr2 )
6418 {
6419 pControl->SetSizePixel(Size(nNr1,nNr2));
6420 pControl->Resize();
6421 }
6422 else
6423 {
6424 ReportError( aUId, GEN_RES_STR2( S_SIZE_BELOW_MINIMUM, String::CreateFromInt32( aMin.Width() ), String::CreateFromInt32( aMin.Height() ) ) );
6425 }
6426 }
6427 else
6428 ReportError( aUId, GEN_RES_STR1( S_SIZE_NOT_CHANGEABLE, MethodString( nMethodId ) ) );
6429 break;
6430 }
6431 case M_Close:
6432 DBG_ASSERT( aUId.equals( pControl->GetUniqueOrHelpId() ), "aUID != UniqueOrHelpId");
6433 SET_WINP_CLOSING(pControl);
6434 ((FloatingWindow*)pControl)->Close();
6435 break;
6436 case M_Help: // Alles was unten weiterbehandelt werden soll
6437 case M_Move:
6438 goto MoreDialog;
6439 default:
6440 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "FloatingWin" ) );
6441 break;
6442 }
6443 break;
6444 case C_ModelessDlg:
6445 case C_ModalDlg:
6446 case C_Dialog:
6447 case C_TabDlg:
6448 MoreDialog:
6449 switch( nMethodId )
6450 {
6451 case M_AnimateMouse :
6452 AnimateMouse( pControl, MitteOben);
6453 break;
6454 case M_Close:
6455 DBG_ASSERT( aUId.equals( pControl->GetUniqueOrHelpId() ), "aUID != UniqueOrHelpId");
6456 SET_WINP_CLOSING(pControl);
6457 ((SystemWindow*)pControl)->Close();
6458 break;
6459 case M_OK:
6460 {
6461 Window *pChild = GetWinByRT( pControl, WINDOW_OKBUTTON );
6462 if( ControlOK( pChild, "OK Button" ) )
6463 {
6464 DBG_ASSERT( aUId.equals( pControl->GetUniqueOrHelpId() ), "aUID != UniqueOrHelpId");
6465 SET_WINP_CLOSING(pControl);
6466 ((Button*)pChild)->Click();
6467 }
6468 break;
6469 }
6470 case M_Cancel:
6471 {
6472 Window *pChild = GetWinByRT( pControl, WINDOW_CANCELBUTTON );
6473 if( ControlOK( pChild, "Cancel Button" ) )
6474 {
6475 DBG_ASSERT( aUId.equals( pControl->GetUniqueOrHelpId() ), "aUID != UniqueOrHelpId");
6476 SET_WINP_CLOSING(pControl);
6477 ((Button*)pChild)->Click();
6478 }
6479 break;
6480 }
6481 case M_Help:
6482 {
6483 Window *pChild = GetWinByRT( pControl, WINDOW_HELPBUTTON );
6484 if( ControlOK( pChild, "Help Button" ) )
6485 ((Button*)pChild)->Click();
6486 break;
6487 }
6488 case M_Default:
6489 {
6490 Window *pChild = ImpGetButton( pControl, WB_DEFBUTTON, WB_DEFBUTTON );
6491 if( ControlOK( pChild, "Default Button" ) )
6492 ((Button*)pChild)->Click();
6493 break;
6494 }
6495 case M_Move:
6496 {
6497 pControl->SetPosPixel(Point(nNr1,nNr2));
6498 break;
6499 }
6500 default:
6501 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "Dialog" ) );
6502 break;
6503 }
6504 break;
6505 case C_WorkWin:
6506 switch( nMethodId )
6507 {
6508 case M_AnimateMouse :
6509 AnimateMouse( pControl, MitteOben);
6510 break;
6511 case M_Close:
6512 DBG_ASSERT( aUId.equals( pControl->GetUniqueOrHelpId() ), "aUID != UniqueOrHelpId");
6513 SET_WINP_CLOSING(pControl);
6514 ((WorkWindow*)pControl)->Close();
6515 break;
6516 case M_Size:
6517 case M_Move:
6518 goto FloatWin;
6519 // break;
6520 case M_IsMax :
6521 pRet->GenReturn ( RET_Value, aUId, ((WorkWindow*)pControl)->IsMaximized() );
6522 break;
6523 case M_IsMin :
6524 pRet->GenReturn ( RET_Value, aUId, ((WorkWindow*)pControl)->IsMinimized() );
6525 break;
6526 case M_IsRestore :
6527 pRet->GenReturn ( RET_Value, aUId, comm_BOOL (!((WorkWindow*)pControl)->IsMaximized() && !((WorkWindow*)pControl)->IsMinimized()) );
6528 break;
6529 case M_Minimize :
6530 ((WorkWindow*)pControl)->Maximize( sal_False );
6531 ((WorkWindow*)pControl)->Minimize();
6532 break;
6533 case M_Maximize :
6534 ((WorkWindow*)pControl)->Maximize();
6535 break;
6536 case M_Restore :
6537 ((WorkWindow*)pControl)->Maximize( sal_False );
6538 ((WorkWindow*)pControl)->Restore();
6539 break;
6540 case M_Help: // Alles was unten weiterbehandelt werden soll
6541 goto MoreDialog;
6542 default:
6543 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "WorkWindow" ) );
6544 break;
6545 }
6546 break;
6547 case C_TabPage:
6548 ReportError( aUId, GEN_RES_STR1( S_INTERNAL_ERROR, MethodString( nMethodId ) ) );
6549 break;
6550 case C_MessBox:
6551 case C_InfoBox:
6552 case C_WarningBox:
6553 case C_ErrorBox:
6554 case C_QueryBox:
6555 {
6556 sal_Bool bDone = sal_True;
6557 MessBox* pMB = (MessBox*)pControl;
6558 switch( nMethodId )
6559 {
6560 case M_GetCheckBoxText:
6561 pRet->GenReturn ( RET_Value, aUId, pMB->GetCheckBoxText() );
6562 break;
6563 case M_IsChecked :
6564 pRet->GenReturn ( RET_Value, aUId, comm_BOOL( pMB->GetCheckBoxState() == STATE_CHECK) );
6565 break;
6566 case M_Check :
6567 pMB->SetCheckBoxState( sal_True );
6568 break;
6569 case M_UnCheck :
6570 pMB->SetCheckBoxState( sal_False );
6571 break;
6572 case M_GetText :
6573 pRet->GenReturn ( RET_Value, aUId, pMB->GetMessText());
6574 break;
6575
6576 default:
6577 bDone = sal_False;
6578 break;
6579 }
6580 if ( bDone )
6581 break; // break the case here else continue at C_ButtonDialog
6582 }
6583 case C_ButtonDialog:
6584 {
6585 ButtonDialog* pBD = (ButtonDialog*)pControl;
6586 #if OSL_DEBUG_LEVEL > 1
6587 m_pDbgWin->AddText( "Working MessBox: " );
6588 if (pControl->IsVisible())
6589 m_pDbgWin->AddText("*(Visible)\n");
6590 else
6591 m_pDbgWin->AddText("*(nicht Visible)\n");
6592 #endif
6593 switch( nMethodId )
6594 {
6595 case M_AnimateMouse :
6596 AnimateMouse( pControl, Mitte);
6597 break;
6598 case M_OK:
6599 if ( pBD->GetPushButton( BUTTONID_OK ) )
6600 {
6601 SET_WINP_CLOSING(pControl);
6602 pBD->EndDialog(RET_OK);
6603 }
6604 else
6605 ReportError( aUId, GEN_RES_STR1( S_NO_OK_BUTTON, MethodString( nMethodId ) ) );
6606 break;
6607 case M_Cancel:
6608 if ( pBD->GetPushButton( BUTTONID_CANCEL ) )
6609 {
6610 SET_WINP_CLOSING(pControl);
6611 pBD->EndDialog(RET_CANCEL);
6612 }
6613 else
6614 ReportError( aUId, GEN_RES_STR1( S_NO_CANCEL_BUTTON, MethodString( nMethodId ) ) );
6615 break;
6616 case M_Yes:
6617 if ( pBD->GetPushButton( BUTTONID_YES ) )
6618 {
6619 SET_WINP_CLOSING(pControl);
6620 pBD->EndDialog(RET_YES);
6621 }
6622 else
6623 ReportError( aUId, GEN_RES_STR1( S_NO_YES_BUTTON, MethodString( nMethodId ) ) );
6624 break;
6625 case M_No:
6626 if ( pBD->GetPushButton( BUTTONID_NO ) )
6627 {
6628 SET_WINP_CLOSING(pControl);
6629 pBD->EndDialog(RET_NO);
6630 }
6631 else
6632 ReportError( aUId, GEN_RES_STR1( S_NO_NO_BUTTON, MethodString( nMethodId ) ) );
6633 break;
6634 case M_Repeat:
6635 if ( pBD->GetPushButton( BUTTONID_RETRY ) )
6636 {
6637 SET_WINP_CLOSING(pControl);
6638 pBD->EndDialog(RET_RETRY);
6639 }
6640 else
6641 ReportError( aUId, GEN_RES_STR1( S_NO_RETRY_BUTTON, MethodString( nMethodId ) ) );
6642 break;
6643 case M_Help:
6644 if ( pBD->GetPushButton( BUTTONID_HELP ) )
6645 {
6646 SET_WINP_CLOSING(pControl);
6647 pBD->EndDialog(BUTTONID_HELP);
6648 }
6649 else
6650 ReportError( aUId, GEN_RES_STR1( S_NO_HELP_BUTTON, MethodString( nMethodId ) ) );
6651 break;
6652 case M_Default:
6653 {
6654 WinBits Style = pControl->GetStyle();
6655 if ( Style & WB_DEF_OK )
6656 {
6657 SET_WINP_CLOSING(pControl);
6658 pBD->EndDialog(RET_OK);
6659 }
6660 else if ( Style & WB_DEF_CANCEL )
6661 {
6662 SET_WINP_CLOSING(pControl);
6663 pBD->EndDialog(RET_CANCEL);
6664 }
6665 else if ( Style & WB_DEF_YES )
6666 {
6667 SET_WINP_CLOSING(pControl);
6668 pBD->EndDialog(RET_YES);
6669 }
6670 else if ( Style & WB_DEF_NO )
6671 {
6672 SET_WINP_CLOSING(pControl);
6673 pBD->EndDialog(RET_NO);
6674 }
6675 else if ( Style & WB_DEF_RETRY )
6676 {
6677 SET_WINP_CLOSING(pControl);
6678 pBD->EndDialog(RET_RETRY);
6679 }
6680 else
6681 ReportError( aUId, GEN_RES_STR1( S_NO_DEFAULT_BUTTON, MethodString( nMethodId ) ) );
6682 }
6683 break;
6684 case M_GetText :
6685 pRet->GenReturn ( RET_Value, aUId, pControl->GetText());
6686 break;
6687 case M_Click:
6688 if ( nParams & PARAM_USHORT_1 )
6689 {
6690 if ( pBD->GetPushButton( nNr1 ) )
6691 {
6692 if ( nNr1 != BUTTONID_HELP )
6693 {
6694 SET_WINP_CLOSING(pControl);
6695 }
6696 pBD->GetPushButton( nNr1 )->Click();
6697 }
6698 else
6699 ReportError( aUId, GEN_RES_STR2( S_NO_DEFAULT_BUTTON, UniString::CreateFromInt32( nNr1 ), MethodString( nMethodId ) ) );
6700 }
6701 else
6702 ReportError( aUId, GEN_RES_STR1( S_BUTTONID_REQUIRED, MethodString( nMethodId ) ) );
6703 break;
6704 case M_GetButtonCount :
6705 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(pBD->GetButtonCount()));
6706 break;
6707 case M_GetButtonId :
6708 if ( ValueOK(aUId, MethodString( nMethodId ),nNr1,pBD->GetButtonCount()) )
6709 pRet->GenReturn ( RET_Value, aUId, comm_ULONG(pBD->GetButtonId(nNr1-1)));
6710 break;
6711 default:
6712 ReportError( aUId, GEN_RES_STR2c2( S_UNKNOWN_METHOD, MethodString(nMethodId), "MessageBox" ) );
6713 break;
6714 }
6715 break;
6716 }
6717 default:
6718 DBG_ERROR( "Unknown Objekttype from UId or Method not suported" );
6719 ReportError( aUId, GEN_RES_STR2( S_UNKNOWN_TYPE, UniString::CreateFromInt32( nRT ), MethodString(nMethodId) ) );
6720 #if OSL_DEBUG_LEVEL > 1
6721 m_pDbgWin->AddText( " Unknown Objekttype from UId or Method not suported" );
6722 #endif
6723 break;
6724 }
6725 }
6726 for( int i = 0; i < 32; i++ )
6727 SafeReschedule();
6728 }
6729 #if OSL_DEBUG_LEVEL > 1
6730 m_pDbgWin->AddText( "\n" );
6731 #endif
6732 if ( bStatementDone )
6733 {
6734 SendProfile( UIdString( aUId ).Append('.').Append( MethodString( nMethodId ) ) );
6735 delete this;
6736 }
6737 else
6738 {
6739 if ( nRetryCount-- )
6740 {
6741 #if OSL_DEBUG_LEVEL > 1
6742 m_pDbgWin->AddText( CUniString("Reschedule command (requed) (").Append( UniString::CreateFromInt32(nRetryCount) ).AppendAscii(")\n") );
6743 #endif
6744 QueStatement( this ); // will que at the start of the list
6745 }
6746 else
6747 {
6748 bStatementDone=sal_True;
6749 }
6750 }
6751 return bStatementDone;
6752
6753 #define FINISH_NEXT
6754 #define FINISH_SAME
6755
6756 }
6757