xref: /aoo42x/main/desktop/source/app/cmdlineargs.cxx (revision 85c309d6)
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