desktop/source/app/cmdlineargs.cxx

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