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 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 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 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 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 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 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 377 StatementSlot::StatementSlot() 378 : nAnzahl( 0 ) 379 , pItemArr(NULL) 380 , nFunctionId( 0 ) 381 , bMenuClosed(sal_False) 382 {} 383 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 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 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 470 SlotStatusListener::SlotStatusListener() 471 : bDisposed( sal_False ) 472 , bEnabled( sal_True ) 473 {} 474 475 // XStatusListener 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 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 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 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 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 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 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().getLength() == 0 ) && !( 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 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 1120 SysWinContainer::~SysWinContainer() 1121 { 1122 delete pDock; 1123 } 1124 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 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; 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 1199 void SetDisplayText( const String &aNewText ){ pEdit->SetText(aNewText); } 1200 String GetDisplayText() const { return pEdit->GetText(); } 1201 sal_Bool IsDisplayTextModified() const { return pEdit->IsModified(); } 1202 void ClearDisplayTextModified() const { pEdit->ClearModifyFlag(); } 1203 1204 void SetConfig( sal_uLong nConf ); 1205 sal_uLong GetConfig(); 1206 1207 sal_Bool IsConfigChanged() { return bConfigChanged; } 1208 void ConfigSent() { bConfigChanged = sal_False; } 1209 1210 sal_Bool IsSendData() { return GetItemState( TT_SEND_DATA ) == STATE_CHECK; } 1211 // sal_Bool IsAllWin() { return GetItemState( TT_ALLWIN ) == STATE_CHECK; } 1212 1213 sal_Bool IsDraging() { return bIsDraging; } 1214 1215 Window* LastMouseMoveWin() { return pLastMouseMoveWin; } 1216 }; 1217 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 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 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 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 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 1282 void DisplayHidWin::Click() 1283 { 1284 nLastItemID = GetCurItemId(); 1285 if ( nLastItemID == TT_SHOW ) 1286 { 1287 SetDraging( sal_True ); 1288 } 1289 ToolBox::Click(); 1290 } 1291 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 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 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 1342 void DisplayHidWin::SetText( const XubString& rStr ) 1343 { 1344 pContainer->SetText( rStr ); 1345 } 1346 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 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; 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 1612 sal_Bool IsTranslationAvailable(){ return bAvailable; } 1613 sal_Bool IsNextDialog(){ return bNext; } 1614 void ResetNextDialog(){ bNext = sal_False; } 1615 1616 Window* GetTranslationWindow(){ return pTranslateWin; } 1617 String GetOriginalText(){ return FixedTextTT_FT_OLD.GetText(); } 1618 String GetTranslationText(){ return EditTT_E_NEW.GetText(); } 1619 String GetComment(){ return EditTT_E_COMMENT.GetText(); } 1620 1621 void EnableTranslation(); 1622 }; 1623 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 1654 TranslateWin::~TranslateWin() 1655 { 1656 Application::RemoveEventHook( nEventHookID ); 1657 } 1658 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 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 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 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 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 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 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 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 ); 1878 String GetDoubleShortcuts() { return aDoubleShortcuts; } 1879 }; 1880 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 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 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 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 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 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().getLength() && 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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