1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_desktop.hxx" 26 #include <cmdlineargs.hxx> 27 #include <vcl/svapp.hxx> 28 #include <rtl/uri.hxx> 29 #include <rtl/ustring.hxx> 30 #include "rtl/process.h" 31 #include <comphelper/processfactory.hxx> 32 #include <com/sun/star/uri/XExternalUriReferenceTranslator.hpp> 33 #include <com/sun/star/lang/XMultiServiceFactory.hpp> 34 #include <com/sun/star/uno/Reference.hxx> 35 #include "tools/getprocessworkingdir.hxx" 36 37 #include <svl/documentlockfile.hxx> 38 39 using namespace rtl; 40 using namespace com::sun::star::lang; 41 using namespace com::sun::star::uri; 42 using namespace com::sun::star::uno; 43 44 namespace desktop 45 { 46 47 namespace { 48 49 class ExtCommandLineSupplier: public CommandLineArgs::Supplier { 50 public: 51 explicit ExtCommandLineSupplier(): 52 m_count(rtl_getAppCommandArgCount()), 53 m_index(0) 54 { 55 rtl::OUString url; 56 if (tools::getProcessWorkingDir(&url)) { 57 m_cwdUrl.reset(url); 58 } 59 } 60 61 virtual ~ExtCommandLineSupplier() {} 62 63 virtual boost::optional< rtl::OUString > getCwdUrl() { return m_cwdUrl; } 64 65 virtual bool next(rtl::OUString * argument) { 66 OSL_ASSERT(argument != NULL); 67 if (m_index < m_count) { 68 rtl_getAppCommandArg(m_index++, &argument->pData); 69 return true; 70 } else { 71 return false; 72 } 73 } 74 75 private: 76 boost::optional< rtl::OUString > m_cwdUrl; 77 sal_uInt32 m_count; 78 sal_uInt32 m_index; 79 }; 80 81 } 82 83 static CommandLineArgs::BoolParam aModuleGroupDefinition[] = 84 { 85 CommandLineArgs::CMD_BOOLPARAM_WRITER, 86 CommandLineArgs::CMD_BOOLPARAM_CALC, 87 CommandLineArgs::CMD_BOOLPARAM_DRAW, 88 CommandLineArgs::CMD_BOOLPARAM_IMPRESS, 89 CommandLineArgs::CMD_BOOLPARAM_GLOBAL, 90 CommandLineArgs::CMD_BOOLPARAM_MATH, 91 CommandLineArgs::CMD_BOOLPARAM_WEB, 92 CommandLineArgs::CMD_BOOLPARAM_BASE 93 }; 94 95 CommandLineArgs::GroupDefinition CommandLineArgs::m_pGroupDefinitions[ CommandLineArgs::CMD_GRPID_COUNT ] = 96 { 97 { 8, aModuleGroupDefinition } 98 }; 99 100 CommandLineArgs::Supplier::Exception::Exception() {} 101 102 CommandLineArgs::Supplier::Exception::Exception(Exception const &) {} 103 104 CommandLineArgs::Supplier::Exception::~Exception() {} 105 106 CommandLineArgs::Supplier::Exception & 107 CommandLineArgs::Supplier::Exception::operator =(Exception const &) 108 { return *this; } 109 110 CommandLineArgs::Supplier::~Supplier() {} 111 112 // intialize class with command line parameters from process environment 113 CommandLineArgs::CommandLineArgs() 114 { 115 ResetParamValues(); 116 ExtCommandLineSupplier s; 117 ParseCommandLine_Impl( s ); 118 } 119 120 CommandLineArgs::CommandLineArgs( Supplier& supplier ) 121 { 122 ResetParamValues(); 123 ParseCommandLine_Impl( supplier ); 124 } 125 126 // ---------------------------------------------------------------------------- 127 128 void CommandLineArgs::ParseCommandLine_Impl( Supplier& supplier ) 129 { 130 m_cwdUrl = supplier.getCwdUrl(); 131 Reference<XMultiServiceFactory> xMS(comphelper::getProcessServiceFactory(), UNO_QUERY); 132 OSL_ENSURE(xMS.is(), "CommandLineArgs: no ProcessServiceFactory."); 133 134 Reference< XExternalUriReferenceTranslator > xTranslator( 135 xMS->createInstance( 136 OUString::createFromAscii( 137 "com.sun.star.uri.ExternalUriReferenceTranslator")), 138 UNO_QUERY); 139 140 // parse command line arguments 141 bool bOpenEvent(true); 142 bool bPrintEvent(false); 143 bool bViewEvent(false); 144 bool bStartEvent(false); 145 bool bPrintToEvent(false); 146 bool bPrinterName(false); 147 bool bForceOpenEvent(false); 148 bool bForceNewEvent(false); 149 bool bDisplaySpec(false); 150 bool bOpenDoc(false); 151 152 m_eArgumentCount = NONE; 153 154 for (;;) 155 { 156 ::rtl::OUString aArg; 157 if ( !supplier.next( &aArg ) ) 158 { 159 break; 160 } 161 // convert file URLs to internal form #112849# 162 if (aArg.indexOf(OUString::createFromAscii("file:"))==0 && 163 xTranslator.is()) 164 { 165 OUString tmp(xTranslator->translateToInternal(aArg)); 166 if (tmp.getLength() > 0) 167 aArg = tmp; 168 } 169 170 String aArgStr = aArg; 171 if ( aArg.getLength() > 0 ) 172 { 173 m_eArgumentCount = m_eArgumentCount == NONE ? ONE : MANY; 174 if ( !InterpretCommandLineParameter( aArg )) 175 { 176 if ( aArgStr.GetChar(0) == '-' ) 177 { 178 // handle this argument as an option 179 if ( aArgStr.EqualsIgnoreCaseAscii( "-n" )) 180 { 181 // force new documents based on the following documents 182 bForceNewEvent = true; 183 bOpenEvent = false; 184 bForceOpenEvent = false; 185 bPrintToEvent = false; 186 bPrintEvent = false; 187 bViewEvent = false; 188 bStartEvent = false; 189 bDisplaySpec = false; 190 } 191 else if ( aArgStr.EqualsIgnoreCaseAscii( "-o" )) 192 { 193 // force open documents regardless if they are templates or not 194 bForceOpenEvent = true; 195 bOpenEvent = false; 196 bForceNewEvent = false; 197 bPrintToEvent = false; 198 bPrintEvent = false; 199 bViewEvent = false; 200 bStartEvent = false; 201 bDisplaySpec = false; 202 } 203 else if ( aArgStr.EqualsIgnoreCaseAscii( "-pt" )) 204 { 205 // Print to special printer 206 bPrintToEvent = true; 207 bPrinterName = true; 208 bPrintEvent = false; 209 bOpenEvent = false; 210 bForceNewEvent = false; 211 bViewEvent = false; 212 bStartEvent = false; 213 bDisplaySpec = false; 214 bForceOpenEvent = false; 215 } 216 else if ( aArgStr.EqualsIgnoreCaseAscii( "-p" )) 217 { 218 // Print to default printer 219 bPrintEvent = true; 220 bPrintToEvent = false; 221 bOpenEvent = false; 222 bForceNewEvent = false; 223 bForceOpenEvent = false; 224 bViewEvent = false; 225 bStartEvent = false; 226 bDisplaySpec = false; 227 } 228 else if ( aArgStr.EqualsIgnoreCaseAscii( "-view" )) 229 { 230 // open in viewmode 231 bOpenEvent = false; 232 bPrintEvent = false; 233 bPrintToEvent = false; 234 bForceNewEvent = false; 235 bForceOpenEvent = false; 236 bViewEvent = true; 237 bStartEvent = false; 238 bDisplaySpec = false; 239 } 240 else if ( aArgStr.EqualsIgnoreCaseAscii( "-show" )) 241 { 242 // open in viewmode 243 bOpenEvent = false; 244 bViewEvent = false; 245 bStartEvent = true; 246 bPrintEvent = false; 247 bPrintToEvent = false; 248 bForceNewEvent = false; 249 bForceOpenEvent = false; 250 bDisplaySpec = false; 251 } 252 else if ( aArgStr.EqualsIgnoreCaseAscii( "-display" )) 253 { 254 // set display 255 bOpenEvent = false; 256 bPrintEvent = false; 257 bForceOpenEvent = false; 258 bPrintToEvent = false; 259 bForceNewEvent = false; 260 bViewEvent = false; 261 bStartEvent = false; 262 bDisplaySpec = true; 263 } 264 else if ( aArgStr.EqualsIgnoreCaseAscii( "-language" )) 265 { 266 bOpenEvent = false; 267 bPrintEvent = false; 268 bForceOpenEvent = false; 269 bPrintToEvent = false; 270 bForceNewEvent = false; 271 bViewEvent = false; 272 bStartEvent = false; 273 bDisplaySpec = false; 274 } 275 276 #ifdef MACOSX 277 /* #i84053# ignore -psn on Mac 278 Platform dependent #ifdef here is ugly, however this is currently 279 the only platform dependent parameter. Should more appear 280 we should find a better solution 281 */ 282 else if ( aArgStr.CompareToAscii( "-psn", 4 ) == COMPARE_EQUAL ) 283 { 284 // finder argument from MacOSX 285 bOpenEvent = false; 286 bPrintEvent = false; 287 bForceOpenEvent = false; 288 bPrintToEvent = false; 289 bForceNewEvent = false; 290 bViewEvent = false; 291 bStartEvent = false; 292 bDisplaySpec = false; 293 } 294 #endif 295 } 296 else 297 { 298 if ( bPrinterName && bPrintToEvent ) 299 { 300 // first argument after "-pt" this must be the printer name 301 AddStringListParam_Impl( CMD_STRINGPARAM_PRINTERNAME, aArgStr ); 302 bPrinterName = sal_False; 303 } 304 else 305 { 306 // handle this argument as a filename 307 if ( bOpenEvent ) 308 { 309 AddStringListParam_Impl( CMD_STRINGPARAM_OPENLIST, aArgStr ); 310 bOpenDoc = true; 311 } 312 else if ( bViewEvent ) 313 { 314 AddStringListParam_Impl( CMD_STRINGPARAM_VIEWLIST, aArgStr ); 315 bOpenDoc = true; 316 } 317 else if ( bStartEvent ) 318 { 319 AddStringListParam_Impl( CMD_STRINGPARAM_STARTLIST, aArgStr ); 320 bOpenDoc = true; 321 } 322 else if ( bPrintEvent ) 323 { 324 AddStringListParam_Impl( CMD_STRINGPARAM_PRINTLIST, aArgStr ); 325 bOpenDoc = true; 326 } 327 else if ( bPrintToEvent ) 328 { 329 AddStringListParam_Impl( CMD_STRINGPARAM_PRINTTOLIST, aArgStr ); 330 bOpenDoc = true; 331 } 332 else if ( bForceNewEvent ) 333 { 334 AddStringListParam_Impl( CMD_STRINGPARAM_FORCENEWLIST, aArgStr ); 335 bOpenDoc = true; 336 } 337 else if ( bForceOpenEvent ) 338 { 339 AddStringListParam_Impl( CMD_STRINGPARAM_FORCEOPENLIST, aArgStr ); 340 bOpenDoc = true; 341 } 342 else if ( bDisplaySpec ) 343 { 344 AddStringListParam_Impl( CMD_STRINGPARAM_DISPLAY, aArgStr ); 345 bDisplaySpec = false; // only one display, not a lsit 346 bOpenEvent = true; // set back to standard 347 } 348 } 349 } 350 } 351 } 352 } 353 354 if ( bOpenDoc ) 355 m_bDocumentArgs = true; 356 } 357 358 void CommandLineArgs::AddStringListParam_Impl( StringParam eParam, const rtl::OUString& aParam ) 359 { 360 OSL_ASSERT( eParam >= 0 && eParam < CMD_STRINGPARAM_COUNT ); 361 if ( m_aStrParams[eParam].getLength() ) 362 m_aStrParams[eParam] += ::rtl::OUString::valueOf( (sal_Unicode)APPEVENT_PARAM_DELIMITER ); 363 m_aStrParams[eParam] += aParam; 364 m_aStrSetParams[eParam] = sal_True; 365 } 366 367 void CommandLineArgs::SetBoolParam_Impl( BoolParam eParam, sal_Bool bValue ) 368 { 369 OSL_ASSERT( eParam >= 0 && eParam < CMD_BOOLPARAM_COUNT ); 370 m_aBoolParams[eParam] = bValue; 371 } 372 373 sal_Bool CommandLineArgs::InterpretCommandLineParameter( const ::rtl::OUString& aArg ) 374 { 375 String aArgStr( aArg ); 376 377 if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-minimized" )) == sal_True ) 378 { 379 SetBoolParam_Impl( CMD_BOOLPARAM_MINIMIZED, sal_True ); 380 return sal_True; 381 } 382 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-invisible" )) == sal_True ) 383 { 384 SetBoolParam_Impl( CMD_BOOLPARAM_INVISIBLE, sal_True ); 385 return sal_True; 386 } 387 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-norestore" )) == sal_True ) 388 { 389 SetBoolParam_Impl( CMD_BOOLPARAM_NORESTORE, sal_True ); 390 return sal_True; 391 } 392 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-nodefault" )) == sal_True ) 393 { 394 SetBoolParam_Impl( CMD_BOOLPARAM_NODEFAULT, sal_True ); 395 return sal_True; 396 } 397 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-bean" )) == sal_True ) 398 { 399 SetBoolParam_Impl( CMD_BOOLPARAM_BEAN, sal_True ); 400 return sal_True; 401 } 402 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-plugin" )) == sal_True ) 403 { 404 SetBoolParam_Impl( CMD_BOOLPARAM_PLUGIN, sal_True ); 405 return sal_True; 406 } 407 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-server" )) == sal_True ) 408 { 409 SetBoolParam_Impl( CMD_BOOLPARAM_SERVER, sal_True ); 410 return sal_True; 411 } 412 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-headless" )) == sal_True ) 413 { 414 // Headless means also invisibile, so set this parameter to true! 415 SetBoolParam_Impl( CMD_BOOLPARAM_HEADLESS, sal_True ); 416 SetBoolParam_Impl( CMD_BOOLPARAM_INVISIBLE, sal_True ); 417 return sal_True; 418 } 419 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-conversionmode" )) == sal_True ) 420 { 421 // ConversionMode means also headless and invisibile, so set these parameters to true! 422 SetBoolParam_Impl( CMD_BOOLPARAM_HEADLESS, sal_True ); 423 SetBoolParam_Impl( CMD_BOOLPARAM_INVISIBLE, sal_True ); 424 SetBoolParam_Impl( CMD_BOOLPARAM_CONVERSIONMODE, sal_True ); 425 return sal_True; 426 } 427 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-quickstart" )) == sal_True ) 428 { 429 #if defined(ENABLE_QUICKSTART_APPLET) 430 SetBoolParam_Impl( CMD_BOOLPARAM_QUICKSTART, sal_True ); 431 #endif 432 SetBoolParam_Impl( CMD_BOOLPARAM_NOQUICKSTART, sal_False ); 433 return sal_True; 434 } 435 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-quickstart=no" ))) 436 { 437 SetBoolParam_Impl( CMD_BOOLPARAM_NOQUICKSTART, sal_True ); 438 SetBoolParam_Impl( CMD_BOOLPARAM_QUICKSTART, sal_False ); 439 return sal_True; 440 } 441 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-terminate_after_init" )) == sal_True ) 442 { 443 SetBoolParam_Impl( CMD_BOOLPARAM_TERMINATEAFTERINIT, sal_True ); 444 return sal_True; 445 } 446 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-nofirststartwizard" )) == sal_True ) 447 { 448 SetBoolParam_Impl( CMD_BOOLPARAM_NOFIRSTSTARTWIZARD, sal_True ); 449 return sal_True; 450 } 451 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-nologo" )) == sal_True ) 452 { 453 SetBoolParam_Impl( CMD_BOOLPARAM_NOLOGO, sal_True ); 454 return sal_True; 455 } 456 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-nolockcheck" )) == sal_True ) 457 { 458 SetBoolParam_Impl( CMD_BOOLPARAM_NOLOCKCHECK, sal_True ); 459 // Workaround for automated testing 460 ::svt::DocumentLockFile::AllowInteraction( sal_False ); 461 462 return sal_True; 463 } 464 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-help" )) 465 || aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-h" )) 466 || aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-?" ))) 467 { 468 SetBoolParam_Impl( CMD_BOOLPARAM_HELP, sal_True ); 469 return sal_True; 470 } 471 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-helpwriter" )) == sal_True ) 472 { 473 SetBoolParam_Impl( CMD_BOOLPARAM_HELPWRITER, sal_True ); 474 return sal_True; 475 } 476 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-helpcalc" )) == sal_True ) 477 { 478 SetBoolParam_Impl( CMD_BOOLPARAM_HELPCALC, sal_True ); 479 return sal_True; 480 } 481 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-helpdraw" )) == sal_True ) 482 { 483 SetBoolParam_Impl( CMD_BOOLPARAM_HELPDRAW, sal_True ); 484 return sal_True; 485 } 486 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-helpimpress" )) == sal_True ) 487 { 488 SetBoolParam_Impl( CMD_BOOLPARAM_HELPIMPRESS, sal_True ); 489 return sal_True; 490 } 491 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-helpbase" )) == sal_True ) 492 { 493 SetBoolParam_Impl( CMD_BOOLPARAM_HELPBASE, sal_True ); 494 return sal_True; 495 } 496 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-helpbasic" )) == sal_True ) 497 { 498 SetBoolParam_Impl( CMD_BOOLPARAM_HELPBASIC, sal_True ); 499 return sal_True; 500 } 501 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-helpmath" )) == sal_True ) 502 { 503 SetBoolParam_Impl( CMD_BOOLPARAM_HELPMATH, sal_True ); 504 return sal_True; 505 } 506 #ifdef MACOSX 507 /* #i84053# ignore -psn on Mac 508 Platform dependent #ifdef here is ugly, however this is currently 509 the only platform dependent parameter. Should more appear 510 we should find a better solution 511 */ 512 else if ( aArg.compareToAscii( "-psn", 4 ) == 0 ) 513 { 514 SetBoolParam_Impl( CMD_BOOLPARAM_PSN, sal_True ); 515 return sal_True; 516 } 517 #endif 518 else if ( aArgStr.Copy(0, 8).EqualsIgnoreCaseAscii( "-accept=" )) 519 { 520 AddStringListParam_Impl( CMD_STRINGPARAM_ACCEPT, aArgStr.Copy( 8 ) ); 521 return sal_True; 522 } 523 else if ( aArgStr.Copy(0, 10).EqualsIgnoreCaseAscii( "-unaccept=" )) 524 { 525 AddStringListParam_Impl( CMD_STRINGPARAM_UNACCEPT, aArgStr.Copy( 10 ) ); 526 return sal_True; 527 } 528 else if ( aArgStr.CompareIgnoreCaseToAscii( "-portal," , 529 RTL_CONSTASCII_LENGTH( "-portal," )) == COMPARE_EQUAL ) 530 { 531 AddStringListParam_Impl( CMD_STRINGPARAM_PORTAL, aArgStr.Copy( RTL_CONSTASCII_LENGTH( "-portal," )) ); 532 return sal_True; 533 } 534 else if ( aArgStr.Copy( 0, 7 ).EqualsIgnoreCaseAscii( "-userid" )) 535 { 536 if ( aArgStr.Len() > 8 ) 537 { 538 rtl::OUString aUserDir = aArgStr; 539 AddStringListParam_Impl( CMD_STRINGPARAM_USERDIR, 540 ::rtl::Uri::decode( aUserDir.copy( 8 ), rtl_UriDecodeWithCharset, RTL_TEXTENCODING_UTF8 ) ); 541 } 542 return sal_True; 543 } 544 else if ( aArgStr.Copy( 0, 15).EqualsIgnoreCaseAscii( "-clientdisplay=" )) 545 { 546 AddStringListParam_Impl( CMD_STRINGPARAM_CLIENTDISPLAY, aArgStr.Copy( 15 ) ); 547 return sal_True; 548 } 549 else if ( aArgStr.Copy(0, 9).EqualsIgnoreCaseAscii( "-version=" )) 550 { 551 AddStringListParam_Impl( CMD_STRINGPARAM_VERSION, aArgStr.Copy( 9 ) ); 552 return sal_True; 553 } 554 else if ( aArgStr.Copy(0, 10).EqualsIgnoreCaseAscii( "-language=" )) 555 { 556 AddStringListParam_Impl( CMD_STRINGPARAM_LANGUAGE, aArgStr.Copy( 10 ) ); 557 return sal_True; 558 } 559 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-writer" )) == sal_True ) 560 { 561 sal_Bool bAlreadySet = CheckGroupMembers( CMD_GRPID_MODULE, CMD_BOOLPARAM_WRITER ); 562 if ( !bAlreadySet ) 563 SetBoolParam_Impl( CMD_BOOLPARAM_WRITER, sal_True ); 564 m_bDocumentArgs = true; 565 return sal_True; 566 } 567 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-calc" )) == sal_True ) 568 { 569 sal_Bool bAlreadySet = CheckGroupMembers( CMD_GRPID_MODULE, CMD_BOOLPARAM_CALC ); 570 if ( !bAlreadySet ) 571 SetBoolParam_Impl( CMD_BOOLPARAM_CALC, sal_True ); 572 m_bDocumentArgs = true; 573 return sal_True; 574 } 575 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-draw" )) == sal_True ) 576 { 577 sal_Bool bAlreadySet = CheckGroupMembers( CMD_GRPID_MODULE, CMD_BOOLPARAM_DRAW ); 578 if ( !bAlreadySet ) 579 SetBoolParam_Impl( CMD_BOOLPARAM_DRAW, sal_True ); 580 m_bDocumentArgs = true; 581 return sal_True; 582 } 583 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-impress" )) == sal_True ) 584 { 585 sal_Bool bAlreadySet = CheckGroupMembers( CMD_GRPID_MODULE, CMD_BOOLPARAM_IMPRESS ); 586 if ( !bAlreadySet ) 587 SetBoolParam_Impl( CMD_BOOLPARAM_IMPRESS, sal_True ); 588 m_bDocumentArgs = true; 589 return sal_True; 590 } 591 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-base" )) == sal_True ) 592 { 593 sal_Bool bAlreadySet = CheckGroupMembers( CMD_GRPID_MODULE, CMD_BOOLPARAM_BASE ); 594 if ( !bAlreadySet ) 595 SetBoolParam_Impl( CMD_BOOLPARAM_BASE, sal_True ); 596 m_bDocumentArgs = true; 597 return sal_True; 598 } 599 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-global" )) == sal_True ) 600 { 601 sal_Bool bAlreadySet = CheckGroupMembers( CMD_GRPID_MODULE, CMD_BOOLPARAM_GLOBAL ); 602 if ( !bAlreadySet ) 603 SetBoolParam_Impl( CMD_BOOLPARAM_GLOBAL, sal_True ); 604 m_bDocumentArgs = true; 605 return sal_True; 606 } 607 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-math" )) == sal_True ) 608 { 609 sal_Bool bAlreadySet = CheckGroupMembers( CMD_GRPID_MODULE, CMD_BOOLPARAM_MATH ); 610 if ( !bAlreadySet ) 611 SetBoolParam_Impl( CMD_BOOLPARAM_MATH, sal_True ); 612 m_bDocumentArgs = true; 613 return sal_True; 614 } 615 else if ( aArg.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "-web" )) == sal_True ) 616 { 617 sal_Bool bAlreadySet = CheckGroupMembers( CMD_GRPID_MODULE, CMD_BOOLPARAM_WEB ); 618 if ( !bAlreadySet ) 619 SetBoolParam_Impl( CMD_BOOLPARAM_WEB, sal_True ); 620 m_bDocumentArgs = true; 621 return sal_True; 622 } 623 624 return sal_False; 625 } 626 627 sal_Bool CommandLineArgs::CheckGroupMembers( GroupParamId nGroupId, BoolParam nExcludeMember ) const 628 { 629 // Check if at least one bool param out of a group is set. An exclude member can be provided. 630 for ( int i = 0; i < m_pGroupDefinitions[nGroupId].nCount; i++ ) 631 { 632 BoolParam nParam = m_pGroupDefinitions[nGroupId].pGroupMembers[i]; 633 if ( nParam != nExcludeMember && m_aBoolParams[nParam] ) 634 return sal_True; 635 } 636 637 return sal_False; 638 } 639 640 void CommandLineArgs::ResetParamValues() 641 { 642 int i; 643 for ( i = 0; i < CMD_BOOLPARAM_COUNT; i++ ) 644 m_aBoolParams[i] = sal_False; 645 for ( i = 0; i < CMD_STRINGPARAM_COUNT; i++ ) 646 m_aStrSetParams[i] = sal_False; 647 m_eArgumentCount = NONE; 648 m_bDocumentArgs = false; 649 } 650 651 void CommandLineArgs::SetBoolParam( BoolParam eParam, sal_Bool bNewValue ) 652 { 653 osl::MutexGuard aMutexGuard( m_aMutex ); 654 655 OSL_ASSERT( ( eParam >= 0 && eParam < CMD_BOOLPARAM_COUNT ) ); 656 m_aBoolParams[eParam] = bNewValue; 657 } 658 659 sal_Bool CommandLineArgs::IsMinimized() const 660 { 661 osl::MutexGuard aMutexGuard( m_aMutex ); 662 return m_aBoolParams[ CMD_BOOLPARAM_MINIMIZED ]; 663 } 664 665 sal_Bool CommandLineArgs::IsInvisible() const 666 { 667 osl::MutexGuard aMutexGuard( m_aMutex ); 668 return m_aBoolParams[ CMD_BOOLPARAM_INVISIBLE ]; 669 } 670 671 sal_Bool CommandLineArgs::IsNoRestore() const 672 { 673 osl::MutexGuard aMutexGuard( m_aMutex ); 674 return m_aBoolParams[ CMD_BOOLPARAM_NORESTORE ]; 675 } 676 677 sal_Bool CommandLineArgs::IsNoDefault() const 678 { 679 osl::MutexGuard aMutexGuard( m_aMutex ); 680 return m_aBoolParams[ CMD_BOOLPARAM_NODEFAULT ]; 681 } 682 683 sal_Bool CommandLineArgs::IsBean() const 684 { 685 osl::MutexGuard aMutexGuard( m_aMutex ); 686 return m_aBoolParams[ CMD_BOOLPARAM_BEAN ]; 687 } 688 689 sal_Bool CommandLineArgs::IsServer() const 690 { 691 osl::MutexGuard aMutexGuard( m_aMutex ); 692 return m_aBoolParams[ CMD_BOOLPARAM_SERVER ]; 693 } 694 695 sal_Bool CommandLineArgs::IsHeadless() const 696 { 697 osl::MutexGuard aMutexGuard( m_aMutex ); 698 return m_aBoolParams[ CMD_BOOLPARAM_HEADLESS ]; 699 } 700 701 sal_Bool CommandLineArgs::IsConversionMode() const 702 { 703 osl::MutexGuard aMutexGuard( m_aMutex ); 704 return m_aBoolParams[ CMD_BOOLPARAM_CONVERSIONMODE ]; 705 } 706 707 sal_Bool CommandLineArgs::IsQuickstart() const 708 { 709 osl::MutexGuard aMutexGuard( m_aMutex ); 710 return m_aBoolParams[ CMD_BOOLPARAM_QUICKSTART ]; 711 } 712 713 sal_Bool CommandLineArgs::IsNoQuickstart() const 714 { 715 osl::MutexGuard aMutexGuard( m_aMutex ); 716 return m_aBoolParams[ CMD_BOOLPARAM_NOQUICKSTART ]; 717 } 718 719 sal_Bool CommandLineArgs::IsTerminateAfterInit() const 720 { 721 osl::MutexGuard aMutexGuard( m_aMutex ); 722 return m_aBoolParams[ CMD_BOOLPARAM_TERMINATEAFTERINIT ]; 723 } 724 725 sal_Bool CommandLineArgs::IsNoFirstStartWizard() const 726 { 727 osl::MutexGuard aMutexGuard( m_aMutex ); 728 return m_aBoolParams[ CMD_BOOLPARAM_NOFIRSTSTARTWIZARD ]; 729 } 730 731 sal_Bool CommandLineArgs::IsNoLogo() const 732 { 733 osl::MutexGuard aMutexGuard( m_aMutex ); 734 return m_aBoolParams[ CMD_BOOLPARAM_NOLOGO ]; 735 } 736 737 sal_Bool CommandLineArgs::IsNoLockcheck() const 738 { 739 osl::MutexGuard aMutexGuard( m_aMutex ); 740 return m_aBoolParams[ CMD_BOOLPARAM_NOLOCKCHECK ]; 741 } 742 743 sal_Bool CommandLineArgs::IsHelp() const 744 { 745 osl::MutexGuard aMutexGuard( m_aMutex ); 746 return m_aBoolParams[ CMD_BOOLPARAM_HELP ]; 747 } 748 sal_Bool CommandLineArgs::IsHelpWriter() const 749 { 750 osl::MutexGuard aMutexGuard( m_aMutex ); 751 return m_aBoolParams[ CMD_BOOLPARAM_HELPWRITER ]; 752 } 753 754 sal_Bool CommandLineArgs::IsHelpCalc() const 755 { 756 osl::MutexGuard aMutexGuard( m_aMutex ); 757 return m_aBoolParams[ CMD_BOOLPARAM_HELPCALC ]; 758 } 759 760 sal_Bool CommandLineArgs::IsHelpDraw() const 761 { 762 osl::MutexGuard aMutexGuard( m_aMutex ); 763 return m_aBoolParams[ CMD_BOOLPARAM_HELPDRAW ]; 764 } 765 766 sal_Bool CommandLineArgs::IsHelpImpress() const 767 { 768 osl::MutexGuard aMutexGuard( m_aMutex ); 769 return m_aBoolParams[ CMD_BOOLPARAM_HELPIMPRESS ]; 770 } 771 772 sal_Bool CommandLineArgs::IsHelpBase() const 773 { 774 osl::MutexGuard aMutexGuard( m_aMutex ); 775 return m_aBoolParams[ CMD_BOOLPARAM_HELPBASE ]; 776 } 777 sal_Bool CommandLineArgs::IsHelpMath() const 778 { 779 osl::MutexGuard aMutexGuard( m_aMutex ); 780 return m_aBoolParams[ CMD_BOOLPARAM_HELPMATH ]; 781 } 782 sal_Bool CommandLineArgs::IsHelpBasic() const 783 { 784 osl::MutexGuard aMutexGuard( m_aMutex ); 785 return m_aBoolParams[ CMD_BOOLPARAM_HELPBASIC ]; 786 } 787 788 sal_Bool CommandLineArgs::IsWriter() const 789 { 790 osl::MutexGuard aMutexGuard( m_aMutex ); 791 return m_aBoolParams[ CMD_BOOLPARAM_WRITER ]; 792 } 793 794 sal_Bool CommandLineArgs::IsCalc() const 795 { 796 osl::MutexGuard aMutexGuard( m_aMutex ); 797 return m_aBoolParams[ CMD_BOOLPARAM_CALC ]; 798 } 799 800 sal_Bool CommandLineArgs::IsDraw() const 801 { 802 osl::MutexGuard aMutexGuard( m_aMutex ); 803 return m_aBoolParams[ CMD_BOOLPARAM_DRAW ]; 804 } 805 806 sal_Bool CommandLineArgs::IsImpress() const 807 { 808 osl::MutexGuard aMutexGuard( m_aMutex ); 809 return m_aBoolParams[ CMD_BOOLPARAM_IMPRESS ]; 810 } 811 812 sal_Bool CommandLineArgs::IsBase() const 813 { 814 osl::MutexGuard aMutexGuard( m_aMutex ); 815 return m_aBoolParams[ CMD_BOOLPARAM_BASE ]; 816 } 817 818 sal_Bool CommandLineArgs::IsGlobal() const 819 { 820 osl::MutexGuard aMutexGuard( m_aMutex ); 821 return m_aBoolParams[ CMD_BOOLPARAM_GLOBAL ]; 822 } 823 824 sal_Bool CommandLineArgs::IsMath() const 825 { 826 osl::MutexGuard aMutexGuard( m_aMutex ); 827 return m_aBoolParams[ CMD_BOOLPARAM_MATH ]; 828 } 829 830 sal_Bool CommandLineArgs::IsWeb() const 831 { 832 osl::MutexGuard aMutexGuard( m_aMutex ); 833 return m_aBoolParams[ CMD_BOOLPARAM_WEB ]; 834 } 835 836 sal_Bool CommandLineArgs::HasModuleParam() const 837 { 838 osl::MutexGuard aMutexGuard( m_aMutex ); 839 return CheckGroupMembers( CMD_GRPID_MODULE, CMD_BOOLPARAM_COUNT ); 840 } 841 842 sal_Bool CommandLineArgs::GetPortalConnectString( ::rtl::OUString& rPara ) const 843 { 844 osl::MutexGuard aMutexGuard( m_aMutex ); 845 rPara = m_aStrParams[ CMD_STRINGPARAM_PORTAL ]; 846 return m_aStrSetParams[ CMD_STRINGPARAM_PORTAL ]; 847 } 848 849 sal_Bool CommandLineArgs::GetAcceptString( ::rtl::OUString& rPara ) const 850 { 851 osl::MutexGuard aMutexGuard( m_aMutex ); 852 rPara = m_aStrParams[ CMD_STRINGPARAM_ACCEPT ]; 853 return m_aStrSetParams[ CMD_STRINGPARAM_ACCEPT ]; 854 } 855 856 sal_Bool CommandLineArgs::GetUnAcceptString( ::rtl::OUString& rPara ) const 857 { 858 osl::MutexGuard aMutexGuard( m_aMutex ); 859 rPara = m_aStrParams[ CMD_STRINGPARAM_UNACCEPT ]; 860 return m_aStrSetParams[ CMD_STRINGPARAM_UNACCEPT ]; 861 } 862 863 sal_Bool CommandLineArgs::GetOpenList( ::rtl::OUString& rPara) const 864 { 865 osl::MutexGuard aMutexGuard( m_aMutex ); 866 rPara = m_aStrParams[ CMD_STRINGPARAM_OPENLIST ]; 867 return m_aStrSetParams[ CMD_STRINGPARAM_OPENLIST ]; 868 } 869 870 sal_Bool CommandLineArgs::GetViewList( ::rtl::OUString& rPara) const 871 { 872 osl::MutexGuard aMutexGuard( m_aMutex ); 873 rPara = m_aStrParams[ CMD_STRINGPARAM_VIEWLIST ]; 874 return m_aStrSetParams[ CMD_STRINGPARAM_VIEWLIST ]; 875 } 876 877 sal_Bool CommandLineArgs::GetStartList( ::rtl::OUString& rPara) const 878 { 879 osl::MutexGuard aMutexGuard( m_aMutex ); 880 rPara = m_aStrParams[ CMD_STRINGPARAM_STARTLIST ]; 881 return m_aStrSetParams[ CMD_STRINGPARAM_STARTLIST ]; 882 } 883 884 sal_Bool CommandLineArgs::GetForceOpenList( ::rtl::OUString& rPara) const 885 { 886 osl::MutexGuard aMutexGuard( m_aMutex ); 887 rPara = m_aStrParams[ CMD_STRINGPARAM_FORCEOPENLIST ]; 888 return m_aStrSetParams[ CMD_STRINGPARAM_FORCEOPENLIST ]; 889 } 890 891 sal_Bool CommandLineArgs::GetForceNewList( ::rtl::OUString& rPara) const 892 { 893 osl::MutexGuard aMutexGuard( m_aMutex ); 894 rPara = m_aStrParams[ CMD_STRINGPARAM_FORCENEWLIST ]; 895 return m_aStrSetParams[ CMD_STRINGPARAM_FORCENEWLIST ]; 896 } 897 898 sal_Bool CommandLineArgs::GetPrintList( ::rtl::OUString& rPara) const 899 { 900 osl::MutexGuard aMutexGuard( m_aMutex ); 901 rPara = m_aStrParams[ CMD_STRINGPARAM_PRINTLIST ]; 902 return m_aStrSetParams[ CMD_STRINGPARAM_PRINTLIST ]; 903 } 904 905 sal_Bool CommandLineArgs::GetPrintToList( ::rtl::OUString& rPara ) const 906 { 907 osl::MutexGuard aMutexGuard( m_aMutex ); 908 rPara = m_aStrParams[ CMD_STRINGPARAM_PRINTTOLIST ]; 909 return m_aStrSetParams[ CMD_STRINGPARAM_PRINTTOLIST ]; 910 } 911 912 sal_Bool CommandLineArgs::GetPrinterName( ::rtl::OUString& rPara ) const 913 { 914 osl::MutexGuard aMutexGuard( m_aMutex ); 915 rPara = m_aStrParams[ CMD_STRINGPARAM_PRINTERNAME ]; 916 return m_aStrSetParams[ CMD_STRINGPARAM_PRINTERNAME ]; 917 } 918 919 sal_Bool CommandLineArgs::GetLanguage( ::rtl::OUString& rPara ) const 920 { 921 osl::MutexGuard aMutexGuard( m_aMutex ); 922 rPara = m_aStrParams[ CMD_STRINGPARAM_LANGUAGE ]; 923 return m_aStrSetParams[ CMD_STRINGPARAM_LANGUAGE ]; 924 } 925 926 sal_Bool CommandLineArgs::IsEmpty() const 927 { 928 osl::MutexGuard aMutexGuard( m_aMutex ); 929 return m_eArgumentCount == NONE; 930 } 931 932 sal_Bool CommandLineArgs::IsEmptyOrAcceptOnly() const 933 { 934 osl::MutexGuard aMutexGuard( m_aMutex ); 935 936 return m_eArgumentCount == NONE || 937 ( ( m_eArgumentCount == ONE ) && ( m_aStrParams[ CMD_STRINGPARAM_ACCEPT ].getLength() )) || 938 ( ( m_eArgumentCount == ONE ) && m_aBoolParams[ CMD_BOOLPARAM_PSN ] ); 939 } 940 941 sal_Bool CommandLineArgs::WantsToLoadDocument() const 942 { 943 osl::MutexGuard aMutexGuard( m_aMutex ); 944 return m_bDocumentArgs; 945 } 946 947 } // namespace desktop 948