desktop/source/app/cmdlineargs.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <config_features.h>
  21
  22 #if HAVE_FEATURE_MACOSX_SANDBOX
  23 #include <premac.h>
  24 #include <Foundation/Foundation.h>
  25 #include <postmac.h>
  26 #endif
  27
  28 #include "cmdlineargs.hxx"
  29 #include <osl/thread.hxx>
  30 #include <tools/stream.hxx>
  31 #include <rtl/ustring.hxx>
  32 #include <rtl/process.h>
  33 #include <comphelper/lok.hxx>
  34 #include <comphelper/processfactory.hxx>
  35 #include <com/sun/star/uri/ExternalUriReferenceTranslator.hpp>
  36 #include <unotools/bootstrap.hxx>
  37
  38 #include <rtl/strbuf.hxx>
  39 #include <osl/file.hxx>
  40 #include <sal/log.hxx>
  41
  42 using namespace com::sun::star::lang;
  43 using namespace com::sun::star::uri;
  44 using namespace com::sun::star::uno;
  45
  46 namespace desktop
  47 {
  48
  49 namespace {
  50
  51 OUString translateExternalUris(OUString const & input) {
  52     OUString t(
  53         css::uri::ExternalUriReferenceTranslator::create(
  54             comphelper::getProcessComponentContext())->
  55         translateToInternal(input));
  56     return t.isEmpty() ? input : t;
  57 }
  58
  59 std::vector< OUString > translateExternalUris(
  60     std::vector< OUString > const & input)
  61 {
  62     std::vector< OUString > t;
  63     t.reserve(input.size());
  64     for (auto const& elem : input)
  65     {
  66         t.push_back(translateExternalUris(elem));
  67     }
  68     return t;
  69 }
  70
  71 class ExtCommandLineSupplier: public CommandLineArgs::Supplier {
  72 public:
  73     explicit ExtCommandLineSupplier():
  74         m_count(
  75             comphelper::LibreOfficeKit::isActive()
  76             ? 0 : rtl_getAppCommandArgCount()),
  77         m_index(0)
  78     {
  79         OUString url;
  80         if (utl::Bootstrap::getProcessWorkingDir(url)) {
  81             m_cwdUrl = url;
  82         }
  83     }
  84
  85     virtual std::optional< OUString > getCwdUrl() override { return m_cwdUrl; }
  86
  87     virtual bool next(OUString * argument) override {
  88         OSL_ASSERT(argument != nullptr);
  89         if (m_index < m_count) {
  90             rtl_getAppCommandArg(m_index++, &argument->pData);
  91             return true;
  92         } else {
  93             return false;
  94         }
  95     }
  96
  97 private:
  98     std::optional< OUString > m_cwdUrl;
  99     sal_uInt32 m_count;
 100     sal_uInt32 m_index;
 101 };
 102
 103 enum class CommandLineEvent {
 104     Open, Print, View, Start, PrintTo,
 105     ForceOpen, ForceNew, Conversion, BatchPrint
 106 };
 107
 108 // Office URI Schemes: see https://msdn.microsoft.com/en-us/library/dn906146
 109 // This functions checks if the arg is an Office URI.
 110 // If applicable, it updates arg to inner URI.
 111 // If no event argument is explicitly set in command line,
 112 // then it returns updated command line event,
 113 // according to Office URI command.
 114 CommandLineEvent CheckOfficeURI(/* in,out */ OUString& arg, CommandLineEvent curEvt)
 115 {
 116     // 1. Strip the scheme name
 117     OUString rest1;
 118     bool isOfficeURI = ( arg.startsWithIgnoreAsciiCase("vnd.libreoffice.command:", &rest1) // Proposed extended schema
 119                       || arg.startsWithIgnoreAsciiCase("ms-word:",                 &rest1)
 120                       || arg.startsWithIgnoreAsciiCase("ms-powerpoint:",           &rest1)
 121                       || arg.startsWithIgnoreAsciiCase("ms-excel:",                &rest1)
 122                       || arg.startsWithIgnoreAsciiCase("ms-visio:",                &rest1)
 123                       || arg.startsWithIgnoreAsciiCase("ms-access:",               &rest1));
 124     if (!isOfficeURI)
 125         return curEvt;
 126
 127     OUString rest2;
 128     tools::Long nURIlen = -1;
 129
 130     // URL might be encoded
 131     OUString decoded_rest = rest1.replaceAll("%7C", "|").replaceAll("%7c", "|");
 132
 133     // 2. Discriminate by command name (incl. 1st command argument descriptor)
 134     //    Extract URI: everything up to possible next argument
 135     if (decoded_rest.startsWith("ofv|u|", &rest2))
 136     {
 137         // Open for view - override only in default mode
 138         if (curEvt == CommandLineEvent::Open)
 139             curEvt = CommandLineEvent::View;
 140         nURIlen = rest2.indexOf("|");
 141     }
 142     else if (decoded_rest.startsWith("ofe|u|", &rest2))
 143     {
 144         // Open for editing - override only in default mode
 145         if (curEvt == CommandLineEvent::Open)
 146             curEvt = CommandLineEvent::ForceOpen;
 147         nURIlen = rest2.indexOf("|");
 148     }
 149     else if (decoded_rest.startsWith("nft|u|", &rest2))
 150     {
 151         // New from template - override only in default mode
 152         if (curEvt == CommandLineEvent::Open)
 153             curEvt = CommandLineEvent::ForceNew;
 154         nURIlen = rest2.indexOf("|");
 155         // TODO: process optional second argument (default save-to location)
 156         // For now, we just ignore it
 157     }
 158     else
 159     {
 160         // Abbreviated scheme: <scheme-name>:URI
 161         // "ofv|u|" implied
 162         // override only in default mode
 163         if (curEvt == CommandLineEvent::Open)
 164             curEvt = CommandLineEvent::View;
 165         rest2 = rest1;
 166     }
 167     if (nURIlen < 0)
 168         nURIlen = rest2.getLength();
 169     arg = rest2.copy(0, nURIlen);
 170     return curEvt;
 171 }
 172
 173 // Skip single newline (be it *NIX LF, MacOS CR, of Win CRLF)
 174 // Changes the offset, and returns true if moved
 175 bool SkipNewline(const char* & pStr)
 176 {
 177     if ((*pStr != '\r') && (*pStr != '\n'))
 178         return false;
 179     if (*pStr == '\r')
 180         ++pStr;
 181     if (*pStr == '\n')
 182         ++pStr;
 183     return true;
 184 }
 185
 186 // Web query: http://support.microsoft.com/kb/157482
 187 CommandLineEvent CheckWebQuery(/* in,out */ OUString& arg, CommandLineEvent curEvt)
 188 {
 189     // Only handle files with extension .iqy
 190     if (!arg.endsWithIgnoreAsciiCase(".iqy"))
 191         return curEvt;
 192
 193     static osl::Mutex aMutex;
 194     osl::MutexGuard aGuard(aMutex);
 195
 196     try
 197     {
 198         OUString sFileURL;
 199         // Cannot use translateExternalUris yet, because process service factory is not yet available
 200         if (osl::FileBase::getFileURLFromSystemPath(arg, sFileURL) != osl::FileBase::RC::E_None)
 201             return curEvt;
 202         SvFileStream stream(sFileURL, StreamMode::READ);
 203
 204         const sal_Int32 nBufLen = 32000;
 205         char sBuffer[nBufLen];
 206         size_t nRead = stream.ReadBytes(sBuffer, nBufLen);
 207         if (nRead < 8) // WEB\n1\n...
 208             return curEvt;
 209
 210         const char* pPos = sBuffer;
 211         if (strncmp(pPos, "WEB", 3) != 0)
 212             return curEvt;
 213         pPos += 3;
 214         if (!SkipNewline(pPos))
 215             return curEvt;
 216         if (*pPos != '1')
 217             return curEvt;
 218         ++pPos;
 219         if (!SkipNewline(pPos))
 220             return curEvt;
 221
 222         OStringBuffer aResult(static_cast<unsigned int>(nRead));
 223         do
 224         {
 225             const char* pPos1 = pPos;
 226             const char* pEnd = sBuffer + nRead;
 227             while ((pPos1 < pEnd) && (*pPos1 != '\r') && (*pPos1 != '\n'))
 228                 ++pPos1;
 229             aResult.append(pPos, pPos1 - pPos);
 230             if (pPos1 < pEnd) // newline
 231                 break;
 232             pPos = sBuffer;
 233         } while ((nRead = stream.ReadBytes(sBuffer, nBufLen)) > 0);
 234
 235         stream.Close();
 236
 237         arg = OStringToOUString(aResult.makeStringAndClear(), osl_getThreadTextEncoding());
 238         return CommandLineEvent::ForceNew;
 239     }
 240     catch (...)
 241     {
 242         SAL_WARN("desktop.app", "An error processing Web Query file: " << arg);
 243     }
 244
 245     return curEvt;
 246 }
 247
 248 } // namespace
 249
 250 CommandLineArgs::Supplier::Exception::Exception() {}
 251
 252 CommandLineArgs::Supplier::Exception::Exception(Exception const &) {}
 253
 254 CommandLineArgs::Supplier::Exception::~Exception() {}
 255
 256 CommandLineArgs::Supplier::Exception &
 257 CommandLineArgs::Supplier::Exception::operator =(Exception const &)
 258 { return *this; }
 259
 260 CommandLineArgs::Supplier::~Supplier() {}
 261
 262 // initialize class with command line parameters from process environment
 263 CommandLineArgs::CommandLineArgs()
 264 {
 265     InitParamValues();
 266     ExtCommandLineSupplier s;
 267     ParseCommandLine_Impl( s );
 268 }
 269
 270 CommandLineArgs::CommandLineArgs( Supplier& supplier )
 271 {
 272     InitParamValues();
 273     ParseCommandLine_Impl( supplier );
 274 }
 275
 276 void CommandLineArgs::ParseCommandLine_Impl( Supplier& supplier )
 277 {
 278     m_cwdUrl = supplier.getCwdUrl();
 279     CommandLineEvent eCurrentEvent = CommandLineEvent::Open;
 280
 281     for (;;)
 282     {
 283         OUString aArg;
 284         if ( !supplier.next( &aArg ) )
 285         {
 286             break;
 287         }
 288
 289         if ( !aArg.isEmpty() )
 290         {
 291             m_bEmpty = false;
 292             OUString oArg;
 293             OUString oDeprecatedArg;
 294             if (!aArg.startsWith("--", &oArg) && aArg.startsWith("-", &oArg)
 295                 && aArg.getLength() > 2) // -h, -?, -n, -o, -p are still valid
 296             {
 297                 oDeprecatedArg = aArg; // save here, since aArg can change later
 298             }
 299
 300             OUString rest;
 301             if ( oArg == "minimized" )
 302             {
 303                 m_minimized = true;
 304             }
 305             else if ( oArg == "invisible" )
 306             {
 307                 m_invisible = true;
 308             }
 309             else if ( oArg == "norestore" )
 310             {
 311                 m_norestore = true;
 312             }
 313             else if ( oArg == "nodefault" )
 314             {
 315                 m_nodefault = true;
 316             }
 317             else if ( oArg == "headless" )
 318             {
 319                 setHeadless();
 320             }
 321             else if ( oArg == "eventtesting" )
 322             {
 323                 m_eventtesting = true;
 324             }
 325             else if ( oArg == "safe-mode" )
 326             {
 327                 m_safemode = true;
 328             }
 329             else if ( oArg == "cat" )
 330             {
 331                 m_textcat = true;
 332                 m_conversionparams = "txt:Text";
 333                 eCurrentEvent = CommandLineEvent::Conversion;
 334                 setHeadless();
 335             }
 336             else if ( oArg == "script-cat" )
 337             {
 338                 m_scriptcat = true;
 339                 eCurrentEvent = CommandLineEvent::Conversion;
 340                 setHeadless();
 341             }
 342             else if ( oArg == "quickstart" )
 343             {
 344 #if defined(ENABLE_QUICKSTART_APPLET)
 345                 m_quickstart = true;
 346 #endif
 347                 m_noquickstart = false;
 348             }
 349             else if ( oArg == "quickstart=no" )
 350             {
 351                 m_noquickstart = true;
 352                 m_quickstart = false;
 353             }
 354             else if ( oArg == "terminate_after_init" )
 355             {
 356                 m_terminateafterinit = true;
 357             }
 358             else if ( oArg == "nofirststartwizard" )
 359             {
 360                 // Do nothing, accept only for backward compatibility
 361             }
 362             else if ( oArg == "nologo" )
 363             {
 364                 m_nologo = true;
 365             }
 366 #if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
 367             else if ( oArg == "nolockcheck" )
 368             {
 369                 m_nolockcheck = true;
 370             }
 371 #endif
 372             else if ( oArg == "help" || aArg == "-h" || aArg == "-?" )
 373             {
 374                 m_help = true;
 375             }
 376             else if ( oArg == "helpwriter" )
 377             {
 378                 m_helpwriter = true;
 379             }
 380             else if ( oArg == "helpcalc" )
 381             {
 382                 m_helpcalc = true;
 383             }
 384             else if ( oArg == "helpdraw" )
 385             {
 386                 m_helpdraw = true;
 387             }
 388             else if ( oArg == "helpimpress" )
 389             {
 390                 m_helpimpress = true;
 391             }
 392             else if ( oArg == "helpbase" )
 393             {
 394                 m_helpbase = true;
 395             }
 396             else if ( oArg == "helpbasic" )
 397             {
 398                 m_helpbasic = true;
 399             }
 400             else if ( oArg == "helpmath" )
 401             {
 402                 m_helpmath = true;
 403             }
 404             else if ( oArg == "protector" )
 405             {
 406                 // Not relevant for us here, but can be used in unit tests.
 407                 // Usually unit tests would not end up here, but e.g. the
 408                 // LOK Tiled Rendering tests end up running a full soffice
 409                 // process, and we can't bail on the use of --protector.
 410
 411                 // We specifically need to consume the following 2 arguments
 412                 // for --protector
 413                 if ((!supplier.next(&aArg) || !supplier.next(&aArg)) && m_unknown.isEmpty())
 414                     m_unknown = "--protector must be followed by two arguments";
 415             }
 416             else if ( oArg == "version" )
 417             {
 418                 m_version = true;
 419             }
 420             else if ( oArg.startsWith("splash-pipe=") )
 421             {
 422                 m_splashpipe = true;
 423             }
 424 #ifdef MACOSX
 425             /* #i84053# ignore -psn on Mac
 426                Platform dependent #ifdef here is ugly, however this is currently
 427                the only platform dependent parameter. Should more appear
 428                we should find a better solution
 429             */
 430             else if ( aArg.startsWith("-psn") )
 431             {
 432                 oDeprecatedArg.clear();
 433             }
 434 #endif
 435 #if HAVE_FEATURE_MACOSX_SANDBOX
 436             else if ( oArg == "nstemporarydirectory" )
 437             {
 438                 printf("%s\n", [NSTemporaryDirectory() UTF8String]);
 439                 exit(0);
 440             }
 441 #endif
 442 #ifdef _WIN32
 443             /* fdo#57203 ignore -Embedding on Windows
 444                when LibreOffice is launched by COM+
 445             */
 446             else if ( oArg == "Embedding" )
 447             {
 448                 oDeprecatedArg.clear();
 449             }
 450 #endif
 451             else if ( oArg.startsWith("infilter=", &rest))
 452             {
 453                 m_infilter.push_back(rest);
 454             }
 455             else if ( oArg.startsWith("accept=", &rest))
 456             {
 457                 m_accept.push_back(rest);
 458             }
 459             else if ( oArg.startsWith("unaccept=", &rest))
 460             {
 461                 m_unaccept.push_back(rest);
 462             }
 463             else if ( oArg.startsWith("language=", &rest))
 464             {
 465                 m_language = rest;
 466             }
 467             else if ( oArg.startsWith("pidfile=", &rest))
 468             {
 469                 m_pidfile = rest;
 470             }
 471             else if ( oArg == "writer" )
 472             {
 473                 m_writer = true;
 474                 m_bDocumentArgs = true;
 475             }
 476             else if ( oArg == "calc" )
 477             {
 478                 m_calc = true;
 479                 m_bDocumentArgs = true;
 480             }
 481             else if ( oArg == "draw" )
 482             {
 483                 m_draw = true;
 484                 m_bDocumentArgs = true;
 485             }
 486             else if ( oArg == "impress" )
 487             {
 488                 m_impress = true;
 489                 m_bDocumentArgs = true;
 490             }
 491             else if ( oArg == "base" )
 492             {
 493                 m_base = true;
 494                 m_bDocumentArgs = true;
 495             }
 496             else if ( oArg == "global" )
 497             {
 498                 m_global = true;
 499                 m_bDocumentArgs = true;
 500             }
 501             else if ( oArg == "math" )
 502             {
 503                 m_math = true;
 504                 m_bDocumentArgs = true;
 505             }
 506             else if ( oArg == "web" )
 507             {
 508                 m_web = true;
 509                 m_bDocumentArgs = true;
 510             }
 511             else if ( aArg == "-n" )
 512             {
 513                 // force new documents based on the following documents
 514                 eCurrentEvent = CommandLineEvent::ForceNew;
 515             }
 516             else if ( aArg == "-o" )
 517             {
 518                 // force open documents regardless if they are templates or not
 519                 eCurrentEvent = CommandLineEvent::ForceOpen;
 520             }
 521             else if ( oArg == "pt" )
 522             {
 523                 // Print to special printer
 524                 eCurrentEvent = CommandLineEvent::PrintTo;
 525                 // first argument after "-pt" must be the printer name
 526                 if (supplier.next(&aArg))
 527                     m_printername = aArg;
 528                 else if (m_unknown.isEmpty())
 529                     m_unknown = "--pt must be followed by printername";
 530             }
 531             else if ( aArg == "-p" )
 532             {
 533                 // Print to default printer
 534                 eCurrentEvent = CommandLineEvent::Print;
 535             }
 536             else if ( oArg == "view")
 537             {
 538                 // open in viewmode
 539                 eCurrentEvent = CommandLineEvent::View;
 540             }
 541             else if ( oArg == "show" )
 542             {
 543                 // open in viewmode
 544                 eCurrentEvent = CommandLineEvent::Start;
 545             }
 546             else if ( oArg == "display" )
 547             {
 548                 // The command line argument following --display should
 549                 // always be treated as the argument of --display.
 550                 // --display and its argument are handled "out of line"
 551                 // in Unix-only desktop/unx/source/splashx.c and vcl/unx/*,
 552                 // and just ignored here
 553                 (void)supplier.next(&aArg);
 554             }
 555             else if ( oArg == "convert-to" )
 556             {
 557                 eCurrentEvent = CommandLineEvent::Conversion;
 558                 // first argument must be the params
 559                 if (supplier.next(&aArg))
 560                 {
 561                     m_conversionparams = aArg;
 562                     // It doesn't make sense to use convert-to without headless.
 563                     setHeadless();
 564                 }
 565                 else if (m_unknown.isEmpty())
 566                     m_unknown = "--convert-to must be followed by output_file_extension[:output_filter_name]";
 567             }
 568             else if ( oArg == "print-to-file" )
 569             {
 570                 eCurrentEvent = CommandLineEvent::BatchPrint;
 571             }
 572             else if ( oArg == "printer-name" )
 573             {
 574                 if (eCurrentEvent == CommandLineEvent::BatchPrint)
 575                 {
 576                     // first argument is the printer name
 577                     if (supplier.next(&aArg))
 578                         m_printername = aArg;
 579                     else if (m_unknown.isEmpty())
 580                         m_unknown = "--printer-name must be followed by printername";
 581                 }
 582                 else if (m_unknown.isEmpty())
 583                 {
 584                     m_unknown = "--printer-name must directly follow --print-to-file";
 585                 }
 586             }
 587             else if ( oArg == "outdir" )
 588             {
 589                 if (eCurrentEvent == CommandLineEvent::Conversion ||
 590                     eCurrentEvent == CommandLineEvent::BatchPrint)
 591                 {
 592                     if (supplier.next(&aArg))
 593                         m_conversionout = aArg;
 594                     else if (m_unknown.isEmpty())
 595                         m_unknown = "--outdir must be followed by output directory path";
 596                 }
 597                 else if (m_unknown.isEmpty())
 598                 {
 599                     m_unknown = "--outdir must directly follow either output filter specification of --convert-to, or --print-to-file or its printer specification";
 600                 }
 601             }
 602             else if ( eCurrentEvent == CommandLineEvent::Conversion
 603                       && oArg == "convert-images-to" )
 604             {
 605                 if (supplier.next(&aArg))
 606                     m_convertimages = aArg;
 607                 else if (m_unknown.isEmpty())
 608                     m_unknown = "--convert-images-to must be followed by an image type";
 609             }
 610             else if ( aArg.startsWith("-") )
 611             {
 612                 // because it's impossible to filter these options that
 613                 // are handled in the soffice shell script with the
 614                 // primitive tools that /bin/sh offers, ignore them here
 615                 if (
 616 #if defined UNX
 617                     oArg != "record" &&
 618                     oArg != "backtrace" &&
 619                     oArg != "strace" &&
 620                     oArg != "valgrind" &&
 621                     // for X Session Management, handled in
 622                     // vcl/unx/generic/app/sm.cxx:
 623                     oArg != "session=" &&
 624 #endif
 625                     //ignore additional legacy options that don't do anything anymore
 626                     oArg != "nocrashreport" &&
 627                     m_unknown.isEmpty())
 628                 {
 629                     m_unknown = aArg;
 630                 }
 631                 oDeprecatedArg.clear();
 632             }
 633             else
 634             {
 635                 // handle this argument as a filename
 636
 637                 // First check if this is an Office URI
 638                 // This will possibly adjust event for this argument
 639                 // and put real URI to aArg
 640                 CommandLineEvent eThisEvent = CheckOfficeURI(aArg, eCurrentEvent);
 641
 642                 // Now check if this is a Web Query file
 643                 eThisEvent = CheckWebQuery(aArg, eThisEvent);
 644
 645                 switch (eThisEvent)
 646                 {
 647                 case CommandLineEvent::Open:
 648                     m_openlist.push_back(aArg);
 649                     m_bDocumentArgs = true;
 650                     break;
 651                 case CommandLineEvent::View:
 652                     m_viewlist.push_back(aArg);
 653                     m_bDocumentArgs = true;
 654                     break;
 655                 case CommandLineEvent::Start:
 656                     m_startlist.push_back(aArg);
 657                     m_bDocumentArgs = true;
 658                     break;
 659                 case CommandLineEvent::Print:
 660                     m_printlist.push_back(aArg);
 661                     m_bDocumentArgs = true;
 662                     break;
 663                 case CommandLineEvent::PrintTo:
 664                     m_printtolist.push_back(aArg);
 665                     m_bDocumentArgs = true;
 666                     break;
 667                 case CommandLineEvent::ForceNew:
 668                     m_forcenewlist.push_back(aArg);
 669                     m_bDocumentArgs = true;
 670                     break;
 671                 case CommandLineEvent::ForceOpen:
 672                     m_forceopenlist.push_back(aArg);
 673                     m_bDocumentArgs = true;
 674                     break;
 675                 case CommandLineEvent::Conversion:
 676                 case CommandLineEvent::BatchPrint:
 677                     m_conversionlist.push_back(aArg);
 678                     break;
 679                 }
 680             }
 681
 682             if (!oDeprecatedArg.isEmpty())
 683             {
 684                 OString sArg(OUStringToOString(oDeprecatedArg, osl_getThreadTextEncoding()));
 685                 fprintf(stderr, "Warning: %s is deprecated.  Use -%s instead.\n", sArg.getStr(), sArg.getStr());
 686             }
 687         }
 688     }
 689 }
 690
 691 void CommandLineArgs::InitParamValues()
 692 {
 693     m_minimized = false;
 694     m_norestore = false;
 695 #if HAVE_FEATURE_UI
 696     m_invisible = false;
 697     m_headless = false;
 698 #else
 699     m_invisible = true;
 700     m_headless = true;
 701 #endif
 702     m_eventtesting = false;
 703     m_quickstart = false;
 704     m_noquickstart = false;
 705     m_terminateafterinit = false;
 706     m_nologo = false;
 707     m_nolockcheck = false;
 708     m_nodefault = false;
 709     m_help = false;
 710     m_writer = false;
 711     m_calc = false;
 712     m_draw = false;
 713     m_impress = false;
 714     m_global = false;
 715     m_math = false;
 716     m_web = false;
 717     m_base = false;
 718     m_helpwriter = false;
 719     m_helpcalc = false;
 720     m_helpdraw = false;
 721     m_helpbasic = false;
 722     m_helpmath = false;
 723     m_helpimpress = false;
 724     m_helpbase = false;
 725     m_version = false;
 726     m_splashpipe = false;
 727     m_bEmpty = true;
 728     m_bDocumentArgs  = false;
 729     m_textcat = false;
 730     m_scriptcat = false;
 731     m_safemode = false;
 732 }
 733
 734 bool CommandLineArgs::HasModuleParam() const
 735 {
 736     return m_writer || m_calc || m_draw || m_impress || m_global || m_math
 737         || m_web || m_base;
 738 }
 739
 740 std::vector< OUString > CommandLineArgs::GetOpenList() const
 741 {
 742     return translateExternalUris(m_openlist);
 743 }
 744
 745 std::vector< OUString > CommandLineArgs::GetViewList() const
 746 {
 747     return translateExternalUris(m_viewlist);
 748 }
 749
 750 std::vector< OUString > CommandLineArgs::GetStartList() const
 751 {
 752     return translateExternalUris(m_startlist);
 753 }
 754
 755 std::vector< OUString > CommandLineArgs::GetForceOpenList() const
 756 {
 757     return translateExternalUris(m_forceopenlist);
 758 }
 759
 760 std::vector< OUString > CommandLineArgs::GetForceNewList() const
 761 {
 762     return translateExternalUris(m_forcenewlist);
 763 }
 764
 765 std::vector< OUString > CommandLineArgs::GetPrintList() const
 766 {
 767     return translateExternalUris(m_printlist);
 768 }
 769
 770 std::vector< OUString > CommandLineArgs::GetPrintToList() const
 771 {
 772     return translateExternalUris(m_printtolist);
 773 }
 774
 775 std::vector< OUString > CommandLineArgs::GetConversionList() const
 776 {
 777     return translateExternalUris(m_conversionlist);
 778 }
 779
 780 OUString CommandLineArgs::GetConversionOut() const
 781 {
 782     return translateExternalUris(m_conversionout);
 783 }
 784
 785 } // namespace desktop
 786
 787 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */