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 #include <cmdlineargs.hxx>
  23 #include <vcl/svapp.hxx>
  24 #include <rtl/uri.hxx>
  25 #include <rtl/ustring.hxx>
  26 #include "rtl/process.h"
  27 #include <comphelper/processfactory.hxx>
  28 #include <com/sun/star/uri/ExternalUriReferenceTranslator.hpp>
  29 #include "tools/getprocessworkingdir.hxx"
  30
  31 #include <svl/documentlockfile.hxx>
  32
  33 #include <cstdio>
  34
  35 using namespace com::sun::star::lang;
  36 using namespace com::sun::star::uri;
  37 using namespace com::sun::star::uno;
  38
  39
  40 namespace desktop
  41 {
  42
  43 namespace {
  44
  45 OUString translateExternalUris(OUString const & input) {
  46     OUString t(
  47         com::sun::star::uri::ExternalUriReferenceTranslator::create(
  48             comphelper::getProcessComponentContext())->
  49         translateToInternal(input));
  50     return t.isEmpty() ? input : t;
  51 }
  52
  53 std::vector< OUString > translateExternalUris(
  54     std::vector< OUString > const & input)
  55 {
  56     std::vector< OUString > t;
  57     for (std::vector< OUString >::const_iterator i(input.begin());
  58          i != input.end(); ++i)
  59     {
  60         t.push_back(translateExternalUris(*i));
  61     }
  62     return t;
  63 }
  64
  65 class ExtCommandLineSupplier: public CommandLineArgs::Supplier {
  66 public:
  67     explicit ExtCommandLineSupplier():
  68         m_count(rtl_getAppCommandArgCount()),
  69         m_index(0)
  70     {
  71         OUString url;
  72         if (tools::getProcessWorkingDir(url)) {
  73             m_cwdUrl.reset(url);
  74         }
  75     }
  76
  77     virtual ~ExtCommandLineSupplier() {}
  78
  79     virtual boost::optional< OUString > getCwdUrl() { return m_cwdUrl; }
  80
  81     virtual bool next(OUString * argument) {
  82         OSL_ASSERT(argument != NULL);
  83         if (m_index < m_count) {
  84             rtl_getAppCommandArg(m_index++, &argument->pData);
  85             return true;
  86         } else {
  87             return false;
  88         }
  89     }
  90
  91 private:
  92     boost::optional< OUString > m_cwdUrl;
  93     sal_uInt32 m_count;
  94     sal_uInt32 m_index;
  95 };
  96
  97 }
  98
  99 CommandLineArgs::Supplier::Exception::Exception() {}
 100
 101 CommandLineArgs::Supplier::Exception::Exception(Exception const &) {}
 102
 103 CommandLineArgs::Supplier::Exception::~Exception() {}
 104
 105 CommandLineArgs::Supplier::Exception &
 106 CommandLineArgs::Supplier::Exception::operator =(Exception const &)
 107 { return *this; }
 108
 109 CommandLineArgs::Supplier::~Supplier() {}
 110
 111 // intialize class with command line parameters from process environment
 112 CommandLineArgs::CommandLineArgs()
 113 {
 114     InitParamValues();
 115     ExtCommandLineSupplier s;
 116     ParseCommandLine_Impl( s );
 117 }
 118
 119 CommandLineArgs::CommandLineArgs( Supplier& supplier )
 120 {
 121     InitParamValues();
 122     ParseCommandLine_Impl( supplier );
 123 }
 124
 125 // ----------------------------------------------------------------------------
 126
 127 void CommandLineArgs::ParseCommandLine_Impl( Supplier& supplier )
 128 {
 129     m_cwdUrl = supplier.getCwdUrl();
 130
 131     // parse command line arguments
 132     bool bOpenEvent(true);
 133     bool bPrintEvent(false);
 134     bool bViewEvent(false);
 135     bool bStartEvent(false);
 136     bool bPrintToEvent(false);
 137     bool bPrinterName(false);
 138     bool bForceOpenEvent(false);
 139     bool bForceNewEvent(false);
 140     bool bDisplaySpec(false);
 141     bool bOpenDoc(false);
 142     bool bConversionEvent(false);
 143     bool bConversionParamsEvent(false);
 144     bool bBatchPrintEvent(false);
 145     bool bBatchPrinterNameEvent(false);
 146     bool bConversionOutEvent(false);
 147
 148     for (;;)
 149     {
 150         OUString aArg;
 151         if ( !supplier.next( &aArg ) )
 152         {
 153             break;
 154         }
 155
 156         if ( !aArg.isEmpty() )
 157         {
 158             m_bEmpty = false;
 159             OUString oArg;
 160             if ( !InterpretCommandLineParameter( aArg, oArg ))
 161             {
 162                 if ( aArg.toChar() == '-' )
 163                 {
 164                     // handle this argument as an option
 165                     if ( aArg.equalsIgnoreAsciiCase("-n"))
 166                     {
 167                         // force new documents based on the following documents
 168                         bForceNewEvent  = true;
 169                         bOpenEvent      = false;
 170                         bForceOpenEvent = false;
 171                         bPrintToEvent   = false;
 172                         bPrintEvent     = false;
 173                         bViewEvent      = false;
 174                         bStartEvent     = false;
 175                         bDisplaySpec    = false;
 176                     }
 177                     else if ( aArg.equalsIgnoreAsciiCase("-o"))
 178                     {
 179                         // force open documents regardless if they are templates or not
 180                         bForceOpenEvent = true;
 181                         bOpenEvent      = false;
 182                         bForceNewEvent  = false;
 183                         bPrintToEvent   = false;
 184                         bPrintEvent     = false;
 185                         bViewEvent      = false;
 186                         bStartEvent     = false;
 187                         bDisplaySpec    = false;
 188                     }
 189                     else if ( oArg.equalsIgnoreAsciiCase("pt"))
 190                     {
 191                         // Print to special printer
 192                         bPrintToEvent   = true;
 193                         bPrinterName    = true;
 194                         bPrintEvent     = false;
 195                         bOpenEvent      = false;
 196                         bForceNewEvent  = false;
 197                         bViewEvent      = false;
 198                         bStartEvent     = false;
 199                         bDisplaySpec    = false;
 200                         bForceOpenEvent = false;
 201                    }
 202                    else if ( aArg.equalsIgnoreAsciiCase("-p"))
 203                    {
 204                         // Print to default printer
 205                         bPrintEvent     = true;
 206                         bPrintToEvent   = false;
 207                         bOpenEvent      = false;
 208                         bForceNewEvent  = false;
 209                         bForceOpenEvent = false;
 210                         bViewEvent      = false;
 211                         bStartEvent     = false;
 212                         bDisplaySpec    = false;
 213                    }
 214                    else if ( oArg.equalsIgnoreAsciiCase("view"))
 215                    {
 216                         // open in viewmode
 217                         bOpenEvent      = false;
 218                         bPrintEvent     = false;
 219                         bPrintToEvent   = false;
 220                         bForceNewEvent  = false;
 221                         bForceOpenEvent = false;
 222                         bViewEvent      = true;
 223                         bStartEvent     = false;
 224                         bDisplaySpec    = false;
 225                    }
 226                    else if ( oArg.equalsIgnoreAsciiCase("show"))
 227                    {
 228                         // open in viewmode
 229                         bOpenEvent      = false;
 230                         bViewEvent      = false;
 231                         bStartEvent     = true;
 232                         bPrintEvent     = false;
 233                         bPrintToEvent   = false;
 234                         bForceNewEvent  = false;
 235                         bForceOpenEvent = false;
 236                         bDisplaySpec    = false;
 237                     }
 238                     else if ( oArg.equalsIgnoreAsciiCase("display"))
 239                     {
 240                         // set display
 241                         bOpenEvent      = false;
 242                         bPrintEvent     = false;
 243                         bForceOpenEvent = false;
 244                         bPrintToEvent   = false;
 245                         bForceNewEvent  = false;
 246                         bViewEvent      = false;
 247                         bStartEvent     = false;
 248                         bDisplaySpec    = true;
 249                     }
 250                     else if ( oArg.equalsIgnoreAsciiCase("language"))
 251                     {
 252                         bOpenEvent      = false;
 253                         bPrintEvent     = false;
 254                         bForceOpenEvent = false;
 255                         bPrintToEvent   = false;
 256                         bForceNewEvent  = false;
 257                         bViewEvent      = false;
 258                         bStartEvent     = false;
 259                         bDisplaySpec    = false;
 260                     }
 261                     else if ( oArg.equalsIgnoreAsciiCase("convert-to"))
 262                     {
 263                         bOpenEvent = false;
 264                         bConversionEvent = true;
 265                         bConversionParamsEvent = true;
 266                     }
 267                     else if ( oArg.equalsIgnoreAsciiCase("print-to-file"))
 268                     {
 269                         bOpenEvent = false;
 270                         bBatchPrintEvent = true;
 271                     }
 272                     else if ( oArg.equalsIgnoreAsciiCase("printer-name") &&
 273                               bBatchPrintEvent )
 274                     {
 275                         bBatchPrinterNameEvent = true;
 276                     }
 277                     else if ( oArg.equalsIgnoreAsciiCase("outdir") &&
 278                               (bConversionEvent || bBatchPrintEvent) )
 279                     {
 280                         bConversionOutEvent = true;
 281                     }
 282                     else
 283                     // because it's impossible to filter these options that
 284                     // are handled in the soffice shell script with the
 285                     // primitive tools that /bin/sh offers, ignore them here
 286                     if (
 287 #if defined UNX
 288                         !oArg.equalsIgnoreAsciiCase("backtrace") &&
 289                         !oArg.equalsIgnoreAsciiCase("strace") &&
 290                         !oArg.equalsIgnoreAsciiCase("valgrind") &&
 291                     // for X Session Management, handled in
 292                     // vcl/unx/generic/app/sm.cxx:
 293                         !oArg.match("session=") &&
 294 #endif
 295                     //ignore additional legacy options that don't do anything anymore
 296                         !oArg.equalsIgnoreAsciiCase("nocrashreport") &&
 297                         m_unknown.isEmpty())
 298                     {
 299                         m_unknown = aArg;
 300                     }
 301                 }
 302                 else
 303                 {
 304                     if ( bPrinterName && bPrintToEvent )
 305                     {
 306                         // first argument after "-pt" this must be the printer name
 307                         m_printername = aArg;
 308                         bPrinterName = false;
 309                     }
 310                     else if ( bConversionParamsEvent && bConversionEvent )
 311                     {
 312                         // first argument must be the params
 313                         m_conversionparams = aArg;
 314                         bConversionParamsEvent = false;
 315                     }
 316                     else if ( bBatchPrinterNameEvent && bBatchPrintEvent )
 317                     {
 318                         // first argument is the printer name
 319                         m_printername = aArg;
 320                         bBatchPrinterNameEvent = false;
 321                     }
 322                     else if ( (bConversionEvent || bBatchPrintEvent) && bConversionOutEvent )
 323                     {
 324                         m_conversionout = aArg;
 325                         bConversionOutEvent = false;
 326                     }
 327                     else
 328                     {
 329                         // handle this argument as a filename
 330                         if ( bOpenEvent )
 331                         {
 332                             m_openlist.push_back(aArg);
 333                             bOpenDoc = true;
 334                         }
 335                         else if ( bViewEvent )
 336                         {
 337                             m_viewlist.push_back(aArg);
 338                             bOpenDoc = true;
 339                         }
 340                         else if ( bStartEvent )
 341                         {
 342                             m_startlist.push_back(aArg);
 343                             bOpenDoc = true;
 344                         }
 345                         else if ( bPrintEvent )
 346                         {
 347                             m_printlist.push_back(aArg);
 348                             bOpenDoc = true;
 349                         }
 350                         else if ( bPrintToEvent )
 351                         {
 352                             m_printtolist.push_back(aArg);
 353                             bOpenDoc = true;
 354                         }
 355                         else if ( bForceNewEvent )
 356                         {
 357                             m_forcenewlist.push_back(aArg);
 358                             bOpenDoc = true;
 359                         }
 360                         else if ( bForceOpenEvent )
 361                         {
 362                             m_forceopenlist.push_back(aArg);
 363                             bOpenDoc = true;
 364                         }
 365                         else if ( bDisplaySpec )
 366                         {
 367                             bDisplaySpec = false; // only one display, not a lsit
 368                             bOpenEvent = true;    // set back to standard
 369                         }
 370                         else if ( bConversionEvent || bBatchPrintEvent )
 371                             m_conversionlist.push_back(aArg);
 372                     }
 373                 }
 374             }
 375         }
 376     }
 377
 378     if ( bOpenDoc )
 379         m_bDocumentArgs = true;
 380 }
 381
 382 bool CommandLineArgs::InterpretCommandLineParameter( const OUString& aArg, OUString& oArg )
 383 {
 384     bool bDeprecated = false;
 385     if (aArg.matchIgnoreAsciiCase("--"))
 386     {
 387         oArg = OUString(aArg.getStr()+2, aArg.getLength()-2);
 388     }
 389     else if (aArg.toChar() == '-')
 390     {
 391         if ( aArg.getLength() > 2 ) // -h, -o, -n, -? are still valid
 392             bDeprecated = true;
 393         oArg = OUString(aArg.getStr()+1, aArg.getLength()-1);
 394     }
 395     else
 396     {
 397         return false;
 398     }
 399
 400     if ( oArg == "minimized" )
 401     {
 402         m_minimized = true;
 403     }
 404     else if ( oArg == "invisible" )
 405     {
 406         m_invisible = true;
 407     }
 408     else if ( oArg == "norestore" )
 409     {
 410         m_norestore = true;
 411     }
 412     else if ( oArg == "nodefault" )
 413     {
 414         m_nodefault = true;
 415     }
 416     else if ( oArg == "headless" )
 417     {
 418         // Headless means also invisibile, so set this parameter to true!
 419         m_headless = true;
 420         m_invisible = true;
 421     }
 422     else if ( oArg == "quickstart" )
 423     {
 424 #if defined(ENABLE_QUICKSTART_APPLET)
 425         m_quickstart = true;
 426 #endif
 427         m_noquickstart = false;
 428     }
 429     else if ( oArg == "quickstart=no" )
 430     {
 431         m_noquickstart = true;
 432         m_quickstart = false;
 433     }
 434     else if ( oArg == "terminate_after_init" )
 435     {
 436         m_terminateafterinit = true;
 437     }
 438     else if ( oArg == "nofirststartwizard" )
 439     {
 440         m_nofirststartwizard = true;
 441     }
 442     else if ( oArg == "nologo" )
 443     {
 444         m_nologo = true;
 445     }
 446 #if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
 447     else if ( oArg == "nolockcheck" )
 448     {
 449         m_nolockcheck = true;
 450         // Workaround for automated testing
 451         ::svt::DocumentLockFile::AllowInteraction( false );
 452     }
 453 #endif
 454     else if ( oArg == "help" || aArg == "-h" || aArg == "-?" )
 455     {
 456         m_help = true;
 457     }
 458     else if ( oArg == "helpwriter" )
 459     {
 460         m_helpwriter = true;
 461     }
 462     else if ( oArg == "helpcalc" )
 463     {
 464         m_helpcalc = true;
 465     }
 466     else if ( oArg == "helpdraw" )
 467     {
 468         m_helpdraw = true;
 469     }
 470     else if ( oArg == "helpimpress" )
 471     {
 472         m_helpimpress = true;
 473     }
 474     else if ( oArg == "helpbase" )
 475     {
 476         m_helpbase = true;
 477     }
 478     else if ( oArg == "helpbasic" )
 479     {
 480         m_helpbasic = true;
 481     }
 482     else if ( oArg == "helpmath" )
 483     {
 484         m_helpmath = true;
 485     }
 486     else if ( oArg == "version" )
 487     {
 488         m_version = true;
 489     }
 490     else if ( oArg.matchIgnoreAsciiCase("splash-pipe=") )
 491     {
 492         m_splashpipe = true;
 493     }
 494 #ifdef MACOSX
 495     /* #i84053# ignore -psn on Mac
 496        Platform dependent #ifdef here is ugly, however this is currently
 497        the only platform dependent parameter. Should more appear
 498        we should find a better solution
 499     */
 500     else if ( aArg.match("-psn") )
 501     {
 502         m_psn = true;
 503         return true;
 504     }
 505 #endif
 506 #ifdef WIN32
 507     /* fdo#57203 ignore -Embedding on Windows
 508        when LibreOffice is launched by COM+
 509      */
 510     else if ( oArg == "Embedding" )
 511     {
 512         return true;
 513     }
 514 #endif
 515     else if ( oArg.matchIgnoreAsciiCase("infilter="))
 516     {
 517         m_infilter.push_back(oArg.copy(RTL_CONSTASCII_LENGTH("infilter=")));
 518     }
 519     else if ( oArg.matchIgnoreAsciiCase("accept="))
 520     {
 521         m_accept.push_back(oArg.copy(RTL_CONSTASCII_LENGTH("accept=")));
 522     }
 523     else if ( oArg.matchIgnoreAsciiCase("unaccept="))
 524     {
 525         m_unaccept.push_back(oArg.copy(RTL_CONSTASCII_LENGTH("unaccept=")));
 526     }
 527     else if ( oArg.matchIgnoreAsciiCase("language="))
 528     {
 529         m_language = oArg.copy(RTL_CONSTASCII_LENGTH("language="));
 530     }
 531     else if ( oArg.matchIgnoreAsciiCase("pidfile="))
 532     {
 533         m_pidfile = oArg.copy(RTL_CONSTASCII_LENGTH("pidfile="));
 534     }
 535     else if ( oArg == "writer" )
 536     {
 537         m_writer = true;
 538         m_bDocumentArgs = true;
 539     }
 540     else if ( oArg == "calc" )
 541     {
 542         m_calc = true;
 543         m_bDocumentArgs = true;
 544     }
 545     else if ( oArg == "draw" )
 546     {
 547         m_draw = true;
 548         m_bDocumentArgs = true;
 549     }
 550     else if ( oArg == "impress" )
 551     {
 552         m_impress = true;
 553         m_bDocumentArgs = true;
 554     }
 555     else if ( oArg == "base" )
 556     {
 557         m_base = true;
 558         m_bDocumentArgs = true;
 559     }
 560     else if ( oArg == "global" )
 561     {
 562         m_global = true;
 563         m_bDocumentArgs = true;
 564     }
 565     else if ( oArg == "math" )
 566     {
 567         m_math = true;
 568         m_bDocumentArgs = true;
 569     }
 570     else if ( oArg == "web" )
 571     {
 572         m_web = true;
 573         m_bDocumentArgs = true;
 574     }
 575     else
 576         return false;
 577
 578     if (bDeprecated)
 579     {
 580         OString sArg(OUStringToOString(aArg, osl_getThreadTextEncoding()));
 581         fprintf(stderr, "Warning: %s is deprecated.  Use -%s instead.\n", sArg.getStr(), sArg.getStr());
 582     }
 583     return true;
 584 }
 585
 586 void CommandLineArgs::InitParamValues()
 587 {
 588     m_minimized = false;
 589     m_norestore = false;
 590 #ifdef LIBO_HEADLESS
 591     m_invisible = true;
 592     m_headless = true;
 593 #else
 594     m_invisible = false;
 595     m_headless = false;
 596 #endif
 597     m_quickstart = false;
 598     m_noquickstart = false;
 599     m_terminateafterinit = false;
 600     m_nofirststartwizard = false;
 601     m_nologo = false;
 602     m_nolockcheck = false;
 603     m_nodefault = false;
 604     m_help = false;
 605     m_writer = false;
 606     m_calc = false;
 607     m_draw = false;
 608     m_impress = false;
 609     m_global = false;
 610     m_math = false;
 611     m_web = false;
 612     m_base = false;
 613     m_helpwriter = false;
 614     m_helpcalc = false;
 615     m_helpdraw = false;
 616     m_helpbasic = false;
 617     m_helpmath = false;
 618     m_helpimpress = false;
 619     m_helpbase = false;
 620     m_psn = false;
 621     m_version = false;
 622     m_splashpipe = false;
 623     m_bEmpty = true;
 624     m_bDocumentArgs  = false;
 625 }
 626
 627 bool CommandLineArgs::IsMinimized() const
 628 {
 629     return m_minimized;
 630 }
 631
 632 bool CommandLineArgs::IsInvisible() const
 633 {
 634     return m_invisible;
 635 }
 636
 637 bool CommandLineArgs::IsNoRestore() const
 638 {
 639     return m_norestore;
 640 }
 641
 642 bool CommandLineArgs::IsNoDefault() const
 643 {
 644     return m_nodefault;
 645 }
 646
 647 bool CommandLineArgs::IsHeadless() const
 648 {
 649     return m_headless;
 650 }
 651
 652 bool CommandLineArgs::IsQuickstart() const
 653 {
 654     return m_quickstart;
 655 }
 656
 657 bool CommandLineArgs::IsNoQuickstart() const
 658 {
 659     return m_noquickstart;
 660 }
 661
 662 bool CommandLineArgs::IsTerminateAfterInit() const
 663 {
 664     return m_terminateafterinit;
 665 }
 666
 667 bool CommandLineArgs::IsNoLogo() const
 668 {
 669     return m_nologo;
 670 }
 671
 672 bool CommandLineArgs::IsNoLockcheck() const
 673 {
 674     return m_nolockcheck;
 675 }
 676
 677 bool CommandLineArgs::IsHelp() const
 678 {
 679     return m_help;
 680 }
 681 bool CommandLineArgs::IsHelpWriter() const
 682 {
 683     return m_helpwriter;
 684 }
 685
 686 bool CommandLineArgs::IsHelpCalc() const
 687 {
 688     return m_helpcalc;
 689 }
 690
 691 bool CommandLineArgs::IsHelpDraw() const
 692 {
 693     return m_helpdraw;
 694 }
 695
 696 bool CommandLineArgs::IsHelpImpress() const
 697 {
 698     return m_helpimpress;
 699 }
 700
 701 bool CommandLineArgs::IsHelpBase() const
 702 {
 703     return m_helpbase;
 704 }
 705 bool CommandLineArgs::IsHelpMath() const
 706 {
 707     return m_helpmath;
 708 }
 709 bool CommandLineArgs::IsHelpBasic() const
 710 {
 711     return m_helpbasic;
 712 }
 713
 714 bool CommandLineArgs::IsWriter() const
 715 {
 716     return m_writer;
 717 }
 718
 719 bool CommandLineArgs::IsCalc() const
 720 {
 721     return m_calc;
 722 }
 723
 724 bool CommandLineArgs::IsDraw() const
 725 {
 726     return m_draw;
 727 }
 728
 729 bool CommandLineArgs::IsImpress() const
 730 {
 731     return m_impress;
 732 }
 733
 734 bool CommandLineArgs::IsBase() const
 735 {
 736     return m_base;
 737 }
 738
 739 bool CommandLineArgs::IsGlobal() const
 740 {
 741     return m_global;
 742 }
 743
 744 bool CommandLineArgs::IsMath() const
 745 {
 746     return m_math;
 747 }
 748
 749 bool CommandLineArgs::IsWeb() const
 750 {
 751     return m_web;
 752 }
 753
 754 bool CommandLineArgs::IsVersion() const
 755 {
 756     return m_version;
 757 }
 758
 759 OUString CommandLineArgs::GetUnknown() const
 760 {
 761     return m_unknown;
 762 }
 763
 764 bool CommandLineArgs::HasModuleParam() const
 765 {
 766     return m_writer || m_calc || m_draw || m_impress || m_global || m_math
 767         || m_web || m_base;
 768 }
 769
 770 bool CommandLineArgs::HasSplashPipe() const
 771 {
 772     return m_splashpipe;
 773 }
 774
 775 std::vector< OUString > const & CommandLineArgs::GetAccept() const
 776 {
 777     return m_accept;
 778 }
 779
 780 std::vector< OUString > const & CommandLineArgs::GetUnaccept() const
 781 {
 782     return m_unaccept;
 783 }
 784
 785 std::vector< OUString > CommandLineArgs::GetOpenList() const
 786 {
 787     return translateExternalUris(m_openlist);
 788 }
 789
 790 std::vector< OUString > CommandLineArgs::GetViewList() const
 791 {
 792     return translateExternalUris(m_viewlist);
 793 }
 794
 795 std::vector< OUString > CommandLineArgs::GetStartList() const
 796 {
 797     return translateExternalUris(m_startlist);
 798 }
 799
 800 std::vector< OUString > CommandLineArgs::GetForceOpenList() const
 801 {
 802     return translateExternalUris(m_forceopenlist);
 803 }
 804
 805 std::vector< OUString > CommandLineArgs::GetForceNewList() const
 806 {
 807     return translateExternalUris(m_forcenewlist);
 808 }
 809
 810 std::vector< OUString > CommandLineArgs::GetPrintList() const
 811 {
 812     return translateExternalUris(m_printlist);
 813 }
 814
 815 std::vector< OUString > CommandLineArgs::GetPrintToList() const
 816 {
 817     return translateExternalUris(m_printtolist);
 818 }
 819
 820 OUString CommandLineArgs::GetPrinterName() const
 821 {
 822     return m_printername;
 823 }
 824
 825 OUString CommandLineArgs::GetLanguage() const
 826 {
 827     return m_language;
 828 }
 829
 830 std::vector< OUString > const & CommandLineArgs::GetInFilter() const
 831 {
 832     return m_infilter;
 833 }
 834
 835 std::vector< OUString > CommandLineArgs::GetConversionList() const
 836 {
 837     return translateExternalUris(m_conversionlist);
 838 }
 839
 840 OUString CommandLineArgs::GetConversionParams() const
 841 {
 842     return m_conversionparams;
 843 }
 844 OUString CommandLineArgs::GetConversionOut() const
 845 {
 846     return translateExternalUris(m_conversionout);
 847 }
 848
 849 bool CommandLineArgs::IsEmpty() const
 850 {
 851     return m_bEmpty;
 852 }
 853
 854 bool CommandLineArgs::WantsToLoadDocument() const
 855 {
 856     return m_bDocumentArgs;
 857 }
 858
 859 OUString CommandLineArgs::GetPidfileName() const
 860 {
 861     return m_pidfile;
 862 }
 863
 864 } // namespace desktop
 865
 866 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */