VirtualBox

Changeset 92372 in vbox for trunk/src


Ignore:
Timestamp:
Nov 11, 2021 2:45:18 PM (3 years ago)
Author:
vboxsync
Message:

Main: bugref:1909: Added translation marks around messages of VBoxManage output

Location:
trunk/src/VBox/Frontends/VBoxManage
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VBoxManage/Makefile.kmk

    r91432 r92372  
    6868        VBoxManageHelp.cpp \
    6969        $(if $(VBOX_WITH_GUEST_PROPS),VBoxManageGuestProp.cpp) \
    70         $(if $(VBOX_WITH_GUEST_CONTROL),VBoxManageGuestCtrl.cpp)
     70        $(if $(VBOX_WITH_GUEST_CONTROL),VBoxManageGuestCtrl.cpp) \
     71
    7172
    7273ifndef VBOX_ONLY_DOCS
    … …  
    115116 VBoxManage_LIBS      += $(LIB_DDU)
    116117
     118ifdef VBOX_WITH_VBOXMANAGE_NLS
     119 VBoxManage_DEFS      += VBOX_WITH_VBOXMANAGE_NLS
     120
     121 VBoxManage_INCS      += \
     122        $(PATH_ROOT)/src/VBox/Main/include
     123
     124 VBoxManage_SOURCES   += \
     125        $(PATH_ROOT)/src/VBox/Main/src-all/VirtualBoxTranslator.cpp \
     126        $(PATH_ROOT)/src/VBox/Main/src-all/QMTranslatorImpl.cpp \
     127        $(PATH_ROOT)/src/VBox/Main/src-all/GlobalStatusConversion.cpp
     128endif
     129
     130
    117131 # VBoxNetPortForwardString.h
    118132 VBoxManageNATNetwork.cpp_INCS += ../../NetworkServices/NetLib/
    … …  
    228242
    229243include $(FILE_KBUILD_SUB_FOOTER)
    230 

  • trunk/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp

    r89905 r92372  
    8989#define HOSTPARTITION_MAX 100
    9090
     91DECLARE_TRANSLATION_CONTEXT(Internal);
     92
    9193
    9294typedef struct HOSTPARTITION
    … …  
    141143    Assert(enmCommand != USAGE_S_DUMPOPTS);
    142144    RTStrmPrintf(pStrm,
    143         "Usage: VBoxManage internalcommands <command> [command arguments]\n"
    144         "\n"
    145         "Commands:\n"
    146         "\n"
    147         "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s"
    148         "WARNING: This is a development tool and shall only be used to analyse\n"
    149         "         problems. It is completely unsupported and will change in\n"
    150         "         incompatible ways without warning.\n",
     145        Internal::tr(
     146         "Usage: VBoxManage internalcommands <command> [command arguments]\n"
     147         "\n"
     148         "Commands:\n"
     149         "\n"
     150         "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s"
     151         "WARNING: This is a development tool and shall only be used to analyse\n"
     152         "         problems. It is completely unsupported and will change in\n"
     153         "         incompatible ways without warning.\n"),
    151154
    152155        (enmCommand == USAGE_I_LOADMAP || enmCommand == USAGE_S_ALL)
    153         ? "  loadmap <vmname|uuid> <symfile> <address> [module] [subtrahend] [segment]\n"
    154           "      This will instruct DBGF to load the given map file\n"
    155           "      during initialization.  (See also loadmap in the debugger.)\n"
    156           "\n"
     156        ? Internal::tr(
     157           "  loadmap <vmname|uuid> <symfile> <address> [module] [subtrahend] [segment]\n"
     158           "      This will instruct DBGF to load the given map file\n"
     159           "      during initialization.  (See also loadmap in the debugger.)\n"
     160           "\n")
    157161        : "",
    158162        (enmCommand == USAGE_I_LOADSYMS || enmCommand == USAGE_S_ALL)
    159         ? "  loadsyms <vmname|uuid> <symfile> [delta] [module] [module address]\n"
    160           "      This will instruct DBGF to load the given symbol file\n"
    161           "      during initialization.\n"
    162           "\n"
     163        ? Internal::tr(
     164           "  loadsyms <vmname|uuid> <symfile> [delta] [module] [module address]\n"
     165           "      This will instruct DBGF to load the given symbol file\n"
     166           "      during initialization.\n"
     167           "\n")
    163168        : "",
    164169        (enmCommand == USAGE_I_SETHDUUID || enmCommand == USAGE_S_ALL)
    165         ? "  sethduuid <filepath> [<uuid>]\n"
    166           "       Assigns a new UUID to the given image file. This way, multiple copies\n"
    167           "       of a container can be registered.\n"
    168           "\n"
     170        ? Internal::tr(
     171           "  sethduuid <filepath> [<uuid>]\n"
     172           "       Assigns a new UUID to the given image file. This way, multiple copies\n"
     173           "       of a container can be registered.\n"
     174           "\n")
    169175        : "",
    170176        (enmCommand == USAGE_I_SETHDPARENTUUID || enmCommand == USAGE_S_ALL)
    171         ? "  sethdparentuuid <filepath> <uuid>\n"
    172           "       Assigns a new parent UUID to the given image file.\n"
    173           "\n"
     177        ? Internal::tr(
     178           "  sethdparentuuid <filepath> <uuid>\n"
     179           "       Assigns a new parent UUID to the given image file.\n"
     180           "\n")
    174181        : "",
    175182        (enmCommand == USAGE_I_DUMPHDINFO || enmCommand == USAGE_S_ALL)
    176         ?  "  dumphdinfo <filepath>\n"
     183        ? Internal::tr(
     184           "  dumphdinfo <filepath>\n"
    177185           "       Prints information about the image at the given location.\n"
    178            "\n"
     186           "\n")
    179187        : "",
    180188        (enmCommand == USAGE_I_LISTPARTITIONS || enmCommand == USAGE_S_ALL)
    181         ? "  listpartitions -rawdisk <diskname>\n"
    182           "       Lists all partitions on <diskname>.\n"
    183           "\n"
     189        ? Internal::tr(
     190           "  listpartitions -rawdisk <diskname>\n"
     191           "       Lists all partitions on <diskname>.\n"
     192           "\n")
    184193        : "",
    185194        (enmCommand == USAGE_I_CREATERAWVMDK || enmCommand == USAGE_S_ALL)
    186         ? "  createrawvmdk -filename <filename> -rawdisk <diskname>\n"
    187           "                [-partitions <list of partition numbers> [-mbr <filename>] ]\n"
    188           "                [-relative]\n"
    189           "       Creates a new VMDK image which gives access to an entire host disk (if\n"
    190           "       the parameter -partitions is not specified) or some partitions of a\n"
    191           "       host disk. If access to individual partitions is granted, then the\n"
    192           "       parameter -mbr can be used to specify an alternative MBR to be used\n"
    193           "       (the partitioning information in the MBR file is ignored).\n"
    194           "       The diskname is on Linux e.g. /dev/sda, and on Windows e.g.\n"
    195           "       \\\\.\\PhysicalDrive0).\n"
    196           "       On Linux or FreeBSD host the parameter -relative causes a VMDK file to\n"
    197           "       be created which refers to individual partitions instead to the entire\n"
    198           "       disk.\n"
    199           "       The necessary partition numbers can be queried with\n"
    200           "         VBoxManage internalcommands listpartitions\n"
    201           "\n"
     195        ? Internal::tr(
     196           "  createrawvmdk -filename <filename> -rawdisk <diskname>\n"
     197           "                [-partitions <list of partition numbers> [-mbr <filename>] ]\n"
     198           "                [-relative]\n"
     199           "       Creates a new VMDK image which gives access to an entire host disk (if\n"
     200           "       the parameter -partitions is not specified) or some partitions of a\n"
     201           "       host disk. If access to individual partitions is granted, then the\n"
     202           "       parameter -mbr can be used to specify an alternative MBR to be used\n"
     203           "       (the partitioning information in the MBR file is ignored).\n"
     204           "       The diskname is on Linux e.g. /dev/sda, and on Windows e.g.\n"
     205           "       \\\\.\\PhysicalDrive0).\n"
     206           "       On Linux or FreeBSD host the parameter -relative causes a VMDK file to\n"
     207           "       be created which refers to individual partitions instead to the entire\n"
     208           "       disk.\n"
     209           "       The necessary partition numbers can be queried with\n"
     210           "         VBoxManage internalcommands listpartitions\n"
     211           "\n")
    202212        : "",
    203213        (enmCommand == USAGE_I_RENAMEVMDK || enmCommand == USAGE_S_ALL)
    204         ? "  renamevmdk -from <filename> -to <filename>\n"
    205           "       Renames an existing VMDK image, including the base file and all its extents.\n"
    206           "\n"
     214        ? Internal::tr(
     215           "  renamevmdk -from <filename> -to <filename>\n"
     216           "       Renames an existing VMDK image, including the base file and all its extents.\n"
     217           "\n")
    207218        : "",
    208219        (enmCommand == USAGE_I_CONVERTTORAW || enmCommand == USAGE_S_ALL)
    209         ? "  converttoraw [-format <fileformat>] <filename> <outputfile>"
    210220#ifdef ENABLE_CONVERT_RAW_TO_STDOUT
    211           "|stdout"
    212 #endif /* ENABLE_CONVERT_RAW_TO_STDOUT */
    213           "\n"
    214           "       Convert image to raw, writing to file"
    215 #ifdef ENABLE_CONVERT_RAW_TO_STDOUT
    216           " or stdout"
    217 #endif /* ENABLE_CONVERT_RAW_TO_STDOUT */
    218           ".\n"
    219           "\n"
     221        ? Internal::tr(
     222           "  converttoraw [-format <fileformat>] <filename> <outputfile>|stdout"
     223           "\n"
     224           "       Convert image to raw, writing to file or stdout.\n"
     225           "\n")
     226#else
     227        ? Internal::tr(
     228           "  converttoraw [-format <fileformat>] <filename> <outputfile>"
     229           "\n"
     230           "       Convert image to raw, writing to file.\n"
     231           "\n")
     232#endif
    220233        : "",
    221234        (enmCommand == USAGE_I_CONVERTHD || enmCommand == USAGE_S_ALL)
    222         ? "  converthd [-srcformat VDI|VMDK|VHD|RAW]\n"
    223           "            [-dstformat VDI|VMDK|VHD|RAW]\n"
    224           "            <inputfile> <outputfile>\n"
    225           "       converts hard disk images between formats\n"
    226           "\n"
     235        ? Internal::tr(
     236           "  converthd [-srcformat VDI|VMDK|VHD|RAW]\n"
     237           "            [-dstformat VDI|VMDK|VHD|RAW]\n"
     238           "            <inputfile> <outputfile>\n"
     239           "       converts hard disk images between formats\n"
     240           "\n")
    227241        : "",
    228242        (enmCommand == USAGE_I_REPAIRHD || enmCommand == USAGE_S_ALL)
    229         ? "  repairhd [-dry-run]\n"
    230           "           [-format VDI|VMDK|VHD|...]\n"
    231           "           <filename>\n"
    232           "       Tries to repair corrupted disk images\n"
    233           "\n"
     243        ? Internal::tr(
     244           "  repairhd [-dry-run]\n"
     245           "           [-format VDI|VMDK|VHD|...]\n"
     246           "           <filename>\n"
     247           "       Tries to repair corrupted disk images\n"
     248           "\n")
    234249        : "",
    235250#ifdef RT_OS_WINDOWS
    236251        (enmCommand == USAGE_I_MODINSTALL || enmCommand == USAGE_S_ALL)
    237         ? "  modinstall\n"
    238           "       Installs the necessary driver for the host OS\n"
    239           "\n"
     252        ? Internal::tr(
     253           "  modinstall\n"
     254           "       Installs the necessary driver for the host OS\n"
     255           "\n")
    240256        : "",
    241257        (enmCommand == USAGE_I_MODUNINSTALL || enmCommand == USAGE_S_ALL)
    242         ? "  moduninstall\n"
    243           "       Deinstalls the driver\n"
    244           "\n"
     258        ? Internal::tr(
     259           "  moduninstall\n"
     260           "       Deinstalls the driver\n"
     261           "\n")
    245262        : "",
    246263#else
    … …  
    249266#endif
    250267        (enmCommand == USAGE_I_DEBUGLOG || enmCommand == USAGE_S_ALL)
    251         ? "  debuglog <vmname|uuid> [--enable|--disable] [--flags todo]\n"
    252           "           [--groups todo] [--destinations todo]\n"
    253           "       Controls debug logging.\n"
    254           "\n"
     268        ? Internal::tr(
     269           "  debuglog <vmname|uuid> [--enable|--disable] [--flags todo]\n"
     270           "           [--groups todo] [--destinations todo]\n"
     271           "       Controls debug logging.\n"
     272           "\n")
    255273        : "",
    256274        (enmCommand == USAGE_I_PASSWORDHASH || enmCommand == USAGE_S_ALL)
    257         ? "  passwordhash <password>\n"
    258           "       Generates a password hash.\n"
    259           "\n"
     275        ? Internal::tr(
     276           "  passwordhash <password>\n"
     277           "       Generates a password hash.\n"
     278           "\n")
    260279        : "",
    261280        (enmCommand == USAGE_I_GUESTSTATS || enmCommand == USAGE_S_ALL)
    262         ? "  gueststats <vmname|uuid> [--interval <seconds>]\n"
    263           "       Obtains and prints internal guest statistics.\n"
    264           "       Sets the update interval if specified.\n"
    265           "\n"
     281        ? Internal::tr(
     282           "  gueststats <vmname|uuid> [--interval <seconds>]\n"
     283           "       Obtains and prints internal guest statistics.\n"
     284           "       Sets the update interval if specified.\n"
     285           "\n")
    266286        : ""
    267287        );
    … …  
    321341        }
    322342    }
    323     RTMsgError("Cannot find unique key for '%s'!", pszKeyBase);
     343    RTMsgError(Internal::tr("Cannot find unique key for '%s'!"), pszKeyBase);
    324344    return E_FAIL;
    325345}
    … …  
    384404    }
    385405    else
    386         RTMsgError("Failed to delete key '%s' from '%s',  string conversion error %Rrc!",
     406        RTMsgError(Internal::tr("Failed to delete key '%s' from '%s',  string conversion error %Rrc!"),
    387407                   pszKey,  pszKeyBase, rc);
    388408
    … …  
    408428                                         Bstr(pszValue).raw());
    409429    if (FAILED(hrc))
    410         RTMsgError("Failed to set '%s/%s/%s' to '%s'! hrc=%#x",
     430        RTMsgError(Internal::tr("Failed to set '%s/%s/%s' to '%s'! hrc=%#x"),
    411431                   pszKeyBase, pszKey, pszAttribute, pszValue, hrc);
    412432    return hrc;
    … …  
    476496    /* filename */
    477497    if (argc < 2)
    478         return errorArgument("Missing the filename argument!\n");
     498        return errorArgument(Internal::tr("Missing the filename argument!\n"));
    479499    pszFilename = argv[1];
    480500
    … …  
    484504        int irc = RTStrToInt64Ex(argv[2], NULL, 0, &offDelta);
    485505        if (RT_FAILURE(irc))
    486             return errorArgument(argv[0], "Failed to read delta '%s', rc=%Rrc\n", argv[2], rc);
     506            return errorArgument(argv[0], Internal::tr("Failed to read delta '%s', rc=%Rrc\n"), argv[2], rc);
    487507    }
    488508
    … …  
    496516        int irc = RTStrToUInt64Ex(argv[4], NULL, 0, &ModuleAddress);
    497517        if (RT_FAILURE(irc))
    498             return errorArgument(argv[0], "Failed to read module address '%s', rc=%Rrc\n", argv[4], rc);
     518            return errorArgument(argv[0], Internal::tr("Failed to read module address '%s', rc=%Rrc\n"), argv[4], rc);
    499519    }
    500520
    … …  
    504524        int irc = RTStrToUInt64Ex(argv[5], NULL, 0, &ModuleSize);
    505525        if (RT_FAILURE(irc))
    506             return errorArgument(argv[0], "Failed to read module size '%s', rc=%Rrc\n", argv[5], rc);
     526            return errorArgument(argv[0], Internal::tr("Failed to read module size '%s', rc=%Rrc\n"), argv[5], rc);
    507527    }
    508528
    … …  
    553573    /* filename */
    554574    if (argc < 2)
    555         return errorArgument("Missing the filename argument!\n");
     575        return errorArgument(Internal::tr("Missing the filename argument!\n"));
    556576    pszFilename = argv[1];
    557577
    558578    /* address */
    559579    if (argc < 3)
    560         return errorArgument("Missing the module address argument!\n");
     580        return errorArgument(Internal::tr("Missing the module address argument!\n"));
    561581    int irc = RTStrToUInt64Ex(argv[2], NULL, 0, &ModuleAddress);
    562582    if (RT_FAILURE(irc))
    563         return errorArgument(argv[0], "Failed to read module address '%s', rc=%Rrc\n", argv[2], rc);
     583        return errorArgument(argv[0], Internal::tr("Failed to read module address '%s', rc=%Rrc\n"), argv[2], rc);
    564584
    565585    /* name (optional) */
    … …  
    572592        irc = RTStrToUInt64Ex(argv[4], NULL, 0, &offSubtrahend);
    573593        if (RT_FAILURE(irc))
    574             return errorArgument(argv[0], "Failed to read subtrahend '%s', rc=%Rrc\n", argv[4], rc);
     594            return errorArgument(argv[0], Internal::tr("Failed to read subtrahend '%s', rc=%Rrc\n"), argv[4], rc);
    575595    }
    576596
    … …  
    580600        irc = RTStrToUInt32Ex(argv[5], NULL, 0, &iSeg);
    581601        if (RT_FAILURE(irc))
    582             return errorArgument(argv[0], "Failed to read segment number '%s', rc=%Rrc\n", argv[5], rc);
     602            return errorArgument(argv[0], Internal::tr("Failed to read segment number '%s', rc=%Rrc\n"), argv[5], rc);
    583603    }
    584604
    … …  
    607627    RT_NOREF(pvUser);
    608628    RTMsgErrorV(pszFormat, va);
    609     RTMsgError("Error code %Rrc at %s(%u) in function %s", rc, RT_SRC_POS_ARGS);
     629    RTMsgError(Internal::tr("Error code %Rrc at %s(%u) in function %s"), rc, RT_SRC_POS_ARGS);
    610630}
    611631
    … …  
    630650        uuidType = HDUUID;
    631651        if (argc != 3 && argc != 2)
    632             return errorSyntax(USAGE_I_SETHDUUID, "Not enough parameters");
     652            return errorSyntax(USAGE_I_SETHDUUID, Internal::tr("Not enough parameters"));
    633653        /* if specified, take UUID, otherwise generate a new one */
    634654        if (argc == 3)
    635655        {
    636656            if (RT_FAILURE(RTUuidFromStr(&rtuuid, argv[2])))
    637                 return errorSyntax(USAGE_I_SETHDUUID, "Invalid UUID parameter");
     657                return errorSyntax(USAGE_I_SETHDUUID, Internal::tr("Invalid UUID parameter"));
    638658            uuid = argv[2];
    639659        } else
    … …  
    644664        uuidType = HDPARENTUUID;
    645665        if (argc != 3)
    646             return errorSyntax(USAGE_I_SETHDPARENTUUID, "Not enough parameters");
     666            return errorSyntax(USAGE_I_SETHDPARENTUUID, Internal::tr("Not enough parameters"));
    647667        if (RT_FAILURE(RTUuidFromStr(&rtuuid, argv[2])))
    648             return errorSyntax(USAGE_I_SETHDPARENTUUID, "Invalid UUID parameter");
     668            return errorSyntax(USAGE_I_SETHDPARENTUUID, Internal::tr("Invalid UUID parameter"));
    649669        uuid = argv[2];
    650670    }
    651671    else
    652         return errorSyntax(USAGE_I_SETHDUUID, "Invalid invocation");
     672        return errorSyntax(USAGE_I_SETHDUUID, Internal::tr("Invalid invocation"));
    653673
    654674    /* just try it */
    … …  
    658678                         argv[1], VDTYPE_INVALID, &pszFormat, &enmType);
    659679    if (RT_FAILURE(rc))
    660         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Format autodetect failed: %Rrc", rc);
     680        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Format autodetect failed: %Rrc"), rc);
    661681
    662682    PVDISK pDisk = NULL;
    … …  
    667687    vdInterfaceError.pfnMessage   = handleVDMessage;
    668688
    669     rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
     689    rc = VDInterfaceAdd(&vdInterfaceError.Core, Internal::tr("VBoxManage_IError"), VDINTERFACETYPE_ERROR,
    670690                        NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
    671691    AssertRC(rc);
    … …  
    673693    rc = VDCreate(pVDIfs, enmType, &pDisk);
    674694    if (RT_FAILURE(rc))
    675         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot create the virtual disk container: %Rrc", rc);
     695        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot create the virtual disk container: %Rrc"), rc);
    676696
    677697    /* Open the image */
    678698    rc = VDOpen(pDisk, pszFormat, argv[1], VD_OPEN_FLAGS_NORMAL | VD_OPEN_FLAGS_INFO, NULL);
    679699    if (RT_FAILURE(rc))
    680         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot open the image: %Rrc", rc);
     700        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot open the image: %Rrc"), rc);
    681701
    682702    if (uuidType == HDUUID)
    … …  
    685705      rc = VDSetParentUuid(pDisk, VD_LAST_IMAGE, uuid.raw());
    686706    if (RT_FAILURE(rc))
    687         RTMsgError("Cannot set a new UUID: %Rrc", rc);
     707        RTMsgError(Internal::tr("Cannot set a new UUID: %Rrc"), rc);
    688708    else
    689         RTPrintf("UUID changed to: %s\n", uuid.toString().c_str());
     709        RTPrintf(Internal::tr("UUID changed to: %s\n"), uuid.toString().c_str());
    690710
    691711    VDCloseAll(pDisk);
    … …  
    702722    if (argc != 1)
    703723    {
    704         return errorSyntax(USAGE_I_DUMPHDINFO, "Not enough parameters");
     724        return errorSyntax(USAGE_I_DUMPHDINFO, Internal::tr("Not enough parameters"));
    705725    }
    706726
    … …  
    711731                         argv[0], VDTYPE_INVALID, &pszFormat, &enmType);
    712732    if (RT_FAILURE(rc))
    713         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Format autodetect failed: %Rrc", rc);
     733        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Format autodetect failed: %Rrc"), rc);
    714734
    715735    PVDISK pDisk = NULL;
    … …  
    720740    vdInterfaceError.pfnMessage   = handleVDMessage;
    721741
    722     rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
     742    rc = VDInterfaceAdd(&vdInterfaceError.Core, Internal::tr("VBoxManage_IError"), VDINTERFACETYPE_ERROR,
    723743                        NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
    724744    AssertRC(rc);
    … …  
    726746    rc = VDCreate(pVDIfs, enmType, &pDisk);
    727747    if (RT_FAILURE(rc))
    728         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot create the virtual disk container: %Rrc", rc);
     748        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot create the virtual disk container: %Rrc"), rc);
    729749
    730750    /* Open the image */
    731751    rc = VDOpen(pDisk, pszFormat, argv[0], VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO, NULL);
    732752    if (RT_FAILURE(rc))
    733         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot open the image: %Rrc", rc);
     753        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot open the image: %Rrc"), rc);
    734754
    735755    VDDumpImages(pDisk);
    … …  
    812832            if (partitionEntrySize * partitionsNumber > 4 * _1M)
    813833            {
    814                 RTMsgError("The GPT header seems corrupt because it contains too many entries");
     834                RTMsgError(Internal::tr("The GPT header seems corrupt because it contains too many entries"));
    815835                return VERR_INVALID_PARAMETER;
    816836            }
    … …  
    819839            if (!pbPartTable)
    820840            {
    821                 RTMsgError("Allocating memory for the GPT partitions entries failed");
     841                RTMsgError(Internal::tr("Allocating memory for the GPT partitions entries failed"));
    822842                return VERR_NO_MEMORY;
    823843            }
    … …  
    828848            if (RT_FAILURE(rc))
    829849            {
    830                 RTMsgError("Reading the partition table failed");
     850                RTMsgError(Internal::tr("Reading the partition table failed"));
    831851                RTMemFree(pbPartTable);
    832852                return rc;
    … …  
    912932                else
    913933                {
    914                     RTMsgError("More than one extended partition");
     934                    RTMsgError(Internal::tr("More than one extended partition"));
    915935                    return VERR_INVALID_PARAMETER;
    916936                }
    … …  
    930950            if (!uStart)
    931951            {
    932                 RTMsgError("Inconsistency for logical partition start");
     952                RTMsgError(Internal::tr("Inconsistency for logical partition start"));
    933953                return VERR_INVALID_PARAMETER;
    934954            }
    … …  
    942962                if (aBuffer[510] != 0x55 || aBuffer[511] != 0xaa)
    943963                {
    944                     RTMsgError("Logical partition without magic");
     964                    RTMsgError(Internal::tr("Logical partition without magic"));
    945965                    return VERR_INVALID_PARAMETER;
    946966                }
    … …  
    949969                if (p[4] == 0)
    950970                {
    951                     RTMsgError("Logical partition with type 0 encountered");
     971                    RTMsgError(Internal::tr("Logical partition with type 0 encountered"));
    952972                    return VERR_INVALID_PARAMETER;
    953973                }
    … …  
    966986                if (!uStartOffset)
    967987                {
    968                     RTMsgError("Invalid partition start offset");
     988                    RTMsgError(Internal::tr("Invalid partition start offset"));
    969989                    return VERR_INVALID_PARAMETER;
    970990                }
    … …  
    9861006                else
    9871007                {
    988                     RTMsgError("Logical partition chain broken");
     1008                    RTMsgError(Internal::tr("Logical partition chain broken"));
    9891009                    return VERR_INVALID_PARAMETER;
    9901010                }
    … …  
    10091029            else if (pPart->aPartitions[j].uStart == uMinVal)
    10101030            {
    1011                 RTMsgError("Two partitions start at the same place");
     1031                RTMsgError(Internal::tr("Two partitions start at the same place"));
    10121032                return VERR_INVALID_PARAMETER;
    10131033            }
    10141034            else if (pPart->aPartitions[j].uStart == 0)
    10151035            {
    1016                 RTMsgError("Partition starts at sector 0");
     1036                RTMsgError(Internal::tr("Partition starts at sector 0"));
    10171037                return VERR_INVALID_PARAMETER;
    10181038            }
    … …  
    10501070                pPart->cPartitions-1 != i)
    10511071            {
    1052                 RTMsgError("Overlapping GPT partitions");
     1072                RTMsgError(Internal::tr("Overlapping GPT partitions"));
    10531073                return VERR_INVALID_PARAMETER;
    10541074            }
    … …  
    10661086            if (pPart->aPartitions[i].uStart < uPrevEnd)
    10671087            {
    1068                 RTMsgError("Overlapping MBR partitions");
     1088                RTMsgError(Internal::tr("Overlapping MBR partitions"));
    10691089                return VERR_INVALID_PARAMETER;
    10701090            }
    … …  
    10891109            if (argc <= i + 1)
    10901110            {
    1091                 return errorArgument("Missing argument to '%s'", argv[i]);
     1111                return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]);
    10921112            }
    10931113            i++;
    … …  
    10961116        else
    10971117        {
    1098             return errorSyntax(USAGE_I_LISTPARTITIONS, "Invalid parameter '%s'", argv[i]);
     1118            return errorSyntax(USAGE_I_LISTPARTITIONS, Internal::tr("Invalid parameter '%s'"), argv[i]);
    10991119        }
    11001120    }
    11011121
    11021122    if (rawdisk.isEmpty())
    1103         return errorSyntax(USAGE_I_LISTPARTITIONS, "Mandatory parameter -rawdisk missing");
     1123        return errorSyntax(USAGE_I_LISTPARTITIONS, Internal::tr("Mandatory parameter -rawdisk missing"));
    11041124
    11051125    RTFILE hRawFile;
    11061126    int vrc = RTFileOpen(&hRawFile, rawdisk.c_str(), RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
    11071127    if (RT_FAILURE(vrc))
    1108         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot open the raw disk: %Rrc", vrc);
     1128        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot open the raw disk: %Rrc"), vrc);
    11091129
    11101130    HOSTPARTITIONS partitions;
    … …  
    11121132    /* Don't bail out on errors, print the table and return the result code. */
    11131133
    1114     RTPrintf("Number  Type   StartCHS       EndCHS      Size (MiB)  Start (Sect)\n");
     1134    RTPrintf(Internal::tr("Number  Type   StartCHS       EndCHS      Size (MiB)  Start (Sect)\n"));
    11151135    for (unsigned i = 0; i < partitions.cPartitions; i++)
    11161136    {
    … …  
    11741194            if (argc <= i + 1)
    11751195            {
    1176                 return errorArgument("Missing argument to '%s'", argv[i]);
     1196                return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]);
    11771197            }
    11781198            i++;
    … …  
    11831203            if (argc <= i + 1)
    11841204            {
    1185                 return errorArgument("Missing argument to '%s'", argv[i]);
     1205                return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]);
    11861206            }
    11871207            i++;
    … …  
    11921212            if (argc <= i + 1)
    11931213            {
    1194                 return errorArgument("Missing argument to '%s'", argv[i]);
     1214                return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]);
    11951215            }
    11961216            i++;
    … …  
    12011221            if (argc <= i + 1)
    12021222            {
    1203                 return errorArgument("Missing argument to '%s'", argv[i]);
     1223                return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]);
    12041224            }
    12051225            i++;
    … …  
    12131233#endif /* RT_OS_LINUX || RT_OS_FREEBSD */
    12141234        else
    1215             return errorSyntax(USAGE_I_CREATERAWVMDK, "Invalid parameter '%s'", argv[i]);
     1235            return errorSyntax(USAGE_I_CREATERAWVMDK, Internal::tr("Invalid parameter '%s'"), argv[i]);
    12161236    }
    12171237
    12181238    if (filename.isEmpty())
    1219         return errorSyntax(USAGE_I_CREATERAWVMDK, "Mandatory parameter -filename missing");
     1239        return errorSyntax(USAGE_I_CREATERAWVMDK, Internal::tr("Mandatory parameter -filename missing"));
    12201240    if (rawdisk.isEmpty())
    1221         return errorSyntax(USAGE_I_CREATERAWVMDK, "Mandatory parameter -rawdisk missing");
     1241        return errorSyntax(USAGE_I_CREATERAWVMDK, Internal::tr("Mandatory parameter -rawdisk missing"));
    12221242    if (!pszPartitions && pszMBRFilename)
    1223         return errorSyntax(USAGE_I_CREATERAWVMDK, "The parameter -mbr is only valid when the parameter -partitions is also present");
     1243        return errorSyntax(USAGE_I_CREATERAWVMDK,
     1244                           Internal::tr("The parameter -mbr is only valid when the parameter -partitions is also present"));
    12241245
    12251246#ifdef RT_OS_DARWIN
    … …  
    12301251    if (RT_FAILURE(vrc))
    12311252    {
    1232         RTMsgError("Cannot open the raw disk '%s': %Rrc", rawdisk.c_str(), vrc);
     1253        RTMsgError(Internal::tr("Cannot open the raw disk '%s': %Rrc"), rawdisk.c_str(), vrc);
    12331254        goto out;
    12341255    }
    … …  
    12591280        else
    12601281        {
    1261             RTMsgError("File '%s' is no fixed/removable medium device", rawdisk.c_str());
     1282            RTMsgError(Internal::tr("File '%s' is no fixed/removable medium device"), rawdisk.c_str());
    12621283            vrc = VERR_INVALID_PARAMETER;
    12631284            goto out;
    … …  
    12761297            && !rawdisk.startsWith("\\\\.\\PhysicalDrive", Utf8Str::CaseInsensitive))
    12771298        {
    1278             RTMsgError("The -relative parameter is invalid for raw disk %s", rawdisk.c_str());
     1299            RTMsgError(Internal::tr("The -relative parameter is invalid for raw disk %s"), rawdisk.c_str());
    12791300            vrc = VERR_INVALID_PARAMETER;
    12801301            goto out;
    … …  
    12901311        if (RT_FAILURE(RTFileQuerySize(hRawFile, &cbSize)))
    12911312        {
    1292             RTMsgError("Cannot get the geometry of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc);
     1313            RTMsgError(Internal::tr("Cannot get the geometry of the raw disk '%s': %Rrc"), rawdisk.c_str(), vrc);
    12931314            goto out;
    12941315        }
    … …  
    12971318            if (fRelative)
    12981319            {
    1299                 RTMsgError("The -relative parameter is invalid for raw images");
     1320                RTMsgError(Internal::tr("The -relative parameter is invalid for raw images"));
    13001321                vrc = VERR_INVALID_PARAMETER;
    13011322                goto out;
    … …  
    13311352                {
    13321353                    vrc = RTErrConvertFromErrno(errno);
    1333                     RTMsgError("Cannot get the size of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc);
     1354                    RTMsgError(Internal::tr("Cannot get the size of the raw disk '%s': %Rrc"), rawdisk.c_str(), vrc);
    13341355                    goto out;
    13351356                }
    … …  
    13411362            if (RT_FAILURE(vrc))
    13421363            {
    1343                 RTMsgError("Failed to get size of file '%s': %Rrc", rawdisk.c_str(), vrc);
     1364                RTMsgError(Internal::tr("Failed to get size of file '%s': %Rrc"), rawdisk.c_str(), vrc);
    13441365                goto out;
    13451366            }
    13461367            else if (fRelative)
    13471368            {
    1348                 RTMsgError("The -relative parameter is invalid for raw images");
     1369                RTMsgError(Internal::tr("The -relative parameter is invalid for raw images"));
    13491370                vrc = VERR_INVALID_PARAMETER;
    13501371                goto out;
    … …  
    13531374        else
    13541375        {
    1355             RTMsgError("File '%s' is no block device", rawdisk.c_str());
     1376            RTMsgError(Internal::tr("File '%s' is no block device"), rawdisk.c_str());
    13561377            vrc = VERR_INVALID_PARAMETER;
    13571378            goto out;
    … …  
    13611382    {
    13621383        vrc = RTErrConvertFromErrno(errno);
    1363         RTMsgError("Failed to get file informtation for raw disk '%s': %Rrc",
     1384        RTMsgError(Internal::tr("Failed to get file informtation for raw disk '%s': %Rrc"),
    13641385                   rawdisk.c_str(), vrc);
    13651386    }
    … …  
    13781399                else
    13791400                {
    1380                     RTMsgError("Cannot get the block size for file '%s': %Rrc", rawdisk.c_str(), vrc);
     1401                    RTMsgError(Internal::tr("Cannot get the block size for file '%s': %Rrc", rawdisk.c_str()), vrc);
    13811402                    vrc = RTErrConvertFromErrno(errno);
    13821403                    goto out;
    … …  
    13861407            {
    13871408                vrc = RTErrConvertFromErrno(errno);
    1388                 RTMsgError("Cannot get the block count for file '%s': %Rrc", rawdisk.c_str(), vrc);
     1409                RTMsgError(Internal::tr("Cannot get the block count for file '%s': %Rrc"), rawdisk.c_str(), vrc);
    13891410                goto out;
    13901411            }
    … …  
    13961417            if (RT_FAILURE(vrc))
    13971418            {
    1398                 RTMsgError("Failed to get size of file '%s': %Rrc", rawdisk.c_str(), vrc);
     1419                RTMsgError(Internal::tr("Failed to get size of file '%s': %Rrc"), rawdisk.c_str(), vrc);
    13991420                goto out;
    14001421            }
    … …  
    14021423        else
    14031424        {
    1404             RTMsgError("File '%s' is neither block device nor regular file", rawdisk.c_str());
     1425            RTMsgError(Internal::tr("File '%s' is neither block device nor regular file"), rawdisk.c_str());
    14051426            vrc = VERR_INVALID_PARAMETER;
    14061427            goto out;
    … …  
    14101431    {
    14111432        vrc = RTErrConvertFromErrno(errno);
    1412         RTMsgError("Failed to get file informtation for raw disk '%s': %Rrc",
     1433        RTMsgError(Internal::tr("Failed to get file informtation for raw disk '%s': %Rrc"),
    14131434                   rawdisk.c_str(), vrc);
    14141435    }
    … …  
    14251446            {
    14261447                vrc = RTErrConvertFromErrno(errno);
    1427                 RTMsgError("Cannot get the size of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc);
     1448                RTMsgError(Internal::tr("Cannot get the size of the raw disk '%s': %Rrc"), rawdisk.c_str(), vrc);
    14281449                goto out;
    14291450            }
    … …  
    14341455            if (RT_FAILURE(vrc))
    14351456            {
    1436                 RTMsgError("Failed to get size of file '%s': %Rrc", rawdisk.c_str(), vrc);
     1457                RTMsgError(Internal::tr("Failed to get size of file '%s': %Rrc"), rawdisk.c_str(), vrc);
    14371458                goto out;
    14381459            }
    … …  
    14401461        else
    14411462        {
    1442             RTMsgError("File '%s' is no block or char device", rawdisk.c_str());
     1463            RTMsgError(Internal::tr("File '%s' is no block or char device"), rawdisk.c_str());
    14431464            vrc = VERR_INVALID_PARAMETER;
    14441465            goto out;
    … …  
    14481469    {
    14491470        vrc = RTErrConvertFromErrno(errno);
    1450         RTMsgError("Failed to get file informtation for raw disk '%s': %Rrc",
     1471        RTMsgError(Internal::tr("Failed to get file informtation for raw disk '%s': %Rrc"),
    14511472                   rawdisk.c_str(), vrc);
    14521473    }
    … …  
    14631484            {
    14641485                vrc = RTErrConvertFromErrno(errno);
    1465                 RTMsgError("Cannot get the block count for file '%s': %Rrc", rawdisk.c_str(), vrc);
     1486                RTMsgError(Internal::tr("Cannot get the block count for file '%s': %Rrc"), rawdisk.c_str(), vrc);
    14661487                goto out;
    14671488            }
    … …  
    14711492            if (fRelative)
    14721493            {
    1473                 RTMsgError("The -relative parameter is invalid for raw images");
     1494                RTMsgError(Internal::tr("The -relative parameter is invalid for raw images"));
    14741495                vrc = VERR_INVALID_PARAMETER;
    14751496                goto out;
    … …  
    14791500        else
    14801501        {
    1481             RTMsgError("File '%s' is neither character device nor regular file", rawdisk.c_str());
     1502            RTMsgError(Internal::tr("File '%s' is neither character device nor regular file"), rawdisk.c_str());
    14821503            vrc = VERR_INVALID_PARAMETER;
    14831504            goto out;
    … …  
    14871508    {
    14881509        vrc = RTErrConvertFromErrno(errno);
    1489         RTMsgError("Failed to get file informtation for raw disk '%s': %Rrc",
     1510        RTMsgError(Internal::tr("Failed to get file informtation for raw disk '%s': %Rrc"),
    14901511                   rawdisk.c_str(), vrc);
    14911512    }
    … …  
    14961517    if (RT_FAILURE(vrc))
    14971518    {
    1498         RTMsgError("Cannot get the size of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc);
     1519        RTMsgError(Internal::tr("Cannot get the size of the raw disk '%s': %Rrc"), rawdisk.c_str(), vrc);
    14991520        goto out;
    15001521    }
    … …  
    15041525    if (!cbSize || cbSize % 512)
    15051526    {
    1506         RTMsgError("Detected size of raw disk '%s' is %RU64, an invalid value", rawdisk.c_str(), cbSize);
     1527        RTMsgError(Internal::tr("Detected size of raw disk '%s' is %RU64, an invalid value"), rawdisk.c_str(), cbSize);
    15071528        vrc = VERR_INVALID_PARAMETER;
    15081529        goto out;
    … …  
    15361557            if (RT_FAILURE(vrc))
    15371558            {
    1538                 RTMsgError("Incorrect value in partitions parameter");
     1559                RTMsgError(Internal::tr("Incorrect value in partitions parameter"));
    15391560                goto out;
    15401561            }
    … …  
    15501571            else if (*p != '\0')
    15511572            {
    1552                 RTMsgError("Incorrect separator in partitions parameter");
     1573                RTMsgError(Internal::tr("Incorrect separator in partitions parameter"));
    15531574                vrc = VERR_INVALID_PARAMETER;
    15541575                goto out;
    … …  
    15601581        if (RT_FAILURE(vrc))
    15611582        {
    1562             RTMsgError("Cannot read the partition information from '%s'", rawdisk.c_str());
     1583            RTMsgError(Internal::tr("Cannot read the partition information from '%s'"), rawdisk.c_str());
    15631584            goto out;
    15641585        }
    … …  
    15751596                 * partitions error later during VMDK creation. So warn
    15761597                 * here and ignore what the user requested. */
    1577                 RTMsgWarning("It is not possible (and necessary) to explicitly give access to the "
    1578                              "extended partition %u. If required, enable access to all logical "
    1579                              "partitions inside this extended partition.",
     1598                RTMsgWarning(Internal::tr(
     1599                                "It is not possible (and necessary) to explicitly give access to the "
     1600                                "extended partition %u. If required, enable access to all logical "
     1601                                "partitions inside this extended partition."),
    15801602                             partitions.aPartitions[i].uIndex);
    15811603                uPartitions &= ~RT_BIT(partitions.aPartitions[i].uIndex);
    … …  
    15941616                if (!pPartDesc)
    15951617                {
    1596                     RTMsgError("Out of memory allocating the partition list for '%s'", rawdisk.c_str());
     1618                    RTMsgError(Internal::tr("Out of memory allocating the partition list for '%s'"), rawdisk.c_str());
    15971619                    vrc = VERR_NO_MEMORY;
    15981620                    goto out;
    … …  
    16101632                if (!pPartData)
    16111633                {
    1612                     RTMsgError("Out of memory allocating the partition descriptor for '%s'", rawdisk.c_str());
     1634                    RTMsgError(Internal::tr("Out of memory allocating the partition descriptor for '%s'"),
     1635                               rawdisk.c_str());
    16131636                    vrc = VERR_NO_MEMORY;
    16141637                    goto out;
    … …  
    16181641                if (RT_FAILURE(vrc))
    16191642                {
    1620                     RTMsgError("Cannot read partition data from raw device '%s': %Rrc", rawdisk.c_str(), vrc);
     1643                    RTMsgError(Internal::tr("Cannot read partition data from raw device '%s': %Rrc"),
     1644                               rawdisk.c_str(), vrc);
    16211645                    goto out;
    16221646                }
    … …  
    16291653                    if (RT_FAILURE(vrc))
    16301654                    {
    1631                         RTMsgError("Cannot open replacement MBR file '%s' specified with -mbr: %Rrc", pszMBRFilename, vrc);
     1655                        RTMsgError(Internal::tr("Cannot open replacement MBR file '%s' specified with -mbr: %Rrc"),
     1656                                   pszMBRFilename, vrc);
    16321657                        goto out;
    16331658                    }
    … …  
    16361661                    if (RT_FAILURE(vrc))
    16371662                    {
    1638                         RTMsgError("Cannot read replacement MBR file '%s': %Rrc", pszMBRFilename, vrc);
     1663                        RTMsgError(Internal::tr("Cannot read replacement MBR file '%s': %Rrc"), pszMBRFilename, vrc);
    16391664                        goto out;
    16401665                    }
    … …  
    16591684            if (!pPartDesc)
    16601685            {
    1661                 RTMsgError("Out of memory allocating the partition list for '%s'", rawdisk.c_str());
     1686                RTMsgError(Internal::tr("Out of memory allocating the partition list for '%s'"), rawdisk.c_str());
    16621687                vrc = VERR_NO_MEMORY;
    16631688                goto out;
    … …  
    17021727                    {
    17031728                        vrc = VERR_NO_STR_MEMORY;
    1704                         RTMsgError("Cannot create reference to individual partition %u, rc=%Rrc",
     1729                        RTMsgError(Internal::tr("Cannot create reference to individual partition %u, rc=%Rrc"),
    17051730                                   partitions.aPartitions[i].uIndex, vrc);
    17061731                        goto out;
    … …  
    17171742                    {
    17181743                        vrc = VERR_NO_STR_MEMORY;
    1719                         RTMsgError("Cannot create reference to individual partition %u (numbered %u), rc=%Rrc",
     1744                        RTMsgError(Internal::tr("Cannot create reference to individual partition %u (numbered %u), rc=%Rrc"),
    17201745                                   partitions.aPartitions[i].uIndex, partitions.aPartitions[i].uIndexWin, vrc);
    17211746                        goto out;
    … …  
    17791804                    if (RawDescriptor.enmPartitioningType == VDISKPARTTYPE_MBR)
    17801805                    {
    1781                         RTMsgError("MBR/EPT overlaps with data area");
     1806                        RTMsgError(Internal::tr("MBR/EPT overlaps with data area"));
    17821807                        vrc = VERR_INVALID_PARAMETER;
    17831808                        goto out;
    … …  
    17851810                    if (RawDescriptor.cPartDescs != i+1)
    17861811                    {
    1787                         RTMsgError("GPT overlaps with data area");
     1812                        RTMsgError(Internal::tr("GPT overlaps with data area"));
    17881813                        vrc = VERR_INVALID_PARAMETER;
    17891814                        goto out;
    … …  
    18231848    if (RT_FAILURE(vrc))
    18241849    {
    1825         RTMsgError("Cannot create the virtual disk container: %Rrc", vrc);
     1850        RTMsgError(Internal::tr("Cannot create the virtual disk container: %Rrc"), vrc);
    18261851        goto out;
    18271852    }
    … …  
    18421867    if (RT_FAILURE(vrc))
    18431868    {
    1844         RTMsgError("Cannot create the raw disk VMDK: %Rrc", vrc);
     1869        RTMsgError(Internal::tr("Cannot create the raw disk VMDK: %Rrc"), vrc);
    18451870        goto out;
    18461871    }
    1847     RTPrintf("RAW host disk access VMDK file %s created successfully.\n", filename.c_str());
     1872    RTPrintf(Internal::tr("RAW host disk access VMDK file %s created successfully.\n"), filename.c_str());
    18481873
    18491874    VDCloseAll(pDisk);
    … …  
    18671892
    18681893out:
    1869     RTMsgError("The raw disk vmdk file was not created");
     1894    RTMsgError(Internal::tr("The raw disk vmdk file was not created"));
    18701895    return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    18711896}
    … …  
    18831908            if (argc <= i + 1)
    18841909            {
    1885                 return errorArgument("Missing argument to '%s'", argv[i]);
     1910                return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]);
    18861911            }
    18871912            i++;
    … …  
    18921917            if (argc <= i + 1)
    18931918            {
    1894                 return errorArgument("Missing argument to '%s'", argv[i]);
     1919                return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]);
    18951920            }
    18961921            i++;
    … …  
    18991924        else
    19001925        {
    1901             return errorSyntax(USAGE_I_RENAMEVMDK, "Invalid parameter '%s'", argv[i]);
     1926            return errorSyntax(USAGE_I_RENAMEVMDK, Internal::tr("Invalid parameter '%s'"), argv[i]);
    19021927        }
    19031928    }
    19041929
    19051930    if (src.isEmpty())
    1906         return errorSyntax(USAGE_I_RENAMEVMDK, "Mandatory parameter -from missing");
     1931        return errorSyntax(USAGE_I_RENAMEVMDK, Internal::tr("Mandatory parameter -from missing"));
    19071932    if (dst.isEmpty())
    1908         return errorSyntax(USAGE_I_RENAMEVMDK, "Mandatory parameter -to missing");
     1933        return errorSyntax(USAGE_I_RENAMEVMDK, Internal::tr("Mandatory parameter -to missing"));
    19091934
    19101935    PVDISK pDisk = NULL;
    … …  
    19211946    vrc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
    19221947    if (RT_FAILURE(vrc))
    1923         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot create the virtual disk container: %Rrc", vrc);
     1948        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot create the virtual disk container: %Rrc"), vrc);
    19241949
    19251950    vrc = VDOpen(pDisk, "VMDK", src.c_str(), VD_OPEN_FLAGS_NORMAL, NULL);
    … …  
    19301955                     NULL, NULL, NULL);
    19311956        if (RT_FAILURE(vrc))
    1932             RTMsgError("Cannot rename the image: %Rrc", vrc);
     1957            RTMsgError(Internal::tr("Cannot rename the image: %Rrc"), vrc);
    19331958    }
    19341959    else
    1935         RTMsgError("Cannot create the source image: %Rrc", vrc);
     1960        RTMsgError(Internal::tr("Cannot create the source image: %Rrc"), vrc);
    19361961    VDCloseAll(pDisk);
    19371962    return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    … …  
    19531978            if (argc <= i + 1)
    19541979            {
    1955                 return errorArgument("Missing argument to '%s'", argv[i]);
     1980                return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]);
    19561981            }
    19571982            i++;
    … …  
    19721997        else
    19731998        {
    1974             return errorSyntax(USAGE_I_CONVERTTORAW, "Invalid parameter '%s'", argv[i]);
     1999            return errorSyntax(USAGE_I_CONVERTTORAW, Internal::tr("Invalid parameter '%s'"), argv[i]);
    19752000        }
    19762001    }
    19772002
    19782003    if (src.isEmpty())
    1979         return errorSyntax(USAGE_I_CONVERTTORAW, "Mandatory filename parameter missing");
     2004        return errorSyntax(USAGE_I_CONVERTTORAW, Internal::tr("Mandatory filename parameter missing"));
    19802005    if (dst.isEmpty())
    1981         return errorSyntax(USAGE_I_CONVERTTORAW, "Mandatory outputfile parameter missing");
     2006        return errorSyntax(USAGE_I_CONVERTTORAW, Internal::tr("Mandatory outputfile parameter missing"));
    19822007
    19832008    PVDISK pDisk = NULL;
    … …  
    19952020    vrc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
    19962021    if (RT_FAILURE(vrc))
    1997         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot create the virtual disk container: %Rrc", vrc);
     2022        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot create the virtual disk container: %Rrc"), vrc);
    19982023
    19992024    /* Open raw output file. */
    … …  
    20072032    {
    20082033        VDCloseAll(pDisk);
    2009         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot create destination file \"%s\": %Rrc", dst.c_str(), vrc);
     2034        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot create destination file \"%s\": %Rrc"),
     2035                              dst.c_str(), vrc);
    20102036    }
    20112037
    … …  
    20252051            }
    20262052            if (RT_FAILURE(vrc))
    2027                 RTMsgError("No file format specified and autodetect failed - please specify format: %Rrc", vrc);
     2053                RTMsgError(Internal::tr("No file format specified and autodetect failed - please specify format: %Rrc"),
     2054                           vrc);
    20282055            else
    2029                 RTMsgError("Only converting harddisk images is supported");
     2056                RTMsgError(Internal::tr("Only converting harddisk images is supported"));
    20302057            return RTEXITCODE_FAILURE;
    20312058        }
    … …  
    20422069            RTFileDelete(dst.c_str());
    20432070        }
    2044         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot open the source image: %Rrc", vrc);
     2071        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot open the source image: %Rrc"), vrc);
    20452072    }
    20462073
    … …  
    20522079    if (pvBuf)
    20532080    {
    2054         RTStrmPrintf(g_pStdErr, "Converting image \"%s\" with size %RU64 bytes (%RU64MB) to raw...\n", src.c_str(), cbSize, (cbSize + _1M - 1) / _1M);
     2081        RTStrmPrintf(g_pStdErr, Internal::tr("Converting image \"%s\" with size %RU64 bytes (%RU64MB) to raw...\n"),
     2082                     src.c_str(), cbSize, (cbSize + _1M - 1) / _1M);
    20552083        while (offFile < cbSize)
    20562084        {
    … …  
    20732101                RTFileDelete(dst.c_str());
    20742102            }
    2075             return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot copy image data: %Rrc", vrc);
     2103            return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot copy image data: %Rrc"), vrc);
    20762104        }
    20772105    }
    … …  
    20852113            RTFileDelete(dst.c_str());
    20862114        }
    2087         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory allocating read buffer");
     2115        return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Out of memory allocating read buffer"));
    20882116    }
    20892117
    … …  
    21132141            if (argc <= i + 1)
    21142142            {
    2115                 return errorArgument("Missing argument to '%s'", argv[i]);
     2143                return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]);
    21162144            }
    21172145            i++;
    … …  
    21222150            if (argc <= i + 1)
    21232151            {
    2124                 return errorArgument("Missing argument to '%s'", argv[i]);
     2152                return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]);
    21252153            }
    21262154            i++;
    … …  
    21372165        else
    21382166        {
    2139             return errorSyntax(USAGE_I_CONVERTHD, "Invalid parameter '%s'", argv[i]);
     2167            return errorSyntax(USAGE_I_CONVERTHD, Internal::tr("Invalid parameter '%s'"), argv[i]);
    21402168        }
    21412169    }
    21422170
    21432171    if (src.isEmpty())
    2144         return errorSyntax(USAGE_I_CONVERTHD, "Mandatory input image parameter missing");
     2172        return errorSyntax(USAGE_I_CONVERTHD, Internal::tr("Mandatory input image parameter missing"));
    21452173    if (dst.isEmpty())
    2146         return errorSyntax(USAGE_I_CONVERTHD, "Mandatory output image parameter missing");
     2174        return errorSyntax(USAGE_I_CONVERTHD, Internal::tr("Mandatory output image parameter missing"));
    21472175
    21482176
    … …  
    21662194            if (RT_FAILURE(vrc))
    21672195            {
    2168                 RTMsgError("No file format specified and autodetect failed - please specify format: %Rrc", vrc);
     2196                RTMsgError(Internal::tr("No file format specified and autodetect failed - please specify format: %Rrc"),
     2197                           vrc);
    21692198                break;
    21702199            }
    … …  
    21762205        if (RT_FAILURE(vrc))
    21772206        {
    2178             RTMsgError("Cannot create the source virtual disk container: %Rrc", vrc);
     2207            RTMsgError(Internal::tr("Cannot create the source virtual disk container: %Rrc"), vrc);
    21792208            break;
    21802209        }
    … …  
    21842213        if (RT_FAILURE(vrc))
    21852214        {
    2186             RTMsgError("Cannot open the source image: %Rrc", vrc);
     2215            RTMsgError(Internal::tr("Cannot open the source image: %Rrc"), vrc);
    21872216            break;
    21882217        }
    … …  
    21952224        if (RT_FAILURE(vrc))
    21962225        {
    2197             RTMsgError("Cannot create the destination virtual disk container: %Rrc", vrc);
     2226            RTMsgError(Internal::tr("Cannot create the destination virtual disk container: %Rrc"), vrc);
    21982227            break;
    21992228        }
    22002229
    22012230        uint64_t cbSize = VDGetSize(pSrcDisk, VD_LAST_IMAGE);
    2202         RTStrmPrintf(g_pStdErr, "Converting image \"%s\" with size %RU64 bytes (%RU64MB)...\n", src.c_str(), cbSize, (cbSize + _1M - 1) / _1M);
     2231        RTStrmPrintf(g_pStdErr, Internal::tr("Converting image \"%s\" with size %RU64 bytes (%RU64MB)...\n"),
     2232                     src.c_str(), cbSize, (cbSize + _1M - 1) / _1M);
    22032233
    22042234        /* Create the output image */
    … …  
    22082238        if (RT_FAILURE(vrc))
    22092239        {
    2210             RTMsgError("Cannot copy the image: %Rrc", vrc);
     2240            RTMsgError(Internal::tr("Cannot copy the image: %Rrc"), vrc);
    22112241            break;
    22122242        }
    … …  
    22452275            if (argc <= i + 1)
    22462276            {
    2247                 return errorArgument("Missing argument to '%s'", argv[i]);
     2277                return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]);
    22482278            }
    22492279            i++;
    … …  
    22562286        else
    22572287        {
    2258             return errorSyntax(USAGE_I_REPAIRHD, "Invalid parameter '%s'", argv[i]);
     2288            return errorSyntax(USAGE_I_REPAIRHD, Internal::tr("Invalid parameter '%s'"), argv[i]);
    22592289        }
    22602290    }
    22612291
    22622292    if (image.isEmpty())
    2263         return errorSyntax(USAGE_I_REPAIRHD, "Mandatory input image parameter missing");
     2293        return errorSyntax(USAGE_I_REPAIRHD, Internal::tr("Mandatory input image parameter missing"));
    22642294
    22652295    PVDINTERFACE     pVDIfs = NULL;
    … …  
    22842314            if (RT_FAILURE(vrc) && (vrc != VERR_VD_IMAGE_CORRUPTED))
    22852315            {
    2286                 RTMsgError("No file format specified and autodetect failed - please specify format: %Rrc", vrc);
     2316                RTMsgError(Internal::tr("No file format specified and autodetect failed - please specify format: %Rrc"),
     2317                           vrc);
    22872318                break;
    22882319            }
    … …  
    23352366     */
    23362367    if (argc < 1)
    2337         return errorSyntax(USAGE_I_DEBUGLOG, "Missing VM name/UUID");
     2368        return errorSyntax(USAGE_I_DEBUGLOG, Internal::tr("Missing VM name/UUID"));
    23382369
    23392370    ComPtr<IMachine> ptrMachine;
    … …  
    24352466    /** @todo flags, groups destination. */
    24362467    if (fFlagsPresent || fGroupsPresent || fDestsPresent)
    2437         RTMsgWarning("One or more of the requested features are not implemented! Feel free to do this.");
     2468        RTMsgWarning(Internal::tr("One or more of the requested features are not implemented! Feel free to do this."));
    24382469
    24392470    if (fEnablePresent && fEnable)
    … …  
    24512482    /* one parameter, the password to hash */
    24522483    if (argc != 1)
    2453         return errorSyntax(USAGE_I_PASSWORDHASH, "password to hash required");
     2484        return errorSyntax(USAGE_I_PASSWORDHASH, Internal::tr("password to hash required"));
    24542485
    24552486    uint8_t abDigest[RTSHA256_HASH_SIZE];
    … …  
    24572488    char pszDigest[RTSHA256_DIGEST_LEN + 1];
    24582489    RTSha256ToString(abDigest, pszDigest, sizeof(pszDigest));
    2459     RTPrintf("Password hash: %s\n", pszDigest);
     2490    RTPrintf(Internal::tr("Password hash: %s\n"), pszDigest);
    24602491
    24612492    return RTEXITCODE_SUCCESS;
    … …  
    24702501    /* one parameter, guest name */
    24712502    if (argc < 1)
    2472         return errorSyntax(USAGE_I_GUESTSTATS, "Missing VM name/UUID");
     2503        return errorSyntax(USAGE_I_GUESTSTATS, Internal::tr("Missing VM name/UUID"));
    24732504
    24742505    /*
    … …  
    25002531
    25012532    if (argc > 1 && aUpdateInterval == 0)
    2502         return errorSyntax(USAGE_I_GUESTSTATS, "Invalid update interval specified");
    2503 
    2504     RTPrintf("argc=%d interval=%u\n", argc, aUpdateInterval);
     2533        return errorSyntax(USAGE_I_GUESTSTATS, Internal::tr("Invalid update interval specified"));
     2534
     2535    RTPrintf(Internal::tr("argc=%d interval=%u\n"), argc, aUpdateInterval);
    25052536
    25062537    ComPtr<IMachine> ptrMachine;
    … …  
    25552586    /* at least a command is required */
    25562587    if (a->argc < 1)
    2557         return errorSyntax(USAGE_S_ALL, "Command missing");
     2588        return errorSyntax(USAGE_S_ALL, Internal::tr("Command missing"));
    25582589
    25592590    /*
    … …  
    25952626
    25962627    /* default: */
    2597     return errorSyntax(USAGE_S_ALL, "Invalid command '%s'", a->argv[0]);
     2628    return errorSyntax(USAGE_S_ALL, Internal::tr("Invalid command '%s'"), a->argv[0]);
    25982629}
    2599 

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManage.cpp

    r91617 r92372  
    4747
    4848#include "VBoxManage.h"
    49 
    5049
    5150/*********************************************************************************************************************************
    … …  
    8281#endif
    8382
     83DECLARE_TRANSLATION_CONTEXT(VBoxManage);
    8484
    8585/*********************************************************************************************************************************
    … …  
    236236    if (FAILED(hrc))
    237237    {
    238         RTStrmPrintf(g_pStdErr, "Progress object failure: %Rhrc\n", hrc);
     238        RTStrmPrintf(g_pStdErr, VBoxManage::tr("Progress object failure: %Rhrc\n"), hrc);
    239239        RTStrmFlush(g_pStdErr);
    240240        return hrc;
    … …  
    253253        if (FAILED(hrc))
    254254        {
    255             RTStrmPrintf(g_pStdErr, "Failed to get progress description: %Rhrc\n", hrc);
     255            RTStrmPrintf(g_pStdErr, VBoxManage::tr("Failed to get progress description: %Rhrc\n"), hrc);
    256256            return hrc;
    257257        }
    … …  
    320320                progress->COMGETTER(TimeRemaining)(&lSecsRem);
    321321
    322                 RTStrmPrintf(g_pStdErr, "(%u/%u) %ls %02u%% => %02u%% (%d s remaining)\n", ulOperation + 1, cOperations,
     322                RTStrmPrintf(g_pStdErr, VBoxManage::tr("(%u/%u) %ls %02u%% => %02u%% (%d s remaining)\n"), ulOperation + 1, cOperations,
    323323                             bstrOperationDescription.raw(), ulCurrentOperationPercent, ulCurrentPercent, lSecsRem);
    324324                ulLastPercent = ulCurrentPercent;
    … …  
    390390        }
    391391        else if (g_fCanceled)
    392             RTStrmPrintf(g_pStdErr, "CANCELED\n");
     392            RTStrmPrintf(g_pStdErr, VBoxManage::tr("CANCELED\n"));
    393393        else
    394394        {
    395395            if (fDetailed)
    396                 RTStrmPrintf(g_pStdErr, "Progress state: %Rhrc\n", iRc);
     396                RTStrmPrintf(g_pStdErr, VBoxManage::tr("Progress state: %Rhrc\n"), iRc);
    397397            else if (fFlags != SHOW_PROGRESS_NONE)
    398398                RTStrmPrintf(g_pStdErr, "%Rhrc\n", iRc);
    … …  
    404404        if (!fDetailed)
    405405            RTStrmPrintf(g_pStdErr, "\n");
    406         RTStrmPrintf(g_pStdErr, "Progress object failure: %Rhrc\n", hrc);
     406        RTStrmPrintf(g_pStdErr, VBoxManage::tr("Progress object failure: %Rhrc\n"), hrc);
    407407    }
    408408    RTStrmFlush(g_pStdErr);
    … …  
    508508        {
    509509            if (i >= argc - 1)
    510                 return RTMsgErrorExit(RTEXITCODE_FAILURE, "Password expected");
     510                return RTMsgErrorExit(RTEXITCODE_FAILURE, VBoxManage::tr("Password expected"));
    511511            /* password for certain settings */
    512512            pszSettingsPw = argv[i + 1];
    … …  
    516516        {
    517517            if (i >= argc-1)
    518                 return RTMsgErrorExit(RTEXITCODE_FAILURE, "No password file specified");
     518                return RTMsgErrorExit(RTEXITCODE_FAILURE, VBoxManage::tr("No password file specified"));
    519519            pszSettingsPwFile = argv[i+1];
    520520            iCmd += 2;
    … …  
    524524        {
    525525            if (papszResponseFileArgs)
    526                 return RTMsgErrorExitFailure("Only one response file allowed");
     526                return RTMsgErrorExitFailure(VBoxManage::tr("Only one response file allowed"));
    527527
    528528            /* Load response file, making sure it's valid UTF-8. */
    … …  
    532532                                  (void **)&pszResponseFile, &cbResponseFile);
    533533            if (RT_FAILURE(vrc))
    534                 return RTMsgErrorExitFailure("Error reading response file '%s': %Rrc", &argv[i][1], vrc);
     534                return RTMsgErrorExitFailure(VBoxManage::tr("Error reading response file '%s': %Rrc"), &argv[i][1], vrc);
    535535            vrc = RTStrValidateEncoding(pszResponseFile);
    536536            if (RT_FAILURE(vrc))
    537537            {
    538538                RTFileReadAllFree(pszResponseFile, cbResponseFile);
    539                 return RTMsgErrorExitFailure("Invalid response file ('%s') encoding: %Rrc", &argv[i][1], vrc);
     539                return RTMsgErrorExitFailure(VBoxManage::tr("Invalid response file ('%s') encoding: %Rrc"), &argv[i][1], vrc);
    540540            }
    541541
    … …  
    545545            RTFileReadAllFree(pszResponseFile, cbResponseFile);
    546546            if (RT_FAILURE(vrc))
    547                 return RTMsgErrorExitFailure("Failed to parse response file '%s' (bourne shell style): %Rrc", &argv[i][1], vrc);
     547                return RTMsgErrorExitFailure(VBoxManage::tr("Failed to parse response file '%s' (bourne shell style): %Rrc"), &argv[i][1], vrc);
    548548
    549549            /* Construct new argv+argc with the response file arguments inserted. */
    … …  
    551551            papszNewArgv = (char **)RTMemAllocZ((cNewArgs + 2) * sizeof(papszNewArgv[0]));
    552552            if (!papszNewArgv)
    553                 return RTMsgErrorExitFailure("out of memory");
     553                return RTMsgErrorExitFailure(VBoxManage::tr("out of memory"));
    554554            memcpy(&papszNewArgv[0], &argv[0], sizeof(argv[0]) * (i + 1));
    555555            memcpy(&papszNewArgv[i + 1], papszResponseFileArgs, sizeof(argv[0]) * cResponseFileArgs);
    … …  
    595595        if (!strcmp(argv[iCmd], "commands"))
    596596        {
    597             RTPrintf("commands:\n");
     597            RTPrintf(VBoxManage::tr("commands:\n"));
    598598            for (unsigned i = 0; i < RT_ELEMENTS(g_aCommands); i++)
    599599                if (   i == 0  /* skip backwards compatibility entries */
    … …  
    604604            return RTEXITCODE_SUCCESS;
    605605        }
    606         return errorSyntax(USAGE_S_ALL, "Invalid command '%s'", argv[iCmd]);
     606        return errorSyntax(USAGE_S_ALL, VBoxManage::tr("Invalid command '%s'"), argv[iCmd]);
    607607    }
    608608
    … …  
    623623                com::GetVBoxUserHomeDirectory(szHome, sizeof(szHome));
    624624                return RTMsgErrorExit(RTEXITCODE_FAILURE,
    625                        "Failed to initialize COM because the global settings directory '%s' is not accessible!", szHome);
     625                       VBoxManage::tr("Failed to initialize COM because the global settings directory '%s' is not accessible!"), szHome);
    626626            }
    627627# endif
    628             return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to initialize COM! (hrc=%Rhrc)", hrc);
     628            return RTMsgErrorExit(RTEXITCODE_FAILURE, VBoxManage::tr("Failed to initialize COM! (hrc=%Rhrc)"), hrc);
    629629        }
    630630
    … …  
    673673            {
    674674                com::ErrorInfo info;
    675                 RTMsgError("Failed to create a session object!");
     675                RTMsgError(VBoxManage::tr("Failed to create a session object!"));
    676676                if (!info.isFullAvailable() && !info.isBasicAvailable())
    677677                    com::GluePrintRCMessage(hrc);
    … …  
    683683        {
    684684            com::ErrorInfo info;
    685             RTMsgError("Failed to create the VirtualBox object!");
     685            RTMsgError(VBoxManage::tr("Failed to create the VirtualBox object!"));
    686686            if (!info.isFullAvailable() && !info.isBasicAvailable())
    687687            {
    688688                com::GluePrintRCMessage(hrc);
    689                 RTMsgError("Most likely, the VirtualBox COM server is not running or failed to start.");
     689                RTMsgError(VBoxManage::tr("Most likely, the VirtualBox COM server is not running or failed to start."));
    690690            }
    691691            else

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManage.h

    r91432 r92372  
    4040#endif
    4141
     42#ifdef VBOX_WITH_VBOXMANAGE_NLS
     43# include "VirtualBoxTranslator.h"
     44#endif
     45
    4246
    4347////////////////////////////////////////////////////////////////////////////////
    … …  
    4650//
    4751////////////////////////////////////////////////////////////////////////////////
     52
     53#ifdef VBOX_WITH_VBOXMANAGE_NLS
     54# define DECLARE_TRANSLATION_CONTEXT(ctx) \
     55struct ctx \
     56{\
     57   static const char *tr(const char *pszSource, const char *pszComment = NULL, const size_t aNum = ~(size_t)0) \
     58   { \
     59       return VirtualBoxTranslator::translate(NULL, #ctx, pszSource, pszComment, aNum); \
     60   } \
     61}
     62#else
     63# define DECLARE_TRANSLATION_CONTEXT(ctx) \
     64struct ctx \
     65{\
     66   static const char *tr(const char *pszSource, const char *pszComment = NULL, const size_t aNum = ~(size_t)0) \
     67   { \
     68       NOREF(pszComment); \
     69       NOREF(aNum);       \
     70       return pszSource;  \
     71   } \
     72}
     73#endif
     74
    4875
    4976/** @name Syntax diagram category, i.e. the command.

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageAppliance.cpp

    r91204 r92372  
    6060#include "VBoxManage.h"
    6161using namespace com;
     62
     63DECLARE_TRANSLATION_CONTEXT(Appliance);
    6264
    6365
    … …  
    211213                if (enmApplType != LOCAL)
    212214                    return errorSyntax(USAGE_EXPORTAPPLIANCE,
    213                                        "Option \"%s\" can't be used together with \"--cloud\" option.",
     215                                       Appliance::tr("Option \"%s\" can't be used together with \"--cloud\" option."),
    214216                                       GetState.pDef->pszLong);
    215217                if (ValueUnion.u32 == (uint32_t)-1)
    216218                    return errorSyntax(USAGE_EXPORTAPPLIANCE,
    217                                        "Value of option \"%s\" is out of range.",
     219                                       Appliance::tr("Value of option \"%s\" is out of range."),
    218220                                       GetState.pDef->pszLong);
    219221
    … …  
    224226            case 'o':   // --ostype
    225227                if (enmApplType == NOT_SET)
    226                     return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys or --cloud option.", GetState.pDef->pszLong);
     228                    return errorSyntax(USAGE_EXPORTAPPLIANCE,
     229                                       Appliance::tr("Option \"%s\" requires preceding --vsys or --cloud option."),
     230                                       GetState.pDef->pszLong);
    227231                mapArgsMapsPerVsys[ulCurVsys]["ostype"] = ValueUnion.psz;
    228232                break;
    … …  
    230234            case 'V':   // --vmname
    231235                if (enmApplType == NOT_SET)
    232                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys or --cloud option.", GetState.pDef->pszLong);
     236                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     237                                       Appliance::tr("Option \"%s\" requires preceding --vsys or --cloud option."),
     238                                       GetState.pDef->pszLong);
    233239                mapArgsMapsPerVsys[ulCurVsys]["vmname"] = ValueUnion.psz;
    234240                break;
    … …  
    236242            case 'S':   // --settingsfile
    237243                if (enmApplType != LOCAL)
    238                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     244                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     245                                       Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     246                                       GetState.pDef->pszLong);
    239247                mapArgsMapsPerVsys[ulCurVsys]["settingsfile"] = ValueUnion.psz;
    240248                break;
    … …  
    242250            case 'p':   // --basefolder
    243251                if (enmApplType == NOT_SET)
    244                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys or --cloud option.", GetState.pDef->pszLong);
     252                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     253                                       Appliance::tr("Option \"%s\" requires preceding --vsys or --cloud option."),
     254                                       GetState.pDef->pszLong);
    245255                mapArgsMapsPerVsys[ulCurVsys]["basefolder"] = ValueUnion.psz;
    246256                break;
    … …  
    248258            case 'g':   // --group
    249259                if (enmApplType != LOCAL)
    250                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     260                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     261                                       Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     262                                       GetState.pDef->pszLong);
    251263                mapArgsMapsPerVsys[ulCurVsys]["group"] = ValueUnion.psz;
    252264                break;
    … …  
    254266            case 'd':   // --description
    255267                if (enmApplType == NOT_SET)
    256                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys or --cloud option.", GetState.pDef->pszLong);
     268                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     269                                       Appliance::tr("Option \"%s\" requires preceding --vsys or --cloud option."),
     270                                       GetState.pDef->pszLong);
    257271                mapArgsMapsPerVsys[ulCurVsys]["description"] = ValueUnion.psz;
    258272                break;
    … …  
    260274            case 'L':   // --eula
    261275                if (enmApplType != LOCAL)
    262                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     276                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     277                                       Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     278                                       GetState.pDef->pszLong);
    263279                mapArgsMapsPerVsys[ulCurVsys]["eula"] = ValueUnion.psz;
    264280                break;
    … …  
    266282            case 'm':   // --memory
    267283                if (enmApplType == NOT_SET)
    268                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys or --cloud option.", GetState.pDef->pszLong);
     284                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     285                                       Appliance::tr("Option \"%s\" requires preceding --vsys or --cloud option."),
     286                                       GetState.pDef->pszLong);
    269287                mapArgsMapsPerVsys[ulCurVsys]["memory"] = ValueUnion.psz;
    270288                break;
    … …  
    272290            case 'c':   // --cpus
    273291                if (enmApplType == NOT_SET)
    274                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys or --cloud option.", GetState.pDef->pszLong);
     292                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     293                                       Appliance::tr("Option \"%s\" requires preceding --vsys or --cloud option."),
     294                                       GetState.pDef->pszLong);
    275295                mapArgsMapsPerVsys[ulCurVsys]["cpus"] = ValueUnion.psz;
    276296                break;
    … …  
    278298            case 'u':   // --unit
    279299                if (enmApplType != LOCAL)
    280                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     300                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     301                                       Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     302                                       GetState.pDef->pszLong);
    281303                if (ValueUnion.u32 == (uint32_t)-1)
    282304                    return errorSyntax(USAGE_EXPORTAPPLIANCE,
    283                                        "Value of option \"%s\" is out of range.",
     305                                       Appliance::tr("Value of option \"%s\" is out of range."),
    284306                                       GetState.pDef->pszLong);
    285307
    … …  
    289311            case 'x':   // --ignore
    290312                if (enmApplType != LOCAL)
    291                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     313                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     314                                       Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     315                                       GetState.pDef->pszLong);
    292316                if (ulCurUnit == (uint32_t)-1)
    293                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit option.", GetState.pDef->pszLong);
     317                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     318                                       Appliance::tr("Option \"%s\" requires preceding --unit option."),
     319                                       GetState.pDef->pszLong);
    294320                mapIgnoresMapsPerVsys[ulCurVsys][ulCurUnit] = true;
    295321                break;
    … …  
    297323            case 'T':   // --scsitype
    298324                if (enmApplType != LOCAL)
    299                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     325                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     326                                       Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     327                                       GetState.pDef->pszLong);
    300328                if (ulCurUnit == (uint32_t)-1)
    301                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit option.", GetState.pDef->pszLong);
     329                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     330                                       Appliance::tr("Option \"%s\" requires preceding --unit option."),
     331                                       GetState.pDef->pszLong);
    302332                mapArgsMapsPerVsys[ulCurVsys][Utf8StrFmt("scsitype%u", ulCurUnit)] = ValueUnion.psz;
    303333                break;
    … …  
    305335            case 'C':   // --controller
    306336                if (enmApplType != LOCAL)
    307                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     337                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     338                                       Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     339                                       GetState.pDef->pszLong);
    308340                if (ulCurUnit == (uint32_t)-1)
    309                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit option.", GetState.pDef->pszLong);
     341                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     342                                       Appliance::tr("Option \"%s\" requires preceding --unit option."),
     343                                       GetState.pDef->pszLong);
    310344                mapArgsMapsPerVsys[ulCurVsys][Utf8StrFmt("controller%u", ulCurUnit)] = ValueUnion.psz;
    311345                break;
    … …  
    313347            case 'D':   // --disk
    314348                if (enmApplType != LOCAL)
    315                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     349                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     350                                       Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     351                                       GetState.pDef->pszLong);
    316352                if (ulCurUnit == (uint32_t)-1)
    317                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit option.", GetState.pDef->pszLong);
     353                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
     354                                       Appliance::tr("Option \"%s\" requires preceding --unit option."),
     355                                       GetState.pDef->pszLong);
    318356                mapArgsMapsPerVsys[ulCurVsys][Utf8StrFmt("disk%u", ulCurUnit)] = ValueUnion.psz;
    319357                break;
    … …  
    321359            case 'O':   // --options
    322360                if (RT_FAILURE(parseImportOptions(ValueUnion.psz, &options)))
    323                     return errorArgument("Invalid import options '%s'\n", ValueUnion.psz);
     361                    return errorArgument(Appliance::tr("Invalid import options '%s'\n"), ValueUnion.psz);
    324362                break;
    325363
    … …  
    331369                if (enmApplType != CLOUD)
    332370                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
    333                                        "Option \"%s\" can't be used together with \"--vsys\" option.",
     371                                       Appliance::tr("Option \"%s\" can't be used together with \"--vsys\" option."),
    334372                                       GetState.pDef->pszLong);
    335373
    … …  
    340378            case 'k':   // --cloudprofile
    341379                if (enmApplType != CLOUD)
    342                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     380                    return errorSyntax(USAGE_IMPORTAPPLIANCE, Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    343381                                       GetState.pDef->pszLong);
    344382                mapArgsMapsPerVsys[ulCurVsys]["cloudprofile"] = ValueUnion.psz;
    … …  
    347385            case 'l':   // --cloudinstanceid
    348386                if (enmApplType != CLOUD)
    349                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     387                    return errorSyntax(USAGE_IMPORTAPPLIANCE, Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    350388                                       GetState.pDef->pszLong);
    351389                mapArgsMapsPerVsys[ulCurVsys]["cloudinstanceid"] = ValueUnion.psz;
    … …  
    354392            case 'B':   // --cloudbucket
    355393                if (enmApplType != CLOUD)
    356                     return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     394                    return errorSyntax(USAGE_EXPORTAPPLIANCE, Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    357395                                       GetState.pDef->pszLong);
    358396                mapArgsMapsPerVsys[ulCurVsys]["cloudbucket"] = ValueUnion.psz;
    … …  
    363401                    strOvfFilename = ValueUnion.psz;
    364402                else
    365                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "Invalid parameter '%s'", ValueUnion.psz);
     403                    return errorSyntax(USAGE_IMPORTAPPLIANCE, Appliance::tr("Invalid parameter '%s'"), ValueUnion.psz);
    366404                break;
    367405
    … …  
    370408                {
    371409                    if (RT_C_IS_PRINT(c))
    372                         return errorSyntax(USAGE_IMPORTAPPLIANCE, "Invalid option -%c", c);
     410                        return errorSyntax(USAGE_IMPORTAPPLIANCE, Appliance::tr("Invalid option -%c"), c);
    373411                    else
    374                         return errorSyntax(USAGE_IMPORTAPPLIANCE, "Invalid option case %i", c);
     412                        return errorSyntax(USAGE_IMPORTAPPLIANCE, Appliance::tr("Invalid option case %i"), c);
    375413                }
    376414                else if (c == VERR_GETOPT_UNKNOWN_OPTION)
    377                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "unknown option: %s\n", ValueUnion.psz);
     415                    return errorSyntax(USAGE_IMPORTAPPLIANCE, Appliance::tr("unknown option: %s\n"), ValueUnion.psz);
    378416                else if (ValueUnion.pDef)
    379417                    return errorSyntax(USAGE_IMPORTAPPLIANCE, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
    380418                else
    381                     return errorSyntax(USAGE_IMPORTAPPLIANCE, "error: %Rrs", c);
     419                    return errorSyntax(USAGE_IMPORTAPPLIANCE, Appliance::tr("error: %Rrs"), c);
    382420        }
    383421    }
    … …  
    385423    /* Last check after parsing all arguments */
    386424    if (strOvfFilename.isEmpty())
    387         return errorSyntax(USAGE_IMPORTAPPLIANCE, "Not enough arguments for \"import\" command.");
     425        return errorSyntax(USAGE_IMPORTAPPLIANCE, Appliance::tr("Not enough arguments for \"import\" command."));
    388426
    389427    if (enmApplType == NOT_SET)
    … …  
    407445            catch (...)
    408446            {
    409                 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Not enough arguments for import from the Cloud.");
     447                return errorSyntax(USAGE_IMPORTAPPLIANCE, Appliance::tr("Not enough arguments for import from the Cloud."));
    410448            }
    411449
    … …  
    430468
    431469        rc = showProgress(progressRead);
    432         CHECK_PROGRESS_ERROR_RET(progressRead, ("Appliance read failed"), RTEXITCODE_FAILURE);
     470        CHECK_PROGRESS_ERROR_RET(progressRead, (Appliance::tr("Appliance read failed")), RTEXITCODE_FAILURE);
    433471
    434472        Bstr path; /* fetch the path, there is stuff like username/password removed if any */
    … …  
    442480            // call interpret(); this can yield both warnings and errors, so we need
    443481            // to tinker with the error info a bit
    444             RTStrmPrintf(g_pStdErr, "Interpreting %ls...\n", path.raw());
     482            RTStrmPrintf(g_pStdErr, Appliance::tr("Interpreting %ls...\n"), path.raw());
    445483            rc = pAppliance->Interpret();
    446484            com::ErrorInfoKeeper eik;
    … …  
    474512            if (retDisks.size() > 0)
    475513            {
    476                 RTPrintf("Disks:\n");
     514                RTPrintf(Appliance::tr("Disks:\n"));
    477515                for (unsigned i = 0; i < retDisks.size(); i++)
    478516                    RTPrintf("  %ls\n", retDisks[i]);
    … …  
    496534                if (ulVsys >= cVirtualSystemDescriptions)
    497535                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
    498                                        "Invalid index %RI32 with -vsys option; the OVF contains only %zu virtual system(s).",
     536                                       Appliance::tr("Invalid index %RI32 with -vsys option; the OVF contains only %zu virtual system(s)."),
    499537                                       ulVsys, cVirtualSystemDescriptions);
    500538            }
    … …  
    530568                                                 ComSafeArrayAsOutParam(aExtraConfigValues)));
    531569
    532                 RTPrintf("Virtual system %u:\n", i);
     570                RTPrintf(Appliance::tr("Virtual system %u:\n"), i);
    533571
    534572                // look up the corresponding command line options, if any
    … …  
    560598                            {
    561599                                bstrFinalValue = strOverride;
    562                                 RTPrintf("%2u: OS type specified with --ostype: \"%ls\"\n",
     600                                RTPrintf(Appliance::tr("%2u: OS type specified with --ostype: \"%ls\"\n"),
    563601                                        a, bstrFinalValue.raw());
    564602                            }
    565603                            else
    566                                 RTPrintf("%2u: Suggested OS type: \"%ls\""
    567                                         "\n    (change with \"--vsys %u --ostype <type>\"; use \"list ostypes\" to list all possible values)\n",
     604                                RTPrintf(Appliance::tr(
     605                                            "%2u: Suggested OS type: \"%ls\""
     606                                            "\n    (change with \"--vsys %u --ostype <type>\"; use \"list ostypes\" to list all possible values)\n"),
    568607                                        a, bstrFinalValue.raw(), i);
    569608                            break;
    … …  
    573612                            {
    574613                                bstrFinalValue = strOverride;
    575                                 RTPrintf("%2u: VM name specified with --vmname: \"%ls\"\n",
     614                                RTPrintf(Appliance::tr("%2u: VM name specified with --vmname: \"%ls\"\n"),
    576615                                        a, bstrFinalValue.raw());
    577616                            }
    578617                            else
    579                                 RTPrintf("%2u: Suggested VM name \"%ls\""
    580                                         "\n    (change with \"--vsys %u --vmname <name>\")\n",
     618                                RTPrintf(Appliance::tr(
     619                                            "%2u: Suggested VM name \"%ls\""
     620                                            "\n    (change with \"--vsys %u --vmname <name>\")\n"),
    581621                                        a, bstrFinalValue.raw(), i);
    582622                            break;
    583623
    584624                        case VirtualSystemDescriptionType_Product:
    585                             RTPrintf("%2u: Product (ignored): %ls\n",
     625                            RTPrintf(Appliance::tr("%2u: Product (ignored): %ls\n"),
    586626                                     a, aVBoxValues[a]);
    587627                            break;
    588628
    589629                        case VirtualSystemDescriptionType_ProductUrl:
    590                             RTPrintf("%2u: ProductUrl (ignored): %ls\n",
     630                            RTPrintf(Appliance::tr("%2u: ProductUrl (ignored): %ls\n"),
    591631                                     a, aVBoxValues[a]);
    592632                            break;
    593633
    594634                        case VirtualSystemDescriptionType_Vendor:
    595                             RTPrintf("%2u: Vendor (ignored): %ls\n",
     635                            RTPrintf(Appliance::tr("%2u: Vendor (ignored): %ls\n"),
    596636                                     a, aVBoxValues[a]);
    597637                            break;
    598638
    599639                        case VirtualSystemDescriptionType_VendorUrl:
    600                             RTPrintf("%2u: VendorUrl (ignored): %ls\n",
     640                            RTPrintf(Appliance::tr("%2u: VendorUrl (ignored): %ls\n"),
    601641                                     a, aVBoxValues[a]);
    602642                            break;
    603643
    604644                        case VirtualSystemDescriptionType_Version:
    605                             RTPrintf("%2u: Version (ignored): %ls\n",
     645                            RTPrintf(Appliance::tr("%2u: Version (ignored): %ls\n"),
    606646                                     a, aVBoxValues[a]);
    607647                            break;
    … …  
    611651                            {
    612652                                bstrFinalValue = strOverride;
    613                                 RTPrintf("%2u: Description specified with --description: \"%ls\"\n",
     653                                RTPrintf(Appliance::tr("%2u: Description specified with --description: \"%ls\"\n"),
    614654                                        a, bstrFinalValue.raw());
    615655                            }
    616656                            else
    617                                 RTPrintf("%2u: Description \"%ls\""
    618                                         "\n    (change with \"--vsys %u --description <desc>\")\n",
     657                                RTPrintf(Appliance::tr(
     658                                            "%2u: Description \"%ls\""
     659                                            "\n    (change with \"--vsys %u --description <desc>\")\n"),
    619660                                        a, bstrFinalValue.raw(), i);
    620661                            break;
    … …  
    626667                                if (strOverride == "show")
    627668                                {
    628                                     RTPrintf("%2u: End-user license agreement"
    629                                              "\n    (accept with \"--vsys %u --eula accept\"):"
    630                                              "\n\n%ls\n\n",
     669                                    RTPrintf(Appliance::tr(
     670                                                "%2u: End-user license agreement"
     671                                                "\n    (accept with \"--vsys %u --eula accept\"):"
     672                                                "\n\n%ls\n\n"),
    631673                                             a, i, bstrFinalValue.raw());
    632674                                }
    633675                                else if (strOverride == "accept")
    634676                                {
    635                                     RTPrintf("%2u: End-user license agreement (accepted)\n",
     677                                    RTPrintf(Appliance::tr("%2u: End-user license agreement (accepted)\n"),
    636678                                             a);
    637679                                    --cLicensesInTheWay;
    … …  
    639681                                else
    640682                                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
    641                                                        "Argument to --eula must be either \"show\" or \"accept\".");
     683                                                       Appliance::tr("Argument to --eula must be either \"show\" or \"accept\"."));
    642684                            }
    643685                            else
    644                                 RTPrintf("%2u: End-user license agreement"
    645                                         "\n    (display with \"--vsys %u --eula show\";"
    646                                         "\n    accept with \"--vsys %u --eula accept\")\n",
     686                                RTPrintf(Appliance::tr(
     687                                            "%2u: End-user license agreement"
     688                                            "\n    (display with \"--vsys %u --eula show\";"
     689                                            "\n    accept with \"--vsys %u --eula accept\")\n"),
    647690                                        a, i, i);
    648691                            break;
    … …  
    658701                                {
    659702                                    bstrFinalValue = strOverride;
    660                                     RTPrintf("%2u: No. of CPUs specified with --cpus: %ls\n",
     703                                    RTPrintf(Appliance::tr("%2u: No. of CPUs specified with --cpus: %ls\n"),
    661704                                             a, bstrFinalValue.raw());
    662705                                }
    663706                                else
    664707                                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
    665                                                        "Argument to --cpus option must be a number greater than %d and less than %d.",
     708                                                       Appliance::tr("Argument to --cpus option must be a number greater than %d and less than %d."),
    666709                                                       VMM_MIN_CPU_COUNT - 1, VMM_MAX_CPU_COUNT + 1);
    667710                            }
    668711                            else
    669                                 RTPrintf("%2u: Number of CPUs: %ls\n    (change with \"--vsys %u --cpus <n>\")\n",
     712                                RTPrintf(Appliance::tr("%2u: Number of CPUs: %ls\n    (change with \"--vsys %u --cpus <n>\")\n"),
    670713                                         a, bstrFinalValue.raw(), i);
    671714                            break;
    … …  
    679722                                {
    680723                                    bstrFinalValue = strOverride;
    681                                     RTPrintf("%2u: Guest memory specified with --memory: %ls MB\n",
     724                                    RTPrintf(Appliance::tr("%2u: Guest memory specified with --memory: %ls MB\n"),
    682725                                             a, bstrFinalValue.raw());
    683726                                }
    684727                                else
    685728                                    return errorSyntax(USAGE_IMPORTAPPLIANCE,
    686                                                        "Argument to --memory option must be a non-negative number.");
     729                                                       Appliance::tr("Argument to --memory option must be a non-negative number."));
    687730                            }
    688731                            else
    689                                 RTPrintf("%2u: Guest memory: %ls MB\n    (change with \"--vsys %u --memory <MB>\")\n",
     732                                RTPrintf(Appliance::tr("%2u: Guest memory: %ls MB\n    (change with \"--vsys %u --memory <MB>\")\n"),
    690733                                         a, bstrFinalValue.raw(), i);
    691734                            break;
    … …  
    695738                            if (fIgnoreThis)
    696739                            {
    697                                 RTPrintf("%2u: IDE controller, type %ls -- disabled\n",
     740                                RTPrintf(Appliance::tr("%2u: IDE controller, type %ls -- disabled\n"),
    698741                                         a,
    699742                                         aVBoxValues[a]);
    … …  
    701744                            }
    702745                            else
    703                                 RTPrintf("%2u: IDE controller, type %ls"
    704                                          "\n    (disable with \"--vsys %u --unit %u --ignore\")\n",
     746                                RTPrintf(Appliance::tr(
     747                                            "%2u: IDE controller, type %ls"
     748                                            "\n    (disable with \"--vsys %u --unit %u --ignore\")\n"),
    705749                                         a,
    706750                                         aVBoxValues[a],
    … …  
    711755                            if (fIgnoreThis)
    712756                            {
    713                                 RTPrintf("%2u: SATA controller, type %ls -- disabled\n",
     757                                RTPrintf(Appliance::tr("%2u: SATA controller, type %ls -- disabled\n"),
    714758                                         a,
    715759                                         aVBoxValues[a]);
    … …  
    717761                            }
    718762                            else
    719                                 RTPrintf("%2u: SATA controller, type %ls"
    720                                         "\n    (disable with \"--vsys %u --unit %u --ignore\")\n",
     763                                RTPrintf(Appliance::tr(
     764                                            "%2u: SATA controller, type %ls"
     765                                            "\n    (disable with \"--vsys %u --unit %u --ignore\")\n"),
    721766                                        a,
    722767                                        aVBoxValues[a],
    … …  
    727772                            if (fIgnoreThis)
    728773                            {
    729                                 RTPrintf("%2u: SAS controller, type %ls -- disabled\n",
     774                                RTPrintf(Appliance::tr("%2u: SAS controller, type %ls -- disabled\n"),
    730775                                         a,
    731776                                         aVBoxValues[a]);
    … …  
    733778                            }
    734779                            else
    735                                 RTPrintf("%2u: SAS controller, type %ls"
    736                                         "\n    (disable with \"--vsys %u --unit %u --ignore\")\n",
     780                                RTPrintf(Appliance::tr(
     781                                            "%2u: SAS controller, type %ls"
     782                                            "\n    (disable with \"--vsys %u --unit %u --ignore\")\n"),
    737783                                        a,
    738784                                        aVBoxValues[a],
    … …  
    743789                            if (fIgnoreThis)
    744790                            {
    745                                 RTPrintf("%2u: SCSI controller, type %ls -- disabled\n",
     791                                RTPrintf(Appliance::tr("%2u: SCSI controller, type %ls -- disabled\n"),
    746792                                         a,
    747793                                         aVBoxValues[a]);
    … …  
    754800                                {
    755801                                    bstrFinalValue = strOverride;
    756                                     RTPrintf("%2u: SCSI controller, type set with --unit %u --scsitype: \"%ls\"\n",
     802                                    RTPrintf(Appliance::tr("%2u: SCSI controller, type set with --unit %u --scsitype: \"%ls\"\n"),
    757803                                            a,
    758804                                            a,
    … …  
    760806                                }
    761807                                else
    762                                     RTPrintf("%2u: SCSI controller, type %ls"
    763                                             "\n    (change with \"--vsys %u --unit %u --scsitype {BusLogic|LsiLogic}\";"
    764                                             "\n    disable with \"--vsys %u --unit %u --ignore\")\n",
     808                                    RTPrintf(Appliance::tr(
     809                                                "%2u: SCSI controller, type %ls"
     810                                                "\n    (change with \"--vsys %u --unit %u --scsitype {BusLogic|LsiLogic}\";"
     811                                                "\n    disable with \"--vsys %u --unit %u --ignore\")\n"),
    765812                                            a,
    766813                                            aVBoxValues[a],
    … …  
    772819                            if (fIgnoreThis)
    773820                            {
    774                                 RTPrintf("%2u: VirtioSCSI controller, type %ls -- disabled\n",
     821                                RTPrintf(Appliance::tr("%2u: VirtioSCSI controller, type %ls -- disabled\n"),
    775822                                         a,
    776823                                         aVBoxValues[a]);
    … …  
    778825                            }
    779826                            else
    780                                 RTPrintf("%2u: VirtioSCSI controller, type %ls"
    781                                         "\n    (disable with \"--vsys %u --unit %u --ignore\")\n",
     827                                RTPrintf(Appliance::tr(
     828                                            "%2u: VirtioSCSI controller, type %ls"
     829                                            "\n    (disable with \"--vsys %u --unit %u --ignore\")\n"),
    782830                                        a,
    783831                                        aVBoxValues[a],
    … …  
    788836                            if (fIgnoreThis)
    789837                            {
    790                                 RTPrintf("%2u: Hard disk image: source image=%ls -- disabled\n",
     838                                RTPrintf(Appliance::tr("%2u: Hard disk image: source image=%ls -- disabled\n"),
    791839                                         a,
    792840                                         aOvfValues[a]);
    … …  
    824872                                        //print some error about incompatible command-line arguments
    825873                                        return errorSyntax(USAGE_IMPORTAPPLIANCE,
    826                                                            "Option --ImportToVDI shall not be used together with "
    827                                                            "manually set target path.");
     874                                                           Appliance::tr("Option --ImportToVDI shall not be used together with "
     875                                                                         "manually set target path."));
    828876
    829877                                    }
    830878
    831                                     RTPrintf("%2u: Hard disk image: source image=%ls, target path=%ls, %ls\n",
     879                                    RTPrintf(Appliance::tr("%2u: Hard disk image: source image=%ls, target path=%ls, %ls\n"),
    832880                                            a,
    833881                                            aOvfValues[a],
    … …  
    847895                                    Bstr bstrExtraConfigValue = strOverride;
    848896                                    bstrExtraConfigValue.detachTo(&aExtraConfigValues[a]);
    849                                     RTPrintf("%2u: Hard disk image: source image=%ls, target path=%ls, %ls\n",
     897                                    RTPrintf(Appliance::tr("%2u: Hard disk image: source image=%ls, target path=%ls, %ls\n"),
    850898                                            a,
    851899                                            aOvfValues[a],
    … …  
    933981                                    bstrFinalValue = strOverride;
    934982
    935                                     RTPrintf("%2u: Hard disk image: source image=%ls, target path=%ls, %ls"
    936                                             "\n    (change target path with \"--vsys %u --unit %u --disk path\";"
    937                                             "\n    disable with \"--vsys %u --unit %u --ignore\")\n",
     983                                    RTPrintf(Appliance::tr(
     984                                                "%2u: Hard disk image: source image=%ls, target path=%ls, %ls"
     985                                                "\n    (change target path with \"--vsys %u --unit %u --disk path\";"
     986                                                "\n    disable with \"--vsys %u --unit %u --ignore\")\n"),
    938987                                            a,
    939988                                            aOvfValues[a],
    … …  
    948997                            if (fIgnoreThis)
    949998                            {
    950                                 RTPrintf("%2u: CD-ROM -- disabled\n",
     999                                RTPrintf(Appliance::tr("%2u: CD-ROM -- disabled\n"),
    9511000                                         a);
    9521001                                aEnabled[a] = false;
    9531002                            }
    9541003                            else
    955                                 RTPrintf("%2u: CD-ROM"
    956                                         "\n    (disable with \"--vsys %u --unit %u --ignore\")\n",
     1004                                RTPrintf(Appliance::tr(
     1005                                            "%2u: CD-ROM"
     1006                                            "\n    (disable with \"--vsys %u --unit %u --ignore\")\n"),
    9571007                                        a, i, a);
    9581008                            break;
    … …  
    9611011                            if (fIgnoreThis)
    9621012                            {
    963                                 RTPrintf("%2u: Floppy -- disabled\n",
     1013                                RTPrintf(Appliance::tr("%2u: Floppy -- disabled\n"),
    9641014                                         a);
    9651015                                aEnabled[a] = false;
    9661016                            }
    9671017                            else
    968                                 RTPrintf("%2u: Floppy"
    969                                         "\n    (disable with \"--vsys %u --unit %u --ignore\")\n",
     1018                                RTPrintf(Appliance::tr(
     1019                                            "%2u: Floppy"
     1020                                            "\n    (disable with \"--vsys %u --unit %u --ignore\")\n"),
    9701021                                        a, i, a);
    9711022                            break;
    9721023
    9731024                        case VirtualSystemDescriptionType_NetworkAdapter:
    974                             RTPrintf("%2u: Network adapter: orig %ls, config %ls, extra %ls\n",   /// @todo implement once we have a plan for the back-end
     1025                            RTPrintf(Appliance::tr("%2u: Network adapter: orig %ls, config %ls, extra %ls\n"),   /// @todo implement once we have a plan for the back-end
    9751026                                     a,
    9761027                                     aOvfValues[a],
    … …  
    9821033                            if (fIgnoreThis)
    9831034                            {
    984                                 RTPrintf("%2u: USB controller -- disabled\n",
     1035                                RTPrintf(Appliance::tr("%2u: USB controller -- disabled\n"),
    9851036                                         a);
    9861037                                aEnabled[a] = false;
    9871038                            }
    9881039                            else
    989                                 RTPrintf("%2u: USB controller"
    990                                         "\n    (disable with \"--vsys %u --unit %u --ignore\")\n",
     1040                                RTPrintf(Appliance::tr(
     1041                                            "%2u: USB controller"
     1042                                            "\n    (disable with \"--vsys %u --unit %u --ignore\")\n"),
    9911043                                        a, i, a);
    9921044                            break;
    … …  
    9951047                            if (fIgnoreThis)
    9961048                            {
    997                                RTPrintf("%2u: Sound card \"%ls\" -- disabled\n",
     1049                               RTPrintf(Appliance::tr("%2u: Sound card \"%ls\" -- disabled\n"),
    9981050                                         a,
    9991051                                         aOvfValues[a]);
    … …  
    10011053                            }
    10021054                            else
    1003                                 RTPrintf("%2u: Sound card (appliance expects \"%ls\", can change on import)"
    1004                                         "\n    (disable with \"--vsys %u --unit %u --ignore\")\n",
     1055                                RTPrintf(Appliance::tr(
     1056                                            "%2u: Sound card (appliance expects \"%ls\", can change on import)"
     1057                                            "\n    (disable with \"--vsys %u --unit %u --ignore\")\n"),
    10051058                                        a,
    10061059                                        aOvfValues[a],
    … …  
    10131066                            {
    10141067                                bstrFinalValue = strOverride;
    1015                                 RTPrintf("%2u: VM settings file name specified with --settingsfile: \"%ls\"\n",
     1068                                RTPrintf(Appliance::tr("%2u: VM settings file name specified with --settingsfile: \"%ls\"\n"),
    10161069                                        a, bstrFinalValue.raw());
    10171070                            }
    10181071                            else
    1019                                 RTPrintf("%2u: Suggested VM settings file name \"%ls\""
    1020                                         "\n    (change with \"--vsys %u --settingsfile <filename>\")\n",
     1072                                RTPrintf(Appliance::tr(
     1073                                            "%2u: Suggested VM settings file name \"%ls\""
     1074                                            "\n    (change with \"--vsys %u --settingsfile <filename>\")\n"),
    10211075                                        a, bstrFinalValue.raw(), i);
    10221076                            break;
    … …  
    10261080                            {
    10271081                                bstrFinalValue = strOverride;
    1028                                 RTPrintf("%2u: VM base folder specified with --basefolder: \"%ls\"\n",
     1082                                RTPrintf(Appliance::tr("%2u: VM base folder specified with --basefolder: \"%ls\"\n"),
    10291083                                        a, bstrFinalValue.raw());
    10301084                            }
    10311085                            else
    1032                                 RTPrintf("%2u: Suggested VM base folder \"%ls\""
    1033                                         "\n    (change with \"--vsys %u --basefolder <path>\")\n",
     1086                                RTPrintf(Appliance::tr(
     1087                                            "%2u: Suggested VM base folder \"%ls\""
     1088                                            "\n    (change with \"--vsys %u --basefolder <path>\")\n"),
    10341089                                        a, bstrFinalValue.raw(), i);
    10351090                            break;
    … …  
    10391094                            {
    10401095                                bstrFinalValue = strOverride;
    1041                                 RTPrintf("%2u: VM group specified with --group: \"%ls\"\n",
     1096                                RTPrintf(Appliance::tr("%2u: VM group specified with --group: \"%ls\"\n"),
    10421097                                        a, bstrFinalValue.raw());
    10431098                            }
    10441099                            else
    1045                                 RTPrintf("%2u: Suggested VM group \"%ls\""
    1046                                         "\n    (change with \"--vsys %u --group <group>\")\n",
     1100                                RTPrintf(Appliance::tr(
     1101                                            "%2u: Suggested VM group \"%ls\""
     1102                                            "\n    (change with \"--vsys %u --group <group>\")\n"),
    10471103                                        a, bstrFinalValue.raw(), i);
    10481104                            break;
    10491105
    10501106                        case VirtualSystemDescriptionType_CloudInstanceShape:
    1051                             RTPrintf("%2u: Suggested cloud shape \"%ls\"\n",
     1107                            RTPrintf(Appliance::tr("%2u: Suggested cloud shape \"%ls\"\n"),
    10521108                                    a, bstrFinalValue.raw());
    10531109                            break;
    … …  
    10571113                            {
    10581114                                bstrFinalValue = strOverride;
    1059                                 RTPrintf("%2u: Cloud bucket id specified with --cloudbucket: \"%ls\"\n",
     1115                                RTPrintf(Appliance::tr("%2u: Cloud bucket id specified with --cloudbucket: \"%ls\"\n"),
    10601116                                        a, bstrFinalValue.raw());
    10611117                            }
    10621118                            else
    1063                                 RTPrintf("%2u: Suggested cloud bucket id \"%ls\""
    1064                                         "\n    (change with \"--cloud %u --cloudbucket <id>\")\n",
     1119                                RTPrintf(Appliance::tr(
     1120                                            "%2u: Suggested cloud bucket id \"%ls\""
     1121                                            "\n    (change with \"--cloud %u --cloudbucket <id>\")\n"),
    10651122                                        a, bstrFinalValue.raw(), i);
    10661123                            break;
    … …  
    10701127                            {
    10711128                                bstrFinalValue = strOverride;
    1072                                 RTPrintf("%2u: Cloud profile name specified with --cloudprofile: \"%ls\"\n",
     1129                                RTPrintf(Appliance::tr("%2u: Cloud profile name specified with --cloudprofile: \"%ls\"\n"),
    10731130                                        a, bstrFinalValue.raw());
    10741131                            }
    10751132                            else
    1076                                 RTPrintf("%2u: Suggested cloud profile name \"%ls\""
    1077                                         "\n    (change with \"--cloud %u --cloudprofile <id>\")\n",
     1133                                RTPrintf(Appliance::tr(
     1134                                            "%2u: Suggested cloud profile name \"%ls\""
     1135                                            "\n    (change with \"--cloud %u --cloudprofile <id>\")\n"),
    10781136                                        a, bstrFinalValue.raw(), i);
    10791137                            break;
    … …  
    10831141                            {
    10841142                                bstrFinalValue = strOverride;
    1085                                 RTPrintf("%2u: Cloud instance id specified with --cloudinstanceid: \"%ls\"\n",
     1143                                RTPrintf(Appliance::tr("%2u: Cloud instance id specified with --cloudinstanceid: \"%ls\"\n"),
    10861144                                        a, bstrFinalValue.raw());
    10871145                            }
    10881146                            else
    1089                                 RTPrintf("%2u: Suggested cloud instance id \"%ls\""
    1090                                         "\n    (change with \"--cloud %u --cloudinstanceid <id>\")\n",
     1147                                RTPrintf(Appliance::tr(
     1148                                            "%2u: Suggested cloud instance id \"%ls\""
     1149                                            "\n    (change with \"--cloud %u --cloudinstanceid <id>\")\n"),
    10911150                                        a, bstrFinalValue.raw(), i);
    10921151                            break;
    10931152
    10941153                        case VirtualSystemDescriptionType_CloudImageId:
    1095                             RTPrintf("%2u: Suggested cloud base image id \"%ls\"\n",
     1154                            RTPrintf(Appliance::tr("%2u: Suggested cloud base image id \"%ls\"\n"),
    10961155                                    a, bstrFinalValue.raw());
    10971156                            break;
    … …  
    11391198
    11401199            if (cLicensesInTheWay == 1)
    1141                 RTMsgError("Cannot import until the license agreement listed above is accepted.");
     1200                RTMsgError(Appliance::tr("Cannot import until the license agreement listed above is accepted."));
    11421201            else if (cLicensesInTheWay > 1)
    1143                 RTMsgError("Cannot import until the %c license agreements listed above are accepted.", cLicensesInTheWay);
     1202                RTMsgError(Appliance::tr("Cannot import until the %c license agreements listed above are accepted."),
     1203                           cLicensesInTheWay);
    11441204
    11451205            if (!cLicensesInTheWay && fExecute)
    … …  
    11511211
    11521212                rc = showProgress(progress);
    1153                 CHECK_PROGRESS_ERROR_RET(progress, ("Appliance import failed"), RTEXITCODE_FAILURE);
     1213                CHECK_PROGRESS_ERROR_RET(progress, (Appliance::tr("Appliance import failed")), RTEXITCODE_FAILURE);
    11541214
    11551215                if (SUCCEEDED(rc))
    1156                     RTPrintf("Successfully imported the appliance.\n");
     1216                    RTPrintf(Appliance::tr("Successfully imported the appliance.\n"));
    11571217            }
    11581218        } // end if (aVirtualSystemDescriptions.size() > 0)
    … …  
    12711331                case 'o':   // --output
    12721332                    if (strOutputFile.length())
    1273                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "You can only specify --output once.");
     1333                        return errorSyntax(USAGE_EXPORTAPPLIANCE, Appliance::tr("You can only specify --output once."));
    12741334                    else
    12751335                        strOutputFile = ValueUnion.psz;
    … …  
    13061366                    if (enmApplType != LOCAL)
    13071367                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
    1308                                            "Option \"%s\" can't be used together with \"--cloud\" option.",
     1368                                           Appliance::tr("Option \"%s\" can't be used together with \"--cloud\" option."),
    13091369                                           GetState.pDef->pszLong);
    13101370                    if (ValueUnion.u32 == (uint32_t)-1)
    13111371                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
    1312                                            "Value of option \"%s\" is out of range.",
     1372                                           Appliance::tr("Value of option \"%s\" is out of range."),
    13131373                                           GetState.pDef->pszLong);
    13141374
    … …  
    13181378                case 'V':   // --vmname
    13191379                    if (enmApplType == NOT_SET)
    1320                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys or --cloud option.",
     1380                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1381                                           Appliance::tr("Option \"%s\" requires preceding --vsys or --cloud option."),
    13211382                                           GetState.pDef->pszLong);
    13221383                    mapArgsMapsPerVsys[ulCurVsys]["vmname"] = ValueUnion.psz;
    … …  
    13251386                case 'p':   // --product
    13261387                    if (enmApplType != LOCAL)
    1327                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     1388                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1389                                           Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     1390                                           GetState.pDef->pszLong);
    13281391                    mapArgsMapsPerVsys[ulCurVsys]["product"] = ValueUnion.psz;
    13291392                    break;
    … …  
    13311394                case 'P':   // --producturl
    13321395                    if (enmApplType != LOCAL)
    1333                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     1396                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1397                                           Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     1398                                           GetState.pDef->pszLong);
    13341399                    mapArgsMapsPerVsys[ulCurVsys]["producturl"] = ValueUnion.psz;
    13351400                    break;
    … …  
    13371402                case 'n':   // --vendor
    13381403                    if (enmApplType != LOCAL)
    1339                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     1404                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1405                                           Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     1406                                           GetState.pDef->pszLong);
    13401407                    mapArgsMapsPerVsys[ulCurVsys]["vendor"] = ValueUnion.psz;
    13411408                    break;
    … …  
    13431410                case 'N':   // --vendorurl
    13441411                    if (enmApplType != LOCAL)
    1345                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     1412                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1413                                           Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     1414                                           GetState.pDef->pszLong);
    13461415                    mapArgsMapsPerVsys[ulCurVsys]["vendorurl"] = ValueUnion.psz;
    13471416                    break;
    … …  
    13491418                case 'v':   // --version
    13501419                    if (enmApplType != LOCAL)
    1351                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     1420                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1421                                           Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     1422                                           GetState.pDef->pszLong);
    13521423                    mapArgsMapsPerVsys[ulCurVsys]["version"] = ValueUnion.psz;
    13531424                    break;
    … …  
    13551426                case 'd':   // --description
    13561427                    if (enmApplType != LOCAL)
    1357                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     1428                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1429                                           Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     1430                                           GetState.pDef->pszLong);
    13581431                    mapArgsMapsPerVsys[ulCurVsys]["description"] = ValueUnion.psz;
    13591432                    break;
    … …  
    13611434                case 'e':   // --eula
    13621435                    if (enmApplType != LOCAL)
    1363                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     1436                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1437                                           Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     1438                                           GetState.pDef->pszLong);
    13641439                    mapArgsMapsPerVsys[ulCurVsys]["eula"] = ValueUnion.psz;
    13651440                    break;
    … …  
    13671442                case 'E':   // --eulafile
    13681443                    if (enmApplType != LOCAL)
    1369                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys option.", GetState.pDef->pszLong);
     1444                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1445                                           Appliance::tr("Option \"%s\" requires preceding --vsys option."),
     1446                                           GetState.pDef->pszLong);
    13701447                    mapArgsMapsPerVsys[ulCurVsys]["eulafile"] = ValueUnion.psz;
    13711448                    break;
    … …  
    13731450                case 'O':   // --options
    13741451                    if (RT_FAILURE(parseExportOptions(ValueUnion.psz, &options)))
    1375                         return errorArgument("Invalid export options '%s'\n", ValueUnion.psz);
     1452                        return errorArgument(Appliance::tr("Invalid export options '%s'\n"), ValueUnion.psz);
    13761453                    break;
    13771454
    … …  
    13831460                    if (enmApplType != CLOUD)
    13841461                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
    1385                                            "Option \"%s\" can't be used together with \"--vsys\" option.",
     1462                                           Appliance::tr("Option \"%s\" can't be used together with \"--vsys\" option."),
    13861463                                           GetState.pDef->pszLong);
    13871464                    if (ValueUnion.u32 == (uint32_t)-1)
    13881465                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
    1389                                            "Value of option \"%s\" is out of range.",
     1466                                           Appliance::tr("Value of option \"%s\" is out of range."),
    13901467                                           GetState.pDef->pszLong);
    13911468
    … …  
    13961473                case 'S':   // --cloudshape
    13971474                    if (enmApplType != CLOUD)
    1398                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     1475                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1476                                           Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    13991477                                           GetState.pDef->pszLong);
    14001478                    mapArgsMapsPerVsys[ulCurVsys]["cloudshape"] = ValueUnion.psz;
    … …  
    14031481                case 'D':   // --clouddomain
    14041482                    if (enmApplType != CLOUD)
    1405                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     1483                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1484                                           Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    14061485                                           GetState.pDef->pszLong);
    14071486                    mapArgsMapsPerVsys[ulCurVsys]["clouddomain"] = ValueUnion.psz;
    … …  
    14101489                case 'R':   // --clouddisksize
    14111490                    if (enmApplType != CLOUD)
    1412                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     1491                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1492                                           Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    14131493                                           GetState.pDef->pszLong);
    14141494                    mapArgsMapsPerVsys[ulCurVsys]["clouddisksize"] = ValueUnion.psz;
    … …  
    14171497                case 'B':   // --cloudbucket
    14181498                    if (enmApplType != CLOUD)
    1419                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     1499                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1500                                           Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    14201501                                           GetState.pDef->pszLong);
    14211502                    mapArgsMapsPerVsys[ulCurVsys]["cloudbucket"] = ValueUnion.psz;
    … …  
    14241505                case 'Q':   // --cloudocivcn
    14251506                    if (enmApplType != CLOUD)
    1426                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     1507                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1508                                           Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    14271509                                           GetState.pDef->pszLong);
    14281510                    mapArgsMapsPerVsys[ulCurVsys]["cloudocivcn"] = ValueUnion.psz;
    … …  
    14311513                case 'A':   // --cloudpublicip
    14321514                    if (enmApplType != CLOUD)
    1433                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     1515                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1516                                           Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    14341517                                           GetState.pDef->pszLong);
    14351518                    mapArgsMapsPerVsys[ulCurVsys]["cloudpublicip"] = ValueUnion.psz;
    … …  
    14381521                case 'i': /* --cloudprivateip */
    14391522                    if (enmApplType != CLOUD)
    1440                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     1523                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1524                                           Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    14411525                                           GetState.pDef->pszLong);
    14421526                    mapArgsMapsPerVsys[ulCurVsys]["cloudprivateip"] = ValueUnion.psz;
    … …  
    14451529                case 'F':   // --cloudprofile
    14461530                    if (enmApplType != CLOUD)
    1447                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     1531                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1532                                           Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    14481533                                           GetState.pDef->pszLong);
    14491534                    mapArgsMapsPerVsys[ulCurVsys]["cloudprofile"] = ValueUnion.psz;
    … …  
    14521537                case 'T':   // --cloudocisubnet
    14531538                    if (enmApplType != CLOUD)
    1454                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     1539                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1540                                           Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    14551541                                           GetState.pDef->pszLong);
    14561542                    mapArgsMapsPerVsys[ulCurVsys]["cloudocisubnet"] = ValueUnion.psz;
    … …  
    14591545                case 'K':   // --cloudkeepobject
    14601546                    if (enmApplType != CLOUD)
    1461                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     1547                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1548                                           Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    14621549                                           GetState.pDef->pszLong);
    14631550                    mapArgsMapsPerVsys[ulCurVsys]["cloudkeepobject"] = ValueUnion.psz;
    … …  
    14661553                case 'L':   // --cloudlaunchinstance
    14671554                    if (enmApplType != CLOUD)
    1468                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     1555                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1556                                           Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    14691557                                           GetState.pDef->pszLong);
    14701558                    mapArgsMapsPerVsys[ulCurVsys]["cloudlaunchinstance"] = ValueUnion.psz;
    … …  
    14731561                case 'M': /* --cloudlaunchmode */
    14741562                    if (enmApplType != CLOUD)
    1475                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     1563                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1564                                           Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    14761565                                           GetState.pDef->pszLong);
    14771566                    mapArgsMapsPerVsys[ulCurVsys]["cloudlaunchmode"] = ValueUnion.psz;
    … …  
    14801569                case 'I':   // --cloudinitscriptpath
    14811570                    if (enmApplType != CLOUD)
    1482                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud option.",
     1571                        return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1572                                           Appliance::tr("Option \"%s\" requires preceding --cloud option."),
    14831573                                           GetState.pDef->pszLong);
    14841574                    mapArgsMapsPerVsys[ulCurVsys]["cloudinitscriptpath"] = ValueUnion.psz;
    … …  
    15011591                    {
    15021592                        if (RT_C_IS_GRAPH(c))
    1503                             return errorSyntax(USAGE_EXPORTAPPLIANCE, "unhandled option: -%c", c);
     1593                            return errorSyntax(USAGE_EXPORTAPPLIANCE, Appliance::tr("unhandled option: -%c"), c);
    15041594                        else
    1505                             return errorSyntax(USAGE_EXPORTAPPLIANCE, "unhandled option: %i", c);
     1595                            return errorSyntax(USAGE_EXPORTAPPLIANCE, Appliance::tr("unhandled option: %i"), c);
    15061596                    }
    15071597                    else if (c == VERR_GETOPT_UNKNOWN_OPTION)
    1508                         return errorSyntax(USAGE_EXPORTAPPLIANCE, "unknown option: %s", ValueUnion.psz);
     1598                        return errorSyntax(USAGE_EXPORTAPPLIANCE, Appliance::tr("unknown option: %s"), ValueUnion.psz);
    15091599                    else if (ValueUnion.pDef)
    15101600                        return errorSyntax(USAGE_EXPORTAPPLIANCE, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
    … …  
    15211611
    15221612        if (llMachines.empty())
    1523             return errorSyntax(USAGE_EXPORTAPPLIANCE, "At least one machine must be specified with the export command.");
     1613            return errorSyntax(USAGE_EXPORTAPPLIANCE,
     1614                               Appliance::tr("At least one machine must be specified with the export command."));
    15241615
    15251616        /* Last check after parsing all arguments */
    15261617        if (strOutputFile.isEmpty())
    1527             return errorSyntax(USAGE_EXPORTAPPLIANCE, "Missing --output argument with export command.");
     1618            return errorSyntax(USAGE_EXPORTAPPLIANCE, Appliance::tr("Missing --output argument with export command."));
    15281619
    15291620        if (enmApplType == NOT_SET)
    … …  
    15401631            if (ulVsys >= llMachines.size())
    15411632                return errorSyntax(USAGE_EXPORTAPPLIANCE,
    1542                                    "Invalid index %RI32 with -vsys option; you specified only %zu virtual system(s).",
     1633                                   Appliance::tr("Invalid index %RI32 with -vsys option; you specified only %zu virtual system(s)."),
    15431634                                   ulVsys, llMachines.size());
    15441635        }
    … …  
    16281719                        else
    16291720                        {
    1630                             RTMsgError("Cannot read license file \"%s\" which should be included in the virtual system %u.",
     1721                            RTMsgError(Appliance::tr("Cannot read license file \"%s\" which should be included in the virtual system %u."),
    16311722                                       itD->second.c_str(), i);
    16321723                            return RTEXITCODE_FAILURE;
    … …  
    16911782        {
    16921783            com::SafeArray<BSTR> aPasswords(aIdentifiers.size());
    1693             RTPrintf("Enter the passwords for the following identifiers to export the apppliance:\n");
     1784            RTPrintf(Appliance::tr("Enter the passwords for the following identifiers to export the apppliance:\n"));
    16941785            for (unsigned idxId = 0; idxId < aIdentifiers.size(); idxId++)
    16951786            {
    … …  
    16981789                Bstr bstrId = aIdentifiers[idxId];
    16991790
    1700                 RTEXITCODE rcExit = readPasswordFromConsole(&strPassword, "Password ID %s:", Utf8Str(bstrId).c_str());
     1791                RTEXITCODE rcExit = readPasswordFromConsole(&strPassword, Appliance::tr("Password ID %s:"),
     1792                                                            Utf8Str(bstrId).c_str());
    17011793                if (rcExit == RTEXITCODE_FAILURE)
    17021794                {
    … …  
    17271819
    17281820        rc = showProgress(progress);
    1729         CHECK_PROGRESS_ERROR_RET(progress, ("Appliance write failed"), RTEXITCODE_FAILURE);
     1821        CHECK_PROGRESS_ERROR_RET(progress, (Appliance::tr("Appliance write failed")), RTEXITCODE_FAILURE);
    17301822
    17311823        if (SUCCEEDED(rc))
    1732             RTPrintf("Successfully exported %d machine(s).\n", llMachines.size());
     1824            RTPrintf(Appliance::tr("Successfully exported %d machine(s).\n"), llMachines.size());
    17331825
    17341826        /*
    … …  
    17861878                    ComObjPtr<ICloudClient> oCloudClient;
    17871879                    CHECK_ERROR_BREAK(pCloudProfile, CreateCloudClient(oCloudClient.asOutParam()));
    1788                     RTPrintf("Creating a cloud instance...\n");
     1880                    RTPrintf(Appliance::tr("Creating a cloud instance...\n"));
    17891881
    17901882                    ComPtr<IProgress> progress1;
    17911883                    CHECK_ERROR_BREAK(oCloudClient, LaunchVM(pVSD, progress1.asOutParam()));
    17921884                    rc = showProgress(progress1);
    1793                     CHECK_PROGRESS_ERROR_RET(progress1, ("Creating the cloud instance failed"), RTEXITCODE_FAILURE);
     1885                    CHECK_PROGRESS_ERROR_RET(progress1, (Appliance::tr("Creating the cloud instance failed")),
     1886                                             RTEXITCODE_FAILURE);
    17941887
    17951888                    if (SUCCEEDED(rc))
    … …  
    18021895                                                 ComSafeArrayAsOutParam(aExtraConfigValues)));
    18031896
    1804                         RTPrintf("A cloud instance with id '%s' (provider '%s') was created\n",
     1897                        RTPrintf(Appliance::tr("A cloud instance with id '%s' (provider '%s') was created\n"),
    18051898                                 Utf8Str(Bstr(aVBoxValues[0]).raw()).c_str(),
    18061899                                 Utf8Str(bstrCloudProviderShortName.raw()).c_str());
    … …  
    18551948    int rc = RTVfsFileOpenNormal(pszOva, RTFILE_O_OPEN | RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE, &hVfsFileOva);
    18561949    if (RT_FAILURE(rc))
    1857         return RTMsgErrorExitFailure("Failed to open OVA '%s' for updating: %Rrc", pszOva, rc);
     1950        return RTMsgErrorExitFailure(Appliance::tr("Failed to open OVA '%s' for updating: %Rrc"), pszOva, rc);
    18581951
    18591952    RTVFSFSSTREAM hVfsFssOva;
    … …  
    18611954    RTVfsFileRelease(hVfsFileOva);
    18621955    if (RT_FAILURE(rc))
    1863         return RTMsgErrorExitFailure("Failed to open OVA '%s' as a TAR file: %Rrc", pszOva, rc);
     1956        return RTMsgErrorExitFailure(Appliance::tr("Failed to open OVA '%s' as a TAR file: %Rrc"), pszOva, rc);
    18641957    *phVfsFssOva = hVfsFssOva;
    18651958
    … …  
    18681961     */
    18691962    if (iVerbosity >= 2)
    1870         RTMsgInfo("Scanning OVA '%s' for a manifest and signature...", pszOva);
     1963        RTMsgInfo(Appliance::tr("Scanning OVA '%s' for a manifest and signature..."), pszOva);
    18711964    char *pszSignatureName = NULL;
    18721965    for (;;)
    … …  
    18841977                rc = VINF_SUCCESS;
    18851978            else
    1886                 RTMsgError("RTVfsFsStrmNext returned %Rrc", rc);
     1979                RTMsgError(Appliance::tr("RTVfsFsStrmNext returned %Rrc"), rc);
    18871980            break;
    18881981        }
    … …  
    19001993        {
    19011994            if (*phVfsManifest != NIL_RTVFSFILE)
    1902                 rc = RTMsgErrorRc(VERR_DUPLICATE, "OVA contains multiple manifests! first: %s  second: %s",
     1995                rc = RTMsgErrorRc(VERR_DUPLICATE, Appliance::tr("OVA contains multiple manifests! first: %s  second: %s"),
    19031996                                  pStrManifestName->c_str(), pszName);
    19041997            else if (pszSignatureName)
    1905                 rc = RTMsgErrorRc(VERR_WRONG_ORDER, "Unsupported OVA file ordering! Signature file ('%s') as succeeded by '%s'.",
     1998                rc = RTMsgErrorRc(VERR_WRONG_ORDER,
     1999                                  Appliance::tr("Unsupported OVA file ordering! Signature file ('%s') as succeeded by '%s'."),
    19062000                                  pszSignatureName, pszName);
    19072001            else
    19082002            {
    19092003                if (iVerbosity >= 2)
    1910                     RTMsgInfo("Found manifest file: %s", pszName);
     2004                    RTMsgInfo(Appliance::tr("Found manifest file: %s"), pszName);
    19112005                rc = pStrManifestName->assignNoThrow(pszName);
    19122006                if (RT_SUCCESS(rc))
    … …  
    19172011                    RTVfsIoStrmRelease(hVfsIos);     /* consumes stream handle.  */
    19182012                    if (RT_FAILURE(rc))
    1919                         rc = RTMsgErrorRc(VERR_DUPLICATE, "Failed to memorize the manifest: %Rrc", rc);
     2013                        rc = RTMsgErrorRc(VERR_DUPLICATE, Appliance::tr("Failed to memorize the manifest: %Rrc"), rc);
    19202014                }
    19212015                else
    1922                     RTMsgError("Out of memory!");
     2016                    RTMsgError(Appliance::tr("Out of memory!"));
    19232017            }
    19242018        }
    … …  
    19282022        {
    19292023            if (*phVfsOldSignature != NIL_RTVFSOBJ)
    1930                 rc = RTMsgErrorRc(VERR_WRONG_ORDER, "Multiple signature files! (%s)", pszName);
     2024                rc = RTMsgErrorRc(VERR_WRONG_ORDER, Appliance::tr("Multiple signature files! (%s)"), pszName);
    19312025            else
    19322026            {
    19332027                if (iVerbosity >= 2)
    1934                     RTMsgInfo("Found existing signature file: %s", pszName);
     2028                    RTMsgInfo(Appliance::tr("Found existing signature file: %s"), pszName);
    19352029                pszSignatureName   = pszName;
    19362030                *phVfsOldSignature = hVfsObj;
    … …  
    19402034        }
    19412035        else if (pszSignatureName)
    1942             rc = RTMsgErrorRc(VERR_WRONG_ORDER, "Unsupported OVA file ordering! Signature file ('%s') as succeeded by '%s'.",
     2036            rc = RTMsgErrorRc(VERR_WRONG_ORDER,
     2037                              Appliance::tr("Unsupported OVA file ordering! Signature file ('%s') as succeeded by '%s'."),
    19432038                              pszSignatureName, pszName);
    19442039
    … …  
    19562051     */
    19572052    if (RT_SUCCESS(rc) && *phVfsManifest == NIL_RTVFSFILE)
    1958         rc = RTMsgErrorRc(VERR_NOT_FOUND, "The OVA contains no manifest and cannot be signed!");
     2053        rc = RTMsgErrorRc(VERR_NOT_FOUND, Appliance::tr("The OVA contains no manifest and cannot be signed!"));
    19592054    else if (RT_SUCCESS(rc) && *phVfsOldSignature != NIL_RTVFSOBJ && !fReSign)
    19602055        rc = RTMsgErrorRc(VERR_ALREADY_EXISTS,
    1961                           "The OVA is already signed ('%s')! (Use the --force option to force re-signing it.)",
     2056                          Appliance::tr("The OVA is already signed ('%s')! (Use the --force option to force re-signing it.)"),
    19622057                          pszSignatureName);
    19632058
    … …  
    19792074{
    19802075    if (iVerbosity > 1)
    1981         RTMsgInfo("Writing '%s' to the OVA...", pszSignatureName);
     2076        RTMsgInfo(Appliance::tr("Writing '%s' to the OVA..."), pszSignatureName);
    19822077
    19832078    /*
    … …  
    19892084        rc = RTZipTarFsStreamTruncate(hVfsFssOva, hVfsOldSignature, false /*fAfter*/);
    19902085        if (RT_FAILURE(rc))
    1991             return RTMsgErrorRc(rc, "RTZipTarFsStreamTruncate failed on '%s': %Rrc", pszOva, rc);
     2086            return RTMsgErrorRc(rc, Appliance::tr("RTZipTarFsStreamTruncate failed on '%s': %Rrc"), pszOva, rc);
    19922087    }
    19932088
    … …  
    19982093    rc = RTVfsFileSeek(hVfsFileSignature, 0, RTFILE_SEEK_BEGIN, NULL);
    19992094    if (RT_FAILURE(rc))
    2000         return RTMsgErrorRc(rc, "RTVfsFileSeek(hVfsFileSignature) failed: %Rrc", rc);
     2095        return RTMsgErrorRc(rc, Appliance::tr("RTVfsFileSeek(hVfsFileSignature) failed: %Rrc"), rc);
    20012096
    20022097    RTVFSOBJ hVfsObj = RTVfsObjFromFile(hVfsFileSignature);
    … …  
    20042099    RTVfsObjRelease(hVfsObj);
    20052100    if (RT_FAILURE(rc))
    2006         return RTMsgErrorRc(rc, "RTVfsFsStrmAdd('%s') failed on '%s': %Rrc", pszSignatureName, pszOva, rc);
     2101        return RTMsgErrorRc(rc, Appliance::tr("RTVfsFsStrmAdd('%s') failed on '%s': %Rrc"), pszSignatureName, pszOva, rc);
    20072102
    20082103    /*
    … …  
    20112106    rc = RTVfsFsStrmEnd(hVfsFssOva);
    20122107    if (RT_FAILURE(rc))
    2013         return RTMsgErrorRc(rc, "RTVfsFsStrmEnd failed on '%s': %Rrc", pszOva, rc);
     2108        return RTMsgErrorRc(rc, Appliance::tr("RTVfsFsStrmEnd failed on '%s': %Rrc"), pszOva, rc);
    20142109
    20152110    return VINF_SUCCESS;
    … …  
    20472142            {
    20482143                if (iVerbosity > 2 && pszTag == NULL)
    2049                     RTMsgInfo("  Successfully decoded the PKCS#7/CMS signature...");
     2144                    RTMsgInfo(Appliance::tr("  Successfully decoded the PKCS#7/CMS signature..."));
    20502145
    20512146                /*
    … …  
    20632158                {
    20642159                    if (iVerbosity > 1 && pszTag != NULL)
    2065                         RTMsgInfo("  Successfully verified the PKCS#7/CMS signature");
     2160                        RTMsgInfo(Appliance::tr("  Successfully verified the PKCS#7/CMS signature"));
    20662161                }
    20672162                else
    2068                     rc = RTMsgErrorRc(rc, "Failed to verify the PKCS#7/CMS signature: %Rrc%RTeim", rc, &pErrInfo->Core);
     2163                    rc = RTMsgErrorRc(rc, Appliance::tr("Failed to verify the PKCS#7/CMS signature: %Rrc%RTeim"),
     2164                                      rc, &pErrInfo->Core);
    20692165            }
    20702166            else
    2071                 RTMsgError("RTCrPkcs7SignedData_CheckSanity failed on PKCS#7/CMS signature: %Rrc%RTeim",
     2167                RTMsgError(Appliance::tr("RTCrPkcs7SignedData_CheckSanity failed on PKCS#7/CMS signature: %Rrc%RTeim"),
    20722168                           rc, &pErrInfo->Core);
    20732169
    20742170        }
    20752171        else
    2076             rc = RTMsgErrorRc(VERR_WRONG_TYPE, "PKCS#7/CMS signature inner ContentType isn't 'data' but: %s",
     2172            rc = RTMsgErrorRc(VERR_WRONG_TYPE, Appliance::tr("PKCS#7/CMS signature inner ContentType isn't 'data' but: %s"),
    20772173                              pSignedData->ContentInfo.ContentType.szObjId);
    20782174    }
    20792175    else
    2080         rc = RTMsgErrorRc(VERR_WRONG_TYPE, "PKCS#7/CMD signature is not 'signedData': %s", pContentInfo->ContentType.szObjId);
     2176        rc = RTMsgErrorRc(VERR_WRONG_TYPE, Appliance::tr("PKCS#7/CMD signature is not 'signedData': %s"),
     2177                          pContentInfo->ContentType.szObjId);
    20812178    return rc;
    20822179}
    … …  
    21182215            }
    21192216            else
    2120                 rc = RTMsgErrorRc(rc, "RTCrPkcs7ContentInfo_Clone failed: %Rrc", rc);
     2217                rc = RTMsgErrorRc(rc, Appliance::tr("RTCrPkcs7ContentInfo_Clone failed: %Rrc"), rc);
    21212218        }
    21222219    }
    21232220    else
    2124         RTMsgError("RTCrPkcs7ContentInfo_DecodeAsn1 failed to decode PKCS#7/CMS signature: %Rrc%RTemi", rc, &pErrInfo->Core);
     2221        RTMsgError(Appliance::tr("RTCrPkcs7ContentInfo_DecodeAsn1 failed to decode PKCS#7/CMS signature: %Rrc%RTemi"),
     2222                   rc, &pErrInfo->Core);
    21252223
    21262224    RTCrPkcs7ContentInfo_Delete(&ContentInfo);
    … …  
    21522250        return RTMsgErrorRc(rc, "RTVfsFileQuerySize/manifest: %Rrc", rc);
    21532251    if (cbManifest > _4M)
    2154         return RTMsgErrorRc(VERR_OUT_OF_RANGE, "Manifest is too big: %#RX64 bytes, max 4MiB", cbManifest);
     2252        return RTMsgErrorRc(VERR_OUT_OF_RANGE, Appliance::tr("Manifest is too big: %#RX64 bytes, max 4MiB", "", cbManifest),
     2253                            cbManifest);
    21552254
    21562255    void *pvManifest = RTMemAllocZ(cbManifest + 1);
    21572256    if (!pvManifest)
    2158         return RTMsgErrorRc(VERR_NO_MEMORY, "Out of memory!");
     2257        return RTMsgErrorRc(VERR_NO_MEMORY, Appliance::tr("Out of memory!"));
    21592258
    21602259    rc = RTVfsFileReadAt(hVfsFileManifest, 0, pvManifest, (size_t)cbManifest, NULL);
    … …  
    21762275                    if (RT_FAILURE(rc))
    21772276                    {
    2178                         RTMsgError("RTCrStoreCertAddFromFile failed on '%s': %Rrc%#RTeim", pszFile, rc, &pErrInfo->Core);
     2277                        RTMsgError(Appliance::tr("RTCrStoreCertAddFromFile failed on '%s': %Rrc%#RTeim"), pszFile, rc, &pErrInfo->Core);
    21792278                        break;
    21802279                    }
    … …  
    21822281            }
    21832282            else
    2184                 RTMsgError("RTCrStoreCreateInMem failed: %Rrc", rc);
     2283                RTMsgError(Appliance::tr("RTCrStoreCreateInMem failed: %Rrc"), rc);
    21852284        }
    21862285        if (RT_SUCCESS(rc))
    … …  
    22132312                        {
    22142313                            if (iVerbosity > 1)
    2215                                 RTMsgInfo("Created PKCS#7/CMS signature: %zu bytes, %s.",
     2314                                RTMsgInfo(Appliance::tr("Created PKCS#7/CMS signature: %zu bytes, %s."),
    22162315                                          cbResult, RTCrDigestTypeToName(enmDigestType));
    22172316                            if (enmDigestType == RTDIGESTTYPE_SHA1)
    2218                                 RTMsgWarning("Using SHA-1 instead of SHA-3 for the PKCS#7/CMS signature.");
     2317                                RTMsgWarning(Appliance::tr("Using SHA-1 instead of SHA-3 for the PKCS#7/CMS signature."));
    22192318
    22202319                            /*
    … …  
    22252324                        }
    22262325                        else
    2227                             RTMsgError("RTCrPemWriteBlobToVfsFile failed: %Rrc", rc);
     2326                            RTMsgError(Appliance::tr("RTCrPemWriteBlobToVfsFile failed: %Rrc"), rc);
    22282327                    }
    22292328                    RTMemFree(pvResult);
    22302329                }
    22312330                else
    2232                     rc = RTMsgErrorRc(VERR_NO_MEMORY, "Out of memory!");
     2331                    rc = RTMsgErrorRc(VERR_NO_MEMORY, Appliance::tr("Out of memory!"));
    22332332            }
    22342333            else
    2235                 RTMsgError("RTCrPkcs7SimpleSignSignedData failed: %Rrc%#RTeim", rc, &pErrInfo->Core);
     2334                RTMsgError(Appliance::tr("RTCrPkcs7SimpleSignSignedData failed: %Rrc%#RTeim"), rc, &pErrInfo->Core);
    22362335        }
    22372336    }
    22382337    else
    2239         RTMsgError("RTVfsFileReadAt failed: %Rrc", rc);
     2338        RTMsgError(Appliance::tr("RTVfsFileReadAt failed: %Rrc"), rc);
    22402339    RTMemFree(pvManifest);
    22412340    return rc;
    … …  
    22902389        default:
    22912390            return RTMsgErrorRc(VERR_INVALID_PARAMETER,
    2292                                 "Unsupported digest type: %s", RTCrDigestTypeToName(enmDigestType));
     2391                                Appliance::tr("Unsupported digest type: %s"), RTCrDigestTypeToName(enmDigestType));
    22932392    }
    22942393
    … …  
    22992398    int rc = RTCrDigestCreateByType(&hDigest, enmDigestType);
    23002399    if (RT_FAILURE(rc))
    2301         return RTMsgErrorRc(rc, "Failed to create digest for %s: %Rrc", RTCrDigestTypeToName(enmDigestType), rc);
     2400        return RTMsgErrorRc(rc, Appliance::tr("Failed to create digest for %s: %Rrc"), RTCrDigestTypeToName(enmDigestType), rc);
    23022401
    23032402    rc = RTCrDigestUpdateFromVfsFile(hDigest, hVfsFileManifest, true /*fRewindFile*/);
    … …  
    23252424                {
    23262425                    if (iVerbosity > 1)
    2327                         RTMsgInfo("Created OVA signature: %zu bytes, %s", cbSignature, RTCrDigestTypeToName(enmDigestType));
     2426                        RTMsgInfo(Appliance::tr("Created OVA signature: %zu bytes, %s"), cbSignature,
     2427                                  RTCrDigestTypeToName(enmDigestType));
    23282428
    23292429                    /*
    … …  
    23372437                    {
    23382438                        if (iVerbosity > 2)
    2339                             RTMsgInfo("  Successfully decoded and verified the OVA signature.\n");
     2439                            RTMsgInfo(Appliance::tr("  Successfully decoded and verified the OVA signature.\n"));
    23402440
    23412441                        /*
    … …  
    23682468                                }
    23692469                                else
    2370                                     RTMsgError("Failed to write certificate to signature file: %Rrc%#RTeim", rc, &pErrInfo->Core);
     2470                                    RTMsgError(Appliance::tr("Failed to write certificate to signature file: %Rrc%#RTeim"),
     2471                                               rc, &pErrInfo->Core);
    23712472                            }
    23722473                            else
    2373                                 RTMsgError("Failed to produce signature file: %Rrc", rc);
     2474                                RTMsgError(Appliance::tr("Failed to produce signature file: %Rrc"), rc);
    23742475                            RTVfsFileRelease(hVfsFileSignature);
    23752476                        }
    23762477                        else
    2377                             RTMsgError("RTVfsMemFileCreate failed: %Rrc", rc);
     2478                            RTMsgError(Appliance::tr("RTVfsMemFileCreate failed: %Rrc"), rc);
    23782479                    }
    23792480                    else
    2380                         RTMsgError("Encountered a problem when validating the signature we just created: %Rrc%#RTeim\n"
    2381                                    "Plase make sure the certificate and private key matches.", rc, &pErrInfo->Core);
     2481                        RTMsgError(Appliance::tr(
     2482                                        "Encountered a problem when validating the signature we just created: %Rrc%#RTeim\n"
     2483                                        "Plase make sure the certificate and private key matches."),
     2484                                   rc, &pErrInfo->Core);
    23822485                }
    23832486                else
    2384                     RTMsgError("2nd RTCrPkixPubKeySignDigest call failed: %Rrc%#RTeim", rc, pErrInfo->Core);
     2487                    RTMsgError(Appliance::tr("2nd RTCrPkixPubKeySignDigest call failed: %Rrc%#RTeim"), rc, pErrInfo->Core);
    23852488                RTMemFree(pvSignature);
    23862489            }
    23872490            else
    2388                 rc = RTMsgErrorRc(VERR_NO_MEMORY, "Out of memory!");
     2491                rc = RTMsgErrorRc(VERR_NO_MEMORY, Appliance::tr("Out of memory!"));
    23892492        }
    23902493        else
    2391             RTMsgError("RTCrPkixPubKeySignDigest failed: %Rrc%#RTeim", rc, pErrInfo->Core);
     2494            RTMsgError(Appliance::tr("RTCrPkixPubKeySignDigest failed: %Rrc%#RTeim"), rc, pErrInfo->Core);
    23922495    }
    23932496    else
    2394         RTMsgError("Failed to create digest %s: %Rrc", RTCrDigestTypeToName(enmDigestType), rc);
     2497        RTMsgError(Appliance::tr("Failed to create digest %s: %Rrc"), RTCrDigestTypeToName(enmDigestType), rc);
    23952498    RTCrDigestRelease(hDigest);
    23962499    return rc;
    … …  
    24562559            case 'p':
    24572560                if (strPrivateKeyPassword.isNotEmpty())
    2458                     RTMsgWarning("Password is given more than once.");
     2561                    RTMsgWarning(Appliance::tr("Password is given more than once."));
    24592562                strPrivateKeyPassword = ValueUnion.psz;
    24602563                break;
    … …  
    24632566            {
    24642567                if (strPrivateKeyPassword.isNotEmpty())
    2465                     RTMsgWarning("Password is given more than once.");
     2568                    RTMsgWarning(Appliance::tr("Password is given more than once."));
    24662569                RTEXITCODE rcExit = readPasswordFile(ValueUnion.psz, &strPrivateKeyPassword);
    24672570                if (rcExit == RTEXITCODE_SUCCESS)
    … …  
    24812584                    enmDigestType = RTDIGESTTYPE_SHA512;
    24822585                else
    2483                     return RTMsgErrorExitFailure("Unknown digest type: %s", ValueUnion.psz);
     2586                    return RTMsgErrorExitFailure(Appliance::tr("Unknown digest type: %s"), ValueUnion.psz);
    24842587                break;
    24852588
    … …  
    24942597            case 'i':
    24952598                if (cIntermediateCerts >= RT_ELEMENTS(apszIntermediateCerts))
    2496                     return RTMsgErrorExitFailure("Too many intermediate certificates: max %zu",
     2599                    return RTMsgErrorExitFailure(Appliance::tr("Too many intermediate certificates: max %zu"),
    24972600                                                 RT_ELEMENTS(apszIntermediateCerts));
    24982601                apszIntermediateCerts[cIntermediateCerts++] = ValueUnion.psz;
    … …  
    25302633    /* Required paramaters: */
    25312634    if (!pszOva || !*pszOva)
    2532         return RTMsgErrorExit(RTEXITCODE_SYNTAX, "No OVA file was specified!");
     2635        return RTMsgErrorExit(RTEXITCODE_SYNTAX, Appliance::tr("No OVA file was specified!"));
    25332636    if (!pszCertificate || !*pszCertificate)
    2534         return RTMsgErrorExit(RTEXITCODE_SYNTAX, "No signing certificate (--certificate=<file>) was specified!");
     2637        return RTMsgErrorExit(RTEXITCODE_SYNTAX, Appliance::tr("No signing certificate (--certificate=<file>) was specified!"));
    25352638    if (!pszPrivateKey || !*pszPrivateKey)
    2536         return RTMsgErrorExit(RTEXITCODE_SYNTAX, "No signing private key (--private-key=<file>) was specified!");
     2639        return RTMsgErrorExit(RTEXITCODE_SYNTAX, Appliance::tr("No signing private key (--private-key=<file>) was specified!"));
    25372640
    25382641    /* Check that input files exists before we commence: */
    25392642    if (!RTFileExists(pszOva))
    2540         return RTMsgErrorExitFailure("The specified OVA file was not found: %s", pszOva);
     2643        return RTMsgErrorExitFailure(Appliance::tr("The specified OVA file was not found: %s"), pszOva);
    25412644    if (!RTFileExists(pszCertificate))
    2542         return RTMsgErrorExitFailure("The specified certificate file was not found: %s", pszCertificate);
     2645        return RTMsgErrorExitFailure(Appliance::tr("The specified certificate file was not found: %s"), pszCertificate);
    25432646    if (!RTFileExists(pszPrivateKey))
    2544         return RTMsgErrorExitFailure("The specified private key file was not found: %s", pszPrivateKey);
     2647        return RTMsgErrorExitFailure(Appliance::tr("The specified private key file was not found: %s"), pszPrivateKey);
    25452648
    25462649    /*
    … …  
    25632666                                              RTErrInfoInitStatic(&ErrInfo));
    25642667        if (RT_FAILURE(rc))
    2565             return RTMsgErrorExitFailure("Error reading certificate from '%s': %Rrc%#RTeim", pszCertificate, rc, &ErrInfo.Core);
     2668            return RTMsgErrorExitFailure(Appliance::tr("Error reading certificate from '%s': %Rrc%#RTeim"),
     2669                                         pszCertificate, rc, &ErrInfo.Core);
    25662670
    25672671        RTCRKEY hPrivateKey = NIL_RTCRKEY;
    … …  
    25712675        {
    25722676            if (iVerbosity > 1)
    2573                 RTMsgInfo("Successfully read the certificate and private key.");
     2677                RTMsgInfo(Appliance::tr("Successfully read the certificate and private key."));
    25742678
    25752679            /*
    … …  
    25972701                                               hVfsFileSignature, hVfsOldSignature, iVerbosity);
    25982702                    if (RT_SUCCESS(rc) && iVerbosity > 0)
    2599                         RTMsgInfo("Successfully signed '%s'.", pszOva);
     2703                        RTMsgInfo(Appliance::tr("Successfully signed '%s'."), pszOva);
    26002704                }
    26012705            }
    … …  
    26032707        }
    26042708        else
    2605             RTPrintf("Error reading the private key from %s: %Rrc%#RTeim", pszPrivateKey, rc, &ErrInfo.Core);
     2709            RTPrintf(Appliance::tr("Error reading the private key from %s: %Rrc%#RTeim"), pszPrivateKey, rc, &ErrInfo.Core);
    26062710        RTCrX509Certificate_Delete(&Certificate);
    26072711    }

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageBandwidthControl.cpp

    r82968 r92372  
    4040using namespace com;
    4141
     42DECLARE_TRANSLATION_CONTEXT(BWControl);
    4243
    4344// funcs
    … …  
    6465            break;
    6566        case VWRN_NUMBER_TOO_BIG:
    66             return "Limit is too big\n";
     67            return BWControl::tr("Limit is too big\n");
    6768        case VWRN_TRAILING_CHARS:
    6869            switch (*pszNext)
    … …  
    7475                case 'm': iMultiplier = 125000;    break;
    7576                case 'k': iMultiplier = 125;       break;
    76                 default:  return "Invalid unit suffix. Valid suffixes are: k, m, g, K, M, G\n";
     77                default:  return BWControl::tr("Invalid unit suffix. Valid suffixes are: k, m, g, K, M, G\n");
    7778            }
    7879            break;
    7980        case VWRN_TRAILING_SPACES:
    80             return "Trailing spaces in limit!\n";
     81            return BWControl::tr("Trailing spaces in limit!\n");
    8182        case VERR_NO_DIGITS:
    82             return "No digits in limit specifier\n";
     83            return BWControl::tr("No digits in limit specifier\n");
    8384        default:
    84             return "Invalid limit specifier\n";
     85            return BWControl::tr("Invalid limit specifier\n");
    8586    }
    8687    if (*pLimit < 0)
    87         return "Limit cannot be negative\n";
     88        return BWControl::tr("Limit cannot be negative\n");
    8889    if (*pLimit > INT64_MAX / iMultiplier)
    89         return "Limit is too big\n";
     90        return BWControl::tr("Limit is too big\n");
    9091    *pLimit *= iMultiplier;
    9192
    … …  
    112113    if (name.isEmpty())
    113114    {
    114         errorArgument("Bandwidth group name must not be empty!\n");
     115        errorArgument(BWControl::tr("Bandwidth group name must not be empty!\n"));
    115116        return RTEXITCODE_FAILURE;
    116117    }
    … …  
    172173    else
    173174    {
    174         errorArgument("Invalid bandwidth group type\n");
     175        errorArgument(BWControl::tr("Invalid bandwidth group type\n"));
    175176        return RTEXITCODE_FAILURE;
    176177    }
    … …  
    312313
    313314    if (a->argc < 2)
    314         return errorSyntax(USAGE_BANDWIDTHCONTROL, "Too few parameters");
     315        return errorSyntax(USAGE_BANDWIDTHCONTROL, BWControl::tr("Too few parameters"));
    315316    else if (a->argc > 7)
    316         return errorSyntax(USAGE_BANDWIDTHCONTROL, "Too many parameters");
     317        return errorSyntax(USAGE_BANDWIDTHCONTROL, BWControl::tr("Too many parameters"));
    317318
    318319    /* try to find the given machine */
    … …  
    335336        if (fRunTime)
    336337        {
    337             errorArgument("Bandwidth groups cannot be created while the VM is running\n");
     338            errorArgument(BWControl::tr("Bandwidth groups cannot be created while the VM is running\n"));
    338339            goto leave;
    339340        }
    … …  
    344345        if (fRunTime)
    345346        {
    346             errorArgument("Bandwidth groups cannot be deleted while the VM is running\n");
     347            errorArgument(BWControl::tr("Bandwidth groups cannot be deleted while the VM is running\n"));
    347348            goto leave;
    348349        }
    … …  
    355356    else
    356357    {
    357         errorSyntax(USAGE_BANDWIDTHCONTROL, "Invalid parameter '%s'", Utf8Str(a->argv[1]).c_str());
     358        errorSyntax(USAGE_BANDWIDTHCONTROL, BWControl::tr("Invalid parameter '%s'"), Utf8Str(a->argv[1]).c_str());
    358359        rc = E_FAIL;
    359360    }
    … …  
    371372
    372373#endif /* !VBOX_ONLY_DOCS */
    373 

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageCloud.cpp

    r91157 r92372  
    4242using namespace com;//at least for Bstr
    4343
     44DECLARE_TRANSLATION_CONTEXT(Cloud);
     45
    4446
    4547/**
    … …  
    7072    if (bstrProvider.isEmpty())
    7173    {
    72         errorSyntax(USAGE_S_NEWCMD, "Parameter --provider is required");
     74        errorSyntax(USAGE_S_NEWCMD, Cloud::tr("Parameter --provider is required"));
    7375        return E_FAIL;
    7476    }
    7577    if (bstrProfile.isEmpty())
    7678    {
    77         errorSyntax(USAGE_S_NEWCMD, "Parameter --profile is required");
     79        errorSyntax(USAGE_S_NEWCMD, Cloud::tr("Parameter --profile is required"));
    7880        return E_FAIL;
    7981    }
    … …  
    160162                    machineStates.push_back(CloudMachineState_Terminating);
    161163                else
    162                     return errorArgument("Unknown cloud instance state \"%s\"", pszState);
     164                    return errorArgument(Cloud::tr("Unknown cloud instance state \"%s\""), pszState);
    163165                break;
    164166            }
    … …  
    207209    else
    208210    {
    209         RTPrintf("Parameter \'compartment\' is empty or absent.\n"
    210                  "Trying to get the compartment from the passed cloud profile \'%s\'\n", pCommonOpts->profile.pszProfileName);
     211        RTPrintf(Cloud::tr("Parameter \'compartment\' is empty or absent.\n"
     212                           "Trying to get the compartment from the passed cloud profile \'%s\'\n"),
     213                 pCommonOpts->profile.pszProfileName);
    211214        Bstr bStrCompartmentId;
    212215        CHECK_ERROR2_RET(hrc, pCloudProfile,
    … …  
    215218        strCompartmentId = bStrCompartmentId;
    216219        if (strCompartmentId.isNotEmpty())
    217             RTPrintf("Found the compartment \'%s\':\n", strCompartmentId.c_str());
     220            RTPrintf(Cloud::tr("Found the compartment \'%s\':\n"), strCompartmentId.c_str());
    218221        else
    219             return errorSyntax(USAGE_S_NEWCMD, "Parameter --compartment-id is required");
     222            return errorSyntax(USAGE_S_NEWCMD, Cloud::tr("Parameter --compartment-id is required"));
    220223    }
    221224
    … …  
    234237    ComPtr<IProgress> pProgress;
    235238
    236     RTPrintf("Reply is in the form \'instance name\' = \'instance id\'\n");
     239    RTPrintf(Cloud::tr("Reply is in the form \'instance name\' = \'instance id\'\n"));
    237240
    238241    CHECK_ERROR2_RET(hrc, oCloudClient,
    … …  
    243246                     RTEXITCODE_FAILURE);
    244247    showProgress(pProgress);
    245     CHECK_PROGRESS_ERROR_RET(pProgress, ("Failed to list instances"), RTEXITCODE_FAILURE);
     248    CHECK_PROGRESS_ERROR_RET(pProgress, (Cloud::tr("Failed to list instances")), RTEXITCODE_FAILURE);
    246249
    247250    CHECK_ERROR2_RET(hrc,
    … …  
    252255            RTEXITCODE_FAILURE);
    253256
    254     RTPrintf("The list of the instances for the cloud profile \'%ls\' \nand compartment \'%s\':\n",
     257    RTPrintf(Cloud::tr("The list of the instances for the cloud profile \'%ls\' \nand compartment \'%s\':\n"),
    255258             bstrProfileName.raw(), strCompartmentId.c_str());
    256259    size_t cIds = arrayVMIds.size();
    … …  
    320323                    imageStates.push_back(CloudImageState_Provisioning);
    321324                else
    322                     return errorArgument("Unknown cloud image state \"%s\"", pszState);
     325                    return errorArgument(Cloud::tr("Unknown cloud image state \"%s\""), pszState);
    323326                break;
    324327            }
    … …  
    368371    else
    369372    {
    370         RTPrintf("Parameter \'compartment\' is empty or absent.\n"
    371                  "Trying to get the compartment from the passed cloud profile \'%s\'\n", pCommonOpts->profile.pszProfileName);
     373        RTPrintf(Cloud::tr("Parameter \'compartment\' is empty or absent.\n"
     374                           "Trying to get the compartment from the passed cloud profile \'%s\'\n"),
     375                 pCommonOpts->profile.pszProfileName);
    372376        Bstr bStrCompartmentId;
    373377        CHECK_ERROR2_RET(hrc, pCloudProfile,
    … …  
    376380        strCompartmentId = bStrCompartmentId;
    377381        if (strCompartmentId.isNotEmpty())
    378             RTPrintf("Found the compartment \'%s\':\n", strCompartmentId.c_str());
     382            RTPrintf(Cloud::tr("Found the compartment \'%s\':\n"), strCompartmentId.c_str());
    379383        else
    380             return errorSyntax(USAGE_S_NEWCMD, "Parameter --compartment-id is required");
     384            return errorSyntax(USAGE_S_NEWCMD, Cloud::tr("Parameter --compartment-id is required"));
    381385    }
    382386
    … …  
    395399    ComPtr<IProgress> pProgress;
    396400
    397     RTPrintf("Reply is in the form \'image name\' = \'image id\'\n");
     401    RTPrintf(Cloud::tr("Reply is in the form \'image name\' = \'image id\'\n"));
    398402    CHECK_ERROR2_RET(hrc, oCloudClient,
    399403                     ListImages(ComSafeArrayAsInParam(imageStates),
    … …  
    403407                     RTEXITCODE_FAILURE);
    404408    showProgress(pProgress);
    405     CHECK_PROGRESS_ERROR_RET(pProgress, ("Failed to list images"), RTEXITCODE_FAILURE);
     409    CHECK_PROGRESS_ERROR_RET(pProgress, (Cloud::tr("Failed to list images")), RTEXITCODE_FAILURE);
    406410
    407411    CHECK_ERROR2_RET(hrc,
    … …  
    412416            RTEXITCODE_FAILURE);
    413417
    414     RTPrintf("The list of the images for the cloud profile \'%ls\' \nand compartment \'%s\':\n",
     418    RTPrintf(Cloud::tr("The list of the images for the cloud profile \'%ls\' \nand compartment \'%s\':\n"),
    415419             bstrProfileName.raw(), strCompartmentId.c_str());
    416420    size_t cNames = arrayVMNames.size();
    … …  
    469473    if (a->argc == iFirst)
    470474    {
    471         RTPrintf("Empty command parameter list, show help.\n");
     475        RTPrintf(Cloud::tr("Empty command parameter list, show help.\n"));
    472476        printHelp(g_pStdOut);
    473477        return RTEXITCODE_SUCCESS;
    … …  
    540544    if (a->argc == iFirst)
    541545    {
    542         RTPrintf("Empty command parameter list, show help.\n");
     546        RTPrintf(Cloud::tr("Empty command parameter list, show help.\n"));
    543547        printHelp(g_pStdOut);
    544548        return RTEXITCODE_SUCCESS;
    … …  
    639643
    640644    if (strPublicSSHKey.isEmpty())
    641         RTPrintf("Warning!!! Public SSH key doesn't present in the passed arguments...\n");
     645        RTPrintf(Cloud::tr("Warning!!! Public SSH key doesn't present in the passed arguments...\n"));
    642646
    643647    if (strImageId.isNotEmpty() && strBootVolumeId.isNotEmpty())
    644         return errorArgument("Parameters --image-id and --boot-volume-id are mutually exclusive. "
    645                              "Only one of them must be presented.");
     648        return errorArgument(Cloud::tr("Parameters --image-id and --boot-volume-id are mutually exclusive. "
     649                                       "Only one of them must be presented."));
    646650
    647651    if (strImageId.isEmpty() && strBootVolumeId.isEmpty())
    648         return errorArgument("Missing parameter --image-id or --boot-volume-id. One of them must be presented.");
     652        return errorArgument(Cloud::tr("Missing parameter --image-id or --boot-volume-id. One of them must be presented."));
    649653
    650654    ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
    … …  
    668672         * or in the inappropriate state. So the check can be omitted.
    669673         */
    670         RTPrintf("Checking the cloud image with id \'%s\'...\n", strImageId.c_str());
     674        RTPrintf(Cloud::tr("Checking the cloud image with id \'%s\'...\n"), strImageId.c_str());
    671675        CHECK_ERROR2_RET(hrc, oCloudClient,
    672676                         GetImageInfo(Bstr(strImageId).raw(),
    … …  
    676680
    677681        hrc = showProgress(pProgress);
    678         CHECK_PROGRESS_ERROR_RET(pProgress, ("Checking the cloud image failed"), RTEXITCODE_FAILURE);
     682        CHECK_PROGRESS_ERROR_RET(pProgress, (Cloud::tr("Checking the cloud image failed")), RTEXITCODE_FAILURE);
    679683
    680684        pProgress.setNull();
    … …  
    682686
    683687    if (strImageId.isNotEmpty())
    684         RTPrintf("Creating cloud instance with name \'%s\' from the image \'%s\'...\n",
     688        RTPrintf(Cloud::tr("Creating cloud instance with name \'%s\' from the image \'%s\'...\n"),
    685689                 strDisplayName.c_str(), strImageId.c_str());
    686690    else
    687         RTPrintf("Creating cloud instance with name \'%s\' from the boot volume \'%s\'...\n",
     691        RTPrintf(Cloud::tr("Creating cloud instance with name \'%s\' from the boot volume \'%s\'...\n"),
    688692                 strDisplayName.c_str(), strBootVolumeId.c_str());
    689693
    … …  
    691695
    692696    hrc = showProgress(pProgress);
    693     CHECK_PROGRESS_ERROR_RET(pProgress, ("Creating cloud instance failed"), RTEXITCODE_FAILURE);
     697    CHECK_PROGRESS_ERROR_RET(pProgress, (Cloud::tr("Creating cloud instance failed")), RTEXITCODE_FAILURE);
    694698
    695699    if (SUCCEEDED(hrc))
    696         RTPrintf("Cloud instance was created successfully\n");
     700        RTPrintf(Cloud::tr("Cloud instance was created successfully\n"));
    697701
    698702    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    … …  
    723727    if (a->argc == iFirst)
    724728    {
    725         RTPrintf("Empty command parameter list, show help.\n");
     729        RTPrintf(Cloud::tr("Empty command parameter list, show help.\n"));
    726730        printHelp(g_pStdOut);
    727731        return RTEXITCODE_SUCCESS;
    … …  
    738742            {
    739743                if (strInstanceId.isNotEmpty())
    740                     return errorArgument("Duplicate parameter: --id");
     744                    return errorArgument(Cloud::tr("Duplicate parameter: --id"));
    741745
    742746                strInstanceId = ValueUnion.psz;
    743747                if (strInstanceId.isEmpty())
    744                     return errorArgument("Empty parameter: --id");
     748                    return errorArgument(Cloud::tr("Empty parameter: --id"));
    745749
    746750                break;
    … …  
    764768
    765769    if (strInstanceId.isEmpty())
    766         return errorArgument("Missing parameter: --id");
     770        return errorArgument(Cloud::tr("Missing parameter: --id"));
    767771
    768772    ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
    … …  
    772776                     CreateCloudClient(oCloudClient.asOutParam()),
    773777                     RTEXITCODE_FAILURE);
    774     RTPrintf("Getting information about cloud instance with id %s...\n", strInstanceId.c_str());
    775     RTPrintf("Reply is in the form \'setting name\' = \'value\'\n");
     778    RTPrintf(Cloud::tr("Getting information about cloud instance with id %s...\n"), strInstanceId.c_str());
     779    RTPrintf(Cloud::tr("Reply is in the form \'setting name\' = \'value\'\n"));
    776780
    777781    ComPtr<IAppliance> pAppliance;
    … …  
    794798
    795799    hrc = showProgress(progress);
    796     CHECK_PROGRESS_ERROR_RET(progress, ("Getting information about cloud instance failed"), RTEXITCODE_FAILURE);
    797 
    798     RTPrintf("Cloud instance info (provider '%s'):\n",
     800    CHECK_PROGRESS_ERROR_RET(progress, (Cloud::tr("Getting information about cloud instance failed")), RTEXITCODE_FAILURE);
     801
     802    RTPrintf(Cloud::tr("Cloud instance info (provider '%s'):\n"),
    799803             pCommonOpts->provider.pszProviderName);
    800804
    … …  
    807811    const size_t vsdHReadableArraySize = 13;//the number of items in the vsdHReadableArray
    808812    vsdHReadable vsdHReadableArray[vsdHReadableArraySize] = {
    809         {VirtualSystemDescriptionType_CloudDomain, "Availability domain = %ls\n", "Availability domain wasn't found\n"},
    810         {VirtualSystemDescriptionType_Name, "Instance displayed name = %ls\n", "Instance displayed name wasn't found\n"},
    811         {VirtualSystemDescriptionType_CloudInstanceState, "Instance state = %ls\n", "Instance state wasn't found\n"},
    812         {VirtualSystemDescriptionType_CloudInstanceId, "Instance Id = %ls\n", "Instance Id wasn't found\n"},
    813         {VirtualSystemDescriptionType_CloudInstanceDisplayName, "Instance name = %ls\n", "Instance name wasn't found\n"},
    814         {VirtualSystemDescriptionType_CloudImageId, "Bootable image Id = %ls\n",
    815             "Image Id whom the instance is booted up wasn't found\n"},
    816         {VirtualSystemDescriptionType_CloudInstanceShape, "Shape of the instance = %ls\n",
    817             "The shape of the instance wasn't found\n"},
    818         {VirtualSystemDescriptionType_OS, "Type of guest OS = %ls\n", "Type of guest OS wasn't found\n"},
    819         {VirtualSystemDescriptionType_Memory, "RAM = %ls MB\n", "Value for RAM wasn't found\n"},
    820         {VirtualSystemDescriptionType_CPU, "CPUs = %ls\n", "Numbers of CPUs weren't found\n"},
    821         {VirtualSystemDescriptionType_CloudPublicIP, "Instance public IP = %ls\n", "Public IP wasn't found\n"},
    822         {VirtualSystemDescriptionType_Miscellaneous, "%ls\n", "Free-form tags or metadata weren't found\n"},
    823         {VirtualSystemDescriptionType_CloudInitScriptPath, "%ls\n", "Cloud-init script wasn't found\n"}
     813        {VirtualSystemDescriptionType_CloudDomain, Cloud::tr("Availability domain = %ls\n"), Cloud::tr("Availability domain wasn't found\n")},
     814        {VirtualSystemDescriptionType_Name, Cloud::tr("Instance displayed name = %ls\n"), Cloud::tr("Instance displayed name wasn't found\n")},
     815        {VirtualSystemDescriptionType_CloudInstanceState, Cloud::tr("Instance state = %ls\n"), Cloud::tr("Instance state wasn't found\n")},
     816        {VirtualSystemDescriptionType_CloudInstanceId, Cloud::tr("Instance Id = %ls\n"), Cloud::tr("Instance Id wasn't found\n")},
     817        {VirtualSystemDescriptionType_CloudInstanceDisplayName, Cloud::tr("Instance name = %ls\n"), Cloud::tr("Instance name wasn't found\n")},
     818        {VirtualSystemDescriptionType_CloudImageId, Cloud::tr("Bootable image Id = %ls\n"),
     819            Cloud::tr("Image Id whom the instance is booted up wasn't found\n")},
     820        {VirtualSystemDescriptionType_CloudInstanceShape, Cloud::tr("Shape of the instance = %ls\n"),
     821            Cloud::tr("The shape of the instance wasn't found\n")},
     822        {VirtualSystemDescriptionType_OS, Cloud::tr("Type of guest OS = %ls\n"), Cloud::tr("Type of guest OS wasn't found\n")},
     823        {VirtualSystemDescriptionType_Memory, Cloud::tr("RAM = %ls MB\n"), Cloud::tr("Value for RAM wasn't found\n")},
     824        {VirtualSystemDescriptionType_CPU, Cloud::tr("CPUs = %ls\n"), Cloud::tr("Numbers of CPUs weren't found\n")},
     825        {VirtualSystemDescriptionType_CloudPublicIP, Cloud::tr("Instance public IP = %ls\n"), Cloud::tr("Public IP wasn't found\n")},
     826        {VirtualSystemDescriptionType_Miscellaneous, "%ls\n", Cloud::tr("Free-form tags or metadata weren't found\n")},
     827        {VirtualSystemDescriptionType_CloudInitScriptPath, "%ls\n", Cloud::tr("Cloud-init script wasn't found\n")}
    824828    };
    825829
    … …  
    875879    if (a->argc == iFirst)
    876880    {
    877         RTPrintf("Empty command parameter list, show help.\n");
     881        RTPrintf(Cloud::tr("Empty command parameter list, show help.\n"));
    878882        printHelp(g_pStdOut);
    879883        return RTEXITCODE_SUCCESS;
    … …  
    890894            {
    891895                if (strInstanceId.isNotEmpty())
    892                     return errorArgument("Duplicate parameter: --id");
     896                    return errorArgument(Cloud::tr("Duplicate parameter: --id"));
    893897
    894898                strInstanceId = ValueUnion.psz;
    895899                if (strInstanceId.isEmpty())
    896                     return errorArgument("Empty parameter: --id");
     900                    return errorArgument(Cloud::tr("Empty parameter: --id"));
    897901
    898902                break;
    … …  
    916920
    917921    if (strInstanceId.isEmpty())
    918         return errorArgument("Missing parameter: --id");
     922        return errorArgument(Cloud::tr("Missing parameter: --id"));
    919923
    920924    ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
    … …  
    924928                     CreateCloudClient(oCloudClient.asOutParam()),
    925929                     RTEXITCODE_FAILURE);
    926     RTPrintf("Starting cloud instance with id %s...\n", strInstanceId.c_str());
     930    RTPrintf(Cloud::tr("Starting cloud instance with id %s...\n"), strInstanceId.c_str());
    927931
    928932    ComPtr<IProgress> progress;
    … …  
    931935                     RTEXITCODE_FAILURE);
    932936    hrc = showProgress(progress);
    933     CHECK_PROGRESS_ERROR_RET(progress, ("Starting the cloud instance failed"), RTEXITCODE_FAILURE);
     937    CHECK_PROGRESS_ERROR_RET(progress, (Cloud::tr("Starting the cloud instance failed")), RTEXITCODE_FAILURE);
    934938
    935939    if (SUCCEEDED(hrc))
    936         RTPrintf("Cloud instance with id %s (provider = '%s', profile = '%s') was started\n",
     940        RTPrintf(Cloud::tr("Cloud instance with id %s (provider = '%s', profile = '%s') was started\n"),
    937941                 strInstanceId.c_str(),
    938942                 pCommonOpts->provider.pszProviderName,
    … …  
    958962    if (a->argc == iFirst)
    959963    {
    960         RTPrintf("Empty command parameter list, show help.\n");
     964        RTPrintf(Cloud::tr("Empty command parameter list, show help.\n"));
    961965        printHelp(g_pStdOut);
    962966        return RTEXITCODE_SUCCESS;
    … …  
    973977            {
    974978                if (strInstanceId.isNotEmpty())
    975                     return errorArgument("Duplicate parameter: --id");
     979                    return errorArgument(Cloud::tr("Duplicate parameter: --id"));
    976980
    977981                strInstanceId = ValueUnion.psz;
    978982                if (strInstanceId.isEmpty())
    979                     return errorArgument("Empty parameter: --id");
     983                    return errorArgument(Cloud::tr("Empty parameter: --id"));
    980984
    981985                break;
    … …  
    9991003
    10001004    if (strInstanceId.isEmpty())
    1001         return errorArgument("Missing parameter: --id");
     1005        return errorArgument(Cloud::tr("Missing parameter: --id"));
    10021006
    10031007    ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
    … …  
    10071011                     CreateCloudClient(oCloudClient.asOutParam()),
    10081012                     RTEXITCODE_FAILURE);
    1009     RTPrintf("Pausing cloud instance with id %s...\n", strInstanceId.c_str());
     1013    RTPrintf(Cloud::tr("Pausing cloud instance with id %s...\n"), strInstanceId.c_str());
    10101014
    10111015    ComPtr<IProgress> progress;
    … …  
    10141018                     RTEXITCODE_FAILURE);
    10151019    hrc = showProgress(progress);
    1016     CHECK_PROGRESS_ERROR_RET(progress, ("Pause the cloud instance failed"), RTEXITCODE_FAILURE);
     1020    CHECK_PROGRESS_ERROR_RET(progress, (Cloud::tr("Pause the cloud instance failed")), RTEXITCODE_FAILURE);
    10171021
    10181022    if (SUCCEEDED(hrc))
    1019         RTPrintf("Cloud instance with id %s (provider = '%s', profile = '%s') was paused\n",
     1023        RTPrintf(Cloud::tr("Cloud instance with id %s (provider = '%s', profile = '%s') was paused\n"),
    10201024                 strInstanceId.c_str(),
    10211025                 pCommonOpts->provider.pszProviderName,
    … …  
    10411045    if (a->argc == iFirst)
    10421046    {
    1043         RTPrintf("Empty command parameter list, show help.\n");
     1047        RTPrintf(Cloud::tr("Empty command parameter list, show help.\n"));
    10441048        printHelp(g_pStdOut);
    10451049        return RTEXITCODE_SUCCESS;
    … …  
    10561060            {
    10571061                if (strInstanceId.isNotEmpty())
    1058                     return errorArgument("Duplicate parameter: --id");
     1062                    return errorArgument(Cloud::tr("Duplicate parameter: --id"));
    10591063
    10601064                strInstanceId = ValueUnion.psz;
    10611065                if (strInstanceId.isEmpty())
    1062                     return errorArgument("Empty parameter: --id");
     1066                    return errorArgument(Cloud::tr("Empty parameter: --id"));
    10631067
    10641068                break;
    … …  
    10821086
    10831087    if (strInstanceId.isEmpty())
    1084         return errorArgument("Missing parameter: --id");
     1088        return errorArgument(Cloud::tr("Missing parameter: --id"));
    10851089
    10861090
    … …  
    10911095                     CreateCloudClient(oCloudClient.asOutParam()),
    10921096                     RTEXITCODE_FAILURE);
    1093     RTPrintf("Terminating cloud instance with id %s...\n", strInstanceId.c_str());
     1097    RTPrintf(Cloud::tr("Terminating cloud instance with id %s...\n"), strInstanceId.c_str());
    10941098
    10951099    ComPtr<IProgress> progress;
    … …  
    10981102                     RTEXITCODE_FAILURE);
    10991103    hrc = showProgress(progress);
    1100     CHECK_PROGRESS_ERROR_RET(progress, ("Termination the cloud instance failed"), RTEXITCODE_FAILURE);
     1104    CHECK_PROGRESS_ERROR_RET(progress, (Cloud::tr("Termination the cloud instance failed")), RTEXITCODE_FAILURE);
    11011105
    11021106    if (SUCCEEDED(hrc))
    1103         RTPrintf("Cloud instance with id %s (provider = '%s', profile = '%s') was terminated\n",
     1107        RTPrintf(Cloud::tr("Cloud instance with id %s (provider = '%s', profile = '%s') was terminated\n"),
    11041108                 strInstanceId.c_str(),
    11051109                 pCommonOpts->provider.pszProviderName,
    … …  
    11391143    if (a->argc == iFirst)
    11401144    {
    1141         RTPrintf("Empty command parameter list, show help.\n");
     1145        RTPrintf(Cloud::tr("Empty command parameter list, show help.\n"));
    11421146        printHelp(g_pStdOut);
    11431147        return RTEXITCODE_SUCCESS;
    … …  
    12161220    if (a->argc == iFirst)
    12171221    {
    1218         RTPrintf("Empty command parameter list, show help.\n");
     1222        RTPrintf(Cloud::tr("Empty command parameter list, show help.\n"));
    12191223        printHelp(g_pStdOut);
    12201224        return RTEXITCODE_SUCCESS;
    … …  
    12741278
    12751279    if (strInstanceId.isNotEmpty() && strObjectName.isNotEmpty())
    1276         return errorArgument("Conflicting parameters: --instance-id and --object-name can't be used together. Choose one.");
     1280        return errorArgument(Cloud::tr("Conflicting parameters: --instance-id and --object-name can't be used together. Choose one."));
    12771281
    12781282    ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
    … …  
    12831287                     RTEXITCODE_FAILURE);
    12841288    if (strInstanceId.isNotEmpty())
    1285         RTPrintf("Creating cloud image with name \'%s\' from the instance \'%s\'...\n",
     1289        RTPrintf(Cloud::tr("Creating cloud image with name \'%s\' from the instance \'%s\'...\n"),
    12861290                 strDisplayName.c_str(), strInstanceId.c_str());
    12871291    else
    1288         RTPrintf("Creating cloud image with name \'%s\' from the object \'%s\' in the bucket \'%s\'...\n",
     1292        RTPrintf(Cloud::tr("Creating cloud image with name \'%s\' from the object \'%s\' in the bucket \'%s\'...\n"),
    12891293                 strDisplayName.c_str(), strObjectName.c_str(), strBucketName.c_str());
    12901294
    … …  
    12941298                     RTEXITCODE_FAILURE);
    12951299    hrc = showProgress(progress);
    1296     CHECK_PROGRESS_ERROR_RET(progress, ("Creating cloud image failed"), RTEXITCODE_FAILURE);
     1300    CHECK_PROGRESS_ERROR_RET(progress, (Cloud::tr("Creating cloud image failed")), RTEXITCODE_FAILURE);
    12971301
    12981302    if (SUCCEEDED(hrc))
    1299         RTPrintf("Cloud image was created successfully\n");
     1303        RTPrintf(Cloud::tr("Cloud image was created successfully\n"));
    13001304
    13011305    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    … …  
    13231327    if (a->argc == iFirst)
    13241328    {
    1325         RTPrintf("Empty command parameter list, show help.\n");
     1329        RTPrintf(Cloud::tr("Empty command parameter list, show help.\n"));
    13261330        printHelp(g_pStdOut);
    13271331        return RTEXITCODE_SUCCESS;
    … …  
    13431347            {
    13441348                if (strBucketName.isNotEmpty())
    1345                     return errorArgument("Duplicate parameter: --bucket-name");
     1349                    return errorArgument(Cloud::tr("Duplicate parameter: --bucket-name"));
    13461350
    13471351                strBucketName = ValueUnion.psz;
    13481352                if (strBucketName.isEmpty())
    1349                     return errorArgument("Empty parameter: --bucket-name");
     1353                    return errorArgument(Cloud::tr("Empty parameter: --bucket-name"));
    13501354
    13511355                break;
    … …  
    13551359            {
    13561360                if (strObjectName.isNotEmpty())
    1357                     return errorArgument("Duplicate parameter: --object-name");
     1361                    return errorArgument(Cloud::tr("Duplicate parameter: --object-name"));
    13581362
    13591363                strObjectName = ValueUnion.psz;
    13601364                if (strObjectName.isEmpty())
    1361                     return errorArgument("Empty parameter: --object-name");
     1365                    return errorArgument(Cloud::tr("Empty parameter: --object-name"));
    13621366
    13631367                break;
    … …  
    13671371            {
    13681372                if (strImageId.isNotEmpty())
    1369                     return errorArgument("Duplicate parameter: --id");
     1373                    return errorArgument(Cloud::tr("Duplicate parameter: --id"));
    13701374
    13711375                strImageId = ValueUnion.psz;
    13721376                if (strImageId.isEmpty())
    1373                     return errorArgument("Empty parameter: --id");
     1377                    return errorArgument(Cloud::tr("Empty parameter: --id"));
    13741378
    13751379                break;
    … …  
    13791383            {
    13801384                if (strDisplayName.isNotEmpty())
    1381                     return errorArgument("Duplicate parameter: --display-name");
     1385                    return errorArgument(Cloud::tr("Duplicate parameter: --display-name"));
    13821386
    13831387                strDisplayName = ValueUnion.psz;
    13841388                if (strDisplayName.isEmpty())
    1385                     return errorArgument("Empty parameter: --display-name");
     1389                    return errorArgument(Cloud::tr("Empty parameter: --display-name"));
    13861390
    13871391                break;
    … …  
    13911395            {
    13921396                if (strLaunchMode.isNotEmpty())
    1393                     return errorArgument("Duplicate parameter: --launch-mode");
     1397                    return errorArgument(Cloud::tr("Duplicate parameter: --launch-mode"));
    13941398
    13951399                strLaunchMode = ValueUnion.psz;
    13961400                if (strLaunchMode.isEmpty())
    1397                     return errorArgument("Empty parameter: --launch-mode");
     1401                    return errorArgument(Cloud::tr("Empty parameter: --launch-mode"));
    13981402
    13991403                break;
    … …  
    14211425        BstrFmt("image-id=%s", strImageId.c_str()).detachTo(parameters.appendedRaw());
    14221426    else
    1423         return errorArgument("Missing parameter: --id");
     1427        return errorArgument(Cloud::tr("Missing parameter: --id"));
    14241428
    14251429    if (strBucketName.isNotEmpty())
    14261430        BstrFmt("bucket-name=%s", strBucketName.c_str()).detachTo(parameters.appendedRaw());
    14271431    else
    1428         return errorArgument("Missing parameter: --bucket-name");
     1432        return errorArgument(Cloud::tr("Missing parameter: --bucket-name"));
    14291433
    14301434    if (strObjectName.isNotEmpty())
    … …  
    14461450
    14471451    if (strObjectName.isNotEmpty())
    1448         RTPrintf("Exporting image \'%s\' to the Cloud with name \'%s\'...\n",
     1452        RTPrintf(Cloud::tr("Exporting image \'%s\' to the Cloud with name \'%s\'...\n"),
    14491453                 strImageId.c_str(), strObjectName.c_str());
    14501454    else
    1451         RTPrintf("Exporting image \'%s\' to the Cloud with default name\n",
     1455        RTPrintf(Cloud::tr("Exporting image \'%s\' to the Cloud with default name\n"),
    14521456                 strImageId.c_str());
    14531457
    … …  
    14771481        {
    14781482            fFound = true;
    1479             RTPrintf("Image %s was found\n", strImageId.c_str());
     1483            RTPrintf(Cloud::tr("Image %s was found\n"), strImageId.c_str());
    14801484            break;
    14811485        }
    … …  
    14841488    if (!fFound)
    14851489    {
    1486         RTPrintf("Process of exporting the image to the Cloud was interrupted. The image wasn't found.\n");
     1490        RTPrintf(Cloud::tr("Process of exporting the image to the Cloud was interrupted. The image wasn't found.\n"));
    14871491        return RTEXITCODE_FAILURE;
    14881492    }
    … …  
    14931497                     RTEXITCODE_FAILURE);
    14941498    hrc = showProgress(progress);
    1495     CHECK_PROGRESS_ERROR_RET(progress, ("Export the image to the Cloud failed"), RTEXITCODE_FAILURE);
     1499    CHECK_PROGRESS_ERROR_RET(progress, (Cloud::tr("Export the image to the Cloud failed")), RTEXITCODE_FAILURE);
    14961500
    14971501    if (SUCCEEDED(hrc))
    1498         RTPrintf("Export the image to the Cloud was successfull\n");
     1502        RTPrintf(Cloud::tr("Export the image to the Cloud was successfull\n"));
    14991503
    15001504    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    … …  
    15191523    if (a->argc == iFirst)
    15201524    {
    1521         RTPrintf("Empty command parameter list, show help.\n");
     1525        RTPrintf(Cloud::tr("Empty command parameter list, show help.\n"));
    15221526        printHelp(g_pStdOut);
    15231527        return RTEXITCODE_SUCCESS;
    … …  
    15701574                     CreateCloudClient(oCloudClient.asOutParam()),
    15711575                     RTEXITCODE_FAILURE);
    1572     RTPrintf("Creating an object \'%s\' from the cloud image \'%s\'...\n", strObjectName.c_str(), strImageId.c_str());
     1576    RTPrintf(Cloud::tr("Creating an object \'%s\' from the cloud image \'%s\'...\n"), strObjectName.c_str(), strImageId.c_str());
    15731577
    15741578    ComPtr<IProgress> progress;
    … …  
    15771581                     RTEXITCODE_FAILURE);
    15781582    hrc = showProgress(progress);
    1579     CHECK_PROGRESS_ERROR_RET(progress, ("Cloud image import failed"), RTEXITCODE_FAILURE);
     1583    CHECK_PROGRESS_ERROR_RET(progress, (Cloud::tr("Cloud image import failed")), RTEXITCODE_FAILURE);
    15801584
    15811585    if (SUCCEEDED(hrc))
    15821586    {
    1583         RTPrintf("Cloud image was imported successfully. Find the downloaded object with the name %s "
    1584                  "in the system temp folder (find the possible environment variables like TEMP, TMP and etc.)\n",
     1587        RTPrintf(Cloud::tr("Cloud image was imported successfully. Find the downloaded object with the name %s "
     1588                           "in the system temp folder (find the possible environment variables like TEMP, TMP and etc.)\n"),
    15851589                 strObjectName.c_str());
    15861590    }
    … …  
    16051609    if (a->argc == iFirst)
    16061610    {
    1607         RTPrintf("Empty command parameter list, show help.\n");
     1611        RTPrintf(Cloud::tr("Empty command parameter list, show help.\n"));
    16081612        printHelp(g_pStdOut);
    16091613        return RTEXITCODE_SUCCESS;
    … …  
    16421646                     CreateCloudClient(oCloudClient.asOutParam()),
    16431647                     RTEXITCODE_FAILURE);
    1644     RTPrintf("Getting information about the cloud image with id \'%s\'...\n", strImageId.c_str());
     1648    RTPrintf(Cloud::tr("Getting information about the cloud image with id \'%s\'...\n"), strImageId.c_str());
    16451649
    16461650    ComPtr<IStringArray> infoArray;
    … …  
    16481652    ComPtr<IProgress> pProgress;
    16491653
    1650     RTPrintf("Reply is in the form \'image property\' = \'value\'\n");
     1654    RTPrintf(Cloud::tr("Reply is in the form \'image property\' = \'value\'\n"));
    16511655    CHECK_ERROR2_RET(hrc, oCloudClient,
    16521656                     GetImageInfo(Bstr(strImageId).raw(),
    … …  
    16561660
    16571661    hrc = showProgress(pProgress);
    1658     CHECK_PROGRESS_ERROR_RET(pProgress, ("Getting information about the cloud image failed"), RTEXITCODE_FAILURE);
     1662    CHECK_PROGRESS_ERROR_RET(pProgress, (Cloud::tr("Getting information about the cloud image failed")), RTEXITCODE_FAILURE);
    16591663
    16601664    CHECK_ERROR2_RET(hrc,
    … …  
    16621666                     RTEXITCODE_FAILURE);
    16631667
    1664     RTPrintf("General information about the image:\n");
     1668    RTPrintf(Cloud::tr("General information about the image:\n"));
    16651669    size_t cParamNames = pStrInfoArray.size();
    16661670    for (size_t k = 0; k < cParamNames; k++)
    … …  
    16971701    if (a->argc == iFirst)
    16981702    {
    1699         RTPrintf("Empty command parameter list, show help.\n");
     1703        RTPrintf(Cloud::tr("Empty command parameter list, show help.\n"));
    17001704        printHelp(g_pStdOut);
    17011705        return RTEXITCODE_SUCCESS;
    … …  
    17121716            {
    17131717                if (strImageId.isNotEmpty())
    1714                     return errorArgument("Duplicate parameter: --id");
     1718                    return errorArgument(Cloud::tr("Duplicate parameter: --id"));
    17151719
    17161720                strImageId = ValueUnion.psz;
    17171721                if (strImageId.isEmpty())
    1718                     return errorArgument("Empty parameter: --id");
     1722                    return errorArgument(Cloud::tr("Empty parameter: --id"));
    17191723
    17201724                break;
    … …  
    17391743
    17401744    if (strImageId.isEmpty())
    1741         return errorArgument("Missing parameter: --id");
     1745        return errorArgument(Cloud::tr("Missing parameter: --id"));
    17421746
    17431747
    … …  
    17481752                     CreateCloudClient(oCloudClient.asOutParam()),
    17491753                     RTEXITCODE_FAILURE);
    1750     RTPrintf("Deleting cloud image with id %s...\n", strImageId.c_str());
     1754    RTPrintf(Cloud::tr("Deleting cloud image with id %s...\n"), strImageId.c_str());
    17511755
    17521756    ComPtr<IProgress> progress;
    … …  
    17551759                     RTEXITCODE_FAILURE);
    17561760    hrc = showProgress(progress);
    1757     CHECK_PROGRESS_ERROR_RET(progress, ("Deleting cloud image failed"), RTEXITCODE_FAILURE);
     1761    CHECK_PROGRESS_ERROR_RET(progress, (Cloud::tr("Deleting cloud image failed")), RTEXITCODE_FAILURE);
    17581762
    17591763    if (SUCCEEDED(hrc))
    1760         RTPrintf("Cloud image with was deleted successfully\n");
     1764        RTPrintf(Cloud::tr("Cloud image with was deleted successfully\n"));
    17611765
    17621766    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    … …  
    17931797    if (a->argc == iFirst)
    17941798    {
    1795         RTPrintf("Empty command parameter list, show help.\n");
     1799        RTPrintf(Cloud::tr("Empty command parameter list, show help.\n"));
    17961800        printHelp(g_pStdOut);
    17971801        return RTEXITCODE_SUCCESS;
    … …  
    19411945
    19421946    if (options.strNetworkName.isEmpty())
    1943         return errorArgument("Missing --name parameter");
     1947        return errorArgument(Cloud::tr("Missing --name parameter"));
    19441948    if (options.strNetworkId.isEmpty())
    1945         return errorArgument("Missing --network-id parameter");
     1949        return errorArgument(Cloud::tr("Missing --network-id parameter"));
    19461950
    19471951    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
    … …  
    19551959    RTEXITCODE rc = createUpdateCloudNetworkCommon(cloudNetwork, options, pCommonOpts);
    19561960    if (RT_SUCCESS(rc))
    1957         RTPrintf("Cloud network was created successfully\n");
     1961        RTPrintf(Cloud::tr("Cloud network was created successfully\n"));
    19581962
    19591963    return rc;
    … …  
    19921996
    19931997    if (strNetworkName.isEmpty())
    1994         return errorArgument("Missing --name parameter");
     1998        return errorArgument(Cloud::tr("Missing --name parameter"));
    19951999
    19962000    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
    … …  
    20002004                     RTEXITCODE_FAILURE);
    20012005
    2002     RTPrintf("Name:            %ls\n", strNetworkName.raw());
     2006    RTPrintf(Cloud::tr("Name:            %ls\n"), strNetworkName.raw());
    20032007    BOOL fEnabled = FALSE;
    20042008    cloudNetwork->COMGETTER(Enabled)(&fEnabled);
    2005     RTPrintf("State:           %s\n", fEnabled ? "Enabled" : "Disabled");
     2009    RTPrintf(Cloud::tr("State:           %s\n"), fEnabled ? Cloud::tr("Enabled") : Cloud::tr("Disabled"));
    20062010    Bstr Provider;
    20072011    cloudNetwork->COMGETTER(Provider)(Provider.asOutParam());
    2008     RTPrintf("CloudProvider:   %ls\n", Provider.raw());
     2012    RTPrintf(Cloud::tr("CloudProvider:   %ls\n"), Provider.raw());
    20092013    Bstr Profile;
    20102014    cloudNetwork->COMGETTER(Profile)(Profile.asOutParam());
    2011     RTPrintf("CloudProfile:    %ls\n", Profile.raw());
     2015    RTPrintf(Cloud::tr("CloudProfile:    %ls\n"), Profile.raw());
    20122016    Bstr NetworkId;
    20132017    cloudNetwork->COMGETTER(NetworkId)(NetworkId.asOutParam());
    2014     RTPrintf("CloudNetworkId:  %ls\n", NetworkId.raw());
     2018    RTPrintf(Cloud::tr("CloudNetworkId:  %ls\n"), NetworkId.raw());
    20152019    Bstr netName = BstrFmt("cloud-%ls", strNetworkName.raw());
    2016     RTPrintf("VBoxNetworkName: %ls\n\n", netName.raw());
     2020    RTPrintf(Cloud::tr("VBoxNetworkName: %ls\n\n"), netName.raw());
    20172021
    20182022    return RTEXITCODE_SUCCESS;
    … …  
    20662070
    20672071    if (options.strNetworkName.isEmpty())
    2068         return errorArgument("Missing --name parameter");
     2072        return errorArgument(Cloud::tr("Missing --name parameter"));
    20692073
    20702074    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
    … …  
    20762080    RTEXITCODE rc = createUpdateCloudNetworkCommon(cloudNetwork, options, pCommonOpts);
    20772081    if (RT_SUCCESS(rc))
    2078         RTPrintf("Cloud network %ls was updated successfully\n", options.strNetworkName.raw());
     2082        RTPrintf(Cloud::tr("Cloud network %ls was updated successfully\n"), options.strNetworkName.raw());
    20792083
    20802084    return rc;
    … …  
    21132117
    21142118    if (strNetworkName.isEmpty())
    2115         return errorArgument("Missing --name parameter");
     2119        return errorArgument(Cloud::tr("Missing --name parameter"));
    21162120
    21172121    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
    … …  
    21262130
    21272131    if (SUCCEEDED(hrc))
    2128         RTPrintf("Cloud network %ls was deleted successfully\n", strNetworkName.raw());
     2132        RTPrintf(Cloud::tr("Cloud network %ls was deleted successfully\n"), strNetworkName.raw());
    21292133
    21302134    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    … …  
    21582162    if (RT_FAILURE(rc))
    21592163    {
    2160         RTStrmPrintf(g_pStdErr, "Failed to compose path to the unattended installer script templates (%Rrc)", rc);
     2164        RTStrmPrintf(g_pStdErr, Cloud::tr("Failed to compose path to the unattended installer script templates (%Rrc)"), rc);
    21612165        RTStrmFlush(g_pStdErr);
    21622166    }
    … …  
    22832287    Bstr guestAdditionsISO;
    22842288    hrc = virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
    2285     if (errorOccured(hrc, "Failed to obtain system properties."))
     2289    if (errorOccured(hrc, Cloud::tr("Failed to obtain system properties.")))
    22862290        return hrc;
    22872291    if (aProxy.isNotEmpty())
    … …  
    22902294    {
    22912295        hrc = systemProperties->COMGETTER(ProxyMode)(&enmProxyMode);
    2292         if (errorOccured(hrc, "Failed to obtain proxy mode."))
     2296        if (errorOccured(hrc, Cloud::tr("Failed to obtain proxy mode.")))
    22932297            return hrc;
    22942298        switch (enmProxyMode)
    … …  
    22992303            case ProxyMode_Manual:
    23002304                hrc = systemProperties->COMGETTER(ProxyURL)(strProxy.asOutParam());
    2301                 if (errorOccured(hrc, "Failed to obtain proxy URL."))
     2305                if (errorOccured(hrc, Cloud::tr("Failed to obtain proxy URL.")))
    23022306                    return hrc;
    23032307                break;
    … …  
    23052309                hrc = getSystemProxyForUrl("https://dl.fedoraproject.org", strProxy);
    23062310                if (FAILED(hrc))
    2307                     errorOccured(hrc, "Failed to get system proxy for https://dl.fedoraproject.org. Will use direct connection.");
     2311                    errorOccured(hrc, Cloud::tr("Failed to get system proxy for https://dl.fedoraproject.org. Will use direct connection."));
    23082312                break;
    23092313            default: /* To get rid of ProxyMode_32BitHack 'warning' */
    … …  
    23142318    }
    23152319    hrc = systemProperties->COMGETTER(DefaultMachineFolder)(defaultMachineFolder.asOutParam());
    2316     if (errorOccured(hrc, "Failed to obtain default machine folder."))
     2320    if (errorOccured(hrc, Cloud::tr("Failed to obtain default machine folder.")))
    23172321        return hrc;
    23182322    if (aGuestAdditionsIso.isEmpty())
    23192323    {
    23202324        hrc = systemProperties->COMGETTER(DefaultAdditionsISO)(guestAdditionsISO.asOutParam());
    2321         if (errorOccured(hrc, "Failed to obtain default guest additions ISO path."))
     2325        if (errorOccured(hrc, Cloud::tr("Failed to obtain default guest additions ISO path.")))
    23222326            return hrc;
    23232327        if (guestAdditionsISO.isEmpty())
    23242328        {
    2325             errorOccured(E_INVALIDARG, "The default guest additions ISO path is empty nor it is provided as --guest-additions-iso parameter. Cannot proceed without it.");
     2329            errorOccured(E_INVALIDARG, Cloud::tr("The default guest additions ISO path is empty nor it is provided as --guest-additions-iso parameter. Cannot proceed without it."));
    23262330            return E_INVALIDARG;
    23272331        }
    … …  
    23342338    if (RT_FAILURE(rc))
    23352339    {
    2336         RTStrmPrintf(g_pStdErr, "Failed to compose a path to the local gateway image (%Rrc)", rc);
     2340        RTStrmPrintf(g_pStdErr, Cloud::tr("Failed to compose a path to the local gateway image (%Rrc)"), rc);
    23372341        RTStrmFlush(g_pStdErr);
    23382342        return E_FAIL;
    … …  
    23422346    if (SUCCEEDED(hrc))
    23432347    {
    2344         RTPrintf("Local gateway image already exists, skipping image preparation step.\n");
    2345         return hrc;
    2346     }
    2347 
    2348     RTPrintf("Preparing unattended install of temporary local gateway machine from %ls...\n", aGatewayIso.raw());
     2348        RTPrintf(Cloud::tr("Local gateway image already exists, skipping image preparation step.\n"));
     2349        return hrc;
     2350    }
     2351
     2352    RTPrintf(Cloud::tr("Preparing unattended install of temporary local gateway machine from %ls...\n"), aGatewayIso.raw());
    23492353    /* The image does not exist, let's try to open the provided ISO file. */
    23502354    ComPtr<IMedium> iso;
    23512355    hrc = virtualBox->OpenMedium(aGatewayIso.raw(), DeviceType_DVD, AccessMode_ReadOnly, FALSE, iso.asOutParam());
    2352     if (errorOccured(hrc, "Failed to open %ls.", aGatewayIso.raw()))
     2356    if (errorOccured(hrc, Cloud::tr("Failed to open %ls."), aGatewayIso.raw()))
    23532357        return hrc;
    23542358
    … …  
    23572361    groups.push_back(Bstr("/gateways").mutableRaw());
    23582362    hrc = virtualBox->CreateMachine(NULL, strGatewayVM.raw(), ComSafeArrayAsInParam(groups), Bstr("Oracle_64").raw(), Bstr("").raw(), machine.asOutParam());
    2359     if (errorOccured(hrc, "Failed to create '%ls'.", strGatewayVM.raw()))
     2363    if (errorOccured(hrc, Cloud::tr("Failed to create '%ls'."), strGatewayVM.raw()))
    23602364        return hrc;
    23612365    /* Initial configuration */
    23622366    hrc = machine->ApplyDefaults(NULL);
    2363     if (errorOccured(hrc, "Failed to apply defaults to '%ls'.", strGatewayVM.raw()))
     2367    if (errorOccured(hrc, Cloud::tr("Failed to apply defaults to '%ls'."), strGatewayVM.raw()))
    23642368        return hrc;
    23652369
    23662370    hrc = machine->COMSETTER(CPUCount)(2);
    2367     if (errorOccured(hrc, "Failed to adjust CPU count for '%ls'.", strGatewayVM.raw()))
     2371    if (errorOccured(hrc, Cloud::tr("Failed to adjust CPU count for '%ls'."), strGatewayVM.raw()))
    23682372        return hrc;
    23692373
    23702374    hrc = machine->COMSETTER(MemorySize)(512/*MB*/);
    2371     if (errorOccured(hrc, "Failed to adjust memory size for '%ls'.", strGatewayVM.raw()))
     2375    if (errorOccured(hrc, Cloud::tr("Failed to adjust memory size for '%ls'."), strGatewayVM.raw()))
    23722376        return hrc;
    23732377
    … …  
    23752379    ComPtr<IAudioAdapter> audioAdapter;
    23762380    hrc = machine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
    2377     if (errorOccured(hrc, "Failed to set attachment type for the second network adapter."))
     2381    if (errorOccured(hrc, Cloud::tr("Failed to set attachment type for the second network adapter.")))
    23782382        return hrc;
    23792383
    23802384    hrc = audioAdapter->COMSETTER(Enabled)(FALSE);
    2381     if (errorOccured(hrc, "Failed to disable the audio adapter."))
     2385    if (errorOccured(hrc, Cloud::tr("Failed to disable the audio adapter.")))
    23822386        return hrc;
    23832387    audioAdapter.setNull();
    23842388
    23852389    hrc = virtualBox->RegisterMachine(machine);
    2386     if (errorOccured(hrc, "Failed to register '%ls'.", strGatewayVM.raw()))
     2390    if (errorOccured(hrc, Cloud::tr("Failed to register '%ls'."), strGatewayVM.raw()))
    23872391        return hrc;
    23882392
    23892393    hrc = virtualBox->CreateMedium(Bstr("VDI").raw(), strGatewayImage.raw(), AccessMode_ReadWrite, DeviceType_HardDisk, hd.asOutParam());
    2390     if (errorOccured(hrc, "Failed to create %ls.", strGatewayImage.raw()))
     2394    if (errorOccured(hrc, Cloud::tr("Failed to create %ls."), strGatewayImage.raw()))
    23912395        return hrc;
    23922396
    … …  
    23992403                                ComSafeArrayAsInParam(mediumVariant),
    24002404                                progress.asOutParam());
    2401     if (errorOccured(hrc, "Failed to create base storage for local gateway image."))
     2405    if (errorOccured(hrc, Cloud::tr("Failed to create base storage for local gateway image.")))
    24022406        return hrc;
    24032407
    24042408    hrc = showProgress(progress);
    2405     CHECK_PROGRESS_ERROR_RET(progress, ("Failed to create base storage for local gateway image."), hrc);
     2409    CHECK_PROGRESS_ERROR_RET(progress, (Cloud::tr("Failed to create base storage for local gateway image.")), hrc);
    24062410
    24072411    ComPtr<ISession> session;
    24082412    hrc = session.createInprocObject(CLSID_Session);
    24092413    hrc = machine->LockMachine(session, LockType_Write);
    2410     if (errorOccured(hrc, "Failed to lock '%ls' for modifications.", strGatewayVM.raw()))
     2414    if (errorOccured(hrc, Cloud::tr("Failed to lock '%ls' for modifications."), strGatewayVM.raw()))
    24112415        return hrc;
    24122416
    24132417    ComPtr<IMachine> sessionMachine;
    24142418    hrc = session->COMGETTER(Machine)(sessionMachine.asOutParam());
    2415     if (errorOccured(hrc, "Failed to obtain a mutable machine."))
     2419    if (errorOccured(hrc, Cloud::tr("Failed to obtain a mutable machine.")))
    24162420        return hrc;
    24172421
    24182422    hrc = sessionMachine->AttachDevice(Bstr("SATA").raw(), 0, 0, DeviceType_HardDisk, hd);
    2419     if (errorOccured(hrc, "Failed to attach HD to '%ls'.", strGatewayVM.raw()))
     2423    if (errorOccured(hrc, Cloud::tr("Failed to attach HD to '%ls'."), strGatewayVM.raw()))
    24202424        return hrc;
    24212425
    24222426    hrc = sessionMachine->AttachDevice(Bstr("IDE").raw(), 0, 0, DeviceType_DVD, iso);
    2423     if (errorOccured(hrc, "Failed to attach ISO to '%ls'.", strGatewayVM.raw()))
     2427    if (errorOccured(hrc, Cloud::tr("Failed to attach ISO to '%ls'."), strGatewayVM.raw()))
    24242428        return hrc;
    24252429
    24262430    /* Save settings */
    24272431    hrc = sessionMachine->SaveSettings();
    2428     if (errorOccured(hrc, "Failed to save '%ls' settings.", strGatewayVM.raw()))
     2432    if (errorOccured(hrc, Cloud::tr("Failed to save '%ls' settings."), strGatewayVM.raw()))
    24292433        return hrc;
    24302434    session->UnlockMachine();
    … …  
    24332437    ComPtr<IUnattended> unattended;
    24342438    hrc = virtualBox->CreateUnattendedInstaller(unattended.asOutParam());
    2435     if (errorOccured(hrc, "Failed to create unattended installer."))
     2439    if (errorOccured(hrc, Cloud::tr("Failed to create unattended installer.")))
    24362440        return hrc;
    24372441
    24382442    hrc = unattended->COMSETTER(Machine)(machine);
    2439     if (errorOccured(hrc, "Failed to set machine for the unattended installer."))
     2443    if (errorOccured(hrc, Cloud::tr("Failed to set machine for the unattended installer.")))
    24402444        return hrc;
    24412445
    24422446    hrc = unattended->COMSETTER(IsoPath)(aGatewayIso.raw());
    2443     if (errorOccured(hrc, "Failed to set machine for the unattended installer."))
     2447    if (errorOccured(hrc, Cloud::tr("Failed to set machine for the unattended installer.")))
    24442448        return hrc;
    24452449
    24462450    hrc = unattended->COMSETTER(User)(strUser.raw());
    2447     if (errorOccured(hrc, "Failed to set user for the unattended installer."))
     2451    if (errorOccured(hrc, Cloud::tr("Failed to set user for the unattended installer.")))
    24482452        return hrc;
    24492453
    24502454    hrc = unattended->COMSETTER(Password)(strPassword.raw());
    2451     if (errorOccured(hrc, "Failed to set password for the unattended installer."))
     2455    if (errorOccured(hrc, Cloud::tr("Failed to set password for the unattended installer.")))
    24522456        return hrc;
    24532457
    24542458    hrc = unattended->COMSETTER(FullUserName)(strUser.raw());
    2455     if (errorOccured(hrc, "Failed to set full user name for the unattended installer."))
     2459    if (errorOccured(hrc, Cloud::tr("Failed to set full user name for the unattended installer.")))
    24562460        return hrc;
    24572461
    24582462    hrc = unattended->COMSETTER(InstallGuestAdditions)(TRUE);
    2459     if (errorOccured(hrc, "Failed to enable guest addtions for the unattended installer."))
     2463    if (errorOccured(hrc, Cloud::tr("Failed to enable guest addtions for the unattended installer.")))
    24602464        return hrc;
    24612465
    24622466    hrc = unattended->COMSETTER(AdditionsIsoPath)(guestAdditionsISO.raw());
    2463     if (errorOccured(hrc, "Failed to set guest addtions ISO path for the unattended installer."))
     2467    if (errorOccured(hrc, Cloud::tr("Failed to set guest addtions ISO path for the unattended installer.")))
    24642468        return hrc;
    24652469
    24662470    hrc = unattended->COMSETTER(ScriptTemplatePath)(strInstallerScript.raw());
    2467     if (errorOccured(hrc, "Failed to set script template for the unattended installer."))
     2471    if (errorOccured(hrc, Cloud::tr("Failed to set script template for the unattended installer.")))
    24682472        return hrc;
    24692473
    24702474    hrc = unattended->COMSETTER(PostInstallScriptTemplatePath)(strPostInstallScript.raw());
    2471     if (errorOccured(hrc, "Failed to set post install script template for the unattended installer."))
     2475    if (errorOccured(hrc, Cloud::tr("Failed to set post install script template for the unattended installer.")))
    24722476        return hrc;
    24732477
    … …  
    24752479    {
    24762480        hrc = unattended->COMSETTER(Proxy)(strProxy.raw());
    2477         if (errorOccured(hrc, "Failed to set post install script template for the unattended installer."))
     2481        if (errorOccured(hrc, Cloud::tr("Failed to set post install script template for the unattended installer.")))
    24782482            return hrc;
    24792483    }
    24802484
    24812485    hrc = unattended->Prepare();
    2482     if (errorOccured(hrc, "Failed to prepare unattended installation."))
     2486    if (errorOccured(hrc, Cloud::tr("Failed to prepare unattended installation.")))
    24832487        return hrc;
    24842488
    24852489    hrc = unattended->ConstructMedia();
    2486     if (errorOccured(hrc, "Failed to construct media for unattended installation."))
     2490    if (errorOccured(hrc, Cloud::tr("Failed to construct media for unattended installation.")))
    24872491        return hrc;
    24882492
    24892493    hrc = unattended->ReconfigureVM();
    2490     if (errorOccured(hrc, "Failed to reconfigure %ls for unattended installation.", strGatewayVM.raw()))
     2494    if (errorOccured(hrc, Cloud::tr("Failed to reconfigure %ls for unattended installation."), strGatewayVM.raw()))
    24912495        return hrc;
    24922496
    … …  
    24972501                RTPrintf("  %32s = " a_szFmt "\n", a_szText, Value); \
    24982502            else \
    2499                 RTPrintf("  %32s = failed: %Rhrc\n", a_szText, hrc2); \
     2503                RTPrintf(Cloud::tr("  %32s = failed: %Rhrc\n"), a_szText, hrc2); \
    25002504        } while (0)
    25012505#define SHOW_STR_ATTR(a_Attr, a_szText) do { \
    … …  
    25052509                RTPrintf("  %32s = %ls\n", a_szText, bstrString.raw()); \
    25062510            else \
    2507                 RTPrintf("  %32s = failed: %Rhrc\n", a_szText, hrc2); \
     2511                RTPrintf(Cloud::tr("  %32s = failed: %Rhrc\n"), a_szText, hrc2); \
    25082512        } while (0)
    25092513
    … …  
    25422546    unattended.setNull();
    25432547
    2544     RTPrintf("Performing unattended install of temporary local gateway...\n");
     2548    RTPrintf(Cloud::tr("Performing unattended install of temporary local gateway...\n"));
    25452549
    25462550    hrc = machine->LaunchVMProcess(session, Bstr("gui").raw(), ComSafeArrayNullInParam(), progress.asOutParam());
    2547     if (errorOccured(hrc, "Failed to launch '%ls'.", strGatewayVM.raw()))
     2551    if (errorOccured(hrc, Cloud::tr("Failed to launch '%ls'."), strGatewayVM.raw()))
    25482552        return hrc;
    25492553
    25502554    hrc = progress->WaitForCompletion(-1);
    2551     if (errorOccured(hrc, "Failed to launch '%ls'.", strGatewayVM.raw()))
     2555    if (errorOccured(hrc, Cloud::tr("Failed to launch '%ls'."), strGatewayVM.raw()))
    25522556        return hrc;
    25532557
    … …  
    25602564        RTThreadSleep(1000); /* One second */
    25612565        hrc = machine->COMGETTER(State)(&machineState);
    2562         if (errorOccured(hrc, "Failed to get machine state."))
     2566        if (errorOccured(hrc, Cloud::tr("Failed to get machine state.")))
    25632567            break;
    25642568        RTPrintf("\r%c", progressChars[i++ % sizeof(progressChars)]);
    25652569        if (machineState == MachineState_Aborted)
    25662570        {
    2567             errorOccured(E_ABORT, "Temporary local gateway VM has aborted.");
     2571            errorOccured(E_ABORT, Cloud::tr("Temporary local gateway VM has aborted."));
    25682572            return E_ABORT;
    25692573        }
    … …  
    25732577    if (machineState != MachineState_PoweredOff)
    25742578    {
    2575         errorOccured(E_ABORT, "Timed out (40min) while waiting for unattended install to finish.");
     2579        errorOccured(E_ABORT, Cloud::tr("Timed out (40min) while waiting for unattended install to finish."));
    25762580        return E_ABORT;
    25772581    }
    … …  
    25792583    RTThreadSleep(5000); /* Five seconds */
    25802584
    2581     RTPrintf("\rDone.\n");
     2585    RTPrintf(Cloud::tr("\rDone.\n"));
    25822586
    25832587    hrc = machine->LockMachine(session, LockType_Write);
    2584     if (errorOccured(hrc, "Failed to lock '%ls' for modifications.", strGatewayVM.raw()))
    2585         return hrc;
    2586 
    2587     RTPrintf("Detaching local gateway image...\n");
     2588    if (errorOccured(hrc, Cloud::tr("Failed to lock '%ls' for modifications."), strGatewayVM.raw()))
     2589        return hrc;
     2590
     2591    RTPrintf(Cloud::tr("Detaching local gateway image...\n"));
    25882592    hrc = session->COMGETTER(Machine)(sessionMachine.asOutParam());
    2589     if (errorOccured(hrc, "Failed to obtain a mutable machine."))
     2593    if (errorOccured(hrc, Cloud::tr("Failed to obtain a mutable machine.")))
    25902594        return hrc;
    25912595
    25922596    hrc = sessionMachine->DetachDevice(Bstr("SATA").raw(), 0, 0);
    2593     if (errorOccured(hrc, "Failed to detach HD to '%ls'.", strGatewayVM.raw()))
     2597    if (errorOccured(hrc, Cloud::tr("Failed to detach HD to '%ls'."), strGatewayVM.raw()))
    25942598        return hrc;
    25952599
    … …  
    25992603    /* Save settings */
    26002604    hrc = sessionMachine->SaveSettings();
    2601     if (errorOccured(hrc, "Failed to save '%ls' settings.", strGatewayVM.raw()))
     2605    if (errorOccured(hrc, Cloud::tr("Failed to save '%ls' settings."), strGatewayVM.raw()))
    26022606        return hrc;
    26032607    session->UnlockMachine();
    … …  
    26052609#if 0
    26062610    /** @todo Unregistering the temporary VM makes the image mutable again. Find out the way around it! */
    2607     RTPrintf("Unregistering temporary local gateway machine...\n");
     2611    RTPrintf(Cloud::tr("Unregistering temporary local gateway machine...\n"));
    26082612    SafeIfaceArray<IMedium> media;
    26092613    hrc = machine->Unregister(CleanupMode_DetachAllReturnNone, ComSafeArrayAsOutParam(media));
    2610     if (errorOccured(hrc, "Failed to unregister '%ls'.", strGatewayVM.raw()))
     2614    if (errorOccured(hrc, Cloud::tr("Failed to unregister '%ls'."), strGatewayVM.raw()))
    26112615        return hrc;
    26122616    hrc = machine->DeleteConfig(ComSafeArrayAsInParam(media), progress.asOutParam());
    2613     if (errorOccured(hrc, "Failed to delete config for '%ls'.", strGatewayVM.raw()))
     2617    if (errorOccured(hrc, Cloud::tr("Failed to delete config for '%ls'."), strGatewayVM.raw()))
    26142618        return hrc;
    26152619    hrc = progress->WaitForCompletion(-1);
    2616     if (errorOccured(hrc, "Failed to delete config for '%ls'.", strGatewayVM.raw()))
     2620    if (errorOccured(hrc, Cloud::tr("Failed to delete config for '%ls'."), strGatewayVM.raw()))
    26172621        return hrc;
    26182622#endif
    26192623
    2620     RTPrintf("Making local gateway image immutable...\n");
     2624    RTPrintf(Cloud::tr("Making local gateway image immutable...\n"));
    26212625    hrc = virtualBox->OpenMedium(strGatewayImage.raw(), DeviceType_HardDisk, AccessMode_ReadWrite, FALSE, hd.asOutParam());
    2622     if (errorOccured(hrc, "Failed to open '%ls'.", strGatewayImage.raw()))
     2626    if (errorOccured(hrc, Cloud::tr("Failed to open '%ls'."), strGatewayImage.raw()))
    26232627        return hrc;
    26242628    hd->COMSETTER(Type)(MediumType_Immutable);
    2625     if (errorOccured(hrc, "Failed to make '%ls' immutable.", strGatewayImage.raw()))
     2629    if (errorOccured(hrc, Cloud::tr("Failed to make '%ls' immutable."), strGatewayImage.raw()))
    26262630        return hrc;
    26272631
    … …  
    27062710
    27072711    if (strLocalGatewayIso.isEmpty())
    2708         return errorArgument("Missing --local-gateway-iso parameter");
     2712        return errorArgument(Cloud::tr("Missing --local-gateway-iso parameter"));
    27092713
    27102714    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
    … …  
    27142718        return RTEXITCODE_FAILURE;
    27152719
    2716     RTPrintf("Setting up tunnel network in the cloud...\n");
     2720    RTPrintf(Cloud::tr("Setting up tunnel network in the cloud...\n"));
    27172721
    27182722    ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
    … …  
    27402744
    27412745    hrc = showProgress(progress);
    2742     CHECK_PROGRESS_ERROR_RET(progress, ("Setting up cloud network environment failed"), RTEXITCODE_FAILURE);
     2746    CHECK_PROGRESS_ERROR_RET(progress, (Cloud::tr("Setting up cloud network environment failed")), RTEXITCODE_FAILURE);
    27432747
    27442748    Bstr tunnelNetworkId;
    27452749    hrc = cloudNetworkEnv->COMGETTER(TunnelNetworkId)(tunnelNetworkId.asOutParam());
    2746     RTPrintf("Cloud network environment was set up successfully. Tunnel network id is: %ls\n", tunnelNetworkId.raw());
     2750    RTPrintf(Cloud::tr("Cloud network environment was set up successfully. Tunnel network id is: %ls\n"), tunnelNetworkId.raw());
    27472751
    27482752    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageCloudMachine.cpp

    r91351 r92372  
    2626#include <algorithm>
    2727#include <vector>
     28
     29DECLARE_TRANSLATION_CONTEXT(CloudMachine);
    2830
    2931
    … …  
    168170    if (aProviders.size() == 0)
    169171    {
    170         RTMsgError("cloud: no providers available");
     172        RTMsgError(CloudMachine::tr("cloud: no providers available"));
    171173        return VERR_NOT_FOUND;
    172174    }
    … …  
    174176    if (aProviders.size() > 1)
    175177    {
    176         RTMsgError("cloud: multiple providers available,"
    177                    " '--provider' option is required");
     178        RTMsgError(CloudMachine::tr("cloud: multiple providers available,"
     179                                    " '--provider' option is required"));
    178180        return VERR_MISSING;
    179181    }
    … …  
    227229    if (aProfiles.size() == 0)
    228230    {
    229         RTMsgError("cloud: no profiles exist");
     231        RTMsgError(CloudMachine::tr("cloud: no profiles exist"));
    230232        return VERR_NOT_FOUND;
    231233    }
    … …  
    233235    if (aProfiles.size() > 1)
    234236    {
    235         RTMsgError("cloud: multiple profiles exist,"
    236                    " '--profile' option is required");
     237        RTMsgError(CloudMachine::tr("cloud: multiple profiles exist,"
     238                                    " '--profile' option is required"));
    237239        return VERR_MISSING;
    238240    }
    … …  
    359361                    hrc);
    360362
    361             RTMsgError("ambiguous name: %ls and %ls", bstrId1.raw(), bstrId2.raw());
     363            RTMsgError(CloudMachine::tr("ambiguous name: %ls and %ls"), bstrId1.raw(), bstrId2.raw());
    362364            return VBOX_E_OBJECT_NOT_FOUND;
    363365        }
    … …  
    415417{
    416418    return RTMsgErrorExit(RTEXITCODE_SYNTAX,
    417                "only one machine can be specified");
     419                          CloudMachine::tr("only one machine can be specified"));
    418420}
    419421
    … …  
    463465            if (RT_FAILURE(rc))
    464466            {
    465                 RTMsgError("not a valid uuid: %s", pcszId);
     467                RTMsgError(CloudMachine::tr("not a valid uuid: %s"), pcszId);
    466468                return VERR_PARSE_ERROR;
    467469            }
    … …  
    526528    if (a->pcszSpec == NULL)
    527529    {
    528         RTMsgErrorExit(RTEXITCODE_SYNTAX, "machine not specified");
     530        RTMsgErrorExit(RTEXITCODE_SYNTAX, CloudMachine::tr("machine not specified"));
    529531        return E_FAIL;
    530532    }
    … …  
    532534    if (a->pcszSpec[0] == '\0')
    533535    {
    534         RTMsgError("machine name is empty");
     536        RTMsgError(CloudMachine::tr("machine name is empty"));
    535537        return E_FAIL;
    536538    }
    … …  
    543545            {
    544546                if (hrc == VBOX_E_OBJECT_NOT_FOUND)
    545                     RTMsgError("unable to find machine with id %s", a->pcszSpec);
     547                    RTMsgError(CloudMachine::tr("unable to find machine with id %s"), a->pcszSpec);
    546548                return hrc;
    547549            }
    … …  
    553555            {
    554556                if (hrc == VBOX_E_OBJECT_NOT_FOUND)
    555                     RTMsgError("unable to find machine with name %s", a->pcszSpec);
     557                    RTMsgError(CloudMachine::tr("unable to find machine with name %s"), a->pcszSpec);
    556558                return hrc;
    557559            }
    … …  
    563565            {
    564566                if (hrc == VBOX_E_OBJECT_NOT_FOUND)
    565                     RTMsgError("unable to find machine %s", a->pcszSpec);
     567                    RTMsgError(CloudMachine::tr("unable to find machine %s"), a->pcszSpec);
    566568                return hrc;
    567569            }
    … …  
    635637                      iFirst, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
    636638    AssertRCReturn(rc, RTMsgErrorExit(RTEXITCODE_INIT,
    637                            "cloud machine: RTGetOptInit: %Rra", rc));
     639                                      CloudMachine::tr("cloud machine: RTGetOptInit: %Rra"), rc));
    638640
    639641    int ch;
    … …  
    650652        if (ch == VINF_GETOPT_NOT_OPTION)
    651653            return RTMsgErrorExit(RTEXITCODE_SYNTAX,
    652                        "Invalid sub-command: %s", Val.psz);
     654                                  CloudMachine::tr("Invalid sub-command: %s"), Val.psz);
    653655
    654656        /*
    … …  
    696698            default:            /* should never happen */
    697699                return RTMsgErrorExit(RTEXITCODE_INIT,
    698                            "cloud machine: internal error: %d", ch);
     700                                      CloudMachine::tr("cloud machine: internal error: %d"), ch);
    699701        }
    700702    }
    701703
    702704    return RTMsgErrorExit(RTEXITCODE_SYNTAX,
    703                "cloud machine: command required\n"
    704                "Try '--help' for more information.");
     705                          CloudMachine::tr("cloud machine: command required\n"
     706                                           "Try '--help' for more information."));
    705707}
    706708
    … …  
    753755    if (a->pcszSpec != NULL)
    754756        return RTMsgErrorExit(RTEXITCODE_SYNTAX,
    755                    "cloud machine list: unexpected machine argument");
     757                              CloudMachine::tr("cloud machine list: unexpected machine argument"));
    756758
    757759
    … …  
    761763                      iFirst, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
    762764    AssertRCReturn(rc, RTMsgErrorExit(RTEXITCODE_INIT,
    763                            "cloud machine list: RTGetOptInit: %Rra", rc));
     765                                      CloudMachine::tr("cloud machine list: RTGetOptInit: %Rra"), rc));
    764766
    765767    int ch;
    … …  
    785787            case VINF_GETOPT_NOT_OPTION:
    786788                return RTMsgErrorExit(RTEXITCODE_SYNTAX,
    787                            "Invalid sub-command: %s", Val.psz);
     789                                      CloudMachine::tr("Invalid sub-command: %s"), Val.psz);
    788790
    789791            default:
    … …  
    983985    if (!fAccessible)
    984986    {
    985         RTMsgError("machine is not accessible"); // XXX: Id?
     987        RTMsgError(CloudMachine::tr("machine is not accessible")); // XXX: Id?
    986988
    987989        ComPtr<IVirtualBoxErrorInfo> pErrorInfo;
    … …  
    10131015    switch (enmState) {
    10141016        case CloudMachineState_Invalid:
    1015             RTPrintf("State: Invalid (%RU32)\n", CloudMachineState_Invalid);
     1017            RTPrintf(CloudMachine::tr("State: Invalid (%RU32)\n"), CloudMachineState_Invalid);
    10161018            break;
    10171019
    10181020        case CloudMachineState_Provisioning:
    1019             RTPrintf("State: Provisioning (%RU32)\n", CloudMachineState_Provisioning);
     1021            RTPrintf(CloudMachine::tr("State: Provisioning (%RU32)\n"), CloudMachineState_Provisioning);
    10201022            break;
    10211023
    10221024        case CloudMachineState_Running:
    1023             RTPrintf("State: Running (%RU32)\n", CloudMachineState_Running);
     1025            RTPrintf(CloudMachine::tr("State: Running (%RU32)\n"), CloudMachineState_Running);
    10241026            break;
    10251027
    10261028        case CloudMachineState_Starting:
    1027             RTPrintf("State: Starting (%RU32)\n", CloudMachineState_Starting);
     1029            RTPrintf(CloudMachine::tr("State: Starting (%RU32)\n"), CloudMachineState_Starting);
    10281030            break;
    10291031
    10301032        case CloudMachineState_Stopping:
    1031             RTPrintf("State: Stopping (%RU32)\n", CloudMachineState_Stopping);
     1033            RTPrintf(CloudMachine::tr("State: Stopping (%RU32)\n"), CloudMachineState_Stopping);
    10321034            break;
    10331035
    10341036        case CloudMachineState_Stopped:
    1035             RTPrintf("State: Stopped (%RU32)\n", CloudMachineState_Stopped);
     1037            RTPrintf(CloudMachine::tr("State: Stopped (%RU32)\n"), CloudMachineState_Stopped);
    10361038            break;
    10371039
    10381040        case CloudMachineState_CreatingImage:
    1039             RTPrintf("State: CreatingImage (%RU32)\n", CloudMachineState_CreatingImage);
     1041            RTPrintf(CloudMachine::tr("State: CreatingImage (%RU32)\n"), CloudMachineState_CreatingImage);
    10401042            break;
    10411043
    10421044        case CloudMachineState_Terminating:
    1043             RTPrintf("State: Terminating (%RU32)\n", CloudMachineState_Terminating);
     1045            RTPrintf(CloudMachine::tr("State: Terminating (%RU32)\n"), CloudMachineState_Terminating);
    10441046            break;
    10451047
    10461048        case CloudMachineState_Terminated:
    1047             RTPrintf("State: Terminated (%RU32)\n", CloudMachineState_Terminated);
     1049            RTPrintf(CloudMachine::tr("State: Terminated (%RU32)\n"), CloudMachineState_Terminated);
    10481050            break;
    10491051
    10501052        default:
    1051             RTPrintf("State: Unknown state (%RU32)\n", enmState);
     1053            RTPrintf(CloudMachine::tr("State: Unknown state (%RU32)\n"), enmState);
    10521054    }
    10531055
    … …  
    10581060    if (RT_UNLIKELY(pDetails.isNull()))
    10591061    {
    1060         RTMsgError("null details"); /* better error message? */
     1062        RTMsgError(CloudMachine::tr("null details")); /* better error message? */
    10611063        return E_FAIL;
    10621064    }
    … …  
    11051107            {
    11061108                RTStrmPrintf(g_pStdErr,
    1107                     "%ls: unable to convert to boolean value\n", bstrLabel.raw());
     1109                             CloudMachine::tr("%ls: unable to convert to boolean value\n"),
     1110                             bstrLabel.raw());
    11081111                break;
    11091112            }
    … …  
    11301133            {
    11311134                RTStrmPrintf(g_pStdErr,
    1132                     "%ls: unable to convert to string value\n", bstrLabel.raw());
     1135                             CloudMachine::tr("%ls: unable to convert to string value\n"),
     1136                             bstrLabel.raw());
    11331137                break;
    11341138            }
    … …  
    11711175            {
    11721176                RTStrmPrintf(g_pStdErr,
    1173                     "%ls: unable to convert to integer value\n", bstrLabel.raw());
     1177                             CloudMachine::tr("%ls: unable to convert to integer value\n"),
     1178                             bstrLabel.raw());
    11741179                break;
    11751180            }
    … …  
    11961201            {
    11971202                RTStrmPrintf(g_pStdErr,
    1198                     "%ls: unable to convert to choice value\n", bstrLabel.raw());
     1203                             CloudMachine::tr("%ls: unable to convert to choice value\n"),
     1204                             bstrLabel.raw());
    11991205                break;
    12001206            }
    … …  
    12051211            {
    12061212                RTStrmPrintf(g_pStdOut,
    1207                     "%ls: values: %Rhra", bstrLabel.raw(), hrc);
     1213                             CloudMachine::tr("%ls: values: %Rhra"),
     1214                             bstrLabel.raw(), hrc);
    12081215                break;
    12091216            }
    … …  
    12141221            {
    12151222                RTStrmPrintf(g_pStdOut,
    1216                     "%ls: selectedIndex: %Rhra", bstrLabel.raw(), hrc);
     1223                             CloudMachine::tr("%ls: selectedIndex: %Rhra"),
     1224                             bstrLabel.raw(), hrc);
    12171225                break;
    12181226            }
    … …  
    12211229            {
    12221230                RTStrmPrintf(g_pStdOut,
    1223                     "%ls: selected index %RI64 out of range [0, %zu)\n",
     1231                             CloudMachine::tr("%ls: selected index %RI64 out of range [0, %zu)\n"),
    12241232                             bstrLabel.raw(), (int64_t)idxSelected, aValues.size());
    12251233                break;
    … …  
    12331241        default:
    12341242        {
    1235             RTStrmPrintf(g_pStdOut, "unknown value type %RU32\n", enmType);
     1243            RTStrmPrintf(g_pStdOut, CloudMachine::tr("unknown value type %RU32\n"), enmType);
    12361244            break;
    12371245        }

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp

    r89597 r92372  
    4141
    4242#include <list>
     43
     44DECLARE_TRANSLATION_CONTEXT(CloudVM);
    4345
    4446VMProcPriority_T nameToVMProcPriority(const char *pszName);
    … …  
    6163        &&  u32 <= cMaxNum)
    6264        return (unsigned)u32;
    63     errorArgument("Invalid %s number '%s'", name, psz);
     65    errorArgument(CloudVM::tr("Invalid %s number '%s'"), name, psz);
    6466    return 0;
    6567}
    … …  
    219221        if (FAILED(rc))
    220222        {
    221             RTMsgError("Failed to send a scancode");
     223            RTMsgError(CloudVM::tr("Failed to send a scancode"));
    222224            break;
    223225        }
    … …  
    232234    if (SUCCEEDED(rc) && codesStored < saScancodes.size())
    233235    {
    234         RTMsgError("Only %d scancodes were stored", codesStored);
     236        RTMsgError(CloudVM::tr("Only %d scancodes were stored"), codesStored);
    235237        rc = E_FAIL;
    236238    }
    … …  
    331333                }
    332334                else
    333                     RTMsgError("Out of memory allocating %d bytes", cbBuffer);
     335                    RTMsgError(CloudVM::tr("Out of memory allocating %d bytes"), cbBuffer);
    334336            }
    335337            else
    336                 RTMsgError("File size %RI64 is greater than %RI64: '%s'", cbFile, cbFileMax, pszFilename);
     338                RTMsgError(CloudVM::tr("File size %RI64 is greater than %RI64: '%s'"), cbFile, cbFileMax, pszFilename);
    337339        }
    338340        else
    339             RTMsgError("Cannot get size of file '%s': %Rrc", pszFilename, vrc);
     341            RTMsgError(CloudVM::tr("Cannot get size of file '%s': %Rrc"), pszFilename, vrc);
    340342
    341343        RTFileClose(File);
    342344    }
    343345    else
    344         RTMsgError("Cannot open file '%s': %Rrc", pszFilename, vrc);
     346        RTMsgError(CloudVM::tr("Cannot open file '%s': %Rrc"), pszFilename, vrc);
    345347
    346348    /* Release SHIFT if pressed. */
    … …  
    359361
    360362    if (a->argc < 2)
    361         return errorSyntax(USAGE_CONTROLVM, "Not enough parameters");
     363        return errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Not enough parameters"));
    362364
    363365    /* try to find the given machine */
    … …  
    379381        CHECK_ERROR_BREAK(a->session, COMGETTER(Console)(console.asOutParam()));
    380382        if (!console)
    381             return RTMsgErrorExit(RTEXITCODE_FAILURE, "Machine '%s' is not currently running", a->argv[0]);
     383            return RTMsgErrorExit(RTEXITCODE_FAILURE, CloudVM::tr("Machine '%s' is not currently running"), a->argv[0]);
    382384
    383385        /* ... and session machine */
    … …  
    401403            if (a->argc <= 1 + 1)
    402404            {
    403                 errorArgument("Missing argument to '%s'. Expected CPU number.", a->argv[1]);
     405                errorArgument(CloudVM::tr("Missing argument to '%s'. Expected CPU number."), a->argv[1]);
    404406                rc = E_FAIL;
    405407                break;
    … …  
    414416            if (a->argc <= 1 + 1)
    415417            {
    416                 errorArgument("Missing argument to '%s'. Expected CPU number.", a->argv[1]);
     418                errorArgument(CloudVM::tr("Missing argument to '%s'. Expected CPU number."), a->argv[1]);
    417419                rc = E_FAIL;
    418420                break;
    … …  
    427429            if (a->argc <= 1 + 1)
    428430            {
    429                 errorArgument("Missing argument to '%s'. Expected execution cap number.", a->argv[1]);
     431                errorArgument(CloudVM::tr("Missing argument to '%s'. Expected execution cap number."), a->argv[1]);
    430432                rc = E_FAIL;
    431433                break;
    … …  
    452454                else
    453455                {
    454                     errorArgument("Invalid value '%s'", Utf8Str(a->argv[2]).c_str());
     456                    errorArgument(CloudVM::tr("Invalid value '%s'"), Utf8Str(a->argv[2]).c_str());
    455457                    rc = E_FAIL;
    456458                    break;
    … …  
    461463            else
    462464            {
    463                 errorArgument("audio adapter not enabled in VM configuration");
     465                errorArgument(CloudVM::tr("audio adapter not enabled in VM configuration"));
    464466                rc = E_FAIL;
    465467                break;
    … …  
    482484                else
    483485                {
    484                     errorArgument("Invalid value '%s'", Utf8Str(a->argv[2]).c_str());
     486                    errorArgument(CloudVM::tr("Invalid value '%s'"), Utf8Str(a->argv[2]).c_str());
    485487                    rc = E_FAIL;
    486488                    break;
    … …  
    491493            else
    492494            {
    493                 errorArgument("audio adapter not enabled in VM configuration");
     495                errorArgument(CloudVM::tr("audio adapter not enabled in VM configuration"));
    494496                rc = E_FAIL;
    495497                break;
    … …  
    501503            if (a->argc <= 1 + 1)
    502504            {
    503                 errorArgument("Missing argument to '%s'.", a->argv[1]);
     505                errorArgument(CloudVM::tr("Missing argument to '%s'."), a->argv[1]);
    504506                rc = E_FAIL;
    505507                break;
    … …  
    519521                else
    520522                {
    521                     errorArgument("Invalid '%s' argument '%s'.", a->argv[2], a->argv[3]);
     523                    errorArgument(CloudVM::tr("Invalid '%s' argument '%s'."), a->argv[2], a->argv[3]);
    522524                    rc = E_FAIL;
    523525                    break;
    … …  
    533535                if (a->argc <= 1 + 2)
    534536                {
    535                     errorArgument("Missing argument to '%s'. Expected enabled / disabled.", a->argv[2]);
     537                    errorArgument(CloudVM::tr("Missing argument to '%s'. Expected enabled / disabled."), a->argv[2]);
    536538                    rc = E_FAIL;
    537539                    break;
    … …  
    549551                else
    550552                {
    551                     errorArgument("Invalid '%s' argument '%s'.", a->argv[2], a->argv[3]);
     553                    errorArgument(CloudVM::tr("Invalid '%s' argument '%s'."), a->argv[2], a->argv[3]);
    552554                    rc = E_FAIL;
    553555                    break;
    … …  
    561563            else
    562564            {
    563                 errorArgument("Invalid '%s' argument '%s'.", a->argv[1], a->argv[2]);
     565                errorArgument(CloudVM::tr("Invalid '%s' argument '%s'."), a->argv[1], a->argv[2]);
    564566                rc = E_FAIL;
    565567                break;
    … …  
    571573            if (a->argc <= 1 + 1)
    572574            {
    573                 errorArgument("Missing argument to '%s'. Expected drag and drop mode.", a->argv[1]);
     575                errorArgument(CloudVM::tr("Missing argument to '%s'. Expected drag and drop mode."), a->argv[1]);
    574576                rc = E_FAIL;
    575577                break;
    … …  
    587589            else
    588590            {
    589                 errorArgument("Invalid '%s' argument '%s'.", a->argv[1], a->argv[2]);
     591                errorArgument(CloudVM::tr("Invalid '%s' argument '%s'."), a->argv[1], a->argv[2]);
    590592                rc = E_FAIL;
    591593            }
    … …  
    603605
    604606            rc = showProgress(progress);
    605             CHECK_PROGRESS_ERROR(progress, ("Failed to power off machine"));
     607            CHECK_PROGRESS_ERROR(progress, (CloudVM::tr("Failed to power off machine")));
    606608        }
    607609        else if (!strcmp(a->argv[1], "savestate"))
    … …  
    622624                    if (machineState != MachineState_Paused)
    623625                    {
    624                         RTMsgError("Machine in invalid state %d -- %s\n",
     626                        RTMsgError(CloudVM::tr("Machine in invalid state %d -- %s\n"),
    625627                                   machineState, machineStateToName(machineState, false));
    626628                    }
    … …  
    645647
    646648            rc = showProgress(progress);
    647             CHECK_PROGRESS_ERROR(progress, ("Failed to save machine state"));
     649            CHECK_PROGRESS_ERROR(progress, (CloudVM::tr("Failed to save machine state")));
    648650            if (FAILED(rc))
    649651            {
    … …  
    668670            if (!pGuest)
    669671            {
    670                 RTMsgError("Guest not running");
     672                RTMsgError(CloudVM::tr("Guest not running"));
    671673                rc = E_FAIL;
    672674                break;
    … …  
    689691            {
    690692                if (rc == VBOX_E_NOT_SUPPORTED)
    691                     RTPrintf("Current installed Guest Additions don't support %s the guest.",
     693                    RTPrintf(CloudVM::tr("Current installed Guest Additions don't support %s the guest."),
    692694                             fReboot ? "rebooting" : "shutting down");
    693695            }
    … …  
    700702            if (!pKeyboard)
    701703            {
    702                 RTMsgError("Guest not running");
     704                RTMsgError(CloudVM::tr("Guest not running"));
    703705                rc = E_FAIL;
    704706                break;
    … …  
    707709            if (a->argc <= 1 + 1)
    708710            {
    709                 errorArgument("Missing argument to '%s'. Expected IBM PC AT set 2 keyboard scancode(s) as hex byte(s).", a->argv[1]);
     711                errorArgument(CloudVM::tr("Missing argument to '%s'. Expected IBM PC AT set 2 keyboard scancode(s) as hex byte(s)."),
     712                              a->argv[1]);
    710713                rc = E_FAIL;
    711714                break;
    … …  
    726729                    if (RT_FAILURE (irc))
    727730                    {
    728                         RTMsgError("Converting '%s' returned %Rrc!", a->argv[i], rc);
     731                        RTMsgError(CloudVM::tr("Converting '%s' returned %Rrc!"), a->argv[i], rc);
    729732                        rc = E_FAIL;
    730733                        break;
    … …  
    735738                else
    736739                {
    737                     RTMsgError("Error: '%s' is not a hex byte!", a->argv[i]);
     740                    RTMsgError(CloudVM::tr("Error: '%s' is not a hex byte!"), a->argv[i]);
    738741                    rc = E_FAIL;
    739742                    break;
    … …  
    752755            if (!pKeyboard)
    753756            {
    754                 RTMsgError("Guest not running");
     757                RTMsgError(CloudVM::tr("Guest not running"));
    755758                rc = E_FAIL;
    756759                break;
    … …  
    759762            if (a->argc <= 1 + 1)
    760763            {
    761                 errorArgument("Missing argument to '%s'. Expected ASCII string(s).", a->argv[1]);
     764                errorArgument(CloudVM::tr("Missing argument to '%s'. Expected ASCII string(s)."), a->argv[1]);
    762765                rc = E_FAIL;
    763766                break;
    … …  
    772775            if (!pKeyboard)
    773776            {
    774                 RTMsgError("Guest not running");
     777                RTMsgError(CloudVM::tr("Guest not running"));
    775778                rc = E_FAIL;
    776779                break;
    … …  
    779782            if (a->argc <= 1 + 1)
    780783            {
    781                 errorArgument("Missing argument to '%s'. Expected file name.", a->argv[1]);
     784                errorArgument(CloudVM::tr("Missing argument to '%s'. Expected file name."), a->argv[1]);
    782785                rc = E_FAIL;
    783786                break;
    … …  
    798801            if (a->argc <= 1 + 1)
    799802            {
    800                 errorArgument("Missing argument to '%s'", a->argv[1]);
     803                errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[1]);
    801804                rc = E_FAIL;
    802805                break;
    … …  
    817820                else
    818821                {
    819                     errorArgument("Invalid link state '%s'", Utf8Str(a->argv[2]).c_str());
     822                    errorArgument(CloudVM::tr("Invalid link state '%s'"), Utf8Str(a->argv[2]).c_str());
    820823                    rc = E_FAIL;
    821824                    break;
    … …  
    842845            if (a->argc <= 2)
    843846            {
    844                 errorArgument("Missing argument to '%s'", a->argv[1]);
     847                errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[1]);
    845848                rc = E_FAIL;
    846849                break;
    … …  
    862865                    else
    863866                    {
    864                         errorArgument("Invalid filename or filename not specified for NIC %lu", n);
     867                        errorArgument(CloudVM::tr("Invalid filename or filename not specified for NIC %lu"), n);
    865868                        rc = E_FAIL;
    866869                        break;
    … …  
    870873                }
    871874                else
    872                     RTMsgError("The NIC %d is currently disabled and thus its tracefile can't be changed", n);
     875                    RTMsgError(CloudVM::tr("The NIC %d is currently disabled and thus its tracefile can't be changed"), n);
    873876            }
    874877        }
    … …  
    885888            if (a->argc <= 2)
    886889            {
    887                 errorArgument("Missing argument to '%s'", a->argv[1]);
     890                errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[1]);
    888891                rc = E_FAIL;
    889892                break;
    … …  
    909912                    else
    910913                    {
    911                         errorArgument("Invalid nictrace%lu argument '%s'", n, Utf8Str(a->argv[2]).c_str());
     914                        errorArgument(CloudVM::tr("Invalid nictrace%lu argument '%s'"), n, Utf8Str(a->argv[2]).c_str());
    912915                        rc = E_FAIL;
    913916                        break;
    … …  
    917920                }
    918921                else
    919                     RTMsgError("The NIC %d is currently disabled and thus its trace flag can't be changed", n);
     922                    RTMsgError(CloudVM::tr("The NIC %d is currently disabled and thus its trace flag can't be changed"), n);
    920923            }
    921924        }
    … …  
    933936            if (a->argc <= 2)
    934937            {
    935                 errorArgument("Missing argument to '%s'", a->argv[1]);
     938                errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[1]);
    936939                rc = E_FAIL;
    937940                break;
    … …  
    961964            else
    962965            {
    963 #define ITERATE_TO_NEXT_TERM(ch)                                           \
    964     do {                                                                   \
    965         while (*ch != ',')                                                 \
    966         {                                                                  \
    967             if (*ch == 0)                                                  \
    968             {                                                              \
    969                 return errorSyntax(USAGE_CONTROLVM,                        \
    970                                    "Missing or invalid argument to '%s'",  \
    971                                     a->argv[1]);                           \
    972             }                                                              \
    973             ch++;                                                          \
    974         }                                                                  \
    975         *ch = '\0';                                                        \
    976         ch++;                                                              \
     966#define ITERATE_TO_NEXT_TERM(ch)                                                        \
     967    do {                                                                                \
     968        while (*ch != ',')                                                              \
     969        {                                                                               \
     970            if (*ch == 0)                                                               \
     971            {                                                                           \
     972                return errorSyntax(USAGE_CONTROLVM,                                     \
     973                                   CloudVM::tr("Missing or invalid argument to '%s'"),  \
     974                                    a->argv[1]);                                        \
     975            }                                                                           \
     976            ch++;                                                                       \
     977        }                                                                               \
     978        *ch = '\0';                                                                     \
     979        ch++;                                                                           \
    977980    } while(0)
    978981
    … …  
    10041007                {
    10051008                    return errorSyntax(USAGE_CONTROLVM,
    1006                                        "Wrong rule proto '%s' specified -- only 'udp' and 'tcp' are allowed.",
     1009                                       CloudVM::tr("Wrong rule proto '%s' specified -- only 'udp' and 'tcp' are allowed."),
    10071010                                       strProto);
    10081011                }
    … …  
    10261029            if (a->argc <= 2)
    10271030            {
    1028                 errorArgument("Missing argument to '%s'", a->argv[1]);
     1031                errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[1]);
    10291032                rc = E_FAIL;
    10301033                break;
    … …  
    10571060                        else
    10581061                        {
    1059                             errorArgument("Invalid nicproperty%d argument '%s'", n, a->argv[2]);
     1062                            errorArgument(CloudVM::tr("Invalid nicproperty%d argument '%s'"), n, a->argv[2]);
    10601063                            rc = E_FAIL;
    10611064                        }
    … …  
    10641067                    else
    10651068                    {
    1066                         RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for nicproperty%d '%s'\n", n, a->argv[2]);
     1069                        RTStrmPrintf(g_pStdErr, CloudVM::tr("Error: Failed to allocate memory for nicproperty%d '%s'\n"),
     1070                                     n, a->argv[2]);
    10671071                        rc = E_FAIL;
    10681072                    }
    … …  
    10711075                }
    10721076                else
    1073                     RTMsgError("The NIC %d is currently disabled and thus its properties can't be changed", n);
     1077                    RTMsgError(CloudVM::tr("The NIC %d is currently disabled and thus its properties can't be changed"), n);
    10741078            }
    10751079        }
    … …  
    10861090            if (a->argc <= 2)
    10871091            {
    1088                 errorArgument("Missing argument to '%s'", a->argv[1]);
     1092                errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[1]);
    10891093                rc = E_FAIL;
    10901094                break;
    … …  
    11101114                    else
    11111115                    {
    1112                         errorArgument("Unknown promiscuous mode policy '%s'", a->argv[2]);
     1116                        errorArgument(CloudVM::tr("Unknown promiscuous mode policy '%s'"), a->argv[2]);
    11131117                        rc = E_INVALIDARG;
    11141118                        break;
    … …  
    11201124                }
    11211125                else
    1122                     RTMsgError("The NIC %d is currently disabled and thus its promiscuous mode can't be changed", n);
     1126                    RTMsgError(CloudVM::tr("The NIC %d is currently disabled and thus its promiscuous mode can't be changed"), n);
    11231127            }
    11241128        }
    … …  
    11351139            if (a->argc <= 2)
    11361140            {
    1137                 errorArgument("Missing argument to '%s'", a->argv[1]);
     1141                errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[1]);
    11381142                rc = E_FAIL;
    11391143                break;
    … …  
    11641168                        if (a->argc <= 3)
    11651169                        {
    1166                             errorArgument("Missing argument to '%s'", a->argv[2]);
     1170                            errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[2]);
    11671171                            rc = E_FAIL;
    11681172                            break;
    … …  
    11761180                        if (a->argc <= 3)
    11771181                        {
    1178                             errorArgument("Missing argument to '%s'", a->argv[2]);
     1182                            errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[2]);
    11791183                            rc = E_FAIL;
    11801184                            break;
    … …  
    11881192                        if (a->argc <= 3)
    11891193                        {
    1190                             errorArgument("Missing argument to '%s'", a->argv[2]);
     1194                            errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[2]);
    11911195                            rc = E_FAIL;
    11921196                            break;
    … …  
    12011205                        if (a->argc <= 3)
    12021206                        {
    1203                             errorArgument("Missing argument to '%s'", a->argv[2]);
     1207                            errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[2]);
    12041208                            rc = E_FAIL;
    12051209                            break;
    … …  
    12121216                        if (a->argc <= 3)
    12131217                        {
    1214                             errorArgument("Missing argument to '%s'", a->argv[2]);
     1218                            errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[2]);
    12151219                            rc = E_FAIL;
    12161220                            break;
    … …  
    12241228                        if (a->argc <= 3)
    12251229                        {
    1226                             errorArgument("Missing argument to '%s'", a->argv[2]);
     1230                            errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[2]);
    12271231                            rc = E_FAIL;
    12281232                            break;
    … …  
    12331237                    else
    12341238                    {
    1235                         errorArgument("Invalid type '%s' specfied for NIC %lu", Utf8Str(a->argv[2]).c_str(), n);
     1239                        errorArgument(CloudVM::tr("Invalid type '%s' specfied for NIC %lu"), Utf8Str(a->argv[2]).c_str(), n);
    12361240                        rc = E_FAIL;
    12371241                        break;
    … …  
    12411245                }
    12421246                else
    1243                     RTMsgError("The NIC %d is currently disabled and thus its attachment type can't be changed", n);
     1247                    RTMsgError(CloudVM::tr("The NIC %d is currently disabled and thus its attachment type can't be changed"), n);
    12441248            }
    12451249        }
    … …  
    12481252        {
    12491253            if (!strcmp(a->argv[1], "vrdp"))
    1250                 RTStrmPrintf(g_pStdErr, "Warning: 'vrdp' is deprecated. Use 'vrde'.\n");
     1254                RTStrmPrintf(g_pStdErr, CloudVM::tr("Warning: 'vrdp' is deprecated. Use 'vrde'.\n"));
    12511255
    12521256            if (a->argc <= 1 + 1)
    12531257            {
    1254                 errorArgument("Missing argument to '%s'", a->argv[1]);
     1258                errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[1]);
    12551259                rc = E_FAIL;
    12561260                break;
    … …  
    12711275                else
    12721276                {
    1273                     errorArgument("Invalid remote desktop server state '%s'", Utf8Str(a->argv[2]).c_str());
     1277                    errorArgument(CloudVM::tr("Invalid remote desktop server state '%s'"), Utf8Str(a->argv[2]).c_str());
    12741278                    rc = E_FAIL;
    12751279                    break;
    … …  
    12831287        {
    12841288            if (!strcmp(a->argv[1], "vrdpport"))
    1285                 RTStrmPrintf(g_pStdErr, "Warning: 'vrdpport' is deprecated. Use 'vrdeport'.\n");
     1289                RTStrmPrintf(g_pStdErr, CloudVM::tr("Warning: 'vrdpport' is deprecated. Use 'vrdeport'.\n"));
    12861290
    12871291            if (a->argc <= 1 + 1)
    12881292            {
    1289                 errorArgument("Missing argument to '%s'", a->argv[1]);
     1293                errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[1]);
    12901294                rc = E_FAIL;
    12911295                break;
    … …  
    13131317        {
    13141318            if (!strcmp(a->argv[1], "vrdpvideochannelquality"))
    1315                 RTStrmPrintf(g_pStdErr, "Warning: 'vrdpvideochannelquality' is deprecated. Use 'vrdevideochannelquality'.\n");
     1319                RTStrmPrintf(g_pStdErr,
     1320                             CloudVM::tr("Warning: 'vrdpvideochannelquality' is deprecated. Use 'vrdevideochannelquality'.\n"));
    13161321
    13171322            if (a->argc <= 1 + 1)
    13181323            {
    1319                 errorArgument("Missing argument to '%s'", a->argv[1]);
     1324                errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[1]);
    13201325                rc = E_FAIL;
    13211326                break;
    … …  
    13371342            if (a->argc <= 1 + 1)
    13381343            {
    1339                 errorArgument("Missing argument to '%s'", a->argv[1]);
     1344                errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[1]);
    13401345                rc = E_FAIL;
    13411346                break;
    … …  
    13631368                    else
    13641369                    {
    1365                         errorArgument("Invalid vrdeproperty argument '%s'", a->argv[2]);
     1370                        errorArgument(CloudVM::tr("Invalid vrdeproperty argument '%s'"), a->argv[2]);
    13661371                        rc = E_FAIL;
    13671372                    }
    … …  
    13701375                else
    13711376                {
    1372                     RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for VRDE property '%s'\n", a->argv[2]);
     1377                    RTStrmPrintf(g_pStdErr, CloudVM::tr("Error: Failed to allocate memory for VRDE property '%s'\n"),
     1378                                 a->argv[2]);
    13731379                    rc = E_FAIL;
    13741380                }
    … …  
    13841390            if (a->argc < 3)
    13851391            {
    1386                 errorSyntax(USAGE_CONTROLVM, "Not enough parameters");
     1392                errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Not enough parameters"));
    13871393                rc = E_FAIL;
    13881394                break;
    … …  
    13901396            else if (a->argc == 4 || a->argc > 5)
    13911397            {
    1392                 errorSyntax(USAGE_CONTROLVM, "Wrong number of arguments");
     1398                errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Wrong number of arguments"));
    13931399                rc = E_FAIL;
    13941400                break;
    … …  
    14061412                else
    14071413                {
    1408                     errorArgument("Invalid parameter '%s'", a->argv[3]);
     1414                    errorArgument(CloudVM::tr("Invalid parameter '%s'"), a->argv[3]);
    14091415                    rc = E_FAIL;
    14101416                    break;
    … …  
    14391445            else if (guid.isZero())
    14401446            {
    1441                 errorArgument("Zero UUID argument '%s'", a->argv[2]);
     1447                errorArgument(CloudVM::tr("Zero UUID argument '%s'"), a->argv[2]);
    14421448                rc = E_FAIL;
    14431449                break;
    … …  
    14571463            if (a->argc != 5 && a->argc != 6 && a->argc != 7 && a->argc != 9)
    14581464            {
    1459                 errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     1465                errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    14601466                rc = E_FAIL;
    14611467                break;
    … …  
    14761482                if (RT_FAILURE(vrc))
    14771483                {
    1478                     errorSyntax(USAGE_CONTROLVM, "Either \"yes\" or \"no\" is expected");
     1484                    errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Either \"yes\" or \"no\" is expected"));
    14791485                    rc = E_FAIL;
    14801486                    break;
    … …  
    14931499            if (!pDisplay)
    14941500            {
    1495                 RTMsgError("Guest not running");
     1501                RTMsgError(CloudVM::tr("Guest not running"));
    14961502                rc = E_FAIL;
    14971503                break;
    … …  
    15051511            if (a->argc < 4)
    15061512            {
    1507                 errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     1513                errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    15081514                rc = E_FAIL;
    15091515                break;
    … …  
    15141520            if (!pDisplay)
    15151521            {
    1516                 RTMsgError("Guest not running");
     1522                RTMsgError(CloudVM::tr("Guest not running"));
    15171523                rc = E_FAIL;
    15181524                break;
    … …  
    15411547                else
    15421548                {
    1543                     errorSyntax(USAGE_CONTROLVM, "Display status must be <on> or <off>");
     1549                    errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Display status must be <on> or <off>"));
    15441550                    rc = E_FAIL;
    15451551                    break;
    … …  
    15561562                    if (argc < 7)
    15571563                    {
    1558                         errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     1564                        errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    15591565                        rc = E_FAIL;
    15601566                        break;
    … …  
    16001606                    && strcmp(a->argv[5 + (a->argc - 7)], "-allowlocallogon"))
    16011607                {
    1602                     errorArgument("Invalid parameter '%s'", a->argv[5]);
     1608                    errorArgument(CloudVM::tr("Invalid parameter '%s'"), a->argv[5]);
    16031609                    rc = E_FAIL;
    16041610                    break;
    … …  
    16121618                             && strcmp(a->argv[3], "--passwordfile"))))
    16131619            {
    1614                 errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     1620                errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    16151621                rc = E_FAIL;
    16161622                break;
    … …  
    16371643            if (!pGuest)
    16381644            {
    1639                 RTMsgError("Guest not running");
     1645                RTMsgError(CloudVM::tr("Guest not running"));
    16401646                rc = E_FAIL;
    16411647                break;
    … …  
    16521658            if (a->argc != 3)
    16531659            {
    1654                 errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     1660                errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    16551661                rc = E_FAIL;
    16561662                break;
    … …  
    16731679                if (!dvdMedium)
    16741680                {
    1675                     errorArgument("Invalid host DVD drive name \"%s\"",
     1681                    errorArgument(CloudVM::tr("Invalid host DVD drive name \"%s\""),
    16761682                                  a->argv[2] + 5);
    16771683                    rc = E_FAIL;
    … …  
    17091715            else
    17101716                uuid = Guid().toString();
    1711             CHECK_ERROR(sessionMachine, MountMedium(Bstr("IDE Controller"), 1, 0, uuid, FALSE /* aForce */));
     1717            CHECK_ERROR(sessionMachine, MountMedium(Bstr(CloudVM::tr("IDE Controller")), 1, 0, uuid, FALSE /* aForce */));
    17121718        }
    17131719        else if (!strcmp(a->argv[1], "floppyattach"))
    … …  
    17161722            if (a->argc != 3)
    17171723            {
    1718                 errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     1724                errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    17191725                rc = E_FAIL;
    17201726                break;
    … …  
    17361742                if (!floppyMedium)
    17371743                {
    1738                     errorArgument("Invalid host floppy drive name \"%s\"",
     1744                    errorArgument(CloudVM::tr("Invalid host floppy drive name \"%s\""),
    17391745                                  a->argv[2] + 5);
    17401746                    rc = E_FAIL;
    … …  
    17651771            }
    17661772            floppyMedium->COMGETTER(Id)(uuid.asOutParam());
    1767             CHECK_ERROR(sessionMachine, MountMedium(Bstr("Floppy Controller"), 0, 0, uuid, FALSE /* aForce */));
     1773            CHECK_ERROR(sessionMachine, MountMedium(Bstr(CloudVM::tr("Floppy Controller")), 0, 0, uuid, FALSE /* aForce */));
    17681774        }
    17691775#endif /* obsolete dvdattach/floppyattach */
    … …  
    17721778            if (a->argc != 3)
    17731779            {
    1774                 errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     1780                errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    17751781                rc = E_FAIL;
    17761782                break;
    … …  
    17811787            if (vrc != VINF_SUCCESS)
    17821788            {
    1783                 errorArgument("Error parsing guest memory balloon size '%s'", a->argv[2]);
     1789                errorArgument(CloudVM::tr("Error parsing guest memory balloon size '%s'"), a->argv[2]);
    17841790                rc = E_FAIL;
    17851791                break;
    … …  
    17921798                if (!pGuest)
    17931799                {
    1794                     RTMsgError("Guest not running");
     1800                    RTMsgError(CloudVM::tr("Guest not running"));
    17951801                    rc = E_FAIL;
    17961802                    break;
    … …  
    18621868
    18631869            rc = showProgress(progress);
    1864             CHECK_PROGRESS_ERROR(progress, ("Teleportation failed"));
     1870            CHECK_PROGRESS_ERROR(progress, (CloudVM::tr("Teleportation failed")));
    18651871        }
    18661872        else if (!strcmp(a->argv[1], "screenshotpng"))
    … …  
    18681874            if (a->argc <= 2 || a->argc > 4)
    18691875            {
    1870                 errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     1876                errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    18711877                rc = E_FAIL;
    18721878                break;
    … …  
    18791885                if (vrc != VINF_SUCCESS)
    18801886                {
    1881                     errorArgument("Error parsing display number '%s'", a->argv[3]);
     1887                    errorArgument(CloudVM::tr("Error parsing display number '%s'"), a->argv[3]);
    18821888                    rc = E_FAIL;
    18831889                    break;
    … …  
    18881894            if (!pDisplay)
    18891895            {
    1890                 RTMsgError("Guest not running");
     1896                RTMsgError(CloudVM::tr("Guest not running"));
    18911897                rc = E_FAIL;
    18921898                break;
    … …  
    19021908            if (RT_FAILURE(vrc))
    19031909            {
    1904                 RTMsgError("Failed to create file '%s' (%Rrc)", a->argv[2], vrc);
     1910                RTMsgError(CloudVM::tr("Failed to create file '%s' (%Rrc)"), a->argv[2], vrc);
    19051911                rc = E_FAIL;
    19061912                break;
    … …  
    19091915            if (RT_FAILURE(vrc))
    19101916            {
    1911                 RTMsgError("Failed to write screenshot to file '%s' (%Rrc)", a->argv[2], vrc);
     1917                RTMsgError(CloudVM::tr("Failed to write screenshot to file '%s' (%Rrc)"), a->argv[2], vrc);
    19121918                rc = E_FAIL;
    19131919            }
    … …  
    19201926            if (a->argc < 3)
    19211927            {
    1922                 errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     1928                errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    19231929                rc = E_FAIL;
    19241930                break;
    … …  
    19801986                        if (vrc != VINF_SUCCESS)
    19811987                        {
    1982                             errorArgument("Error parsing display number '%s'", a->argv[i]);
     1988                            errorArgument(CloudVM::tr("Error parsing display number '%s'"), a->argv[i]);
    19831989                            rc = E_FAIL;
    19841990                            break;
    … …  
    19861992                        if (iScreen >= cMonitors)
    19871993                        {
    1988                             errorArgument("Invalid screen ID specified '%u'", iScreen);
     1994                            errorArgument(CloudVM::tr("Invalid screen ID specified '%u'"), iScreen);
    19891995                            rc = E_FAIL;
    19901996                            break;
    … …  
    20012007                if (a->argc != 4)
    20022008                {
    2003                     errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     2009                    errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    20042010                    rc = E_FAIL;
    20052011                    break;
    … …  
    20142020                if (a->argc != 5)
    20152021                {
    2016                     errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     2022                    errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    20172023                    rc = E_FAIL;
    20182024                    break;
    … …  
    20232029                if (RT_FAILURE(vrc))
    20242030                {
    2025                     errorArgument("Error parsing video width '%s'", a->argv[3]);
     2031                    errorArgument(CloudVM::tr("Error parsing video width '%s'"), a->argv[3]);
    20262032                    rc = E_FAIL;
    20272033                    break;
    … …  
    20322038                if (RT_FAILURE(vrc))
    20332039                {
    2034                     errorArgument("Error parsing video height '%s'", a->argv[4]);
     2040                    errorArgument(CloudVM::tr("Error parsing video height '%s'"), a->argv[4]);
    20352041                    rc = E_FAIL;
    20362042                    break;
    … …  
    20472053                if (a->argc != 4)
    20482054                {
    2049                     errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     2055                    errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    20502056                    rc = E_FAIL;
    20512057                    break;
    … …  
    20562062                if (RT_FAILURE(vrc))
    20572063                {
    2058                     errorArgument("Error parsing video rate '%s'", a->argv[3]);
     2064                    errorArgument(CloudVM::tr("Error parsing video rate '%s'"), a->argv[3]);
    20592065                    rc = E_FAIL;
    20602066                    break;
    … …  
    20682074                if (a->argc != 4)
    20692075                {
    2070                     errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     2076                    errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    20712077                    rc = E_FAIL;
    20722078                    break;
    … …  
    20772083                if (RT_FAILURE(vrc))
    20782084                {
    2079                     errorArgument("Error parsing video FPS '%s'", a->argv[3]);
     2085                    errorArgument(CloudVM::tr("Error parsing video FPS '%s'"), a->argv[3]);
    20802086                    rc = E_FAIL;
    20812087                    break;
    … …  
    20892095                if (a->argc != 4)
    20902096                {
    2091                     errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     2097                    errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    20922098                    rc = E_FAIL;
    20932099                    break;
    … …  
    20982104                if (RT_FAILURE(vrc))
    20992105                {
    2100                     errorArgument("Error parsing maximum time '%s'", a->argv[3]);
     2106                    errorArgument(CloudVM::tr("Error parsing maximum time '%s'"), a->argv[3]);
    21012107                    rc = E_FAIL;
    21022108                    break;
    … …  
    21102116                if (a->argc != 4)
    21112117                {
    2112                     errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     2118                    errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    21132119                    rc = E_FAIL;
    21142120                    break;
    … …  
    21192125                if (RT_FAILURE(vrc))
    21202126                {
    2121                     errorArgument("Error parsing maximum file size '%s'", a->argv[3]);
     2127                    errorArgument(CloudVM::tr("Error parsing maximum file size '%s'"), a->argv[3]);
    21222128                    rc = E_FAIL;
    21232129                    break;
    … …  
    21312137                if (a->argc != 4)
    21322138                {
    2133                     errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     2139                    errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    21342140                    rc = E_FAIL;
    21352141                    break;
    … …  
    21452151            if (a->argc < 3)
    21462152            {
    2147                 errorArgument("Missing argument to '%s'", a->argv[1]);
     2153                errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[1]);
    21482154                rc = E_FAIL;
    21492155                break;
    … …  
    21542160            if (!pEmulatedUSB)
    21552161            {
    2156                 RTMsgError("Guest not running");
     2162                RTMsgError(CloudVM::tr("Guest not running"));
    21572163                rc = E_FAIL;
    21582164                break;
    … …  
    21872193            else
    21882194            {
    2189                 errorArgument("Invalid argument to '%s'", a->argv[1]);
     2195                errorArgument(CloudVM::tr("Invalid argument to '%s'"), a->argv[1]);
    21902196                rc = E_FAIL;
    21912197                break;
    … …  
    21972203                && a->argc != 6)
    21982204            {
    2199                 errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     2205                errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    22002206                break;
    22012207            }
    … …  
    22082214                        && strcmp(a->argv[5], "no")))
    22092215                {
    2210                     errorSyntax(USAGE_CONTROLVM, "Invalid parameters");
     2216                    errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Invalid parameters"));
    22112217                    break;
    22122218                }
    … …  
    22212227            {
    22222228                /* Get password from console. */
    2223                 RTEXITCODE rcExit = readPasswordFromConsole(&strPassword, "Enter password:");
     2229                RTEXITCODE rcExit = readPasswordFromConsole(&strPassword, CloudVM::tr("Enter password:"));
    22242230                if (rcExit == RTEXITCODE_FAILURE)
    22252231                    break;
    … …  
    22302236                if (rcExit == RTEXITCODE_FAILURE)
    22312237                {
    2232                     RTMsgError("Failed to read new password from file");
     2238                    RTMsgError(CloudVM::tr("Failed to read new password from file"));
    22332239                    break;
    22342240                }
    … …  
    22412247            if (a->argc != 3)
    22422248            {
    2243                 errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
     2249                errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Incorrect number of parameters"));
    22442250                break;
    22452251            }
    … …  
    22612267            if (a->argc < 3)
    22622268            {
    2263                 errorArgument("Missing argument to '%s'", a->argv[1]);
     2269                errorArgument(CloudVM::tr("Missing argument to '%s'"), a->argv[1]);
    22642270                rc = E_FAIL;
    22652271                break;
    … …  
    22752281                if (a->argc != 3)
    22762282                {
    2277                     errorArgument("Incorrect arguments to '%s'", a->argv[1]);
     2283                    errorArgument(CloudVM::tr("Incorrect arguments to '%s'"), a->argv[1]);
    22782284                    rc = E_FAIL;
    22792285                    break;
    … …  
    22902296                if (a->argc != 4)
    22912297                {
    2292                     errorArgument("Incorrect arguments to '%s'", a->argv[1]);
     2298                    errorArgument(CloudVM::tr("Incorrect arguments to '%s'"), a->argv[1]);
    22932299                    rc = E_FAIL;
    22942300                    break;
    … …  
    23312337                if (a->argc != 3)
    23322338                {
    2333                     errorArgument("Incorrect arguments to '%s'", a->argv[1]);
     2339                    errorArgument(CloudVM::tr("Incorrect arguments to '%s'"), a->argv[1]);
    23342340                    rc = E_FAIL;
    23352341                    break;
    … …  
    23432349            if (a->argc != 3)
    23442350            {
    2345                 errorArgument("Incorrect arguments to '%s'", a->argv[1]);
     2351                errorArgument(CloudVM::tr("Incorrect arguments to '%s'"), a->argv[1]);
    23462352                rc = E_FAIL;
    23472353                break;
    … …  
    23502356            if (enmPriority == VMProcPriority_Invalid)
    23512357            {
    2352                 errorArgument("Invalid vm-process-priority '%s'", a->argv[2]);
     2358                errorArgument(CloudVM::tr("Invalid vm-process-priority '%s'"), a->argv[2]);
    23532359                rc = E_FAIL;
    23542360            }
    … …  
    23632369            if (a->argc != 3)
    23642370            {
    2365                 errorArgument("Incorrect arguments to '%s'", a->argv[1]);
     2371                errorArgument(CloudVM::tr("Incorrect arguments to '%s'"), a->argv[1]);
    23662372                rc = E_FAIL;
    23672373                break;
    … …  
    23772383            else
    23782384            {
    2379                 errorArgument("Invalid value '%s'", Utf8Str(a->argv[2]).c_str());
     2385                errorArgument(CloudVM::tr("Invalid value '%s'"), Utf8Str(a->argv[2]).c_str());
    23802386                rc = E_FAIL;
    23812387                break;
    … …  
    23892395            if (a->argc != 3)
    23902396            {
    2391                 errorArgument("Incorrect arguments to '%s'", a->argv[1]);
     2397                errorArgument(CloudVM::tr("Incorrect arguments to '%s'"), a->argv[1]);
    23922398                rc = E_FAIL;
    23932399                break;
    … …  
    23982404            if (RT_FAILURE(vrc) || *pszNext != '\0')
    23992405            {
    2400                 errorArgument("Invalid autostart delay number '%s'", a->argv[2]);
     2406                errorArgument(CloudVM::tr("Invalid autostart delay number '%s'"), a->argv[2]);
    24012407                rc = E_FAIL;
    24022408                break;
    … …  
    24092415        else
    24102416        {
    2411             errorSyntax(USAGE_CONTROLVM, "Invalid parameter '%s'", a->argv[1]);
     2417            errorSyntax(USAGE_CONTROLVM, CloudVM::tr("Invalid parameter '%s'"), a->argv[1]);
    24122418            rc = E_FAIL;
    24132419        }

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageDHCPServer.cpp

    r86820 r92372  
    4444using namespace com;
    4545
     46DECLARE_TRANSLATION_CONTEXT(DHCPServer);
    4647
    4748/*********************************************************************************************************************************
    … …  
    6162        case DHCPD_CMD_COMMON_OPT_NETWORK: \
    6263            if ((a_pCtx)->pszInterface != NULL) \
    63                 return errorSyntax("Either --network or --interface, not both"); \
     64                return errorSyntax(DHCPServer::tr("Either --network or --interface, not both")); \
    6465            (a_pCtx)->pszNetwork = ValueUnion.psz; \
    6566            break; \
    6667        case DHCPD_CMD_COMMON_OPT_INTERFACE: \
    6768            if ((a_pCtx)->pszNetwork != NULL) \
    68                 return errorSyntax("Either --interface or --network, not both"); \
     69                return errorSyntax(DHCPServer::tr("Either --interface or --network, not both")); \
    6970            (a_pCtx)->pszInterface = ValueUnion.psz; \
    7071            break
    … …  
    176177            if (FAILED(hrc))
    177178            {
    178                 errorArgument("Failed to locate host-only interface '%s'", pCtx->pszInterface);
     179                errorArgument(DHCPServer::tr("Failed to locate host-only interface '%s'"), pCtx->pszInterface);
    179180                return ptrRet;
    180181            }
    … …  
    190191            return ptrRet;
    191192        if (pCtx->pszNetwork)
    192             errorArgument("Failed to find DHCP server for network '%s'", pCtx->pszNetwork);
     193            errorArgument(DHCPServer::tr("Failed to find DHCP server for network '%s'"), pCtx->pszNetwork);
    193194        else
    194             errorArgument("Failed to find DHCP server for host-only interface '%s' (network '%ls')",
     195            errorArgument(DHCPServer::tr("Failed to find DHCP server for host-only interface '%s' (network '%ls')"),
    195196                          pCtx->pszInterface, bstrNetName.raw());
    196197    }
    197198    else
    198         errorSyntax("You need to specify either --network or --interface to identify the DHCP server");
     199        errorSyntax(DHCPServer::tr("You need to specify either --network or --interface to identify the DHCP server"));
    199200    return ptrRet;
    200201}
    … …  
    470471                case 'g':   // --global     Sets the option scope to 'global'.
    471472                    if (fNeedValueOrRemove)
    472                         return errorSyntax("Incomplete option sequence preseeding '--global'");
     473                        return errorSyntax(DHCPServer::tr("Incomplete option sequence preseeding '--global'"));
    473474                    Scope.setGlobal();
    474475                    break;
    … …  
    476477                case 'G':   // --group
    477478                    if (fNeedValueOrRemove)
    478                         return errorSyntax("Incomplete option sequence preseeding '--group'");
     479                        return errorSyntax(DHCPServer::tr("Incomplete option sequence preseeding '--group'"));
    479480                    if (!*ValueUnion.psz)
    480                         return errorSyntax("Group name cannot be empty");
     481                        return errorSyntax(DHCPServer::tr("Group name cannot be empty"));
    481482                    Scope.setGroup(ValueUnion.psz);
    482483                    break;
    … …  
    484485                case 'E':   // --mac-address
    485486                    if (fNeedValueOrRemove)
    486                         return errorSyntax("Incomplete option sequence preseeding '--mac-address'");
     487                        return errorSyntax(DHCPServer::tr("Incomplete option sequence preseeding '--mac-address'"));
    487488                    RTStrPrintf(szMACAddress, sizeof(szMACAddress), "%RTmac", &ValueUnion.MacAddr);
    488489                    Scope.setMACAddress(szMACAddress);
    … …  
    491492                case 'M':   // --vm         Sets the option scope to ValueUnion.psz + 0.
    492493                    if (fNeedValueOrRemove)
    493                         return errorSyntax("Incomplete option sequence preseeding '--vm'");
     494                        return errorSyntax(DHCPServer::tr("Incomplete option sequence preseeding '--vm'"));
    494495                    Scope.setMachineNIC(ValueUnion.psz);
    495496                    break;
    … …  
    497498                case 'n':   // --nic        Sets the option scope to pszVmName + (ValueUnion.u8 - 1).
    498499                    if (Scope.getScope() != DHCPConfigScope_MachineNIC)
    499                         return errorSyntax("--nic option requires a --vm preceeding selecting the VM it should apply to");
     500                        return errorSyntax(DHCPServer::tr("--nic option requires a --vm preceeding selecting the VM it should apply to"));
    500501                    if (fNeedValueOrRemove)
    501                         return errorSyntax("Incomplete option sequence preseeding '--nic=%u", ValueUnion.u8);
     502                        return errorSyntax(DHCPServer::tr("Incomplete option sequence preseeding '--nic=%u"), ValueUnion.u8);
    502503                    if (ValueUnion.u8 < 1)
    503                         return errorSyntax("invalid NIC number: %u", ValueUnion.u8);
     504                        return errorSyntax(DHCPServer::tr("invalid NIC number: %u"), ValueUnion.u8);
    504505                    Scope.setMachineSlot(ValueUnion.u8 - 1);
    505506                    break;
    … …  
    536537                                                 NULL, &cbRet);
    537538                    if (RT_FAILURE(vrc))
    538                         return errorArgument("Malformed hex string given to --set-opt-hex %u: %s\n", idAddOpt, ValueUnion.psz);
     539                        return errorArgument(DHCPServer::tr("Malformed hex string given to --set-opt-hex %u: %s\n"),
     540                                             idAddOpt, ValueUnion.psz);
    539541                    if (iPass == 1)
    540542                    {
    … …  
    550552                case 'D':   // --del-opt num
    551553                    if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
    552                         return errorSyntax("--del-opt does not apply to the 'add' subcommand");
     554                        return errorSyntax(DHCPServer::tr("--del-opt does not apply to the 'add' subcommand"));
    553555                    if (iPass == 1)
    554556                    {
    … …  
    562564                case DHCP_ADDMOD_UNFORCE_OPTION:    // --unforce-opt
    563565                    if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
    564                         return errorSyntax("--unforce-opt does not apply to the 'add' subcommand");
     566                        return errorSyntax(DHCPServer::tr("--unforce-opt does not apply to the 'add' subcommand"));
    565567                    RT_FALL_THROUGH();
    566568                case DHCP_ADDMOD_UNSUPPRESS_OPTION: // --unsupress-opt
    567569                    if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
    568                         return errorSyntax("--unsuppress-opt does not apply to the 'add' subcommand");
     570                        return errorSyntax(DHCPServer::tr("--unsuppress-opt does not apply to the 'add' subcommand"));
    569571                    RT_FALL_THROUGH();
    570572                case DHCP_ADDMOD_FORCE_OPTION:      // --force-opt
    … …  
    624626                case DHCP_ADDMOD_ZAP_OPTIONS:
    625627                    if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
    626                         return errorSyntax("--zap-options does not apply to the 'add' subcommand");
     628                        return errorSyntax(DHCPServer::tr("--zap-options does not apply to the 'add' subcommand"));
    627629                    if (iPass == 1)
    628630                    {
    … …  
    666668                case 'R':   // --remove-config
    667669                    if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
    668                         return errorSyntax("--remove-config does not apply to the 'add' subcommand");
     670                        return errorSyntax(DHCPServer::tr("--remove-config does not apply to the 'add' subcommand"));
    669671                    if (Scope.getScope() == DHCPConfigScope_Global)
    670                         return errorSyntax("--remove-config cannot be applied to the global config");
     672                        return errorSyntax(DHCPServer::tr("--remove-config cannot be applied to the global config"));
    671673                    if (iPass == 1)
    672674                    {
    … …  
    681683                case 'f':   // --fixed-address
    682684                    if (Scope.getScope() != DHCPConfigScope_MachineNIC && Scope.getScope() != DHCPConfigScope_MAC)
    683                         return errorSyntax("--fixed-address can only be applied to a VM NIC or an MAC address");
     685                        return errorSyntax(DHCPServer::tr("--fixed-address can only be applied to a VM NIC or an MAC address"));
    684686                    if (iPass == 1)
    685687                    {
    … …  
    715717                {
    716718                    if (Scope.getScope() != DHCPConfigScope_Group)
    717                         return errorSyntax("A group must be selected to perform condition alterations.");
     719                        return errorSyntax(DHCPServer::tr("A group must be selected to perform condition alterations."));
    718720                    if (!*ValueUnion.psz)
    719                         return errorSyntax("Condition value cannot be empty"); /* or can it? */
     721                        return errorSyntax(DHCPServer::tr("Condition value cannot be empty")); /* or can it? */
    720722                    if (iPass != 1)
    721723                        break;
    … …  
    810812                            }
    811813                        if (!fFound)
    812                             rcExit = RTMsgErrorExitFailure("Could not find any condition of type %d with value '%s' to delete",
     814                            rcExit = RTMsgErrorExitFailure(DHCPServer::tr("Could not find any condition of type %d with value '%s' to delete"),
    813815                                                           enmType, ValueUnion.psz);
    814816                    }
    … …  
    818820                case DHCP_ADDMOD_ZAP_CONDITIONS:
    819821                    if (Scope.getScope() != DHCPConfigScope_Group)
    820                         return errorSyntax("--zap-conditions can only be with a group selected");
     822                        return errorSyntax(DHCPServer::tr("--zap-conditions can only be with a group selected"));
    821823                    if (iPass == 1)
    822824                    {
    … …  
    837839                case 'i':   // --id
    838840                    if (fNeedValueOrRemove)
    839                         return errorSyntax("Incomplete option sequence preseeding '--id=%u", ValueUnion.u8);
     841                        return errorSyntax(DHCPServer::tr("Incomplete option sequence preseeding '--id=%u"), ValueUnion.u8);
    840842                    u8OptId = ValueUnion.u8;
    841843                    fNeedValueOrRemove = true;
    … …  
    844846                case 'p':   // --value
    845847                    if (!fNeedValueOrRemove)
    846                         return errorSyntax("--value without --id=dhcp-opt-no");
     848                        return errorSyntax(DHCPServer::tr("--value without --id=dhcp-opt-no"));
    847849                    if (iPass == 1)
    848850                    {
    … …  
    858860                case 'r':   // --remove
    859861                    if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
    860                         return errorSyntax("--remove does not apply to the 'add' subcommand");
     862                        return errorSyntax(DHCPServer::tr("--remove does not apply to the 'add' subcommand"));
    861863                    if (!fNeedValueOrRemove)
    862                         return errorSyntax("--remove without --id=dhcp-opt-no");
     864                        return errorSyntax(DHCPServer::tr("--remove without --id=dhcp-opt-no"));
    863865
    864866                    if (iPass == 1)
    … …  
    885887         */
    886888        if (!pCtx->pszNetwork && !pCtx->pszInterface)
    887             return errorSyntax("You need to specify either --network or --interface to identify the DHCP server");
     889            return errorSyntax(DHCPServer::tr("You need to specify either --network or --interface to identify the DHCP server"));
    888890
    889891        if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
    890892        {
    891893            if (!pszServerIp)
    892                 rcExit = errorSyntax("Missing required option: --ip");
     894                rcExit = errorSyntax(DHCPServer::tr("Missing required option: --ip"));
    893895            if (!pszNetmask)
    894                 rcExit = errorSyntax("Missing required option: --netmask");
     896                rcExit = errorSyntax(DHCPServer::tr("Missing required option: --netmask"));
    895897            if (!pszLowerIp)
    896                 rcExit = errorSyntax("Missing required option: --lowerip");
     898                rcExit = errorSyntax(DHCPServer::tr("Missing required option: --lowerip"));
    897899            if (!pszUpperIp)
    898                 rcExit = errorSyntax("Missing required option: --upperip");
     900                rcExit = errorSyntax(DHCPServer::tr("Missing required option: --upperip"));
    899901            if (rcExit != RTEXITCODE_SUCCESS)
    900902                return rcExit;
    … …  
    914916            CHECK_ERROR(host, FindHostNetworkInterfaceByName(Bstr(pCtx->pszInterface).mutableRaw(), hif.asOutParam()));
    915917            if (FAILED(rc))
    916                 return errorArgument("Could not find interface '%s'", pCtx->pszInterface);
     918                return errorArgument(DHCPServer::tr("Could not find interface '%s'"), pCtx->pszInterface);
    917919
    918920            CHECK_ERROR(hif, COMGETTER(NetworkName) (NetName.asOutParam()));
    919921            if (FAILED(rc))
    920                 return errorArgument("Could not get network name for the interface '%s'", pCtx->pszInterface);
     922                return errorArgument(DHCPServer::tr("Could not get network name for the interface '%s'"), pCtx->pszInterface);
    921923        }
    922924        else
    … …  
    929931        {
    930932            if (SUCCEEDED(rc))
    931                 return errorArgument("DHCP server already exists");
     933                return errorArgument(DHCPServer::tr("DHCP server already exists"));
    932934
    933935            CHECK_ERROR(pCtx->pArg->virtualBox, CreateDHCPServer(NetName.mutableRaw(), ptrDHCPServer.asOutParam()));
    934936            if (FAILED(rc))
    935                 return errorArgument("Failed to create the DHCP server");
     937                return errorArgument(DHCPServer::tr("Failed to create the DHCP server"));
    936938        }
    937939        else if (FAILED(rc))
    938             return errorArgument("DHCP server does not exist");
     940            return errorArgument(DHCPServer::tr("DHCP server does not exist"));
    939941
    940942        /*
    … …  
    968970            CHECK_ERROR2_STMT(hrc, ptrDHCPServer, SetConfiguration(bstrServerIp.raw(), bstrNetmask.raw(),
    969971                                                                   bstrLowerIp.raw(), bstrUpperIp.raw()),
    970                               rcExit = errorArgument("Failed to set configuration (%ls, %ls, %ls, %ls)", bstrServerIp.raw(),
     972                              rcExit = errorArgument(DHCPServer::tr("Failed to set configuration (%ls, %ls, %ls, %ls)"), bstrServerIp.raw(),
    971973                                                     bstrNetmask.raw(), bstrLowerIp.raw(), bstrUpperIp.raw()));
    972974        }
    … …  
    10201022        if (SUCCEEDED(hrc))
    10211023            return RTEXITCODE_SUCCESS;
    1022         errorArgument("Failed to remove server");
     1024        errorArgument(DHCPServer::tr("Failed to remove server"));
    10231025    }
    10241026    return RTEXITCODE_FAILURE;
    … …  
    10871089        if (SUCCEEDED(hrc))
    10881090            return RTEXITCODE_SUCCESS;
    1089         errorArgument("Failed to start the server");
     1091        errorArgument(DHCPServer::tr("Failed to start the server"));
    10901092        GlueHandleComErrorNoCtx(ptrDHCPServer, hrc);
    10911093    }
    … …  
    11311133        if (SUCCEEDED(hrc))
    11321134            return RTEXITCODE_SUCCESS;
    1133         errorArgument("Failed to restart the server");
     1135        errorArgument(DHCPServer::tr("Failed to restart the server"));
    11341136        GlueHandleComErrorNoCtx(ptrDHCPServer, hrc);
    11351137    }
    … …  
    11751177        if (SUCCEEDED(hrc))
    11761178            return RTEXITCODE_SUCCESS;
    1177         errorArgument("Failed to stop the server");
     1179        errorArgument(DHCPServer::tr("Failed to stop the server"));
    11781180        GlueHandleComErrorNoCtx(ptrDHCPServer, hrc);
    11791181    }
    … …  
    12221224
    12231225    if (!fHaveMacAddress)
    1224         return errorSyntax("You need to specify a MAC address too look for");
     1226        return errorSyntax(DHCPServer::tr("You need to specify a MAC address too look for"));
    12251227
    12261228    /*
    … …  
    12501252        RTTimeToStringEx(RTTimeExplode(&Time, RTTimeSpecSetSeconds(&TimeSpec, secExpire)), szExpire, sizeof(szExpire), 0);
    12511253
    1252         RTPrintf("IP Address:  %ls\n"
    1253                  "MAC Address: %RTmac\n"
    1254                  "State:       %ls\n"
    1255                  "Issued:      %s (%RU64)\n"
    1256                  "Expire:      %s (%RU64)\n"
    1257                  "TTL:         %RU64 sec, currently %RU64 sec left\n",
     1254        RTPrintf(DHCPServer::tr("IP Address:  %ls\n"
     1255                                "MAC Address: %RTmac\n"
     1256                                "State:       %ls\n"
     1257                                "Issued:      %s (%RU64)\n"
     1258                                "Expire:      %s (%RU64)\n"
     1259                                "TTL:         %RU64 sec, currently %RU64 sec left\n"),
    12581260                 bstrAddress.raw(),
    12591261                 &MacAddress,
    … …  
    13301332    return errorNoSubcommand();
    13311333}
    1332 

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageDebugVM.cpp

    r89697 r92372  
    4040#include "VBoxManage.h"
    4141
     42DECLARE_TRANSLATION_CONTEXT(DebugVM);
     43
    4244
    4345/**
    … …  
    111113
    112114    if (!cRegisters)
    113         return errorSyntax("The getregisters sub-command takes at least one register name");
     115        return errorSyntax(DebugVM::tr("The getregisters sub-command takes at least one register name"));
    114116    return RTEXITCODE_SUCCESS;
    115117}
    … …  
    152154
    153155    if (!pszInfo)
    154         return errorSyntax("Must specify info item to display");
     156        return errorSyntax(DebugVM::tr("Must specify info item to display"));
    155157
    156158    /*
    … …  
    299301            case 'c':
    300302                if (pszCompression)
    301                     return errorSyntax("The --compression option has already been given");
     303                    return errorSyntax(DebugVM::tr("The --compression option has already been given"));
    302304                pszCompression = ValueUnion.psz;
    303305                break;
    304306            case 'f':
    305307                if (pszFilename)
    306                     return errorSyntax("The --filename option has already been given");
     308                    return errorSyntax(DebugVM::tr("The --filename option has already been given"));
    307309                pszFilename = ValueUnion.psz;
    308310                break;
    … …  
    313315
    314316    if (!pszFilename)
    315         return errorSyntax("The --filename option is required");
     317        return errorSyntax(DebugVM::tr("The --filename option is required"));
    316318
    317319    /*
    … …  
    321323    rc = RTPathAbs(pszFilename, szAbsFilename, sizeof(szAbsFilename));
    322324    if (RT_FAILURE(rc))
    323         return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathAbs failed on '%s': %Rrc", pszFilename, rc);
     325        return RTMsgErrorExit(RTEXITCODE_FAILURE, DebugVM::tr("RTPathAbs failed on '%s': %Rrc"), pszFilename, rc);
    324326
    325327    com::Bstr bstrFilename(szAbsFilename);
    … …  
    347349    com::Bstr bstrName;
    348350    CHECK_ERROR2I_RET(pDebugger, DetectOS(bstrName.asOutParam()), RTEXITCODE_FAILURE);
    349     RTPrintf("Detected: %ls\n", bstrName.raw());
     351    RTPrintf(DebugVM::tr("Detected: %ls\n"), bstrName.raw());
    350352    return RTEXITCODE_SUCCESS;
    351353}
    … …  
    367369    com::Bstr bstrVersion;
    368370    CHECK_ERROR2I_RET(pDebugger, COMGETTER(OSVersion)(bstrVersion.asOutParam()), RTEXITCODE_FAILURE);
    369     RTPrintf("Name:    %ls\n", bstrName.raw());
    370     RTPrintf("Version: %ls\n", bstrVersion.raw());
     371    RTPrintf(DebugVM::tr("Name:    %ls\n"), bstrName.raw());
     372    RTPrintf(DebugVM::tr("Version: %ls\n"), bstrVersion.raw());
    371373    return RTEXITCODE_SUCCESS;
    372374}
    … …  
    446448                const char *pszEqual = strchr(ValueUnion.psz, '=');
    447449                if (!pszEqual)
    448                     return errorSyntax("setregisters expects input on the form 'register=value' got '%s'", ValueUnion.psz);
     450                    return errorSyntax(DebugVM::tr("setregisters expects input on the form 'register=value' got '%s'"),
     451                                       ValueUnion.psz);
    449452                try
    450453                {
    … …  
    457460                catch (std::bad_alloc &)
    458461                {
    459                     RTMsgError("Out of memory\n");
     462                    RTMsgError(DebugVM::tr("Out of memory\n"));
    460463                    return RTEXITCODE_FAILURE;
    461464                }
    … …  
    469472
    470473    if (!aBstrNames.size())
    471         return errorSyntax("The setregisters sub-command takes at least one register name");
     474        return errorSyntax(DebugVM::tr("The setregisters sub-command takes at least one register name"));
    472475
    473476    /*
    … …  
    478481    {
    479482        CHECK_ERROR2I_RET(pDebugger, SetRegister(idCpu, aBstrNames[0], aBstrValues[0]), RTEXITCODE_FAILURE);
    480         RTPrintf("Successfully set %ls\n", aBstrNames[0]);
     483        RTPrintf(DebugVM::tr("Successfully set %ls\n"), aBstrNames[0]);
    481484    }
    482485    else
    … …  
    484487        CHECK_ERROR2I_RET(pDebugger, SetRegisters(idCpu, ComSafeArrayAsInParam(aBstrNames), ComSafeArrayAsInParam(aBstrValues)),
    485488                          RTEXITCODE_FAILURE);
    486         RTPrintf("Successfully set %u registers\n", aBstrNames.size());
     489        RTPrintf(DebugVM::tr("Successfully set %u registers\n"), aBstrNames.size());
    487490    }
    488491
    … …  
    511514    {
    512515        case DEBUGVM_SHOW_FLAGS_HUMAN_READABLE: RTPrintf(" %27s=%ls\n", pszVar, pbstrValue->raw()); break;
    513         case DEBUGVM_SHOW_FLAGS_SH_EXPORT:      RTPrintf("export %s='%ls'\n", pszVar, pbstrValue->raw()); break;
     516        case DEBUGVM_SHOW_FLAGS_SH_EXPORT:      RTPrintf(DebugVM::tr("export %s='%ls'\n"), pszVar, pbstrValue->raw()); break;
    514517        case DEBUGVM_SHOW_FLAGS_SH_EVAL:        RTPrintf("%s='%ls'\n", pszVar, pbstrValue->raw()); break;
    515         case DEBUGVM_SHOW_FLAGS_CMD_SET:        RTPrintf("set %s=%ls\n", pszVar, pbstrValue->raw()); break;
     518        case DEBUGVM_SHOW_FLAGS_CMD_SET:        RTPrintf(DebugVM::tr("set %s=%ls\n"), pszVar, pbstrValue->raw()); break;
    516519        default: AssertFailed();
    517520    }
    … …  
    528531{
    529532    if ((fFlags & DEBUGVM_SHOW_FLAGS_FMT_MASK) == DEBUGVM_SHOW_FLAGS_HUMAN_READABLE)
    530         RTPrintf("Debug logger settings:\n");
     533        RTPrintf(DebugVM::tr("Debug logger settings:\n"));
    531534
    532535    com::Bstr bstr;
    … …  
    552555{
    553556    if ((fFlags & DEBUGVM_SHOW_FLAGS_FMT_MASK) == DEBUGVM_SHOW_FLAGS_HUMAN_READABLE)
    554         RTPrintf("Release logger settings:\n");
     557        RTPrintf(DebugVM::tr("Release logger settings:\n"));
    555558
    556559    com::Bstr bstr;
    … …  
    626629                    rcExit = handleDebugVM_Show_LogRelSettings(pDebugger, fFlags);
    627630                else
    628                     rcExit = errorSyntax("The show sub-command has no idea what '%s' might be", ValueUnion.psz);
     631                    rcExit = errorSyntax(DebugVM::tr("The show sub-command has no idea what '%s' might be"), ValueUnion.psz);
    629632                if (rcExit != RTEXITCODE_SUCCESS)
    630633                    return rcExit;
    … …  
    700703                if (idCpu > 0)
    701704                    RTPrintf("\n");
    702                 RTPrintf("====================== CPU #%u ======================\n", idCpu);
     705                RTPrintf(DebugVM::tr("====================== CPU #%u ======================\n"), idCpu);
    703706            }
    704707            RTPrintf("%ls\n", bstrGuestStack.raw());
    … …  
    747750            case 'p':
    748751                if (pszPattern)
    749                     return errorSyntax("Multiple --pattern options are not permitted");
     752                    return errorSyntax(DebugVM::tr("Multiple --pattern options are not permitted"));
    750753                pszPattern = ValueUnion.psz;
    751754                break;
    … …  
    761764
    762765    if (fReset && fWithDescriptions)
    763         return errorSyntax("The --reset and --descriptions options does not mix");
     766        return errorSyntax(DebugVM::tr("The --reset and --descriptions options does not mix"));
    764767
    765768    /*
    … …  
    831834
    832835    if (!pszFilename)
    833         return errorSyntax("The --filename is missing");
     836        return errorSyntax(DebugVM::tr("The --filename is missing"));
    834837
    835838    /*
    … …  
    955958        }
    956959        else
    957             RTMsgError("Machine '%s' is not currently running.\n", pArgs->argv[0]);
     960            RTMsgError(DebugVM::tr("Machine '%s' is not currently running.\n"), pArgs->argv[0]);
    958961    }
    959962
    … …  
    962965    return rcExit;
    963966}
    964 

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp

    r91352 r92372  
    5454} MEDIUMCATEGORY;
    5555
    56 
     56DECLARE_TRANSLATION_CONTEXT(Disk);
    5757
    5858// funcs
    … …  
    6464    RT_NOREF(pvUser);
    6565    RTMsgErrorV(pszFormat, va);
    66     RTMsgError("Error code %Rrc at %s(%u) in function %s", rc, RT_SRC_POS_ARGS);
     66    RTMsgError(Disk::tr("Error code %Rrc at %s(%u) in function %s"), rc, RT_SRC_POS_ARGS);
    6767}
    6868
    … …  
    184184        {
    185185            if (!fSilent)
    186                 RTMsgError("Cannot convert filename \"%s\" to absolute path", pszFilenameOrUuid);
     186                RTMsgError(Disk::tr("Cannot convert filename \"%s\" to absolute path"), pszFilenameOrUuid);
    187187            return E_FAIL;
    188188        }
    … …  
    219219        if (RT_FAILURE(irc))
    220220        {
    221             RTMsgError("Cannot convert filename \"%s\" to absolute path", pszFilename);
     221            RTMsgError(Disk::tr("Cannot convert filename \"%s\" to absolute path"), pszFilename);
    222222            return E_FAIL;
    223223        }
    … …  
    288288            if (!m_pszFreeValue)
    289289            {
    290                 RTMsgError("Out of memory copying '%s'", m_pszValue);
     290                RTMsgError(Disk::tr("Out of memory copying '%s'"), m_pszValue);
    291291                throw std::bad_alloc();
    292292            }
    … …  
    328328            case 'H':   // disk
    329329                if (cmd != CMD_NONE)
    330                     return errorSyntax(USAGE_CREATEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
     330                    return errorSyntax(USAGE_CREATEMEDIUM, Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
    331331                cmd = CMD_DISK;
    332332                break;
    … …  
    334334            case 'D':   // DVD
    335335                if (cmd != CMD_NONE)
    336                     return errorSyntax(USAGE_CREATEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
     336                    return errorSyntax(USAGE_CREATEMEDIUM, Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
    337337                cmd = CMD_DVD;
    338338                break;
    … …  
    340340            case 'L':   // floppy
    341341                if (cmd != CMD_NONE)
    342                     return errorSyntax(USAGE_CREATEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
     342                    return errorSyntax(USAGE_CREATEMEDIUM, Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
    343343                cmd = CMD_FLOPPY;
    344344                break;
    … …  
    371371                char *pszValue = (char *)strchr(ValueUnion.psz, '=');
    372372                if (!pszValue)
    373                     return RTMsgErrorExitFailure("Invalid key value pair: No '='.");
     373                    return RTMsgErrorExitFailure(Disk::tr("Invalid key value pair: No '='."));
    374374
    375375                lstProperties.push_back(MediumProperty());
    … …  
    387387                    vrc = RTFileOpen(&hValueFile, pszValue, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
    388388                    if (RT_FAILURE(vrc))
    389                         return RTMsgErrorExitFailure("Cannot open replacement value file '%s': %Rrc", pszValue, vrc);
     389                        return RTMsgErrorExitFailure(Disk::tr("Cannot open replacement value file '%s': %Rrc"), pszValue, vrc);
    390390
    391391                    uint64_t cbValue = 0;
    … …  
    403403                                    rNewProp.m_pszFreeValue[rNewProp.m_cbValue] = '\0';
    404404                                else
    405                                     RTMsgError("Error reading replacement MBR file '%s': %Rrc", pszValue, vrc);
     405                                    RTMsgError(Disk::tr("Error reading replacement MBR file '%s': %Rrc"), pszValue, vrc);
    406406                            }
    407407                            else
    408                                 vrc = RTMsgErrorRc(VERR_NO_MEMORY, "Out of memory reading '%s': %Rrc", pszValue, vrc);
     408                                vrc = RTMsgErrorRc(VERR_NO_MEMORY, Disk::tr("Out of memory reading '%s': %Rrc"), pszValue, vrc);
    409409                        }
    410410                        else
    411                             vrc = RTMsgErrorRc(VERR_OUT_OF_RANGE, "Replacement value file '%s' is to big: %Rhcb, max 16MiB", pszValue, cbValue);
     411                            vrc = RTMsgErrorRc(VERR_OUT_OF_RANGE,
     412                                               Disk::tr("Replacement value file '%s' is to big: %Rhcb, max 16MiB"),
     413                                               pszValue, cbValue);
    412414                    }
    413415                    else
    414                         RTMsgError("Cannot get the size of the value file '%s': %Rrc", pszValue, vrc);
     416                        RTMsgError(Disk::tr("Cannot get the size of the value file '%s': %Rrc"), pszValue, vrc);
    415417                    RTFileClose(hValueFile);
    416418                    if (RT_FAILURE(vrc))
    … …  
    431433                vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
    432434                if (RT_FAILURE(vrc))
    433                     return errorArgument("Invalid medium variant '%s'", ValueUnion.psz);
     435                    return errorArgument(Disk::tr("Invalid medium variant '%s'"), ValueUnion.psz);
    434436                break;
    435437
    436438            case VINF_GETOPT_NOT_OPTION:
    437                 return errorSyntax(USAGE_CREATEMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
     439                return errorSyntax(USAGE_CREATEMEDIUM, Disk::tr("Invalid parameter '%s'"), ValueUnion.psz);
    438440
    439441            default:
    … …  
    441443                {
    442444                    if (RT_C_IS_PRINT(c))
    443                         return errorSyntax(USAGE_CREATEMEDIUM, "Invalid option -%c", c);
     445                        return errorSyntax(USAGE_CREATEMEDIUM, Disk::tr("Invalid option -%c"), c);
    444446                    else
    445                         return errorSyntax(USAGE_CREATEMEDIUM, "Invalid option case %i", c);
     447                        return errorSyntax(USAGE_CREATEMEDIUM, Disk::tr("Invalid option case %i"), c);
    446448                }
    447449                else if (c == VERR_GETOPT_UNKNOWN_OPTION)
    448                     return errorSyntax(USAGE_CREATEMEDIUM, "unknown option: %s\n", ValueUnion.psz);
     450                    return errorSyntax(USAGE_CREATEMEDIUM, Disk::tr("unknown option: %s\n"), ValueUnion.psz);
    449451                else if (ValueUnion.pDef)
    450452                    return errorSyntax(USAGE_CREATEMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
    451453                else
    452                     return errorSyntax(USAGE_CREATEMEDIUM, "error: %Rrs", c);
     454                    return errorSyntax(USAGE_CREATEMEDIUM, Disk::tr("error: %Rrs"), c);
    453455        }
    454456    }
    … …  
    461463    {
    462464        if (!filename || !*filename)
    463             return errorSyntax(USAGE_CREATEMEDIUM, "Parameters --filename is required");
     465            return errorSyntax(USAGE_CREATEMEDIUM, Disk::tr("Parameters --filename is required"));
    464466        if ((enmMediumVariant & MediumVariant_VmdkRawDisk) == 0 && size == 0)
    465             return errorSyntax(USAGE_CREATEMEDIUM, "Parameters --size is required");
     467            return errorSyntax(USAGE_CREATEMEDIUM, Disk::tr("Parameters --size is required"));
    466468        if (!format || !*format)
    467469        {
    … …  
    481483        if (   !filename
    482484            || !*filename)
    483             return errorSyntax(USAGE_CREATEMEDIUM, "Parameters --filename is required");
     485            return errorSyntax(USAGE_CREATEMEDIUM, Disk::tr("Parameters --filename is required"));
    484486        size = 0;
    485487        if (cmd != CMD_DISK)
    486             return errorSyntax(USAGE_CREATEMEDIUM, "Creating a differencing medium is only supported for hard disks");
     488            return errorSyntax(USAGE_CREATEMEDIUM, Disk::tr("Creating a differencing medium is only supported for hard disks"));
    487489        enmMediumVariant = MediumVariant_Diff;
    488490        if (!format || !*format)
    … …  
    503505            return RTEXITCODE_FAILURE;
    504506        if (pParentMedium.isNull())
    505             return RTMsgErrorExit(RTEXITCODE_FAILURE, "Invalid parent hard disk reference, avoiding crash");
     507            return RTMsgErrorExit(RTEXITCODE_FAILURE, Disk::tr("Invalid parent hard disk reference, avoiding crash"));
    506508        MediumState_T state;
    507509        CHECK_ERROR(pParentMedium, COMGETTER(State)(&state));
    … …  
    585587                    }
    586588                if (!fPropertyFound)
    587                     return RTMsgErrorExit(RTEXITCODE_FAILURE, "The %s is not found in the property list of the requested medium format.",
     589                    return RTMsgErrorExit(RTEXITCODE_FAILURE,
     590                                          Disk::tr("The %s is not found in the property list of the requested medium format."),
    588591                                          pszKey);
    589592                if (!fBinary)
    … …  
    595598                    HRESULT hrc = bstrBase64Value.base64Encode(it->m_pszValue, it->m_cbValue);
    596599                    if (FAILED(hrc))
    597                         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Base64 encoding of the property %s failed. (%Rhrc)",
     600                        return RTMsgErrorExit(RTEXITCODE_FAILURE, Disk::tr("Base64 encoding of the property %s failed. (%Rhrc)"),
    598601                                              pszKey, hrc);
    599602                    CHECK_ERROR2I_RET(pMedium, SetProperty(Bstr(pszKey).raw(), bstrBase64Value.raw()), RTEXITCODE_FAILURE);
    … …  
    619622        {
    620623            rc = showProgress(pProgress);
    621             CHECK_PROGRESS_ERROR(pProgress, ("Failed to create medium"));
     624            CHECK_PROGRESS_ERROR(pProgress, (Disk::tr("Failed to create medium")));
    622625        }
    623626    }
    … …  
    627630        Bstr uuid;
    628631        CHECK_ERROR(pMedium, COMGETTER(Id)(uuid.asOutParam()));
    629         RTPrintf("Medium created. UUID: %s\n", Utf8Str(uuid).c_str());
     632        RTPrintf(Disk::tr("Medium created. UUID: %s\n"), Utf8Str(uuid).c_str());
    630633
    631634        //CHECK_ERROR(pMedium, Close());
    … …  
    696699            case 'H':   // disk
    697700                if (cmd != CMD_NONE)
    698                     return errorSyntax(USAGE_MODIFYMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
     701                    return errorSyntax(USAGE_MODIFYMEDIUM, Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
    699702                cmd = CMD_DISK;
    700703                break;
    … …  
    702705            case 'D':   // DVD
    703706                if (cmd != CMD_NONE)
    704                     return errorSyntax(USAGE_MODIFYMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
     707                    return errorSyntax(USAGE_MODIFYMEDIUM, Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
    705708                cmd = CMD_DVD;
    706709                break;
    … …  
    708711            case 'L':   // floppy
    709712                if (cmd != CMD_NONE)
    710                     return errorSyntax(USAGE_MODIFYMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
     713                    return errorSyntax(USAGE_MODIFYMEDIUM, Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
    711714                cmd = CMD_FLOPPY;
    712715                break;
    … …  
    715718                vrc = parseMediumType(ValueUnion.psz, &enmMediumType);
    716719                if (RT_FAILURE(vrc))
    717                     return errorArgument("Invalid medium type '%s'", ValueUnion.psz);
     720                    return errorArgument(Disk::tr("Invalid medium type '%s'"), ValueUnion.psz);
    718721                fModifyMediumType = true;
    719722                break;
    … …  
    722725                vrc = parseBool(ValueUnion.psz, &AutoReset);
    723726                if (RT_FAILURE(vrc))
    724                     return errorArgument("Invalid autoreset parameter '%s'", ValueUnion.psz);
     727                    return errorArgument(Disk::tr("Invalid autoreset parameter '%s'"), ValueUnion.psz);
    725728                fModifyAutoReset = true;
    726729                break;
    … …  
    745748                    else
    746749                    {
    747                         errorArgument("Invalid --property argument '%s'", ValueUnion.psz);
     750                        errorArgument(Disk::tr("Invalid --property argument '%s'"), ValueUnion.psz);
    748751                        rc = E_FAIL;
    749752                    }
    … …  
    752755                else
    753756                {
    754                     RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for medium property '%s'\n", ValueUnion.psz);
     757                    RTStrmPrintf(g_pStdErr, Disk::tr("Error: Failed to allocate memory for medium property '%s'\n"),
     758                                 ValueUnion.psz);
    755759                    rc = E_FAIL;
    756760                }
    … …  
    795799                    pszFilenameOrUuid = ValueUnion.psz;
    796800                else
    797                     return errorSyntax(USAGE_MODIFYMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
     801                    return errorSyntax(USAGE_MODIFYMEDIUM, Disk::tr("Invalid parameter '%s'"), ValueUnion.psz);
    798802                break;
    799803
    … …  
    802806                {
    803807                    if (RT_C_IS_PRINT(c))
    804                         return errorSyntax(USAGE_MODIFYMEDIUM, "Invalid option -%c", c);
     808                        return errorSyntax(USAGE_MODIFYMEDIUM, Disk::tr("Invalid option -%c"), c);
    805809                    else
    806                         return errorSyntax(USAGE_MODIFYMEDIUM, "Invalid option case %i", c);
     810                        return errorSyntax(USAGE_MODIFYMEDIUM, Disk::tr("Invalid option case %i"), c);
    807811                }
    808812                else if (c == VERR_GETOPT_UNKNOWN_OPTION)
    809                     return errorSyntax(USAGE_MODIFYMEDIUM, "unknown option: %s\n", ValueUnion.psz);
     813                    return errorSyntax(USAGE_MODIFYMEDIUM, Disk::tr("unknown option: %s\n"), ValueUnion.psz);
    810814                else if (ValueUnion.pDef)
    811815                    return errorSyntax(USAGE_MODIFYMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
    812816                else
    813                     return errorSyntax(USAGE_MODIFYMEDIUM, "error: %Rrs", c);
     817                    return errorSyntax(USAGE_MODIFYMEDIUM, Disk::tr("error: %Rrs"), c);
    814818        }
    815819    }
    … …  
    819823
    820824    if (!pszFilenameOrUuid)
    821         return errorSyntax(USAGE_MODIFYMEDIUM, "Medium name or UUID required");
     825        return errorSyntax(USAGE_MODIFYMEDIUM, Disk::tr("Medium name or UUID required"));
    822826
    823827    if (!fModifyMediumType
    … …  
    830834        && !fModifyDescription
    831835        )
    832         return errorSyntax(USAGE_MODIFYMEDIUM, "No operation specified");
     836        return errorSyntax(USAGE_MODIFYMEDIUM, Disk::tr("No operation specified"));
    833837
    834838    /* Always open the medium if necessary, there is no other way. */
    … …  
    851855    if (pMedium.isNull())
    852856    {
    853         RTMsgError("Invalid medium reference, avoiding crash");
     857        RTMsgError(Disk::tr("Invalid medium reference, avoiding crash"));
    854858        return RTEXITCODE_FAILURE;
    855859    }
    … …  
    872876        if (cbResize > (uint64_t)logicalSize * 1000)
    873877        {
    874             RTMsgError("Error: Attempt to resize the medium from %RU64.%RU64 MB to %RU64.%RU64 MB. Use --resizebyte if this is intended!\n",
    875                     logicalSize / _1M, (logicalSize % _1M) / (_1M / 10), cbResize / _1M, (cbResize % _1M) / (_1M / 10));
     878            RTMsgError(Disk::tr("Error: Attempt to resize the medium from %RU64.%RU64 MB to %RU64.%RU64 MB. Use --resizebyte if this is intended!\n"),
     879                       logicalSize / _1M, (logicalSize % _1M) / (_1M / 10), cbResize / _1M, (cbResize % _1M) / (_1M / 10));
    876880            return RTEXITCODE_FAILURE;
    877881        }
    … …  
    906910        {
    907911            if (rc == E_NOTIMPL)
    908                 RTMsgError("Compact medium operation is not implemented!");
     912                RTMsgError(Disk::tr("Compact medium operation is not implemented!"));
    909913            else if (rc == VBOX_E_NOT_SUPPORTED)
    910                 RTMsgError("Compact medium operation for this format is not implemented yet!");
     914                RTMsgError(Disk::tr("Compact medium operation for this format is not implemented yet!"));
    911915            else if (!pProgress.isNull())
    912                 CHECK_PROGRESS_ERROR(pProgress, ("Failed to compact medium"));
     916                CHECK_PROGRESS_ERROR(pProgress, (Disk::tr("Failed to compact medium")));
    913917            else
    914                 RTMsgError("Failed to compact medium!");
     918                RTMsgError(Disk::tr("Failed to compact medium!"));
    915919        }
    916920    }
    … …  
    925929        {
    926930            if (!pProgress.isNull())
    927                 CHECK_PROGRESS_ERROR(pProgress, ("Failed to resize medium"));
     931                CHECK_PROGRESS_ERROR(pProgress, (Disk::tr("Failed to resize medium")));
    928932            else if (rc == E_NOTIMPL)
    929                 RTMsgError("Resize medium operation is not implemented!");
     933                RTMsgError(Disk::tr("Resize medium operation is not implemented!"));
    930934            else if (rc == VBOX_E_NOT_SUPPORTED)
    931                 RTMsgError("Resize medium operation for this format is not implemented yet!");
     935                RTMsgError(Disk::tr("Resize medium operation for this format is not implemented yet!"));
    932936            else
    933                 RTMsgError("Failed to resize medium!");
     937                RTMsgError(Disk::tr("Failed to resize medium!"));
    934938        }
    935939    }
    … …  
    947951            {
    948952                rc = showProgress(pProgress);
    949                 CHECK_PROGRESS_ERROR(pProgress, ("Failed to move medium"));
     953                CHECK_PROGRESS_ERROR(pProgress, (Disk::tr("Failed to move medium")));
    950954            }
    951955
    … …  
    953957            CHECK_ERROR_BREAK(pMedium, COMGETTER(Id)(uuid.asOutParam()));
    954958
    955             RTPrintf("Move medium with UUID %s finished\n", Utf8Str(uuid).c_str());
     959            RTPrintf(Disk::tr("Move medium with UUID %s finished\n"), Utf8Str(uuid).c_str());
    956960        }
    957961        while (0);
    … …  
    966970        Bstr uuid;
    967971        CHECK_ERROR(pMedium, COMGETTER(Id)(uuid.asOutParam()));
    968         RTPrintf("Set new location of medium with UUID %s finished\n", Utf8Str(uuid).c_str());
     972        RTPrintf(Disk::tr("Set new location of medium with UUID %s finished\n"), Utf8Str(uuid).c_str());
    969973    }
    970974
    … …  
    973977        CHECK_ERROR(pMedium, COMSETTER(Description)(Bstr(pszNewLocation).raw()));
    974978
    975         RTPrintf("Medium description has been changed.\n");
     979        RTPrintf(Disk::tr("Medium description has been changed.\n"));
    976980    }
    977981
    … …  
    10211025            case 'd':   // disk
    10221026                if (cmd != CMD_NONE)
    1023                     return errorSyntax(USAGE_CLONEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
     1027                    return errorSyntax(USAGE_CLONEMEDIUM, Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
    10241028                cmd = CMD_DISK;
    10251029                break;
    … …  
    10271031            case 'D':   // DVD
    10281032                if (cmd != CMD_NONE)
    1029                     return errorSyntax(USAGE_CLONEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
     1033                    return errorSyntax(USAGE_CLONEMEDIUM, Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
    10301034                cmd = CMD_DVD;
    10311035                break;
    … …  
    10331037            case 'f':   // floppy
    10341038                if (cmd != CMD_NONE)
    1035                     return errorSyntax(USAGE_CLONEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
     1039                    return errorSyntax(USAGE_CLONEMEDIUM, Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
    10361040                cmd = CMD_FLOPPY;
    10371041                break;
    … …  
    10561060                vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
    10571061                if (RT_FAILURE(vrc))
    1058                     return errorArgument("Invalid medium variant '%s'", ValueUnion.psz);
     1062                    return errorArgument(Disk::tr("Invalid medium variant '%s'"), ValueUnion.psz);
    10591063                break;
    10601064
    … …  
    10651069                    pszDst = ValueUnion.psz;
    10661070                else
    1067                     return errorSyntax(USAGE_CLONEMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
     1071                    return errorSyntax(USAGE_CLONEMEDIUM, Disk::tr("Invalid parameter '%s'"), ValueUnion.psz);
    10681072                break;
    10691073
    … …  
    10721076                {
    10731077                    if (RT_C_IS_GRAPH(c))
    1074                         return errorSyntax(USAGE_CLONEMEDIUM, "unhandled option: -%c", c);
     1078                        return errorSyntax(USAGE_CLONEMEDIUM, Disk::tr("unhandled option: -%c"), c);
    10751079                    else
    1076                         return errorSyntax(USAGE_CLONEMEDIUM, "unhandled option: %i", c);
     1080                        return errorSyntax(USAGE_CLONEMEDIUM, Disk::tr("unhandled option: %i"), c);
    10771081                }
    10781082                else if (c == VERR_GETOPT_UNKNOWN_OPTION)
    1079                     return errorSyntax(USAGE_CLONEMEDIUM, "unknown option: %s", ValueUnion.psz);
     1083                    return errorSyntax(USAGE_CLONEMEDIUM, Disk::tr("unknown option: %s"), ValueUnion.psz);
    10801084                else if (ValueUnion.pDef)
    10811085                    return errorSyntax(USAGE_CLONEMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
    10821086                else
    1083                     return errorSyntax(USAGE_CLONEMEDIUM, "error: %Rrs", c);
     1087                    return errorSyntax(USAGE_CLONEMEDIUM, Disk::tr("error: %Rrs"), c);
    10841088        }
    10851089    }
    … …  
    10881092        cmd = CMD_DISK;
    10891093    if (!pszSrc)
    1090         return errorSyntax(USAGE_CLONEMEDIUM, "Mandatory UUID or input file parameter missing");
     1094        return errorSyntax(USAGE_CLONEMEDIUM, Disk::tr("Mandatory UUID or input file parameter missing"));
    10911095    if (!pszDst)
    1092         return errorSyntax(USAGE_CLONEMEDIUM, "Mandatory output file parameter missing");
     1096        return errorSyntax(USAGE_CLONEMEDIUM, Disk::tr("Mandatory output file parameter missing"));
    10931097    if (fExisting && (!format.isEmpty() || enmMediumVariant != MediumVariant_Standard))
    1094         return errorSyntax(USAGE_CLONEMEDIUM, "Specified options which cannot be used with --existing");
     1098        return errorSyntax(USAGE_CLONEMEDIUM, Disk::tr("Specified options which cannot be used with --existing"));
    10951099
    10961100    ComPtr<IMedium> pSrcMedium;
    … …  
    11801184
    11811185        rc = showProgress(pProgress);
    1182         CHECK_PROGRESS_ERROR_BREAK(pProgress, ("Failed to clone medium"));
     1186        CHECK_PROGRESS_ERROR_BREAK(pProgress, (Disk::tr("Failed to clone medium")));
    11831187
    11841188        Bstr uuid;
    11851189        CHECK_ERROR_BREAK(pDstMedium, COMGETTER(Id)(uuid.asOutParam()));
    11861190
    1187         RTPrintf("Clone medium created in format '%ls'. UUID: %s\n",
     1191        RTPrintf(Disk::tr("Clone medium created in format '%ls'. UUID: %s\n"),
    11881192                 format.raw(), Utf8Str(uuid).c_str());
    11891193    }
    … …  
    12291233            case 'u':   // --uuid
    12301234                if (RT_FAILURE(RTUuidFromStr(&uuid, ValueUnion.psz)))
    1231                     return errorSyntax(USAGE_CONVERTFROMRAW, "Invalid UUID '%s'", ValueUnion.psz);
     1235                    return errorSyntax(USAGE_CONVERTFROMRAW, Disk::tr("Invalid UUID '%s'"), ValueUnion.psz);
    12321236                pUuid = &uuid;
    12331237                break;
    … …  
    12411245                rc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
    12421246                if (RT_FAILURE(rc))
    1243                     return errorArgument("Invalid medium variant '%s'", ValueUnion.psz);
     1247                    return errorArgument(Disk::tr("Invalid medium variant '%s'"), ValueUnion.psz);
    12441248                /// @todo cleaner solution than assuming 1:1 mapping?
    12451249                uImageFlags = (unsigned)enmMediumVariant;
    … …  
    12571261                    filesize = ValueUnion.psz;
    12581262                else
    1259                     return errorSyntax(USAGE_CONVERTFROMRAW, "Invalid parameter '%s'", ValueUnion.psz);
     1263                    return errorSyntax(USAGE_CONVERTFROMRAW, Disk::tr("Invalid parameter '%s'"), ValueUnion.psz);
    12601264                break;
    12611265
    … …  
    12661270
    12671271    if (!srcfilename || !dstfilename || (fReadFromStdIn && !filesize))
    1268         return errorSyntax(USAGE_CONVERTFROMRAW, "Incorrect number of parameters");
    1269     RTStrmPrintf(g_pStdErr, "Converting from raw image file=\"%s\" to file=\"%s\"...\n",
     1272        return errorSyntax(USAGE_CONVERTFROMRAW, Disk::tr("Incorrect number of parameters"));
     1273    RTStrmPrintf(g_pStdErr, Disk::tr("Converting from raw image file=\"%s\" to file=\"%s\"...\n"),
    12701274                 srcfilename, dstfilename);
    12711275
    … …  
    12891293    if (RT_FAILURE(rc))
    12901294    {
    1291         RTMsgError("Cannot open file \"%s\": %Rrc", srcfilename, rc);
     1295        RTMsgError(Disk::tr("Cannot open file \"%s\": %Rrc"), srcfilename, rc);
    12921296        goto out;
    12931297    }
    … …  
    13011305    if (RT_FAILURE(rc))
    13021306    {
    1303         RTMsgError("Cannot get image size for file \"%s\": %Rrc", srcfilename, rc);
     1307        RTMsgError(Disk::tr("Cannot get image size for file \"%s\": %Rrc"), srcfilename, rc);
    13041308        goto out;
    13051309    }
    13061310
    1307     RTStrmPrintf(g_pStdErr, "Creating %s image with size %RU64 bytes (%RU64MB)...\n",
    1308                  (uImageFlags & VD_IMAGE_FLAGS_FIXED) ? "fixed" : "dynamic", cbFile, (cbFile + _1M - 1) / _1M);
     1311    RTStrmPrintf(g_pStdErr, Disk::tr("Creating %s image with size %RU64 bytes (%RU64MB)...\n"),
     1312                 (uImageFlags & VD_IMAGE_FLAGS_FIXED) ? Disk::tr("fixed") : Disk::tr("dynamic"),
     1313                 cbFile, (cbFile + _1M - 1) / _1M);
    13091314    char pszComment[256];
    1310     RTStrPrintf(pszComment, sizeof(pszComment), "Converted image from %s", srcfilename);
     1315    RTStrPrintf(pszComment, sizeof(pszComment), Disk::tr("Converted image from %s"), srcfilename);
    13111316    rc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
    13121317    if (RT_FAILURE(rc))
    13131318    {
    1314         RTMsgError("Cannot create the virtual disk container: %Rrc", rc);
     1319        RTMsgError(Disk::tr("Cannot create the virtual disk container: %Rrc"), rc);
    13151320        goto out;
    13161321    }
    … …  
    13301335    if (RT_FAILURE(rc))
    13311336    {
    1332         RTMsgError("Cannot create the disk image \"%s\": %Rrc", dstfilename, rc);
     1337        RTMsgError(Disk::tr("Cannot create the disk image \"%s\": %Rrc"), dstfilename, rc);
    13331338        goto out;
    13341339    }
    … …  
    13401345    {
    13411346        rc = VERR_NO_MEMORY;
    1342         RTMsgError("Out of memory allocating buffers for image \"%s\": %Rrc", dstfilename, rc);
     1347        RTMsgError(Disk::tr("Out of memory allocating buffers for image \"%s\": %Rrc"), dstfilename, rc);
    13431348        goto out;
    13441349    }
    … …  
    13591364        if (RT_FAILURE(rc))
    13601365        {
    1361             RTMsgError("Failed to write to disk image \"%s\": %Rrc", dstfilename, rc);
     1366            RTMsgError(Disk::tr("Failed to write to disk image \"%s\": %Rrc"), dstfilename, rc);
    13621367            goto out;
    13631368        }
    … …  
    13881393        RTPrintf("UUID:           %ls\n", uuid.raw());
    13891394        if (pszParentUUID)
    1390             RTPrintf("Parent UUID:    %s\n", pszParentUUID);
     1395            RTPrintf(Disk::tr("Parent UUID:    %s\n"), pszParentUUID);
    13911396
    13921397        /* check for accessibility */
    13931398        MediumState_T enmState;
    13941399        CHECK_ERROR_BREAK(pMedium, RefreshState(&enmState));
    1395         const char *pszState = "unknown";
     1400        const char *pszState = Disk::tr("unknown");
    13961401        switch (enmState)
    13971402        {
    13981403            case MediumState_NotCreated:
    1399                 pszState = "not created";
     1404                pszState = Disk::tr("not created");
    14001405                break;
    14011406            case MediumState_Created:
    1402                 pszState = "created";
     1407                pszState = Disk::tr("created");
    14031408                break;
    14041409            case MediumState_LockedRead:
    1405                 pszState = "locked read";
     1410                pszState = Disk::tr("locked read");
    14061411                break;
    14071412            case MediumState_LockedWrite:
    1408                 pszState = "locked write";
     1413                pszState = Disk::tr("locked write");
    14091414                break;
    14101415            case MediumState_Inaccessible:
    1411                 pszState = "inaccessible";
     1416                pszState = Disk::tr("inaccessible");
    14121417                break;
    14131418            case MediumState_Creating:
    1414                 pszState = "creating";
     1419                pszState = Disk::tr("creating");
    14151420                break;
    14161421            case MediumState_Deleting:
    1417                 pszState = "deleting";
     1422                pszState = Disk::tr("deleting");
    14181423                break;
    14191424#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
    … …  
    14211426#endif
    14221427        }
    1423         RTPrintf("State:          %s\n", pszState);
     1428        RTPrintf(Disk::tr("State:          %s\n"), pszState);
    14241429
    14251430        if (fOptLong && enmState == MediumState_Inaccessible)
    … …  
    14271432            Bstr err;
    14281433            CHECK_ERROR_BREAK(pMedium, COMGETTER(LastAccessError)(err.asOutParam()));
    1429             RTPrintf("Access Error:   %ls\n", err.raw());
     1434            RTPrintf(Disk::tr("Access Error:   %ls\n"), err.raw());
    14301435        }
    14311436
    … …  
    14351440            pMedium->COMGETTER(Description)(description.asOutParam());
    14361441            if (!description.isEmpty())
    1437                 RTPrintf("Description:    %ls\n", description.raw());
     1442                RTPrintf(Disk::tr("Description:    %ls\n"), description.raw());
    14381443        }
    14391444
    14401445        MediumType_T type;
    14411446        pMedium->COMGETTER(Type)(&type);
    1442         const char *typeStr = "unknown";
     1447        const char *typeStr = Disk::tr("unknown");
    14431448        switch (type)
    14441449        {
    14451450            case MediumType_Normal:
    14461451                if (pszParentUUID && Guid(pszParentUUID).isValid())
    1447                     typeStr = "normal (differencing)";
     1452                    typeStr = Disk::tr("normal (differencing)");
    14481453                else
    1449                     typeStr = "normal (base)";
     1454                    typeStr = Disk::tr("normal (base)");
    14501455                break;
    14511456            case MediumType_Immutable:
    1452                 typeStr = "immutable";
     1457                typeStr = Disk::tr("immutable");
    14531458                break;
    14541459            case MediumType_Writethrough:
    1455                 typeStr = "writethrough";
     1460                typeStr = Disk::tr("writethrough");
    14561461                break;
    14571462            case MediumType_Shareable:
    1458                 typeStr = "shareable";
     1463                typeStr = Disk::tr("shareable");
    14591464                break;
    14601465            case MediumType_Readonly:
    1461                 typeStr = "readonly";
     1466                typeStr = Disk::tr("readonly");
    14621467                break;
    14631468            case MediumType_MultiAttach:
    1464                 typeStr = "multiattach";
     1469                typeStr = Disk::tr("multiattach");
    14651470                break;
    14661471#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
    … …  
    14681473#endif
    14691474        }
    1470         RTPrintf("Type:           %s\n", typeStr);
     1475        RTPrintf(Disk::tr("Type:           %s\n"), typeStr);
    14711476
    14721477        /* print out information specific for differencing media */
    … …  
    14751480            BOOL autoReset = FALSE;
    14761481            pMedium->COMGETTER(AutoReset)(&autoReset);
    1477             RTPrintf("Auto-Reset:     %s\n", autoReset ? "on" : "off");
     1482            RTPrintf(Disk::tr("Auto-Reset:     %s\n"), autoReset ? Disk::tr("on") : Disk::tr("off"));
    14781483        }
    14791484
    14801485        Bstr loc;
    14811486        pMedium->COMGETTER(Location)(loc.asOutParam());
    1482         RTPrintf("Location:       %ls\n", loc.raw());
     1487        RTPrintf(Disk::tr("Location:       %ls\n"), loc.raw());
    14831488
    14841489        Bstr format;
    14851490        pMedium->COMGETTER(Format)(format.asOutParam());
    1486         RTPrintf("Storage format: %ls\n", format.raw());
     1491        RTPrintf(Disk::tr("Storage format: %ls\n"), format.raw());
    14871492
    14881493        if (fOptLong)
    … …  
    14951500                variant |= safeArray_variant[i];
    14961501
    1497             const char *variantStr = "unknown";
     1502            const char *variantStr = Disk::tr("unknown");
    14981503            switch (variant & ~(MediumVariant_Fixed | MediumVariant_Diff))
    14991504            {
    15001505                case MediumVariant_VmdkSplit2G:
    1501                     variantStr = "split2G";
     1506                    variantStr = Disk::tr("split2G");
    15021507                    break;
    15031508                case MediumVariant_VmdkStreamOptimized:
    1504                     variantStr = "streamOptimized";
     1509                    variantStr = Disk::tr("streamOptimized");
    15051510                    break;
    15061511                case MediumVariant_VmdkESX:
    1507                     variantStr = "ESX";
     1512                    variantStr = Disk::tr("ESX");
    15081513                    break;
    15091514                case MediumVariant_Standard:
    1510                     variantStr = "default";
     1515                    variantStr = Disk::tr("default");
    15111516                    break;
    15121517            }
    1513             const char *variantTypeStr = "dynamic";
     1518            const char *variantTypeStr = Disk::tr("dynamic");
    15141519            if (variant & MediumVariant_Fixed)
    1515                 variantTypeStr = "fixed";
     1520                variantTypeStr = Disk::tr("fixed");
    15161521            else if (variant & MediumVariant_Diff)
    1517                 variantTypeStr = "differencing";
    1518             RTPrintf("Format variant: %s %s\n", variantTypeStr, variantStr);
     1522                variantTypeStr = Disk::tr("differencing");
     1523            RTPrintf(Disk::tr("Format variant: %s %s\n"), variantTypeStr, variantStr);
    15191524        }
    15201525
    15211526        LONG64 logicalSize;
    15221527        pMedium->COMGETTER(LogicalSize)(&logicalSize);
    1523         RTPrintf("Capacity:       %lld MBytes\n", logicalSize >> 20);
     1528        RTPrintf(Disk::tr("Capacity:       %lld MBytes\n"), logicalSize >> 20);
    15241529        if (fOptLong)
    15251530        {
    15261531            LONG64 actualSize;
    15271532            pMedium->COMGETTER(Size)(&actualSize);
    1528             RTPrintf("Size on disk:   %lld MBytes\n", actualSize >> 20);
     1533            RTPrintf(Disk::tr("Size on disk:   %lld MBytes\n"), actualSize >> 20);
    15291534        }
    15301535
    … …  
    15341539        if (SUCCEEDED(rc2))
    15351540        {
    1536             RTPrintf("Encryption:     enabled\n");
     1541            RTPrintf(Disk::tr("Encryption:     enabled\n"));
    15371542            if (fOptLong)
    15381543            {
    1539                 RTPrintf("Cipher:         %ls\n", strCipher.raw());
    1540                 RTPrintf("Password ID:    %ls\n", strPasswordId.raw());
     1544                RTPrintf(Disk::tr("Cipher:         %ls\n"), strCipher.raw());
     1545                RTPrintf(Disk::tr("Password ID:    %ls\n"), strPasswordId.raw());
    15411546            }
    15421547        }
    15431548        else
    1544             RTPrintf("Encryption:     disabled\n");
     1549            RTPrintf(Disk::tr("Encryption:     disabled\n"));
    15451550
    15461551        if (fOptLong)
    … …  
    15581563                    value = values[i];
    15591564                RTPrintf("%s%ls=%ls\n",
    1560                          fFirst ? "Property:       " : "                ",
     1565                         fFirst ? Disk::tr("Property:       ") : "                ",
    15611566                         names[i], value.raw());
    15621567                fFirst = false;
    … …  
    15791584                    pMachine->COMGETTER(Id)(uuid.asOutParam());
    15801585                    RTPrintf("%s%ls (UUID: %ls)",
    1581                              fFirst ? "In use by VMs:  " : "                ",
     1586                             fFirst ? Disk::tr("In use by VMs:  ") : "                ",
    15821587                             name.raw(), machineIds[i]);
    15831588                    fFirst = false;
    … …  
    16141619                    pChild->COMGETTER(Id)(childUUID.asOutParam());
    16151620                    RTPrintf("%s%ls\n",
    1616                              fFirst ? "Child UUIDs:    " : "                ",
     1621                             fFirst ? Disk::tr("Child UUIDs:    ") : "                ",
    16171622                             childUUID.raw());
    16181623                    fFirst = false;
    … …  
    16551660            case 'd':   // disk
    16561661                if (cmd != CMD_NONE)
    1657                     return errorSyntax(USAGE_SHOWMEDIUMINFO, "Only one command can be specified: '%s'", ValueUnion.psz);
     1662                    return errorSyntax(USAGE_SHOWMEDIUMINFO, Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
    16581663                cmd = CMD_DISK;
    16591664                break;
    … …  
    16611666            case 'D':   // DVD
    16621667                if (cmd != CMD_NONE)
    1663                     return errorSyntax(USAGE_SHOWMEDIUMINFO, "Only one command can be specified: '%s'", ValueUnion.psz);
     1668                    return errorSyntax(USAGE_SHOWMEDIUMINFO, Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
    16641669                cmd = CMD_DVD;
    16651670                break;
    … …  
    16671672            case 'f':   // floppy
    16681673                if (cmd != CMD_NONE)
    1669                     return errorSyntax(USAGE_SHOWMEDIUMINFO, "Only one command can be specified: '%s'", ValueUnion.psz);
     1674                    return errorSyntax(USAGE_SHOWMEDIUMINFO, Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
    16701675                cmd = CMD_FLOPPY;
    16711676                break;
    … …  
    16751680                    pszFilenameOrUuid = ValueUnion.psz;
    16761681                else
    1677                     return errorSyntax(USAGE_SHOWMEDIUMINFO, "Invalid parameter '%s'", ValueUnion.psz);
     1682                    return errorSyntax(USAGE_SHOWMEDIUMINFO, Disk::tr("Invalid parameter '%s'"), ValueUnion.psz);
    16781683                break;
    16791684
    … …  
    16821687                {
    16831688                    if (RT_C_IS_PRINT(c))
    1684                         return errorSyntax(USAGE_SHOWMEDIUMINFO, "Invalid option -%c", c);
     1689                        return errorSyntax(USAGE_SHOWMEDIUMINFO, Disk::tr("Invalid option -%c"), c);
    16851690                    else
    1686                         return errorSyntax(USAGE_SHOWMEDIUMINFO, "Invalid option case %i", c);
     1691                        return errorSyntax(USAGE_SHOWMEDIUMINFO, Disk::tr("Invalid option case %i"), c);
    16871692                }
    16881693                else if (c == VERR_GETOPT_UNKNOWN_OPTION)
    1689                     return errorSyntax(USAGE_SHOWMEDIUMINFO, "unknown option: %s\n", ValueUnion.psz);
     1694                    return errorSyntax(USAGE_SHOWMEDIUMINFO, Disk::tr("unknown option: %s\n"), ValueUnion.psz);
    16901695                else if (ValueUnion.pDef)
    16911696                    return errorSyntax(USAGE_SHOWMEDIUMINFO, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
    16921697                else
    1693                     return errorSyntax(USAGE_SHOWMEDIUMINFO, "error: %Rrs", c);
     1698                    return errorSyntax(USAGE_SHOWMEDIUMINFO, Disk::tr("error: %Rrs"), c);
    16941699        }
    16951700    }
    … …  
    17001705    /* check for required options */
    17011706    if (!pszFilenameOrUuid)
    1702         return errorSyntax(USAGE_SHOWMEDIUMINFO, "Medium name or UUID required");
     1707        return errorSyntax(USAGE_SHOWMEDIUMINFO, Disk::tr("Medium name or UUID required"));
    17031708
    17041709    HRESULT rc = S_OK; /* Prevents warning. */
    … …  
    17201725        return RTEXITCODE_FAILURE;
    17211726
    1722     Utf8Str strParentUUID("base");
     1727    Utf8Str strParentUUID(Disk::tr("base"));
    17231728    ComPtr<IMedium> pParent;
    17241729    pMedium->COMGETTER(Parent)(pParent.asOutParam());
    … …  
    17671772            case 'd':   // disk
    17681773                if (cmd != CMD_NONE)
    1769                     return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
     1774                    return errorSyntax(USAGE_CLOSEMEDIUM, Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
    17701775                cmd = CMD_DISK;
    17711776                break;
    … …  
    17731778            case 'D':   // DVD
    17741779                if (cmd != CMD_NONE)
    1775                     return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
     1780                    return errorSyntax(USAGE_CLOSEMEDIUM, Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
    17761781                cmd = CMD_DVD;
    17771782                break;
    … …  
    17791784            case 'f':   // floppy
    17801785                if (cmd != CMD_NONE)
    1781                     return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
     1786                    return errorSyntax(USAGE_CLOSEMEDIUM, Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
    17821787                cmd = CMD_FLOPPY;
    17831788                break;
    … …  
    17911796                    pszFilenameOrUuid = ValueUnion.psz;
    17921797                else
    1793                     return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
     1798                    return errorSyntax(USAGE_CLOSEMEDIUM, Disk::tr("Invalid parameter '%s'"), ValueUnion.psz);
    17941799                break;
    17951800
    … …  
    17981803                {
    17991804                    if (RT_C_IS_PRINT(c))
    1800                         return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid option -%c", c);
     1805                        return errorSyntax(USAGE_CLOSEMEDIUM, Disk::tr("Invalid option -%c"), c);
    18011806                    else
    1802                         return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid option case %i", c);
     1807                        return errorSyntax(USAGE_CLOSEMEDIUM, Disk::tr("Invalid option case %i"), c);
    18031808                }
    18041809                else if (c == VERR_GETOPT_UNKNOWN_OPTION)
    1805                     return errorSyntax(USAGE_CLOSEMEDIUM, "unknown option: %s\n", ValueUnion.psz);
     1810                    return errorSyntax(USAGE_CLOSEMEDIUM, Disk::tr("unknown option: %s\n"), ValueUnion.psz);
    18061811                else if (ValueUnion.pDef)
    18071812                    return errorSyntax(USAGE_CLOSEMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
    18081813                else
    1809                     return errorSyntax(USAGE_CLOSEMEDIUM, "error: %Rrs", c);
     1814                    return errorSyntax(USAGE_CLOSEMEDIUM, Disk::tr("error: %Rrs"), c);
    18101815        }
    18111816    }
    … …  
    18151820        cmd = CMD_DISK;
    18161821    if (!pszFilenameOrUuid)
    1817         return errorSyntax(USAGE_CLOSEMEDIUM, "Medium name or UUID required");
     1822        return errorSyntax(USAGE_CLOSEMEDIUM, Disk::tr("Medium name or UUID required"));
    18181823
    18191824    ComPtr<IMedium> pMedium;
    … …  
    18401845            {
    18411846                rc = showProgress(pProgress);
    1842                 CHECK_PROGRESS_ERROR(pProgress, ("Failed to delete medium"));
     1847                CHECK_PROGRESS_ERROR(pProgress, (Disk::tr("Failed to delete medium")));
    18431848            }
    18441849            else
    1845                 RTMsgError("Failed to delete medium. Error code %Rrc", rc);
     1850                RTMsgError(Disk::tr("Failed to delete medium. Error code %Rrc"), rc);
    18461851        }
    18471852        CHECK_ERROR(pMedium, Close());
    … …  
    18791884        else
    18801885        {
    1881             AssertMsgFailed(("unexpected parameter %s\n", pszCmd));
     1886            AssertMsgFailed((Disk::tr("unexpected parameter %s\n"), pszCmd));
    18821887            cmd = CMD_DISK;
    18831888        }
    … …  
    18921897
    18931898    if (a->argc == 0)
    1894         return errorSyntax(USAGE_MEDIUMPROPERTY, "Missing action");
     1899        return errorSyntax(USAGE_MEDIUMPROPERTY, Disk::tr("Missing action"));
    18951900
    18961901    pszAction = a->argv[0];
    … …  
    18981903        && RTStrICmp(pszAction, "get")
    18991904        && RTStrICmp(pszAction, "delete"))
    1900         return errorSyntax(USAGE_MEDIUMPROPERTY, "Invalid action given: %s", pszAction);
     1905        return errorSyntax(USAGE_MEDIUMPROPERTY, Disk::tr("Invalid action given: %s"), pszAction);
    19011906
    19021907    if (   (   !RTStrICmp(pszAction, "set")
    … …  
    19041909        || (   RTStrICmp(pszAction, "set")
    19051910            && a->argc != 3))
    1906         return errorSyntax(USAGE_MEDIUMPROPERTY, "Invalid number of arguments given for action: %s", pszAction);
     1911        return errorSyntax(USAGE_MEDIUMPROPERTY, Disk::tr("Invalid number of arguments given for action: %s"), pszAction);
    19071912
    19081913    pszFilenameOrUuid = a->argv[1];
    … …  
    20032008                    pszFilenameOrUuid = ValueUnion.psz;
    20042009                else
    2005                     return errorSyntax(USAGE_ENCRYPTMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
     2010                    return errorSyntax(USAGE_ENCRYPTMEDIUM, Disk::tr("Invalid parameter '%s'"), ValueUnion.psz);
    20062011                break;
    20072012
    … …  
    20102015                {
    20112016                    if (RT_C_IS_PRINT(c))
    2012                         return errorSyntax(USAGE_ENCRYPTMEDIUM, "Invalid option -%c", c);
     2017                        return errorSyntax(USAGE_ENCRYPTMEDIUM, Disk::tr("Invalid option -%c"), c);
    20132018                    else
    2014                         return errorSyntax(USAGE_ENCRYPTMEDIUM, "Invalid option case %i", c);
     2019                        return errorSyntax(USAGE_ENCRYPTMEDIUM, Disk::tr("Invalid option case %i"), c);
    20152020                }
    20162021                else if (c == VERR_GETOPT_UNKNOWN_OPTION)
    2017                     return errorSyntax(USAGE_ENCRYPTMEDIUM, "unknown option: %s\n", ValueUnion.psz);
     2022                    return errorSyntax(USAGE_ENCRYPTMEDIUM, Disk::tr("unknown option: %s\n"), ValueUnion.psz);
    20182023                else if (ValueUnion.pDef)
    20192024                    return errorSyntax(USAGE_ENCRYPTMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
    20202025                else
    2021                     return errorSyntax(USAGE_ENCRYPTMEDIUM, "error: %Rrs", c);
     2026                    return errorSyntax(USAGE_ENCRYPTMEDIUM, Disk::tr("error: %Rrs"), c);
    20222027        }
    20232028    }
    20242029
    20252030    if (!pszFilenameOrUuid)
    2026         return errorSyntax(USAGE_ENCRYPTMEDIUM, "Disk name or UUID required");
     2031        return errorSyntax(USAGE_ENCRYPTMEDIUM, Disk::tr("Disk name or UUID required"));
    20272032
    20282033    if (!pszPasswordNew && !pszPasswordOld)
    2029         return errorSyntax(USAGE_ENCRYPTMEDIUM, "No password specified");
     2034        return errorSyntax(USAGE_ENCRYPTMEDIUM, Disk::tr("No password specified"));
    20302035
    20312036    if (   (pszPasswordNew && !pszNewPasswordId)
    20322037        || (!pszPasswordNew && pszNewPasswordId))
    2033         return errorSyntax(USAGE_ENCRYPTMEDIUM, "A new password must always have a valid identifier set at the same time");
     2038        return errorSyntax(USAGE_ENCRYPTMEDIUM,
     2039                           Disk::tr("A new password must always have a valid identifier set at the same time"));
    20342040
    20352041    if (pszPasswordNew)
    … …  
    20382044        {
    20392045            /* Get password from console. */
    2040             RTEXITCODE rcExit = readPasswordFromConsole(&strPasswordNew, "Enter new password:");
     2046            RTEXITCODE rcExit = readPasswordFromConsole(&strPasswordNew, Disk::tr("Enter new password:"));
    20412047            if (rcExit == RTEXITCODE_FAILURE)
    20422048                return rcExit;
    … …  
    20472053            if (rcExit == RTEXITCODE_FAILURE)
    20482054            {
    2049                 RTMsgError("Failed to read new password from file");
     2055                RTMsgError(Disk::tr("Failed to read new password from file"));
    20502056                return rcExit;
    20512057            }
    … …  
    20582064        {
    20592065            /* Get password from console. */
    2060             RTEXITCODE rcExit = readPasswordFromConsole(&strPasswordOld, "Enter old password:");
     2066            RTEXITCODE rcExit = readPasswordFromConsole(&strPasswordOld, Disk::tr("Enter old password:"));
    20612067            if (rcExit == RTEXITCODE_FAILURE)
    20622068                return rcExit;
    … …  
    20672073            if (rcExit == RTEXITCODE_FAILURE)
    20682074            {
    2069                 RTMsgError("Failed to read old password from file");
     2075                RTMsgError(Disk::tr("Failed to read old password from file"));
    20702076                return rcExit;
    20712077            }
    … …  
    20802086        return RTEXITCODE_FAILURE;
    20812087    if (hardDisk.isNull())
    2082         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Invalid hard disk reference, avoiding crash");
     2088        return RTMsgErrorExit(RTEXITCODE_FAILURE, Disk::tr("Invalid hard disk reference, avoiding crash"));
    20832089
    20842090    ComPtr<IProgress> progress;
    … …  
    20912097    {
    20922098        if (rc == E_NOTIMPL)
    2093             RTMsgError("Encrypt hard disk operation is not implemented!");
     2099            RTMsgError(Disk::tr("Encrypt hard disk operation is not implemented!"));
    20942100        else if (rc == VBOX_E_NOT_SUPPORTED)
    2095             RTMsgError("Encrypt hard disk operation for this cipher is not implemented yet!");
     2101            RTMsgError(Disk::tr("Encrypt hard disk operation for this cipher is not implemented yet!"));
    20962102        else if (!progress.isNull())
    2097             CHECK_PROGRESS_ERROR(progress, ("Failed to encrypt hard disk"));
     2103            CHECK_PROGRESS_ERROR(progress, (Disk::tr("Failed to encrypt hard disk")));
    20982104        else
    2099             RTMsgError("Failed to encrypt hard disk!");
     2105            RTMsgError(Disk::tr("Failed to encrypt hard disk!"));
    21002106    }
    21012107
    … …  
    21112117
    21122118    if (a->argc != 2)
    2113         return errorSyntax(USAGE_MEDIUMENCCHKPWD, "Invalid number of arguments: %d", a->argc);
     2119        return errorSyntax(USAGE_MEDIUMENCCHKPWD, Disk::tr("Invalid number of arguments: %d"), a->argc);
    21142120
    21152121    pszFilenameOrUuid = a->argv[0];
    … …  
    21182124    {
    21192125        /* Get password from console. */
    2120         RTEXITCODE rcExit = readPasswordFromConsole(&strPassword, "Enter password:");
     2126        RTEXITCODE rcExit = readPasswordFromConsole(&strPassword, Disk::tr("Enter password:"));
    21212127        if (rcExit == RTEXITCODE_FAILURE)
    21222128            return rcExit;
    … …  
    21272133        if (rcExit == RTEXITCODE_FAILURE)
    21282134        {
    2129             RTMsgError("Failed to read password from file");
     2135            RTMsgError(Disk::tr("Failed to read password from file"));
    21302136            return rcExit;
    21312137        }
    … …  
    21392145        return RTEXITCODE_FAILURE;
    21402146    if (hardDisk.isNull())
    2141         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Invalid hard disk reference, avoiding crash");
     2147        return RTMsgErrorExit(RTEXITCODE_FAILURE, Disk::tr("Invalid hard disk reference, avoiding crash"));
    21422148
    21432149    CHECK_ERROR(hardDisk, CheckEncryptionPassword(Bstr(strPassword).raw()));
    21442150    if (SUCCEEDED(rc))
    2145         RTPrintf("The given password is correct\n");
     2151        RTPrintf(Disk::tr("The given password is correct\n"));
    21462152    return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    21472153}
    … …  
    22212227     */
    22222228    if (pCommonOpts->enmDeviceType == DeviceType_Null)
    2223         return errorSyntax("No medium specified!");
     2229        return errorSyntax(Disk::tr("No medium specified!"));
    22242230
    22252231    /*
    … …  
    22322238        RTEXITCODE rcExit;
    22332239        if (pCommonOpts->pszPasswordFile[0] == '-' && pCommonOpts->pszPasswordFile[1] == '\0')
    2234             rcExit = readPasswordFromConsole(&strPassword, "Enter encryption password:");
     2240            rcExit = readPasswordFromConsole(&strPassword, Disk::tr("Enter encryption password:"));
    22352241        else
    22362242            rcExit = readPasswordFile(pCommonOpts->pszPasswordFile, &strPassword);
    … …  
    23842390            int vrc = RTStrmOpen(pszOutput, fHex ? "wt" : "wb", &pOut);
    23852391            if (RT_FAILURE(vrc))
    2386                 rcExit = RTMsgErrorExitFailure("Error opening '%s' for writing: %Rrc", pszOutput, vrc);
     2392                rcExit = RTMsgErrorExitFailure(Disk::tr("Error opening '%s' for writing: %Rrc"), pszOutput, vrc);
    23872393        }
    23882394        else
    … …  
    24002406            if (off >= cbMedium)
    24012407            {
    2402                 RTMsgWarning("Specified offset (%#RX64) is beyond the end of the medium (%#RX64)", off, cbMedium);
     2408                RTMsgWarning(Disk::tr("Specified offset (%#RX64) is beyond the end of the medium (%#RX64)"), off, cbMedium);
    24032409                cb = 0;
    24042410            }
    … …  
    24302436                if (FAILED(hrc))
    24312437                {
    2432                     RTStrPrintf(szLine, sizeof(szLine), "Read(%zu bytes at %#RX64)", cbToRead, off);
     2438                    RTStrPrintf(szLine, sizeof(szLine), Disk::tr("Read(%zu bytes at %#RX64)", "", cbToRead), cbToRead, off);
    24332439                    com::GlueHandleComError(ptrMediumIO, szLine, hrc, __FILE__, __LINE__);
    24342440                    break;
    … …  
    24592465                                if (cDuplicates > 0)
    24602466                                {
    2461                                     RTStrmPrintf(pOut, "**********  <ditto x %RU64>\n", cDuplicates);
     2467                                    RTStrmPrintf(pOut, Disk::tr("**********  <ditto x %RU64>\n"), cDuplicates);
    24622468                                    cDuplicates = 0;
    24632469                                }
    … …  
    25082514                    if (RT_FAILURE(vrc))
    25092515                    {
    2510                         rcExit = RTMsgErrorExitFailure("Error writing to '%s': %Rrc", pszOutput, vrc);
     2516                        rcExit = RTMsgErrorExitFailure(Disk::tr("Error writing to '%s': %Rrc"), pszOutput, vrc);
    25112517                        break;
    25122518                    }
    … …  
    25162522                if (cbReturned != cbToRead)
    25172523                {
    2518                     rcExit = RTMsgErrorExitFailure("Expected read() at offset %RU64 (%#RX64) to return %#zx bytes, only got %#zx!\n",
     2524                    rcExit = RTMsgErrorExitFailure(Disk::tr("Expected read() at offset %RU64 (%#RX64) to return %#zx bytes, only got %#zx!\n",
     2525                                                            "", cbReturned),
    25192526                                                   off, off, cbReturned, cbToRead);
    25202527                    break;
    … …  
    25312538                int vrc = RTStrmClose(pOut);
    25322539                if (RT_FAILURE(vrc))
    2533                     rcExit = RTMsgErrorExitFailure("Error closing '%s': %Rrc", pszOutput, vrc);
     2540                    rcExit = RTMsgErrorExitFailure(Disk::tr("Error closing '%s': %Rrc"), pszOutput, vrc);
    25342541            }
    25352542            else if (!fHex)
    … …  
    25792586                int vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
    25802587                if (RT_FAILURE(vrc))
    2581                     return errorArgument("Invalid medium variant '%s'", ValueUnion.psz);
     2588                    return errorArgument(Disk::tr("Invalid medium variant '%s'"), ValueUnion.psz);
    25822589                break;
    25832590            }
    … …  
    26042611            int vrc = RTStrmOpen(pszOutput, "wb", &pOut);
    26052612            if (RT_FAILURE(vrc))
    2606                 rcExit = RTMsgErrorExitFailure("Error opening '%s' for writing: %Rrc", pszOutput, vrc);
     2613                rcExit = RTMsgErrorExitFailure(Disk::tr("Error opening '%s' for writing: %Rrc"), pszOutput, vrc);
    26072614        }
    26082615        else
    … …  
    26482655                        if (RT_FAILURE(vrc))
    26492656                        {
    2650                             rcExit = RTMsgErrorExitFailure("Error writing to '%s': %Rrc", pszOutput, vrc);
     2657                            rcExit = RTMsgErrorExitFailure(Disk::tr("Error writing to '%s': %Rrc"), pszOutput, vrc);
    26512658                            break;
    26522659                        }
    … …  
    26692676                int vrc = RTStrmClose(pOut);
    26702677                if (RT_FAILURE(vrc))
    2671                     rcExit = RTMsgErrorExitFailure("Error closing '%s': %Rrc", pszOutput, vrc);
     2678                    rcExit = RTMsgErrorExitFailure(Disk::tr("Error closing '%s': %Rrc"), pszOutput, vrc);
    26722679            }
    26732680            else

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.cpp

    r89981 r92372  
    6565
    6666using namespace com;
    67 
    6867
    6968/*********************************************************************************************************************************
    … …  
    218217#endif /* VBOX_ONLY_DOCS */
    219218
     219DECLARE_TRANSLATION_CONTEXT(GuestCtrl);
    220220
    221221void usageGuestControl(PRTSTREAM pStrm, const char *pcszSep1, const char *pcszSep2, uint64_t fSubcommandScope)
    … …  
    233233    if (~fAnonSubCmds & fSubcommandScope)
    234234        RTStrmPrintf(pStrm,
    235                      "%s guestcontrol %s    <uuid|vmname> [--verbose|-v] [--quiet|-q]\n"
    236                      "                              [--user[name] <name>] [--domain <domain>]\n"
    237                      "                              [--passwordfile <file> | --password <password>]\n%s",
     235                     GuestCtrl::tr("%s guestcontrol %s    <uuid|vmname> [--verbose|-v] [--quiet|-q]\n"
     236                                   "                              [--user[name] <name>] [--domain <domain>]\n"
     237                                   "                              [--passwordfile <file> | --password <password>]\n%s"),
    238238                     pcszSep1, pcszSep2, (fSubcommandScope & RTMSGREFENTRYSTR_SCOPE_MASK) == RTMSGREFENTRYSTR_SCOPE_GLOBAL ? "\n" : "");
    239239    if (fSubcommandScope & HELP_SCOPE_GSTCTRL_RUN)
    240240        RTStrmPrintf(pStrm,
    241                      "                              run [common-options]\n"
    242                      "                              [--exe <path to executable>] [--timeout <msec>]\n"
    243                      "                              [-E|--putenv <NAME>[=<VALUE>]] [--unquoted-args]\n"
    244                      "                              [--ignore-operhaned-processes] [--profile]\n"
    245                      "                              [--no-wait-stdout|--wait-stdout]\n"
    246                      "                              [--no-wait-stderr|--wait-stderr]\n"
    247                      "                              [--dos2unix] [--unix2dos]\n"
    248                      "                              -- <program/arg0> [argument1] ... [argumentN]]\n"
    249                      "\n");
     241                     GuestCtrl::tr("                              run [common-options]\n"
     242                                   "                              [--exe <path to executable>] [--timeout <msec>]\n"
     243                                   "                              [-E|--putenv <NAME>[=<VALUE>]] [--unquoted-args]\n"
     244                                   "                              [--ignore-operhaned-processes] [--profile]\n"
     245                                   "                              [--no-wait-stdout|--wait-stdout]\n"
     246                                   "                              [--no-wait-stderr|--wait-stderr]\n"
     247                                   "                              [--dos2unix] [--unix2dos]\n"
     248                                   "                              -- <program/arg0> [argument1] ... [argumentN]]\n"
     249                                   "\n"));
    250250    if (fSubcommandScope & HELP_SCOPE_GSTCTRL_START)
    251251        RTStrmPrintf(pStrm,
    252                      "                              start [common-options]\n"
    253                      "                              [--exe <path to executable>] [--timeout <msec>]\n"
    254                      "                              [-E|--putenv <NAME>[=<VALUE>]] [--unquoted-args]\n"
    255                      "                              [--ignore-operhaned-processes] [--profile]\n"
    256                      "                              -- <program/arg0> [argument1] ... [argumentN]]\n"
    257                      "\n");
     252                     GuestCtrl::tr("                              start [common-options]\n"
     253                                   "                              [--exe <path to executable>] [--timeout <msec>]\n"
     254                                   "                              [-E|--putenv <NAME>[=<VALUE>]] [--unquoted-args]\n"
     255                                   "                              [--ignore-operhaned-processes] [--profile]\n"
     256                                   "                              -- <program/arg0> [argument1] ... [argumentN]]\n"
     257                                   "\n"));
    258258    if (fSubcommandScope & HELP_SCOPE_GSTCTRL_COPYFROM)
    259259        RTStrmPrintf(pStrm,
    260                      "                              copyfrom [common-options]\n"
    261                      "                              [--follow] [-R|--recursive]\n"
    262                      "                              <guest-src0> [guest-src1 [...]] <host-dst>\n"
    263                      "\n"
    264                      "                              copyfrom [common-options]\n"
    265                      "                              [--follow] [-R|--recursive]\n"
    266                      "                              [--target-directory <host-dst-dir>]\n"
    267                      "                              <guest-src0> [guest-src1 [...]]\n"
    268                      "\n");
     260                     GuestCtrl::tr("                              copyfrom [common-options]\n"
     261                                   "                              [--follow] [-R|--recursive]\n"
     262                                   "                              <guest-src0> [guest-src1 [...]] <host-dst>\n"
     263                                   "\n"
     264                                   "                              copyfrom [common-options]\n"
     265                                   "                              [--follow] [-R|--recursive]\n"
     266                                   "                              [--target-directory <host-dst-dir>]\n"
     267                                   "                              <guest-src0> [guest-src1 [...]]\n"
     268                                   "\n"));
    269269    if (fSubcommandScope & HELP_SCOPE_GSTCTRL_COPYTO)
    270270        RTStrmPrintf(pStrm,
    271                      "                              copyto [common-options]\n"
    272                      "                              [--follow] [-R|--recursive]\n"
    273                      "                              <host-src0> [host-src1 [...]] <guest-dst>\n"
    274                      "\n"
    275                      "                              copyto [common-options]\n"
    276                      "                              [--follow] [-R|--recursive]\n"
    277                      "                              [--target-directory <guest-dst>]\n"
    278                      "                              <host-src0> [host-src1 [...]]\n"
    279                      "\n");
     271                     GuestCtrl::tr("                              copyto [common-options]\n"
     272                                   "                              [--follow] [-R|--recursive]\n"
     273                                   "                              <host-src0> [host-src1 [...]] <guest-dst>\n"
     274                                   "\n"
     275                                   "                              copyto [common-options]\n"
     276                                   "                              [--follow] [-R|--recursive]\n"
     277                                   "                              [--target-directory <guest-dst>]\n"
     278                                   "                              <host-src0> [host-src1 [...]]\n"
     279                                   "\n"));
    280280    if (fSubcommandScope & HELP_SCOPE_GSTCTRL_MKDIR)
    281281        RTStrmPrintf(pStrm,
    282                      "                              mkdir|createdir[ectory] [common-options]\n"
    283                      "                              [--parents] [--mode <mode>]\n"
    284                      "                              <guest directory> [...]\n"
    285                      "\n");
     282                     GuestCtrl::tr("                              mkdir|createdir[ectory] [common-options]\n"
     283                                   "                              [--parents] [--mode <mode>]\n"
     284                                   "                              <guest directory> [...]\n"
     285                                   "\n"));
    286286    if (fSubcommandScope & HELP_SCOPE_GSTCTRL_RMDIR)
    287287        RTStrmPrintf(pStrm,
    288                      "                              rmdir|removedir[ectory] [common-options]\n"
    289                      "                              [-R|--recursive]\n"
    290                      "                              <guest directory> [...]\n"
    291                      "\n");
     288                     GuestCtrl::tr("                              rmdir|removedir[ectory] [common-options]\n"
     289                                   "                              [-R|--recursive]\n"
     290                                   "                              <guest directory> [...]\n"
     291                                   "\n"));
    292292    if (fSubcommandScope & HELP_SCOPE_GSTCTRL_RM)
    293293        RTStrmPrintf(pStrm,
    294                      "                              removefile|rm [common-options] [-f|--force]\n"
    295                      "                              <guest file> [...]\n"
    296                      "\n");
     294                     GuestCtrl::tr("                              removefile|rm [common-options] [-f|--force]\n"
     295                                   "                              <guest file> [...]\n"
     296                                   "\n"));
    297297    if (fSubcommandScope & HELP_SCOPE_GSTCTRL_MV)
    298298        RTStrmPrintf(pStrm,
    299                      "                              mv|move|ren[ame] [common-options]\n"
    300                      "                              <source> [source1 [...]] <dest>\n"
    301                      "\n");
     299                     GuestCtrl::tr("                              mv|move|ren[ame] [common-options]\n"
     300                                   "                              <source> [source1 [...]] <dest>\n"
     301                                   "\n"));
    302302    if (fSubcommandScope & HELP_SCOPE_GSTCTRL_MKTEMP)
    303303        RTStrmPrintf(pStrm,
    304                      "                              mktemp|createtemp[orary] [common-options]\n"
    305                      "                              [--secure] [--mode <mode>] [--tmpdir <directory>]\n"
    306                      "                              <template>\n"
    307                      "\n");
     304                     GuestCtrl::tr("                              mktemp|createtemp[orary] [common-options]\n"
     305                                   "                              [--secure] [--mode <mode>] [--tmpdir <directory>]\n"
     306                                   "                              <template>\n"
     307                                   "\n"));
    308308    if (fSubcommandScope & HELP_SCOPE_GSTCTRL_STAT)
    309309        RTStrmPrintf(pStrm,
    310                      "                              stat [common-options]\n"
    311                      "                              <file> [...]\n"
    312                      "\n");
     310                     GuestCtrl::tr("                              stat [common-options]\n"
     311                                   "                              <file> [...]\n"
     312                                   "\n"));
    313313
    314314    /*
    … …  
    324324        if (fSubcommandScope & HELP_SCOPE_GSTCTRL_LIST)
    325325            RTStrmPrintf(pStrm,
    326                      "                              list <all|sessions|processes|files> [common-opts]\n"
    327                      "\n");
     326                         GuestCtrl::tr("                              list <all|sessions|processes|files> [common-opts]\n"
     327                                       "\n"));
    328328        if (fSubcommandScope & HELP_SCOPE_GSTCTRL_CLOSEPROCESS)
    329329            RTStrmPrintf(pStrm,
    330                      "                              closeprocess [common-options]\n"
    331                      "                              <   --session-id <ID>\n"
    332                      "                                | --session-name <name or pattern>\n"
    333                      "                              <PID1> [PID1 [...]]\n"
    334                      "\n");
     330                         GuestCtrl::tr("                              closeprocess [common-options]\n"
     331                                       "                              <   --session-id <ID>\n"
     332                                       "                                | --session-name <name or pattern>\n"
     333                                       "                              <PID1> [PID1 [...]]\n"
     334                                       "\n"));
    335335        if (fSubcommandScope & HELP_SCOPE_GSTCTRL_CLOSESESSION)
    336336            RTStrmPrintf(pStrm,
    337                      "                              closesession [common-options]\n"
    338                      "                              <  --all | --session-id <ID>\n"
    339                      "                                | --session-name <name or pattern> >\n"
    340                      "\n");
     337                         GuestCtrl::tr("                              closesession [common-options]\n"
     338                                       "                              <  --all | --session-id <ID>\n"
     339                                       "                                | --session-name <name or pattern> >\n"
     340                                       "\n"));
    341341        if (fSubcommandScope & HELP_SCOPE_GSTCTRL_UPDATEGA)
    342342            RTStrmPrintf(pStrm,
    343                      "                              updatega|updateguestadditions|updateadditions\n"
    344                      "                              [--source <guest additions .ISO>]\n"
    345                      "                              [--wait-start] [common-options]\n"
    346                      "                              [-- [<argument1>] ... [<argumentN>]]\n"
    347                      "\n");
     343                         GuestCtrl::tr("                              updatega|updateguestadditions|updateadditions\n"
     344                                       "                              [--source <guest additions .ISO>]\n"
     345                                       "                              [--wait-start] [common-options]\n"
     346                                       "                              [-- [<argument1>] ... [<argumentN>]]\n"
     347                                       "\n"));
    348348        if (fSubcommandScope & HELP_SCOPE_GSTCTRL_WATCH)
    349349            RTStrmPrintf(pStrm,
    350                      "                              watch [--timeout <msec>] [common-options]\n"
    351                      "\n");
     350                         GuestCtrl::tr("                              watch [--timeout <msec>] [common-options]\n"
     351                                       "\n"));
    352352        if (fSubcommandScope & HELP_SCOPE_GSTCTRL_WAITRUNLEVEL)
    353353            RTStrmPrintf(pStrm,
    354                      "                              waitrunlevel [--timeout <msec>] [common-options]\n"
    355                      "                              <system|userland|desktop>\n"
    356                      "\n");
     354                         GuestCtrl::tr("                              waitrunlevel [--timeout <msec>] [common-options]\n"
     355                                       "                              <system|userland|desktop>\n"
     356                                       "\n"));
    357357    }
    358358}
    … …  
    413413    {
    414414        rc = RTErrConvertFromWin32(GetLastError());
    415         RTMsgError("Unable to install console control handler, rc=%Rrc\n", rc);
     415        RTMsgError(GuestCtrl::tr("Unable to install console control handler, rc=%Rrc\n"), rc);
    416416    }
    417417#else
    … …  
    440440    {
    441441        rc = RTErrConvertFromWin32(GetLastError());
    442         RTMsgError("Unable to uninstall console control handler, rc=%Rrc\n", rc);
     442        RTMsgError(GuestCtrl::tr("Unable to uninstall console control handler, rc=%Rrc\n"), rc);
    443443    }
    444444#else
    … …  
    467467    {
    468468        case ProcessStatus_Starting:
    469             return "starting";
     469            return GuestCtrl::tr("starting");
    470470        case ProcessStatus_Started:
    471             return "started";
     471            return GuestCtrl::tr("started");
    472472        case ProcessStatus_Paused:
    473             return "paused";
     473            return GuestCtrl::tr("paused");
    474474        case ProcessStatus_Terminating:
    475             return "terminating";
     475            return GuestCtrl::tr("terminating");
    476476        case ProcessStatus_TerminatedNormally:
    477             return "successfully terminated";
     477            return GuestCtrl::tr("successfully terminated");
    478478        case ProcessStatus_TerminatedSignal:
    479             return "terminated by signal";
     479            return GuestCtrl::tr("terminated by signal");
    480480        case ProcessStatus_TerminatedAbnormally:
    481             return "abnormally aborted";
     481            return GuestCtrl::tr("abnormally aborted");
    482482        case ProcessStatus_TimedOutKilled:
    483             return "timed out";
     483            return GuestCtrl::tr("timed out");
    484484        case ProcessStatus_TimedOutAbnormally:
    485             return "timed out, hanging";
     485            return GuestCtrl::tr("timed out, hanging");
    486486        case ProcessStatus_Down:
    487             return "killed";
     487            return GuestCtrl::tr("killed");
    488488        case ProcessStatus_Error:
    489             return "error";
     489            return GuestCtrl::tr("error");
    490490        default:
    491491            break;
    492492    }
    493     return "unknown";
     493    return GuestCtrl::tr("unknown");
    494494}
    495495
    … …  
    502502    {
    503503        case ProcessWaitResult_Start:
    504             return "started";
     504            return GuestCtrl::tr("started");
    505505        case ProcessWaitResult_Terminate:
    506             return "terminated";
     506            return GuestCtrl::tr("terminated");
    507507        case ProcessWaitResult_Status:
    508             return "status changed";
     508            return GuestCtrl::tr("status changed");
    509509        case ProcessWaitResult_Error:
    510             return "error";
     510            return GuestCtrl::tr("error");
    511511        case ProcessWaitResult_Timeout:
    512             return "timed out";
     512            return GuestCtrl::tr("timed out");
    513513        case ProcessWaitResult_StdIn:
    514             return "stdin ready";
     514            return GuestCtrl::tr("stdin ready");
    515515        case ProcessWaitResult_StdOut:
    516             return "data on stdout";
     516            return GuestCtrl::tr("data on stdout");
    517517        case ProcessWaitResult_StdErr:
    518             return "data on stderr";
     518            return GuestCtrl::tr("data on stderr");
    519519        case ProcessWaitResult_WaitFlagNotSupported:
    520             return "waiting flag not supported";
     520            return GuestCtrl::tr("waiting flag not supported");
    521521        default:
    522522            break;
    523523    }
    524     return "unknown";
     524    return GuestCtrl::tr("unknown");
    525525}
    526526
    … …  
    533533    {
    534534        case GuestSessionStatus_Starting:
    535             return "starting";
     535            return GuestCtrl::tr("starting");
    536536        case GuestSessionStatus_Started:
    537             return "started";
     537            return GuestCtrl::tr("started");
    538538        case GuestSessionStatus_Terminating:
    539             return "terminating";
     539            return GuestCtrl::tr("terminating");
    540540        case GuestSessionStatus_Terminated:
    541             return "terminated";
     541            return GuestCtrl::tr("terminated");
    542542        case GuestSessionStatus_TimedOutKilled:
    543             return "timed out";
     543            return GuestCtrl::tr("timed out");
    544544        case GuestSessionStatus_TimedOutAbnormally:
    545             return "timed out, hanging";
     545            return GuestCtrl::tr("timed out, hanging");
    546546        case GuestSessionStatus_Down:
    547             return "killed";
     547            return GuestCtrl::tr("killed");
    548548        case GuestSessionStatus_Error:
    549             return "error";
     549            return GuestCtrl::tr("error");
    550550        default:
    551551            break;
    552552    }
    553     return "unknown";
     553    return GuestCtrl::tr("unknown");
    554554}
    555555
    … …  
    562562    {
    563563        case FileStatus_Opening:
    564             return "opening";
     564            return GuestCtrl::tr("opening");
    565565        case FileStatus_Open:
    566             return "open";
     566            return GuestCtrl::tr("open");
    567567        case FileStatus_Closing:
    568             return "closing";
     568            return GuestCtrl::tr("closing");
    569569        case FileStatus_Closed:
    570             return "closed";
     570            return GuestCtrl::tr("closed");
    571571        case FileStatus_Down:
    572             return "killed";
     572            return GuestCtrl::tr("killed");
    573573        case FileStatus_Error:
    574             return "error";
     574            return GuestCtrl::tr("error");
    575575        default:
    576576            break;
    577577    }
    578     return "unknown";
     578    return GuestCtrl::tr("unknown");
    579579}
    580580
    … …  
    586586    switch (enmType)
    587587    {
    588         case FsObjType_Unknown:     return "unknown";
    589         case FsObjType_Fifo:        return "fifo";
    590         case FsObjType_DevChar:     return "char-device";
    591         case FsObjType_Directory:   return "directory";
    592         case FsObjType_DevBlock:    return "block-device";
    593         case FsObjType_File:        return "file";
    594         case FsObjType_Symlink:     return "symlink";
    595         case FsObjType_Socket:      return "socket";
    596         case FsObjType_WhiteOut:    return "white-out";
     588        case FsObjType_Unknown:     return GuestCtrl::tr("unknown");
     589        case FsObjType_Fifo:        return GuestCtrl::tr("fifo");
     590        case FsObjType_DevChar:     return GuestCtrl::tr("char-device");
     591        case FsObjType_Directory:   return GuestCtrl::tr("directory");
     592        case FsObjType_DevBlock:    return GuestCtrl::tr("block-device");
     593        case FsObjType_File:        return GuestCtrl::tr("file");
     594        case FsObjType_Symlink:     return GuestCtrl::tr("symlink");
     595        case FsObjType_Socket:      return GuestCtrl::tr("socket");
     596        case FsObjType_WhiteOut:    return GuestCtrl::tr("white-out");
    597597#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
    598598        case FsObjType_32BitHack: break;
    599599#endif
    600600    }
    601     return "unknown";
     601    return GuestCtrl::tr("unknown");
    602602}
    603603
    … …  
    613613        else
    614614        {
    615             RTMsgError("Error details:");
     615            RTMsgError(GuestCtrl::tr("Error details:"));
    616616            GluePrintErrorInfo(errorInfo);
    617617        }
    618618        return VERR_GENERAL_FAILURE; /** @todo */
    619619    }
    620     AssertMsgFailedReturn(("Object has indicated no error (%Rhrc)!?\n", errorInfo.getResultCode()),
     620    AssertMsgFailedReturn((GuestCtrl::tr("Object has indicated no error (%Rhrc)!?\n"), errorInfo.getResultCode()),
    621621                          VERR_INVALID_PARAMETER);
    622622}
    … …  
    650650    } while(0);
    651651
    652     AssertMsgStmt(SUCCEEDED(rc), ("Could not lookup progress information\n"), vrc = VERR_COM_UNEXPECTED);
     652    AssertMsgStmt(SUCCEEDED(rc), (GuestCtrl::tr("Could not lookup progress information\n")), vrc = VERR_COM_UNEXPECTED);
    653653
    654654    return vrc;
    … …  
    709709        catch (std::bad_alloc &)
    710710        {
    711             return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory");
     711            return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory"));
    712712        }
    713713    }
    … …  
    737737                pCtx->strUsername = pValueUnion->psz;
    738738            else
    739                 RTMsgWarning("The --username|-u option is ignored by '%s'", pCtx->pCmdDef->pszName);
     739                RTMsgWarning(GuestCtrl::tr("The --username|-u option is ignored by '%s'"), pCtx->pCmdDef->pszName);
    740740            break;
    741741
    … …  
    744744            {
    745745                if (pCtx->strPassword.isNotEmpty())
    746                     RTMsgWarning("Password is given more than once.");
     746                    RTMsgWarning(GuestCtrl::tr("Password is given more than once."));
    747747                pCtx->strPassword = pValueUnion->psz;
    748748            }
    749749            else
    750                 RTMsgWarning("The --password option is ignored by '%s'", pCtx->pCmdDef->pszName);
     750                RTMsgWarning(GuestCtrl::tr("The --password option is ignored by '%s'"), pCtx->pCmdDef->pszName);
    751751            break;
    752752
    … …  
    755755                rcExit = readPasswordFile(pValueUnion->psz, &pCtx->strPassword);
    756756            else
    757                 RTMsgWarning("The --password-file|-p option is ignored by '%s'", pCtx->pCmdDef->pszName);
     757                RTMsgWarning(GuestCtrl::tr("The --password-file|-p option is ignored by '%s'"), pCtx->pCmdDef->pszName);
    758758            break;
    759759
    … …  
    762762                pCtx->strDomain = pValueUnion->psz;
    763763            else
    764                 RTMsgWarning("The --domain option is ignored by '%s'", pCtx->pCmdDef->pszName);
     764                RTMsgWarning(GuestCtrl::tr("The --domain option is ignored by '%s'"), pCtx->pCmdDef->pszName);
    765765            break;
    766766
    … …  
    827827                    }
    828828                    else
    829                         RTMsgError("Failed to get a IConsole pointer for the machine. Is it still running?\n");
     829                        RTMsgError(GuestCtrl::tr("Failed to get a IConsole pointer for the machine. Is it still running?\n"));
    830830                }
    831831            }
    832832        }
    833833        else if (SUCCEEDED(rc))
    834             RTMsgError("Machine \"%s\" is not running (currently %s)!\n",
     834            RTMsgError(GuestCtrl::tr("Machine \"%s\" is not running (currently %s)!\n"),
    835835                       pCtx->pszVmNameOrUuid, machineStateToName(enmMachineState, false));
    836836    }
    … …  
    861861    char *pszSessionName;
    862862    if (RTStrAPrintf(&pszSessionName,
    863                      "[%RU32] VBoxManage Guest Control [%s] - %s",
     863                     GuestCtrl::tr("[%RU32] VBoxManage Guest Control [%s] - %s"),
    864864                     RTProcSelf(), pCtx->pszVmNameOrUuid, pCtx->pCmdDef->pszName) < 0)
    865         return RTMsgErrorExit(RTEXITCODE_FAILURE, "No enough memory for session name");
     865        return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("No enough memory for session name"));
    866866
    867867    /*
    … …  
    869869     */
    870870    if (pCtx->cVerbose)
    871         RTPrintf("Creating guest session as user '%s'...\n", pCtx->strUsername.c_str());
     871        RTPrintf(GuestCtrl::tr("Creating guest session as user '%s'...\n"), pCtx->strUsername.c_str());
    872872    try
    873873    {
    … …  
    880880    catch (std::bad_alloc &)
    881881    {
    882         RTMsgError("Out of memory setting up IGuest::CreateSession call");
     882        RTMsgError(GuestCtrl::tr("Out of memory setting up IGuest::CreateSession call"));
    883883        rc = E_OUTOFMEMORY;
    884884    }
    … …  
    889889         */
    890890        if (pCtx->cVerbose)
    891             RTPrintf("Waiting for guest session to start...\n");
     891            RTPrintf(GuestCtrl::tr("Waiting for guest session to start...\n"));
    892892        GuestSessionWaitResult_T enmWaitResult = GuestSessionWaitResult_None; /* Shut up MSC */
    893893        try
    … …  
    901901        catch (std::bad_alloc &)
    902902        {
    903             RTMsgError("Out of memory setting up IGuestSession::WaitForArray call");
     903            RTMsgError(GuestCtrl::tr("Out of memory setting up IGuestSession::WaitForArray call"));
    904904            rc = E_OUTOFMEMORY;
    905905        }
    … …  
    917917                {
    918918                    if (pCtx->cVerbose)
    919                         RTPrintf("Successfully started guest session (ID %RU32)\n", pCtx->uSessionID);
     919                        RTPrintf(GuestCtrl::tr("Successfully started guest session (ID %RU32)\n"), pCtx->uSessionID);
    920920                    RTStrFree(pszSessionName);
    921921                    return RTEXITCODE_SUCCESS;
    … …  
    926926                GuestSessionStatus_T enmSessionStatus;
    927927                CHECK_ERROR(pCtx->pGuestSession, COMGETTER(Status)(&enmSessionStatus));
    928                 RTMsgError("Error starting guest session (current status is: %s)\n",
    929                            SUCCEEDED(rc) ? gctlGuestSessionStatusToText(enmSessionStatus) : "<unknown>");
     928                RTMsgError(GuestCtrl::tr("Error starting guest session (current status is: %s)\n"),
     929                           SUCCEEDED(rc) ? gctlGuestSessionStatusToText(enmSessionStatus) : GuestCtrl::tr("<unknown>"));
    930930            }
    931931        }
    … …  
    986986    }
    987987    else
    988         rcExit = errorSyntaxEx(USAGE_GUESTCONTROL, pCtx->pCmdDef->fSubcommandScope, "No user name specified!");
     988        rcExit = errorSyntaxEx(USAGE_GUESTCONTROL, pCtx->pCmdDef->fSubcommandScope, GuestCtrl::tr("No user name specified!"));
    989989
    990990    pCtx->fPostOptionParsingInited = rcExit == RTEXITCODE_SUCCESS;
    … …  
    10261026        {
    10271027            if (pCtx->cVerbose)
    1028                 RTPrintf("Closing guest session ...\n");
     1028                RTPrintf(GuestCtrl::tr("Closing guest session ...\n"));
    10291029
    10301030            CHECK_ERROR(pCtx->pGuestSession, Close());
    … …  
    10321032        else if (   pCtx->fDetachGuestSession
    10331033                 && pCtx->cVerbose)
    1034             RTPrintf("Guest session detached\n");
     1034            RTPrintf(GuestCtrl::tr("Guest session detached\n"));
    10351035
    10361036        pCtx->pGuestSession.setNull();
    … …  
    11931193            vrc = RTVfsIoStrmWrite(hVfsIosDst, pbBuf, cbOutputData, true /*fBlocking*/,  NULL);
    11941194            if (RT_FAILURE(vrc))
    1195                 RTMsgError("Unable to write output, rc=%Rrc\n", vrc);
     1195                RTMsgError(GuestCtrl::tr("Unable to write output, rc=%Rrc\n"), vrc);
    11961196        }
    11971197    }
    … …  
    12231223            if (enmTransformation != kStreamTransform_None)
    12241224            {
    1225                 RTMsgWarning("Unsupported %s line ending conversion", pszName);
     1225                RTMsgWarning(GuestCtrl::tr("Unsupported %s line ending conversion"), pszName);
    12261226                /** @todo Implement dos2unix and unix2dos stream filters. */
    12271227            }
    12281228            return true;
    12291229        }
    1230         RTMsgWarning("Error getting %s handle: %Rrc", pszName, vrc);
     1230        RTMsgWarning(GuestCtrl::tr("Error getting %s handle: %Rrc"), pszName, vrc);
    12311231    }
    12321232    else /* If disabled, all goes to / gets fed to/from the bit bucket. */
    … …  
    13541354                        || ValueUnion.psz[0] == '=')
    13551355                        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_RUN,
    1356                                              "Invalid argument variable[=value]: '%s'", ValueUnion.psz);
     1356                                             GuestCtrl::tr("Invalid argument variable[=value]: '%s'"), ValueUnion.psz);
    13571357                    aEnv.push_back(Bstr(ValueUnion.psz).raw());
    13581358                    break;
    … …  
    13641364                case kGstCtrlRunOpt_NoProfile:
    13651365                    /** @todo Deprecated, will be removed. */
    1366                     RTPrintf("Warning: Deprecated option \"--no-profile\" specified\n");
     1366                    RTPrintf(GuestCtrl::tr("Warning: Deprecated option \"--no-profile\" specified\n"));
    13671367                    break;
    13681368
    … …  
    14301430        /* Must have something to execute. */
    14311431        if (!pszImage || !*pszImage)
    1432             return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_RUN, "No executable specified!");
     1432            return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_RUN, GuestCtrl::tr("No executable specified!"));
    14331433
    14341434        /*
    … …  
    14821482            {
    14831483                if (cMsTimeout == 0)
    1484                     RTPrintf("Starting guest process ...\n");
     1484                    RTPrintf(GuestCtrl::tr("Starting guest process ...\n"));
    14851485                else
    1486                     RTPrintf("Starting guest process (within %ums)\n", cMsTimeout);
     1486                    RTPrintf(GuestCtrl::tr("Starting guest process (within %ums)\n"), cMsTimeout);
    14871487            }
    14881488            ComPtr<IGuestProcess> pProcess;
    … …  
    15061506            CHECK_ERROR_BREAK(pProcess, COMGETTER(PID)(&uPID));
    15071507            if (fRunCmd && pCtx->cVerbose)
    1508                 RTPrintf("Process '%s' (PID %RU32) started\n", pszImage, uPID);
     1508                RTPrintf(GuestCtrl::tr("Process '%s' (PID %RU32) started\n"), pszImage, uPID);
    15091509            else if (!fRunCmd && pCtx->cVerbose)
    15101510            {
    15111511                /* Just print plain PID to make it easier for scripts
    15121512                 * invoking VBoxManage. */
    1513                 RTPrintf("[%RU32 - Session %RU32]\n", uPID, pCtx->uSessionID);
     1513                RTPrintf(GuestCtrl::tr("[%RU32 - Session %RU32]\n"), uPID, pCtx->uSessionID);
    15141514            }
    15151515
    … …  
    15321532                                                         &waitResult));
    15331533                if (pCtx->cVerbose)
    1534                     RTPrintf("waitResult: %d\n", waitResult);
     1534                    RTPrintf(GuestCtrl::tr("waitResult: %d\n"), waitResult);
    15351535                switch (waitResult)
    15361536                {
    … …  
    15481548                    case ProcessWaitResult_Terminate:
    15491549                        if (pCtx->cVerbose)
    1550                             RTPrintf("Process terminated\n");
     1550                            RTPrintf(GuestCtrl::tr("Process terminated\n"));
    15511551                        /* Process terminated, we're done. */
    15521552                        fCompleted = true;
    … …  
    16251625            {
    16261626                if (pCtx->cVerbose)
    1627                     RTPrintf("Process execution aborted!\n");
     1627                    RTPrintf(GuestCtrl::tr("Process execution aborted!\n"));
    16281628                rcExit = EXITCODEEXEC_CANCELED;
    16291629            }
    … …  
    16311631            {
    16321632                if (pCtx->cVerbose)
    1633                     RTPrintf("Process successfully started!\n");
     1633                    RTPrintf(GuestCtrl::tr("Process successfully started!\n"));
    16341634                rcExit = RTEXITCODE_SUCCESS;
    16351635            }
    … …  
    16451645                    CHECK_ERROR_BREAK(pProcess, COMGETTER(ExitCode)(&lExitCode));
    16461646                    if (pCtx->cVerbose)
    1647                         RTPrintf("Exit code=%u (Status=%u [%s])\n",
     1647                        RTPrintf(GuestCtrl::tr("Exit code=%u (Status=%u [%s])\n"),
    16481648                                 lExitCode, procStatus, gctlProcessStatusToText(procStatus));
    16491649
    … …  
    16541654                {
    16551655                    if (pCtx->cVerbose)
    1656                         RTPrintf("Process timed out (guest side) and %s\n",
     1656                        RTPrintf(GuestCtrl::tr("Process timed out (guest side) and %s\n"),
    16571657                                 procStatus == ProcessStatus_TimedOutAbnormally
    1658                                  ? "failed to terminate so far" : "was terminated");
     1658                                 ? GuestCtrl::tr("failed to terminate so far") : GuestCtrl::tr("was terminated"));
    16591659                    rcExit = EXITCODEEXEC_TIMEOUT;
    16601660                }
    … …  
    16621662                {
    16631663                    if (pCtx->cVerbose)
    1664                         RTPrintf("Process now is in status [%s] (unexpected)\n", gctlProcessStatusToText(procStatus));
     1664                        RTPrintf(GuestCtrl::tr("Process now is in status [%s] (unexpected)\n"),
     1665                                 gctlProcessStatusToText(procStatus));
    16651666                    rcExit = RTEXITCODE_FAILURE;
    16661667                }
    … …  
    16691670            {
    16701671                if (pCtx->cVerbose)
    1671                     RTPrintf("Process monitor loop quit with vrc=%Rrc\n", vrc);
     1672                    RTPrintf(GuestCtrl::tr("Process monitor loop quit with vrc=%Rrc\n"), vrc);
    16721673                rcExit = RTEXITCODE_FAILURE;
    16731674            }
    … …  
    16751676            {
    16761677                if (pCtx->cVerbose)
    1677                     RTPrintf("Process monitor loop timed out\n");
     1678                    RTPrintf(GuestCtrl::tr("Process monitor loop timed out\n"));
    16781679                rcExit = EXITCODEEXEC_TIMEOUT;
    16791680            }
    … …  
    17901791
    17911792    if (!cSources)
    1792         return errorSyntaxEx(USAGE_GUESTCONTROL, uUsage, "No sources specified!");
     1793        return errorSyntaxEx(USAGE_GUESTCONTROL, uUsage, GuestCtrl::tr("No sources specified!"));
    17931794
    17941795    /* Unless a --target-directory is given, the last argument is the destination, so
    … …  
    17981799
    17991800    if (pszDst == NULL)
    1800         return errorSyntaxEx(USAGE_GUESTCONTROL, uUsage, "No destination specified!");
     1801        return errorSyntaxEx(USAGE_GUESTCONTROL, uUsage, GuestCtrl::tr("No destination specified!"));
    18011802
    18021803    char szAbsDst[RTPATH_MAX];
    … …  
    18071808            pszDst = szAbsDst;
    18081809        else
    1809             return RTMsgErrorExitFailure("RTPathAbs failed on '%s': %Rrc", pszDst, vrc);
     1810            return RTMsgErrorExitFailure(GuestCtrl::tr("RTPathAbs failed on '%s': %Rrc"), pszDst, vrc);
    18101811    }
    18111812
    … …  
    18201821    {
    18211822        if (fHostToGuest)
    1822             RTPrintf("Copying from host to guest ...\n");
     1823            RTPrintf(GuestCtrl::tr("Copying from host to guest ...\n"));
    18231824        else
    1824             RTPrintf("Copying from guest to host ...\n");
     1825            RTPrintf(GuestCtrl::tr("Copying from guest to host ...\n"));
    18251826    }
    18261827
    … …  
    18491850    NOREF(fDstMustBeDir);
    18501851    if (cSources != 1)
    1851         return RTMsgErrorExitFailure("Only one source file or directory at the moment.");
     1852        return RTMsgErrorExitFailure(GuestCtrl::tr("Only one source file or directory at the moment."));
    18521853    for (size_t iSrc = 0; iSrc < cSources; iSrc++)
    18531854    {
    … …  
    18581859        const char *pszSrcFinalComp = RTPathFilename(pszSource);
    18591860        if (pszSrcFinalComp && strpbrk(pszSrcFinalComp, "*?"))
    1860             rcExit = RTMsgErrorExitFailure("Skipping '%s' because wildcard expansion isn't implemented yet\n", pszSource);
     1861            rcExit = RTMsgErrorExitFailure(GuestCtrl::tr("Skipping '%s' because wildcard expansion isn't implemented yet\n"),
     1862                                           pszSource);
    18611863        else if (fHostToGuest)
    18621864        {
    … …  
    18751877                    {
    18761878                        if (pCtx->cVerbose)
    1877                             RTPrintf("File '%s' -> '%s'\n", szAbsSrc, pszDst);
     1879                            RTPrintf(GuestCtrl::tr("File '%s' -> '%s'\n"), szAbsSrc, pszDst);
    18781880
    18791881                        SafeArray<FileCopyFlag_T> copyFlags;
    … …  
    18841886                    {
    18851887                        if (pCtx->cVerbose)
    1886                             RTPrintf("Directory '%s' -> '%s'\n", szAbsSrc, pszDst);
     1888                            RTPrintf(GuestCtrl::tr("Directory '%s' -> '%s'\n"), szAbsSrc, pszDst);
    18871889
    18881890                        SafeArray<DirectoryCopyFlag_T> copyFlags;
    … …  
    18921894                    }
    18931895                    else
    1894                         rcExit = RTMsgErrorExitFailure("Not a file or directory: %s\n", szAbsSrc);
     1896                        rcExit = RTMsgErrorExitFailure(GuestCtrl::tr("Not a file or directory: %s\n"), szAbsSrc);
    18951897                }
    18961898                else
    1897                     rcExit = RTMsgErrorExitFailure("RTPathQueryInfo failed on '%s': %Rrc", szAbsSrc, vrc);
     1899                    rcExit = RTMsgErrorExitFailure(GuestCtrl::tr("RTPathQueryInfo failed on '%s': %Rrc"), szAbsSrc, vrc);
    18981900            }
    18991901            else
    1900                 rcExit = RTMsgErrorExitFailure("RTPathAbs failed on '%s': %Rrc", pszSource, vrc);
     1902                rcExit = RTMsgErrorExitFailure(GuestCtrl::tr("RTPathAbs failed on '%s': %Rrc"), pszSource, vrc);
    19011903        }
    19021904        else
    … …  
    19181920                    {
    19191921                        if (pCtx->cVerbose)
    1920                             RTPrintf("Directory '%s' -> '%s'\n", pszSource, pszDst);
     1922                            RTPrintf(GuestCtrl::tr("Directory '%s' -> '%s'\n"), pszSource, pszDst);
    19211923
    19221924                        SafeArray<DirectoryCopyFlag_T> aCopyFlags;
    … …  
    19281930                    {
    19291931                        if (pCtx->cVerbose)
    1930                             RTPrintf("File '%s' -> '%s'\n", pszSource, pszDst);
     1932                            RTPrintf(GuestCtrl::tr("File '%s' -> '%s'\n"), pszSource, pszDst);
    19311933
    19321934                        SafeArray<FileCopyFlag_T> aCopyFlags;
    … …  
    19351937                    }
    19361938                    else
    1937                         rcExit = RTMsgErrorExitFailure("Not a file or directory: %s\n", pszSource);
     1939                        rcExit = RTMsgErrorExitFailure(GuestCtrl::tr("Not a file or directory: %s\n"), pszSource);
    19381940                }
    19391941                else
    … …  
    19411943            }
    19421944            else
    1943                 rcExit = RTMsgErrorExitFailure("FsObjQueryInfo failed on '%s': %Rhrc", pszSource, rc);
     1945                rcExit = RTMsgErrorExitFailure(GuestCtrl::tr("FsObjQueryInfo failed on '%s': %Rhrc"), pszSource, rc);
    19441946        }
    19451947    }
    … …  
    19561958            rc = pProgress->WaitForCompletion(-1 /* No timeout */);
    19571959        if (SUCCEEDED(rc))
    1958             CHECK_PROGRESS_ERROR(pProgress, ("File copy failed"));
     1960            CHECK_PROGRESS_ERROR(pProgress, (GuestCtrl::tr("File copy failed")));
    19591961        vrc = gctlPrintProgressError(pProgress);
    19601962    }
    … …  
    20212023                        return rcExit;
    20222024                    if (pCtx->cVerbose)
    2023                         RTPrintf("Creating %RU32 directories...\n", argc - GetState.iNext + 1);
     2025                        RTPrintf(GuestCtrl::tr("Creating %RU32 directories...\n"), argc - GetState.iNext + 1);
    20242026                }
    20252027                if (g_fGuestCtrlCanceled)
    2026                     return RTMsgErrorExit(RTEXITCODE_FAILURE, "mkdir was interrupted by Ctrl-C (%u left)\n",
     2028                    return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("mkdir was interrupted by Ctrl-C (%u left)\n"),
    20272029                                          argc - GetState.iNext + 1);
    20282030
    … …  
    20372039                cDirsCreated++;
    20382040                if (pCtx->cVerbose)
    2039                     RTPrintf("Creating directory \"%s\" ...\n", ValueUnion.psz);
     2041                    RTPrintf(GuestCtrl::tr("Creating directory \"%s\" ...\n"), ValueUnion.psz);
    20402042                try
    20412043                {
    … …  
    20482050                catch (std::bad_alloc &)
    20492051                {
    2050                     return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory\n");
     2052                    return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory\n"));
    20512053                }
    20522054                break;
    … …  
    20582060
    20592061    if (!cDirsCreated)
    2060         return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_MKDIR, "No directory to create specified!");
     2062        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_MKDIR, GuestCtrl::tr("No directory to create specified!"));
    20612063    return rcExit;
    20622064}
    … …  
    21042106                        return rcExit;
    21052107                    if (pCtx->cVerbose)
    2106                         RTPrintf("Removing %RU32 directorie%s(s)...\n", argc - GetState.iNext + 1, fRecursive ? "tree" : "");
     2108                    {
     2109                        if (fRecursive)
     2110                            RTPrintf(GuestCtrl::tr("Removing %RU32 directory tree(s)...\n", "", argc - GetState.iNext + 1),
     2111                                     argc - GetState.iNext + 1);
     2112                        else
     2113                            RTPrintf(GuestCtrl::tr("Removing %RU32 directorie(s)...\n", "", argc - GetState.iNext + 1),
     2114                                     argc - GetState.iNext + 1);
     2115                    }
    21072116                }
    21082117                if (g_fGuestCtrlCanceled)
    2109                     return RTMsgErrorExit(RTEXITCODE_FAILURE, "rmdir was interrupted by Ctrl-C (%u left)\n",
     2118                    return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("rmdir was interrupted by Ctrl-C (%u left)\n"),
    21102119                                          argc - GetState.iNext + 1);
    21112120
    … …  
    21182127                     */
    21192128                    if (pCtx->cVerbose)
    2120                         RTPrintf("Removing directory \"%s\" ...\n", ValueUnion.psz);
     2129                        RTPrintf(GuestCtrl::tr("Removing directory \"%s\" ...\n"), ValueUnion.psz);
    21212130                    try
    21222131                    {
    … …  
    21252134                    catch (std::bad_alloc &)
    21262135                    {
    2127                         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory\n");
     2136                        return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory\n"));
    21282137                    }
    21292138                }
    … …  
    21372146                     */
    21382147                    if (pCtx->cVerbose)
    2139                         RTPrintf("Recursively removing directory \"%s\" ...\n", ValueUnion.psz);
     2148                        RTPrintf(GuestCtrl::tr("Recursively removing directory \"%s\" ...\n"), ValueUnion.psz);
    21402149                    try
    21412150                    {
    … …  
    21552164                                rc = ptrProgress->WaitForCompletion(-1 /* indefinitely */);
    21562165                            if (SUCCEEDED(rc))
    2157                                 CHECK_PROGRESS_ERROR(ptrProgress, ("Directory deletion failed"));
     2166                                CHECK_PROGRESS_ERROR(ptrProgress, (GuestCtrl::tr("Directory deletion failed")));
    21582167                            ptrProgress.setNull();
    21592168                        }
    … …  
    21612170                    catch (std::bad_alloc &)
    21622171                    {
    2163                         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory during recursive rmdir\n");
     2172                        return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory during recursive rmdir\n"));
    21642173                    }
    21652174                }
    … …  
    21792188
    21802189    if (!cDirRemoved)
    2181         return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_RMDIR, "No directory to remove specified!");
     2190        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_RMDIR, GuestCtrl::tr("No directory to remove specified!"));
    21822191    return rcExit;
    21832192}
    … …  
    22192228                        return rcExit;
    22202229                    if (pCtx->cVerbose)
    2221                         RTPrintf("Removing %RU32 file(s)...\n", argc - GetState.iNext + 1);
     2230                        RTPrintf(GuestCtrl::tr("Removing %RU32 file(s)...\n"), argc - GetState.iNext + 1);
    22222231                }
    22232232                if (g_fGuestCtrlCanceled)
    2224                     return RTMsgErrorExit(RTEXITCODE_FAILURE, "rm was interrupted by Ctrl-C (%u left)\n",
     2233                    return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("rm was interrupted by Ctrl-C (%u left)\n"),
    22252234                                          argc - GetState.iNext + 1);
    22262235
    … …  
    22332242                cFilesDeleted++;
    22342243                if (pCtx->cVerbose)
    2235                     RTPrintf("Removing file \"%s\" ...\n", ValueUnion.psz);
     2244                    RTPrintf(GuestCtrl::tr("Removing file \"%s\" ...\n", ValueUnion.psz));
    22362245                try
    22372246                {
    … …  
    22452254                catch (std::bad_alloc &)
    22462255                {
    2247                     return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory\n");
     2256                    return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory\n"));
    22482257                }
    22492258                break;
    … …  
    22552264
    22562265    if (!cFilesDeleted && !fForce)
    2257         return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_RM, "No file to remove specified!");
     2266        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_RM, GuestCtrl::tr("No file to remove specified!"));
    22582267    return rcExit;
    22592268}
    … …  
    23132322
    23142323    if (RT_FAILURE(vrc))
    2315         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to initialize, rc=%Rrc\n", vrc);
     2324        return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Failed to initialize, rc=%Rrc\n"), vrc);
    23162325
    23172326    size_t cSources = vecSources.size();
    23182327    if (!cSources)
    23192328        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_MV,
    2320                              "No source(s) to move specified!");
     2329                             GuestCtrl::tr("No source(s) to move specified!"));
    23212330    if (cSources < 2)
    23222331        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_MV,
    2323                              "No destination specified!");
     2332                             GuestCtrl::tr("No destination specified!"));
    23242333
    23252334    RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
    … …  
    23402349        if (FAILED(rc))
    23412350        {
    2342             return RTMsgErrorExit(RTEXITCODE_FAILURE, "Destination does not exist\n");
     2351            return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Destination does not exist\n"));
    23432352        }
    23442353        else
    … …  
    23492358            {
    23502359                if (enmObjType != FsObjType_Directory)
    2351                     return RTMsgErrorExit(RTEXITCODE_FAILURE, "Destination must be a directory when specifying multiple sources\n");
     2360                    return RTMsgErrorExit(RTEXITCODE_FAILURE,
     2361                                          GuestCtrl::tr("Destination must be a directory when specifying multiple sources\n"));
    23522362            }
    23532363            else
    2354                 return RTMsgErrorExit(RTEXITCODE_FAILURE, "Unable to determine destination type: %Rhrc\n", rc);
     2364                return RTMsgErrorExit(RTEXITCODE_FAILURE,
     2365                                      GuestCtrl::tr("Unable to determine destination type: %Rhrc\n"),
     2366                                      rc);
    23552367        }
    23562368    }
    … …  
    23602372     */
    23612373    if (pCtx->cVerbose)
    2362         RTPrintf("Renaming %RU32 %s ...\n", cSources, cSources > 1 ? "sources" : "source");
     2374        RTPrintf(GuestCtrl::tr("Renaming %RU32 %s ...\n"), cSources,
     2375                 cSources > 1 ? GuestCtrl::tr("sources", "", cSources) : GuestCtrl::tr("source"));
    23632376
    23642377    std::vector< Utf8Str >::iterator it = vecSources.begin();
    … …  
    23752388        if (FAILED(rc))
    23762389        {
    2377             RTPrintf("Cannot stat \"%s\": No such file or directory\n", strSrcCur.c_str());
     2390            RTPrintf(GuestCtrl::tr("Cannot stat \"%s\": No such file or directory\n"), strSrcCur.c_str());
    23782391            ++it;
    23792392            continue; /* Skip. */
    … …  
    23922405
    23932406        if (pCtx->cVerbose)
    2394             RTPrintf("Renaming %s \"%s\" to \"%s\" ...\n",
    2395                      enmObjType == FsObjType_Directory ? "directory" : "file",
     2407            RTPrintf(GuestCtrl::tr("Renaming %s \"%s\" to \"%s\" ...\n"),
     2408                     enmObjType == FsObjType_Directory ? GuestCtrl::tr("directory") : GuestCtrl::tr("file"),
    23962409                     strSrcCur.c_str(), pszDstCur);
    23972410
    … …  
    24122425        && pCtx->cVerbose)
    24132426    {
    2414         RTPrintf("Warning: Not all sources were renamed\n");
     2427        RTPrintf(GuestCtrl::tr("Warning: Not all sources were renamed\n"));
    24152428    }
    24162429
    … …  
    24722485                else
    24732486                    return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_MKTEMP,
    2474                                          "More than one template specified!\n");
     2487                                         GuestCtrl::tr("More than one template specified!\n"));
    24752488                break;
    24762489
    … …  
    24822495    if (strTemplate.isEmpty())
    24832496        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_MKTEMP,
    2484                              "No template specified!");
     2497                             GuestCtrl::tr("No template specified!"));
    24852498
    24862499    if (!fDirectory)
    24872500        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_MKTEMP,
    2488                              "Creating temporary files is currently not supported!");
     2501                             GuestCtrl::tr("Creating temporary files is currently not supported!"));
    24892502
    24902503    RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
    … …  
    24982511    {
    24992512        if (fDirectory && !strTempDir.isEmpty())
    2500             RTPrintf("Creating temporary directory from template '%s' in directory '%s' ...\n",
     2513            RTPrintf(GuestCtrl::tr("Creating temporary directory from template '%s' in directory '%s' ...\n"),
    25012514                     strTemplate.c_str(), strTempDir.c_str());
    25022515        else if (fDirectory)
    2503             RTPrintf("Creating temporary directory from template '%s' in default temporary directory ...\n",
     2516            RTPrintf(GuestCtrl::tr("Creating temporary directory from template '%s' in default temporary directory ...\n"),
    25042517                     strTemplate.c_str());
    25052518        else if (!fDirectory && !strTempDir.isEmpty())
    2506             RTPrintf("Creating temporary file from template '%s' in directory '%s' ...\n",
     2519            RTPrintf(GuestCtrl::tr("Creating temporary file from template '%s' in directory '%s' ...\n"),
    25072520                     strTemplate.c_str(), strTempDir.c_str());
    25082521        else if (!fDirectory)
    2509             RTPrintf("Creating temporary file from template '%s' in default temporary directory ...\n",
     2522            RTPrintf(GuestCtrl::tr("Creating temporary file from template '%s' in default temporary directory ...\n"),
    25102523                     strTemplate.c_str());
    25112524    }
    … …  
    25202533                                                             bstrDirectory.asOutParam()));
    25212534        if (SUCCEEDED(rc))
    2522             RTPrintf("Directory name: %ls\n", bstrDirectory.raw());
     2535            RTPrintf(GuestCtrl::tr("Directory name: %ls\n"), bstrDirectory.raw());
    25232536    }
    25242537    else
    … …  
    25642577            case 't': /* Terse */
    25652578                return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_STAT,
    2566                                      "Command \"%s\" not implemented yet!", ValueUnion.psz);
     2579                                     GuestCtrl::tr("Command \"%s\" not implemented yet!"), ValueUnion.psz);
    25672580
    25682581            default:
    … …  
    25722585
    25732586    if (ch != VINF_GETOPT_NOT_OPTION)
    2574         return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_STAT, "Nothing to stat!");
     2587        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_STAT, GuestCtrl::tr("Nothing to stat!"));
    25752588
    25762589    RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
    … …  
    25852598    {
    25862599        if (pCtx->cVerbose)
    2587             RTPrintf("Checking for element \"%s\" ...\n", ValueUnion.psz);
     2600            RTPrintf(GuestCtrl::tr("Checking for element \"%s\" ...\n"), ValueUnion.psz);
    25882601
    25892602        ComPtr<IGuestFsObjInfo> pFsObjInfo;
    … …  
    25952608             * non-existing "element" (object or file, please, nobody calls it elements). */
    25962609            if (pCtx->cVerbose)
    2597                 RTPrintf("Failed to stat '%s': No such file\n", ValueUnion.psz);
     2610                RTPrintf(GuestCtrl::tr("Failed to stat '%s': No such file\n"), ValueUnion.psz);
    25982611            rcExit = RTEXITCODE_FAILURE;
    25992612        }
    26002613        else
    26012614        {
    2602             RTPrintf("  File: '%s'\n", ValueUnion.psz); /** @todo escape this name. */
     2615            RTPrintf(GuestCtrl::tr("  File: '%s'\n"), ValueUnion.psz); /** @todo escape this name. */
    26032616
    26042617            FsObjType_T enmType = FsObjType_Unknown;
    … …  
    26352648            CHECK_ERROR2I(pFsObjInfo, COMGETTER(AccessTime)(&nsAccessTime));
    26362649
    2637             RTPrintf("  Size: %-17RU64 Alloc: %-19RU64 Type: %s\n", cbObject, cbAllocated, gctlFsObjTypeToName(enmType));
    2638             RTPrintf("Device: %#-17RX32 INode: %-18RU64 Links: %u\n", uDevNode, idNode, cHardLinks);
     2650            RTPrintf(GuestCtrl::tr("  Size: %-17RU64 Alloc: %-19RU64 Type: %s\n"),
     2651                     cbObject, cbAllocated, gctlFsObjTypeToName(enmType));
     2652            RTPrintf(GuestCtrl::tr("Device: %#-17RX32 INode: %-18RU64 Links: %u\n"), uDevNode, idNode, cHardLinks);
    26392653
    26402654            Utf8Str strAttrib(bstrAttribs);
    … …  
    26472661                pszAttribs = strchr(pszMode, '\0');
    26482662            if (uDeviceNo != 0)
    2649                 RTPrintf("  Mode: %-16s Attrib: %-17s Dev ID: %#RX32\n", pszMode, pszAttribs, uDeviceNo);
     2663                RTPrintf(GuestCtrl::tr("  Mode: %-16s Attrib: %-17s Dev ID: %#RX32\n"), pszMode, pszAttribs, uDeviceNo);
    26502664            else
    2651                 RTPrintf("  Mode: %-16s Attrib: %s\n", pszMode, pszAttribs);
    2652 
    2653             RTPrintf(" Owner: %4d/%-12ls Group: %4d/%ls\n", uid, bstrUsername.raw(),  gid, bstrGroupName.raw());
     2665                RTPrintf(GuestCtrl::tr("  Mode: %-16s Attrib: %s\n"), pszMode, pszAttribs);
     2666
     2667            RTPrintf(GuestCtrl::tr(" Owner: %4d/%-12ls Group: %4d/%ls\n"), uid, bstrUsername.raw(),  gid, bstrGroupName.raw());
    26542668
    26552669            RTTIMESPEC  TimeSpec;
    26562670            char        szTmp[RTTIME_STR_LEN];
    2657             RTPrintf(" Birth: %s\n", RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsBirthTime), szTmp, sizeof(szTmp)));
    2658             RTPrintf("Change: %s\n", RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsChangeTime), szTmp, sizeof(szTmp)));
    2659             RTPrintf("Modify: %s\n", RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsModificationTime), szTmp, sizeof(szTmp)));
    2660             RTPrintf("Access: %s\n", RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsAccessTime), szTmp, sizeof(szTmp)));
     2671            RTPrintf(GuestCtrl::tr(" Birth: %s\n"), RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsBirthTime),
     2672                     szTmp, sizeof(szTmp)));
     2673            RTPrintf(GuestCtrl::tr("Change: %s\n"), RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsChangeTime),
     2674                     szTmp, sizeof(szTmp)));
     2675            RTPrintf(GuestCtrl::tr("Modify: %s\n"), RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsModificationTime),
     2676                     szTmp, sizeof(szTmp)));
     2677            RTPrintf(GuestCtrl::tr("Access: %s\n"), RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsAccessTime),
     2678                     szTmp, sizeof(szTmp)));
    26612679
    26622680            /* Skiping: Generation ID - only the ISO9660 VFS sets this.  FreeBSD user flags. */
    … …  
    27102728
    27112729            if (pCtx->cVerbose)
    2712                 RTPrintf("Current run level is %RU32\n", enmRunLevelCur);
     2730                RTPrintf(GuestCtrl::tr("Current run level is %RU32\n"), enmRunLevelCur);
    27132731
    27142732        } while (0);
    … …  
    27172735        {
    27182736            if (pCtx->cVerbose)
    2719                 RTPrintf("Waiting for run level %RU32 ...\n", enmRunLevel);
     2737                RTPrintf(GuestCtrl::tr("Waiting for run level %RU32 ...\n"), enmRunLevel);
    27202738
    27212739            RTMSINTERVAL tsStart = RTTimeMilliTS();
    … …  
    27302748                    else
    27312749                    {
    2732                         RTPrintf("Waiting failed with %Rrc\n", vrc);
     2750                        RTPrintf(GuestCtrl::tr("Waiting failed with %Rrc\n"), vrc);
    27332751                        break;
    27342752                    }
    … …  
    27362754                else if (pCtx->cVerbose)
    27372755                {
    2738                     RTPrintf("Run level %RU32 reached\n", enmRunLevel);
     2756                    RTPrintf(GuestCtrl::tr("Run level %RU32 reached\n"), enmRunLevel);
    27392757                    break;
    27402758                }
    … …  
    27452763            if (   vrc == VERR_TIMEOUT
    27462764                && pCtx->cVerbose)
    2747                 RTPrintf("Run level %RU32 not reached within time\n", enmRunLevel);
     2765                RTPrintf(GuestCtrl::tr("Run level %RU32 not reached within time\n"), enmRunLevel);
    27482766        }
    27492767
    … …  
    28312849                vrc = RTPathAbsCxx(strSource, ValueUnion.psz);
    28322850                if (RT_FAILURE(vrc))
    2833                     return RTMsgErrorExitFailure("RTPathAbsCxx failed on '%s': %Rrc", ValueUnion.psz, vrc);
     2851                    return RTMsgErrorExitFailure(GuestCtrl::tr("RTPathAbsCxx failed on '%s': %Rrc"), ValueUnion.psz, vrc);
    28342852                break;
    28352853
    … …  
    28602878
    28612879    if (pCtx->cVerbose)
    2862         RTPrintf("Updating Guest Additions ...\n");
     2880        RTPrintf(GuestCtrl::tr("Updating Guest Additions ...\n"));
    28632881
    28642882    HRESULT rc = S_OK;
    … …  
    28762894    if (strSource.isEmpty())
    28772895    {
    2878         RTMsgError("No Guest Additions source found or specified, aborting\n");
     2896        RTMsgError(GuestCtrl::tr("No Guest Additions source found or specified, aborting\n"));
    28792897        vrc = VERR_FILE_NOT_FOUND;
    28802898    }
    28812899    else if (!RTFileExists(strSource.c_str()))
    28822900    {
    2883         RTMsgError("Source \"%s\" does not exist!\n", strSource.c_str());
     2901        RTMsgError(GuestCtrl::tr("Source \"%s\" does not exist!\n"), strSource.c_str());
    28842902        vrc = VERR_FILE_NOT_FOUND;
    28852903    }
    … …  
    28922910        if (SUCCEEDED(rc) && !guest.isNull())
    28932911        {
    2894             SHOW_STRING_PROP_NOT_EMPTY(guest, OSTypeId, "GuestOSType", "OS type:");
     2912            SHOW_STRING_PROP_NOT_EMPTY(guest, OSTypeId, "GuestOSType", GuestCtrl::tr("OS type:"));
    28952913
    28962914            AdditionsRunLevelType_T guestRunLevel; /** @todo Add a runlevel-to-string (e.g. 0 = "None") method? */
    28972915            rc = guest->COMGETTER(AdditionsRunLevel)(&guestRunLevel);
    28982916            if (SUCCEEDED(rc))
    2899                 SHOW_ULONG_VALUE("GuestAdditionsRunLevel", "Additions run level:", (ULONG)guestRunLevel, "");
     2917                SHOW_ULONG_VALUE("GuestAdditionsRunLevel", GuestCtrl::tr("Additions run level:"), (ULONG)guestRunLevel, "");
    29002918
    29012919            Bstr guestString;
    … …  
    29092927                    uRevision = 0;
    29102928                RTStrPrintf(szValue, sizeof(szValue), "%ls r%u", guestString.raw(), uRevision);
    2911                 SHOW_UTF8_STRING("GuestAdditionsVersion", "Additions version:", szValue);
     2929                SHOW_UTF8_STRING("GuestAdditionsVersion", GuestCtrl::tr("Additions version:"), szValue);
    29122930            }
    29132931#endif
    … …  
    29162934    {
    29172935        if (pCtx->cVerbose)
    2918             RTPrintf("Using source: %s\n", strSource.c_str());
     2936            RTPrintf(GuestCtrl::tr("Using source: %s\n"), strSource.c_str());
    29192937
    29202938        RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
    … …  
    29252943        {
    29262944            if (pCtx->cVerbose)
    2927                 RTPrintf("Waiting for current Guest Additions inside VM getting ready for updating ...\n");
     2945                RTPrintf(GuestCtrl::tr("Waiting for current Guest Additions inside VM getting ready for updating ...\n"));
    29282946
    29292947            const uint64_t uTsStart = RTTimeMilliTS();
    … …  
    29462964                {
    29472965                    if (pCtx->cVerbose)
    2948                         RTPrintf("Guest Additions %lsr%RU64 currently installed, waiting for Guest Additions installer to start ...\n",
     2966                        RTPrintf(GuestCtrl::tr("Guest Additions %lsr%RU64 currently installed, waiting for Guest Additions installer to start ...\n"),
    29492967                                 strGstVerCur.raw(), uGstRevCur);
    29502968                }
    … …  
    29702988
    29712989                if (SUCCEEDED(rc))
    2972                     CHECK_PROGRESS_ERROR(pProgress, ("Guest Additions update failed"));
     2990                    CHECK_PROGRESS_ERROR(pProgress, (GuestCtrl::tr("Guest Additions update failed")));
    29732991                vrc = gctlPrintProgressError(pProgress);
    29742992                if (RT_SUCCESS(vrc))
    29752993                {
    29762994                    if (pCtx->cVerbose)
    2977                         RTPrintf("Guest Additions update successful.\n");
     2995                        RTPrintf(GuestCtrl::tr("Guest Additions update successful.\n"));
    29782996
    29792997                    if (fRebootOnFinish)
    29802998                    {
    29812999                        if (pCtx->cVerbose)
    2982                             RTPrintf("Rebooting guest ...\n");
     3000                            RTPrintf(GuestCtrl::tr("Rebooting guest ...\n"));
    29833001                        com::SafeArray<GuestShutdownFlag_T> aShutdownFlags;
    29843002                        aShutdownFlags.push_back(GuestShutdownFlag_Reboot);
    … …  
    29883006                            if (rc == VBOX_E_NOT_SUPPORTED)
    29893007                            {
    2990                                 RTPrintf("Current installed Guest Additions don't support automatic rebooting. "
    2991                                          "Please reboot manually.\n");
     3008                                RTPrintf(GuestCtrl::tr("Current installed Guest Additions don't support automatic rebooting. "
     3009                                                       "Please reboot manually.\n"));
    29923010                                vrc = VERR_NOT_SUPPORTED;
    29933011                            }
    … …  
    30003018                            {
    30013019                                if (pCtx->cVerbose)
    3002                                     RTPrintf("Waiting for new Guest Additions inside VM getting ready ...\n");
     3020                                    RTPrintf(GuestCtrl::tr("Waiting for new Guest Additions inside VM getting ready ...\n"));
    30033021
    30043022                                vrc = gctlWaitForRunLevel(pCtx, AdditionsRunLevelType_Userland, cMsTimeout);
    … …  
    30083026                                    {
    30093027                                        if (pCtx->cVerbose)
    3010                                             RTPrintf("Verifying Guest Additions update ...\n");
     3028                                            RTPrintf(GuestCtrl::tr("Verifying Guest Additions update ...\n"));
    30113029
    30123030                                        /* Get new Guest Additions version / revision. */
    … …  
    30273045                                        if (pCtx->cVerbose)
    30283046                                        {
    3029                                             RTPrintf("Old Guest Additions: %ls%RU64\n", strGstVerCur.raw(), uGstRevCur);
    3030                                             RTPrintf("New Guest Additions: %ls%RU64\n", strGstVerNew.raw(), uGstRevNew);
     3047                                            RTPrintf(GuestCtrl::tr("Old Guest Additions: %ls%RU64\n"), strGstVerCur.raw(),
     3048                                                                   uGstRevCur);
     3049                                            RTPrintf(GuestCtrl::tr("New Guest Additions: %ls%RU64\n"), strGstVerNew.raw(),
     3050                                                                   uGstRevNew);
    30313051
    30323052                                            if (RT_FAILURE(vrc))
    30333053                                            {
    3034                                                 RTPrintf("\nError updating Guest Additions, please check guest installer log\n");
     3054                                                RTPrintf(GuestCtrl::tr("\nError updating Guest Additions, please check guest installer log\n"));
    30353055                                            }
    30363056                                            else
    30373057                                            {
    30383058                                                if (uGstRevNew < uGstRevCur)
    3039                                                     RTPrintf("\nWARNING: Guest Additions were downgraded\n");
     3059                                                    RTPrintf(GuestCtrl::tr("\nWARNING: Guest Additions were downgraded\n"));
    30403060                                            }
    30413061                                        }
    … …  
    30443064                            }
    30453065                            else if (pCtx->cVerbose)
    3046                                 RTPrintf("The guest needs to be restarted in order to make use of the updated Guest Additions.\n");
     3066                                RTPrintf(GuestCtrl::tr("The guest needs to be restarted in order to make use of the updated Guest Additions.\n"));
    30473067                        }
    30483068                    }
    … …  
    31183138                if (enmRunLevel == AdditionsRunLevelType_None)
    31193139                    return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_WAITRUNLEVEL,
    3120                                          "Invalid run level specified. Valid values are: system, userland, desktop");
     3140                                         GuestCtrl::tr("Invalid run level specified. Valid values are: system, userland, desktop"));
    31213141                break;
    31223142            }
    … …  
    31323152
    31333153    if (enmRunLevel == AdditionsRunLevelType_None)
    3134         return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_WAITRUNLEVEL, "Missing run level to wait for");
     3154        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_WAITRUNLEVEL, GuestCtrl::tr("Missing run level to wait for"));
    31353155
    31363156    vrc = gctlWaitForRunLevel(pCtx, enmRunLevel, cMsTimeout);
    … …  
    31803200                else
    31813201                    return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_LIST,
    3182                                          "Unknown list: '%s'", ValueUnion.psz);
     3202                                         GuestCtrl::tr("Unknown list: '%s'"), ValueUnion.psz);
    31833203                fSeenListArg = true;
    31843204                break;
    … …  
    31903210
    31913211    if (!fSeenListArg)
    3192         return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_LIST, "Missing list name");
     3212        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_LIST, GuestCtrl::tr("Missing list name"));
    31933213    Assert(fListAll || fListSessions);
    31943214
    … …  
    32113231        if (cSessions)
    32123232        {
    3213             RTPrintf("Active guest sessions:\n");
     3233            RTPrintf(GuestCtrl::tr("Active guest sessions:\n"));
    32143234
    32153235            /** @todo Make this output a bit prettier. No time now. */
    … …  
    32303250                        GuestSessionStatus_T sessionStatus;
    32313251                        CHECK_ERROR_BREAK(pCurSession, COMGETTER(Status)(&sessionStatus));
    3232                         RTPrintf("\n\tSession #%-3zu ID=%-3RU32 User=%-16ls Status=[%s] Name=%ls",
     3252                        RTPrintf(GuestCtrl::tr("\n\tSession #%-3zu ID=%-3RU32 User=%-16ls Status=[%s] Name=%ls"),
    32333253                                 i, uID, strUser.raw(), gctlGuestSessionStatusToText(sessionStatus), strName.raw());
    32343254                    } while (0);
    … …  
    32533273                                    CHECK_ERROR_BREAK(pCurProcess, COMGETTER(Status)(&procStatus));
    32543274
    3255                                     RTPrintf("\n\t\tProcess #%-03zu PID=%-6RU32 Status=[%s] Command=%ls",
     3275                                    RTPrintf(GuestCtrl::tr("\n\t\tProcess #%-03zu PID=%-6RU32 Status=[%s] Command=%ls"),
    32563276                                             a, uPID, gctlProcessStatusToText(procStatus), strExecPath.raw());
    32573277                                } while (0);
    … …  
    32813301                                    CHECK_ERROR_BREAK(pCurFile, COMGETTER(Status)(&fileStatus));
    32823302
    3283                                     RTPrintf("\n\t\tFile #%-03zu ID=%-6RU32 Status=[%s] Name=%ls",
     3303                                    RTPrintf(GuestCtrl::tr("\n\t\tFile #%-03zu ID=%-6RU32 Status=[%s] Name=%ls"),
    32843304                                             a, idFile, gctlFileStatusToText(fileStatus), strName.raw());
    32853305                                } while (0);
    … …  
    32923312            }
    32933313
    3294             RTPrintf("\n\nTotal guest sessions: %zu\n", collSessions.size());
     3314            RTPrintf(GuestCtrl::tr("\n\nTotal guest sessions: %zu\n"), collSessions.size());
    32953315            if (fListAll || fListProcesses)
    3296                 RTPrintf("Total guest processes: %zu\n", cTotalProcs);
     3316                RTPrintf(GuestCtrl::tr("Total guest processes: %zu\n"), cTotalProcs);
    32973317            if (fListAll || fListFiles)
    3298                 RTPrintf("Total guest files: %zu\n", cTotalFiles);
     3318                RTPrintf(GuestCtrl::tr("Total guest files: %zu\n"), cTotalFiles);
    32993319        }
    33003320        else
    3301             RTPrintf("No active guest sessions found\n");
     3321            RTPrintf(GuestCtrl::tr("No active guest sessions found\n"));
    33023322    }
    33033323
    … …  
    33613381                        catch (std::bad_alloc &)
    33623382                        {
    3363                             return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory");
     3383                            return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory"));
    33643384                        }
    33653385                    }
    33663386                    else
    3367                         return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_CLOSEPROCESS, "Invalid PID value: 0");
     3387                        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_CLOSEPROCESS,
     3388                                             GuestCtrl::tr("Invalid PID value: 0"));
    33683389                }
    33693390                else
    3370                     return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_CLOSEPROCESS, "Error parsing PID value: %Rrc", rc);
     3391                    return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_CLOSEPROCESS,
     3392                                         GuestCtrl::tr("Error parsing PID value: %Rrc"), rc);
    33713393                break;
    33723394            }
    … …  
    33793401    if (vecPID.empty())
    33803402        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_CLOSEPROCESS,
    3381                              "At least one PID must be specified to kill!");
     3403                             GuestCtrl::tr("At least one PID must be specified to kill!"));
    33823404
    33833405    if (   strSessionName.isEmpty()
    33843406        && idSession == UINT32_MAX)
    3385         return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_CLOSEPROCESS, "No session ID specified!");
     3407        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_CLOSEPROCESS, GuestCtrl::tr("No session ID specified!"));
    33863408
    33873409    if (   strSessionName.isNotEmpty()
    33883410        && idSession != UINT32_MAX)
    33893411        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_CLOSEPROCESS,
    3390                              "Either session ID or name (pattern) must be specified");
     3412                             GuestCtrl::tr("Either session ID or name (pattern) must be specified"));
    33913413
    33923414    RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
    … …  
    34513473                    {
    34523474                        if (pCtx->cVerbose)
    3453                             RTPrintf("Terminating process (PID %RU32) (session ID %RU32) ...\n",
     3475                            RTPrintf(GuestCtrl::tr("Terminating process (PID %RU32) (session ID %RU32) ...\n"),
    34543476                                     uPID, uID);
    34553477                        CHECK_ERROR_BREAK(pProcess, Terminate());
    … …  
    34593481                    {
    34603482                        if (idSession != UINT32_MAX)
    3461                             RTPrintf("No matching process(es) for session ID %RU32 found\n",
     3483                            RTPrintf(GuestCtrl::tr("No matching process(es) for session ID %RU32 found\n"),
    34623484                                     idSession);
    34633485                    }
    … …  
    34713493
    34723494        if (!cSessionsHandled)
    3473             RTPrintf("No matching session(s) found\n");
     3495            RTPrintf(GuestCtrl::tr("No matching session(s) found\n"));
    34743496
    34753497        if (uProcsTerminated)
    3476             RTPrintf("%RU32 %s terminated\n",
    3477                      uProcsTerminated, uProcsTerminated == 1 ? "process" : "processes");
     3498            RTPrintf(GuestCtrl::tr("%RU32 process(es) terminated\n", "", uProcsTerminated), uProcsTerminated);
    34783499
    34793500    } while (0);
    … …  
    35403561        && idSession == UINT32_MAX)
    35413562        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_CLOSESESSION,
    3542                              "No session ID specified!");
     3563                             GuestCtrl::tr("No session ID specified!"));
    35433564
    35443565    if (   !strSessionName.isEmpty()
    35453566        && idSession != UINT32_MAX)
    35463567        return errorSyntaxEx(USAGE_GUESTCONTROL, HELP_SCOPE_GSTCTRL_CLOSESESSION,
    3547                              "Either session ID or name (pattern) must be specified");
     3568                             GuestCtrl::tr("Either session ID or name (pattern) must be specified"));
    35483569
    35493570    RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
    … …  
    35833604                Assert(!pSession.isNull());
    35843605                if (pCtx->cVerbose)
    3585                     RTPrintf("Closing guest session ID=#%RU32 \"%s\" ...\n",
     3606                    RTPrintf(GuestCtrl::tr("Closing guest session ID=#%RU32 \"%s\" ...\n"),
    35863607                             uID, strNameUtf8.c_str());
    35873608                CHECK_ERROR_BREAK(pSession, Close());
    35883609                if (pCtx->cVerbose)
    3589                     RTPrintf("Guest session successfully closed\n");
     3610                    RTPrintf(GuestCtrl::tr("Guest session successfully closed\n"));
    35903611
    35913612                pSession.setNull();
    … …  
    35953616        if (!cSessionsHandled)
    35963617        {
    3597             RTPrintf("No guest session(s) found\n");
     3618            RTPrintf(GuestCtrl::tr("No guest session(s) found\n"));
    35983619            rc = E_ABORT; /* To set exit code accordingly. */
    35993620        }
    … …  
    36743695
    36753696        if (pCtx->cVerbose)
    3676             RTPrintf("Waiting for events ...\n");
     3697            RTPrintf(GuestCtrl::tr("Waiting for events ...\n"));
    36773698
    36783699        /* Wait for the global signal semaphore getting signalled. */
    … …  
    36813702        {
    36823703            if (pCtx->cVerbose)
    3683                 RTPrintf("Waiting done\n");
     3704                RTPrintf(GuestCtrl::tr("Waiting done\n"));
    36843705        }
    36853706        else if (RT_FAILURE(vrc))
    3686             RTPrintf("Waiting failed with %Rrc\n", vrc);
     3707            RTPrintf(GuestCtrl::tr("Waiting failed with %Rrc\n"), vrc);
    36873708
    36883709        if (!pGuestListener.isNull())
    … …  
    38183839                                return rcExit;
    38193840                            }
    3820                         return errorSyntax(USAGE_GUESTCONTROL, "Unknown sub-command: '%s'", pszCmd);
     3841                        return errorSyntax(USAGE_GUESTCONTROL, GuestCtrl::tr("Unknown sub-command: '%s'"), pszCmd);
    38213842                    }
    38223843                    break;
    … …  
    38273848        }
    38283849        if (CmdCtx.pszVmNameOrUuid)
    3829             rcExit = errorSyntax(USAGE_GUESTCONTROL, "Missing sub-command");
     3850            rcExit = errorSyntax(USAGE_GUESTCONTROL, GuestCtrl::tr("Missing sub-command"));
    38303851        else
    3831             rcExit = errorSyntax(USAGE_GUESTCONTROL, "Missing VM name and sub-command");
     3852            rcExit = errorSyntax(USAGE_GUESTCONTROL, GuestCtrl::tr("Missing VM name and sub-command"));
    38323853    }
    38333854    return rcExit;
    38343855}
    38353856#endif /* !VBOX_ONLY_DOCS */
    3836 

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrlListener.cpp

    r84519 r92372  
    3535#include <vector>
    3636
     37DECLARE_TRANSLATION_CONTEXT(GuestCtrlLsnr);
     38
    3739
    3840/** Event semaphore we're using for notification. */
    … …  
    104106                CHECK_ERROR_BREAK(pProcess, COMGETTER(Id)(&uID));
    105107
    106                 RTPrintf("File ID=%RU32 \"%s\" changed status to [%s]\n",
     108                RTPrintf(GuestCtrlLsnr::tr("File ID=%RU32 \"%s\" changed status to [%s]\n"),
    107109                         uID, Utf8Str(strPath).c_str(), gctlFileStatusToText(fileSts));
    108110
    … …  
    160162                CHECK_ERROR_BREAK(pProcess, COMGETTER(PID)(&uPID));
    161163
    162                 RTPrintf("Process PID=%RU32 \"%s\" changed status to [%s]\n",
     164                RTPrintf(GuestCtrlLsnr::tr("Process PID=%RU32 \"%s\" changed status to [%s]\n"),
    163165                         uPID, Utf8Str(strPath).c_str(), gctlProcessStatusToText(procSts));
    164166
    … …  
    254256                CHECK_ERROR_BREAK(pFile, COMGETTER(Filename)(strPath.asOutParam()));
    255257
    256                 RTPrintf("File \"%s\" %s\n",
     258                RTPrintf(GuestCtrlLsnr::tr("File \"%s\" %s\n"),
    257259                         Utf8Str(strPath).c_str(),
    258                          fRegistered ? "registered" : "unregistered");
     260                         fRegistered ? GuestCtrlLsnr::tr("registered") : GuestCtrlLsnr::tr("unregistered"));
    259261                if (fRegistered)
    260262                {
    261263                    if (mfVerbose)
    262                         RTPrintf("Registering ...\n");
     264                        RTPrintf(GuestCtrlLsnr::tr("Registering ...\n"));
    263265
    264266                    /* Register for IGuestFile events. */
    … …  
    283285                    {
    284286                        if (mfVerbose)
    285                             RTPrintf("Unregistering file ...\n");
     287                            RTPrintf(GuestCtrlLsnr::tr("Unregistering file ...\n"));
    286288
    287289                        if (!itFile->first.isNull())
    … …  
    319321                CHECK_ERROR_BREAK(pProcess, COMGETTER(ExecutablePath)(strPath.asOutParam()));
    320322
    321                 RTPrintf("Process \"%s\" %s\n",
     323                RTPrintf(GuestCtrlLsnr::tr("Process \"%s\" %s\n"),
    322324                         Utf8Str(strPath).c_str(),
    323                          fRegistered ? "registered" : "unregistered");
     325                         fRegistered ? GuestCtrlLsnr::tr("registered") : GuestCtrlLsnr::tr("unregistered"));
    324326                if (fRegistered)
    325327                {
    326328                    if (mfVerbose)
    327                         RTPrintf("Registering ...\n");
     329                        RTPrintf(GuestCtrlLsnr::tr("Registering ...\n"));
    328330
    329331                    /* Register for IGuestProcess events. */
    … …  
    348350                    {
    349351                        if (mfVerbose)
    350                             RTPrintf("Unregistering process ...\n");
     352                            RTPrintf(GuestCtrlLsnr::tr("Unregistering process ...\n"));
    351353
    352354                        if (!itProc->first.isNull())
    … …  
    386388                CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam()));
    387389
    388                 RTPrintf("Session ID=%RU32 \"%s\" changed status to [%s]\n",
     390                RTPrintf(GuestCtrlLsnr::tr("Session ID=%RU32 \"%s\" changed status to [%s]\n"),
    389391                         uID, Utf8Str(strName).c_str(), gctlGuestSessionStatusToText(sessSts));
    390392
    … …  
    462464                CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID));
    463465
    464                 RTPrintf("Session ID=%RU32 \"%s\" %s\n",
     466                RTPrintf(GuestCtrlLsnr::tr("Session ID=%RU32 \"%s\" %s\n"),
    465467                         uID, Utf8Str(strName).c_str(),
    466                          fRegistered ? "registered" : "unregistered");
     468                         fRegistered ? GuestCtrlLsnr::tr("registered") : GuestCtrlLsnr::tr("unregistered"));
    467469                if (fRegistered)
    468470                {
    469471                    if (mfVerbose)
    470                         RTPrintf("Registering ...\n");
     472                        RTPrintf(GuestCtrlLsnr::tr("Registering ...\n"));
    471473
    472474                    /* Register for IGuestSession events. */
    … …  
    492494                    {
    493495                        if (mfVerbose)
    494                             RTPrintf("Unregistering ...\n");
     496                            RTPrintf(GuestCtrlLsnr::tr("Unregistering ...\n"));
    495497
    496498                        if (!itSession->first.isNull())
    … …  
    555557
    556558            if (mfVerbose)
    557                 RTPrintf("Reached run level %RU32\n", RunLevelCur);
     559                RTPrintf(GuestCtrlLsnr::tr("Reached run level %RU32\n"), RunLevelCur);
    558560
    559561            if (RunLevelCur == mRunLevelTarget)
    … …  
    574576
    575577#endif /* !VBOX_ONLY_DOCS */
    576 

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestProp.cpp

    r82968 r92372  
    5151#endif /* !VBOX_ONLY_DOCS */
    5252
     53DECLARE_TRANSLATION_CONTEXT(GuestProp);
     54
     55
    5356void usageGuestProperty(PRTSTREAM pStrm, const char *pcszSep1, const char *pcszSep2)
    5457{
    55     RTStrmPrintf(pStrm,
    56                        "%s guestproperty %s   get <uuid|vmname>\n"
    57                  "                            <property> [--verbose]\n"
    58                  "\n", pcszSep1, pcszSep2);
    59     RTStrmPrintf(pStrm,
    60                        "%s guestproperty %s   set <uuid|vmname>\n"
    61                  "                            <property> [<value> [--flags <flags>]]\n"
    62                  "\n", pcszSep1, pcszSep2);
    63     RTStrmPrintf(pStrm,
    64                        "%s guestproperty %s   delete|unset <uuid|vmname>\n"
    65                  "                            <property>\n"
    66                  "\n", pcszSep1, pcszSep2);
    67     RTStrmPrintf(pStrm,
    68                        "%s guestproperty %s   enumerate <uuid|vmname>\n"
    69                  "                            [--patterns <patterns>]\n"
    70                  "\n", pcszSep1, pcszSep2);
    71     RTStrmPrintf(pStrm,
    72                        "%s guestproperty %s   wait <uuid|vmname> <patterns>\n"
    73                  "                            [--timeout <msec>] [--fail-on-timeout]\n"
    74                  "\n", pcszSep1, pcszSep2);
     58    RTStrmPrintf(pStrm, GuestProp::tr("%s guestproperty %s   get <uuid|vmname>\n"
     59                                "                            <property> [--verbose]\n"
     60                                "\n"), pcszSep1, pcszSep2);
     61    RTStrmPrintf(pStrm, GuestProp::tr("%s guestproperty %s   set <uuid|vmname>\n"
     62                                "                            <property> [<value> [--flags <flags>]]\n"
     63                                "\n"), pcszSep1, pcszSep2);
     64    RTStrmPrintf(pStrm, GuestProp::tr("%s guestproperty %s   delete|unset <uuid|vmname>\n"
     65                                "                            <property>\n"
     66                                "\n"), pcszSep1, pcszSep2);
     67    RTStrmPrintf(pStrm, GuestProp::tr("%s guestproperty %s   enumerate <uuid|vmname>\n"
     68                                "                            [--patterns <patterns>]\n"
     69                                "\n"), pcszSep1, pcszSep2);
     70    RTStrmPrintf(pStrm, GuestProp::tr("%s guestproperty %s   wait <uuid|vmname> <patterns>\n"
     71                                "                            [--timeout <msec>] [--fail-on-timeout]\n"
     72                                "\n"), pcszSep1, pcszSep2);
    7573}
    7674
    … …  
    8785        verbose = true;
    8886    else if (a->argc != 2)
    89         return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
     87        return errorSyntax(USAGE_GUESTPROPERTY, GuestProp::tr("Incorrect parameters"));
    9088
    9189    ComPtr<IMachine> machine;
    … …  
    107105                                              &i64Timestamp, flags.asOutParam()));
    108106        if (value.isEmpty())
    109             RTPrintf("No value set!\n");
     107            RTPrintf(GuestProp::tr("No value set!\n"));
    110108        else
    111             RTPrintf("Value: %ls\n", value.raw());
     109            RTPrintf(GuestProp::tr("Value: %ls\n"), value.raw());
    112110        if (!value.isEmpty() && verbose)
    113111        {
    114             RTPrintf("Timestamp: %lld\n", i64Timestamp);
    115             RTPrintf("Flags: %ls\n", flags.raw());
     112            RTPrintf(GuestProp::tr("Timestamp: %lld\n"), i64Timestamp);
     113            RTPrintf(GuestProp::tr("Flags: %ls\n"), flags.raw());
    116114        }
    117115    }
    … …  
    146144        usageOK = false;
    147145    if (!usageOK)
    148         return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
     146        return errorSyntax(USAGE_GUESTPROPERTY, GuestProp::tr("Incorrect parameters"));
    149147    /* This is always needed. */
    150148    pszName = a->argv[1];
    … …  
    190188        usageOK = false;
    191189    if (!usageOK)
    192         return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
     190        return errorSyntax(USAGE_GUESTPROPERTY, GuestProp::tr("Incorrect parameters"));
    193191    /* This is always needed. */
    194192    pszName = a->argv[1];
    … …  
    232230             && strcmp(a->argv[1], "--patterns")
    233231             && strcmp(a->argv[1], "-patterns")))
    234         return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
     232        return errorSyntax(USAGE_GUESTPROPERTY, GuestProp::tr("Incorrect parameters"));
    235233
    236234    /*
    … …  
    268266        {
    269267            if (names.size() == 0)
    270                 RTPrintf("No properties found.\n");
     268                RTPrintf(GuestProp::tr("No properties found.\n"));
    271269            for (unsigned i = 0; i < names.size(); ++i)
    272                 RTPrintf("Name: %ls, value: %ls, timestamp: %lld, flags: %ls\n",
     270                RTPrintf(GuestProp::tr("Name: %ls, value: %ls, timestamp: %lld, flags: %ls\n"),
    273271                         names[i], values[i], timestamps[i], flags[i]);
    274272        }
    … …  
    319317    }
    320318    if (!usageOK)
    321         return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
     319        return errorSyntax(USAGE_GUESTPROPERTY, GuestProp::tr("Incorrect parameters"));
    322320
    323321    /*
    … …  
    374372                        gpcev->COMGETTER(Value)(aNextValue.asOutParam());
    375373                        gpcev->COMGETTER(Flags)(aNextFlags.asOutParam());
    376                         RTPrintf("Name: %ls, value: %ls, flags: %ls\n",
     374                        RTPrintf(GuestProp::tr("Name: %ls, value: %ls, flags: %ls\n"),
    377375                                 aNextName.raw(), aNextValue.raw(), aNextFlags.raw());
    378376                        fSignalled = true;
    … …  
    391389    if (!fSignalled)
    392390    {
    393         RTMsgError("Time out or interruption while waiting for a notification.");
     391        RTMsgError(GuestProp::tr("Time out or interruption while waiting for a notification."));
    394392        if (fFailOnTimeout)
    395393            /* Hysterical rasins: We always returned 2 here, which now translates to syntax error... Which is bad. */
    … …  
    417415
    418416    if (a->argc == 0)
    419         return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
     417        return errorSyntax(USAGE_GUESTPROPERTY, GuestProp::tr("Incorrect parameters"));
    420418
    421419    /* switch (cmd) */
    … …  
    432430
    433431    /* default: */
    434     return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters");
     432    return errorSyntax(USAGE_GUESTPROPERTY, GuestProp::tr("Incorrect parameters"));
    435433}
    436434

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageHelp.cpp

    r92364 r92372  
    4545*   Global Variables                                                                                                             *
    4646*********************************************************************************************************************************/
     47DECLARE_TRANSLATION_CONTEXT(Help);
     48
    4749#ifndef VBOX_ONLY_DOCS
    4850static enum HELP_CMD_VBOXMANAGE    g_enmCurCommand = HELP_CMD_VBOXMANAGE_INVALID;
    … …  
    103105            {
    104106                if (fSubcommandScope == RTMSGREFENTRYSTR_SCOPE_GLOBAL)
    105                     RTStrmPrintf(pStrm, "Usage - %c%s:\n", RT_C_TO_UPPER(pHelp->pszBrief[0]), pHelp->pszBrief + 1);
     107                    RTStrmPrintf(pStrm, Help::tr("Usage - %c%s:\n"), RT_C_TO_UPPER(pHelp->pszBrief[0]), pHelp->pszBrief + 1);
    106108                else
    107                     RTStrmPrintf(pStrm, "Usage:\n");
     109                    RTStrmPrintf(pStrm, Help::tr("Usage:\n"));
    108110            }
    109111            RTMsgRefEntryPrintStringTable(pStrm, &pHelp->Synopsis, fSubcommandScope, &cPendingBlankLines, &cLinesWritten);
    … …  
    177179    Assert(g_fCurSubcommandScope == RTMSGREFENTRYSTR_SCOPE_GLOBAL);
    178180
    179     return errorSyntax("No subcommand specified");
     181    return errorSyntax(Help::tr("No subcommand specified"));
    180182}
    181183
    … …  
    203205    }
    204206
    205     return errorSyntax("Unknown subcommand: %s", pszSubcommand);
     207    return errorSyntax(Help::tr("Unknown subcommand: %s"), pszSubcommand);
    206208}
    207209
    … …  
    236238    }
    237239
    238     return errorSyntax("Too many parameters");
     240    return errorSyntax(Help::tr("Too many parameters"));
    239241}
    240242
    … …  
    281283{
    282284    if (rcGetOpt == VINF_GETOPT_NOT_OPTION)
    283         RTMsgError("Invalid parameter '%s'", pValueUnion->psz);
     285        RTMsgError(Help::tr("Invalid parameter '%s'"), pValueUnion->psz);
    284286    else if (rcGetOpt > 0)
    285287    {
    286288        if (RT_C_IS_PRINT(rcGetOpt))
    287             RTMsgError("Invalid option -%c", rcGetOpt);
     289            RTMsgError(Help::tr("Invalid option -%c"), rcGetOpt);
    288290        else
    289             RTMsgError("Invalid option case %i", rcGetOpt);
     291            RTMsgError(Help::tr("Invalid option case %i"), rcGetOpt);
    290292    }
    291293    else if (rcGetOpt == VERR_GETOPT_UNKNOWN_OPTION)
    292         RTMsgError("Unknown option: %s", pValueUnion->psz);
     294        RTMsgError(Help::tr("Unknown option: %s"), pValueUnion->psz);
    293295    else if (rcGetOpt == VERR_GETOPT_INVALID_ARGUMENT_FORMAT)
    294         RTMsgError("Invalid argument format: %s", pValueUnion->psz);
     296        RTMsgError(Help::tr("Invalid argument format: %s"), pValueUnion->psz);
    295297    else if (pValueUnion->pDef)
    296298        RTMsgError("%s: %Rrs", pValueUnion->pDef->pszLong, rcGetOpt);
    … …  
    316318    showLogo(g_pStdErr);
    317319    if (rcGetOptFetchValue == VERR_GETOPT_REQUIRED_ARGUMENT_MISSING)
    318         RTMsgError("Missing the %u%s value for option %s",
    319                    iValueNo, iValueNo == 1 ? "st" : iValueNo == 2 ? "nd" : iValueNo == 3 ? "rd" : "th",  pszOption);
     320        RTMsgError(Help::tr("Missing the %u%s value for option %s"),
     321                   iValueNo,
     322                   iValueNo == 1 ? Help::tr("st")
     323                    : iValueNo == 2 ? Help::tr("nd")
     324                    : iValueNo == 3 ? Help::tr("rd")
     325                    : Help::tr("th"),
     326                   pszOption);
    320327    else
    321328        errorGetOptWorker(rcGetOptFetchValue, pValueUnion);
    … …  
    442449
    443450    RTStrmPrintf(pStrm,
    444                  "Usage:\n"
    445                  "\n");
     451                 Help::tr("Usage:\n"
     452                          "\n"));
    446453
    447454    if (enmCommand == USAGE_S_ALL)
    448455        RTStrmPrintf(pStrm,
    449                      "  VBoxManage [<general option>] <command>\n"
    450                      "\n"
    451                      "\n"
    452                      "General Options:\n"
    453                      "\n"
    454                      "  [-V|--version]            print version number and exit\n"
    455                      "  [--dump-build-type]       print build type and exit\n"
    456                      "  [-q|--nologo]             suppress the logo\n"
    457                      "  [--settingspw <pw>]       provide the settings password\n"
    458                      "  [--settingspwfile <file>] provide a file containing the settings password\n"
    459                      "  [@<response-file>]        load arguments from the given response file (bourne style)\n"
    460                      "\n"
    461                      "\n"
    462                      "Commands:\n"
    463                      "\n");
     456                     Help::tr(
     457                       "  VBoxManage [<general option>] <command>\n"
     458                       "\n"
     459                       "\n"
     460                       "General Options:\n"
     461                       "\n"
     462                       "  [-V|--version]            print version number and exit\n"
     463                       "  [--dump-build-type]       print build type and exit\n"
     464                       "  [-q|--nologo]             suppress the logo\n"
     465                       "  [--settingspw <pw>]       provide the settings password\n"
     466                       "  [--settingspwfile <file>] provide a file containing the settings password\n"
     467                       "  [@<response-file>]        load arguments from the given response file (bourne style)\n"
     468                       "\n"
     469                       "\n"
     470                       "Commands:\n"
     471                       "\n"));
    464472
    465473    const char *pcszSep1 = " ";
    … …  
    476484    {
    477485        RTStrmPrintf(pStrm,
    478                            "%s startvm %s         <uuid|vmname>...\n"
    479                      "                            [--type gui", SEP);
     486                     Help::tr(
     487                             "%s startvm %s         <uuid|vmname>...\n"
     488                       "                            [--type gui"), SEP);
    480489        if (fVBoxSDL)
    481490            RTStrmPrintf(pStrm, "|sdl");
    482491        RTStrmPrintf(pStrm, "|headless|separate]\n");
    483492        RTStrmPrintf(pStrm,
    484                      "                            [-E|--putenv <NAME>[=<VALUE>]]\n"
    485                      "\n");
     493                     Help::tr(
     494                       "                            [-E|--putenv <NAME>[=<VALUE>]]\n"
     495                       "\n"));
    486496    }
    487497
    … …  
    489499    {
    490500        RTStrmPrintf(pStrm,
    491                            "%s controlvm %s       <uuid|vmname>\n"
    492                      "                            pause|resume|reset|poweroff|savestate|\n"
     501                     Help::tr(
     502                             "%s controlvm %s       <uuid|vmname>\n"
     503                       "                            pause|resume|reset|poweroff|savestate|\n"), SEP);
    493504#ifdef VBOX_WITH_GUEST_CONTROL
    494                      "                            reboot|shutdown [--force]|\n"
    495 #endif
    496                      "                            acpipowerbutton|acpisleepbutton|\n"
    497                      "                            keyboardputscancode <hex> [<hex> ...]|\n"
    498                      "                            keyboardputstring <string1> [<string2> ...]|\n"
    499                      "                            keyboardputfile <filename>|\n"
    500                      "                            setlinkstate<1-N> on|off |\n"
     505        RTStrmPrintf(pStrm,
     506                       "                            reboot|shutdown [--force]|\n");
     507#endif
     508        RTStrmPrintf(pStrm,
     509                     Help::tr(
     510                       "                            acpipowerbutton|acpisleepbutton|\n"
     511                       "                            keyboardputscancode <hex> [<hex> ...]|\n"
     512                       "                            keyboardputstring <string1> [<string2> ...]|\n"
     513                       "                            keyboardputfile <filename>|\n"
     514                       "                            setlinkstate<1-N> on|off |\n"));
    501515#if defined(VBOX_WITH_NETFLT)
    502                      "                            nic<1-N> null|nat|bridged|intnet|hostonly|generic|\n"
    503                      "                                     natnetwork [<devicename>] |\n"
     516        RTStrmPrintf(pStrm,
     517                     Help::tr(
     518                       "                            nic<1-N> null|nat|bridged|intnet|hostonly|generic|\n"
     519                       "                                     natnetwork [<devicename>] |\n"));
    504520#else /* !VBOX_WITH_NETFLT */
    505                      "                            nic<1-N> null|nat|bridged|intnet|generic|natnetwork\n"
    506                      "                                     [<devicename>] |\n"
     521        RTStrmPrintf(pStrm,
     522                     Help::tr(
     523                       "                            nic<1-N> null|nat|bridged|intnet|generic|natnetwork\n"
     524                       "                                     [<devicename>] |\n"));
    507525#endif /* !VBOX_WITH_NETFLT */
    508                      "                            nictrace<1-N> on|off |\n"
    509                      "                            nictracefile<1-N> <filename> |\n"
    510                      "                            nicproperty<1-N> name=[value] |\n"
    511                      "                            nicpromisc<1-N> deny|allow-vms|allow-all |\n"
    512                      "                            natpf<1-N> [<rulename>],tcp|udp,[<hostip>],\n"
    513                      "                                        <hostport>,[<guestip>],<guestport> |\n"
    514                      "                            natpf<1-N> delete <rulename> |\n"
    515                      "                            guestmemoryballoon <balloonsize in MB> |\n"
    516                      "                            usbattach <uuid>|<address>\n"
    517                      "                                      [--capturefile <filename>] |\n"
    518                      "                            usbdetach <uuid>|<address> |\n"
    519                      "                            audioin on|off |\n"
    520                      "                            audioout on|off |\n"
     526        RTStrmPrintf(pStrm,
     527                     Help::tr(
     528                       "                            nictrace<1-N> on|off |\n"
     529                       "                            nictracefile<1-N> <filename> |\n"
     530                       "                            nicproperty<1-N> name=[value] |\n"
     531                       "                            nicpromisc<1-N> deny|allow-vms|allow-all |\n"
     532                       "                            natpf<1-N> [<rulename>],tcp|udp,[<hostip>],\n"
     533                       "                                        <hostport>,[<guestip>],<guestport> |\n"
     534                       "                            natpf<1-N> delete <rulename> |\n"
     535                       "                            guestmemoryballoon <balloonsize in MB> |\n"
     536                       "                            usbattach <uuid>|<address>\n"
     537                       "                                      [--capturefile <filename>] |\n"
     538                       "                            usbdetach <uuid>|<address> |\n"
     539                       "                            audioin on|off |\n"
     540                       "                            audioout on|off |\n"));
    521541#ifdef VBOX_WITH_SHARED_CLIPBOARD
    522                      "                            clipboard mode disabled|hosttoguest|guesttohost|\n"
    523                      "                                           bidirectional |\n"
     542        RTStrmPrintf(pStrm,
     543                       "                            clipboard mode disabled|hosttoguest|guesttohost|\n"
     544                       "                                           bidirectional |\n");
    524545# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    525                      "                            clipboard filetransfers enabled|disabled |\n"
     546        RTStrmPrintf(pStrm,
     547                       "                            clipboard filetransfers enabled|disabled |\n");
    526548# endif
    527549#endif
    528                      "                            draganddrop disabled|hosttoguest|guesttohost|\n"
    529                      "                                        bidirectional |\n"
    530                      "                            vrde on|off |\n"
    531                      "                            vrdeport <port> |\n"
    532                      "                            vrdeproperty <name=[value]> |\n"
    533                      "                            vrdevideochannelquality <percent> |\n"
    534                      "                            setvideomodehint <xres> <yres> <bpp>\n"
    535                      "                                            [[<display>] [<enabled:yes|no> |\n"
    536                      "                                              [<xorigin> <yorigin>]]] |\n"
    537                      "                            setscreenlayout <display> on|primary <xorigin> <yorigin> <xres> <yres> <bpp> | off\n"
    538                      "                            screenshotpng <file> [display] |\n"
     550        RTStrmPrintf(pStrm,
     551                     Help::tr(
     552                       "                            draganddrop disabled|hosttoguest|guesttohost|\n"
     553                       "                                        bidirectional |\n"
     554                       "                            vrde on|off |\n"
     555                       "                            vrdeport <port> |\n"
     556                       "                            vrdeproperty <name=[value]> |\n"
     557                       "                            vrdevideochannelquality <percent> |\n"
     558                       "                            setvideomodehint <xres> <yres> <bpp>\n"
     559                       "                                            [[<display>] [<enabled:yes|no> |\n"
     560                       "                                              [<xorigin> <yorigin>]]] |\n"
     561                       "                            setscreenlayout <display> on|primary <xorigin> <yorigin> <xres> <yres> <bpp> | off\n"
     562                       "                            screenshotpng <file> [display] |\n"));
    539563#ifdef VBOX_WITH_RECORDING
    540                      "                            recording on|off |\n"
    541                      "                            recording screens all|none|<screen>,[<screen>...] |\n"
    542                      "                            recording filename <file> |\n"
    543                      "                            recording videores <width>x<height> |\n"
    544                      "                            recording videorate <rate> |\n"
    545                      "                            recording videofps <fps> |\n"
    546                      "                            recording maxtime <s> |\n"
    547                      "                            recording maxfilesize <MB> |\n"
     564        RTStrmPrintf(pStrm,
     565                     Help::tr(
     566                       "                            recording on|off |\n"
     567                       "                            recording screens all|none|<screen>,[<screen>...] |\n"
     568                       "                            recording filename <file> |\n"
     569                       "                            recording videores <width>x<height> |\n"
     570                       "                            recording videorate <rate> |\n"
     571                       "                            recording videofps <fps> |\n"
     572                       "                            recording maxtime <s> |\n"
     573                       "                            recording maxfilesize <MB> |\n"));
    548574#endif /* VBOX_WITH_RECORDING */
    549                      "                            setcredentials <username>\n"
    550                      "                                           --passwordfile <file> | <password>\n"
    551                      "                                           <domain>\n"
    552                      "                                           [--allowlocallogon <yes|no>] |\n"
    553                      "                            teleport --host <name> --port <port>\n"
    554                      "                                     [--maxdowntime <msec>]\n"
    555                      "                                     [--passwordfile <file> |\n"
    556                      "                                      --password <password>] |\n"
    557                      "                            plugcpu <id> |\n"
    558                      "                            unplugcpu <id> |\n"
    559                      "                            cpuexecutioncap <1-100>\n"
    560                      "                            webcam <attach [path [settings]]> | <detach [path]> | <list>\n"
    561                      "                            addencpassword <id>\n"
    562                      "                                           <password file>|-\n"
    563                      "                                           [--removeonsuspend <yes|no>]\n"
    564                      "                            removeencpassword <id>\n"
    565                      "                            removeallencpasswords\n"
    566                      "                            changeuartmode<1-N> disconnected|\n"
    567                      "                                                server <pipe>|\n"
    568                      "                                                client <pipe>|\n"
    569                      "                                                tcpserver <port>|\n"
    570                      "                                                tcpclient <hostname:port>|\n"
    571                      "                                                file <file>|\n"
    572                      "                                                <devicename>\n"
    573                      "                            vm-process-priority default|flat|low|normal|high\n"
    574                      "                            autostart-enabled on|off\n"
    575                      "                            autostart-delay <seconds>\n"
    576                      "\n", SEP);
     575        RTStrmPrintf(pStrm,
     576                     Help::tr(
     577                       "                            setcredentials <username>\n"
     578                       "                                           --passwordfile <file> | <password>\n"
     579                       "                                           <domain>\n"
     580                       "                                           [--allowlocallogon <yes|no>] |\n"
     581                       "                            teleport --host <name> --port <port>\n"
     582                       "                                     [--maxdowntime <msec>]\n"
     583                       "                                     [--passwordfile <file> |\n"
     584                       "                                      --password <password>] |\n"
     585                       "                            plugcpu <id> |\n"
     586                       "                            unplugcpu <id> |\n"
     587                       "                            cpuexecutioncap <1-100>\n"
     588                       "                            webcam <attach [path [settings]]> | <detach [path]> | <list>\n"
     589                       "                            addencpassword <id>\n"
     590                       "                                           <password file>|-\n"
     591                       "                                           [--removeonsuspend <yes|no>]\n"
     592                       "                            removeencpassword <id>\n"
     593                       "                            removeallencpasswords\n"
     594                       "                            changeuartmode<1-N> disconnected|\n"
     595                       "                                                server <pipe>|\n"
     596                       "                                                client <pipe>|\n"
     597                       "                                                tcpserver <port>|\n"
     598                       "                                                tcpclient <hostname:port>|\n"
     599                       "                                                file <file>|\n"
     600                       "                                                <devicename>\n"
     601                       "                            vm-process-priority default|flat|low|normal|high\n"
     602                       "                            autostart-enabled on|off\n"
     603                       "                            autostart-delay <seconds>\n"
     604                       "\n"));
    577605    }
    578606
    579607    if (enmCommand == USAGE_DISCARDSTATE || enmCommand == USAGE_S_ALL)
    580608        RTStrmPrintf(pStrm,
    581                            "%s discardstate %s    <uuid|vmname>\n"
    582                      "\n", SEP);
     609                     Help::tr(
     610                             "%s discardstate %s    <uuid|vmname>\n"
     611                       "\n"), SEP);
    583612
    584613    if (enmCommand == USAGE_ADOPTSTATE || enmCommand == USAGE_S_ALL)
    585614        RTStrmPrintf(pStrm,
    586                            "%s adoptstate %s      <uuid|vmname> <state_file>\n"
    587                      "\n", SEP);
     615                     Help::tr(
     616                             "%s adoptstate %s      <uuid|vmname> <state_file>\n"
     617                       "\n"), SEP);
    588618
    589619    if (enmCommand == USAGE_CLOSEMEDIUM || enmCommand == USAGE_S_ALL)
    590620        RTStrmPrintf(pStrm,
    591                            "%s closemedium %s     [disk|dvd|floppy] <uuid|filename>\n"
    592                      "                            [--delete]\n"
    593                      "\n", SEP);
     621                     Help::tr(
     622                             "%s closemedium %s     [disk|dvd|floppy] <uuid|filename>\n"
     623                       "                            [--delete]\n"
     624                       "\n"), SEP);
    594625
    595626    if (enmCommand == USAGE_STORAGEATTACH || enmCommand == USAGE_S_ALL)
    596627        RTStrmPrintf(pStrm,
    597                            "%s storageattach %s   <uuid|vmname>\n"
    598                      "                            --storagectl <name>\n"
    599                      "                            [--port <number>]\n"
    600                      "                            [--device <number>]\n"
    601                      "                            [--type dvddrive|hdd|fdd]\n"
    602                      "                            [--medium none|emptydrive|additions|\n"
    603                      "                                      <uuid|filename>|host:<drive>|iscsi]\n"
    604                      "                            [--mtype normal|writethrough|immutable|shareable|\n"
    605                      "                                     readonly|multiattach]\n"
    606                      "                            [--comment <text>]\n"
    607                      "                            [--setuuid <uuid>]\n"
    608                      "                            [--setparentuuid <uuid>]\n"
    609                      "                            [--passthrough on|off]\n"
    610                      "                            [--tempeject on|off]\n"
    611                      "                            [--nonrotational on|off]\n"
    612                      "                            [--discard on|off]\n"
    613                      "                            [--hotpluggable on|off]\n"
    614                      "                            [--bandwidthgroup <name>]\n"
    615                      "                            [--forceunmount]\n"
    616                      "                            [--server <name>|<ip>]\n"
    617                      "                            [--target <target>]\n"
    618                      "                            [--tport <port>]\n"
    619                      "                            [--lun <lun>]\n"
    620                      "                            [--encodedlun <lun>]\n"
    621                      "                            [--username <username>]\n"
    622                      "                            [--password <password>]\n"
    623                      "                            [--passwordfile <file>]\n"
    624                      "                            [--initiator <initiator>]\n"
    625                      "                            [--intnet]\n"
    626                      "\n", SEP);
     628                     Help::tr(
     629                             "%s storageattach %s   <uuid|vmname>\n"
     630                       "                            --storagectl <name>\n"
     631                       "                            [--port <number>]\n"
     632                       "                            [--device <number>]\n"
     633                       "                            [--type dvddrive|hdd|fdd]\n"
     634                       "                            [--medium none|emptydrive|additions|\n"
     635                       "                                      <uuid|filename>|host:<drive>|iscsi]\n"
     636                       "                            [--mtype normal|writethrough|immutable|shareable|\n"
     637                       "                                     readonly|multiattach]\n"
     638                       "                            [--comment <text>]\n"
     639                       "                            [--setuuid <uuid>]\n"
     640                       "                            [--setparentuuid <uuid>]\n"
     641                       "                            [--passthrough on|off]\n"
     642                       "                            [--tempeject on|off]\n"
     643                       "                            [--nonrotational on|off]\n"
     644                       "                            [--discard on|off]\n"
     645                       "                            [--hotpluggable on|off]\n"
     646                       "                            [--bandwidthgroup <name>]\n"
     647                       "                            [--forceunmount]\n"
     648                       "                            [--server <name>|<ip>]\n"
     649                       "                            [--target <target>]\n"
     650                       "                            [--tport <port>]\n"
     651                       "                            [--lun <lun>]\n"
     652                       "                            [--encodedlun <lun>]\n"
     653                       "                            [--username <username>]\n"
     654                       "                            [--password <password>]\n"
     655                       "                            [--passwordfile <file>]\n"
     656                       "                            [--initiator <initiator>]\n"
     657                       "                            [--intnet]\n"
     658                       "\n"), SEP);
    627659
    628660    if (enmCommand == USAGE_STORAGECONTROLLER || enmCommand == USAGE_S_ALL)
    629661        RTStrmPrintf(pStrm,
    630                            "%s storagectl %s      <uuid|vmname>\n"
    631                      "                            --name <name>\n"
    632                      "                            [--add ide|sata|scsi|floppy|sas|usb|pcie|virtio]\n"
    633                      "                            [--controller LSILogic|LSILogicSAS|BusLogic|\n"
    634                      "                                          IntelAHCI|PIIX3|PIIX4|ICH6|I82078|\n"
    635                      "                            [             USB|NVMe|VirtIO]\n"
    636                      "                            [--portcount <1-n>]\n"
    637                      "                            [--hostiocache on|off]\n"
    638                      "                            [--bootable on|off]\n"
    639                      "                            [--rename <name>]\n"
    640                      "                            [--remove]\n"
    641                      "\n", SEP);
     662                     Help::tr(
     663                             "%s storagectl %s      <uuid|vmname>\n"
     664                       "                            --name <name>\n"
     665                       "                            [--add ide|sata|scsi|floppy|sas|usb|pcie|virtio]\n"
     666                       "                            [--controller LSILogic|LSILogicSAS|BusLogic|\n"
     667                       "                                          IntelAHCI|PIIX3|PIIX4|ICH6|I82078|\n"
     668                       "                            [             USB|NVMe|VirtIO]\n"
     669                       "                            [--portcount <1-n>]\n"
     670                       "                            [--hostiocache on|off]\n"
     671                       "                            [--bootable on|off]\n"
     672                       "                            [--rename <name>]\n"
     673                       "                            [--remove]\n"
     674                       "\n"), SEP);
    642675
    643676    if (enmCommand == USAGE_BANDWIDTHCONTROL || enmCommand == USAGE_S_ALL)
    644677        RTStrmPrintf(pStrm,
    645                            "%s bandwidthctl %s    <uuid|vmname>\n"
    646                      "                            add <name> --type disk|network\n"
    647                      "                                --limit <megabytes per second>[k|m|g|K|M|G] |\n"
    648                      "                            set <name>\n"
    649                      "                                --limit <megabytes per second>[k|m|g|K|M|G] |\n"
    650                      "                            remove <name> |\n"
    651                      "                            list [--machinereadable]\n"
    652                      "                            (limit units: k=kilobit, m=megabit, g=gigabit,\n"
    653                      "                                          K=kilobyte, M=megabyte, G=gigabyte)\n"
    654                      "\n", SEP);
     678                     Help::tr(
     679                             "%s bandwidthctl %s    <uuid|vmname>\n"
     680                       "                            add <name> --type disk|network\n"
     681                       "                                --limit <megabytes per second>[k|m|g|K|M|G] |\n"
     682                       "                            set <name>\n"
     683                       "                                --limit <megabytes per second>[k|m|g|K|M|G] |\n"
     684                       "                            remove <name> |\n"
     685                       "                            list [--machinereadable]\n"
     686                       "                            (limit units: k=kilobit, m=megabit, g=gigabit,\n"
     687                       "                                          K=kilobyte, M=megabyte, G=gigabyte)\n"
     688                       "\n"), SEP);
    655689
    656690    if (enmCommand == USAGE_SHOWMEDIUMINFO || enmCommand == USAGE_S_ALL)
    657691        RTStrmPrintf(pStrm,
    658                            "%s showmediuminfo %s  [disk|dvd|floppy] <uuid|filename>\n"
    659                      "\n", SEP);
     692                     Help::tr(
     693                             "%s showmediuminfo %s  [disk|dvd|floppy] <uuid|filename>\n"
     694                       "\n"), SEP);
    660695
    661696    if (enmCommand == USAGE_CREATEMEDIUM || enmCommand == USAGE_S_ALL)
    662697        RTStrmPrintf(pStrm,
    663                            "%s createmedium %s    [disk|dvd|floppy] --filename <filename>\n"
    664                      "                            [--size <megabytes>|--sizebyte <bytes>]\n"
    665                      "                            [--diffparent <uuid>|<filename>]\n"
    666                      "                            [--format VDI|VMDK|VHD] (default: VDI)]\n"
    667                      "                            [--variant Standard,Fixed,Split2G,Stream,ESX,\n"
    668                      "                                       Formatted,RawDisk]\n"
    669                      "                            [[--property <name>=<value>] --property <name>=<value>\n"
    670                      "                              --property-file <name>=</path/to/file/with/value>]...\n"
    671                      "\n", SEP);
     698                     Help::tr(
     699                             "%s createmedium %s    [disk|dvd|floppy] --filename <filename>\n"
     700                       "                            [--size <megabytes>|--sizebyte <bytes>]\n"
     701                       "                            [--diffparent <uuid>|<filename>]\n"
     702                       "                            [--format VDI|VMDK|VHD] (default: VDI)]\n"
     703                       "                            [--variant Standard,Fixed,Split2G,Stream,ESX,\n"
     704                       "                                       Formatted,RawDisk]\n"
     705                       "                            [[--property <name>=<value>] --property <name>=<value>\n"
     706                       "                              --property-file <name>=</path/to/file/with/value>]...\n"
     707                       "\n"), SEP);
    672708
    673709    if (enmCommand == USAGE_MODIFYMEDIUM || enmCommand == USAGE_S_ALL)
    674710        RTStrmPrintf(pStrm,
    675                            "%s modifymedium %s    [disk|dvd|floppy] <uuid|filename>\n"
    676                      "                            [--type normal|writethrough|immutable|shareable|\n"
    677                      "                                    readonly|multiattach]\n"
    678                      "                            [--autoreset on|off]\n"
    679                      "                            [--property <name=[value]>]\n"
    680                      "                            [--compact]\n"
    681                      "                            [--resize <megabytes>|--resizebyte <bytes>]\n"
    682                      "                            [--move <path>]\n"
    683                      "                            [--setlocation <path>]\n"
    684                      "                            [--description <description string>]"
    685                      "\n", SEP);
     711                     Help::tr(
     712                             "%s modifymedium %s    [disk|dvd|floppy] <uuid|filename>\n"
     713                       "                            [--type normal|writethrough|immutable|shareable|\n"
     714                       "                                    readonly|multiattach]\n"
     715                       "                            [--autoreset on|off]\n"
     716                       "                            [--property <name=[value]>]\n"
     717                       "                            [--compact]\n"
     718                       "                            [--resize <megabytes>|--resizebyte <bytes>]\n"
     719                       "                            [--move <path>]\n"
     720                       "                            [--setlocation <path>]\n"
     721                       "                            [--description <description string>]"
     722                       "\n"), SEP);
    686723
    687724    if (enmCommand == USAGE_CLONEMEDIUM || enmCommand == USAGE_S_ALL)
    688725        RTStrmPrintf(pStrm,
    689                            "%s clonemedium %s     [disk|dvd|floppy] <uuid|inputfile> <uuid|outputfile>\n"
    690                      "                            [--format VDI|VMDK|VHD|RAW|<other>]\n"
    691                      "                            [--variant Standard,Fixed,Split2G,Stream,ESX]\n"
    692                      "                            [--existing]\n"
    693                      "\n", SEP);
     726                     Help::tr(
     727                             "%s clonemedium %s     [disk|dvd|floppy] <uuid|inputfile> <uuid|outputfile>\n"
     728                       "                            [--format VDI|VMDK|VHD|RAW|<other>]\n"
     729                       "                            [--variant Standard,Fixed,Split2G,Stream,ESX]\n"
     730                       "                            [--existing]\n"
     731                       "\n"), SEP);
    694732
    695733    if (enmCommand == USAGE_MEDIUMPROPERTY || enmCommand == USAGE_S_ALL)
    696734        RTStrmPrintf(pStrm,
    697                            "%s mediumproperty %s  [disk|dvd|floppy] set <uuid|filename>\n"
    698                      "                            <property> <value>\n"
    699                      "\n"
    700                      "                            [disk|dvd|floppy] get <uuid|filename>\n"
    701                      "                            <property>\n"
    702                      "\n"
    703                      "                            [disk|dvd|floppy] delete <uuid|filename>\n"
    704                      "                            <property>\n"
    705                      "\n", SEP);
     735                     Help::tr(
     736                             "%s mediumproperty %s  [disk|dvd|floppy] set <uuid|filename>\n"
     737                       "                            <property> <value>\n"
     738                       "\n"
     739                       "                            [disk|dvd|floppy] get <uuid|filename>\n"
     740                       "                            <property>\n"
     741                       "\n"
     742                       "                            [disk|dvd|floppy] delete <uuid|filename>\n"
     743                       "                            <property>\n"
     744                       "\n"), SEP);
    706745
    707746    if (enmCommand == USAGE_ENCRYPTMEDIUM || enmCommand == USAGE_S_ALL)
    708747        RTStrmPrintf(pStrm,
    709                            "%s encryptmedium %s   <uuid|filename>\n"
    710                      "                            [--newpassword <file>|-]\n"
    711                      "                            [--oldpassword <file>|-]\n"
    712                      "                            [--cipher <cipher identifier>]\n"
    713                      "                            [--newpasswordid <password identifier>]\n"
    714                      "\n", SEP);
     748                     Help::tr(
     749                             "%s encryptmedium %s   <uuid|filename>\n"
     750                       "                            [--newpassword <file>|-]\n"
     751                       "                            [--oldpassword <file>|-]\n"
     752                       "                            [--cipher <cipher identifier>]\n"
     753                       "                            [--newpasswordid <password identifier>]\n"
     754                       "\n"), SEP);
    715755
    716756    if (enmCommand == USAGE_MEDIUMENCCHKPWD || enmCommand == USAGE_S_ALL)
    717757        RTStrmPrintf(pStrm,
    718                            "%s checkmediumpwd %s  <uuid|filename>\n"
    719                      "                            <pwd file>|-\n"
    720                      "\n", SEP);
     758                     Help::tr(
     759                             "%s checkmediumpwd %s  <uuid|filename>\n"
     760                       "                            <pwd file>|-\n"
     761                       "\n"), SEP);
    721762
    722763    if (enmCommand == USAGE_CONVERTFROMRAW || enmCommand == USAGE_S_ALL)
    723764        RTStrmPrintf(pStrm,
    724                            "%s convertfromraw %s  <filename> <outputfile>\n"
    725                      "                            [--format VDI|VMDK|VHD]\n"
    726                      "                            [--variant Standard,Fixed,Split2G,Stream,ESX]\n"
    727                      "                            [--uuid <uuid>]\n"
    728                            "%s convertfromraw %s  stdin <outputfile> <bytes>\n"
    729                      "                            [--format VDI|VMDK|VHD]\n"
    730                      "                            [--variant Standard,Fixed,Split2G,Stream,ESX]\n"
    731                      "                            [--uuid <uuid>]\n"
    732                      "\n", SEP, SEP);
     765                     Help::tr(
     766                             "%s convertfromraw %s  <filename> <outputfile>\n"
     767                       "                            [--format VDI|VMDK|VHD]\n"
     768                       "                            [--variant Standard,Fixed,Split2G,Stream,ESX]\n"
     769                       "                            [--uuid <uuid>]\n"
     770                             "%s convertfromraw %s  stdin <outputfile> <bytes>\n"
     771                       "                            [--format VDI|VMDK|VHD]\n"
     772                       "                            [--variant Standard,Fixed,Split2G,Stream,ESX]\n"
     773                       "                            [--uuid <uuid>]\n"
     774                       "\n"), SEP, SEP);
    733775
    734776    if (enmCommand == USAGE_GETEXTRADATA || enmCommand == USAGE_S_ALL)
    735777        RTStrmPrintf(pStrm,
    736                            "%s getextradata %s    global|<uuid|vmname>\n"
    737                      "                            <key>|[enumerate]\n"
    738                      "\n", SEP);
     778                     Help::tr(
     779                             "%s getextradata %s    global|<uuid|vmname>\n"
     780                       "                            <key>|[enumerate]\n"
     781                       "\n"), SEP);
    739782
    740783    if (enmCommand == USAGE_SETEXTRADATA || enmCommand == USAGE_S_ALL)
    741784        RTStrmPrintf(pStrm,
    742                            "%s setextradata %s    global|<uuid|vmname>\n"
    743                      "                            <key>\n"
    744                      "                            [<value>] (no value deletes key)\n"
    745                      "\n", SEP);
     785                     Help::tr(
     786                             "%s setextradata %s    global|<uuid|vmname>\n"
     787                       "                            <key>\n"
     788                       "                            [<value>] (no value deletes key)\n"
     789                       "\n"), SEP);
    746790
    747791    if (enmCommand == USAGE_SETPROPERTY || enmCommand == USAGE_S_ALL)
    748792        RTStrmPrintf(pStrm,
    749                            "%s setproperty %s     machinefolder default|<folder> |\n"
    750                      "                            hwvirtexclusive on|off |\n"
    751                      "                            vrdeauthlibrary default|<library> |\n"
    752                      "                            websrvauthlibrary default|null|<library> |\n"
    753                      "                            vrdeextpack null|<library> |\n"
    754                      "                            autostartdbpath null|<folder> |\n"
    755                      "                            loghistorycount <value>\n"
    756                      "                            defaultfrontend default|<name>\n"
    757                      "                            logginglevel <log setting>\n"
    758                      "                            proxymode system|noproxy|manual\n"
    759                      "                            proxyurl <url>\n"
     793                     Help::tr(
     794                             "%s setproperty %s     machinefolder default|<folder> |\n"
     795                       "                            hwvirtexclusive on|off |\n"
     796                       "                            vrdeauthlibrary default|<library> |\n"
     797                       "                            websrvauthlibrary default|null|<library> |\n"
     798                       "                            vrdeextpack null|<library> |\n"
     799                       "                            autostartdbpath null|<folder> |\n"
     800                       "                            loghistorycount <value>\n"
     801                       "                            defaultfrontend default|<name>\n"
     802                       "                            logginglevel <log setting>\n"
     803                       "                            proxymode system|noproxy|manual\n"
     804                       "                            proxyurl <url>\n"), SEP);
    760805#ifdef VBOX_WITH_MAIN_NLS
    761                      "                            language <language id>\n"
    762 #endif
    763                      "\n", SEP);
     806        RTStrmPrintf(pStrm,
     807                     Help::tr(
     808                       "                            language <language id>\n"));
     809#endif
     810        RTStrmPrintf(pStrm,
     811                       "\n");
    764812
    765813    if (enmCommand == USAGE_USBFILTER || enmCommand == USAGE_S_ALL)
    … …  
    767815        if (fSubcommandScope & HELP_SCOPE_USBFILTER_ADD)
    768816            RTStrmPrintf(pStrm,
    769                                "%s usbfilter %s       add <index,0-N>\n"
    770                          "                            --target <uuid|vmname>|global\n"
    771                          "                            --name <string>\n"
    772                          "                            --action ignore|hold (global filters only)\n"
    773                          "                            [--active yes|no] (yes)\n"
    774                          "                            [--vendorid <XXXX>] (null)\n"
    775                          "                            [--productid <XXXX>] (null)\n"
    776                          "                            [--revision <IIFF>] (null)\n"
    777                          "                            [--manufacturer <string>] (null)\n"
    778                          "                            [--product <string>] (null)\n"
    779                          "                            [--remote yes|no] (null, VM filters only)\n"
    780                          "                            [--serialnumber <string>] (null)\n"
    781                          "                            [--maskedinterfaces <XXXXXXXX>]\n"
    782                          "\n", SEP);
     817                         Help::tr(
     818                                 "%s usbfilter %s       add <index,0-N>\n"
     819                           "                            --target <uuid|vmname>|global\n"
     820                           "                            --name <string>\n"
     821                           "                            --action ignore|hold (global filters only)\n"
     822                           "                            [--active yes|no] (yes)\n"
     823                           "                            [--vendorid <XXXX>] (null)\n"
     824                           "                            [--productid <XXXX>] (null)\n"
     825                           "                            [--revision <IIFF>] (null)\n"
     826                           "                            [--manufacturer <string>] (null)\n"
     827                           "                            [--product <string>] (null)\n"
     828                           "                            [--remote yes|no] (null, VM filters only)\n"
     829                           "                            [--serialnumber <string>] (null)\n"
     830                           "                            [--maskedinterfaces <XXXXXXXX>]\n"
     831                           "\n"), SEP);
    783832
    784833        if (fSubcommandScope & HELP_SCOPE_USBFILTER_MODIFY)
    785834            RTStrmPrintf(pStrm,
    786                                "%s usbfilter %s       modify <index,0-N>\n"
    787                          "                            --target <uuid|vmname>|global\n"
    788                          "                            [--name <string>]\n"
    789                          "                            [--action ignore|hold] (global filters only)\n"
    790                          "                            [--active yes|no]\n"
    791                          "                            [--vendorid <XXXX>|\"\"]\n"
    792                          "                            [--productid <XXXX>|\"\"]\n"
    793                          "                            [--revision <IIFF>|\"\"]\n"
    794                          "                            [--manufacturer <string>|\"\"]\n"
    795                          "                            [--product <string>|\"\"]\n"
    796                          "                            [--remote yes|no] (null, VM filters only)\n"
    797                          "                            [--serialnumber <string>|\"\"]\n"
    798                          "                            [--maskedinterfaces <XXXXXXXX>]\n"
    799                          "\n", SEP);
     835                         Help::tr(
     836                                 "%s usbfilter %s       modify <index,0-N>\n"
     837                           "                            --target <uuid|vmname>|global\n"
     838                           "                            [--name <string>]\n"
     839                           "                            [--action ignore|hold] (global filters only)\n"
     840                           "                            [--active yes|no]\n"
     841                           "                            [--vendorid <XXXX>|\"\"]\n"
     842                           "                            [--productid <XXXX>|\"\"]\n"
     843                           "                            [--revision <IIFF>|\"\"]\n"
     844                           "                            [--manufacturer <string>|\"\"]\n"
     845                           "                            [--product <string>|\"\"]\n"
     846                           "                            [--remote yes|no] (null, VM filters only)\n"
     847                           "                            [--serialnumber <string>|\"\"]\n"
     848                           "                            [--maskedinterfaces <XXXXXXXX>]\n"
     849                           "\n"), SEP);
    800850
    801851        if (fSubcommandScope & HELP_SCOPE_USBFILTER_REMOVE)
    802852            RTStrmPrintf(pStrm,
    803                                "%s usbfilter %s       remove <index,0-N>\n"
    804                          "                            --target <uuid|vmname>|global\n"
    805                          "\n", SEP);
     853                         Help::tr(
     854                                 "%s usbfilter %s       remove <index,0-N>\n"
     855                           "                            --target <uuid|vmname>|global\n"
     856                           "\n"), SEP);
    806857    }
    807858
    … …  
    818869    if (enmCommand == USAGE_METRICS || enmCommand == USAGE_S_ALL)
    819870        RTStrmPrintf(pStrm,
    820                            "%s metrics %s         list [*|host|<vmname> [<metric_list>]]\n"
    821                      "                                                 (comma-separated)\n\n"
    822                            "%s metrics %s         setup\n"
    823                      "                            [--period <seconds>] (default: 1)\n"
    824                      "                            [--samples <count>] (default: 1)\n"
    825                      "                            [--list]\n"
    826                      "                            [*|host|<vmname> [<metric_list>]]\n\n"
    827                            "%s metrics %s         query [*|host|<vmname> [<metric_list>]]\n\n"
    828                            "%s metrics %s         enable\n"
    829                      "                            [--list]\n"
    830                      "                            [*|host|<vmname> [<metric_list>]]\n\n"
    831                            "%s metrics %s         disable\n"
    832                      "                            [--list]\n"
    833                      "                            [*|host|<vmname> [<metric_list>]]\n\n"
    834                            "%s metrics %s         collect\n"
    835                      "                            [--period <seconds>] (default: 1)\n"
    836                      "                            [--samples <count>] (default: 1)\n"
    837                      "                            [--list]\n"
    838                      "                            [--detach]\n"
    839                      "                            [*|host|<vmname> [<metric_list>]]\n"
    840                      "\n", SEP, SEP, SEP, SEP, SEP, SEP);
     871                     Help::tr(
     872                             "%s metrics %s         list [*|host|<vmname> [<metric_list>]]\n"
     873                       "                                                 (comma-separated)\n\n"
     874                             "%s metrics %s         setup\n"
     875                       "                            [--period <seconds>] (default: 1)\n"
     876                       "                            [--samples <count>] (default: 1)\n"
     877                       "                            [--list]\n"
     878                       "                            [*|host|<vmname> [<metric_list>]]\n\n"
     879                             "%s metrics %s         query [*|host|<vmname> [<metric_list>]]\n\n"
     880                             "%s metrics %s         enable\n"
     881                       "                            [--list]\n"
     882                       "                            [*|host|<vmname> [<metric_list>]]\n\n"
     883                             "%s metrics %s         disable\n"
     884                       "                            [--list]\n"
     885                       "                            [*|host|<vmname> [<metric_list>]]\n\n"
     886                             "%s metrics %s         collect\n"
     887                       "                            [--period <seconds>] (default: 1)\n"
     888                       "                            [--samples <count>] (default: 1)\n"
     889                       "                            [--list]\n"
     890                       "                            [--detach]\n"
     891                       "                            [*|host|<vmname> [<metric_list>]]\n"
     892                       "\n"), SEP, SEP, SEP, SEP, SEP, SEP);
    841893
    842894#if defined(VBOX_WITH_NAT_SERVICE)
    … …  
    844896    {
    845897        RTStrmPrintf(pStrm,
    846                            "%s natnetwork %s      add --netname <name>\n"
    847                      "                            --network <network>\n"
    848                      "                            [--enable|--disable]\n"
    849                      "                            [--dhcp on|off]\n"
    850                      "                            [--port-forward-4 <rule>]\n"
    851                      "                            [--loopback-4 <rule>]\n"
    852                      "                            [--ipv6 on|off]\n"
    853                      "                            [--port-forward-6 <rule>]\n"
    854                      "                            [--loopback-6 <rule>]\n\n"
    855                            "%s natnetwork %s      remove --netname <name>\n\n"
    856                            "%s natnetwork %s      modify --netname <name>\n"
    857                      "                            [--network <network>]\n"
    858                      "                            [--enable|--disable]\n"
    859                      "                            [--dhcp on|off]\n"
    860                      "                            [--port-forward-4 <rule>]\n"
    861                      "                            [--loopback-4 <rule>]\n"
    862                      "                            [--ipv6 on|off]\n"
    863                      "                            [--port-forward-6 <rule>]\n"
    864                      "                            [--loopback-6 <rule>]\n\n"
    865                            "%s natnetwork %s      start --netname <name>\n\n"
    866                            "%s natnetwork %s      stop --netname <name>\n\n"
    867                            "%s natnetwork %s      list [<pattern>]\n"
    868                      "\n", SEP, SEP, SEP, SEP, SEP, SEP);
     898                     Help::tr(
     899                             "%s natnetwork %s      add --netname <name>\n"
     900                       "                            --network <network>\n"
     901                       "                            [--enable|--disable]\n"
     902                       "                            [--dhcp on|off]\n"
     903                       "                            [--port-forward-4 <rule>]\n"
     904                       "                            [--loopback-4 <rule>]\n"
     905                       "                            [--ipv6 on|off]\n"
     906                       "                            [--port-forward-6 <rule>]\n"
     907                       "                            [--loopback-6 <rule>]\n\n"
     908                             "%s natnetwork %s      remove --netname <name>\n\n"
     909                             "%s natnetwork %s      modify --netname <name>\n"
     910                       "                            [--network <network>]\n"
     911                       "                            [--enable|--disable]\n"
     912                       "                            [--dhcp on|off]\n"
     913                       "                            [--port-forward-4 <rule>]\n"
     914                       "                            [--loopback-4 <rule>]\n"
     915                       "                            [--ipv6 on|off]\n"
     916                       "                            [--port-forward-6 <rule>]\n"
     917                       "                            [--loopback-6 <rule>]\n\n"
     918                             "%s natnetwork %s      start --netname <name>\n\n"
     919                             "%s natnetwork %s      stop --netname <name>\n\n"
     920                             "%s natnetwork %s      list [<pattern>]\n"
     921                       "\n"), SEP, SEP, SEP, SEP, SEP, SEP);
    869922
    870923
    … …  
    876929    {
    877930        RTStrmPrintf(pStrm,
    878                            "%s hostonlyif %s      ipconfig <name>\n"
    879                      "                            [--dhcp |\n"
    880                      "                            --ip <ipv4> [--netmask <ipv4> (def:255.255.255.0)]|\n"
    881                      "                            --ipv6 <ipv6> [--netmasklengthv6 <N> (def:64)]]"
     931                     Help::tr(
     932                             "%s hostonlyif %s      ipconfig <name>\n"
     933                       "                            [--dhcp |\n"
     934                       "                            --ip <ipv4> [--netmask <ipv4> (def:255.255.255.0)]|\n"
     935                       "                            --ipv6 <ipv6> [--netmasklengthv6 <N> (def:64)]]"), SEP);
    882936# if !defined(RT_OS_SOLARIS) || defined(VBOX_ONLY_DOCS)
    883                      " |\n"
    884                      "                            create |\n"
    885                      "                            remove <name>\n"
     937        RTStrmPrintf(pStrm,
     938                     Help::tr(
     939                       " |\n"
     940                       "                            create |\n"
     941                       "                            remove <name>\n"));
    886942# else
    887                      "\n"
     943        RTStrmPrintf(pStrm,
     944                     Help::tr(
     945                       "\n");
    888946# endif
    889                      "\n", SEP);
     947        RTStrmPrintf(pStrm,
     948                       "\n");
    890949    }
    891950#endif
    … …  
    894953    {
    895954        RTStrmPrintf(pStrm,
    896                            "%s usbdevsource %s    add <source name>\n"
    897                      "                            --backend <backend>\n"
    898                      "                            --address <address>\n"
    899                            "%s usbdevsource %s    remove <source name>\n"
    900                      "\n", SEP, SEP);
     955                     Help::tr(
     956                             "%s usbdevsource %s    add <source name>\n"
     957                       "                            --backend <backend>\n"
     958                       "                            --address <address>\n"
     959                             "%s usbdevsource %s    remove <source name>\n"
     960                       "\n"), SEP, SEP);
    901961    }
    902962
    … …  
    939999#endif
    9401000    va_start(args, pszFormat);
    941     RTStrmPrintf(g_pStdErr, "\nSyntax error: %N\n", pszFormat, &args);
     1001    RTStrmPrintf(g_pStdErr, Help::tr("\nSyntax error: %N\n"), pszFormat, &args);
    9421002    va_end(args);
    9431003    return RTEXITCODE_SYNTAX;
    … …  
    9631023#endif
    9641024    va_start(args, pszFormat);
    965     RTStrmPrintf(g_pStdErr, "\nSyntax error: %N\n", pszFormat, &args);
     1025    RTStrmPrintf(g_pStdErr, Help::tr("\nSyntax error: %N\n"), pszFormat, &args);
    9661026    va_end(args);
    9671027    return RTEXITCODE_SYNTAX;
    … …  
    10221082
    10231083    if (rc == VINF_GETOPT_NOT_OPTION)
    1024         return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Invalid parameter '%s'", pValueUnion->psz);
     1084        return RTMsgErrorExit(RTEXITCODE_SYNTAX, Help::tr("Invalid parameter '%s'"), pValueUnion->psz);
    10251085    if (rc > 0)
    10261086    {
    10271087        if (RT_C_IS_PRINT(rc))
    1028             return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Invalid option -%c", rc);
    1029         return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Invalid option case %i", rc);
     1088            return RTMsgErrorExit(RTEXITCODE_SYNTAX, Help::tr("Invalid option -%c"), rc);
     1089        return RTMsgErrorExit(RTEXITCODE_SYNTAX, Help::tr("Invalid option case %i"), rc);
    10301090    }
    10311091    if (rc == VERR_GETOPT_UNKNOWN_OPTION)
    1032         return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown option: %s", pValueUnion->psz);
     1092        return RTMsgErrorExit(RTEXITCODE_SYNTAX, Help::tr("Unknown option: %s"), pValueUnion->psz);
    10331093    if (rc == VERR_GETOPT_INVALID_ARGUMENT_FORMAT)
    1034         return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Invalid argument format: %s", pValueUnion->psz);
     1094        return RTMsgErrorExit(RTEXITCODE_SYNTAX, Help::tr("Invalid argument format: %s"), pValueUnion->psz);
    10351095    if (pValueUnion->pDef)
    10361096        return RTMsgErrorExit(RTEXITCODE_SYNTAX, "%s: %Rrs", pValueUnion->pDef->pszLong, rc);
    … …  
    10651125    return RTEXITCODE_SYNTAX;
    10661126}
    1067 

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageHostonly.cpp

    r91416 r92372  
    4141#include "VBoxManage.h"
    4242
     43DECLARE_TRANSLATION_CONTEXT(HostOnly);
     44
    4345#ifndef VBOX_ONLY_DOCS
    4446using namespace com;
    … …  
    9395    {
    9496        /*HRESULT hrc =*/ showProgress(progress);
    95         CHECK_PROGRESS_ERROR_RET(progress, ("Failed to create the host-only adapter"), RTEXITCODE_FAILURE);
     97        CHECK_PROGRESS_ERROR_RET(progress, (HostOnly::tr("Failed to create the host-only adapter")), RTEXITCODE_FAILURE);
    9698    }
    9799
    … …  
    102104        RTPrintf("%ls", bstrName.raw());
    103105    else
    104         RTPrintf("Interface '%ls' was successfully created\n", bstrName.raw());
     106        RTPrintf(HostOnly::tr("Interface '%ls' was successfully created\n"), bstrName.raw());
    105107    return RTEXITCODE_SUCCESS;
    106108}
    … …  
    121123            case VINF_GETOPT_NOT_OPTION:
    122124                if (pszName)
    123                     return errorSyntax(USAGE_HOSTONLYIFS, "Only one interface name can be specified");
     125                    return errorSyntax(USAGE_HOSTONLYIFS, HostOnly::tr("Only one interface name can be specified"));
    124126                pszName = ValueUnion.psz;
    125127                break;
    … …  
    129131        }
    130132    if (!pszName)
    131         return errorSyntax(USAGE_HOSTONLYIFS, "No interface name was specified");
     133        return errorSyntax(USAGE_HOSTONLYIFS, HostOnly::tr("No interface name was specified"));
    132134
    133135    /*
    … …  
    147149
    148150    /*HRESULT hrc =*/ showProgress(progress);
    149     CHECK_PROGRESS_ERROR_RET(progress, ("Failed to remove the host-only adapter"), RTEXITCODE_FAILURE);
     151    CHECK_PROGRESS_ERROR_RET(progress, (HostOnly::tr("Failed to remove the host-only adapter")), RTEXITCODE_FAILURE);
    150152
    151153    return RTEXITCODE_SUCCESS;
    … …  
    191193            case 'a':   // --ip
    192194                if (pszIp)
    193                     RTMsgWarning("The --ip option is specified more than once");
     195                    RTMsgWarning(HostOnly::tr("The --ip option is specified more than once"));
    194196                pszIp = ValueUnion.psz;
    195197                break;
    196198            case 'm':   // --netmask
    197199                if (pszNetmask)
    198                     RTMsgWarning("The --netmask option is specified more than once");
     200                    RTMsgWarning(HostOnly::tr("The --netmask option is specified more than once"));
    199201                pszNetmask = ValueUnion.psz;
    200202                break;
    201203            case 'b':   // --ipv6
    202204                if (pszIpv6)
    203                     RTMsgWarning("The --ipv6 option is specified more than once");
     205                    RTMsgWarning(HostOnly::tr("The --ipv6 option is specified more than once"));
    204206                pszIpv6 = ValueUnion.psz;
    205207                break;
    206208            case 'l':   // --netmasklengthv6
    207209                if (fNetmasklengthv6)
    208                     RTMsgWarning("The --netmasklengthv6 option is specified more than once");
     210                    RTMsgWarning(HostOnly::tr("The --netmasklengthv6 option is specified more than once"));
    209211                fNetmasklengthv6 = true;
    210212                uNetmasklengthv6 = ValueUnion.u8;
    … …  
    212214            case VINF_GETOPT_NOT_OPTION:
    213215                if (pszName)
    214                     return errorSyntax(USAGE_HOSTONLYIFS, "Only one interface name can be specified");
     216                    return errorSyntax(USAGE_HOSTONLYIFS, HostOnly::tr("Only one interface name can be specified"));
    215217                pszName = ValueUnion.psz;
    216218                break;
    … …  
    222224    /* parameter sanity check */
    223225    if (fDhcp && (fNetmasklengthv6 || pszIpv6 || pszIp || pszNetmask))
    224         return errorSyntax(USAGE_HOSTONLYIFS, "You can not use --dhcp with static ip configuration parameters: --ip, --netmask, --ipv6 and --netmasklengthv6.");
     226        return errorSyntax(USAGE_HOSTONLYIFS,
     227                           HostOnly::tr("You can not use --dhcp with static ip configuration parameters: --ip, --netmask, --ipv6 and --netmasklengthv6."));
    225228    if ((pszIp || pszNetmask) && (fNetmasklengthv6 || pszIpv6))
    226         return errorSyntax(USAGE_HOSTONLYIFS, "You can not use ipv4 configuration (--ip and --netmask) with ipv6 (--ipv6 and --netmasklengthv6) simultaneously.");
     229        return errorSyntax(USAGE_HOSTONLYIFS,
     230                           HostOnly::tr("You can not use ipv4 configuration (--ip and --netmask) with ipv6 (--ipv6 and --netmasklengthv6) simultaneously."));
    227231
    228232    ComPtr<IHost> host;
    … …  
    232236    CHECK_ERROR2I_RET(host, FindHostNetworkInterfaceByName(Bstr(pszName).raw(), hif.asOutParam()), RTEXITCODE_FAILURE);
    233237    if (hif.isNull())
    234         return errorArgument("Could not find interface '%s'", pszName);
     238        return errorArgument(HostOnly::tr("Could not find interface '%s'"), pszName);
    235239
    236240    if (fDhcp)
    … …  
    248252        if (!fIpV6Supported)
    249253        {
    250             RTMsgError("IPv6 setting is not supported for this adapter");
     254            RTMsgError(HostOnly::tr("IPv6 setting is not supported for this adapter"));
    251255            return RTEXITCODE_FAILURE;
    252256        }
    … …  
    257261    }
    258262    else
    259         return errorSyntax(USAGE_HOSTONLYIFS, "Neither -dhcp nor -ip nor -ipv6 was specfified");
     263        return errorSyntax(USAGE_HOSTONLYIFS, HostOnly::tr("Neither -dhcp nor -ip nor -ipv6 was specfified"));
    260264
    261265    return RTEXITCODE_SUCCESS;
    … …  
    266270{
    267271    if (a->argc < 1)
    268         return errorSyntax(USAGE_HOSTONLYIFS, "No sub-command specified");
     272        return errorSyntax(USAGE_HOSTONLYIFS, HostOnly::tr("No sub-command specified"));
    269273
    270274    RTEXITCODE rcExit;
    … …  
    278282#endif
    279283    else
    280         rcExit = errorSyntax(USAGE_HOSTONLYIFS, "Unknown sub-command '%s'", a->argv[0]);
     284        rcExit = errorSyntax(USAGE_HOSTONLYIFS, HostOnly::tr("Unknown sub-command '%s'"), a->argv[0]);
    281285    return rcExit;
    282286}
    … …  
    399403
    400404    if (options.bstrNetworkName.isEmpty())
    401         return errorArgument("The --name parameter must be specified");
     405        return errorArgument(HostOnly::tr("The --name parameter must be specified"));
    402406    if (options.bstrNetworkMask.isEmpty())
    403         return errorArgument("The --netmask parameter must be specified");
     407        return errorArgument(HostOnly::tr("The --netmask parameter must be specified"));
    404408    if (options.bstrLowerIp.isEmpty())
    405         return errorArgument("The --lower-ip parameter must be specified");
     409        return errorArgument(HostOnly::tr("The --lower-ip parameter must be specified"));
    406410    if (options.bstrUpperIp.isEmpty())
    407         return errorArgument("The --upper-ip parameter must be specified");
     411        return errorArgument(HostOnly::tr("The --upper-ip parameter must be specified"));
    408412
    409413    CHECK_ERROR2_RET(hrc, pVirtualBox,
    … …  
    436440    }
    437441    else
    438         return errorArgument("Either --name or --id parameter must be specified");
     442        return errorArgument(HostOnly::tr("Either --name or --id parameter must be specified"));
    439443
    440444    return createUpdateHostOnlyNetworkCommon(hostOnlyNetwork, options);
    … …  
    492496    }
    493497    else
    494         return errorArgument("Either --name or --id parameter must be specified");
     498        return errorArgument(HostOnly::tr("Either --name or --id parameter must be specified"));
    495499
    496500    CHECK_ERROR2_RET(hrc, pVirtualBox,
    … …  
    503507{
    504508    if (a->argc < 1)
    505         return errorSyntax("No sub-command specified");
     509        return errorSyntax(HostOnly::tr("No sub-command specified"));
    506510
    507511    RTEXITCODE rcExit;
    … …  
    522526    }
    523527    else
    524         rcExit = errorSyntax("Unknown sub-command '%s'", a->argv[0]);
     528        rcExit = errorSyntax(HostOnly::tr("Unknown sub-command '%s'"), a->argv[0]);
    525529    return rcExit;
    526530}

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

    r92107 r92372  
    4848using namespace com;
    4949
     50DECLARE_TRANSLATION_CONTEXT(Info);
    5051
    5152// funcs
    … …  
    9596    {
    9697        /* print with indentation */
    97         RTPrintf("   %sName: %ls (UUID: %s)%s\n",
     98        RTPrintf(Info::tr("   %sName: %ls (UUID: %s)%s\n"),
    9899                 prefix.c_str(),
    99100                 name.raw(),
    … …  
    101102                 (fCurrent) ? " *" : "");
    102103        if (!description.isEmpty())
    103             RTPrintf("   %sDescription:\n%ls\n", prefix.c_str(), description.raw());
     104            RTPrintf(Info::tr("   %sDescription:\n%ls\n"), prefix.c_str(), description.raw());
    104105    }
    105106
    … …  
    150151    {
    151152        case MachineState_PoweredOff:
    152             return fShort ? "poweroff"             : "powered off";
     153            return fShort ? "poweroff"             : Info::tr("powered off");
    153154        case MachineState_Saved:
    154             return "saved";
     155            return fShort ? "saved"                : Info::tr("saved");
    155156        case MachineState_Teleported:
    156             return "teleported";
     157            return fShort ? "teleported"           : Info::tr("teleported");
    157158        case MachineState_Aborted:
    158             return "aborted";
     159            return fShort ? "aborted"              : Info::tr("aborted");
    159160        case MachineState_AbortedSaved:
    160             return "aborted-saved";
     161            return fShort ? "aborted-saved"        : Info::tr("aborted-saved");
    161162        case MachineState_Running:
    162             return "running";
     163            return fShort ? "running"              : Info::tr("running");
    163164        case MachineState_Paused:
    164             return "paused";
     165            return fShort ? "paused"               : Info::tr("paused");
    165166        case MachineState_Stuck:
    166             return fShort ? "gurumeditation"       : "guru meditation";
     167            return fShort ? "gurumeditation"       : Info::tr("guru meditation");
    167168        case MachineState_Teleporting:
    168             return "teleporting";
     169            return fShort ? "teleporting"          : Info::tr("teleporting");
    169170        case MachineState_LiveSnapshotting:
    170             return fShort ? "livesnapshotting"     : "live snapshotting";
     171            return fShort ? "livesnapshotting"     : Info::tr("live snapshotting");
    171172        case MachineState_Starting:
    172             return "starting";
     173            return fShort ? "starting"             : Info::tr("starting");
    173174        case MachineState_Stopping:
    174             return "stopping";
     175            return fShort ? "stopping"             : Info::tr("stopping");
    175176        case MachineState_Saving:
    176             return "saving";
     177            return fShort ? "saving"               : Info::tr("saving");
    177178        case MachineState_Restoring:
    178             return "restoring";
     179            return fShort ? "restoring"            : Info::tr("restoring");
    179180        case MachineState_TeleportingPausedVM:
    180             return fShort ? "teleportingpausedvm"  : "teleporting paused vm";
     181            return fShort ? "teleportingpausedvm"  : Info::tr("teleporting paused vm");
    181182        case MachineState_TeleportingIn:
    182             return fShort ? "teleportingin"        : "teleporting (incoming)";
     183            return fShort ? "teleportingin"        : Info::tr("teleporting (incoming)");
    183184        case MachineState_DeletingSnapshotOnline:
    184             return fShort ? "deletingsnapshotlive" : "deleting snapshot live";
     185            return fShort ? "deletingsnapshotlive" : Info::tr("deleting snapshot live");
    185186        case MachineState_DeletingSnapshotPaused:
    186             return fShort ? "deletingsnapshotlivepaused" : "deleting snapshot live paused";
     187            return fShort ? "deletingsnapshotlivepaused" : Info::tr("deleting snapshot live paused");
    187188        case MachineState_OnlineSnapshotting:
    188             return fShort ? "onlinesnapshotting"   : "online snapshotting";
     189            return fShort ? "onlinesnapshotting"   : Info::tr("online snapshotting");
    189190        case MachineState_RestoringSnapshot:
    190             return fShort ? "restoringsnapshot"    : "restoring snapshot";
     191            return fShort ? "restoringsnapshot"    : Info::tr("restoring snapshot");
    191192        case MachineState_DeletingSnapshot:
    192             return fShort ? "deletingsnapshot"     : "deleting snapshot";
     193            return fShort ? "deletingsnapshot"     : Info::tr("deleting snapshot");
    193194        case MachineState_SettingUp:
    194             return fShort ? "settingup"            : "setting up";
     195            return fShort ? "settingup"            : Info::tr("setting up");
    195196        case MachineState_Snapshotting:
    196             return fShort ? "snapshotting"         : "offline snapshotting";
     197            return fShort ? "snapshotting"         : Info::tr("offline snapshotting");
    197198        default:
    198199            break;
    199200    }
    200     return "unknown";
     201    return Info::tr("unknown");
    201202}
    202203
    … …  
    206207    {
    207208        case AdditionsFacilityStatus_Inactive:
    208             return fShort ? "inactive" : "not active";
     209            return fShort ? "inactive"    : Info::tr("not active");
    209210        case AdditionsFacilityStatus_Paused:
    210             return "paused";
     211            return fShort ? "paused"      : Info::tr("paused");
    211212        case AdditionsFacilityStatus_PreInit:
    212             return fShort ? "preinit" : "pre-initializing";
     213            return fShort ? "preinit"     : Info::tr("pre-initializing");
    213214        case AdditionsFacilityStatus_Init:
    214             return fShort ? "init"    : "initializing";
     215            return fShort ? "init"        : Info::tr("initializing");
    215216        case AdditionsFacilityStatus_Active:
    216             return fShort ? "active"  : "active/running";
     217            return fShort ? "active"      : Info::tr("active/running");
    217218        case AdditionsFacilityStatus_Terminating:
    218             return "terminating";
     219            return fShort ? "terminating" : Info::tr("terminating");
    219220        case AdditionsFacilityStatus_Terminated:
    220             return "terminated";
     221            return fShort ? "terminated"  : Info::tr("terminated");
    221222        case AdditionsFacilityStatus_Failed:
    222             return "failed";
     223            return fShort ? "failed"      : Info::tr("failed");
    223224        case AdditionsFacilityStatus_Unknown:
    224225        default:
    225226            break;
    226227    }
    227     return "unknown";
     228    return Info::tr("unknown");
    228229}
    229230
    … …  
    324325    switch (enmType)
    325326    {
    326         case BandwidthGroupType_Null:    return "Null";
    327         case BandwidthGroupType_Disk:    return "Disk";
    328         case BandwidthGroupType_Network: return "Network";
     327        case BandwidthGroupType_Null:    return Info::tr("Null");
     328        case BandwidthGroupType_Disk:    return Info::tr("Disk");
     329        case BandwidthGroupType_Network: return Info::tr("Network");
    329330#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
    330331        case BandwidthGroupType_32BitHack: break; /* Shut up compiler warnings. */
    331332#endif
    332333    }
    333     return "unknown";
     334    return Info::tr("unknown");
    334335}
    335336
    … …  
    363364            if (cBytes == 0)
    364365            {
    365                 RTPrintf("Name: '%ls', Type: %s, Limit: none (disabled)\n", strName.raw(), pszType);
     366                RTPrintf(Info::tr("Name: '%ls', Type: %s, Limit: none (disabled)\n"), strName.raw(), pszType);
    366367                continue;
    367368            }
    … …  
    404405                        pszNetUnits = "m";
    405406                    }
    406                     RTPrintf("Name: '%ls', Type: %s, Limit: %lld %sbits/sec (%lld %sbytes/sec)\n", strName.raw(), pszType, cBits, pszNetUnits, cBytes, pszUnits);
     407                    RTPrintf(Info::tr("Name: '%ls', Type: %s, Limit: %lld %sbits/sec (%lld %sbytes/sec)\n"),
     408                             strName.raw(), pszType, cBits, pszNetUnits, cBytes, pszUnits);
    407409                }
    408410            }
    409411            if (!pszNetUnits)
    410                 RTPrintf("Name: '%ls', Type: %s, Limit: %lld %sbytes/sec\n", strName.raw(), pszType, cBytes, pszUnits);
     412                RTPrintf(Info::tr("Name: '%ls', Type: %s, Limit: %lld %sbytes/sec\n"), strName.raw(), pszType, cBytes, pszUnits);
    411413        }
    412414    }
    413415    if (details != VMINFO_MACHINEREADABLE)
    414         RTPrintf(bwGroups.size() != 0 ? "\n" : "<none>\n\n");
     416        RTPrintf(bwGroups.size() != 0 ? "\n" : Info::tr("<none>\n\n"));
    415417
    416418    return rc;
    … …  
    439441    else
    440442    {
    441         RTPrintf("Name: '%ls', Host path: '%ls' (%s), %s%s",
    442                  name.raw(), hostPath.raw(), pszDesc, writable ? "writable" : "readonly", fAutoMount ? ", auto-mount" : "");
     443        RTPrintf(Info::tr("Name: '%ls', Host path: '%ls' (%s), %s%s"),
     444                 name.raw(), hostPath.raw(), pszDesc, writable ? Info::tr("writable") : Info::tr("readonly"),
     445                 fAutoMount ? Info::tr(", auto-mount") : "");
    443446        if (bstrAutoMountPoint.isNotEmpty())
    444             RTPrintf(", mount-point: '%ls'\n", bstrAutoMountPoint.raw());
     447            RTPrintf(Info::tr(", mount-point: '%ls'\n"), bstrAutoMountPoint.raw());
    445448        else
    446449            RTPrintf("\n");
    … …  
    457460            if (details == VMINFO_MACHINEREADABLE)
    458461                return "none";
    459             return "None";
     462            return Info::tr("None");
    460463
    461464        case IommuType_Automatic:
    462465            if (details == VMINFO_MACHINEREADABLE)
    463466                return "automatic";
    464             return "Automatic";
     467            return Info::tr("Automatic");
    465468
    466469        case IommuType_AMD:
    … …  
    477480            if (details == VMINFO_MACHINEREADABLE)
    478481                return "unknown";
    479             return "Unknown";
     482            return Info::tr("Unknown");
    480483    }
    481484}
    … …  
    489492            if (details == VMINFO_MACHINEREADABLE)
    490493                return "none";
    491             return "None";
     494            return Info::tr("None");
    492495
    493496        case ParavirtProvider_Default:
    494497            if (details == VMINFO_MACHINEREADABLE)
    495498                return "default";
    496             return "Default";
     499            return Info::tr("Default");
    497500
    498501        case ParavirtProvider_Legacy:
    499502            if (details == VMINFO_MACHINEREADABLE)
    500503                return "legacy";
    501             return "Legacy";
     504            return Info::tr("Legacy");
    502505
    503506        case ParavirtProvider_Minimal:
    504507            if (details == VMINFO_MACHINEREADABLE)
    505508                return "minimal";
    506             return "Minimal";
     509            return Info::tr("Minimal");
    507510
    508511        case ParavirtProvider_HyperV:
    … …  
    519522            if (details == VMINFO_MACHINEREADABLE)
    520523                return "unknown";
    521             return "Unknown";
     524            return Info::tr("Unknown");
    522525    }
    523526}
    … …  
    580583
    581584#define SHOW_BOOL_VALUE(a_pszMachine, a_pszHuman, a_fValue) \
    582     SHOW_BOOL_VALUE_EX(a_pszMachine, a_pszHuman, a_fValue, "enabled", "disabled")
     585    SHOW_BOOL_VALUE_EX(a_pszMachine, a_pszHuman, a_fValue, Info::tr("enabled"), Info::tr("disabled"))
    583586
    584587#define SHOW_ULONG_VALUE(a_pszMachine, a_pszHuman, a_uValue, a_pszUnit) \
    … …  
    603606
    604607#define SHOW_BOOLEAN_PROP(a_pObj, a_Prop, a_pszMachine, a_pszHuman) \
    605     SHOW_BOOLEAN_PROP_EX(a_pObj, a_Prop, a_pszMachine, a_pszHuman, "enabled", "disabled")
     608    SHOW_BOOLEAN_PROP_EX(a_pObj, a_Prop, a_pszMachine, a_pszHuman, Info::tr("enabled"), Info::tr("disabled"))
    606609
    607610#define SHOW_BOOLEAN_PROP_EX(a_pObj, a_Prop, a_pszMachine, a_pszHuman, a_szTrue, a_szFalse) \
    … …  
    626629            outputMachineReadableString(a_pszMachine, f ? "on" : "off"); \
    627630        else \
    628             RTPrintf("%-28s %s\n", a_pszHuman, f ? "enabled" : "disabled"); \
     631            RTPrintf("%-28s %s\n", a_pszHuman, f ? Info::tr("enabled") : Info::tr("disabled")); \
    629632    } while (0)
    630633
    … …  
    751754        machine->COMGETTER(Id)(uuid.asOutParam());
    752755        if (details == VMINFO_COMPACT)
    753             RTPrintf("\"<inaccessible>\" {%s}\n", Utf8Str(uuid).c_str());
     756            RTPrintf(Info::tr("\"<inaccessible>\" {%s}\n"), Utf8Str(uuid).c_str());
    754757        else
    755758        {
    … …  
    757760                RTPrintf("name=\"<inaccessible>\"\n");
    758761            else
    759                 RTPrintf("Name:            <inaccessible!>\n");
     762                RTPrintf(Info::tr("Name:            <inaccessible!>\n"));
    760763            if (details == VMINFO_MACHINEREADABLE)
    761764                RTPrintf("UUID=\"%s\"\n", Utf8Str(uuid).c_str());
    … …  
    766769                Bstr settingsFilePath;
    767770                rc = machine->COMGETTER(SettingsFilePath)(settingsFilePath.asOutParam());
    768                 RTPrintf("Config file:     %ls\n", settingsFilePath.raw());
     771                RTPrintf(Info::tr("Config file:     %ls\n"), settingsFilePath.raw());
    769772                ComPtr<IVirtualBoxErrorInfo> accessError;
    770773                rc = machine->COMGETTER(AccessError)(accessError.asOutParam());
    771                 RTPrintf("Access error details:\n");
     774                RTPrintf(Info::tr("Access error details:\n"));
    772775                ErrorInfo ei(accessError);
    773776                GluePrintErrorInfo(ei);
    … …  
    789792    }
    790793
    791     SHOW_STRING_PROP(      machine, Name,                       "name",                 "Name:");
    792     SHOW_STRINGARRAY_PROP( machine, Groups,                     "groups",               "Groups:");
     794    SHOW_STRING_PROP(      machine, Name,                       "name",                 Info::tr("Name:"));
     795    SHOW_STRINGARRAY_PROP( machine, Groups,                     "groups",               Info::tr("Groups:"));
    793796    Bstr osTypeId;
    794797    CHECK_ERROR2I_RET(machine, COMGETTER(OSTypeId)(osTypeId.asOutParam()), hrcCheck);
    … …  
    796799    pVirtualBox->GetGuestOSType(osTypeId.raw(), osType.asOutParam());
    797800    if (!osType.isNull())
    798         SHOW_STRING_PROP(       osType, Description,                "ostype",               "Guest OS:");
     801        SHOW_STRING_PROP(       osType, Description,                "ostype",               Info::tr("Guest OS:"));
    799802    else
    800         SHOW_STRING_PROP(      machine, OSTypeId,                   "ostype",               "Guest OS:");
     803        SHOW_STRING_PROP(      machine, OSTypeId,                   "ostype",               Info::tr("Guest OS:"));
    801804    SHOW_UUID_PROP(        machine, Id,                         "UUID",                 "UUID:");
    802     SHOW_STRING_PROP(      machine, SettingsFilePath,           "CfgFile",              "Config file:");
    803     SHOW_STRING_PROP(      machine, SnapshotFolder,             "SnapFldr",             "Snapshot folder:");
    804     SHOW_STRING_PROP(      machine, LogFolder,                  "LogFldr",              "Log folder:");
    805     SHOW_UUID_PROP(        machine, HardwareUUID,               "hardwareuuid",         "Hardware UUID:");
    806     SHOW_ULONG_PROP(       machine, MemorySize,                 "memory",               "Memory size:",     "MB");
    807     SHOW_BOOLEAN_PROP(     machine, PageFusionEnabled,          "pagefusion",           "Page Fusion:");
     805    SHOW_STRING_PROP(      machine, SettingsFilePath,           "CfgFile",              Info::tr("Config file:"));
     806    SHOW_STRING_PROP(      machine, SnapshotFolder,             "SnapFldr",             Info::tr("Snapshot folder:"));
     807    SHOW_STRING_PROP(      machine, LogFolder,                  "LogFldr",              Info::tr("Log folder:"));
     808    SHOW_UUID_PROP(        machine, HardwareUUID,               "hardwareuuid",         Info::tr("Hardware UUID:"));
     809    SHOW_ULONG_PROP(       machine, MemorySize,                 "memory",               Info::tr("Memory size:"),     "MB");
     810    SHOW_BOOLEAN_PROP(     machine, PageFusionEnabled,          "pagefusion",           Info::tr("Page Fusion:"));
    808811    ComPtr<IGraphicsAdapter> pGraphicsAdapter;
    809812    machine->COMGETTER(GraphicsAdapter)(pGraphicsAdapter.asOutParam());
    810     SHOW_ULONG_PROP(pGraphicsAdapter, VRAMSize,                 "vram",                 "VRAM size:",       "MB");
    811     SHOW_ULONG_PROP(       machine, CPUExecutionCap,            "cpuexecutioncap",      "CPU exec cap:",    "%");
    812     SHOW_BOOLEAN_PROP(     machine, HPETEnabled,                "hpet",                 "HPET:");
    813     SHOW_STRING_PROP_MAJ(  machine, CPUProfile,                 "cpu-profile",          "CPUProfile:",      "host", 6);
     813    SHOW_ULONG_PROP(pGraphicsAdapter, VRAMSize,                 "vram",                 Info::tr("VRAM size:"),       "MB");
     814    SHOW_ULONG_PROP(       machine, CPUExecutionCap,            "cpuexecutioncap",      Info::tr("CPU exec cap:"),    "%");
     815    SHOW_BOOLEAN_PROP(     machine, HPETEnabled,                "hpet",                 Info::tr("HPET:"));
     816    SHOW_STRING_PROP_MAJ(  machine, CPUProfile,                 "cpu-profile",          Info::tr("CPUProfile:"),      "host", 6);
    814817
    815818    ChipsetType_T chipsetType;
    … …  
    818821    switch (chipsetType)
    819822    {
    820         case ChipsetType_Null:  pszChipsetType = "invalid"; break;
     823        case ChipsetType_Null:
     824            if (details == VMINFO_MACHINEREADABLE)
     825                pszChipsetType = "invalid";
     826            else
     827                pszChipsetType = Info::tr("invalid");
     828            break;
    821829        case ChipsetType_PIIX3: pszChipsetType = "piix3"; break;
    822830        case ChipsetType_ICH9:  pszChipsetType = "ich9"; break;
    823         default:                AssertFailed(); pszChipsetType = "unknown"; break;
    824     }
    825     SHOW_UTF8_STRING("chipset", "Chipset:", pszChipsetType);
     831        default:
     832            AssertFailed();
     833            if (details == VMINFO_MACHINEREADABLE)
     834                pszChipsetType = "unknown";
     835            else
     836                pszChipsetType = Info::tr("unknown");
     837            break;
     838    }
     839    SHOW_UTF8_STRING("chipset", Info::tr("Chipset:"), pszChipsetType);
    826840
    827841    FirmwareType_T firmwareType;
    … …  
    835849        case FirmwareType_EFI64:    pszFirmwareType = "EFI64"; break;
    836850        case FirmwareType_EFIDUAL:  pszFirmwareType = "EFIDUAL"; break;
    837         default:                    AssertFailed(); pszFirmwareType = "unknown"; break;
    838     }
    839     SHOW_UTF8_STRING("firmware", "Firmware:", pszFirmwareType);
    840 
    841     SHOW_ULONG_PROP(       machine, CPUCount,                   "cpus",                 "Number of CPUs:", "");
     851        default:
     852            AssertFailed();
     853            if (details == VMINFO_MACHINEREADABLE)
     854                pszFirmwareType = "unknown";
     855            else
     856                pszFirmwareType = Info::tr("unknown");
     857            break;
     858    }
     859    SHOW_UTF8_STRING("firmware", Info::tr("Firmware:"), pszFirmwareType);
     860
     861    SHOW_ULONG_PROP(       machine, CPUCount, "cpus", Info::tr("Number of CPUs:"), "");
    842862    SHOW_BOOLEAN_METHOD(   machine, GetCPUProperty(CPUPropertyType_PAE, &f), "pae", "PAE:");
    843     SHOW_BOOLEAN_METHOD(   machine, GetCPUProperty(CPUPropertyType_LongMode, &f), "longmode", "Long Mode:");
    844     SHOW_BOOLEAN_METHOD(   machine, GetCPUProperty(CPUPropertyType_TripleFaultReset, &f), "triplefaultreset", "Triple Fault Reset:");
     863    SHOW_BOOLEAN_METHOD(   machine, GetCPUProperty(CPUPropertyType_LongMode, &f), "longmode", Info::tr("Long Mode:"));
     864    SHOW_BOOLEAN_METHOD(   machine, GetCPUProperty(CPUPropertyType_TripleFaultReset, &f), "triplefaultreset", Info::tr("Triple Fault Reset:"));
    845865    SHOW_BOOLEAN_METHOD(   machine, GetCPUProperty(CPUPropertyType_APIC, &f), "apic", "APIC:");
    846866    SHOW_BOOLEAN_METHOD(   machine, GetCPUProperty(CPUPropertyType_X2APIC, &f), "x2apic", "X2APIC:");
    847     SHOW_BOOLEAN_METHOD(   machine, GetCPUProperty(CPUPropertyType_HWVirt, &f), "nested-hw-virt", "Nested VT-x/AMD-V:");
    848     SHOW_ULONG_PROP(       machine, CPUIDPortabilityLevel, "cpuid-portability-level",   "CPUID Portability Level:", "");
     867    SHOW_BOOLEAN_METHOD(   machine, GetCPUProperty(CPUPropertyType_HWVirt, &f), "nested-hw-virt", Info::tr("Nested VT-x/AMD-V:"));
     868    SHOW_ULONG_PROP(       machine, CPUIDPortabilityLevel, "cpuid-portability-level", Info::tr("CPUID Portability Level:"), "");
    849869
    850870    if (details != VMINFO_MACHINEREADABLE)
    851         RTPrintf("%-28s ", "CPUID overrides:");
     871        RTPrintf("%-28s ", Info::tr("CPUID overrides:"));
    852872    ULONG uOrdinal = 0;
    853873    for (uOrdinal = 0; uOrdinal < _4K; uOrdinal++)
    … …  
    862882            {
    863883                if (!uOrdinal)
    864                     RTPrintf("Leaf no.      EAX      EBX      ECX      EDX\n");
     884                    RTPrintf(Info::tr("Leaf no.      EAX      EBX      ECX      EDX\n"));
    865885                RTPrintf("%-28s %08x/%03x  %08x %08x %08x %08x\n", "", uLeaf, uSubLeaf, uEAX, uEBX, uECX, uEDX);
    866886            }
    … …  
    874894    }
    875895    if (!uOrdinal && details != VMINFO_MACHINEREADABLE)
    876         RTPrintf("None\n");
     896        RTPrintf(Info::tr("None\n"));
    877897
    878898    ComPtr<IBIOSSettings> biosSettings;
    … …  
    888908    {
    889909        case BIOSBootMenuMode_Disabled:
    890             pszBootMenu = "disabled";
     910            if (details == VMINFO_MACHINEREADABLE)
     911                pszBootMenu = "disabled";
     912            else
     913                pszBootMenu = Info::tr("disabled");
    891914            break;
    892915        case BIOSBootMenuMode_MenuOnly:
    … …  
    894917                pszBootMenu = "menuonly";
    895918            else
    896                 pszBootMenu = "menu only";
     919                pszBootMenu = Info::tr("menu only");
    897920            break;
    898921        default:
    … …  
    900923                pszBootMenu = "messageandmenu";
    901924            else
    902                 pszBootMenu = "message and menu";
    903     }
    904     SHOW_UTF8_STRING("bootmenu", "Boot menu mode:", pszBootMenu);
     925                pszBootMenu = Info::tr("message and menu");
     926    }
     927    SHOW_UTF8_STRING("bootmenu", Info::tr("Boot menu mode:"), pszBootMenu);
    905928
    906929    ComPtr<ISystemProperties> systemProperties;
    … …  
    914937        const char *pszDevice;
    915938        if (bootOrder == DeviceType_Floppy)
    916             pszDevice = details == VMINFO_MACHINEREADABLE ? "floppy"        : "Floppy";
     939            pszDevice = details == VMINFO_MACHINEREADABLE ? "floppy"        : Info::tr("Floppy");
    917940        else if (bootOrder == DeviceType_DVD)
    918941            pszDevice = details == VMINFO_MACHINEREADABLE ? "dvd"           : "DVD";
    919942        else if (bootOrder == DeviceType_HardDisk)
    920             pszDevice = details == VMINFO_MACHINEREADABLE ? "disk"          : "HardDisk";
     943            pszDevice = details == VMINFO_MACHINEREADABLE ? "disk"          : Info::tr("HardDisk");
    921944        else if (bootOrder == DeviceType_Network)
    922             pszDevice = details == VMINFO_MACHINEREADABLE ? "net"           : "Network";
     945            pszDevice = details == VMINFO_MACHINEREADABLE ? "net"           : Info::tr("Network");
    923946        else if (bootOrder == DeviceType_USB)
    924947            pszDevice = details == VMINFO_MACHINEREADABLE ? "usb"           : "USB";
    925948        else if (bootOrder == DeviceType_SharedFolder)
    926             pszDevice = details == VMINFO_MACHINEREADABLE ? "sharedfolder"  : "Shared Folder";
     949            pszDevice = details == VMINFO_MACHINEREADABLE ? "sharedfolder"  : Info::tr("Shared Folder");
    927950        else
    928             pszDevice = details == VMINFO_MACHINEREADABLE ? "none"          : "Not Assigned";
    929         SHOW_UTF8_STRING(FmtNm(szNm, "boot%u", i), FmtNm(szNm, "Boot Device %u:", i), pszDevice);
     951            pszDevice = details == VMINFO_MACHINEREADABLE ? "none"          : Info::tr("Not Assigned");
     952        SHOW_UTF8_STRING(FmtNm(szNm, "boot%u", i), FmtNm(szNm, Info::tr("Boot Device %u:"), i), pszDevice);
    930953    }
    931954
    … …  
    939962    {
    940963        case APICMode_Disabled:
    941             pszAPIC = "disabled";
     964            if (details == VMINFO_MACHINEREADABLE)
     965                pszAPIC = "disabled";
     966            else
     967                pszAPIC = Info::tr("disabled");
    942968            break;
    943969        case APICMode_APIC:
    … …  
    955981            break;
    956982    }
    957     SHOW_UTF8_STRING("biosapic", "BIOS APIC mode:", pszAPIC);
    958 
    959     SHOW_LONG64_PROP(biosSettings,  TimeOffset,                 "biossystemtimeoffset", "Time offset:",  "ms");
     983    SHOW_UTF8_STRING("biosapic", Info::tr("BIOS APIC mode:"), pszAPIC);
     984
     985    SHOW_LONG64_PROP(biosSettings,  TimeOffset, "biossystemtimeoffset", Info::tr("Time offset:"),  Info::tr("ms"));
    960986    Bstr bstrNVRAMFile;
    961987    CHECK_ERROR2I_RET(nvramStore, COMGETTER(NonVolatileStorageFile)(bstrNVRAMFile.asOutParam()), hrcCheck);
    962988    if (bstrNVRAMFile.isNotEmpty())
    963         SHOW_BSTR_STRING("BIOS NVRAM File", "BIOS NVRAM File:", bstrNVRAMFile);
    964     SHOW_BOOLEAN_PROP_EX(machine,   RTCUseUTC,                  "rtcuseutc",            "RTC:",         "UTC", "local time");
    965     SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_Enabled,   &f),   "hwvirtex",     "Hardware Virtualization:");
    966     SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, &f),"nestedpaging", "Nested Paging:");
    967     SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_LargePages, &f),  "largepages",   "Large Pages:");
     989        SHOW_BSTR_STRING("BIOS NVRAM File", Info::tr("BIOS NVRAM File:"), bstrNVRAMFile);
     990    SHOW_BOOLEAN_PROP_EX(machine,   RTCUseUTC, "rtcuseutc", Info::tr("RTC:"), "UTC", Info::tr("local time"));
     991    SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_Enabled,   &f),   "hwvirtex",     Info::tr("Hardware Virtualization:"));
     992    SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, &f),"nestedpaging", Info::tr("Nested Paging:"));
     993    SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_LargePages, &f),  "largepages",   Info::tr("Large Pages:"));
    968994    SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_VPID, &f),        "vtxvpid",      "VT-x VPID:");
    969     SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, &f), "vtxux", "VT-x Unrestricted Exec.:");
    970     SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_VirtVmsaveVmload, &f),      "virtvmsavevmload", "AMD-V Virt. Vmsave/Vmload:");
     995    SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, &f), "vtxux", Info::tr("VT-x Unrestricted Exec.:"));
     996    SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_VirtVmsaveVmload, &f),      "virtvmsavevmload", Info::tr("AMD-V Virt. Vmsave/Vmload:"));
    971997
    972998#ifdef VBOX_WITH_IOMMU_AMD
    … …  
    9801006    CHECK_ERROR2I_RET(machine, COMGETTER(ParavirtProvider)(&paravirtProvider), hrcCheck);
    9811007    const char *pszParavirtProvider = paravirtProviderToString(paravirtProvider, details);
    982     SHOW_UTF8_STRING("paravirtprovider", "Paravirt. Provider:", pszParavirtProvider);
     1008    SHOW_UTF8_STRING("paravirtprovider", Info::tr("Paravirt. Provider:"), pszParavirtProvider);
    9831009
    9841010    ParavirtProvider_T effParavirtProvider;
    9851011    CHECK_ERROR2I_RET(machine, GetEffectiveParavirtProvider(&effParavirtProvider), hrcCheck);
    9861012    const char *pszEffParavirtProvider = paravirtProviderToString(effParavirtProvider, details);
    987     SHOW_UTF8_STRING("effparavirtprovider", "Effective Paravirt. Prov.:", pszEffParavirtProvider);
     1013    SHOW_UTF8_STRING("effparavirtprovider", Info::tr("Effective Paravirt. Prov.:"), pszEffParavirtProvider);
    9881014
    9891015    Bstr paravirtDebug;
    9901016    CHECK_ERROR2I_RET(machine, COMGETTER(ParavirtDebug)(paravirtDebug.asOutParam()), hrcCheck);
    9911017    if (paravirtDebug.isNotEmpty())
    992         SHOW_BSTR_STRING("paravirtdebug", "Paravirt. Debug:", paravirtDebug);
     1018        SHOW_BSTR_STRING("paravirtdebug", Info::tr("Paravirt. Debug:"), paravirtDebug);
    9931019
    9941020    MachineState_T machineState;
    … …  
    10131039    }
    10141040    else
    1015         RTPrintf("%-28s %s (since %s)\n", "State:", pszState, pszTime);
     1041        RTPrintf(Info::tr("%-28s %s (since %s)\n"), Info::tr("State:"), pszState, pszTime);
    10161042
    10171043    GraphicsControllerType_T enmGraphics;
    … …  
    10191045    if (SUCCEEDED(rc))
    10201046    {
    1021         const char *pszCtrl  = "Unknown";
     1047        const char *pszCtrl;
    10221048        switch (enmGraphics)
    10231049        {
    … …  
    10261052                    pszCtrl = "null";
    10271053                else
    1028                     pszCtrl = "Null";
     1054                    pszCtrl = Info::tr("Null");
    10291055                break;
    10301056            case GraphicsControllerType_VBoxVGA:
    … …  
    10491075                if (details == VMINFO_MACHINEREADABLE)
    10501076                    pszCtrl = "unknown";
     1077                else
     1078                    pszCtrl = Info::tr("Unknown");
    10511079                break;
    10521080        }
    … …  
    10551083            RTPrintf("graphicscontroller=\"%s\"\n", pszCtrl);
    10561084        else
    1057             RTPrintf("%-28s %s\n", "Graphics Controller:", pszCtrl);
    1058     }
    1059 
    1060     SHOW_ULONG_PROP(pGraphicsAdapter, MonitorCount,             "monitorcount",             "Monitor count:", "");
    1061     SHOW_BOOLEAN_PROP(pGraphicsAdapter, Accelerate3DEnabled,    "accelerate3d",             "3D Acceleration:");
     1085            RTPrintf("%-28s %s\n", Info::tr("Graphics Controller:"), pszCtrl);
     1086    }
     1087
     1088    SHOW_ULONG_PROP(pGraphicsAdapter, MonitorCount,             "monitorcount",             Info::tr("Monitor count:"), "");
     1089    SHOW_BOOLEAN_PROP(pGraphicsAdapter, Accelerate3DEnabled,    "accelerate3d",             Info::tr("3D Acceleration:"));
    10621090#ifdef VBOX_WITH_VIDEOHWACCEL
    1063     SHOW_BOOLEAN_PROP(pGraphicsAdapter, Accelerate2DVideoEnabled, "accelerate2dvideo",      "2D Video Acceleration:");
     1091    SHOW_BOOLEAN_PROP(pGraphicsAdapter, Accelerate2DVideoEnabled, "accelerate2dvideo",      Info::tr("2D Video Acceleration:"));
    10641092#endif
    1065     SHOW_BOOLEAN_PROP(    machine,  TeleporterEnabled,          "teleporterenabled",        "Teleporter Enabled:");
    1066     SHOW_ULONG_PROP(      machine,  TeleporterPort,             "teleporterport",           "Teleporter Port:", "");
    1067     SHOW_STRING_PROP(     machine,  TeleporterAddress,          "teleporteraddress",        "Teleporter Address:");
    1068     SHOW_STRING_PROP(     machine,  TeleporterPassword,         "teleporterpassword",       "Teleporter Password:");
    1069     SHOW_BOOLEAN_PROP(    machine,  TracingEnabled,             "tracing-enabled",          "Tracing Enabled:");
    1070     SHOW_BOOLEAN_PROP(    machine,  AllowTracingToAccessVM,     "tracing-allow-vm-access",  "Allow Tracing to Access VM:");
    1071     SHOW_STRING_PROP(     machine,  TracingConfig,              "tracing-config",           "Tracing Configuration:");
    1072     SHOW_BOOLEAN_PROP(    machine,  AutostartEnabled,           "autostart-enabled",        "Autostart Enabled:");
    1073     SHOW_ULONG_PROP(      machine,  AutostartDelay,             "autostart-delay",          "Autostart Delay:", "");
    1074     SHOW_STRING_PROP(     machine,  DefaultFrontend,            "defaultfrontend",          "Default Frontend:");
     1093    SHOW_BOOLEAN_PROP(    machine,  TeleporterEnabled,          "teleporterenabled",        Info::tr("Teleporter Enabled:"));
     1094    SHOW_ULONG_PROP(      machine,  TeleporterPort,             "teleporterport",           Info::tr("Teleporter Port:"), "");
     1095    SHOW_STRING_PROP(     machine,  TeleporterAddress,          "teleporteraddress",        Info::tr("Teleporter Address:"));
     1096    SHOW_STRING_PROP(     machine,  TeleporterPassword,         "teleporterpassword",       Info::tr("Teleporter Password:"));
     1097    SHOW_BOOLEAN_PROP(    machine,  TracingEnabled,             "tracing-enabled",          Info::tr("Tracing Enabled:"));
     1098    SHOW_BOOLEAN_PROP(    machine,  AllowTracingToAccessVM,     "tracing-allow-vm-access",  Info::tr("Allow Tracing to Access VM:"));
     1099    SHOW_STRING_PROP(     machine,  TracingConfig,              "tracing-config",           Info::tr("Tracing Configuration:"));
     1100    SHOW_BOOLEAN_PROP(    machine,  AutostartEnabled,           "autostart-enabled",        Info::tr("Autostart Enabled:"));
     1101    SHOW_ULONG_PROP(      machine,  AutostartDelay,             "autostart-delay",          Info::tr("Autostart Delay:"), "");
     1102    SHOW_STRING_PROP(     machine,  DefaultFrontend,            "defaultfrontend",          Info::tr("Default Frontend:"));
    10751103
    10761104    VMProcPriority_T enmVMProcPriority;
    … …  
    10801108    {
    10811109        case VMProcPriority_Flat:
    1082             pszVMProcPriority = "flat";
     1110            if (details == VMINFO_MACHINEREADABLE)
     1111                pszVMProcPriority = "flat";
     1112            else
     1113                pszVMProcPriority = Info::tr("flat");
    10831114            break;
    10841115        case VMProcPriority_Low:
    1085             pszVMProcPriority = "low";
     1116            if (details == VMINFO_MACHINEREADABLE)
     1117                pszVMProcPriority = "low";
     1118            else
     1119                pszVMProcPriority = Info::tr("low");
    10861120            break;
    10871121        case VMProcPriority_Normal:
    1088             pszVMProcPriority = "normal";
     1122            if (details == VMINFO_MACHINEREADABLE)
     1123                pszVMProcPriority = "normal";
     1124            else
     1125                pszVMProcPriority = Info::tr("normal");
    10891126            break;
    10901127        case VMProcPriority_High:
    1091             pszVMProcPriority = "high";
     1128            if (details == VMINFO_MACHINEREADABLE)
     1129                pszVMProcPriority = "high";
     1130            else
     1131                pszVMProcPriority = Info::tr("high");
    10921132            break;
    10931133        default:
    1094             pszVMProcPriority = "default";
     1134            if (details == VMINFO_MACHINEREADABLE)
     1135                pszVMProcPriority = "default";
     1136            else
     1137                pszVMProcPriority = Info::tr("default");
    10951138            break;
    10961139    }
    … …  
    11171160            RTPrintf("storagecontrollername%u=\"%ls\"\n", i, storageCtlName.raw());
    11181161        else
    1119             RTPrintf("Storage Controller Name (%u):            %ls\n", i, storageCtlName.raw());
     1162            RTPrintf(Info::tr("Storage Controller Name (%u):            %ls\n"), i, storageCtlName.raw());
    11201163
    11211164        storageCtl->COMGETTER(ControllerType)(&enmCtlType);
    … …  
    11571200
    11581201            default:
    1159                 pszCtl = "unknown";
     1202                if (details == VMINFO_MACHINEREADABLE)
     1203                    pszCtl = "unknown";
     1204                else
     1205                    pszCtl = Info::tr("unknown");
    11601206        }
    11611207        if (details == VMINFO_MACHINEREADABLE)
    11621208            RTPrintf("storagecontrollertype%u=\"%s\"\n", i, pszCtl);
    11631209        else
    1164             RTPrintf("Storage Controller Type (%u):            %s\n", i, pszCtl);
     1210            RTPrintf(Info::tr("Storage Controller Type (%u):            %s\n"), i, pszCtl);
    11651211
    11661212        storageCtl->COMGETTER(Instance)(&ulValue);
    … …  
    11681214            RTPrintf("storagecontrollerinstance%u=\"%lu\"\n", i, ulValue);
    11691215        else
    1170             RTPrintf("Storage Controller Instance Number (%u): %lu\n", i, ulValue);
     1216            RTPrintf(Info::tr("Storage Controller Instance Number (%u): %lu\n"), i, ulValue);
    11711217
    11721218        storageCtl->COMGETTER(MaxPortCount)(&ulValue);
    … …  
    11741220            RTPrintf("storagecontrollermaxportcount%u=\"%lu\"\n", i, ulValue);
    11751221        else
    1176             RTPrintf("Storage Controller Max Port Count (%u):  %lu\n", i, ulValue);
     1222            RTPrintf(Info::tr("Storage Controller Max Port Count (%u):  %lu\n"), i, ulValue);
    11771223
    11781224        storageCtl->COMGETTER(PortCount)(&ulValue);
    … …  
    11801226            RTPrintf("storagecontrollerportcount%u=\"%lu\"\n", i, ulValue);
    11811227        else
    1182             RTPrintf("Storage Controller Port Count (%u):      %lu\n", i, ulValue);
     1228            RTPrintf(Info::tr("Storage Controller Port Count (%u):      %lu\n"), i, ulValue);
    11831229
    11841230        storageCtl->COMGETTER(Bootable)(&fBootable);
    … …  
    11861232            RTPrintf("storagecontrollerbootable%u=\"%s\"\n", i, fBootable ? "on" : "off");
    11871233        else
    1188             RTPrintf("Storage Controller Bootable (%u):        %s\n", i, fBootable ? "on" : "off");
     1234            RTPrintf(Info::tr("Storage Controller Bootable (%u):        %s\n"), i, fBootable ? Info::tr("on") : Info::tr("off"));
    11891235    }
    11901236
    … …  
    12551301                                 Utf8Str(uuid).c_str());
    12561302                        if (fPassthrough)
    1257                             RTPrintf(" (passthrough enabled)");
     1303                            RTPrintf(Info::tr(" (passthrough enabled)"));
    12581304                        if (fTempEject)
    1259                             RTPrintf(" (temp eject)");
     1305                            RTPrintf(Info::tr(" (temp eject)"));
    12601306                        if (fIsEjected)
    1261                             RTPrintf(" (ejected)");
     1307                            RTPrintf(Info::tr(" (ejected)"));
    12621308                        RTPrintf("\n");
    12631309                    }
    … …  
    12741320                    else
    12751321                    {
    1276                         RTPrintf("%ls (%d, %d): Empty", storageCtlName.raw(), i, k);
     1322                        RTPrintf(Info::tr("%ls (%d, %d): Empty"), storageCtlName.raw(), i, k);
    12771323                        if (fTempEject)
    1278                             RTPrintf(" (temp eject)");
     1324                            RTPrintf(Info::tr(" (temp eject)"));
    12791325                        if (fIsEjected)
    1280                             RTPrintf(" (ejected)");
     1326                            RTPrintf(Info::tr(" (ejected)"));
    12811327                        RTPrintf("\n");
    12821328                    }
    … …  
    13001346        if (SUCCEEDED(rc) && nic)
    13011347        {
    1302             FmtNm(szNm, details == VMINFO_MACHINEREADABLE ? "nic%u" : "NIC %u:", currentNIC + 1);
     1348            FmtNm(szNm, details == VMINFO_MACHINEREADABLE ? "nic%u" : Info::tr("NIC %u:"), currentNIC + 1);
    13031349
    13041350            BOOL fEnabled;
    … …  
    13091355                    RTPrintf("%s=\"none\"\n", szNm);
    13101356                else
    1311                     RTPrintf("%-28s disabled\n", szNm);
     1357                    RTPrintf(Info::tr("%-28s disabled\n"), szNm);
    13121358            }
    13131359            else
    … …  
    13261372                            strAttachment = "null";
    13271373                        else
    1328                             strAttachment = "none";
     1374                            strAttachment = Info::tr("none");
    13291375                        break;
    13301376
    … …  
    13941440                                                         strGuestIP.c_str(), strGuestPort.c_str());
    13951441                            else
    1396                                 strNatForwardings.printf("%sNIC %d Rule(%d):   name = %s, protocol = %s, host ip = %s, host port = %s, guest ip = %s, guest port = %s\n",
     1442                                strNatForwardings.printf(Info::tr("%sNIC %d Rule(%d):   name = %s, protocol = %s, host ip = %s, host port = %s, guest ip = %s, guest port = %s\n"),
    13971443                                                         strNatForwardings.c_str(), currentNIC + 1, i, strName.c_str(),
    13981444                                                         strProto.c_str(), strHostIP.c_str(), strHostPort.c_str(),
    … …  
    14171463                        {
    14181464                            strAttachment = "NAT";
    1419                             strNatSettings.printf("NIC %d Settings:  MTU: %d, Socket (send: %d, receive: %d), TCP Window (send:%d, receive: %d)\n",
     1465                            strNatSettings.printf(Info::tr("NIC %d Settings:  MTU: %d, Socket (send: %d, receive: %d), TCP Window (send:%d, receive: %d)\n"),
    14201466                                                  currentNIC + 1, mtu, sockSnd ? sockSnd : 64, sockRcv ? sockRcv : 64, tcpSnd ? tcpSnd : 64, tcpRcv ? tcpRcv : 64);
    14211467                        }
    … …  
    14331479                        }
    14341480                        else
    1435                             strAttachment.printf("Bridged Interface '%ls'", strBridgeAdp.raw());
     1481                            strAttachment.printf(Info::tr("Bridged Interface '%ls'"), strBridgeAdp.raw());
    14361482                        break;
    14371483                    }
    … …  
    14471493                        }
    14481494                        else
    1449                             strAttachment.printf("Internal Network '%s'", Utf8Str(strNetwork).c_str());
     1495                            strAttachment.printf(Info::tr("Internal Network '%s'"), Utf8Str(strNetwork).c_str());
    14501496                        break;
    14511497                    }
    … …  
    14611507                        }
    14621508                        else
    1463                             strAttachment.printf("Host-only Interface '%ls'", strHostonlyAdp.raw());
     1509                            strAttachment.printf(Info::tr("Host-only Interface '%ls'"), strHostonlyAdp.raw());
    14641510                        break;
    14651511                    }
    … …  
    14761522                        else
    14771523                        {
    1478                             strAttachment.printf("Generic '%ls'", strGenericDriver.raw());
     1524                            strAttachment.printf(Info::tr("Generic '%ls'"), strGenericDriver.raw());
    14791525
    14801526                            // show the generic properties
    … …  
    15051551                        }
    15061552                        else
    1507                             strAttachment.printf("NAT Network '%s'", Utf8Str(strNetwork).c_str());
     1553                            strAttachment.printf(Info::tr("NAT Network '%s'"), Utf8Str(strNetwork).c_str());
    15081554                        break;
    15091555                    }
    … …  
    15201566                        }
    15211567                        else
    1522                             strAttachment.printf("Host Only Network '%s'", Utf8Str(strNetwork).c_str());
     1568                            strAttachment.printf(Info::tr("Host Only Network '%s'"), Utf8Str(strNetwork).c_str());
    15231569                        break;
    15241570                    }
    … …  
    15361582                        }
    15371583                        else
    1538                             strAttachment.printf("Cloud Network '%s'", Utf8Str(strNetwork).c_str());
     1584                            strAttachment.printf(Info::tr("Cloud Network '%s'"), Utf8Str(strNetwork).c_str());
    15391585                        break;
    15401586                    }
    … …  
    15421588
    15431589                    default:
    1544                         strAttachment = "unknown";
     1590                        if (details == VMINFO_MACHINEREADABLE)
     1591                            strAttachment = "unknown";
     1592                        else
     1593                            strAttachment = Info::tr("unknown");
    15451594                        break;
    15461595                }
    … …  
    15561605                switch (enmPromiscModePolicy)
    15571606                {
    1558                     case NetworkAdapterPromiscModePolicy_Deny:          pszPromiscuousGuestPolicy = "deny"; break;
    1559                     case NetworkAdapterPromiscModePolicy_AllowNetwork:  pszPromiscuousGuestPolicy = "allow-vms"; break;
    1560                     case NetworkAdapterPromiscModePolicy_AllowAll:      pszPromiscuousGuestPolicy = "allow-all"; break;
     1607                    case NetworkAdapterPromiscModePolicy_Deny:          pszPromiscuousGuestPolicy = Info::tr("deny"); break;
     1608                    case NetworkAdapterPromiscModePolicy_AllowNetwork:  pszPromiscuousGuestPolicy = Info::tr("allow-vms"); break;
     1609                    case NetworkAdapterPromiscModePolicy_AllowAll:      pszPromiscuousGuestPolicy = Info::tr("allow-all"); break;
    15611610                    default: AssertFailedReturn(E_INVALIDARG);
    15621611                }
    … …  
    15891638                    case NetworkAdapterType_Virtio_1_0: pszNICType = "virtio_1.0";  break;
    15901639#endif
    1591                     default: AssertFailed();            pszNICType = "unknown";     break;
     1640                    default:
     1641                        AssertFailed();
     1642                        if (details == VMINFO_MACHINEREADABLE)
     1643                            pszNICType = "unknown";
     1644                        else
     1645                            pszNICType = Info::tr("unknown");
     1646                        break;
    15921647                }
    15931648
    … …  
    16161671                }
    16171672                else
    1618                     RTPrintf("%-28s MAC: %ls, Attachment: %s, Cable connected: %s, Trace: %s (file: %ls), Type: %s, Reported speed: %d Mbps, Boot priority: %d, Promisc Policy: %s, Bandwidth group: %ls\n",
     1673                    RTPrintf(Info::tr("%-28s MAC: %ls, Attachment: %s, Cable connected: %s, Trace: %s (file: %ls), Type: %s, Reported speed: %d Mbps, Boot priority: %d, Promisc Policy: %s, Bandwidth group: %ls\n"),
    16191674                             szNm, strMACAddress.raw(), strAttachment.c_str(),
    1620                              fConnected ? "on" : "off",
    1621                              fTraceEnabled ? "on" : "off",
    1622                              traceFile.isEmpty() ? Bstr("none").raw() : traceFile.raw(),
     1675                             fConnected ? Info::tr("on") : Info::tr("off"),
     1676                             fTraceEnabled ? Info::tr("on") : Info::tr("off"),
     1677                             traceFile.isEmpty() ? Bstr(Info::tr("none")).raw() : traceFile.raw(),
    16231678                             pszNICType,
    16241679                             ulLineSpeed / 1000,
    16251680                             (int)ulBootPriority,
    16261681                             pszPromiscuousGuestPolicy,
    1627                              strBwGroup.isEmpty() ? Bstr("none").raw() : strBwGroup.raw());
     1682                             strBwGroup.isEmpty() ? Bstr(Info::tr("none")).raw() : strBwGroup.raw());
    16281683                if (strNatSettings.length())
    16291684                    RTPrintf(strNatSettings.c_str());
    … …  
    16361691    /* Pointing device information */
    16371692    PointingHIDType_T aPointingHID;
    1638     const char *pszHID = "Unknown";
     1693    const char *pszHID = Info::tr("Unknown");
    16391694    const char *pszMrHID = "unknown";
    16401695    machine->COMGETTER(PointingHIDType)(&aPointingHID);
    … …  
    16421697    {
    16431698        case PointingHIDType_None:
    1644             pszHID = "None";
     1699            pszHID = Info::tr("None");
    16451700            pszMrHID = "none";
    16461701            break;
    16471702        case PointingHIDType_PS2Mouse:
    1648             pszHID = "PS/2 Mouse";
     1703            pszHID = Info::tr("PS/2 Mouse");
    16491704            pszMrHID = "ps2mouse";
    16501705            break;
    16511706        case PointingHIDType_USBMouse:
    1652             pszHID = "USB Mouse";
     1707            pszHID = Info::tr("USB Mouse");
    16531708            pszMrHID = "usbmouse";
    16541709            break;
    16551710        case PointingHIDType_USBTablet:
    1656             pszHID = "USB Tablet";
     1711            pszHID = Info::tr("USB Tablet");
    16571712            pszMrHID = "usbtablet";
    16581713            break;
    16591714        case PointingHIDType_ComboMouse:
    1660             pszHID = "USB Tablet and PS/2 Mouse";
     1715            pszHID = Info::tr("USB Tablet and PS/2 Mouse");
    16611716            pszMrHID = "combomouse";
    16621717            break;
    16631718        case PointingHIDType_USBMultiTouch:
    1664             pszHID = "USB Multi-Touch";
     1719            pszHID = Info::tr("USB Multi-Touch");
    16651720            pszMrHID = "usbmultitouch";
    16661721            break;
    … …  
    16681723            break;
    16691724    }
    1670     SHOW_UTF8_STRING("hidpointing", "Pointing Device:", details == VMINFO_MACHINEREADABLE ? pszMrHID : pszHID);
     1725    SHOW_UTF8_STRING("hidpointing", Info::tr("Pointing Device:"), details == VMINFO_MACHINEREADABLE ? pszMrHID : pszHID);
    16711726
    16721727    /* Keyboard device information */
    16731728    KeyboardHIDType_T aKeyboardHID;
    16741729    machine->COMGETTER(KeyboardHIDType)(&aKeyboardHID);
    1675     pszHID = "Unknown";
     1730    pszHID = Info::tr("Unknown");
    16761731    pszMrHID = "unknown";
    16771732    switch (aKeyboardHID)
    16781733    {
    16791734        case KeyboardHIDType_None:
    1680             pszHID = "None";
     1735            pszHID = Info::tr("None");
    16811736            pszMrHID = "none";
    16821737            break;
    16831738        case KeyboardHIDType_PS2Keyboard:
    1684             pszHID = "PS/2 Keyboard";
     1739            pszHID = Info::tr("PS/2 Keyboard");
    16851740            pszMrHID = "ps2kbd";
    16861741            break;
    16871742        case KeyboardHIDType_USBKeyboard:
    1688             pszHID = "USB Keyboard";
     1743            pszHID = Info::tr("USB Keyboard");
    16891744            pszMrHID = "usbkbd";
    16901745            break;
    16911746        case KeyboardHIDType_ComboKeyboard:
    1692             pszHID = "USB and PS/2 Keyboard";
     1747            pszHID = Info::tr("USB and PS/2 Keyboard");
    16931748            pszMrHID = "combokbd";
    16941749            break;
    … …  
    16961751            break;
    16971752    }
    1698     SHOW_UTF8_STRING("hidkeyboard", "Keyboard Device:", details == VMINFO_MACHINEREADABLE ? pszMrHID : pszHID);
     1753    SHOW_UTF8_STRING("hidkeyboard", Info::tr("Keyboard Device:"), details == VMINFO_MACHINEREADABLE ? pszMrHID : pszHID);
    16991754
    17001755    ComPtr<ISystemProperties> sysProps;
    … …  
    17101765        if (SUCCEEDED(rc) && uart)
    17111766        {
    1712             FmtNm(szNm, details == VMINFO_MACHINEREADABLE ? "uart%u" : "UART %u:", currentUART + 1);
     1767            FmtNm(szNm, details == VMINFO_MACHINEREADABLE ? "uart%u" : Info::tr("UART %u:"), currentUART + 1);
    17131768
    17141769            /* show the config of this UART */
    … …  
    17201775                    RTPrintf("%s=\"off\"\n", szNm);
    17211776                else
    1722                     RTPrintf("%-28s disabled\n", szNm);
     1777                    RTPrintf(Info::tr("%-28s disabled\n"), szNm);
    17231778            }
    17241779            else
    … …  
    17391794                    RTPrintf("%s=\"%#06x,%d\"\n", szNm, ulIOBase, ulIRQ);
    17401795                else
    1741                     RTPrintf("%-28s I/O base: %#06x, IRQ: %d", szNm, ulIOBase, ulIRQ);
     1796                    RTPrintf(Info::tr("%-28s I/O base: %#06x, IRQ: %d"), szNm, ulIOBase, ulIRQ);
    17421797                switch (HostMode)
    17431798                {
    … …  
    17471802                            RTPrintf("uartmode%d=\"disconnected\"\n", currentUART + 1);
    17481803                        else
    1749                             RTPrintf(", disconnected");
     1804                            RTPrintf(Info::tr(", disconnected"));
    17501805                        break;
    17511806                    case PortMode_RawFile:
    … …  
    17541809                                     path.raw());
    17551810                        else
    1756                             RTPrintf(", attached to raw file '%ls'\n",
     1811                            RTPrintf(Info::tr(", attached to raw file '%ls'\n"),
    17571812                                     path.raw());
    17581813                        break;
    … …  
    17621817                                     fServer ? "tcpserver" : "tcpclient", path.raw());
    17631818                        else
    1764                             RTPrintf(", attached to tcp (%s) '%ls'",
    1765                                      fServer ? "server" : "client", path.raw());
     1819                            RTPrintf(Info::tr(", attached to tcp (%s) '%ls'"),
     1820                                     fServer ? Info::tr("server") : Info::tr("client"), path.raw());
    17661821                        break;
    17671822                    case PortMode_HostPipe:
    … …  
    17701825                                     fServer ? "server" : "client", path.raw());
    17711826                        else
    1772                             RTPrintf(", attached to pipe (%s) '%ls'",
    1773                                      fServer ? "server" : "client", path.raw());
     1827                            RTPrintf(Info::tr(", attached to pipe (%s) '%ls'"),
     1828                                     fServer ? Info::tr("server") : Info::tr("client"), path.raw());
    17741829                        break;
    17751830                    case PortMode_HostDevice:
    … …  
    17781833                                     path.raw());
    17791834                        else
    1780                             RTPrintf(", attached to device '%ls'", path.raw());
     1835                            RTPrintf(Info::tr(", attached to device '%ls'"), path.raw());
    17811836                        break;
    17821837                }
    … …  
    18161871        if (SUCCEEDED(rc) && lpt)
    18171872        {
    1818             FmtNm(szNm, details == VMINFO_MACHINEREADABLE ? "lpt%u" : "LPT %u:", currentLPT + 1);
     1873            FmtNm(szNm, details == VMINFO_MACHINEREADABLE ? "lpt%u" : Info::tr("LPT %u:"), currentLPT + 1);
    18191874
    18201875            /* show the config of this LPT */
    … …  
    18261881                    RTPrintf("%s=\"off\"\n", szNm);
    18271882                else
    1828                     RTPrintf("%-28s disabled\n", szNm);
     1883                    RTPrintf(Info::tr("%-28s disabled\n"), szNm);
    18291884            }
    18301885            else
    … …  
    18391894                    RTPrintf("%s=\"%#06x,%d\"\n", szNm, ulIOBase, ulIRQ);
    18401895                else
    1841                     RTPrintf("%-28s I/O base: %#06x, IRQ: %d", szNm, ulIOBase, ulIRQ);
     1896                    RTPrintf(Info::tr("%-28s I/O base: %#06x, IRQ: %d"), szNm, ulIOBase, ulIRQ);
    18421897                if (details == VMINFO_MACHINEREADABLE)
    18431898                    RTPrintf("lptmode%d=\"%ls\"\n", currentLPT + 1, path.raw());
    18441899                else
    1845                     RTPrintf(", attached to device '%ls'\n", path.raw());
     1900                    RTPrintf(Info::tr(", attached to device '%ls'\n"), path.raw());
    18461901            }
    18471902        }
    … …  
    18521907    if (SUCCEEDED(rc))
    18531908    {
    1854         const char *pszDrv   = "Unknown";
    1855         const char *pszCtrl  = "Unknown";
    1856         const char *pszCodec = "Unknown";
     1909        const char *pszDrv   = Info::tr("Unknown");
     1910        const char *pszCtrl  = Info::tr("Unknown");
     1911        const char *pszCodec = Info::tr("Unknown");
    18571912        BOOL fEnabled;
    18581913        rc = AudioAdapter->COMGETTER(Enabled)(&fEnabled);
    … …  
    18671922                        pszDrv = "null";
    18681923                    else
    1869                         pszDrv = "Null";
     1924                        pszDrv = Info::tr("Null");
    18701925                    break;
    18711926                case AudioDriverType_WinMM:
    … …  
    19682023        else
    19692024        {
    1970             RTPrintf("%-28s %s", "Audio:", fEnabled ? "enabled" : "disabled");
     2025            RTPrintf("%-28s %s", Info::tr("Audio:"), fEnabled ? Info::tr("enabled") : Info::tr("disabled"));
    19712026            if (fEnabled)
    1972                 RTPrintf(" (Driver: %s, Controller: %s, Codec: %s)", pszDrv, pszCtrl, pszCodec);
     2027                RTPrintf(Info::tr(" (Driver: %s, Controller: %s, Codec: %s)"), pszDrv, pszCtrl, pszCodec);
    19732028            RTPrintf("\n");
    19742029        }
    1975         SHOW_BOOLEAN_PROP(AudioAdapter, EnabledOut,  "audio_out",  "Audio playback:");
    1976         SHOW_BOOLEAN_PROP(AudioAdapter, EnabledIn, "audio_in", "Audio capture:");
     2030        SHOW_BOOLEAN_PROP(AudioAdapter, EnabledOut,  "audio_out",  Info::tr("Audio playback:"));
     2031        SHOW_BOOLEAN_PROP(AudioAdapter, EnabledIn, "audio_in", Info::tr("Audio capture:"));
    19772032    }
    19782033
    … …  
    19882043                break;
    19892044            case ClipboardMode_HostToGuest:
    1990                 psz = details == VMINFO_MACHINEREADABLE ? "hosttoguest" : "HostToGuest";
     2045                psz = details == VMINFO_MACHINEREADABLE ? "hosttoguest" : Info::tr("HostToGuest");
    19912046                break;
    19922047            case ClipboardMode_GuestToHost:
    1993                 psz = details == VMINFO_MACHINEREADABLE ? "guesttohost" : "GuestToHost";
     2048                psz = details == VMINFO_MACHINEREADABLE ? "guesttohost" : Info::tr("GuestToHost");
    19942049                break;
    19952050            case ClipboardMode_Bidirectional:
    1996                 psz = details == VMINFO_MACHINEREADABLE ? "bidirectional" : "Bidirectional";
     2051                psz = details == VMINFO_MACHINEREADABLE ? "bidirectional" : Info::tr("Bidirectional");
    19972052                break;
    19982053            default:
    1999                 psz = details == VMINFO_MACHINEREADABLE ? "unknown" : "Unknown";
    2000                 break;
    2001         }
    2002         SHOW_UTF8_STRING("clipboard", "Clipboard Mode:", psz);
     2054                psz = details == VMINFO_MACHINEREADABLE ? "unknown" : Info::tr("Unknown");
     2055                break;
     2056        }
     2057        SHOW_UTF8_STRING("clipboard", Info::tr("Clipboard Mode:"), psz);
    20032058#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
    2004         SHOW_BOOLEAN_PROP(machine, ClipboardFileTransfersEnabled, "clipboard_file_transfers", "Clipboard file transfers:");
     2059        SHOW_BOOLEAN_PROP(machine, ClipboardFileTransfersEnabled, "clipboard_file_transfers", Info::tr("Clipboard file transfers:"));
    20052060#endif
    20062061    }
    … …  
    20172072                break;
    20182073            case DnDMode_HostToGuest:
    2019                 psz = details == VMINFO_MACHINEREADABLE ? "hosttoguest" : "HostToGuest";
     2074                psz = details == VMINFO_MACHINEREADABLE ? "hosttoguest" : Info::tr("HostToGuest");
    20202075                break;
    20212076            case DnDMode_GuestToHost:
    2022                 psz = details == VMINFO_MACHINEREADABLE ? "guesttohost" : "GuestToHost";
     2077                psz = details == VMINFO_MACHINEREADABLE ? "guesttohost" : Info::tr("GuestToHost");
    20232078                break;
    20242079            case DnDMode_Bidirectional:
    2025                 psz = details == VMINFO_MACHINEREADABLE ? "bidirectional" : "Bidirectional";
     2080                psz = details == VMINFO_MACHINEREADABLE ? "bidirectional" : Info::tr("Bidirectional");
    20262081                break;
    20272082            default:
    2028                 psz = details == VMINFO_MACHINEREADABLE ? "unknown" : "Unknown";
    2029                 break;
    2030         }
    2031         SHOW_UTF8_STRING("draganddrop", "Drag and drop Mode:", psz);
     2083                psz = details == VMINFO_MACHINEREADABLE ? "unknown" : Info::tr("Unknown");
     2084                break;
     2085        }
     2086        SHOW_UTF8_STRING("draganddrop", Info::tr("Drag and drop Mode:"), psz);
    20322087    }
    20332088
    … …  
    20402095            rc = machine->COMGETTER(SessionName)(sessName.asOutParam());
    20412096            if (SUCCEEDED(rc) && !sessName.isEmpty())
    2042                 SHOW_BSTR_STRING("SessionName", "Session name:", sessName);
     2097                SHOW_BSTR_STRING("SessionName", Info::tr("Session name:"), sessName);
    20432098        }
    20442099    }
    … …  
    20732128            else
    20742129            {
    2075                 const char *pszMonitorStatus = "unknown status";
     2130                const char *pszMonitorStatus = Info::tr("unknown status");
    20762131                switch (monitorStatus)
    20772132                {
    2078                     case GuestMonitorStatus_Blank:    pszMonitorStatus = "blank"; break;
    2079                     case GuestMonitorStatus_Enabled:  pszMonitorStatus = "enabled"; break;
    2080                     case GuestMonitorStatus_Disabled: pszMonitorStatus = "disabled"; break;
     2133                    case GuestMonitorStatus_Blank:    pszMonitorStatus = Info::tr("blank"); break;
     2134                    case GuestMonitorStatus_Enabled:  pszMonitorStatus = Info::tr("enabled"); break;
     2135                    case GuestMonitorStatus_Disabled: pszMonitorStatus = Info::tr("disabled"); break;
    20812136                    default: break;
    20822137                }
    2083                 RTPrintf("%-28s %dx%dx%d at %d,%d %s\n", "Video mode:", xRes, yRes, bpp, xOrigin, yOrigin, pszMonitorStatus);
     2138                RTPrintf("%-28s %dx%dx%d at %d,%d %s\n", Info::tr("Video mode:"), xRes, yRes, bpp, xOrigin, yOrigin, pszMonitorStatus);
    20842139            }
    20852140        }
    … …  
    21192174            {
    21202175                case AuthType_Null:
    2121                     strAuthType = "null";
     2176                    if (details == VMINFO_MACHINEREADABLE)
     2177                        strAuthType = "null";
     2178                    else
     2179                        strAuthType = Info::tr("null");
    21222180                    break;
    21232181                case AuthType_External:
    2124                     strAuthType = "external";
     2182                    if (details == VMINFO_MACHINEREADABLE)
     2183                        strAuthType = "external";
     2184                    else
     2185                        strAuthType = Info::tr("external");
    21252186                    break;
    21262187                case AuthType_Guest:
    2127                     strAuthType = "guest";
     2188                    if (details == VMINFO_MACHINEREADABLE)
     2189                        strAuthType = "guest";
     2190                    else
     2191                        strAuthType = Info::tr("guest");
    21282192                    break;
    21292193                default:
    2130                     strAuthType = "unknown";
     2194                    if (details == VMINFO_MACHINEREADABLE)
     2195                        strAuthType = "unknown";
     2196                    else
     2197                        strAuthType = Info::tr("unknown");
    21312198                    break;
    21322199            }
    … …  
    21672234                if (address.isEmpty())
    21682235                    address = "0.0.0.0";
    2169                 RTPrintf("%-28s enabled (Address %ls, Ports %ls, MultiConn: %s, ReuseSingleConn: %s, Authentication type: %s)\n",
    2170                          "VRDE:", address.raw(), ports.raw(), fMultiCon ? "on" : "off", fReuseCon ? "on" : "off", strAuthType);
     2236                RTPrintf(Info::tr("%-28s enabled (Address %ls, Ports %ls, MultiConn: %s, ReuseSingleConn: %s, Authentication type: %s)\n"),
     2237                         "VRDE:", address.raw(), ports.raw(), fMultiCon ? Info::tr("on") : Info::tr("off"),
     2238                         fReuseCon ? Info::tr("on") : Info::tr("off"), strAuthType);
    21712239                if (pConsole && currentPort != -1 && currentPort != 0)
    2172                    RTPrintf("%-28s %d\n", "VRDE port:", currentPort);
     2240                   RTPrintf("%-28s %d\n", Info::tr("VRDE port:"), currentPort);
    21732241                if (fVideoChannel)
    2174                     RTPrintf("%-28s enabled (Quality %ls)\n", "Video redirection:", videoChannelQuality.raw());
     2242                    RTPrintf(Info::tr("%-28s enabled (Quality %ls)\n"), Info::tr("Video redirection:"), videoChannelQuality.raw());
    21752243                else
    2176                     RTPrintf("%-28s disabled\n", "Video redirection:");
     2244                    RTPrintf(Info::tr("%-28s disabled\n"), Info::tr("Video redirection:"));
    21772245            }
    21782246            com::SafeArray<BSTR> aProperties;
    … …  
    21942262                    {
    21952263                        if (value.isEmpty())
    2196                             RTPrintf("%-28s: %-10lS = <not set>\n", "VRDE property", aProperties[i]);
     2264                            RTPrintf(Info::tr("%-28s: %-10lS = <not set>\n"), Info::tr("VRDE property"), aProperties[i]);
    21972265                        else
    2198                             RTPrintf("%-28s: %-10lS = \"%ls\"\n", "VRDE property", aProperties[i], value.raw());
     2266                            RTPrintf("%-28s: %-10lS = \"%ls\"\n", Info::tr("VRDE property"), aProperties[i], value.raw());
    21992267                    }
    22002268                }
    … …  
    22062274                RTPrintf("vrde=\"off\"\n");
    22072275            else
    2208                 RTPrintf("%-28s disabled\n", "VRDE:");
     2276                RTPrintf(Info::tr("%-28s disabled\n"), "VRDE:");
    22092277        }
    22102278    }
    … …  
    22592327        {
    22602328            if (details != VMINFO_MACHINEREADABLE)
    2261                 RTPrintf("\nUSB Device Filters:\n\n");
     2329                RTPrintf(Info::tr("\nUSB Device Filters:\n\n"));
    22622330
    22632331            if (Coll.size() == 0)
    22642332            {
    22652333                if (details != VMINFO_MACHINEREADABLE)
    2266                     RTPrintf("<none>\n\n");
     2334                    RTPrintf(Info::tr("<none>\n\n"));
    22672335            }
    22682336            else
    … …  
    22732341
    22742342                    if (details != VMINFO_MACHINEREADABLE)
    2275                         SHOW_UTF8_STRING("index", "Index:", FmtNm(szNm, "%zu", index));
    2276                     SHOW_BOOLEAN_PROP_EX(DevPtr, Active,   FmtNm(szNm, "USBFilterActive%zu", index + 1),       "Active:", "yes", "no");
    2277                     SHOW_STRING_PROP(DevPtr, Name,         FmtNm(szNm, "USBFilterName%zu", index + 1),         "Name:");
    2278                     SHOW_STRING_PROP(DevPtr, VendorId,     FmtNm(szNm, "USBFilterVendorId%zu", index + 1),     "VendorId:");
    2279                     SHOW_STRING_PROP(DevPtr, ProductId,    FmtNm(szNm, "USBFilterProductId%zu", index + 1),    "ProductId:");
    2280                     SHOW_STRING_PROP(DevPtr, Revision,     FmtNm(szNm, "USBFilterRevision%zu", index + 1),     "Revision:");
    2281                     SHOW_STRING_PROP(DevPtr, Manufacturer, FmtNm(szNm, "USBFilterManufacturer%zu", index + 1), "Manufacturer:");
    2282                     SHOW_STRING_PROP(DevPtr, Product,      FmtNm(szNm, "USBFilterProduct%zu", index + 1),      "Product:");
    2283                     SHOW_STRING_PROP(DevPtr, Remote,       FmtNm(szNm, "USBFilterRemote%zu", index + 1),       "Remote:");
    2284                     SHOW_STRING_PROP(DevPtr, SerialNumber, FmtNm(szNm, "USBFilterSerialNumber%zu", index + 1),       "Serial Number:");
     2343                        SHOW_UTF8_STRING("index", Info::tr("Index:"), FmtNm(szNm, "%zu", index));
     2344                    SHOW_BOOLEAN_PROP_EX(DevPtr, Active,   FmtNm(szNm, "USBFilterActive%zu", index + 1),       Info::tr("Active:"), Info::tr("yes"), Info::tr("no"));
     2345                    SHOW_STRING_PROP(DevPtr, Name,         FmtNm(szNm, "USBFilterName%zu", index + 1),         Info::tr("Name:"));
     2346                    SHOW_STRING_PROP(DevPtr, VendorId,     FmtNm(szNm, "USBFilterVendorId%zu", index + 1),     Info::tr("VendorId:"));
     2347                    SHOW_STRING_PROP(DevPtr, ProductId,    FmtNm(szNm, "USBFilterProductId%zu", index + 1),    Info::tr("ProductId:"));
     2348                    SHOW_STRING_PROP(DevPtr, Revision,     FmtNm(szNm, "USBFilterRevision%zu", index + 1),     Info::tr("Revision:"));
     2349                    SHOW_STRING_PROP(DevPtr, Manufacturer, FmtNm(szNm, "USBFilterManufacturer%zu", index + 1), Info::tr("Manufacturer:"));
     2350                    SHOW_STRING_PROP(DevPtr, Product,      FmtNm(szNm, "USBFilterProduct%zu", index + 1),      Info::tr("Product:"));
     2351                    SHOW_STRING_PROP(DevPtr, Remote,       FmtNm(szNm, "USBFilterRemote%zu", index + 1),       Info::tr("Remote:"));
     2352                    SHOW_STRING_PROP(DevPtr, SerialNumber, FmtNm(szNm, "USBFilterSerialNumber%zu", index + 1), Info::tr("Serial Number:"));
    22852353                    if (details != VMINFO_MACHINEREADABLE)
    22862354                    {
    … …  
    22882356                        CHECK_ERROR_RET(DevPtr, COMGETTER(MaskedInterfaces)(&fMaskedIfs), rc);
    22892357                        if (fMaskedIfs)
    2290                             RTPrintf("%-28s %#010x\n", "Masked Interfaces:", fMaskedIfs);
     2358                            RTPrintf("%-28s %#010x\n", Info::tr("Masked Interfaces:"), fMaskedIfs);
    22912359                        RTPrintf("\n");
    22922360                    }
    … …  
    23002368            {
    23012369                if (details != VMINFO_MACHINEREADABLE)
    2302                     RTPrintf("Available remote USB devices:\n\n");
     2370                    RTPrintf(Info::tr("Available remote USB devices:\n\n"));
    23032371
    23042372                SafeIfaceArray <IHostUSBDevice> coll;
    … …  
    23082376                {
    23092377                    if (details != VMINFO_MACHINEREADABLE)
    2310                         RTPrintf("<none>\n\n");
     2378                        RTPrintf(Info::tr("<none>\n\n"));
    23112379                }
    23122380                else
    … …  
    23192387
    23202388                        SHOW_STRING_PROP(dev, Id, FmtNm(szNm, "%sActive%zu", pszPfx, i + 1), "UUID:");
    2321                         SHOW_USHORT_PROP_EX2(dev, VendorId,  FmtNm(szNm, "%sVendorId%zu", pszPfx, i + 1),  "VendorId:",  "", "%#06x", "%#06x (%04X)");
    2322                         SHOW_USHORT_PROP_EX2(dev, ProductId, FmtNm(szNm, "%sProductId%zu", pszPfx, i + 1), "ProductId:", "", "%#06x", "%#06x (%04X)");
     2389                        SHOW_USHORT_PROP_EX2(dev, VendorId,  FmtNm(szNm, "%sVendorId%zu", pszPfx, i + 1),  Info::tr("VendorId:"),  "", "%#06x", "%#06x (%04X)");
     2390                        SHOW_USHORT_PROP_EX2(dev, ProductId, FmtNm(szNm, "%sProductId%zu", pszPfx, i + 1), Info::tr("ProductId:"), "", "%#06x", "%#06x (%04X)");
    23232391
    23242392                        USHORT bcdRevision;
    … …  
    23292397                            RTStrPrintf(szValue, sizeof(szValue), "%u.%u (%02u%02u)\n",
    23302398                                        bcdRevision >> 8, bcdRevision & 0xff, bcdRevision >> 8, bcdRevision & 0xff);
    2331                         SHOW_UTF8_STRING(FmtNm(szNm, "%sRevision%zu", pszPfx, i + 1), "Revision:", szValue);
    2332 
    2333                         SHOW_STRING_PROP_NOT_EMPTY(dev, Manufacturer, FmtNm(szNm, "%sManufacturer%zu", pszPfx, i + 1), "Manufacturer:");
    2334                         SHOW_STRING_PROP_NOT_EMPTY(dev, Product,      FmtNm(szNm, "%sProduct%zu", pszPfx, i + 1),      "Product:");
    2335                         SHOW_STRING_PROP_NOT_EMPTY(dev, SerialNumber, FmtNm(szNm, "%sSerialNumber%zu", pszPfx, i + 1), "SerialNumber:");
    2336                         SHOW_STRING_PROP_NOT_EMPTY(dev, Address,      FmtNm(szNm, "%sAddress%zu", pszPfx, i + 1),      "Address:");
     2399                        SHOW_UTF8_STRING(FmtNm(szNm, "%sRevision%zu", pszPfx, i + 1), Info::tr("Revision:"), szValue);
     2400
     2401                        SHOW_STRING_PROP_NOT_EMPTY(dev, Manufacturer, FmtNm(szNm, "%sManufacturer%zu", pszPfx, i + 1), Info::tr("Manufacturer:"));
     2402                        SHOW_STRING_PROP_NOT_EMPTY(dev, Product,      FmtNm(szNm, "%sProduct%zu", pszPfx, i + 1),      Info::tr("Product:"));
     2403                        SHOW_STRING_PROP_NOT_EMPTY(dev, SerialNumber, FmtNm(szNm, "%sSerialNumber%zu", pszPfx, i + 1), Info::tr("SerialNumber:"));
     2404                        SHOW_STRING_PROP_NOT_EMPTY(dev, Address,      FmtNm(szNm, "%sAddress%zu", pszPfx, i + 1),      Info::tr("Address:"));
    23372405
    23382406                        if (details != VMINFO_MACHINEREADABLE)
    … …  
    23452413            {
    23462414                if (details != VMINFO_MACHINEREADABLE)
    2347                     RTPrintf("Currently Attached USB Devices:\n\n");
     2415                    RTPrintf(Info::tr("Currently Attached USB Devices:\n\n"));
    23482416
    23492417                SafeIfaceArray <IUSBDevice> coll;
    … …  
    23532421                {
    23542422                    if (details != VMINFO_MACHINEREADABLE)
    2355                         RTPrintf("<none>\n\n");
     2423                        RTPrintf(Info::tr("<none>\n\n"));
    23562424                }
    23572425                else
    … …  
    23642432
    23652433                        SHOW_STRING_PROP(dev, Id, FmtNm(szNm, "%sActive%zu", pszPfx, i + 1), "UUID:");
    2366                         SHOW_USHORT_PROP_EX2(dev, VendorId,  FmtNm(szNm, "%sVendorId%zu", pszPfx, i + 1),  "VendorId:",  "", "%#06x", "%#06x (%04X)");
    2367                         SHOW_USHORT_PROP_EX2(dev, ProductId, FmtNm(szNm, "%sProductId%zu", pszPfx, i + 1), "ProductId:", "", "%#06x", "%#06x (%04X)");
     2434                        SHOW_USHORT_PROP_EX2(dev, VendorId,  FmtNm(szNm, "%sVendorId%zu", pszPfx, i + 1),  Info::tr("VendorId:"),  "", "%#06x", "%#06x (%04X)");
     2435                        SHOW_USHORT_PROP_EX2(dev, ProductId, FmtNm(szNm, "%sProductId%zu", pszPfx, i + 1), Info::tr("ProductId:"), "", "%#06x", "%#06x (%04X)");
    23682436
    23692437                        USHORT bcdRevision;
    … …  
    23742442                            RTStrPrintf(szValue, sizeof(szValue), "%u.%u (%02u%02u)\n",
    23752443                                        bcdRevision >> 8, bcdRevision & 0xff, bcdRevision >> 8, bcdRevision & 0xff);
    2376                         SHOW_UTF8_STRING(FmtNm(szNm, "%sRevision%zu", pszPfx, i + 1), "Revision:", szValue);
    2377 
    2378                         SHOW_STRING_PROP_NOT_EMPTY(dev, Manufacturer, FmtNm(szNm, "%sManufacturer%zu", pszPfx, i + 1), "Manufacturer:");
    2379                         SHOW_STRING_PROP_NOT_EMPTY(dev, Product,      FmtNm(szNm, "%sProduct%zu", pszPfx, i + 1),      "Product:");
    2380                         SHOW_STRING_PROP_NOT_EMPTY(dev, SerialNumber, FmtNm(szNm, "%sSerialNumber%zu", pszPfx, i + 1), "SerialNumber:");
    2381                         SHOW_STRING_PROP_NOT_EMPTY(dev, Address,      FmtNm(szNm, "%sAddress%zu", pszPfx, i + 1),      "Address:");
     2444                        SHOW_UTF8_STRING(FmtNm(szNm, "%sRevision%zu", pszPfx, i + 1), Info::tr("Revision:"), szValue);
     2445
     2446                        SHOW_STRING_PROP_NOT_EMPTY(dev, Manufacturer, FmtNm(szNm, "%sManufacturer%zu", pszPfx, i + 1), Info::tr("Manufacturer:"));
     2447                        SHOW_STRING_PROP_NOT_EMPTY(dev, Product,      FmtNm(szNm, "%sProduct%zu", pszPfx, i + 1),      Info::tr("Product:"));
     2448                        SHOW_STRING_PROP_NOT_EMPTY(dev, SerialNumber, FmtNm(szNm, "%sSerialNumber%zu", pszPfx, i + 1), Info::tr("SerialNumber:"));
     2449                        SHOW_STRING_PROP_NOT_EMPTY(dev, Address,      FmtNm(szNm, "%sAddress%zu", pszPfx, i + 1),      Info::tr("Address:"));
    23822450
    23832451                        if (details != VMINFO_MACHINEREADABLE)
    … …  
    23982466             if (assignments.size() > 0 && (details != VMINFO_MACHINEREADABLE))
    23992467             {
    2400                  RTPrintf("\nAttached physical PCI devices:\n\n");
     2468                 RTPrintf(Info::tr("\nAttached physical PCI devices:\n\n"));
    24012469             }
    24022470
    … …  
    24172485                     RTPrintf("AttachedHostPCI=%s,%s\n", szHostPCIAddress, szGuestPCIAddress);
    24182486                 else
    2419                      RTPrintf("   Host device %ls at %s attached as %s\n", DevName.raw(), szHostPCIAddress, szGuestPCIAddress);
     2487                     RTPrintf(Info::tr("   Host device %ls at %s attached as %s\n"), DevName.raw(), szHostPCIAddress, szGuestPCIAddress);
    24202488             }
    24212489
    … …  
    24332501     */
    24342502    if (details != VMINFO_MACHINEREADABLE)
    2435         RTPrintf("Bandwidth groups:  ");
     2503        RTPrintf(Info::tr("Bandwidth groups:  "));
    24362504    {
    24372505        ComPtr<IBandwidthControl> bwCtrl;
    … …  
    24462514     */
    24472515    if (details != VMINFO_MACHINEREADABLE)
    2448         RTPrintf("Shared folders:");
     2516        RTPrintf(Info::tr("Shared folders:"));
    24492517    uint32_t numSharedFolders = 0;
    24502518#if 0 // not yet implemented
    … …  
    24562524        {
    24572525            ComPtr<ISharedFolder> sf = sfColl[i];
    2458             showSharedFolder(sf, details, "global mapping", "GlobalMapping", i + 1, numSharedFolders == 0);
     2526            showSharedFolder(sf, details, Info::tr("global mapping"), "GlobalMapping", i + 1, numSharedFolders == 0);
    24592527            ++numSharedFolders;
    24602528        }
    … …  
    24682536        {
    24692537            ComPtr<ISharedFolder> sf = folders[i];
    2470             showSharedFolder(sf, details, "machine mapping", "MachineMapping", i + 1, numSharedFolders == 0);
     2538            showSharedFolder(sf, details, Info::tr("machine mapping"), "MachineMapping", i + 1, numSharedFolders == 0);
    24712539            ++numSharedFolders;
    24722540        }
    … …  
    24802548        {
    24812549            ComPtr<ISharedFolder> sf = folders[i];
    2482             showSharedFolder(sf, details, "transient mapping", "TransientMapping", i + 1, numSharedFolders == 0);
     2550            showSharedFolder(sf, details, Info::tr("transient mapping"), "TransientMapping", i + 1, numSharedFolders == 0);
    24832551            ++numSharedFolders;
    24842552        }
    24852553    }
    24862554    if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
    2487         RTPrintf("<none>\n");
     2555        RTPrintf(Info::tr("<none>\n"));
    24882556    if (details != VMINFO_MACHINEREADABLE)
    24892557        RTPrintf("\n");
    … …  
    25292597        }
    25302598
    2531         SHOW_BOOL_VALUE_EX("VRDEActiveConnection", "VRDE Connection:", fActive, "active", "not active");
    2532         SHOW_ULONG_VALUE("VRDEClients=", "Clients so far:", cNumberOfClients, "");
     2599        SHOW_BOOL_VALUE_EX("VRDEActiveConnection", Info::tr("VRDE Connection:"), fActive, Info::tr("active"), Info::tr("not active"));
     2600        SHOW_ULONG_VALUE("VRDEClients=", Info::tr("Clients so far:"), cNumberOfClients, "");
    25332601
    25342602        if (cNumberOfClients > 0)
    … …  
    25372605            makeTimeStr(szTimeValue, sizeof(szTimeValue), BeginTime);
    25382606            if (fActive)
    2539                 SHOW_UTF8_STRING("VRDEStartTime", "Start time:", szTimeValue);
     2607                SHOW_UTF8_STRING("VRDEStartTime", Info::tr("Start time:"), szTimeValue);
    25402608            else
    25412609            {
    2542                 SHOW_UTF8_STRING("VRDELastStartTime", "Last started:", szTimeValue);
     2610                SHOW_UTF8_STRING("VRDELastStartTime", Info::tr("Last started:"), szTimeValue);
    25432611                makeTimeStr(szTimeValue, sizeof(szTimeValue), EndTime);
    2544                 SHOW_UTF8_STRING("VRDELastEndTime", "Last ended:", szTimeValue);
     2612                SHOW_UTF8_STRING("VRDELastEndTime", Info::tr("Last ended:"), szTimeValue);
    25452613            }
    25462614
    … …  
    25522620                ThroughputReceive = (BytesReceived * 1000) / (EndTime - BeginTime);
    25532621            }
    2554             SHOW_LONG64_VALUE("VRDEBytesSent", "Sent:", BytesSent, "Bytes");
    2555             SHOW_LONG64_VALUE("VRDEThroughputSend", "Average speed:", ThroughputSend, "B/s");
    2556             SHOW_LONG64_VALUE("VRDEBytesSentTotal", "Sent total:", BytesSentTotal, "Bytes");
    2557 
    2558             SHOW_LONG64_VALUE("VRDEBytesReceived", "Received:", BytesReceived, "Bytes");
    2559             SHOW_LONG64_VALUE("VRDEThroughputReceive", "Speed:", ThroughputReceive, "B/s");
    2560             SHOW_LONG64_VALUE("VRDEBytesReceivedTotal", "Received total:", BytesReceivedTotal, "Bytes");
     2622            SHOW_LONG64_VALUE("VRDEBytesSent", Info::tr("Sent:"), BytesSent, Info::tr("Bytes"));
     2623            SHOW_LONG64_VALUE("VRDEThroughputSend", Info::tr("Average speed:"), ThroughputSend, Info::tr("B/s"));
     2624            SHOW_LONG64_VALUE("VRDEBytesSentTotal", Info::tr("Sent total:"), BytesSentTotal, Info::tr("Bytes"));
     2625
     2626            SHOW_LONG64_VALUE("VRDEBytesReceived", Info::tr("Received:"), BytesReceived, Info::tr("Bytes"));
     2627            SHOW_LONG64_VALUE("VRDEThroughputReceive", Info::tr("Speed:"), ThroughputReceive, Info::tr("B/s"));
     2628            SHOW_LONG64_VALUE("VRDEBytesReceivedTotal", Info::tr("Received total:"), BytesReceivedTotal, Info::tr("Bytes"));
    25612629
    25622630            if (fActive)
    25632631            {
    2564                 SHOW_BSTR_STRING("VRDEUserName", "User name:", User);
    2565                 SHOW_BSTR_STRING("VRDEDomain", "Domain:", Domain);
    2566                 SHOW_BSTR_STRING("VRDEClientName", "Client name:", ClientName);
    2567                 SHOW_BSTR_STRING("VRDEClientIP", "Client IP:", ClientIP);
    2568                 SHOW_ULONG_VALUE("VRDEClientVersion", "Client version:", ClientVersion, "");
    2569                 SHOW_UTF8_STRING("VRDEEncryption", "Encryption:", EncryptionStyle == 0 ? "RDP4" : "RDP5 (X.509)");
     2632                SHOW_BSTR_STRING("VRDEUserName", Info::tr("User name:"), User);
     2633                SHOW_BSTR_STRING("VRDEDomain", Info::tr("Domain:"), Domain);
     2634                SHOW_BSTR_STRING("VRDEClientName", Info::tr("Client name:"), ClientName);
     2635                SHOW_BSTR_STRING("VRDEClientIP", Info::tr("Client IP:"), ClientIP);
     2636                SHOW_ULONG_VALUE("VRDEClientVersion", Info::tr("Client version:"), ClientVersion, "");
     2637                SHOW_UTF8_STRING("VRDEEncryption", Info::tr("Encryption:"), EncryptionStyle == 0 ? "RDP4" : "RDP5 (X.509)");
    25702638            }
    25712639        }
    … …  
    26222690        }
    26232691
    2624         SHOW_BOOL_VALUE_EX("videocap", "Capturing:", fCaptureVideo, "active", "not active");
     2692        SHOW_BOOL_VALUE_EX("videocap", Info::tr("Capturing:"), fCaptureVideo, Info::tr("active"), Info::tr("not active"));
    26252693# ifdef VBOX_WITH_AUDIO_RECORDING
    2626         SHOW_BOOL_VALUE_EX("videocapaudio", "Capture audio:", fCaptureAudio, "active", "not active");
     2694        SHOW_BOOL_VALUE_EX("videocapaudio", Info::tr("Capture audio:"), fCaptureAudio, Info::tr("active"), Info::tr("not active"));
    26272695# endif
    26282696        szValue[0] = '\0';
    … …  
    26342702                off += RTStrPrintf(&szValue[off], sizeof(szValue) - off, off ? ",%zu" : "%zu", i);
    26352703        }
    2636         SHOW_UTF8_STRING("capturescreens", "Capture screens:", szValue);
    2637         SHOW_BSTR_STRING("capturefilename", "Capture file:", bstrFile);
     2704        SHOW_UTF8_STRING("capturescreens", Info::tr("Capture screens:"), szValue);
     2705        SHOW_BSTR_STRING("capturefilename", Info::tr("Capture file:"), bstrFile);
    26382706        RTStrPrintf(szValue, sizeof(szValue), "%ux%u", Width, Height);
    2639         SHOW_UTF8_STRING("captureres", "Capture dimensions:", szValue);
    2640         SHOW_ULONG_VALUE("capturevideorate", "Capture rate:", Rate, "kbps");
    2641         SHOW_ULONG_VALUE("capturevideofps", "Capture FPS:", Fps, "kbps");
    2642         SHOW_BSTR_STRING("captureopts", "Capture options:", bstrOptions);
     2707        SHOW_UTF8_STRING("captureres", Info::tr("Capture dimensions:"), szValue);
     2708        SHOW_ULONG_VALUE("capturevideorate", Info::tr("Capture rate:"), Rate, Info::tr("kbps"));
     2709        SHOW_ULONG_VALUE("capturevideofps", Info::tr("Capture FPS:"), Fps, Info::tr("kbps"));
     2710        SHOW_BSTR_STRING("captureopts", Info::tr("Capture options:"), bstrOptions);
    26432711
    26442712        if (details != VMINFO_MACHINEREADABLE)
    … …  
    26592727                outputMachineReadableString("description", &description);
    26602728            else
    2661                 RTPrintf("Description:\n%ls\n", description.raw());
     2729                RTPrintf(Info::tr("Description:\n%ls\n"), description.raw());
    26622730        }
    26632731    }
    26642732
    26652733    if (details != VMINFO_MACHINEREADABLE)
    2666         RTPrintf("Guest:\n\n");
    2667 
    2668     SHOW_ULONG_PROP(machine, MemoryBalloonSize, "GuestMemoryBalloon", "Configured memory balloon size:", "MB");
     2734        RTPrintf(Info::tr("Guest:\n\n"));
     2735
     2736    SHOW_ULONG_PROP(machine, MemoryBalloonSize, "GuestMemoryBalloon", Info::tr("Configured memory balloon size:"), Info::tr("MB"));
    26692737
    26702738    if (pConsole)
    … …  
    26742742        if (SUCCEEDED(rc) && !guest.isNull())
    26752743        {
    2676             SHOW_STRING_PROP_NOT_EMPTY(guest, OSTypeId, "GuestOSType", "OS type:");
     2744            SHOW_STRING_PROP_NOT_EMPTY(guest, OSTypeId, "GuestOSType", Info::tr("OS type:"));
    26772745
    26782746            AdditionsRunLevelType_T guestRunLevel; /** @todo Add a runlevel-to-string (e.g. 0 = "None") method? */
    26792747            rc = guest->COMGETTER(AdditionsRunLevel)(&guestRunLevel);
    26802748            if (SUCCEEDED(rc))
    2681                 SHOW_ULONG_VALUE("GuestAdditionsRunLevel", "Additions run level:", (ULONG)guestRunLevel, "");
     2749                SHOW_ULONG_VALUE("GuestAdditionsRunLevel", Info::tr("Additions run level:"), (ULONG)guestRunLevel, "");
    26822750
    26832751            Bstr guestString;
    … …  
    26912759                    uRevision = 0;
    26922760                RTStrPrintf(szValue, sizeof(szValue), "%ls r%u", guestString.raw(), uRevision);
    2693                 SHOW_UTF8_STRING("GuestAdditionsVersion", "Additions version:", szValue);
     2761                SHOW_UTF8_STRING("GuestAdditionsVersion", Info::tr("Additions version:"), szValue);
    26942762            }
    26952763
    26962764            if (details != VMINFO_MACHINEREADABLE)
    2697                 RTPrintf("\nGuest Facilities:\n\n");
     2765                RTPrintf(Info::tr("\nGuest Facilities:\n\n"));
    26982766
    26992767            /* Print information about known Guest Additions facilities: */
    … …  
    27192787                        {
    27202788                            makeTimeStr(szLastUpdated, sizeof(szLastUpdated), lLastUpdatedMS);
    2721                             RTPrintf("Facility \"%ls\": %s (last update: %s)\n",
     2789                            RTPrintf(Info::tr("Facility \"%ls\": %s (last update: %s)\n"),
    27222790                                     guestString.raw(), facilityStateToName(curStatus, false /* No short naming */), szLastUpdated);
    27232791                        }
    … …  
    27302798            }
    27312799            if (!collFac.size() && details != VMINFO_MACHINEREADABLE)
    2732                 RTPrintf("No active facilities.\n");
     2800                RTPrintf(Info::tr("No active facilities.\n"));
    27332801        }
    27342802    }
    … …  
    27492817        {
    27502818            if (details != VMINFO_MACHINEREADABLE)
    2751                 RTPrintf("Snapshots:\n\n");
     2819                RTPrintf(Info::tr("Snapshots:\n\n"));
    27522820            showSnapshots(snapshot, currentSnapshot, details);
    27532821        }
    … …  
    28092877                    VMNameOrUuid = ValueUnion.psz;
    28102878                else
    2811                     return errorSyntax(USAGE_SHOWVMINFO, "Invalid parameter '%s'", ValueUnion.psz);
     2879                    return errorSyntax(USAGE_SHOWVMINFO, Info::tr("Invalid parameter '%s'"), ValueUnion.psz);
    28122880                break;
    28132881
    … …  
    28192887    /* check for required options */
    28202888    if (!VMNameOrUuid)
    2821         return errorSyntax(USAGE_SHOWVMINFO, "VM name or UUID required");
     2889        return errorSyntax(USAGE_SHOWVMINFO, Info::tr("VM name or UUID required"));
    28222890
    28232891    /* try to find the given machine */
    … …  
    28302898    /* Printing the log is exclusive. */
    28312899    if (fLog && (fMachinereadable || fDetails))
    2832         return errorSyntax(USAGE_SHOWVMINFO, "Option --log is exclusive");
     2900        return errorSyntax(USAGE_SHOWVMINFO, Info::tr("Option --log is exclusive"));
    28332901
    28342902    if (fLog)

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageList.cpp

    r91416 r92372  
    4444using namespace com;
    4545
     46DECLARE_TRANSLATION_CONTEXT(List);
     47
    4648#ifdef VBOX_WITH_HOSTNETIF_API
    4749static const char *getHostIfMediumTypeText(HostNetworkInterfaceMediumType_T enmType)
    … …  
    5254        case HostNetworkInterfaceMediumType_PPP: return "PPP";
    5355        case HostNetworkInterfaceMediumType_SLIP: return "SLIP";
    54         case HostNetworkInterfaceMediumType_Unknown: return "Unknown";
     56        case HostNetworkInterfaceMediumType_Unknown: return List::tr("Unknown");
    5557#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
    5658        case HostNetworkInterfaceMediumType_32BitHack: break; /* Shut up compiler warnings. */
    5759#endif
    5860    }
    59     return "unknown";
     61    return List::tr("unknown");
    6062}
    6163
    … …  
    6466    switch (enmStatus)
    6567    {
    66         case HostNetworkInterfaceStatus_Up: return "Up";
    67         case HostNetworkInterfaceStatus_Down: return "Down";
    68         case HostNetworkInterfaceStatus_Unknown: return "Unknown";
     68        case HostNetworkInterfaceStatus_Up: return List::tr("Up");
     69        case HostNetworkInterfaceStatus_Down: return List::tr("Down");
     70        case HostNetworkInterfaceStatus_Unknown: return List::tr("Unknown");
    6971#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
    7072        case HostNetworkInterfaceStatus_32BitHack: break; /* Shut up compiler warnings. */
    7173#endif
    7274    }
    73     return "unknown";
     75    return List::tr("unknown");
    7476}
    7577#endif /* VBOX_WITH_HOSTNETIF_API */
    … …  
    7981    switch (enmType)
    8082    {
    81         case DeviceType_HardDisk: return "HardDisk";
     83        case DeviceType_HardDisk: return List::tr("HardDisk");
    8284        case DeviceType_DVD: return "DVD";
    83         case DeviceType_Floppy: return "Floppy";
     85        case DeviceType_Floppy: return List::tr("Floppy");
    8486        /* Make MSC happy */
    8587        case DeviceType_Null: return "Null";
    86         case DeviceType_Network:        return "Network";
     88        case DeviceType_Network:        return List::tr("Network");
    8789        case DeviceType_USB:            return "USB";
    88         case DeviceType_SharedFolder:   return "SharedFolder";
    89         case DeviceType_Graphics3D:     return "Graphics3D";
     90        case DeviceType_SharedFolder:   return List::tr("SharedFolder");
     91        case DeviceType_Graphics3D:     return List::tr("Graphics3D");
    9092#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
    9193        case DeviceType_32BitHack: break; /* Shut up compiler warnings. */
    9294#endif
    9395    }
    94     return "Unknown";
     96    return List::tr("Unknown");
    9597}
    9698
    … …  
    109111    for (size_t i = 0; i < internalNetworks.size(); ++i)
    110112    {
    111         RTPrintf("Name:        %ls\n", internalNetworks[i]);
     113        RTPrintf(List::tr("Name:        %ls\n"), internalNetworks[i]);
    112114    }
    113115    return rc;
    … …  
    147149        Bstr interfaceName;
    148150        networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
    149         RTPrintf("Name:        %ls\n", interfaceName.raw());
     151        RTPrintf(List::tr("Name:        %ls\n"), interfaceName.raw());
    150152        Guid interfaceGuid;
    151153        networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
    … …  
    154156        Bstr interfaceName;
    155157        networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
    156         RTPrintf("Name:            %ls\n", interfaceName.raw());
     158        RTPrintf(List::tr("Name:            %ls\n"), interfaceName.raw());
    157159        Bstr interfaceGuid;
    158160        networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
    … …  
    160162        BOOL fDHCPEnabled = FALSE;
    161163        networkInterface->COMGETTER(DHCPEnabled)(&fDHCPEnabled);
    162         RTPrintf("DHCP:            %s\n", fDHCPEnabled ? "Enabled" : "Disabled");
     164        RTPrintf("DHCP:            %s\n", fDHCPEnabled ? List::tr("Enabled") : List::tr("Disabled"));
    163165
    164166        Bstr IPAddress;
    165167        networkInterface->COMGETTER(IPAddress)(IPAddress.asOutParam());
    166         RTPrintf("IPAddress:       %ls\n", IPAddress.raw());
     168        RTPrintf(List::tr("IPAddress:       %ls\n"), IPAddress.raw());
    167169        Bstr NetworkMask;
    168170        networkInterface->COMGETTER(NetworkMask)(NetworkMask.asOutParam());
    169         RTPrintf("NetworkMask:     %ls\n", NetworkMask.raw());
     171        RTPrintf(List::tr("NetworkMask:     %ls\n"), NetworkMask.raw());
    170172        Bstr IPV6Address;
    171173        networkInterface->COMGETTER(IPV6Address)(IPV6Address.asOutParam());
    172         RTPrintf("IPV6Address:     %ls\n", IPV6Address.raw());
     174        RTPrintf(List::tr("IPV6Address:     %ls\n"), IPV6Address.raw());
    173175        ULONG IPV6NetworkMaskPrefixLength;
    174176        networkInterface->COMGETTER(IPV6NetworkMaskPrefixLength)(&IPV6NetworkMaskPrefixLength);
    175         RTPrintf("IPV6NetworkMaskPrefixLength: %d\n", IPV6NetworkMaskPrefixLength);
     177        RTPrintf(List::tr("IPV6NetworkMaskPrefixLength: %d\n"), IPV6NetworkMaskPrefixLength);
    176178        Bstr HardwareAddress;
    177179        networkInterface->COMGETTER(HardwareAddress)(HardwareAddress.asOutParam());
    178         RTPrintf("HardwareAddress: %ls\n", HardwareAddress.raw());
     180        RTPrintf(List::tr("HardwareAddress: %ls\n"), HardwareAddress.raw());
    179181        HostNetworkInterfaceMediumType_T Type;
    180182        networkInterface->COMGETTER(MediumType)(&Type);
    181         RTPrintf("MediumType:      %s\n", getHostIfMediumTypeText(Type));
     183        RTPrintf(List::tr("MediumType:      %s\n"), getHostIfMediumTypeText(Type));
    182184        BOOL fWireless = FALSE;
    183185        networkInterface->COMGETTER(Wireless)(&fWireless);
    184         RTPrintf("Wireless:        %s\n", fWireless ? "Yes" : "No");
     186        RTPrintf(List::tr("Wireless:        %s\n"), fWireless ? List::tr("Yes") : List::tr("No"));
    185187        HostNetworkInterfaceStatus_T Status;
    186188        networkInterface->COMGETTER(Status)(&Status);
    187         RTPrintf("Status:          %s\n", getHostIfStatusText(Status));
     189        RTPrintf(List::tr("Status:          %s\n"), getHostIfStatusText(Status));
    188190        Bstr netName;
    189191        networkInterface->COMGETTER(NetworkName)(netName.asOutParam());
    190         RTPrintf("VBoxNetworkName: %ls\n\n", netName.raw());
     192        RTPrintf(List::tr("VBoxNetworkName: %ls\n\n"), netName.raw());
    191193#endif
    192194    }
    … …  
    213215        Bstr networkName;
    214216        hostOnlyNetwork->COMGETTER(NetworkName)(networkName.asOutParam());
    215         RTPrintf("Name:            %ls\n", networkName.raw());
     217        RTPrintf(List::tr("Name:            %ls\n"), networkName.raw());
    216218        Bstr networkGuid;
    217219        hostOnlyNetwork->COMGETTER(Id)(networkGuid.asOutParam());
    … …  
    219221        BOOL fEnabled = FALSE;
    220222        hostOnlyNetwork->COMGETTER(Enabled)(&fEnabled);
    221         RTPrintf("State:           %s\n", fEnabled ? "Enabled" : "Disabled");
     223        RTPrintf(List::tr("State:           %s\n"), fEnabled ? List::tr("Enabled") : List::tr("Disabled"));
    222224
    223225        Bstr networkMask;
    224226        hostOnlyNetwork->COMGETTER(NetworkMask)(networkMask.asOutParam());
    225         RTPrintf("NetworkMask:     %ls\n", networkMask.raw());
     227        RTPrintf(List::tr("NetworkMask:     %ls\n"), networkMask.raw());
    226228        Bstr lowerIP;
    227229        hostOnlyNetwork->COMGETTER(LowerIP)(lowerIP.asOutParam());
    228         RTPrintf("LowerIP:         %ls\n", lowerIP.raw());
     230        RTPrintf(List::tr("LowerIP:         %ls\n"), lowerIP.raw());
    229231        Bstr upperIP;
    230232        hostOnlyNetwork->COMGETTER(UpperIP)(upperIP.asOutParam());
    231         RTPrintf("UpperIP:         %ls\n", upperIP.raw());
     233        RTPrintf(List::tr("UpperIP:         %ls\n"), upperIP.raw());
    232234        // Bstr NetworkId;
    233235        // hostOnlyNetwork->COMGETTER(Id)(NetworkId.asOutParam());
    234236        // RTPrintf("NetworkId:       %ls\n", NetworkId.raw());
    235237        Bstr netName = BstrFmt("hostonly-%ls", networkName.raw());
    236         RTPrintf("VBoxNetworkName: %ls\n\n", netName.raw());
     238        RTPrintf(List::tr("VBoxNetworkName: %ls\n\n"), netName.raw());
    237239    }
    238240    return rc;
    … …  
    259261        Bstr networkName;
    260262        cloudNetwork->COMGETTER(NetworkName)(networkName.asOutParam());
    261         RTPrintf("Name:            %ls\n", networkName.raw());
     263        RTPrintf(List::tr("Name:            %ls\n"), networkName.raw());
    262264        // Guid interfaceGuid;
    263265        // cloudNetwork->COMGETTER(Id)(interfaceGuid.asOutParam());
    … …  
    265267        BOOL fEnabled = FALSE;
    266268        cloudNetwork->COMGETTER(Enabled)(&fEnabled);
    267         RTPrintf("State:           %s\n", fEnabled ? "Enabled" : "Disabled");
     269        RTPrintf(List::tr("State:           %s\n"), fEnabled ? List::tr("Enabled") : List::tr("Disabled"));
    268270
    269271        Bstr Provider;
    270272        cloudNetwork->COMGETTER(Provider)(Provider.asOutParam());
    271         RTPrintf("CloudProvider:   %ls\n", Provider.raw());
     273        RTPrintf(List::tr("CloudProvider:   %ls\n"), Provider.raw());
    272274        Bstr Profile;
    273275        cloudNetwork->COMGETTER(Profile)(Profile.asOutParam());
    274         RTPrintf("CloudProfile:    %ls\n", Profile.raw());
     276        RTPrintf(List::tr("CloudProfile:    %ls\n"), Profile.raw());
    275277        Bstr NetworkId;
    276278        cloudNetwork->COMGETTER(NetworkId)(NetworkId.asOutParam());
    277         RTPrintf("CloudNetworkId:  %ls\n", NetworkId.raw());
     279        RTPrintf(List::tr("CloudNetworkId:  %ls\n"), NetworkId.raw());
    278280        Bstr netName = BstrFmt("cloud-%ls", networkName.raw());
    279         RTPrintf("VBoxNetworkName: %ls\n\n", netName.raw());
     281        RTPrintf(List::tr("VBoxNetworkName: %ls\n\n"), netName.raw());
    280282    }
    281283    return rc;
    … …  
    299301    =
    300302    {
    301         { ProcessorFeature_HWVirtEx,     "HW virtualization" },
     303        { ProcessorFeature_HWVirtEx,     List::tr("HW virtualization") },
    302304        { ProcessorFeature_PAE,          "PAE" },
    303         { ProcessorFeature_LongMode,     "long mode" },
    304         { ProcessorFeature_NestedPaging, "nested paging" },
    305         { ProcessorFeature_UnrestrictedGuest, "unrestricted guest" },
    306         { ProcessorFeature_NestedHWVirt, "nested HW virtualization" },
    307         { ProcessorFeature_VirtVmsaveVmload, "virt. vmsave/vmload" },
     305        { ProcessorFeature_LongMode,     List::tr("long mode") },
     306        { ProcessorFeature_NestedPaging, List::tr("nested paging") },
     307        { ProcessorFeature_UnrestrictedGuest, List::tr("unrestricted guest") },
     308        { ProcessorFeature_NestedHWVirt, List::tr("nested HW virtualization") },
     309        { ProcessorFeature_VirtVmsaveVmload, List::tr("virt. vmsave/vmload") },
    308310    };
    309311    HRESULT rc;
    … …  
    311313    CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
    312314
    313     RTPrintf("Host Information:\n\n");
     315    RTPrintf(List::tr("Host Information:\n\n"));
    314316
    315317    LONG64      u64UtcTime = 0;
    … …  
    317319    RTTIMESPEC  timeSpec;
    318320    char        szTime[32];
    319     RTPrintf("Host time: %s\n", RTTimeSpecToString(RTTimeSpecSetMilli(&timeSpec, u64UtcTime), szTime, sizeof(szTime)));
     321    RTPrintf(List::tr("Host time: %s\n"), RTTimeSpecToString(RTTimeSpecSetMilli(&timeSpec, u64UtcTime), szTime, sizeof(szTime)));
    320322
    321323    ULONG processorOnlineCount = 0;
    322324    CHECK_ERROR(Host, COMGETTER(ProcessorOnlineCount)(&processorOnlineCount));
    323     RTPrintf("Processor online count: %lu\n", processorOnlineCount);
     325    RTPrintf(List::tr("Processor online count: %lu\n"), processorOnlineCount);
    324326    ULONG processorCount = 0;
    325327    CHECK_ERROR(Host, COMGETTER(ProcessorCount)(&processorCount));
    326     RTPrintf("Processor count: %lu\n", processorCount);
     328    RTPrintf(List::tr("Processor count: %lu\n"), processorCount);
    327329    ULONG processorOnlineCoreCount = 0;
    328330    CHECK_ERROR(Host, COMGETTER(ProcessorOnlineCoreCount)(&processorOnlineCoreCount));
    329     RTPrintf("Processor online core count: %lu\n", processorOnlineCoreCount);
     331    RTPrintf(List::tr("Processor online core count: %lu\n"), processorOnlineCoreCount);
    330332    ULONG processorCoreCount = 0;
    331333    CHECK_ERROR(Host, COMGETTER(ProcessorCoreCount)(&processorCoreCount));
    332     RTPrintf("Processor core count: %lu\n", processorCoreCount);
     334    RTPrintf(List::tr("Processor core count: %lu\n"), processorCoreCount);
    333335    for (unsigned i = 0; i < RT_ELEMENTS(features); i++)
    334336    {
    335337        BOOL supported;
    336338        CHECK_ERROR(Host, GetProcessorFeature(features[i].feature, &supported));
    337         RTPrintf("Processor supports %s: %s\n", features[i].pszName, supported ? "yes" : "no");
     339        RTPrintf(List::tr("Processor supports %s: %s\n"), features[i].pszName, supported ? List::tr("yes") : List::tr("no"));
    338340    }
    339341    for (ULONG i = 0; i < processorCount; i++)
    … …  
    342344        CHECK_ERROR(Host, GetProcessorSpeed(i, &processorSpeed));
    343345        if (processorSpeed)
    344             RTPrintf("Processor#%u speed: %lu MHz\n", i, processorSpeed);
     346            RTPrintf(List::tr("Processor#%u speed: %lu MHz\n"), i, processorSpeed);
    345347        else
    346             RTPrintf("Processor#%u speed: unknown\n", i);
     348            RTPrintf(List::tr("Processor#%u speed: unknown\n"), i);
    347349        Bstr processorDescription;
    348350        CHECK_ERROR(Host, GetProcessorDescription(i, processorDescription.asOutParam()));
    349         RTPrintf("Processor#%u description: %ls\n", i, processorDescription.raw());
     351        RTPrintf(List::tr("Processor#%u description: %ls\n"), i, processorDescription.raw());
    350352    }
    351353
    352354    ULONG memorySize = 0;
    353355    CHECK_ERROR(Host, COMGETTER(MemorySize)(&memorySize));
    354     RTPrintf("Memory size: %lu MByte\n", memorySize);
     356    RTPrintf(List::tr("Memory size: %lu MByte\n"), memorySize);
    355357
    356358    ULONG memoryAvailable = 0;
    357359    CHECK_ERROR(Host, COMGETTER(MemoryAvailable)(&memoryAvailable));
    358     RTPrintf("Memory available: %lu MByte\n", memoryAvailable);
     360    RTPrintf(List::tr("Memory available: %lu MByte\n"), memoryAvailable);
    359361
    360362    Bstr operatingSystem;
    361363    CHECK_ERROR(Host, COMGETTER(OperatingSystem)(operatingSystem.asOutParam()));
    362     RTPrintf("Operating system: %ls\n", operatingSystem.raw());
     364    RTPrintf(List::tr("Operating system: %ls\n"), operatingSystem.raw());
    363365
    364366    Bstr oSVersion;
    365367    CHECK_ERROR(Host, COMGETTER(OSVersion)(oSVersion.asOutParam()));
    366     RTPrintf("Operating system version: %ls\n", oSVersion.raw());
     368    RTPrintf(List::tr("Operating system version: %ls\n"), oSVersion.raw());
    367369    return rc;
    368370}
    … …  
    422424    CHECK_ERROR(systemProperties, COMGETTER(MediumFormats)(ComSafeArrayAsOutParam(mediumFormats)));
    423425
    424     RTPrintf("Supported hard disk backends:\n\n");
     426    RTPrintf(List::tr("Supported hard disk backends:\n\n"));
    425427    for (size_t i = 0; i < mediumFormats.size(); ++i)
    426428    {
    … …  
    441443
    442444
    443         RTPrintf("Backend %u: id='%ls' description='%ls' capabilities=%#06x extensions='",
     445        RTPrintf(List::tr("Backend %u: id='%ls' description='%ls' capabilities=%#06x extensions='"),
    444446                i, id.raw(), description.raw(), caps);
    445447
    … …  
    470472                                        ComSafeArrayAsOutParam(propertyDefaults)));
    471473
    472         RTPrintf(" properties=(");
     474        RTPrintf(List::tr(" properties=("));
    473475        if (propertyNames.size() > 0)
    474476        {
    475477            for (size_t j = 0; j < propertyNames.size(); ++j)
    476478            {
    477                 RTPrintf("\n  name='%ls' desc='%ls' type=",
     479                RTPrintf(List::tr("\n  name='%ls' desc='%ls' type="),
    478480                        Bstr(propertyNames[j]).raw(), Bstr(propertyDescriptions[j]).raw());
    479481                switch (propertyTypes[j])
    480482                {
    481                     case DataType_Int32: RTPrintf("int"); break;
    482                     case DataType_Int8: RTPrintf("byte"); break;
    483                     case DataType_String: RTPrintf("string"); break;
     483                    case DataType_Int32: RTPrintf(List::tr("int")); break;
     484                    case DataType_Int8: RTPrintf(List::tr("byte")); break;
     485                    case DataType_String: RTPrintf(List::tr("string")); break;
    484486#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
    485487                    case DataType_32BitHack: break; /* Shut up compiler warnings. */
    486488#endif
    487489                }
    488                 RTPrintf(" flags=%#04x", propertyFlags[j]);
    489                 RTPrintf(" default='%ls'", Bstr(propertyDefaults[j]).raw());
     490                RTPrintf(List::tr(" flags=%#04x"), propertyFlags[j]);
     491                RTPrintf(List::tr(" default='%ls'"), Bstr(propertyDefaults[j]).raw());
    490492                if (j != propertyNames.size()-1)
    491493                    RTPrintf(", ");
    … …  
    513515    CHECK_ERROR_RET(Host, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(CollPtr)), 1);
    514516
    515     RTPrintf("Host USB Devices:\n\n");
     517    RTPrintf(List::tr("Host USB Devices:\n\n"));
    516518
    517519    if (CollPtr.size() == 0)
    518520    {
    519         RTPrintf("<none>\n\n");
     521        RTPrintf(List::tr("<none>\n\n"));
    520522    }
    521523    else
    … …  
    541543            CHECK_ERROR_RET(dev, COMGETTER(Speed)(&enmSpeed), 1);
    542544
    543             RTPrintf("UUID:               %s\n"
    544                      "VendorId:           %#06x (%04X)\n"
    545                      "ProductId:          %#06x (%04X)\n"
    546                      "Revision:           %u.%u (%02u%02u)\n"
    547                      "Port:               %u\n",
     545            RTPrintf(List::tr(
     546                       "UUID:               %s\n"
     547                       "VendorId:           %#06x (%04X)\n"
     548                       "ProductId:          %#06x (%04X)\n"
     549                       "Revision:           %u.%u (%02u%02u)\n"
     550                       "Port:               %u\n"),
    548551                     Utf8Str(id).c_str(),
    549552                     usVendorId, usVendorId, usProductId, usProductId,
    … …  
    556559            {
    557560                case USBConnectionSpeed_Low:
    558                     pszSpeed = "Low";
     561                    pszSpeed = List::tr("Low");
    559562                    break;
    560563                case USBConnectionSpeed_Full:
    561                     pszSpeed = "Full";
     564                    pszSpeed = List::tr("Full");
    562565                    break;
    563566                case USBConnectionSpeed_High:
    564                     pszSpeed = "High";
     567                    pszSpeed = List::tr("High");
    565568                    break;
    566569                case USBConnectionSpeed_Super:
    567                     pszSpeed = "Super";
     570                    pszSpeed = List::tr("Super");
    568571                    break;
    569572                case USBConnectionSpeed_SuperPlus:
    570                     pszSpeed = "SuperPlus";
     573                    pszSpeed = List::tr("SuperPlus");
    571574                    break;
    572575                default:
    … …  
    575578            }
    576579
    577             RTPrintf("USB version/speed:  %u/%s\n", usVersion, pszSpeed);
     580            RTPrintf(List::tr("USB version/speed:  %u/%s\n"), usVersion, pszSpeed);
    578581
    579582            /* optional stuff. */
    … …  
    584587                bstr = Bstr(CollDevInfo[0]);
    585588            if (!bstr.isEmpty())
    586                 RTPrintf("Manufacturer:       %ls\n", bstr.raw());
     589                RTPrintf(List::tr("Manufacturer:       %ls\n"), bstr.raw());
    587590            if (CollDevInfo.size() >= 2)
    588591                bstr = Bstr(CollDevInfo[1]);
    589592            if (!bstr.isEmpty())
    590                 RTPrintf("Product:            %ls\n", bstr.raw());
     593                RTPrintf(List::tr("Product:            %ls\n"), bstr.raw());
    591594            CHECK_ERROR_RET(dev, COMGETTER(SerialNumber)(bstr.asOutParam()), 1);
    592595            if (!bstr.isEmpty())
    593                 RTPrintf("SerialNumber:       %ls\n", bstr.raw());
     596                RTPrintf(List::tr("SerialNumber:       %ls\n"), bstr.raw());
    594597            CHECK_ERROR_RET(dev, COMGETTER(Address)(bstr.asOutParam()), 1);
    595598            if (!bstr.isEmpty())
    596                 RTPrintf("Address:            %ls\n", bstr.raw());
     599                RTPrintf(List::tr("Address:            %ls\n"), bstr.raw());
    597600            CHECK_ERROR_RET(dev, COMGETTER(PortPath)(bstr.asOutParam()), 1);
    598601            if (!bstr.isEmpty())
    599                 RTPrintf("Port path:          %ls\n", bstr.raw());
     602                RTPrintf(List::tr("Port path:          %ls\n"), bstr.raw());
    600603
    601604            /* current state  */
    … …  
    606609            {
    607610                case USBDeviceState_NotSupported:
    608                     pszState = "Not supported";
     611                    pszState = List::tr("Not supported");
    609612                    break;
    610613                case USBDeviceState_Unavailable:
    611                     pszState = "Unavailable";
     614                    pszState = List::tr("Unavailable");
    612615                    break;
    613616                case USBDeviceState_Busy:
    614                     pszState = "Busy";
     617                    pszState = List::tr("Busy");
    615618                    break;
    616619                case USBDeviceState_Available:
    617                     pszState = "Available";
     620                    pszState = List::tr("Available");
    618621                    break;
    619622                case USBDeviceState_Held:
    620                     pszState = "Held";
     623                    pszState = List::tr("Held");
    621624                    break;
    622625                case USBDeviceState_Captured:
    623                     pszState = "Captured";
     626                    pszState = List::tr("Captured");
    624627                    break;
    625628                default:
    … …  
    627630                    break;
    628631            }
    629             RTPrintf("Current State:      %s\n\n", pszState);
     632            RTPrintf(List::tr("Current State:      %s\n\n"), pszState);
    630633        }
    631634    }
    … …  
    644647    HRESULT rc;
    645648
    646     RTPrintf("Global USB Device Filters:\n\n");
     649    RTPrintf(List::tr("Global USB Device Filters:\n\n"));
    647650
    648651    ComPtr<IHost> host;
    … …  
    654657    if (coll.size() == 0)
    655658    {
    656         RTPrintf("<none>\n\n");
     659        RTPrintf(List::tr("<none>\n\n"));
    657660    }
    658661    else
    … …  
    664667            /* Query info. */
    665668
    666             RTPrintf("Index:            %zu\n", index);
     669            RTPrintf(List::tr("Index:            %zu\n"), index);
    667670
    668671            BOOL active = FALSE;
    669672            CHECK_ERROR_RET(flt, COMGETTER(Active)(&active), 1);
    670             RTPrintf("Active:           %s\n", active ? "yes" : "no");
     673            RTPrintf(List::tr("Active:           %s\n"), active ? List::tr("yes") : List::tr("no"));
    671674
    672675            USBDeviceFilterAction_T action;
    673676            CHECK_ERROR_RET(flt, COMGETTER(Action)(&action), 1);
    674             const char *pszAction = "<invalid>";
     677            const char *pszAction = List::tr("<invalid>");
    675678            switch (action)
    676679            {
    677680                case USBDeviceFilterAction_Ignore:
    678                     pszAction = "Ignore";
     681                    pszAction = List::tr("Ignore");
    679682                    break;
    680683                case USBDeviceFilterAction_Hold:
    681                     pszAction = "Hold";
     684                    pszAction = List::tr("Hold");
    682685                    break;
    683686                default:
    684687                    break;
    685688            }
    686             RTPrintf("Action:           %s\n", pszAction);
     689            RTPrintf(List::tr("Action:           %s\n"), pszAction);
    687690
    688691            Bstr bstr;
    689692            CHECK_ERROR_RET(flt, COMGETTER(Name)(bstr.asOutParam()), 1);
    690             RTPrintf("Name:             %ls\n", bstr.raw());
     693            RTPrintf(List::tr("Name:             %ls\n"), bstr.raw());
    691694            CHECK_ERROR_RET(flt, COMGETTER(VendorId)(bstr.asOutParam()), 1);
    692             RTPrintf("VendorId:         %ls\n", bstr.raw());
     695            RTPrintf(List::tr("VendorId:         %ls\n"), bstr.raw());
    693696            CHECK_ERROR_RET(flt, COMGETTER(ProductId)(bstr.asOutParam()), 1);
    694             RTPrintf("ProductId:        %ls\n", bstr.raw());
     697            RTPrintf(List::tr("ProductId:        %ls\n"), bstr.raw());
    695698            CHECK_ERROR_RET(flt, COMGETTER(Revision)(bstr.asOutParam()), 1);
    696             RTPrintf("Revision:         %ls\n", bstr.raw());
     699            RTPrintf(List::tr("Revision:         %ls\n"), bstr.raw());
    697700            CHECK_ERROR_RET(flt, COMGETTER(Manufacturer)(bstr.asOutParam()), 1);
    698             RTPrintf("Manufacturer:     %ls\n", bstr.raw());
     701            RTPrintf(List::tr("Manufacturer:     %ls\n"), bstr.raw());
    699702            CHECK_ERROR_RET(flt, COMGETTER(Product)(bstr.asOutParam()), 1);
    700             RTPrintf("Product:          %ls\n", bstr.raw());
     703            RTPrintf(List::tr("Product:          %ls\n"), bstr.raw());
    701704            CHECK_ERROR_RET(flt, COMGETTER(SerialNumber)(bstr.asOutParam()), 1);
    702             RTPrintf("Serial Number:    %ls\n\n", bstr.raw());
     705            RTPrintf(List::tr("Serial Number:    %ls\n\n"), bstr.raw());
    703706        }
    704707    }
    … …  
    725728
    726729    pVirtualBox->COMGETTER(APIVersion)(str.asOutParam());
    727     RTPrintf("API version:                     %ls\n", str.raw());
     730    RTPrintf(List::tr("API version:                     %ls\n"), str.raw());
    728731
    729732    systemProperties->COMGETTER(MinGuestRAM)(&ulValue);
    730     RTPrintf("Minimum guest RAM size:          %u Megabytes\n", ulValue);
     733    RTPrintf(List::tr("Minimum guest RAM size:          %u Megabytes\n"), ulValue);
    731734    systemProperties->COMGETTER(MaxGuestRAM)(&ulValue);
    732     RTPrintf("Maximum guest RAM size:          %u Megabytes\n", ulValue);
     735    RTPrintf(List::tr("Maximum guest RAM size:          %u Megabytes\n"), ulValue);
    733736    systemProperties->COMGETTER(MinGuestVRAM)(&ulValue);
    734     RTPrintf("Minimum video RAM size:          %u Megabytes\n", ulValue);
     737    RTPrintf(List::tr("Minimum video RAM size:          %u Megabytes\n"), ulValue);
    735738    systemProperties->COMGETTER(MaxGuestVRAM)(&ulValue);
    736     RTPrintf("Maximum video RAM size:          %u Megabytes\n", ulValue);
     739    RTPrintf(List::tr("Maximum video RAM size:          %u Megabytes\n"), ulValue);
    737740    systemProperties->COMGETTER(MaxGuestMonitors)(&ulValue);
    738     RTPrintf("Maximum guest monitor count:     %u\n", ulValue);
     741    RTPrintf(List::tr("Maximum guest monitor count:     %u\n"), ulValue);
    739742    systemProperties->COMGETTER(MinGuestCPUCount)(&ulValue);
    740     RTPrintf("Minimum guest CPU count:         %u\n", ulValue);
     743    RTPrintf(List::tr("Minimum guest CPU count:         %u\n"), ulValue);
    741744    systemProperties->COMGETTER(MaxGuestCPUCount)(&ulValue);
    742     RTPrintf("Maximum guest CPU count:         %u\n", ulValue);
     745    RTPrintf(List::tr("Maximum guest CPU count:         %u\n"), ulValue);
    743746    systemProperties->COMGETTER(InfoVDSize)(&i64Value);
    744     RTPrintf("Virtual disk limit (info):       %lld Bytes\n", i64Value);
     747    RTPrintf(List::tr("Virtual disk limit (info):       %lld Bytes\n"), i64Value);
    745748    systemProperties->COMGETTER(SerialPortCount)(&ulValue);
    746     RTPrintf("Maximum Serial Port count:       %u\n", ulValue);
     749    RTPrintf(List::tr("Maximum Serial Port count:       %u\n"), ulValue);
    747750    systemProperties->COMGETTER(ParallelPortCount)(&ulValue);
    748     RTPrintf("Maximum Parallel Port count:     %u\n", ulValue);
     751    RTPrintf(List::tr("Maximum Parallel Port count:     %u\n"), ulValue);
    749752    systemProperties->COMGETTER(MaxBootPosition)(&ulValue);
    750     RTPrintf("Maximum Boot Position:           %u\n", ulValue);
     753    RTPrintf(List::tr("Maximum Boot Position:           %u\n"), ulValue);
    751754    systemProperties->GetMaxNetworkAdapters(ChipsetType_PIIX3, &ulValue);
    752     RTPrintf("Maximum PIIX3 Network Adapter count:   %u\n", ulValue);
     755    RTPrintf(List::tr("Maximum PIIX3 Network Adapter count:   %u\n"), ulValue);
    753756    systemProperties->GetMaxNetworkAdapters(ChipsetType_ICH9,  &ulValue);
    754     RTPrintf("Maximum ICH9 Network Adapter count:   %u\n", ulValue);
     757    RTPrintf(List::tr("Maximum ICH9 Network Adapter count:   %u\n"), ulValue);
    755758    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_IDE, &ulValue);
    756     RTPrintf("Maximum PIIX3 IDE Controllers:   %u\n", ulValue);
     759    RTPrintf(List::tr("Maximum PIIX3 IDE Controllers:   %u\n"), ulValue);
    757760    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_IDE, &ulValue);
    758     RTPrintf("Maximum ICH9 IDE Controllers:    %u\n", ulValue);
     761    RTPrintf(List::tr("Maximum ICH9 IDE Controllers:    %u\n"), ulValue);
    759762    systemProperties->GetMaxPortCountForStorageBus(StorageBus_IDE, &ulValue);
    760     RTPrintf("Maximum IDE Port count:          %u\n", ulValue);
     763    RTPrintf(List::tr("Maximum IDE Port count:          %u\n"), ulValue);
    761764    systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_IDE, &ulValue);
    762     RTPrintf("Maximum Devices per IDE Port:    %u\n", ulValue);
     765    RTPrintf(List::tr("Maximum Devices per IDE Port:    %u\n"), ulValue);
    763766    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SATA, &ulValue);
    764     RTPrintf("Maximum PIIX3 SATA Controllers:  %u\n", ulValue);
     767    RTPrintf(List::tr("Maximum PIIX3 SATA Controllers:  %u\n"), ulValue);
    765768    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SATA, &ulValue);
    766     RTPrintf("Maximum ICH9 SATA Controllers:   %u\n", ulValue);
     769    RTPrintf(List::tr("Maximum ICH9 SATA Controllers:   %u\n"), ulValue);
    767770    systemProperties->GetMaxPortCountForStorageBus(StorageBus_SATA, &ulValue);
    768     RTPrintf("Maximum SATA Port count:         %u\n", ulValue);
     771    RTPrintf(List::tr("Maximum SATA Port count:         %u\n"), ulValue);
    769772    systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SATA, &ulValue);
    770     RTPrintf("Maximum Devices per SATA Port:   %u\n", ulValue);
     773    RTPrintf(List::tr("Maximum Devices per SATA Port:   %u\n"), ulValue);
    771774    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SCSI, &ulValue);
    772     RTPrintf("Maximum PIIX3 SCSI Controllers:  %u\n", ulValue);
     775    RTPrintf(List::tr("Maximum PIIX3 SCSI Controllers:  %u\n"), ulValue);
    773776    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SCSI, &ulValue);
    774     RTPrintf("Maximum ICH9 SCSI Controllers:   %u\n", ulValue);
     777    RTPrintf(List::tr("Maximum ICH9 SCSI Controllers:   %u\n"), ulValue);
    775778    systemProperties->GetMaxPortCountForStorageBus(StorageBus_SCSI, &ulValue);
    776     RTPrintf("Maximum SCSI Port count:         %u\n", ulValue);
     779    RTPrintf(List::tr("Maximum SCSI Port count:         %u\n"), ulValue);
    777780    systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SCSI, &ulValue);
    778     RTPrintf("Maximum Devices per SCSI Port:   %u\n", ulValue);
     781    RTPrintf(List::tr("Maximum Devices per SCSI Port:   %u\n"), ulValue);
    779782    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SAS, &ulValue);
    780     RTPrintf("Maximum SAS PIIX3 Controllers:   %u\n", ulValue);
     783    RTPrintf(List::tr("Maximum SAS PIIX3 Controllers:   %u\n"), ulValue);
    781784    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SAS, &ulValue);
    782     RTPrintf("Maximum SAS ICH9 Controllers:    %u\n", ulValue);
     785    RTPrintf(List::tr("Maximum SAS ICH9 Controllers:    %u\n"), ulValue);
    783786    systemProperties->GetMaxPortCountForStorageBus(StorageBus_SAS, &ulValue);
    784     RTPrintf("Maximum SAS Port count:          %u\n", ulValue);
     787    RTPrintf(List::tr("Maximum SAS Port count:          %u\n"), ulValue);
    785788    systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SAS, &ulValue);
    786     RTPrintf("Maximum Devices per SAS Port:    %u\n", ulValue);
     789    RTPrintf(List::tr("Maximum Devices per SAS Port:    %u\n"), ulValue);
    787790    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_PCIe, &ulValue);
    788     RTPrintf("Maximum NVMe PIIX3 Controllers:  %u\n", ulValue);
     791    RTPrintf(List::tr("Maximum NVMe PIIX3 Controllers:  %u\n"), ulValue);
    789792    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_PCIe, &ulValue);
    790     RTPrintf("Maximum NVMe ICH9 Controllers:   %u\n", ulValue);
     793    RTPrintf(List::tr("Maximum NVMe ICH9 Controllers:   %u\n"), ulValue);
    791794    systemProperties->GetMaxPortCountForStorageBus(StorageBus_PCIe, &ulValue);
    792     RTPrintf("Maximum NVMe Port count:         %u\n", ulValue);
     795    RTPrintf(List::tr("Maximum NVMe Port count:         %u\n"), ulValue);
    793796    systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_PCIe, &ulValue);
    794     RTPrintf("Maximum Devices per NVMe Port:   %u\n", ulValue);
     797    RTPrintf(List::tr("Maximum Devices per NVMe Port:   %u\n"), ulValue);
    795798    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_VirtioSCSI, &ulValue);
    796     RTPrintf("Maximum virtio-scsi PIIX3 Controllers:  %u\n", ulValue);
     799    RTPrintf(List::tr("Maximum virtio-scsi PIIX3 Controllers:  %u\n"), ulValue);
    797800    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_VirtioSCSI, &ulValue);
    798     RTPrintf("Maximum virtio-scsi ICH9 Controllers:   %u\n", ulValue);
     801    RTPrintf(List::tr("Maximum virtio-scsi ICH9 Controllers:   %u\n"), ulValue);
    799802    systemProperties->GetMaxPortCountForStorageBus(StorageBus_VirtioSCSI, &ulValue);
    800     RTPrintf("Maximum virtio-scsi Port count:         %u\n", ulValue);
     803    RTPrintf(List::tr("Maximum virtio-scsi Port count:         %u\n"), ulValue);
    801804    systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_VirtioSCSI, &ulValue);
    802     RTPrintf("Maximum Devices per virtio-scsi Port:   %u\n", ulValue);
     805    RTPrintf(List::tr("Maximum Devices per virtio-scsi Port:   %u\n"), ulValue);
    803806    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_Floppy, &ulValue);
    804     RTPrintf("Maximum PIIX3 Floppy Controllers:%u\n", ulValue);
     807    RTPrintf(List::tr("Maximum PIIX3 Floppy Controllers:%u\n"), ulValue);
    805808    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_Floppy, &ulValue);
    806     RTPrintf("Maximum ICH9 Floppy Controllers: %u\n", ulValue);
     809    RTPrintf(List::tr("Maximum ICH9 Floppy Controllers: %u\n"), ulValue);
    807810    systemProperties->GetMaxPortCountForStorageBus(StorageBus_Floppy, &ulValue);
    808     RTPrintf("Maximum Floppy Port count:       %u\n", ulValue);
     811    RTPrintf(List::tr("Maximum Floppy Port count:       %u\n"), ulValue);
    809812    systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_Floppy, &ulValue);
    810     RTPrintf("Maximum Devices per Floppy Port: %u\n", ulValue);
     813    RTPrintf(List::tr("Maximum Devices per Floppy Port: %u\n"), ulValue);
    811814#if 0
    812815    systemProperties->GetFreeDiskSpaceWarning(&i64Value);
    813     RTPrintf("Free disk space warning at:      %u Bytes\n", i64Value);
     816    RTPrintf(List::tr("Free disk space warning at:      %u Bytes\n"), i64Value);
    814817    systemProperties->GetFreeDiskSpacePercentWarning(&ulValue);
    815     RTPrintf("Free disk space warning at:      %u %%\n", ulValue);
     818    RTPrintf(List::tr("Free disk space warning at:      %u %%\n"), ulValue);
    816819    systemProperties->GetFreeDiskSpaceError(&i64Value);
    817     RTPrintf("Free disk space error at:        %u Bytes\n", i64Value);
     820    RTPrintf(List::tr("Free disk space error at:        %u Bytes\n"), i64Value);
    818821    systemProperties->GetFreeDiskSpacePercentError(&ulValue);
    819     RTPrintf("Free disk space error at:        %u %%\n", ulValue);
     822    RTPrintf(List::tr("Free disk space error at:        %u %%\n"), ulValue);
    820823#endif
    821824    systemProperties->COMGETTER(DefaultMachineFolder)(str.asOutParam());
    822     RTPrintf("Default machine folder:          %ls\n", str.raw());
     825    RTPrintf(List::tr("Default machine folder:          %ls\n"), str.raw());
    823826    systemProperties->COMGETTER(RawModeSupported)(&fValue);
    824     RTPrintf("Raw-mode Supported:              %s\n", fValue ? "yes" : "no");
     827    RTPrintf(List::tr("Raw-mode Supported:              %s\n"), fValue ? List::tr("yes") : List::tr("no"));
    825828    systemProperties->COMGETTER(ExclusiveHwVirt)(&fValue);
    826     RTPrintf("Exclusive HW virtualization use: %s\n", fValue ? "on" : "off");
     829    RTPrintf(List::tr("Exclusive HW virtualization use: %s\n"), fValue ? List::tr("on") : List::tr("off"));
    827830    systemProperties->COMGETTER(DefaultHardDiskFormat)(str.asOutParam());
    828     RTPrintf("Default hard disk format:        %ls\n", str.raw());
     831    RTPrintf(List::tr("Default hard disk format:        %ls\n"), str.raw());
    829832    systemProperties->COMGETTER(VRDEAuthLibrary)(str.asOutParam());
    830     RTPrintf("VRDE auth library:               %ls\n", str.raw());
     833    RTPrintf(List::tr("VRDE auth library:               %ls\n"), str.raw());
    831834    systemProperties->COMGETTER(WebServiceAuthLibrary)(str.asOutParam());
    832     RTPrintf("Webservice auth. library:        %ls\n", str.raw());
     835    RTPrintf(List::tr("Webservice auth. library:        %ls\n"), str.raw());
    833836    systemProperties->COMGETTER(DefaultVRDEExtPack)(str.asOutParam());
    834     RTPrintf("Remote desktop ExtPack:          %ls\n", str.raw());
     837    RTPrintf(List::tr("Remote desktop ExtPack:          %ls\n"), str.raw());
    835838    systemProperties->COMGETTER(LogHistoryCount)(&ulValue);
    836     RTPrintf("Log history count:               %u\n", ulValue);
     839    RTPrintf(List::tr("Log history count:               %u\n"), ulValue);
    837840    systemProperties->COMGETTER(DefaultFrontend)(str.asOutParam());
    838     RTPrintf("Default frontend:                %ls\n", str.raw());
     841    RTPrintf(List::tr("Default frontend:                %ls\n"), str.raw());
    839842    AudioDriverType_T enmAudio;
    840843    systemProperties->COMGETTER(DefaultAudioDriver)(&enmAudio);
    841844    switch (enmAudio)
    842845    {
    843         case AudioDriverType_Null:          psz = "Null";          break;
     846        case AudioDriverType_Null:          psz = List::tr("Null"); break;
    844847        case AudioDriverType_WinMM:         psz = "WinMM";          break;
    845848        case AudioDriverType_OSS:           psz = "OSS";            break;
    … …  
    850853        case AudioDriverType_Pulse:         psz = "Pulse";          break;
    851854        case AudioDriverType_SolAudio:      psz = "SolAudio";       break;
    852         default:                            psz = "Unknown";
    853     }
    854     RTPrintf("Default audio driver:            %s\n", psz);
     855        default:                            psz = List::tr("Unknown");
     856    }
     857    RTPrintf(List::tr("Default audio driver:            %s\n"), psz);
    855858    systemProperties->COMGETTER(AutostartDatabasePath)(str.asOutParam());
    856     RTPrintf("Autostart database path:         %ls\n", str.raw());
     859    RTPrintf(List::tr("Autostart database path:         %ls\n"), str.raw());
    857860    systemProperties->COMGETTER(DefaultAdditionsISO)(str.asOutParam());
    858     RTPrintf("Default Guest Additions ISO:     %ls\n", str.raw());
     861    RTPrintf(List::tr("Default Guest Additions ISO:     %ls\n"), str.raw());
    859862    systemProperties->COMGETTER(LoggingLevel)(str.asOutParam());
    860     RTPrintf("Logging Level:                   %ls\n", str.raw());
     863    RTPrintf(List::tr("Logging Level:                   %ls\n"), str.raw());
    861864    ProxyMode_T enmProxyMode = (ProxyMode_T)42;
    862865    systemProperties->COMGETTER(ProxyMode)(&enmProxyMode);
    863     psz = "Unknown";
     866    psz = List::tr("Unknown");
    864867    switch (enmProxyMode)
    865868    {
    866         case ProxyMode_System:              psz = "System"; break;
    867         case ProxyMode_NoProxy:             psz = "NoProxy"; break;
    868         case ProxyMode_Manual:              psz = "Manual"; break;
     869        case ProxyMode_System:              psz = List::tr("System"); break;
     870        case ProxyMode_NoProxy:             psz = List::tr("NoProxy"); break;
     871        case ProxyMode_Manual:              psz = List::tr("Manual"); break;
    869872#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
    870873        case ProxyMode_32BitHack:           break; /* Shut up compiler warnings. */
    871874#endif
    872875    }
    873     RTPrintf("Proxy Mode:                      %s\n", psz);
     876    RTPrintf(List::tr("Proxy Mode:                      %s\n"), psz);
    874877    systemProperties->COMGETTER(ProxyURL)(str.asOutParam());
    875     RTPrintf("Proxy URL:                       %ls\n", str.raw());
     878    RTPrintf(List::tr("Proxy URL:                       %ls\n"), str.raw());
    876879    systemProperties->COMGETTER(VBoxUpdateEnabled)(&fValue);
    877     RTPrintf("Update check enabled:            %s\n", fValue ? "yes" : "no");
     880    RTPrintf(List::tr("Update check enabled:            %s\n"), fValue ? List::tr("yes") : List::tr("no"));
    878881    systemProperties->COMGETTER(VBoxUpdateCount)(&ulValue);
    879     RTPrintf("Update check count:              %u\n", ulValue);
     882    RTPrintf(List::tr("Update check count:              %u\n"), ulValue);
    880883    systemProperties->COMGETTER(VBoxUpdateFrequency)(&ulValue);
    881884    if (ulValue == 0)
    882         RTPrintf("Update check frequency:          never\n");
     885        RTPrintf(List::tr("Update check frequency:          never\n"));
    883886    else if (ulValue == 1)
    884         RTPrintf("Update check frequency:          every day\n");
     887        RTPrintf(List::tr("Update check frequency:          every day\n"));
    885888    else
    886         RTPrintf("Update check frequency:          every %u days\n", ulValue);
     889        RTPrintf(List::tr("Update check frequency:          every %u days\n"), ulValue);
    887890    VBoxUpdateTarget_T enmVBoxUpdateTarget;
    888891    systemProperties->COMGETTER(VBoxUpdateTarget)(&enmVBoxUpdateTarget);
    … …  
    890893    {
    891894        case VBoxUpdateTarget_Stable:
    892             psz = "Stable: new minor and maintenance releases";
     895            psz = List::tr("Stable: new minor and maintenance releases");
    893896            break;
    894897        case VBoxUpdateTarget_AllReleases:
    895             psz = "All releases: new minor, maintenance, and major releases";
     898            psz = List::tr("All releases: new minor, maintenance, and major releases");
    896899            break;
    897900        case VBoxUpdateTarget_WithBetas:
    898             psz = "With Betas: new minor, maintenance, major, and beta releases";
     901            psz = List::tr("With Betas: new minor, maintenance, major, and beta releases");
    899902            break;
    900903        default:
    901             psz = "Unset";
    902             break;
    903     }
    904     RTPrintf("Update check target:             %s\n", psz);
     904            psz = List::tr("Unset");
     905            break;
     906    }
     907    RTPrintf(List::tr("Update check target:             %s\n"), psz);
    905908    systemProperties->COMGETTER(VBoxUpdateLastCheckDate)(str.asOutParam());
    906     RTPrintf("Last check date:                 %ls\n", str.raw());
     909    RTPrintf(List::tr("Last check date:                 %ls\n"), str.raw());
    907910#ifdef VBOX_WITH_MAIN_NLS
    908911    systemProperties->COMGETTER(LanguageId)(str.asOutParam());
    909     RTPrintf("User language:                   %ls\n", str.raw());
     912    RTPrintf(List::tr("User language:                   %ls\n"), str.raw());
    910913#endif
    911914    return S_OK;
    … …  
    923926    CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(MinLeaseTime)(&secs), hrcRet = hrcCheck);
    924927    if (secs == 0)
    925         RTPrintf("    minLeaseTime:     default\n");
     928        RTPrintf(List::tr("    minLeaseTime:     default\n"));
    926929    else
    927         RTPrintf("    minLeaseTime:     %u sec\n", secs);
     930        RTPrintf(List::tr("    minLeaseTime:     %u sec\n"), secs);
    928931
    929932    secs = 0;
    930933    CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(DefaultLeaseTime)(&secs), hrcRet = hrcCheck);
    931934    if (secs == 0)
    932         RTPrintf("    defaultLeaseTime: default\n");
     935        RTPrintf(List::tr("    defaultLeaseTime: default\n"));
    933936    else
    934         RTPrintf("    defaultLeaseTime: %u sec\n", secs);
     937        RTPrintf(List::tr("    defaultLeaseTime: %u sec\n"), secs);
    935938
    936939    secs = 0;
    937940    CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(MaxLeaseTime)(&secs), hrcRet = hrcCheck);
    938941    if (secs == 0)
    939         RTPrintf("    maxLeaseTime:     default\n");
     942        RTPrintf(List::tr("    maxLeaseTime:     default\n"));
    940943    else
    941         RTPrintf("    maxLeaseTime:     %u sec\n", secs);
     944        RTPrintf(List::tr("    maxLeaseTime:     %u sec\n"), secs);
    942945
    943946    com::SafeArray<DHCPOption_T>         Options;
    … …  
    945948    CHECK_ERROR2_STMT(hrc, ptrConfig, COMGETTER(ForcedOptions(ComSafeArrayAsOutParam(Options))), hrcRet = hrc);
    946949    if (FAILED(hrc))
    947         RTPrintf("    Forced options:   %Rhrc\n", hrc);
     950        RTPrintf(List::tr("    Forced options:   %Rhrc\n"), hrc);
    948951    else if (Options.size() == 0)
    949         RTPrintf("    Forced options:   None\n");
     952        RTPrintf(List::tr("    Forced options:   None\n"));
    950953    else
    951954    {
    952         RTPrintf("    Forced options:   ");
     955        RTPrintf(List::tr("    Forced options:   "));
    953956        for (size_t i = 0; i < Options.size(); i++)
    954957            RTPrintf(i ? ", %u" : "%u", Options[i]);
    … …  
    958961    CHECK_ERROR2_STMT(hrc, ptrConfig, COMGETTER(SuppressedOptions(ComSafeArrayAsOutParam(Options))), hrcRet = hrc);
    959962    if (FAILED(hrc))
    960         RTPrintf("    Suppressed opt.s: %Rhrc\n", hrc);
     963        RTPrintf(List::tr("    Suppressed opt.s: %Rhrc\n"), hrc);
    961964    else if (Options.size() == 0)
    962         RTPrintf("    Suppressed opts.: None\n");
     965        RTPrintf(List::tr("    Suppressed opts.: None\n"));
    963966    else
    964967    {
    965         RTPrintf("    Suppressed opts.: ");
     968        RTPrintf(List::tr("    Suppressed opts.: "));
    966969        for (size_t i = 0; i < Options.size(); i++)
    967970            RTPrintf(i ? ", %u" : "%u", Options[i]);
    … …  
    975978                                                    ComSafeArrayAsOutParam(Values)), hrcRet = hrc);
    976979    if (FAILED(hrc))
    977         RTPrintf("    DHCP options:     %Rhrc\n", hrc);
     980        RTPrintf(List::tr("    DHCP options:     %Rhrc\n"), hrc);
    978981    else if (Options.size() != Encodings.size() || Options.size() != Values.size())
    979982    {
    980         RTPrintf("    DHCP options:     Return count mismatch: %zu, %zu, %zu\n", Options.size(), Encodings.size(), Values.size());
     983        RTPrintf(List::tr("    DHCP options:     Return count mismatch: %zu, %zu, %zu\n"),
     984                 Options.size(), Encodings.size(), Values.size());
    981985        hrcRet = E_FAIL;
    982986    }
    983987    else if (Options.size() == 0)
    984         RTPrintf("    DHCP options:     None\n");
     988        RTPrintf(List::tr("    DHCP options:     None\n"));
    985989    else
    986990        for (size_t i = 0; i < Options.size(); i++)
    … …  
    989993            {
    990994                case DHCPOptionEncoding_Normal:
    991                     RTPrintf("      %3d/legacy: %ls\n", Options[i], Values[i]);
     995                    RTPrintf(List::tr("      %3d/legacy: %ls\n"), Options[i], Values[i]);
    992996                    break;
    993997                case DHCPOptionEncoding_Hex:
    994                     RTPrintf("      %3d/hex:    %ls\n", Options[i], Values[i]);
     998                    RTPrintf(List::tr("      %3d/hex:    %ls\n"), Options[i], Values[i]);
    995999                    break;
    9961000                default:
    997                     RTPrintf("      %3d/%u?: %ls\n", Options[i], Encodings[i], Values[i]);
     1001                    RTPrintf(List::tr("      %3d/%u?: %ls\n"), Options[i], Encodings[i], Values[i]);
    9981002                    break;
    9991003            }
    … …  
    10231027        Bstr bstr;
    10241028        CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(NetworkName)(bstr.asOutParam()), hrcRet = hrcCheck);
    1025         RTPrintf("NetworkName:    %ls\n", bstr.raw());
     1029        RTPrintf(List::tr("NetworkName:    %ls\n"), bstr.raw());
    10261030
    10271031        CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(IPAddress)(bstr.asOutParam()), hrcRet = hrcCheck);
    1028         RTPrintf("Dhcpd IP:       %ls\n", bstr.raw());
     1032        RTPrintf(List::tr("Dhcpd IP:       %ls\n"), bstr.raw());
    10291033
    10301034        CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(LowerIP)(bstr.asOutParam()), hrcRet = hrcCheck);
    1031         RTPrintf("LowerIPAddress: %ls\n", bstr.raw());
     1035        RTPrintf(List::tr("LowerIPAddress: %ls\n"), bstr.raw());
    10321036
    10331037        CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(UpperIP)(bstr.asOutParam()), hrcRet = hrcCheck);
    1034         RTPrintf("UpperIPAddress: %ls\n", bstr.raw());
     1038        RTPrintf(List::tr("UpperIPAddress: %ls\n"), bstr.raw());
    10351039
    10361040        CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(NetworkMask)(bstr.asOutParam()), hrcRet = hrcCheck);
    1037         RTPrintf("NetworkMask:    %ls\n", bstr.raw());
     1041        RTPrintf(List::tr("NetworkMask:    %ls\n"), bstr.raw());
    10381042
    10391043        BOOL fEnabled = FALSE;
    10401044        CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(Enabled)(&fEnabled), hrcRet = hrcCheck);
    1041         RTPrintf("Enabled:        %s\n", fEnabled ? "Yes" : "No");
     1045        RTPrintf(List::tr("Enabled:        %s\n"), fEnabled ? List::tr("Yes") : List::tr("No"));
    10421046
    10431047        /* Global configuration: */
    1044         RTPrintf("Global Configuration:\n");
     1048        RTPrintf(List::tr("Global Configuration:\n"));
    10451049        HRESULT hrc;
    10461050        ComPtr<IDHCPGlobalConfig> ptrGlobal;
    … …  
    10571061        CHECK_ERROR2_STMT(hrc, ptrDHCPServer, COMGETTER(GroupConfigs)(ComSafeArrayAsOutParam(Groups)), hrcRet = hrc);
    10581062        if (FAILED(hrc))
    1059             RTPrintf("Groups:               %Rrc\n", hrc);
     1063            RTPrintf(List::tr("Groups:               %Rrc\n"), hrc);
    10601064        else if (Groups.size() == 0)
    1061             RTPrintf("Groups:               None\n");
     1065            RTPrintf(List::tr("Groups:               None\n"));
    10621066        else
    10631067        {
    … …  
    10651069            {
    10661070                CHECK_ERROR2I_STMT(Groups[iGrp], COMGETTER(Name)(bstr.asOutParam()), hrcRet = hrcCheck);
    1067                 RTPrintf("Group:                %ls\n", bstr.raw());
     1071                RTPrintf(List::tr("Group:                %ls\n"), bstr.raw());
    10681072
    10691073                com::SafeIfaceArray<IDHCPGroupCondition> Conditions;
    10701074                CHECK_ERROR2_STMT(hrc, Groups[iGrp], COMGETTER(Conditions)(ComSafeArrayAsOutParam(Conditions)), hrcRet = hrc);
    10711075                if (FAILED(hrc))
    1072                     RTPrintf("    Conditions:       %Rhrc\n", hrc);
     1076                    RTPrintf(List::tr("    Conditions:       %Rhrc\n"), hrc);
    10731077                else if (Conditions.size() == 0)
    1074                     RTPrintf("    Conditions:       None\n");
     1078                    RTPrintf(List::tr("    Conditions:       None\n"));
    10751079                else
    10761080                    for (size_t iCond = 0; iCond < Conditions.size(); iCond++)
    … …  
    10821086                        CHECK_ERROR2_STMT(hrc, Conditions[iCond], COMGETTER(Value)(bstr.asOutParam()), hrcRet = hrc);
    10831087
    1084                         RTPrintf("    Conditions:       %s %s %ls\n",
    1085                                  fInclusive ? "include" : "exclude",
     1088                        RTPrintf(List::tr("    Conditions:       %s %s %ls\n"),
     1089                                 fInclusive ? List::tr("include") : List::tr("exclude"),
    10861090                                   enmType == DHCPGroupConditionType_MAC                    ? "MAC       "
    10871091                                 : enmType == DHCPGroupConditionType_MACWildcard            ? "MAC*      "
    … …  
    11051109        CHECK_ERROR2_STMT(hrc, ptrDHCPServer, COMGETTER(IndividualConfigs)(ComSafeArrayAsOutParam(Hosts)), hrcRet = hrc);
    11061110        if (FAILED(hrc))
    1107             RTPrintf("Individual Configs:   %Rrc\n", hrc);
     1111            RTPrintf(List::tr("Individual Configs:   %Rrc\n"), hrc);
    11081112        else if (Hosts.size() == 0)
    1109             RTPrintf("Individual Configs:   None\n");
     1113            RTPrintf(List::tr("Individual Configs:   None\n"));
    11101114        else
    11111115        {
    … …  
    11181122                {
    11191123                    CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(MACAddress)(bstr.asOutParam()), hrcRet = hrcCheck);
    1120                     RTPrintf("Individual Config:    MAC %ls\n", bstr.raw());
     1124                    RTPrintf(List::tr("Individual Config:    MAC %ls\n"), bstr.raw());
    11211125                }
    11221126                else
    … …  
    11281132                    hrc = Hosts[iHost]->COMGETTER(MACAddress)(bstrMACAddress.asOutParam()); /* No CHECK_ERROR2 stuff! */
    11291133                    if (SUCCEEDED(hrc))
    1130                         RTPrintf("Individual Config:    VM NIC: %ls slot %u, MAC %ls\n", bstr.raw(), uSlot, bstrMACAddress.raw());
     1134                        RTPrintf(List::tr("Individual Config:    VM NIC: %ls slot %u, MAC %ls\n"), bstr.raw(), uSlot,
     1135                                 bstrMACAddress.raw());
    11311136                    else
    1132                         RTPrintf("Individual Config:    VM NIC: %ls slot %u, MAC %Rhrc\n", bstr.raw(), uSlot, hrc);
     1137                        RTPrintf(List::tr("Individual Config:    VM NIC: %ls slot %u, MAC %Rhrc\n"), bstr.raw(), uSlot, hrc);
    11331138                }
    11341139
    11351140                CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(FixedAddress)(bstr.asOutParam()), hrcRet = hrcCheck);
    11361141                if (bstr.isNotEmpty())
    1137                     RTPrintf("    Fixed Address:    %ls\n", bstr.raw());
     1142                    RTPrintf(List::tr("    Fixed Address:    %ls\n"), bstr.raw());
    11381143                else
    1139                     RTPrintf("    Fixed Address:    dynamic\n");
     1144                    RTPrintf(List::tr("    Fixed Address:    dynamic\n"));
    11401145
    11411146                hrc = showDhcpConfig(Hosts[iHost]);
    … …  
    11631168    SafeIfaceArray<IExtPack> extPacks;
    11641169    CHECK_ERROR2I_RET(ptrExtPackMgr, COMGETTER(InstalledExtPacks)(ComSafeArrayAsOutParam(extPacks)), hrcCheck);
    1165     RTPrintf("Extension Packs: %u\n", extPacks.size());
     1170    RTPrintf(List::tr("Extension Packs: %u\n"), extPacks.size());
    11661171
    11671172    HRESULT hrc = S_OK;
    … …  
    11891194        if (i)
    11901195            RTPrintf("\n");
    1191         RTPrintf("Pack no.%2zu:   %ls\n"
    1192                  "Version:      %ls\n"
    1193                  "Revision:     %u\n"
    1194                  "Edition:      %ls\n"
    1195                  "Description:  %ls\n"
    1196                  "VRDE Module:  %ls\n"
    1197                  "Usable:       %RTbool\n"
    1198                  "Why unusable: %ls\n",
     1196        RTPrintf(List::tr(
     1197                   "Pack no.%2zu:   %ls\n"
     1198                   "Version:      %ls\n"
     1199                   "Revision:     %u\n"
     1200                   "Edition:      %ls\n"
     1201                   "Description:  %ls\n"
     1202                   "VRDE Module:  %ls\n"
     1203                   "Usable:       %RTbool\n"
     1204                   "Why unusable: %ls\n"),
    11991205                 i, bstrName.raw(),
    12001206                 bstrVersion.raw(),
    … …  
    12441250    com::SafeIfaceArray<IHostVideoInputDevice> hostVideoInputDevices;
    12451251    CHECK_ERROR(host, COMGETTER(VideoInputDevices)(ComSafeArrayAsOutParam(hostVideoInputDevices)));
    1246     RTPrintf("Video Input Devices: %u\n", hostVideoInputDevices.size());
     1252    RTPrintf(List::tr("Video Input Devices: %u\n"), hostVideoInputDevices.size());
    12471253    for (size_t i = 0; i < hostVideoInputDevices.size(); ++i)
    12481254    {
    … …  
    12731279    CHECK_ERROR(systemProperties, COMGETTER(ScreenShotFormats)(ComSafeArrayAsOutParam(formats)));
    12741280
    1275     RTPrintf("Supported %d screen shot formats:\n", formats.size());
     1281    RTPrintf(List::tr("Supported %d screen shot formats:\n"), formats.size());
    12761282    for (size_t i = 0; i < formats.size(); ++i)
    12771283    {
    … …  
    13021308    CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders)));
    13031309
    1304     RTPrintf("Supported %d cloud providers:\n", apCloudProviders.size());
     1310    RTPrintf(List::tr("Supported %d cloud providers:\n"), apCloudProviders.size());
    13051311    for (size_t i = 0; i < apCloudProviders.size(); ++i)
    13061312    {
    … …  
    13081314        Bstr bstrProviderName;
    13091315        pCloudProvider->COMGETTER(Name)(bstrProviderName.asOutParam());
    1310         RTPrintf("Name:            %ls\n", bstrProviderName.raw());
     1316        RTPrintf(List::tr("Name:            %ls\n"), bstrProviderName.raw());
    13111317        pCloudProvider->COMGETTER(ShortName)(bstrProviderName.asOutParam());
    1312         RTPrintf("Short Name:      %ls\n", bstrProviderName.raw());
     1318        RTPrintf(List::tr("Short Name:      %ls\n"), bstrProviderName.raw());
    13131319        Bstr bstrProviderID;
    13141320        pCloudProvider->COMGETTER(Id)(bstrProviderID.asOutParam());
    … …  
    13461352            Bstr bstrProfileName;
    13471353            pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
    1348             RTPrintf("Name:          %ls\n", bstrProfileName.raw());
     1354            RTPrintf(List::tr("Name:          %ls\n"), bstrProfileName.raw());
    13491355            Bstr bstrProviderID;
    13501356            pCloudProfile->COMGETTER(ProviderId)(bstrProviderID.asOutParam());
    1351             RTPrintf("Provider GUID: %ls\n", bstrProviderID.raw());
     1357            RTPrintf(List::tr("Provider GUID: %ls\n"), bstrProviderID.raw());
    13521358
    13531359            if (fOptLong)
    … …  
    13651371                        value = values[k];
    13661372                    RTPrintf("%s%ls=%ls\n",
    1367                              fFirst ? "Property:      " : "               ",
     1373                             fFirst ? List::tr("Property:      ") : "               ",
    13681374                             names[k], value.raw());
    13691375                    fFirst = false;
    … …  
    14031409    else
    14041410    {
    1405         RTPrintf("CPU Profile #%02zu:\n", idx);
    1406         RTPrintf("  Architecture: %s\n", pszArchitecture);
    1407         RTPrintf("  Name:         %ls\n", bstrName.raw());
     1411        RTPrintf(List::tr("CPU Profile #%02zu:\n"), idx);
     1412        RTPrintf(List::tr("  Architecture: %s\n"), pszArchitecture);
     1413        RTPrintf(List::tr("  Name:         %ls\n"), bstrName.raw());
    14081414        CHECK_ERROR2I_RET(pProfile, COMGETTER(FullName)(bstrName.asOutParam()), hrcCheck);
    1409         RTPrintf("  Full Name:    %ls\n", bstrName.raw());
     1415        RTPrintf(List::tr("  Full Name:    %ls\n"), bstrName.raw());
    14101416    }
    14111417    return hrc;
    … …  
    16571663        CHECK_ERROR(pHostDrive,COMGETTER(DrivePath)(bstrDrivePath.asOutParam()));
    16581664        if (SUCCEEDED(rc))
    1659             RTPrintf("%sDrive:       %ls\n", i > 0 ? "\n" : "", bstrDrivePath.raw());
     1665            RTPrintf(List::tr("%sDrive:       %ls\n"), i > 0 ? "\n" : "", bstrDrivePath.raw());
    16601666        else
    1661             RTPrintf("%sDrive:       %Rhrc\n", i > 0 ? "\n" : "", rc);
     1667            RTPrintf(List::tr("%sDrive:       %Rhrc\n"), i > 0 ? "\n" : "", rc);
    16621668
    16631669        com::Bstr bstrModel;
    16641670        CHECK_ERROR(pHostDrive,COMGETTER(Model)(bstrModel.asOutParam()));
    16651671        if (FAILED(rc))
    1666             RTPrintf("Model:       %Rhrc\n", rc);
     1672            RTPrintf(List::tr("Model:       %Rhrc\n"), rc);
    16671673        else if (bstrModel.isNotEmpty())
    1668             RTPrintf("Model:       \"%ls\"\n", bstrModel.raw());
     1674            RTPrintf(List::tr("Model:       \"%ls\"\n"), bstrModel.raw());
    16691675        else
    1670             RTPrintf("Model:       unknown/inaccessible\n");
     1676            RTPrintf(List::tr("Model:       unknown/inaccessible\n"));
    16711677
    16721678        /* The other attributes are not accessible in limited mode and will fail
    … …  
    16781684        else if (rc == E_ACCESSDENIED)
    16791685        {
    1680             RTPrintf("Further disk and partitioning information is not available for drive \"%ls\". (E_ACCESSDENIED)\n",
     1686            RTPrintf(List::tr("Further disk and partitioning information is not available for drive \"%ls\". (E_ACCESSDENIED)\n"),
    16811687                     bstrDrivePath.raw());
    16821688            continue;
    … …  
    16911697        rc = pHostDrive->COMGETTER(Size)(&cbSize);
    16921698        if (SUCCEEDED(rc) && fOptLong)
    1693             RTPrintf("Size:        %llu bytes (%Rhcb)\n", cbSize, cbSize);
     1699            RTPrintf(List::tr("Size:        %llu bytes (%Rhcb)\n"), cbSize, cbSize);
    16941700        else if (SUCCEEDED(rc))
    1695             RTPrintf("Size:        %Rhcb\n", cbSize);
     1701            RTPrintf(List::tr("Size:        %Rhcb\n"), cbSize);
    16961702        else
    16971703        {
    1698             RTPrintf("Size:        %Rhrc\n", rc);
     1704            RTPrintf(List::tr("Size:        %Rhrc\n"), rc);
    16991705            com::GlueHandleComErrorNoCtx(pHostDrive, rc);
    17001706        }
    … …  
    17031709        rc = pHostDrive->COMGETTER(SectorSize)(&cbSectorSize);
    17041710        if (SUCCEEDED(rc))
    1705             RTPrintf("Sector Size: %u bytes\n", cbSectorSize);
     1711            RTPrintf(List::tr("Sector Size: %u bytes\n"), cbSectorSize);
    17061712        else
    17071713        {
    1708             RTPrintf("Sector Size: %Rhrc\n", rc);
     1714            RTPrintf(List::tr("Sector Size: %Rhrc\n"), rc);
    17091715            com::GlueHandleComErrorNoCtx(pHostDrive, rc);
    17101716        }
    … …  
    17131719        rc = pHostDrive->COMGETTER(PartitioningType)(&partitioningType);
    17141720        if (SUCCEEDED(rc))
    1715             RTPrintf("Scheme:      %s\n", partitioningType == PartitioningType_MBR ? "MBR" : "GPT");
     1721            RTPrintf(List::tr("Scheme:      %s\n"), partitioningType == PartitioningType_MBR ? "MBR" : "GPT");
    17161722        else
    17171723        {
    1718             RTPrintf("Scheme:      %Rhrc\n", rc);
     1724            RTPrintf(List::tr("Scheme:      %Rhrc\n"), rc);
    17191725            com::GlueHandleComErrorNoCtx(pHostDrive, rc);
    17201726        }
    … …  
    17241730        if (FAILED(rc))
    17251731        {
    1726             RTPrintf("Partitions:  %Rhrc\n", rc);
     1732            RTPrintf(List::tr("Partitions:  %Rhrc\n"), rc);
    17271733            com::GlueHandleComErrorNoCtx(pHostDrive, rc);
    17281734        }
    17291735        else if (apHostDrivesPartitions.size() == 0)
    1730             RTPrintf("Partitions:  None (or not able to grok them).\n");
     1736            RTPrintf(List::tr("Partitions:  None (or not able to grok them).\n"));
    17311737        else if (partitioningType == PartitioningType_MBR)
    17321738        {
    17331739            if (fOptLong)
    1734                 RTPrintf("Partitions:                              First         Last\n"
    1735                          "##  Type      Byte Size     Byte Offset  Cyl/Head/Sec  Cyl/Head/Sec Active\n");
     1740                RTPrintf(List::tr("Partitions:                              First         Last\n"
     1741                                  "##  Type      Byte Size     Byte Offset  Cyl/Head/Sec  Cyl/Head/Sec Active\n"));
    17361742            else
    1737                 RTPrintf("Partitions:                   First         Last\n"
    1738                          "##  Type  Size      Start     Cyl/Head/Sec  Cyl/Head/Sec Active\n");
     1743                RTPrintf(List::tr("Partitions:                   First         Last\n"
     1744                                  "##  Type  Size      Start     Cyl/Head/Sec  Cyl/Head/Sec Active\n"));
    17391745            for (size_t j = 0; j < apHostDrivesPartitions.size(); ++j)
    17401746            {
    … …  
    17711777                             idx, uType, cbSize, offStart,
    17721778                             uStartCylinder, uStartHead, uStartSector, uEndCylinder, uEndHead, uEndSector,
    1773                              fActive ? "yes" : "no", PartitionTypeToString(enmType, ""));
     1779                             fActive ? List::tr("yes") : List::tr("no"), PartitionTypeToString(enmType, ""));
    17741780                else
    17751781                    RTPrintf("%2u   %02x   %8Rhcb  %8Rhcb  %4u/%3u/%2u   %4u/%3u/%2u   %s   %s\n",
    17761782                             idx, uType, (uint64_t)cbSize, (uint64_t)offStart,
    17771783                             uStartCylinder, uStartHead, uStartSector, uEndCylinder, uEndHead, uEndSector,
    1778                              fActive ? "yes" : "no", PartitionTypeToString(enmType, ""));
     1784                             fActive ? List::tr("yes") : List::tr("no"), PartitionTypeToString(enmType, ""));
    17791785            }
    17801786        }
    … …  
    17941800
    17951801            if (fOptLong)
    1796                 RTPrintf("Partitions:\n"
    1797                          "## %-*s Uuid                                           Byte Size         Byte Offset Active Name\n",
    1798                          (int)cchMaxType, "Type");
     1802                RTPrintf(List::tr(
     1803                           "Partitions:\n"
     1804                           "## %-*s Uuid                                           Byte Size         Byte Offset Active Name\n"),
     1805                         (int)cchMaxType, List::tr("Type"));
    17991806            else
    1800                 RTPrintf("Partitions:\n"
    1801                          "##  %-*s  Uuid                                   Size      Start   Active Name\n",
    1802                          (int)cchMaxType, "Type");
     1807                RTPrintf(List::tr(
     1808                           "Partitions:\n"
     1809                           "##  %-*s  Uuid                                   Size      Start   Active Name\n"),
     1810                         (int)cchMaxType, List::tr("Type"));
    18031811
    18041812            for (size_t j = 0; j < apHostDrivesPartitions.size(); ++j)
    … …  
    18331841                if (fOptLong)
    18341842                    RTPrintf("%2u %-*s %36ls %19llu %19llu   %-3s  %ls\n", idx, cchMaxType, pszTypeNm,
    1835                              bstrUuidPartition.raw(), cbSize, offStart, fActive ? "on" : "off", bstrName.raw());
     1843                             bstrUuidPartition.raw(), cbSize, offStart, fActive ? List::tr("on") : List::tr("off"),
     1844                             bstrName.raw());
    18361845                else
    18371846                    RTPrintf("%2u  %-*s  %36ls  %8Rhcb  %8Rhcb  %-3s   %ls\n", idx, cchMaxType, pszTypeNm,
    1838                              bstrUuidPartition.raw(), cbSize, offStart, fActive ? "on" : "off", bstrName.raw());
     1847                             bstrUuidPartition.raw(), cbSize, offStart, fActive ? List::tr("on") : List::tr("off"),
     1848                             bstrName.raw());
    18391849            }
    18401850        }
    … …  
    20042014                    Bstr guestDescription;
    20052015                    guestOS->COMGETTER(Description)(guestDescription.asOutParam());
    2006                     RTPrintf("Description: %ls\n", guestDescription.raw());
     2016                    RTPrintf(List::tr("Description: %ls\n"), guestDescription.raw());
    20072017                    Bstr familyId;
    20082018                    guestOS->COMGETTER(FamilyId)(familyId.asOutParam());
    2009                     RTPrintf("Family ID:   %ls\n", familyId.raw());
     2019                    RTPrintf(List::tr("Family ID:   %ls\n"), familyId.raw());
    20102020                    Bstr familyDescription;
    20112021                    guestOS->COMGETTER(FamilyDescription)(familyDescription.asOutParam());
    2012                     RTPrintf("Family Desc: %ls\n", familyDescription.raw());
     2022                    RTPrintf(List::tr("Family Desc: %ls\n"), familyDescription.raw());
    20132023                    BOOL is64Bit;
    20142024                    guestOS->COMGETTER(Is64Bit)(&is64Bit);
    2015                     RTPrintf("64 bit:      %RTbool\n", is64Bit);
     2025                    RTPrintf(List::tr("64 bit:      %RTbool\n"), is64Bit);
    20162026                    RTPrintf("\n");
    20172027                }
    … …  
    20362046                    Bstr location;
    20372047                    dvdDrive->COMGETTER(Location)(location.asOutParam());
    2038                     RTPrintf("Name:         %ls\n\n", location.raw());
     2048                    RTPrintf(List::tr("Name:         %ls\n\n"), location.raw());
    20392049                }
    20402050            }
    … …  
    20582068                    Bstr location;
    20592069                    floppyDrive->COMGETTER(Location)(location.asOutParam());
    2060                     RTPrintf("Name:         %ls\n\n", location.raw());
     2070                    RTPrintf(List::tr("Name:         %ls\n\n"), location.raw());
    20612071                }
    20622072            }
    … …  
    20952105            CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
    20962106
    2097             RTPrintf("Host CPUIDs:\n\nLeaf no.  EAX      EBX      ECX      EDX\n");
     2107            RTPrintf(List::tr("Host CPUIDs:\n\nLeaf no.  EAX      EBX      ECX      EDX\n"));
    20982108            ULONG uCpuNo = 0; /* ASSUMES that CPU#0 is online. */
    20992109            static uint32_t const s_auCpuIdRanges[] =
    … …  
    21272137            com::SafeIfaceArray<IMedium> hdds;
    21282138            CHECK_ERROR(pVirtualBox, COMGETTER(HardDisks)(ComSafeArrayAsOutParam(hdds)));
    2129             rc = listMedia(pVirtualBox, hdds, "base", fOptLong);
     2139            rc = listMedia(pVirtualBox, hdds, List::tr("base"), fOptLong);
    21302140            break;
    21312141        }
    … …  
    21802190                Bstr netName;
    21812191                net->COMGETTER(NetworkName)(netName.asOutParam());
    2182                 RTPrintf("NetworkName:    %ls\n", netName.raw());
     2192                RTPrintf(List::tr("NetworkName:    %ls\n"), netName.raw());
    21832193                Bstr gateway;
    21842194                net->COMGETTER(Gateway)(gateway.asOutParam());
    … …  
    21862196                Bstr network;
    21872197                net->COMGETTER(Network)(network.asOutParam());
    2188                 RTPrintf("Network:        %ls\n", network.raw());
     2198                RTPrintf(List::tr("Network:        %ls\n"), network.raw());
    21892199                BOOL fEnabled;
    21902200                net->COMGETTER(IPv6Enabled)(&fEnabled);
    2191                 RTPrintf("IPv6 Enabled:   %s\n", fEnabled ? "Yes" : "No");
     2201                RTPrintf(List::tr("IPv6 Enabled:   %s\n"), fEnabled ? List::tr("Yes") : List::tr("No"));
    21922202                Bstr ipv6prefix;
    21932203                net->COMGETTER(IPv6Prefix)(ipv6prefix.asOutParam());
    2194                 RTPrintf("IPv6 Prefix:    %ls\n", ipv6prefix.raw());
     2204                RTPrintf(List::tr("IPv6 Prefix:    %ls\n"), ipv6prefix.raw());
    21952205                net->COMGETTER(NeedDhcpServer)(&fEnabled);
    2196                 RTPrintf("DHCP Enabled:   %s\n", fEnabled ? "Yes" : "No");
     2206                RTPrintf(List::tr("DHCP Enabled:   %s\n"), fEnabled ? List::tr("Yes") : List::tr("No"));
    21972207                net->COMGETTER(Enabled)(&fEnabled);
    2198                 RTPrintf("Enabled:        %s\n", fEnabled ? "Yes" : "No");
     2208                RTPrintf(List::tr("Enabled:        %s\n"), fEnabled ? List::tr("Yes") : List::tr("No"));
    21992209
    22002210#define PRINT_STRING_ARRAY(title) \
    … …  
    22102220
    22112221                CHECK_ERROR(nets[i], COMGETTER(PortForwardRules4)(ComSafeArrayAsOutParam(strs)));
    2212                 PRINT_STRING_ARRAY("Port-forwarding (ipv4)\n");
     2222                PRINT_STRING_ARRAY(List::tr("Port-forwarding (ipv4)\n"));
    22132223                strs.setNull();
    22142224
    22152225                CHECK_ERROR(nets[i], COMGETTER(PortForwardRules6)(ComSafeArrayAsOutParam(strs)));
    2216                 PRINT_STRING_ARRAY("Port-forwarding (ipv6)\n");
     2226                PRINT_STRING_ARRAY(List::tr("Port-forwarding (ipv6)\n"));
    22172227                strs.setNull();
    22182228
    22192229                CHECK_ERROR(nets[i], COMGETTER(LocalMappings)(ComSafeArrayAsOutParam(strs)));
    2220                 PRINT_STRING_ARRAY("loopback mappings (ipv4)\n");
     2230                PRINT_STRING_ARRAY(List::tr("loopback mappings (ipv4)\n"));
    22212231                strs.setNull();
    22222232
    … …  
    23902400
    23912401            case VINF_GETOPT_NOT_OPTION:
    2392                 return errorSyntax(USAGE_LIST, "Unknown subcommand \"%s\".", ValueUnion.psz);
     2402                return errorSyntax(USAGE_LIST, List::tr("Unknown subcommand \"%s\"."), ValueUnion.psz);
    23932403
    23942404            default:
    … …  
    24012411     */
    24022412    if (enmOptCommand == kListNotSpecified)
    2403         return errorSyntax(USAGE_LIST, "Missing subcommand for \"list\" command.\n");
     2413        return errorSyntax(USAGE_LIST, List::tr("Missing subcommand for \"list\" command.\n"));
    24042414    if (!fOptMultiple)
    24052415    {

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageMetrics.cpp

    r85121 r92372  
    4141using namespace com;
    4242
     43DECLARE_TRANSLATION_CONTEXT(Metrics);
    4344
    4445// funcs
    … …  
    8990            else
    9091            {
    91                 errorArgument("Invalid machine name: '%s'", argv[0]);
     92                errorArgument(Metrics::tr("Invalid machine name: '%s'"), argv[0]);
    9293                return rc;
    9394            }
    … …  
    127128    ComPtr<IHost> host = aObject;
    128129    if (!host.isNull())
    129         return Bstr("host");
     130        return Bstr(Metrics::tr("host"));
    130131
    131132    ComPtr<IMachine> machine = aObject;
    … …  
    137138            return name;
    138139    }
    139     return Bstr("unknown");
     140    return Bstr(Metrics::tr("unknown"));
    140141}
    141142
    … …  
    148149        ComPtr<IUnknown> object;
    149150        Bstr metricName;
    150         RTPrintf("The following metrics were modified:\n\n"
    151                  "Object     Metric\n"
    152                  "---------- --------------------\n");
     151        RTPrintf(Metrics::tr("The following metrics were modified:\n\n"
     152                             "Object     Metric\n"
     153                             "---------- --------------------\n"));
    153154        for (size_t i = 0; i < metrics.size(); i++)
    154155        {
    … …  
    162163    else
    163164    {
    164         RTMsgError("No metrics match the specified filter!");
     165        RTMsgError(Metrics::tr("No metrics match the specified filter!"));
    165166    }
    166167}
    … …  
    194195    ULONG period, count;
    195196    LONG minimum, maximum;
    196     RTPrintf(
     197    RTPrintf(Metrics::tr(
    197198"Object          Metric                                   Unit    Minimum    Maximum     Period      Count Description\n"
    198 "--------------- ---------------------------------------- ---- ---------- ---------- ---------- ---------- -----------\n");
     199"--------------- ---------------------------------------- ---- ---------- ---------- ---------- ---------- -----------\n"));
    199200    for (size_t i = 0; i < metricInfo.size(); i++)
    200201    {
    … …  
    235236        {
    236237            if (argc <= i + 1)
    237                 return errorArgument("Missing argument to '%s'", argv[i]);
     238                return errorArgument(Metrics::tr("Missing argument to '%s'"), argv[i]);
    238239            if (   VINF_SUCCESS != RTStrToUInt32Full(argv[++i], 10, &period)
    239240                || !period)
    240                 return errorArgument("Invalid value for 'period' parameter: '%s'", argv[i]);
     241                return errorArgument(Metrics::tr("Invalid value for 'period' parameter: '%s'"), argv[i]);
    241242        }
    242243        else if (   !strcmp(argv[i], "--samples")
    … …  
    244245        {
    245246            if (argc <= i + 1)
    246                 return errorArgument("Missing argument to '%s'", argv[i]);
     247                return errorArgument(Metrics::tr("Missing argument to '%s'"), argv[i]);
    247248            if (   VINF_SUCCESS != RTStrToUInt32Full(argv[++i], 10, &samples)
    248249                || !samples)
    249                 return errorArgument("Invalid value for 'samples' parameter: '%s'", argv[i]);
     250                return errorArgument(Metrics::tr("Invalid value for 'samples' parameter: '%s'"), argv[i]);
    250251        }
    251252        else if (   !strcmp(argv[i], "--list")
    … …  
    312313                                                       ComSafeArrayAsOutParam(retData)) );
    313314
    314     RTPrintf("Object          Metric                                   Values\n"
    315              "--------------- ---------------------------------------- --------------------------------------------\n");
     315    RTPrintf(Metrics::tr(
     316                "Object          Metric                                   Values\n"
     317                "--------------- ---------------------------------------- --------------------------------------------\n"));
    316318    for (unsigned i = 0; i < retNames.size(); i++)
    317319    {
    … …  
    401403        {
    402404            if (argc <= i + 1)
    403                 return errorArgument("Missing argument to '%s'", argv[i]);
     405                return errorArgument(Metrics::tr("Missing argument to '%s'"), argv[i]);
    404406            if (   VINF_SUCCESS != RTStrToUInt32Full(argv[++i], 10, &period)
    405407                || !period)
    406                 return errorArgument("Invalid value for 'period' parameter: '%s'", argv[i]);
     408                return errorArgument(Metrics::tr("Invalid value for 'period' parameter: '%s'"), argv[i]);
    407409        }
    408410        else if (   !strcmp(argv[i], "--samples")
    … …  
    410412        {
    411413            if (argc <= i + 1)
    412                 return errorArgument("Missing argument to '%s'", argv[i]);
     414                return errorArgument(Metrics::tr("Missing argument to '%s'"), argv[i]);
    413415            if (   VINF_SUCCESS != RTStrToUInt32Full(argv[++i], 10, &samples)
    414416                || !samples)
    415                 return errorArgument("Invalid value for 'samples' parameter: '%s'", argv[i]);
     417                return errorArgument(Metrics::tr("Invalid value for 'samples' parameter: '%s'"), argv[i]);
    416418        }
    417419        else if (   !strcmp(argv[i], "--list")
    … …  
    472474    if (isDetached)
    473475    {
    474         RTMsgWarning("The background process holding collected metrics will shutdown\n"
    475                      "in few seconds, discarding all collected data and parameters.");
     476        RTMsgWarning(Metrics::tr("The background process holding collected metrics will shutdown\n"
     477                                 "in few seconds, discarding all collected data and parameters."));
    476478        return RTEXITCODE_SUCCESS;
    477479    }
    … …  
    481483#endif /* RT_OS_WINDOWS */
    482484
    483     RTPrintf("Time stamp   Object     Metric               Value\n");
     485    RTPrintf(Metrics::tr("Time stamp   Object     Metric               Value\n"));
    484486
    485487    while (g_fKeepGoing)
    … …  
    624626    /* at least one option: subcommand name */
    625627    if (a->argc < 1)
    626         return errorSyntax(USAGE_METRICS, "Subcommand missing");
     628        return errorSyntax(USAGE_METRICS, Metrics::tr("Subcommand missing"));
    627629
    628630    ComPtr<IPerformanceCollector> performanceCollector;
    … …  
    643645        rcExit = handleMetricsDisable(a->argc, a->argv, a->virtualBox, performanceCollector);
    644646    else
    645         return errorSyntax(USAGE_METRICS, "Invalid subcommand '%s'", a->argv[0]);
     647        return errorSyntax(USAGE_METRICS, Metrics::tr("Invalid subcommand '%s'"), a->argv[0]);
    646648
    647649    return rcExit;
    … …  
    649651
    650652#endif /* !VBOX_ONLY_DOCS */
    651 

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageMisc.cpp

    r92143 r92372  
    5959using namespace com;
    6060
    61 
     61DECLARE_TRANSLATION_CONTEXT(Misc);
    6262
    6363RTEXITCODE handleRegisterVM(HandlerArg *a)
    … …  
    6666
    6767    if (a->argc != 1)
    68         return errorSyntax(USAGE_REGISTERVM, "Incorrect number of parameters");
     68        return errorSyntax(USAGE_REGISTERVM, Misc::tr("Incorrect number of parameters"));
    6969
    7070    ComPtr<IMachine> machine;
    … …  
    7979        int vrc = RTPathAbs(a->argv[0], szVMFileAbs, sizeof(szVMFileAbs));
    8080        if (RT_FAILURE(vrc))
    81             return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot convert filename \"%s\" to absolute path: %Rrc", a->argv[0], vrc);
     81            return RTMsgErrorExit(RTEXITCODE_FAILURE, Misc::tr("Cannot convert filename \"%s\" to absolute path: %Rrc"),
     82                                  a->argv[0], vrc);
    8283        CHECK_ERROR(a->virtualBox, OpenMachine(Bstr(szVMFileAbs).raw(),
    8384                                               machine.asOutParam()));
    … …  
    124125                    VMName = ValueUnion.psz;
    125126                else
    126                     return errorSyntax(USAGE_UNREGISTERVM, "Invalid parameter '%s'", ValueUnion.psz);
     127                    return errorSyntax(USAGE_UNREGISTERVM, Misc::tr("Invalid parameter '%s'"), ValueUnion.psz);
    127128                break;
    128129
    … …  
    131132                {
    132133                    if (RT_C_IS_PRINT(c))
    133                         return errorSyntax(USAGE_UNREGISTERVM, "Invalid option -%c", c);
    134                     return errorSyntax(USAGE_UNREGISTERVM, "Invalid option case %i", c);
     134                        return errorSyntax(USAGE_UNREGISTERVM, Misc::tr("Invalid option -%c"), c);
     135                    return errorSyntax(USAGE_UNREGISTERVM, Misc::tr("Invalid option case %i"), c);
    135136                }
    136137                if (c == VERR_GETOPT_UNKNOWN_OPTION)
    137                     return errorSyntax(USAGE_UNREGISTERVM, "unknown option: %s\n", ValueUnion.psz);
     138                    return errorSyntax(USAGE_UNREGISTERVM, Misc::tr("unknown option: %s\n"), ValueUnion.psz);
    138139                if (ValueUnion.pDef)
    139140                    return errorSyntax(USAGE_UNREGISTERVM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
    140                 return errorSyntax(USAGE_UNREGISTERVM, "error: %Rrs", c);
     141                return errorSyntax(USAGE_UNREGISTERVM, Misc::tr("error: %Rrs"), c);
    141142        }
    142143    }
    … …  
    144145    /* check for required options */
    145146    if (!VMName)
    146         return errorSyntax(USAGE_UNREGISTERVM, "VM name required");
     147        return errorSyntax(USAGE_UNREGISTERVM, Misc::tr("VM name required"));
    147148
    148149    ComPtr<IMachine> machine;
    … …  
    161162
    162163        rc = showProgress(pProgress);
    163         CHECK_PROGRESS_ERROR_RET(pProgress, ("Machine delete failed"), RTEXITCODE_FAILURE);
     164        CHECK_PROGRESS_ERROR_RET(pProgress, (Misc::tr("Machine delete failed")), RTEXITCODE_FAILURE);
    164165    }
    165166    else
    … …  
    255256    /* check for required options */
    256257    if (bstrName.isEmpty())
    257         return errorSyntax(USAGE_CREATEVM, "Parameter --name is required");
     258        return errorSyntax(USAGE_CREATEVM, Misc::tr("Parameter --name is required"));
    258259
    259260    do
    … …  
    297298        Bstr settingsFile;
    298299        CHECK_ERROR_BREAK(machine, COMGETTER(SettingsFilePath)(settingsFile.asOutParam()));
    299         RTPrintf("Virtual machine '%ls' is created%s.\n"
    300                  "UUID: %s\n"
    301                  "Settings file: '%ls'\n",
    302                  bstrName.raw(), fRegister ? " and registered" : "",
     300        RTPrintf(Misc::tr("Virtual machine '%ls' is created%s.\n"
     301                          "UUID: %s\n"
     302                          "Settings file: '%ls'\n"),
     303                 bstrName.raw(), fRegister ? Misc::tr(" and registered") : "",
    303304                 Utf8Str(uuid).c_str(), settingsFile.raw());
    304305    }
    … …  
    342343                    vrc = RTPathAbs(ValueUnion.psz, szTargetFolder, sizeof(szTargetFolder));
    343344                    if (RT_FAILURE(vrc))
    344                         return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathAbs(%s,,) failed with rc=%Rrc", ValueUnion.psz, vrc);
     345                        return RTMsgErrorExit(RTEXITCODE_FAILURE, Misc::tr("RTPathAbs(%s,,) failed with rc=%Rrc"),
     346                                              ValueUnion.psz, vrc);
    345347                } else {
    346348                    szTargetFolder[0] = '\0';
    … …  
    352354                    pszSrcName = ValueUnion.psz;
    353355                else
    354                     return errorSyntax(USAGE_MOVEVM, "Invalid parameter '%s'", ValueUnion.psz);
     356                    return errorSyntax(USAGE_MOVEVM, Misc::tr("Invalid parameter '%s'"), ValueUnion.psz);
    355357                break;
    356358
    … …  
    368370    /* Check for required options */
    369371    if (!pszSrcName)
    370         return errorSyntax(USAGE_MOVEVM, "VM name required");
     372        return errorSyntax(USAGE_MOVEVM, Misc::tr("VM name required"));
    371373
    372374    /* Get the machine object */
    … …  
    392394                        RTEXITCODE_FAILURE);
    393395        rc = showProgress(progress);
    394         CHECK_PROGRESS_ERROR_RET(progress, ("Move VM failed"), RTEXITCODE_FAILURE);
     396        CHECK_PROGRESS_ERROR_RET(progress, (Misc::tr("Move VM failed")), RTEXITCODE_FAILURE);
    395397
    396398        sessionMachine.setNull();
    397399        CHECK_ERROR_RET(a->session, UnlockMachine(), RTEXITCODE_FAILURE);
    398400
    399         RTPrintf("Machine has been successfully moved into %s\n", szTargetFolder[0] != '\0' ? szTargetFolder : "the same location");
     401        RTPrintf(Misc::tr("Machine has been successfully moved into %s\n"),
     402                 szTargetFolder[0] != '\0' ? szTargetFolder : Misc::tr("the same location"));
    400403    }
    401404
    … …  
    507510            case 'm':   // --mode
    508511                if (RT_FAILURE(parseCloneMode(ValueUnion.psz, &mode)))
    509                     return errorArgument("Invalid clone mode '%s'\n", ValueUnion.psz);
     512                    return errorArgument(Misc::tr("Invalid clone mode '%s'\n"), ValueUnion.psz);
    510513                break;
    511514
    512515            case 'o':   // --options
    513516                if (RT_FAILURE(parseCloneOptions(ValueUnion.psz, &options)))
    514                     return errorArgument("Invalid clone options '%s'\n", ValueUnion.psz);
     517                    return errorArgument(Misc::tr("Invalid clone options '%s'\n"), ValueUnion.psz);
    515518                break;
    516519
    … …  
    527530                    pszSrcName = ValueUnion.psz;
    528531                else
    529                     return errorSyntax("Invalid parameter '%s'", ValueUnion.psz);
     532                    return errorSyntax(Misc::tr("Invalid parameter '%s'"), ValueUnion.psz);
    530533                break;
    531534
    … …  
    537540    /* Check for required options */
    538541    if (!pszSrcName)
    539         return errorSyntax("VM name required");
     542        return errorSyntax(Misc::tr("VM name required"));
    540543
    541544    /* Get the machine object */
    … …  
    559562    /* Default name necessary? */
    560563    if (!pszTrgName)
    561         pszTrgName = RTStrAPrintf2("%s Clone", pszSrcName);
     564        pszTrgName = RTStrAPrintf2(Misc::tr("%s Clone"), pszSrcName);
    562565
    563566    Bstr createFlags;
    … …  
    593596                    RTEXITCODE_FAILURE);
    594597    rc = showProgress(progress);
    595     CHECK_PROGRESS_ERROR_RET(progress, ("Clone VM failed"), RTEXITCODE_FAILURE);
     598    CHECK_PROGRESS_ERROR_RET(progress, (Misc::tr("Clone VM failed")), RTEXITCODE_FAILURE);
    596599
    597600    if (fRegister)
    … …  
    600603    Bstr bstrNewName;
    601604    CHECK_ERROR_RET(trgMachine, COMGETTER(Name)(bstrNewName.asOutParam()), RTEXITCODE_FAILURE);
    602     RTPrintf("Machine has been successfully cloned as \"%ls\"\n", bstrNewName.raw());
     605    RTPrintf(Misc::tr("Machine has been successfully cloned as \"%ls\"\n"), bstrNewName.raw());
    603606
    604607    return RTEXITCODE_SUCCESS;
    … …  
    669672                    aBstrEnv.push_back(Bstr(ValueUnion.psz).raw());
    670673                else
    671                     return errorSyntax(USAGE_STARTVM, "Parameter to option --putenv must not contain any newline character");
     674                    return errorSyntax(USAGE_STARTVM,
     675                                       Misc::tr("Parameter to option --putenv must not contain any newline character"));
    672676                break;
    673677
    … …  
    680684                {
    681685                    if (RT_C_IS_PRINT(c))
    682                         return errorSyntax(USAGE_STARTVM, "Invalid option -%c", c);
     686                        return errorSyntax(USAGE_STARTVM, Misc::tr("Invalid option -%c"), c);
    683687                    else
    684                         return errorSyntax(USAGE_STARTVM, "Invalid option case %i", c);
     688                        return errorSyntax(USAGE_STARTVM, Misc::tr("Invalid option case %i"), c);
    685689                }
    686690                else if (c == VERR_GETOPT_UNKNOWN_OPTION)
    687                     return errorSyntax(USAGE_STARTVM, "unknown option: %s\n", ValueUnion.psz);
     691                    return errorSyntax(USAGE_STARTVM, Misc::tr("unknown option: %s\n"), ValueUnion.psz);
    688692                else if (ValueUnion.pDef)
    689693                    return errorSyntax(USAGE_STARTVM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
    690694                else
    691                     return errorSyntax(USAGE_STARTVM, "error: %Rrs", c);
     695                    return errorSyntax(USAGE_STARTVM, Misc::tr("error: %Rrs"), c);
    692696        }
    693697    }
    … …  
    695699    /* check for required options */
    696700    if (VMs.empty())
    697         return errorSyntax(USAGE_STARTVM, "at least one VM name or uuid required");
     701        return errorSyntax(USAGE_STARTVM, Misc::tr("at least one VM name or uuid required"));
    698702
    699703    for (std::list<const char *>::const_iterator it = VMs.begin();
    … …  
    713717            if (SUCCEEDED(rc) && !progress.isNull())
    714718            {
    715                 RTPrintf("Waiting for VM \"%s\" to power on...\n", pszVM);
     719                RTPrintf(Misc::tr("Waiting for VM \"%s\" to power on...\n"), pszVM);
    716720                CHECK_ERROR(progress, WaitForCompletion(-1));
    717721                if (SUCCEEDED(rc))
    … …  
    728732                        {
    729733                            if (SUCCEEDED(iRc))
    730                                 RTPrintf("VM \"%s\" has been successfully started.\n", pszVM);
     734                                RTPrintf(Misc::tr("VM \"%s\" has been successfully started.\n"), pszVM);
    731735                            else
    732736                            {
    … …  
    757761
    758762    if (a->argc != 1)
    759         return errorSyntax(USAGE_DISCARDSTATE, "Incorrect number of parameters");
     763        return errorSyntax(USAGE_DISCARDSTATE, Misc::tr("Incorrect number of parameters"));
    760764
    761765    ComPtr<IMachine> machine;
    … …  
    786790
    787791    if (a->argc != 2)
    788         return errorSyntax(USAGE_ADOPTSTATE, "Incorrect number of parameters");
     792        return errorSyntax(USAGE_ADOPTSTATE, Misc::tr("Incorrect number of parameters"));
    789793
    790794    ComPtr<IMachine> machine;
    … …  
    796800        int vrc = RTPathAbs(a->argv[1], szStateFileAbs, sizeof(szStateFileAbs));
    797801        if (RT_FAILURE(vrc))
    798             return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot convert filename \"%s\" to absolute path: %Rrc", a->argv[0], vrc);
     802            return RTMsgErrorExit(RTEXITCODE_FAILURE, Misc::tr("Cannot convert filename \"%s\" to absolute path: %Rrc"),
     803                                  a->argv[0], vrc);
    799804
    800805        do
    … …  
    820825
    821826    if (a->argc > 2 || a->argc < 1)
    822         return errorSyntax(USAGE_GETEXTRADATA, "Incorrect number of parameters");
     827        return errorSyntax(USAGE_GETEXTRADATA, Misc::tr("Incorrect number of parameters"));
    823828
    824829    /* global data? */
    … …  
    840845                                                        bstrValue.asOutParam()));
    841846
    842                 RTPrintf("Key: %ls, Value: %ls\n", bstrKey.raw(), bstrValue.raw());
     847                RTPrintf(Misc::tr("Key: %ls, Value: %ls\n"), bstrKey.raw(), bstrValue.raw());
    843848            }
    844849        }
    … …  
    849854                                                    value.asOutParam()));
    850855            if (!value.isEmpty())
    851                 RTPrintf("Value: %ls\n", value.raw());
     856                RTPrintf(Misc::tr("Value: %ls\n"), value.raw());
    852857            else
    853                 RTPrintf("No value set!\n");
     858                RTPrintf(Misc::tr("No value set!\n"));
    854859        }
    855860    }
    … …  
    876881                                                      bstrValue.asOutParam()));
    877882
    878                     RTPrintf("Key: %ls, Value: %ls\n", bstrKey.raw(), bstrValue.raw());
     883                    RTPrintf(Misc::tr("Key: %ls, Value: %ls\n"), bstrKey.raw(), bstrValue.raw());
    879884                }
    880885            }
    … …  
    885890                                                  value.asOutParam()));
    886891                if (!value.isEmpty())
    887                     RTPrintf("Value: %ls\n", value.raw());
     892                    RTPrintf(Misc::tr("Value: %ls\n"), value.raw());
    888893                else
    889                     RTPrintf("No value set!\n");
     894                    RTPrintf(Misc::tr("No value set!\n"));
    890895            }
    891896        }
    … …  
    899904
    900905    if (a->argc < 2)
    901         return errorSyntax(USAGE_SETEXTRADATA, "Not enough parameters");
     906        return errorSyntax(USAGE_SETEXTRADATA, Misc::tr("Not enough parameters"));
    902907
    903908    /* global data? */
    … …  
    912917                                                    Bstr(a->argv[2]).raw()));
    913918        else
    914             return errorSyntax(USAGE_SETEXTRADATA, "Too many parameters");
     919            return errorSyntax(USAGE_SETEXTRADATA, Misc::tr("Too many parameters"));
    915920    }
    916921    else
    … …  
    934939                                                         Bstr(a->argv[2]).raw()));
    935940            else
    936                 return errorSyntax(USAGE_SETEXTRADATA, "Too many parameters");
     941                return errorSyntax(USAGE_SETEXTRADATA, Misc::tr("Too many parameters"));
    937942        }
    938943    }
    … …  
    946951    /* there must be two arguments: property name and value */
    947952    if (a->argc != 2)
    948         return errorSyntax(USAGE_SETPROPERTY, "Incorrect number of parameters");
     953        return errorSyntax(USAGE_SETPROPERTY, Misc::tr("Incorrect number of parameters"));
    949954
    950955    ComPtr<ISystemProperties> systemProperties;
    … …  
    968973            fHwVirtExclusive = false;
    969974        else
    970             return errorArgument("Invalid hwvirtexclusive argument '%s'", a->argv[1]);
     975            return errorArgument(Misc::tr("Invalid hwvirtexclusive argument '%s'"), a->argv[1]);
    971976        CHECK_ERROR(systemProperties, COMSETTER(ExclusiveHwVirt)(fHwVirtExclusive));
    972977    }
    … …  
    975980    {
    976981        if (!strcmp(a->argv[0], "vrdpauthlibrary"))
    977             RTStrmPrintf(g_pStdErr, "Warning: 'vrdpauthlibrary' is deprecated. Use 'vrdeauthlibrary'.\n");
     982            RTStrmPrintf(g_pStdErr, Misc::tr("Warning: 'vrdpauthlibrary' is deprecated. Use 'vrdeauthlibrary'.\n"));
    978983
    979984        /* reset to default? */
    … …  
    10051010        vrc = RTStrToUInt32Ex(a->argv[1], NULL, 0, &uVal);
    10061011        if (vrc != VINF_SUCCESS)
    1007             return errorArgument("Error parsing Log history count '%s'", a->argv[1]);
     1012            return errorArgument(Misc::tr("Error parsing Log history count '%s'"), a->argv[1]);
    10081013        CHECK_ERROR(systemProperties, COMSETTER(LogHistoryCount)(uVal));
    10091014    }
    … …  
    10401045            enmProxyMode = ProxyMode_Manual;
    10411046        else
    1042             return errorArgument("Unknown proxy mode: '%s'", a->argv[1]);
     1047            return errorArgument(Misc::tr("Unknown proxy mode: '%s'"), a->argv[1]);
    10431048        CHECK_ERROR(systemProperties, COMSETTER(ProxyMode)(enmProxyMode));
    10441049    }
    … …  
    10711076#endif
    10721077    else
    1073         return errorSyntax(USAGE_SETPROPERTY, "Invalid parameter '%s'", a->argv[0]);
     1078        return errorSyntax(USAGE_SETPROPERTY, Misc::tr("Invalid parameter '%s'"), a->argv[0]);
    10741079
    10751080    return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    … …  
    11341139            case VINF_GETOPT_NOT_OPTION:
    11351140                if (pszMachineName)
    1136                     return errorArgument("Machine name is given more than once: first '%s', then '%s'",
     1141                    return errorArgument(Misc::tr("Machine name is given more than once: first '%s', then '%s'"),
    11371142                                         pszMachineName, ValueUnion.psz);
    11381143                pszMachineName = ValueUnion.psz;
    … …  
    11441149
    11451150    if (!pszMachineName)
    1146         return errorSyntax("No machine was specified");
     1151        return errorSyntax(Misc::tr("No machine was specified"));
    11471152
    11481153    if (!pszName)
    1149         return errorSyntax("No shared folder name (--name) was given");
     1154        return errorSyntax(Misc::tr("No shared folder name (--name) was given"));
    11501155    if (strchr(pszName, ' '))
    1151         return errorSyntax("Invalid shared folder name '%s': contains space", pszName);
     1156        return errorSyntax(Misc::tr("Invalid shared folder name '%s': contains space"), pszName);
    11521157    if (strchr(pszName, '\t'))
    1153         return errorSyntax("Invalid shared folder name '%s': contains tabs", pszName);
     1158        return errorSyntax(Misc::tr("Invalid shared folder name '%s': contains tabs"), pszName);
    11541159    if (strchr(pszName, '\n') || strchr(pszName, '\r'))
    1155         return errorSyntax("Invalid shared folder name '%s': contains newline", pszName);
     1160        return errorSyntax(Misc::tr("Invalid shared folder name '%s': contains newline"), pszName);
    11561161
    11571162    if (!pszHostPath)
    1158         return errorSyntax("No host path (--hostpath) was given");
     1163        return errorSyntax(Misc::tr("No host path (--hostpath) was given"));
    11591164    char szAbsHostPath[RTPATH_MAX];
    11601165    int vrc = RTPathAbs(pszHostPath, szAbsHostPath, sizeof(szAbsHostPath));
    11611166    if (RT_FAILURE(vrc))
    1162         return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTAbsPath failed on '%s': %Rrc", pszHostPath, vrc);
     1167        return RTMsgErrorExit(RTEXITCODE_FAILURE, Misc::tr("RTAbsPath failed on '%s': %Rrc"), pszHostPath, vrc);
    11631168
    11641169    /*
    … …  
    11831188        CHECK_ERROR2I_RET(a->session, COMGETTER(Console)(ptrConsole.asOutParam()), RTEXITCODE_FAILURE);
    11841189        if (ptrConsole.isNull())
    1185             return RTMsgErrorExit(RTEXITCODE_FAILURE, "Machine '%s' is not currently running.", pszMachineName);
     1190            return RTMsgErrorExit(RTEXITCODE_FAILURE, Misc::tr("Machine '%s' is not currently running."), pszMachineName);
    11861191
    11871192        CHECK_ERROR2(hrc, ptrConsole, CreateSharedFolder(Bstr(pszName).raw(), Bstr(szAbsHostPath).raw(),
    … …  
    12461251            case VINF_GETOPT_NOT_OPTION:
    12471252                if (pszMachineName)
    1248                     return errorArgument("Machine name is given more than once: first '%s', then '%s'",
     1253                    return errorArgument(Misc::tr("Machine name is given more than once: first '%s', then '%s'"),
    12491254                                         pszMachineName, ValueUnion.psz);
    12501255                pszMachineName = ValueUnion.psz;
    … …  
    12561261
    12571262    if (!pszMachineName)
    1258         return errorSyntax("No machine was specified");
     1263        return errorSyntax(Misc::tr("No machine was specified"));
    12591264    if (!pszName)
    1260         return errorSyntax("No shared folder name (--name) was given");
     1265        return errorSyntax(Misc::tr("No shared folder name (--name) was given"));
    12611266
    12621267    /*
    … …  
    12791284        CHECK_ERROR2I_RET(a->session, COMGETTER(Console)(ptrConsole.asOutParam()), RTEXITCODE_FAILURE);
    12801285        if (ptrConsole.isNull())
    1281             return RTMsgErrorExit(RTEXITCODE_FAILURE, "Machine '%s' is not currently running.\n", pszMachineName);
     1286            return RTMsgErrorExit(RTEXITCODE_FAILURE, Misc::tr("Machine '%s' is not currently running.\n"), pszMachineName);
    12821287
    12831288        CHECK_ERROR2(hrc, ptrConsole, RemoveSharedFolder(Bstr(pszName).raw()));
    … …  
    13111316{
    13121317    if (a->argc < 1)
    1313         return errorSyntax("Not enough parameters");
     1318        return errorSyntax(Misc::tr("Not enough parameters"));
    13141319
    13151320    if (!strcmp(a->argv[0], "add"))
    … …  
    13701375                case VINF_GETOPT_NOT_OPTION:
    13711376                    if (pszName)
    1372                         return errorSyntax("Too many extension pack names given to \"extpack uninstall\"");
     1377                        return errorSyntax(Misc::tr("Too many extension pack names given to \"extpack uninstall\""));
    13731378                    pszName = ValueUnion.psz;
    13741379                    break;
    … …  
    13791384        }
    13801385        if (!pszName)
    1381             return errorSyntax("No extension pack name was given to \"extpack install\"");
     1386            return errorSyntax(Misc::tr("No extension pack name was given to \"extpack install\""));
    13821387
    13831388        char szPath[RTPATH_MAX];
    13841389        int vrc = RTPathAbs(pszName, szPath, sizeof(szPath));
    13851390        if (RT_FAILURE(vrc))
    1386             return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathAbs(%s,,) failed with rc=%Rrc", pszName, vrc);
     1391            return RTMsgErrorExit(RTEXITCODE_FAILURE, Misc::tr("RTPathAbs(%s,,) failed with rc=%Rrc"), pszName, vrc);
    13871392
    13881393        Bstr bstrTarball(szPath);
    … …  
    14081413            AssertRCStmt(vrc, szDigest[0] = '\0');
    14091414            if (lstLicenseHashes.contains(szDigest))
    1410                 RTPrintf("License accepted.\n");
     1415                RTPrintf(Misc::tr("License accepted.\n"));
    14111416            else
    14121417            {
    14131418                RTPrintf("%s\n", strLicense.c_str());
    1414                 RTPrintf("Do you agree to these license terms and conditions (y/n)? " );
     1419                RTPrintf(Misc::tr("Do you agree to these license terms and conditions (y/n)? "));
    14151420                ch = RTStrmGetCh(g_pStdIn);
    14161421                RTPrintf("\n");
    14171422                if (ch != 'y' && ch != 'Y')
    14181423                {
    1419                     RTPrintf("Installation of \"%ls\" aborted.\n", bstrName.raw());
     1424                    RTPrintf(Misc::tr("Installation of \"%ls\" aborted.\n"), bstrName.raw());
    14201425                    return RTEXITCODE_FAILURE;
    14211426                }
    14221427                if (szDigest[0])
    1423                     RTPrintf("License accepted. For batch installation add\n"
    1424                              "--accept-license=%s\n"
    1425                              "to the VBoxManage command line.\n\n", szDigest);
     1428                    RTPrintf(Misc::tr("License accepted. For batch installation add\n"
     1429                                      "--accept-license=%s\n"
     1430                                      "to the VBoxManage command line.\n\n"), szDigest);
    14261431            }
    14271432        }
    … …  
    14291434        CHECK_ERROR2I_RET(ptrExtPackFile, Install(fReplace, NULL, ptrProgress.asOutParam()), RTEXITCODE_FAILURE);
    14301435        hrc = showProgress(ptrProgress);
    1431         CHECK_PROGRESS_ERROR_RET(ptrProgress, ("Failed to install \"%s\"", szPath), RTEXITCODE_FAILURE);
    1432 
    1433         RTPrintf("Successfully installed \"%ls\".\n", bstrName.raw());
     1436        CHECK_PROGRESS_ERROR_RET(ptrProgress, (Misc::tr("Failed to install \"%s\""), szPath), RTEXITCODE_FAILURE);
     1437
     1438        RTPrintf(Misc::tr("Successfully installed \"%ls\".\n"), bstrName.raw());
    14341439    }
    14351440    else if (!strcmp(a->argv[0], "uninstall"))
    … …  
    14551460                case VINF_GETOPT_NOT_OPTION:
    14561461                    if (pszName)
    1457                         return errorSyntax("Too many extension pack names given to \"extpack uninstall\"");
     1462                        return errorSyntax(Misc::tr("Too many extension pack names given to \"extpack uninstall\""));
    14581463                    pszName = ValueUnion.psz;
    14591464                    break;
    … …  
    14641469        }
    14651470        if (!pszName)
    1466             return errorSyntax("No extension pack name was given to \"extpack uninstall\"");
     1471            return errorSyntax(Misc::tr("No extension pack name was given to \"extpack uninstall\""));
    14671472
    14681473        Bstr bstrName(pszName);
    … …  
    14701475        CHECK_ERROR2I_RET(ptrExtPackMgr, Uninstall(bstrName.raw(), fForced, NULL, ptrProgress.asOutParam()), RTEXITCODE_FAILURE);
    14711476        hrc = showProgress(ptrProgress);
    1472         CHECK_PROGRESS_ERROR_RET(ptrProgress, ("Failed to uninstall \"%s\"", pszName), RTEXITCODE_FAILURE);
    1473 
    1474         RTPrintf("Successfully uninstalled \"%s\".\n", pszName);
     1477        CHECK_PROGRESS_ERROR_RET(ptrProgress, (Misc::tr("Failed to uninstall \"%s\""), pszName), RTEXITCODE_FAILURE);
     1478
     1479        RTPrintf(Misc::tr("Successfully uninstalled \"%s\".\n"), pszName);
    14751480    }
    14761481    else if (!strcmp(a->argv[0], "cleanup"))
    … …  
    14801485            return errorTooManyParameters(&a->argv[1]);
    14811486        CHECK_ERROR2I_RET(ptrExtPackMgr, Cleanup(), RTEXITCODE_FAILURE);
    1482         RTPrintf("Successfully performed extension pack cleanup\n");
     1487        RTPrintf(Misc::tr("Successfully performed extension pack cleanup\n"));
    14831488    }
    14841489    else
    … …  
    15221527                vrc = RTPathAbs(ValueUnion.psz, szIsoPath, sizeof(szIsoPath));
    15231528                if (RT_FAILURE(vrc))
    1524                     return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc);
     1529                    return errorSyntax(Misc::tr("RTPathAbs failed on '%s': %Rrc"), ValueUnion.psz, vrc);
    15251530                break;
    15261531
    … …  
    15381543     */
    15391544    if (szIsoPath[0] == '\0')
    1540         return errorSyntax("No ISO specified");
     1545        return errorSyntax(Misc::tr("No ISO specified"));
    15411546
    15421547    /*
    … …  
    15751580    else
    15761581    {
    1577         RTMsgInfo("Detected '%s' to be:\n", szIsoPath);
    1578         RTPrintf("    OS TypeId    = %ls\n"
    1579                  "    OS Version   = %ls\n"
    1580                  "    OS Flavor    = %ls\n"
    1581                  "    OS Languages = %ls\n"
    1582                  "    OS Hints     = %ls\n",
     1582        RTMsgInfo(Misc::tr("Detected '%s' to be:\n"), szIsoPath);
     1583        RTPrintf(Misc::tr("    OS TypeId    = %ls\n"
     1584                          "    OS Version   = %ls\n"
     1585                          "    OS Flavor    = %ls\n"
     1586                          "    OS Languages = %ls\n"
     1587                          "    OS Hints     = %ls\n"),
    15831588                 bstrDetectedOSTypeId.raw(),
    15841589                 bstrDetectedVersion.raw(),
    … …  
    16571662            case VINF_GETOPT_NOT_OPTION:
    16581663                if (ptrMachine.isNotNull())
    1659                     return errorSyntax("VM name/UUID given more than once!");
     1664                    return errorSyntax(Misc::tr("VM name/UUID given more than once!"));
    16601665                CHECK_ERROR2_RET(hrc, a->virtualBox, FindMachine(Bstr(ValueUnion.psz).raw(), ptrMachine.asOutParam()), RTEXITCODE_FAILURE);
    16611666                CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Machine)(ptrMachine), RTEXITCODE_FAILURE);
    … …  
    16651670                vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath));
    16661671                if (RT_FAILURE(vrc))
    1667                     return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc);
     1672                    return errorSyntax(Misc::tr("RTPathAbs failed on '%s': %Rrc"), ValueUnion.psz, vrc);
    16681673                CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(IsoPath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE);
    16691674                break;
    … …  
    17041709                vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath));
    17051710                if (RT_FAILURE(vrc))
    1706                     return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc);
     1711                    return errorSyntax(Misc::tr("RTPathAbs failed on '%s': %Rrc"), ValueUnion.psz, vrc);
    17071712                CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(AdditionsIsoPath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE);
    17081713                break;
    … …  
    17171722                vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath));
    17181723                if (RT_FAILURE(vrc))
    1719                     return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc);
     1724                    return errorSyntax(Misc::tr("RTPathAbs failed on '%s': %Rrc"), ValueUnion.psz, vrc);
    17201725                CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(ValidationKitIsoPath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE);
    17211726                break;
    … …  
    17521757                vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath));
    17531758                if (RT_FAILURE(vrc))
    1754                     return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc);
     1759                    return errorSyntax(Misc::tr("RTPathAbs failed on '%s': %Rrc"), ValueUnion.psz, vrc);
    17551760                CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(AuxiliaryBasePath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE);
    17561761                break;
    … …  
    17631768                vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath));
    17641769                if (RT_FAILURE(vrc))
    1765                     return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc);
     1770                    return errorSyntax(Misc::tr("RTPathAbs failed on '%s': %Rrc"), ValueUnion.psz, vrc);
    17661771                CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(ScriptTemplatePath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE);
    17671772                break;
    … …  
    17701775                vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath));
    17711776                if (RT_FAILURE(vrc))
    1772                     return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc);
     1777                    return errorSyntax(Misc::tr("RTPathAbs failed on '%s': %Rrc"), ValueUnion.psz, vrc);
    17731778                CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(PostInstallScriptTemplatePath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE);
    17741779                break;
    … …  
    17991804     */
    18001805    if (ptrMachine.isNull())
    1801         return errorSyntax("Missing VM name/UUID");
     1806        return errorSyntax(Misc::tr("Missing VM name/UUID"));
    18021807
    18031808    /*
    … …  
    18511856            return RTEXITCODE_FAILURE;
    18521857        if (ptrConsole.isNotNull())
    1853             return RTMsgErrorExit(RTEXITCODE_FAILURE, "Machine '%ls' is currently running", bstrMachineName.raw());
     1858            return RTMsgErrorExit(RTEXITCODE_FAILURE, Misc::tr("Machine '%ls' is currently running"), bstrMachineName.raw());
    18541859    }
    18551860
    … …  
    18571862     * Do the work.
    18581863     */
    1859     RTMsgInfo("%s unattended installation of %s in machine '%ls' (%ls).\n",
    1860               RTStrICmp(pszSessionType, "none") == 0 ? "Preparing" : "Starting",
     1864    RTMsgInfo(Misc::tr("%s unattended installation of %s in machine '%ls' (%ls).\n"),
     1865              RTStrICmp(pszSessionType, "none") == 0 ? Misc::tr("Preparing") : Misc::tr("Starting"),
    18611866              strInstalledOS.c_str(), bstrMachineName.raw(), bstrUuid.raw());
    18621867
    … …  
    18711876     * Retrieve and display the parameters actually used.
    18721877     */
    1873     RTMsgInfo("Using values:\n");
     1878    RTMsgInfo(Misc::tr("Using values:\n"));
    18741879#define SHOW_ATTR(a_Attr, a_szText, a_Type, a_szFmt) do { \
    18751880            a_Type Value; \
    … …  
    18781883                RTPrintf("  %32s = " a_szFmt "\n", a_szText, Value); \
    18791884            else \
    1880                 RTPrintf("  %32s = failed: %Rhrc\n", a_szText, hrc2); \
     1885                RTPrintf(Misc::tr("  %32s = failed: %Rhrc\n"), a_szText, hrc2); \
    18811886        } while (0)
    18821887#define SHOW_STR_ATTR(a_Attr, a_szText) do { \
    … …  
    18861891                RTPrintf("  %32s = %ls\n", a_szText, bstrString.raw()); \
    18871892            else \
    1888                 RTPrintf("  %32s = failed: %Rhrc\n", a_szText, hrc2); \
     1893                RTPrintf(Misc::tr("  %32s = failed: %Rhrc\n"), a_szText, hrc2); \
    18891894        } while (0)
    18901895
    … …  
    19301935    {
    19311936        if (!fDryRun)
    1932             RTMsgInfo("VM '%ls' (%ls) is ready to be started (e.g. VBoxManage startvm).\n", bstrMachineName.raw(), bstrUuid.raw());
     1937            RTMsgInfo(Misc::tr("VM '%ls' (%ls) is ready to be started (e.g. VBoxManage startvm).\n"), bstrMachineName.raw(), bstrUuid.raw());
    19331938        hrc = S_OK;
    19341939    }
    … …  
    19491954        if (SUCCEEDED(hrc) && !ptrProgress.isNull())
    19501955        {
    1951             RTMsgInfo("Waiting for VM '%ls' to power on...\n", bstrMachineName.raw());
     1956            RTMsgInfo(Misc::tr("Waiting for VM '%ls' to power on...\n"), bstrMachineName.raw());
    19521957            CHECK_ERROR2(hrc, ptrProgress, WaitForCompletion(-1));
    19531958            if (SUCCEEDED(hrc))
    … …  
    19641969                    {
    19651970                        if (SUCCEEDED(iRc))
    1966                             RTMsgInfo("VM '%ls' (%ls) has been successfully started.\n", bstrMachineName.raw(), bstrUuid.raw());
     1971                            RTMsgInfo(Misc::tr("VM '%ls' (%ls) has been successfully started.\n"),
     1972                                      bstrMachineName.raw(), bstrUuid.raw());
    19671973                        else
    19681974                        {
    … …  
    20952101    /* check for required options */
    20962102    if (bstrProvider.isEmpty())
    2097         return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --provider is required");
     2103        return errorSyntax(USAGE_CLOUDPROFILE, Misc::tr("Parameter --provider is required"));
    20982104    if (bstrProfile.isEmpty())
    2099         return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --profile is required");
     2105        return errorSyntax(USAGE_CLOUDPROFILE, Misc::tr("Parameter --profile is required"));
    21002106
    21012107    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
    … …  
    21262132    CHECK_ERROR2(hrc, pCloudProvider, SaveProfiles());
    21272133
    2128     RTPrintf("Provider %ls: profile '%ls' was updated.\n",bstrProvider.raw(), bstrProfile.raw());
     2134    RTPrintf(Misc::tr("Provider %ls: profile '%ls' was updated.\n"),bstrProvider.raw(), bstrProfile.raw());
    21292135
    21302136    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    … …  
    21452151    /* check for required options */
    21462152    if (bstrProvider.isEmpty())
    2147         return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --provider is required");
     2153        return errorSyntax(USAGE_CLOUDPROFILE, Misc::tr("Parameter --provider is required"));
    21482154    if (bstrProfile.isEmpty())
    2149         return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --profile is required");
     2155        return errorSyntax(USAGE_CLOUDPROFILE, Misc::tr("Parameter --profile is required"));
    21502156
    21512157    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
    … …  
    21682174        Bstr bstrProviderID;
    21692175        pCloudProfile->COMGETTER(ProviderId)(bstrProviderID.asOutParam());
    2170         RTPrintf("Provider GUID: %ls\n", bstrProviderID.raw());
     2176        RTPrintf(Misc::tr("Provider GUID: %ls\n"), bstrProviderID.raw());
    21712177
    21722178        com::SafeArray<BSTR> names;
    … …  
    21842190                value = values[k];
    21852191            RTPrintf("%s%ls=%ls\n",
    2186                      fFirst ? "Property:      " : "               ",
     2192                     fFirst ? Misc::tr("Property:      ") : "               ",
    21872193                     names[k], value.raw());
    21882194            fFirst = false;
    … …  
    22052211    /* check for required options */
    22062212    if (bstrProvider.isEmpty())
    2207         return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --provider is required");
     2213        return errorSyntax(USAGE_CLOUDPROFILE, Misc::tr("Parameter --provider is required"));
    22082214    if (bstrProfile.isEmpty())
    2209         return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --profile is required");
     2215        return errorSyntax(USAGE_CLOUDPROFILE, Misc::tr("Parameter --profile is required"));
    22102216
    22112217    /*
    … …  
    22892295    CHECK_ERROR2(hrc, pCloudProvider, SaveProfiles());
    22902296
    2291     RTPrintf("Provider %ls: profile '%ls' was added.\n",bstrProvider.raw(), bstrProfile.raw());
     2297    RTPrintf(Misc::tr("Provider %ls: profile '%ls' was added.\n"),bstrProvider.raw(), bstrProfile.raw());
    22922298
    22932299    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    … …  
    23032309    /* check for required options */
    23042310    if (bstrProvider.isEmpty())
    2305         return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --provider is required");
     2311        return errorSyntax(USAGE_CLOUDPROFILE, Misc::tr("Parameter --provider is required"));
    23062312    if (bstrProfile.isEmpty())
    2307         return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --profile is required");
     2313        return errorSyntax(USAGE_CLOUDPROFILE, Misc::tr("Parameter --profile is required"));
    23082314
    23092315    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
    … …  
    23322338                         RTEXITCODE_FAILURE);
    23332339
    2334         RTPrintf("Provider %ls: profile '%ls' was deleted.\n",bstrProvider.raw(), bstrProfile.raw());
     2340        RTPrintf(Misc::tr("Provider %ls: profile '%ls' was deleted.\n"), bstrProvider.raw(), bstrProfile.raw());
    23352341    }
    23362342

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyNvram.cpp

    r91685 r92372  
    4242using namespace com;
    4343
     44DECLARE_TRANSLATION_CONTEXT(Nvram);
    4445
    4546// funcs
    … …  
    120121
    121122    if (!pszPlatformKey)
    122         return errorSyntax("No platform key file path was given to \"enrollpk\"");
     123        return errorSyntax(Nvram::tr("No platform key file path was given to \"enrollpk\""));
    123124    if (!pszOwnerUuid)
    124         return errorSyntax("No owner UUID was given to \"enrollpk\"");
     125        return errorSyntax(Nvram::tr("No owner UUID was given to \"enrollpk\""));
    125126
    126127    RTFILE hPkFile;
    … …  
    146147                }
    147148                else
    148                     RTMsgError("Cannot read contents of file \"%s\": %Rrc", pszPlatformKey, vrc);
     149                    RTMsgError(Nvram::tr("Cannot read contents of file \"%s\": %Rrc"), pszPlatformKey, vrc);
    149150            }
    150151            else
    151                 RTMsgError("File \"%s\" is bigger than 32KByte", pszPlatformKey);
     152                RTMsgError(Nvram::tr("File \"%s\" is bigger than 32KByte"), pszPlatformKey);
    152153        }
    153154        else
    154             RTMsgError("Cannot get size of file \"%s\": %Rrc", pszPlatformKey, vrc);
     155            RTMsgError(Nvram::tr("Cannot get size of file \"%s\": %Rrc"), pszPlatformKey, vrc);
    155156
    156157        RTFileClose(hPkFile);
    157158    }
    158159    else
    159         RTMsgError("Cannot open file \"%s\": %Rrc", pszPlatformKey, vrc);
     160        RTMsgError(Nvram::tr("Cannot open file \"%s\": %Rrc"), pszPlatformKey, vrc);
    160161
    161162    return RTEXITCODE_FAILURE;
    … …  
    249250
    250251    if (!pszVarName)
    251         return errorSyntax("No variable name was given to \"queryvar\"");
     252        return errorSyntax(Nvram::tr("No variable name was given to \"queryvar\""));
    252253
    253254    ComPtr<IUefiVariableStore> uefiVarStore;
    … …  
    276277            vrc = RTFileWrite(hFile, aData.raw(), aData.size(), NULL /*pcbWritten*/);
    277278            if (RT_FAILURE(vrc))
    278                 rcExit = RTMsgErrorExitFailure("Error writing to '%s': %Rrc", pszVarDataFilename, vrc);
     279                rcExit = RTMsgErrorExitFailure(Nvram::tr("Error writing to '%s': %Rrc"), pszVarDataFilename, vrc);
    279280
    280281            RTFileClose(hFile);
    281282        }
    282283        else
    283            rcExit = RTMsgErrorExitFailure("Error opening '%s': %Rrc", pszVarDataFilename, vrc);
     284           rcExit = RTMsgErrorExitFailure(Nvram::tr("Error opening '%s': %Rrc"), pszVarDataFilename, vrc);
    284285    }
    285286
    … …  
    328329
    329330    if (!pszVarName)
    330         return errorSyntax("No variable name was given to \"deletevar\"");
     331        return errorSyntax(Nvram::tr("No variable name was given to \"deletevar\""));
    331332    if (!pszOwnerUuid)
    332         return errorSyntax("No owner UUID was given to \"deletevar\"");
     333        return errorSyntax(Nvram::tr("No owner UUID was given to \"deletevar\""));
    333334
    334335    ComPtr<IUefiVariableStore> uefiVarStore;
    … …  
    380381
    381382    if (!pszVarName)
    382         return errorSyntax("No variable name was given to \"changevar\"");
     383        return errorSyntax(Nvram::tr("No variable name was given to \"changevar\""));
    383384    if (!pszVarDataFilename)
    384         return errorSyntax("No variable data filename was given to \"changevar\"");
     385        return errorSyntax(Nvram::tr("No variable data filename was given to \"changevar\""));
    385386
    386387    RTFILE hFile = NIL_RTFILE;
    … …  
    406407            }
    407408            else
    408                 rcExit = RTMsgErrorExitFailure("Error reading from '%s': %Rrc", pszVarDataFilename, vrc);
     409                rcExit = RTMsgErrorExitFailure(Nvram::tr("Error reading from '%s': %Rrc"), pszVarDataFilename, vrc);
    409410        }
    410411    }
    411412    else
    412        rcExit = RTMsgErrorExitFailure("Error opening '%s': %Rrc", pszVarDataFilename, vrc);
     413       rcExit = RTMsgErrorExitFailure(Nvram::tr("Error opening '%s': %Rrc"), pszVarDataFilename, vrc);
    413414
    414415    return rcExit;
    … …  
    497498
    498499#endif /* !VBOX_ONLY_DOCS */
    499 

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp

    r92133 r92372  
    3939#include "VBoxManage.h"
    4040#include "VBoxManageUtils.h"
     41
     42DECLARE_TRANSLATION_CONTEXT(ModifyVM);
    4143
    4244#ifndef VBOX_ONLY_DOCS
    … …  
    460462static void vrdeWarningDeprecatedOption(const char *pszOption)
    461463{
    462     RTStrmPrintf(g_pStdErr, "Warning: '--vrdp%s' is deprecated. Use '--vrde%s'.\n", pszOption, pszOption);
     464    RTStrmPrintf(g_pStdErr, ModifyVM::tr("Warning: '--vrdp%s' is deprecated. Use '--vrde%s'.\n"), pszOption, pszOption);
    463465}
    464466
    … …  
    536538        && uIndex <= cMaxIndex)
    537539        return uIndex;
    538     errorArgument("Invalid %s number %u", pszName, uIndex);
     540    errorArgument(ModifyVM::tr("Invalid %s number %u"), pszName, uIndex);
    539541    return 0;
    540542}
    … …  
    565567     * individually. */
    566568    if (a->argc < 2)
    567         return errorSyntax(USAGE_MODIFYVM, "Not enough parameters");
     569        return errorSyntax(USAGE_MODIFYVM, ModifyVM::tr("Not enough parameters"));
    568570
    569571    /* try to find the given sessionMachine */
    … …  
    628630                if (RT_FAILURE(vrc))
    629631                {
    630                     RTMsgError("Cannot open file \"%s\": %Rrc", ValueUnion.psz, vrc);
     632                    RTMsgError(ModifyVM::tr("Cannot open file \"%s\": %Rrc"), ValueUnion.psz, vrc);
    631633                    rc = E_FAIL;
    632634                    break;
    … …  
    636638                if (RT_FAILURE(vrc))
    637639                {
    638                     RTMsgError("Cannot get size of file \"%s\": %Rrc", ValueUnion.psz, vrc);
     640                    RTMsgError(ModifyVM::tr("Cannot get size of file \"%s\": %Rrc"), ValueUnion.psz, vrc);
    639641                    rc = E_FAIL;
    640642                    break;
    … …  
    642644                if (cbSize > _256K)
    643645                {
    644                     RTMsgError("File \"%s\" is bigger than 256KByte", ValueUnion.psz);
     646                    RTMsgError(ModifyVM::tr("File \"%s\" is bigger than 256KByte"), ValueUnion.psz);
    645647                    rc = E_FAIL;
    646648                    break;
    … …  
    650652                if (RT_FAILURE(vrc))
    651653                {
    652                     RTMsgError("Cannot read contents of file \"%s\": %Rrc", ValueUnion.psz, vrc);
     654                    RTMsgError(ModifyVM::tr("Cannot read contents of file \"%s\": %Rrc"), ValueUnion.psz, vrc);
    653655                    rc = E_FAIL;
    654656                    break;
    … …  
    701703                else
    702704                {
    703                     errorArgument("Invalid --firmware argument '%s'", ValueUnion.psz);
     705                    errorArgument(ModifyVM::tr("Invalid --firmware argument '%s'"), ValueUnion.psz);
    704706                    rc = E_FAIL;
    705707                }
    … …  
    772774                else
    773775                {
    774                     errorArgument("Invalid --paravirtprovider argument '%s'", ValueUnion.psz);
     776                    errorArgument(ModifyVM::tr("Invalid --paravirtprovider argument '%s'"), ValueUnion.psz);
    775777                    rc = E_FAIL;
    776778                }
    … …  
    800802                    int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX);
    801803                    if (RT_FAILURE(vrc))
    802                         return errorSyntax(USAGE_MODIFYVM, "Missing or Invalid argument to '%s'", GetOptState.pDef->pszLong);
     804                        return errorSyntax(USAGE_MODIFYVM, ModifyVM::tr("Missing or Invalid argument to '%s'"),
     805                                           GetOptState.pDef->pszLong);
    803806                    aValue[i] = ValueUnion.u32;
    804807                }
    … …  
    943946                else
    944947                {
    945                     errorArgument("Invalid --graphicscontroller argument '%s'", ValueUnion.psz);
     948                    errorArgument(ModifyVM::tr("Invalid --graphicscontroller argument '%s'"), ValueUnion.psz);
    946949                    rc = E_FAIL;
    947950                }
    … …  
    10091012                else
    10101013                {
    1011                     errorArgument("Invalid --biosbootmenu argument '%s'", ValueUnion.psz);
     1014                    errorArgument(ModifyVM::tr("Invalid --biosbootmenu argument '%s'"), ValueUnion.psz);
    10121015                    rc = E_FAIL;
    10131016                }
    … …  
    10331036                else
    10341037                {
    1035                     errorArgument("Invalid --biosapic argument '%s'", ValueUnion.psz);
     1038                    errorArgument(ModifyVM::tr("Invalid --biosapic argument '%s'"), ValueUnion.psz);
    10361039                    rc = E_FAIL;
    10371040                }
    … …  
    10801083                }
    10811084                else
    1082                     return errorArgument("Invalid boot device '%s'", ValueUnion.psz);
     1085                    return errorArgument(ModifyVM::tr("Invalid boot device '%s'"), ValueUnion.psz);
    10831086                break;
    10841087            }
    … …  
    11601163                else
    11611164                {
    1162                     errorArgument("Invalid --idecontroller argument '%s'", ValueUnion.psz);
     1165                    errorArgument(ModifyVM::tr("Invalid --idecontroller argument '%s'"), ValueUnion.psz);
    11631166                    rc = E_FAIL;
    11641167                }
    … …  
    11901193                    CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("SATA").raw()));
    11911194                else
    1192                     return errorArgument("Invalid --usb argument '%s'", ValueUnion.psz);
     1195                    return errorArgument(ModifyVM::tr("Invalid --usb argument '%s'"), ValueUnion.psz);
    11931196                break;
    11941197            }
    … …  
    12651268                }
    12661269                else
    1267                     return errorArgument("Invalid --scsitype argument '%s'", ValueUnion.psz);
     1270                    return errorArgument(ModifyVM::tr("Invalid --scsitype argument '%s'"), ValueUnion.psz);
    12681271                break;
    12691272            }
    … …  
    13201323                        if (RT_FAILURE(RTPathReal(ValueUnion.psz + 5, szPathReal, sizeof(szPathReal))))
    13211324                        {
    1322                             errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
     1325                            errorArgument(ModifyVM::tr("Invalid host DVD drive name \"%s\""), ValueUnion.psz + 5);
    13231326                            rc = E_FAIL;
    13241327                            break;
    … …  
    13281331                        if (!dvdMedium)
    13291332                        {
    1330                             errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
     1333                            errorArgument(ModifyVM::tr("Invalid host DVD drive name \"%s\""), ValueUnion.psz + 5);
    13311334                            rc = E_FAIL;
    13321335                            break;
    … …  
    13941397                        if (!floppyMedium)
    13951398                        {
    1396                             errorArgument("Invalid host floppy drive name \"%s\"", ValueUnion.psz + 5);
     1399                            errorArgument(ModifyVM::tr("Invalid host floppy drive name \"%s\""), ValueUnion.psz + 5);
    13971400                            rc = E_FAIL;
    13981401                            break;
    … …  
    14741477                        else
    14751478                        {
    1476                             errorArgument("Invalid --nicproperty%d argument '%s'", GetOptState.uIndex, ValueUnion.psz);
     1479                            errorArgument(ModifyVM::tr("Invalid --nicproperty%d argument '%s'"), GetOptState.uIndex, ValueUnion.psz);
    14771480                            rc = E_FAIL;
    14781481                        }
    … …  
    14811484                    else
    14821485                    {
    1483                         RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for --nicproperty%d '%s'\n", GetOptState.uIndex, ValueUnion.psz);
     1486                        RTStrmPrintf(g_pStdErr, ModifyVM::tr("Error: Failed to allocate memory for --nicproperty%d '%s'\n"),
     1487                                     GetOptState.uIndex, ValueUnion.psz);
    14841488                        rc = E_FAIL;
    14851489                    }
    … …  
    15361540                else
    15371541                {
    1538                     errorArgument("Invalid NIC type '%s' specified for NIC %u", ValueUnion.psz, GetOptState.uIndex);
     1542                    errorArgument(ModifyVM::tr("Invalid NIC type '%s' specified for NIC %u"),
     1543                                  ValueUnion.psz, GetOptState.uIndex);
    15391544                    rc = E_FAIL;
    15401545                }
    … …  
    15701575                if (ValueUnion.u32 > 4)
    15711576                {
    1572                     errorArgument("Invalid boot priority '%u' specfied for NIC %u", ValueUnion.u32, GetOptState.uIndex);
     1577                    errorArgument(ModifyVM::tr("Invalid boot priority '%u' specfied for NIC %u"), ValueUnion.u32, GetOptState.uIndex);
    15731578                    rc = E_FAIL;
    15741579                }
    … …  
    15921597                else
    15931598                {
    1594                     errorArgument("Unknown promiscuous mode policy '%s'", ValueUnion.psz);
     1599                    errorArgument(ModifyVM::tr("Unknown promiscuous mode policy '%s'"), ValueUnion.psz);
    15951600                    rc = E_INVALIDARG;
    15961601                    break;
    … …  
    17191724                else
    17201725                {
    1721                     errorArgument("Invalid type '%s' specfied for NIC %u", ValueUnion.psz, GetOptState.uIndex);
     1726                    errorArgument(ModifyVM::tr("Invalid type '%s' specfied for NIC %u"), ValueUnion.psz, GetOptState.uIndex);
    17221727                    rc = E_FAIL;
    17231728                }
    … …  
    18901895            }
    18911896
    1892 #define ITERATE_TO_NEXT_TERM(ch)                                           \
    1893     do {                                                                   \
    1894         while (*ch != ',')                                                 \
    1895         {                                                                  \
    1896             if (*ch == 0)                                                  \
    1897             {                                                              \
    1898                 return errorSyntax(USAGE_MODIFYVM,                         \
    1899                                    "Missing or Invalid argument to '%s'",  \
    1900                                     GetOptState.pDef->pszLong);            \
    1901             }                                                              \
    1902             ch++;                                                          \
    1903         }                                                                  \
    1904         *ch = '\0';                                                        \
    1905         ch++;                                                              \
     1897#define ITERATE_TO_NEXT_TERM(ch)                                                         \
     1898    do {                                                                                 \
     1899        while (*ch != ',')                                                               \
     1900        {                                                                                \
     1901            if (*ch == 0)                                                                \
     1902            {                                                                            \
     1903                return errorSyntax(USAGE_MODIFYVM,                                       \
     1904                                   ModifyVM::tr("Missing or Invalid argument to '%s'"),  \
     1905                                    GetOptState.pDef->pszLong);                          \
     1906            }                                                                            \
     1907            ch++;                                                                        \
     1908        }                                                                                \
     1909        *ch = '\0';                                                                      \
     1910        ch++;                                                                            \
    19061911    } while(0)
    19071912
    … …  
    19811986                    else
    19821987                    {
    1983                         errorArgument("Invalid proto '%s' specfied for NIC %u", ValueUnion.psz, GetOptState.uIndex);
     1988                        errorArgument(ModifyVM::tr("Invalid proto '%s' specfied for NIC %u"), ValueUnion.psz, GetOptState.uIndex);
    19841989                        rc = E_FAIL;
    19851990                        break;
    … …  
    19972002                    vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
    19982003                    if (RT_FAILURE(vrc))
    1999                         return errorSyntax(USAGE_MODIFYVM, "Not enough parameters");
     2004                        return errorSyntax(USAGE_MODIFYVM, ModifyVM::tr("Not enough parameters"));
    20002005                    CHECK_ERROR(engine, RemoveRedirect(Bstr(ValueUnion.psz).raw()));
    20012006                }
    … …  
    21992204                else
    22002205                {
    2201                     errorArgument("Invalid type '%s' specfied for pointing device", ValueUnion.psz);
     2206                    errorArgument(ModifyVM::tr("Invalid type '%s' specfied for pointing device"), ValueUnion.psz);
    22022207                    rc = E_FAIL;
    22032208                }
    … …  
    22442249                else
    22452250                {
    2246                     errorArgument("Invalid type '%s' specfied for keyboard", ValueUnion.psz);
     2251                    errorArgument(ModifyVM::tr("Invalid type '%s' specfied for keyboard"), ValueUnion.psz);
    22472252                    rc = E_FAIL;
    22482253                }
    … …  
    22902295                    if (RT_FAILURE(vrc))
    22912296                        return errorSyntax(USAGE_MODIFYVM,
    2292                                            "Missing or Invalid argument to '%s'",
     2297                                           ModifyVM::tr("Missing or Invalid argument to '%s'"),
    22932298                                           GetOptState.pDef->pszLong);
    22942299
    … …  
    23492354                else
    23502355                    return errorSyntax(USAGE_MODIFYVM,
    2351                                        "Invalid argument to '%s'",
     2356                                       ModifyVM::tr("Invalid argument to '%s'"),
    23522357                                       GetOptState.pDef->pszLong);
    23532358                break;
    … …  
    23712376                    if (RT_FAILURE(vrc))
    23722377                        return errorSyntax(USAGE_MODIFYVM,
    2373                                            "Missing or Invalid argument to '%s'",
     2378                                           ModifyVM::tr("Missing or Invalid argument to '%s'"),
    23742379                                           GetOptState.pDef->pszLong);
    23752380
    … …  
    23782383                    vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
    23792384                    if (vrc != VINF_SUCCESS || uVal == 0)
    2380                         return errorArgument("Error parsing UART I/O base '%s'", pszIOBase);
     2385                        return errorArgument(ModifyVM::tr("Error parsing UART I/O base '%s'"), pszIOBase);
    23812386                    CHECK_ERROR(uart, COMSETTER(IOBase)(uVal));
    23822387
    … …  
    24152420                    if (RT_FAILURE(vrc))
    24162421                        return errorSyntax(USAGE_MODIFYVM,
    2417                                            "Missing or Invalid argument to '%s'",
     2422                                           ModifyVM::tr("Missing or Invalid argument to '%s'"),
    24182423                                           GetOptState.pDef->pszLong);
    24192424
    … …  
    24222427                    vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
    24232428                    if (vrc != VINF_SUCCESS || uVal == 0)
    2424                         return errorArgument("Error parsing LPT I/O base '%s'", pszIOBase);
     2429                        return errorArgument(ModifyVM::tr("Error parsing LPT I/O base '%s'"), pszIOBase);
    24252430                    CHECK_ERROR(lpt, COMSETTER(IOBase)(uVal));
    24262431
    … …  
    24512456                else
    24522457                {
    2453                     errorArgument("Invalid --audiocontroller argument '%s'", ValueUnion.psz);
     2458                    errorArgument(ModifyVM::tr("Invalid --audiocontroller argument '%s'"), ValueUnion.psz);
    24542459                    rc = E_FAIL;
    24552460                }
    … …  
    24732478                else
    24742479                {
    2475                     errorArgument("Invalid --audiocodec argument '%s'", ValueUnion.psz);
     2480                    errorArgument(ModifyVM::tr("Invalid --audiocodec argument '%s'"), ValueUnion.psz);
    24762481                    rc = E_FAIL;
    24772482                }
    … …  
    25452550                else
    25462551                {
    2547                     errorArgument("Invalid --audio argument '%s'", ValueUnion.psz);
     2552                    errorArgument(ModifyVM::tr("Invalid --audio argument '%s'"), ValueUnion.psz);
    25482553                    rc = E_FAIL;
    25492554                }
    … …  
    25852590                else
    25862591                {
    2587                     errorArgument("Invalid --clipboard-mode argument '%s'", ValueUnion.psz);
     2592                    errorArgument(ModifyVM::tr("Invalid --clipboard-mode argument '%s'"), ValueUnion.psz);
    25882593                    rc = E_FAIL;
    25892594                }
    … …  
    26052610                else
    26062611                {
    2607                     errorArgument("Invalid --clipboard-file-transfers argument '%s'", ValueUnion.psz);
     2612                    errorArgument(ModifyVM::tr("Invalid --clipboard-file-transfers argument '%s'"), ValueUnion.psz);
    26082613                    rc = E_FAIL;
    26092614                }
    … …  
    26302635                else
    26312636                {
    2632                     errorArgument("Invalid --draganddrop argument '%s'", ValueUnion.psz);
     2637                    errorArgument(ModifyVM::tr("Invalid --draganddrop argument '%s'"), ValueUnion.psz);
    26332638                    rc = E_FAIL;
    26342639                }
    … …  
    26842689                            RTStrFree(pszProperty);
    26852690
    2686                             errorArgument("Invalid --vrdeproperty argument '%s'", ValueUnion.psz);
     2691                            errorArgument(ModifyVM::tr("Invalid --vrdeproperty argument '%s'"), ValueUnion.psz);
    26872692                            rc = E_FAIL;
    26882693                            break;
    … …  
    26922697                    else
    26932698                    {
    2694                         RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for VRDE property '%s'\n", ValueUnion.psz);
     2699                        RTStrmPrintf(g_pStdErr, ModifyVM::tr("Error: Failed to allocate memory for VRDE property '%s'\n"),
     2700                                     ValueUnion.psz);
    26952701                        rc = E_FAIL;
    26962702                    }
    … …  
    27532759                else
    27542760                {
    2755                     errorArgument("Invalid --vrdeauthtype argument '%s'", ValueUnion.psz);
     2761                    errorArgument(ModifyVM::tr("Invalid --vrdeauthtype argument '%s'"), ValueUnion.psz);
    27562762                    rc = E_FAIL;
    27572763                }
    … …  
    28512857                if (RT_FAILURE(vrc))
    28522858                    return errorSyntax(USAGE_MODIFYVM,
    2853                                        "Missing or Invalid argument to '%s'",
     2859                                       ModifyVM::tr("Missing or Invalid argument to '%s'"),
    28542860                                       GetOptState.pDef->pszLong);
    28552861                const char *pszNewName = ValueUnion.psz;
    … …  
    28722878                if (!fRenamed)
    28732879                {
    2874                     errorArgument("Invalid --usbrename parameters, nothing renamed");
     2880                    errorArgument(ModifyVM::tr("Invalid --usbrename parameters, nothing renamed"));
    28752881                    rc = E_FAIL;
    28762882                }
    … …  
    30763082                    if (!fIoApic)
    30773083                    {
    3078                         RTStrmPrintf(g_pStdErr, "*** I/O APIC must be enabled for ICH9, enabling. ***\n");
     3084                        RTStrmPrintf(g_pStdErr, ModifyVM::tr("*** I/O APIC must be enabled for ICH9, enabling. ***\n"));
    30793085                        CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(TRUE));
    30803086                    }
    … …  
    30823088                else
    30833089                {
    3084                     errorArgument("Invalid --chipset argument '%s' (valid: piix3,ich9)", ValueUnion.psz);
     3090                    errorArgument(ModifyVM::tr("Invalid --chipset argument '%s' (valid: piix3,ich9)"), ValueUnion.psz);
    30853091                    rc = E_FAIL;
    30863092                }
    … …  
    31003106                    CHECK_ERROR(sessionMachine, COMSETTER(IommuType)(IommuType_Intel));
    31013107#else
    3102                     errorArgument("Invalid --iommu argument '%s' (valid: none,amd,automatic)", ValueUnion.psz);
     3108                    errorArgument(ModifyVM::tr("Invalid --iommu argument '%s' (valid: none,amd,automatic)"), ValueUnion.psz);
    31033109                    rc = E_FAIL;
    31043110#endif
    … …  
    31093115#ifndef VBOX_WITH_IOMMU_INTEL
    31103116                    RTStrmPrintf(g_pStdErr,
    3111                                  "Warning: On Intel hosts, 'automatic' will not enable an IOMMU since the Intel IOMMU device is not supported yet.\n");
     3117                                 ModifyVM::tr("Warning: On Intel hosts, 'automatic' will not enable an IOMMU since the Intel IOMMU device is not supported yet.\n"));
    31123118#endif
    31133119                }
    31143120                else
    31153121                {
    3116                     errorArgument("Invalid --iommu argument '%s'", ValueUnion.psz);
     3122                    errorArgument(ModifyVM::tr("Invalid --iommu argument '%s'"), ValueUnion.psz);
    31173123                    rc = E_FAIL;
    31183124                }
    … …  
    31393145                else
    31403146                {
    3141                     errorArgument("Invalid --tpm-type argument '%s'", ValueUnion.psz);
     3147                    errorArgument(ModifyVM::tr("Invalid --tpm-type argument '%s'"), ValueUnion.psz);
    31423148                    rc = E_FAIL;
    31433149                }
    … …  
    31963202                        if (parseScreens(ValueUnion.psz, &screens))
    31973203                        {
    3198                             errorArgument("Invalid list of screens specified\n");
     3204                            errorArgument(ModifyVM::tr("Invalid list of screens specified\n"));
    31993205                            rc = E_FAIL;
    32003206                            break;
    … …  
    32183224                            if (RT_FAILURE(vrc))
    32193225                            {
    3220                                 errorArgument("Cannot convert filename \"%s\" to absolute path\n", ValueUnion.psz);
     3226                                errorArgument(ModifyVM::tr("Cannot convert filename \"%s\" to absolute path\n"), ValueUnion.psz);
    32213227                                rc = E_FAIL;
    32223228                                break;
    … …  
    32483254                        if (RT_FAILURE(vrc) || vrc != VWRN_TRAILING_CHARS || !pszNext || *pszNext != 'x')
    32493255                        {
    3250                             errorArgument("Error parsing video resolution '%s' (expected <width>x<height>)", ValueUnion.psz);
     3256                            errorArgument(ModifyVM::tr("Error parsing video resolution '%s' (expected <width>x<height>)"),
     3257                                          ValueUnion.psz);
    32513258                            rc = E_FAIL;
    32523259                            break;
    … …  
    32563263                        if (vrc != VINF_SUCCESS)
    32573264                        {
    3258                             errorArgument("Error parsing video resolution '%s' (expected <width>x<height>)", ValueUnion.psz);
     3265                            errorArgument(ModifyVM::tr("Error parsing video resolution '%s' (expected <width>x<height>)"),
     3266                                          ValueUnion.psz);
    32593267                            rc = E_FAIL;
    32603268                            break;
    … …  
    33303338                else
    33313339                {
    3332                     errorArgument("Invalid --autostop-type argument '%s' (valid: disabled, savestate, poweroff, acpishutdown)", ValueUnion.psz);
     3340                    errorArgument(ModifyVM::tr("Invalid --autostop-type argument '%s' (valid: disabled, savestate, poweroff, acpishutdown)"),
     3341                                  ValueUnion.psz);
    33333342                    rc = E_FAIL;
    33343343                }
    … …  
    33493358                if (iHostAddr == -1 || iGuestAddr == -1)
    33503359                {
    3351                     errorArgument("Invalid --pciattach argument '%s' (valid: 'HB:HD.HF@GB:GD.GF' or just 'HB:HD.HF')", ValueUnion.psz);
     3360                    errorArgument(ModifyVM::tr("Invalid --pciattach argument '%s' (valid: 'HB:HD.HF@GB:GD.GF' or just 'HB:HD.HF')"),
     3361                                  ValueUnion.psz);
    33523362                    rc = E_FAIL;
    33533363                }
    … …  
    33663376                if (iHostAddr == -1)
    33673377                {
    3368                     errorArgument("Invalid --pcidetach argument '%s' (valid: 'HB:HD.HF')", ValueUnion.psz);
     3378                    errorArgument(ModifyVM::tr("Invalid --pcidetach argument '%s' (valid: 'HB:HD.HF')"), ValueUnion.psz);
    33693379                    rc = E_FAIL;
    33703380                }
    … …  
    34003410                if (enmPriority == VMProcPriority_Invalid)
    34013411                {
    3402                     errorArgument("Invalid --vm-process-priority '%s'", ValueUnion.psz);
     3412                    errorArgument(ModifyVM::tr("Invalid --vm-process-priority '%s'"), ValueUnion.psz);
    34033413                    rc = E_FAIL;
    34043414                }

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageNATNetwork.cpp

    r88757 r92372  
    5858#ifndef VBOX_ONLY_DOCS
    5959
     60DECLARE_TRANSLATION_CONTEXT(Nat);
     61
    6062using namespace com;
    6163
    … …  
    9496
    9597        CHECK_ERROR_BREAK(pNATNet, COMGETTER(NetworkName)(strVal.asOutParam()));
    96         RTPrintf("Name:         %ls\n", strVal.raw());
     98        RTPrintf(Nat::tr("Name:         %ls\n"), strVal.raw());
    9799
    98100        CHECK_ERROR_BREAK(pNATNet, COMGETTER(Network)(strVal.asOutParam()));
    99         RTPrintf("Network:      %ls\n", strVal.raw());
     101        RTPrintf(Nat::tr("Network:      %ls\n"), strVal.raw());
    100102
    101103        CHECK_ERROR_BREAK(pNATNet, COMGETTER(Gateway)(strVal.asOutParam()));
    102         RTPrintf("Gateway:      %ls\n", strVal.raw());
     104        RTPrintf(Nat::tr("Gateway:      %ls\n"), strVal.raw());
    103105
    104106        CHECK_ERROR_BREAK(pNATNet, COMGETTER(NeedDhcpServer)(&fVal));
    105         RTPrintf("DHCP Sever:   %s\n",  fVal ? "Yes" : "No");
     107        RTPrintf(Nat::tr("DHCP Sever:   %s\n"),  fVal ? Nat::tr("Yes") : Nat::tr("No"));
    106108
    107109        CHECK_ERROR_BREAK(pNATNet, COMGETTER(IPv6Enabled)(&fVal));
    108         RTPrintf("IPv6:         %s\n",  fVal ? "Yes" : "No");
     110        RTPrintf(Nat::tr("IPv6:         %s\n"),  fVal ? Nat::tr("Yes") : Nat::tr("No"));
    109111
    110112        CHECK_ERROR_BREAK(pNATNet, COMGETTER(IPv6Prefix)(strVal.asOutParam()));
    111         RTPrintf("IPv6 Prefix:  %ls\n", strVal.raw());
     113        RTPrintf(Nat::tr("IPv6 Prefix:  %ls\n"), strVal.raw());
    112114
    113115        CHECK_ERROR_BREAK(pNATNet, COMGETTER(AdvertiseDefaultIPv6RouteEnabled)(&fVal));
    114         RTPrintf("IPv6 Default: %s\n",  fVal ? "Yes" : "No");
     116        RTPrintf(Nat::tr("IPv6 Default: %s\n"),  fVal ? Nat::tr("Yes") : Nat::tr("No"));
    115117
    116118
    117119        CHECK_ERROR_BREAK(pNATNet, COMGETTER(Enabled)(&fVal));
    118         RTPrintf("Enabled:      %s\n",  fVal ? "Yes" : "No");
     120        RTPrintf(Nat::tr("Enabled:      %s\n"),  fVal ? Nat::tr("Yes") : Nat::tr("No"));
    119121        /** @todo Add more information here. */
    120122        RTPrintf("\n");
    … …  
    129131    HRESULT rc;
    130132
    131     RTPrintf("NAT Networks:\n\n");
     133    RTPrintf(Nat::tr("NAT Networks:\n\n"));
    132134
    133135    const char *pszFilter = NULL;
    … …  
    163165
    164166    if (SUCCEEDED(rc))
    165         RTPrintf("%zu %s found\n", cFound, cFound == 1 ? "network" : "networks");
     167        RTPrintf(Nat::tr("%zu %s found\n"), cFound, cFound == 1 ? Nat::tr("network") : Nat::tr("networks", "", cFound));
    166168
    167169    return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    … …  
    171173{
    172174    if (a->argc - 1 <= 1)
    173         return errorSyntax(USAGE_NATNETWORK, "Not enough parameters");
     175        return errorSyntax(USAGE_NATNETWORK, Nat::tr("Not enough parameters"));
    174176
    175177    const char *pNetName = NULL;
    … …  
    218220            case 't':   // --netname
    219221                if (pNetName)
    220                     return errorSyntax(USAGE_NATNETWORK, "You can only specify --netname only once.");
     222                    return errorSyntax(USAGE_NATNETWORK, Nat::tr("You can only specify --netname only once."));
    221223                pNetName = ValueUnion.psz;
    222224                break;
    … …  
    224226            case 'n':   // --network
    225227                if (pPrefixIPv4)
    226                     return errorSyntax(USAGE_NATNETWORK, "You can only specify --network only once.");
     228                    return errorSyntax(USAGE_NATNETWORK, Nat::tr("You can only specify --network only once."));
    227229                pPrefixIPv4 = ValueUnion.psz;
    228230                break;
    … …  
    230232            case 'e':   // --enable
    231233                if (enable >= 0)
    232                     return errorSyntax(USAGE_NATNETWORK, "You can specify either --enable or --disable once.");
     234                    return errorSyntax(USAGE_NATNETWORK, Nat::tr("You can specify either --enable or --disable once."));
    233235                enable = 1;
    234236                break;
    … …  
    236238            case 'd':   // --disable
    237239                if (enable >= 0)
    238                     return errorSyntax(USAGE_NATNETWORK, "You can specify either --enable or --disable once.");
     240                    return errorSyntax(USAGE_NATNETWORK, Nat::tr("You can specify either --enable or --disable once."));
    239241                enable = 0;
    240242                break;
    … …  
    242244            case 'h':
    243245                if (dhcp != -1)
    244                     return errorSyntax(USAGE_NATNETWORK, "You can specify --dhcp only once.");
     246                    return errorSyntax(USAGE_NATNETWORK, Nat::tr("You can specify --dhcp only once."));
    245247                dhcp = ValueUnion.f;
    246248                break;
    … …  
    248250            case '6':
    249251                if (ipv6 != -1)
    250                     return errorSyntax(USAGE_NATNETWORK, "You can specify --ipv6 only once.");
     252                    return errorSyntax(USAGE_NATNETWORK, Nat::tr("You can specify --ipv6 only once."));
    251253                ipv6 = ValueUnion.f;
    252254                break;
    … …  
    254256            case NATNET_CMD_OPT_IPV6_PREFIX:
    255257                if (pPrefixIPv6)
    256                     return errorSyntax(USAGE_NATNETWORK, "You can specify --ipv6-prefix only once.");
     258                    return errorSyntax(USAGE_NATNETWORK, Nat::tr("You can specify --ipv6-prefix only once."));
    257259                pPrefixIPv6 = ValueUnion.psz;
    258260                break;
    … …  
    265267                    if (enmCode != OP_MODIFY)
    266268                      errorSyntax(USAGE_NATNETWORK,
    267                                   "loopback couldn't be deleted on modified\n");
     269                                  Nat::tr("loopback couldn't be deleted on modified\n"));
    268270                    if (c == 'L')
    269271                        loopback6Offset = -1;
    … …  
    277279                        if (RT_FAILURE(vrc))
    278280                          return errorSyntax(USAGE_NATNETWORK,
    279                                              "Not enough parmaters\n");
     281                                             Nat::tr("Not enough parmaters\n"));
    280282
    281283                        vLoopback2Delete.push_back(std::string(Addr2Delete.psz));
    … …  
    302304                    int irc = netPfStrToPf(ValueUnion.psz, (c == 'P'), &Pfr);
    303305                    if (RT_FAILURE(irc))
    304                         return errorSyntax(USAGE_NATNETWORK, "Invalid port-forward rule %s\n", ValueUnion.psz);
     306                        return errorSyntax(USAGE_NATNETWORK, Nat::tr("Invalid port-forward rule %s\n"), ValueUnion.psz);
    305307
    306308                    vPf2Add.push_back(Pfr);
    … …  
    311313                    if (enmCode != OP_MODIFY)
    312314                        return errorSyntax(USAGE_NATNETWORK,
    313                                            "Port-forward could be deleted on modify \n");
     315                                           Nat::tr("Port-forward could be deleted on modify \n"));
    314316
    315317                    RTGETOPTUNION NamePf2DeleteUnion;
    316318                    int vrc = RTGetOptFetchValue(&GetState, &NamePf2DeleteUnion, RTGETOPT_REQ_STRING);
    317319                    if (RT_FAILURE(vrc))
    318                         return errorSyntax(USAGE_NATNETWORK, "Not enough parmaters\n");
     320                        return errorSyntax(USAGE_NATNETWORK, Nat::tr("Not enough parmaters\n"));
    319321
    320322                    if (strlen(NamePf2DeleteUnion.psz) > PF_NAMELEN)
    321                         return errorSyntax(USAGE_NATNETWORK, "Port-forward rule name is too long\n");
     323                        return errorSyntax(USAGE_NATNETWORK, Nat::tr("Port-forward rule name is too long\n"));
    322324
    323325                    PFNAME2DELETE Name2Delete;
    … …  
    336338
    337339    if (!pNetName)
    338         return errorSyntax(USAGE_NATNETWORK, "You need to specify the --netname option");
     340        return errorSyntax(USAGE_NATNETWORK, Nat::tr("You need to specify the --netname option"));
    339341    /* verification */
    340342    switch (enmCode)
    … …  
    342344        case OP_ADD:
    343345            if (!pPrefixIPv4)
    344                 return errorSyntax(USAGE_NATNETWORK, "You need to specify the --network option");
     346                return errorSyntax(USAGE_NATNETWORK, Nat::tr("You need to specify the --network option"));
    345347            break;
    346348        case OP_MODIFY:
    … …  
    350352            break;
    351353        default:
    352             AssertMsgFailedReturn(("Unknown operation (:%d)", enmCode), RTEXITCODE_FAILURE);
     354            AssertMsgFailedReturn((Nat::tr("Unknown operation (:%d)"), enmCode), RTEXITCODE_FAILURE);
    353355    }
    354356
    … …  
    362364    {
    363365        if (SUCCEEDED(rc))
    364             return errorArgument("NATNetwork server already exists");
     366            return errorArgument(Nat::tr("NATNetwork server already exists"));
    365367
    366368        CHECK_ERROR(a->virtualBox, CreateNATNetwork(NetName.raw(), net.asOutParam()));
    367369        if (FAILED(rc))
    368             return errorArgument("Failed to create the NAT network service");
     370            return errorArgument(Nat::tr("Failed to create the NAT network service"));
    369371    }
    370372    else if (FAILED(rc))
    371         return errorArgument("NATNetwork server does not exist");
     373        return errorArgument(Nat::tr("NATNetwork server does not exist"));
    372374
    373375    switch (enmCode)
    … …  
    380382                CHECK_ERROR(net, COMSETTER(Network)(Bstr(pPrefixIPv4).raw()));
    381383                if (FAILED(rc))
    382                     return errorArgument("Failed to set configuration");
     384                    return errorArgument(Nat::tr("Failed to set configuration"));
    383385            }
    384386            if (dhcp >= 0)
    … …  
    386388                CHECK_ERROR(net, COMSETTER(NeedDhcpServer) ((BOOL)dhcp));
    387389                if (FAILED(rc))
    388                     return errorArgument("Failed to set configuration");
     390                    return errorArgument(Nat::tr("Failed to set configuration"));
    389391            }
    390392
    … …  
    398400                CHECK_ERROR(net, COMSETTER(IPv6Enabled)(FALSE));
    399401                if (FAILED(rc))
    400                     return errorArgument("Failed to set configuration");
     402                    return errorArgument(Nat::tr("Failed to set configuration"));
    401403            }
    402404
    … …  
    405407                CHECK_ERROR(net, COMSETTER(IPv6Prefix)(Bstr(pPrefixIPv6).raw()));
    406408                if (FAILED(rc))
    407                     return errorArgument("Failed to set configuration");
     409                    return errorArgument(Nat::tr("Failed to set configuration"));
    408410            }
    409411
    … …  
    416418                CHECK_ERROR(net, COMSETTER(IPv6Enabled)(TRUE));
    417419                if (FAILED(rc))
    418                     return errorArgument("Failed to set configuration");
     420                    return errorArgument(Nat::tr("Failed to set configuration"));
    419421            }
    420422
    … …  
    427429                                                           Bstr((*it).szName).raw()));
    428430                    if (FAILED(rc))
    429                         return errorArgument("Failed to delete pf");
     431                        return errorArgument(Nat::tr("Failed to delete pf"));
    430432                }
    431433            }
    … …  
    452454                                                        (*it).u16PfrGuestPort));
    453455                    if (FAILED(rc))
    454                         return errorArgument("Failed to add pf");
     456                        return errorArgument(Nat::tr("Failed to add pf"));
    455457                }
    456458            }
    … …  
    478480                    Bstr bstrAddress;
    479481
    480                     AssertReturn(pos != std::string::npos, errorArgument("invalid loopback string"));
     482                    AssertReturn(pos != std::string::npos, errorArgument(Nat::tr("invalid loopback string")));
    481483
    482484                    address = it->substr(0, pos);
    … …  
    484486
    485487                    lOffset = RTStrToUInt32(strOffset.c_str());
    486                     AssertReturn(lOffset > 0, errorArgument("invalid loopback string"));
     488                    AssertReturn(lOffset > 0, errorArgument(Nat::tr("invalid loopback string")));
    487489
    488490                    bstrAddress = Bstr(address.c_str());
    … …  
    511513                CHECK_ERROR(net, COMSETTER(Enabled) ((BOOL)enable));
    512514                if (FAILED(rc))
    513                     return errorArgument("Failed to set configuration");
     515                    return errorArgument(Nat::tr("Failed to set configuration"));
    514516            }
    515517            break;
    … …  
    519521            CHECK_ERROR(a->virtualBox, RemoveNATNetwork(net));
    520522            if (FAILED(rc))
    521                 return errorArgument("Failed to remove nat network");
     523                return errorArgument(Nat::tr("Failed to remove nat network"));
    522524            break;
    523525        }
    … …  
    526528            CHECK_ERROR(net, Start());
    527529            if (FAILED(rc))
    528                 return errorArgument("Failed to start network");
     530                return errorArgument(Nat::tr("Failed to start network"));
    529531            break;
    530532        }
    … …  
    533535            CHECK_ERROR(net, Stop());
    534536            if (FAILED(rc))
    535                 return errorArgument("Failed to stop network");
     537                return errorArgument(Nat::tr("Failed to stop network"));
    536538            break;
    537539        }
    … …  
    545547{
    546548    if (a->argc < 1)
    547         return errorSyntax(USAGE_NATNETWORK, "Not enough parameters");
     549        return errorSyntax(USAGE_NATNETWORK, Nat::tr("Not enough parameters"));
    548550
    549551    RTEXITCODE rcExit;
    … …  
    561563        rcExit = handleNATList(a);
    562564    else
    563         rcExit = errorSyntax(USAGE_NATNETWORK, "Invalid parameter '%s'", Utf8Str(a->argv[0]).c_str());
     565        rcExit = errorSyntax(USAGE_NATNETWORK, Nat::tr("Invalid parameter '%s'"), Utf8Str(a->argv[0]).c_str());
    564566    return rcExit;
    565567}

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageSnapshot.cpp

    r85138 r92372  
    3434#include "VBoxManage.h"
    3535using namespace com;
     36
     37DECLARE_TRANSLATION_CONTEXT(Snapshot);
    3638
    3739/**
    … …  
    194196    if (FAILED(hrc))
    195197    {
    196         RTPrintf("This machine does not have any snapshots\n");
     198        RTPrintf(Snapshot::tr("This machine does not have any snapshots\n"));
    197199        return RTEXITCODE_FAILURE;
    198200    }
    … …  
    250252                CHECK_ERROR_BREAK(pBaseMedium, COMGETTER(Name)(bstrBaseMediumName.asOutParam()));
    251253
    252                 RTPrintf("[%RI32] Images and snapshots for medium \"%ls\"\n", i, bstrBaseMediumName.raw());
     254                RTPrintf(Snapshot::tr("[%RI32] Images and snapshots for medium \"%ls\"\n"), i, bstrBaseMediumName.raw());
    253255
    254256                DumpMediumWithChildren(pCurrentStateMedium,
    … …  
    325327    /* we need at least a VM and a command */
    326328    if (a->argc < 2)
    327         return errorSyntax("Not enough parameters");
     329        return errorSyntax(Snapshot::tr("Not enough parameters"));
    328330
    329331    /* the first argument must be the VM */
    … …  
    355357            if (a->argc < 3)
    356358            {
    357                 errorSyntax("Missing snapshot name");
     359                errorSyntax(Snapshot::tr("Missing snapshot name"));
    358360                rc = E_FAIL;
    359361                break;
    … …  
    400402                        vrc = parseSnapshotUniqueFlags(Value.psz, &enmUnique);
    401403                        if (RT_FAILURE(vrc))
    402                             return errorArgument("Invalid unique name description '%s'", Value.psz);
     404                            return errorArgument(Snapshot::tr("Invalid unique name description '%s'"), Value.psz);
    403405                        break;
    404406
    … …  
    463465                    if (SUCCEEDED(rc))
    464466                    {
    465                         errorArgument("Failed to generate a unique snapshot name");
     467                        errorArgument(Snapshot::tr("Failed to generate a unique snapshot name"));
    466468                        rc = E_FAIL;
    467469                        break;
    … …  
    479481            rc = showProgress(progress);
    480482            if (SUCCEEDED(rc))
    481                 RTPrintf("Snapshot taken. UUID: %ls\n", snapId.raw());
     483                RTPrintf(Snapshot::tr("Snapshot taken. UUID: %ls\n"), snapId.raw());
    482484            else
    483                 CHECK_PROGRESS_ERROR(progress, ("Failed to take snapshot"));
     485                CHECK_PROGRESS_ERROR(progress, (Snapshot::tr("Failed to take snapshot")));
    484486        }
    485487        else if (    (fDelete = !strcmp(a->argv[1], "delete"))
    … …  
    496498                if (a->argc > 2)
    497499                {
    498                     errorSyntax("Too many arguments");
     500                    errorSyntax(Snapshot::tr("Too many arguments"));
    499501                    rc = E_FAIL;
    500502                    break;
    … …  
    504506            else if (a->argc != 3)
    505507            {
    506                 errorSyntax("Expecting snapshot name only");
     508                errorSyntax(Snapshot::tr("Expecting snapshot name only"));
    507509                rc = E_FAIL;
    508510                break;
    … …  
    516518                if (pSnapshot.isNull())
    517519                {
    518                     RTPrintf("This machine does not have any snapshots\n");
     520                    RTPrintf(Snapshot::tr("This machine does not have any snapshots\n"));
    519521                    return RTEXITCODE_FAILURE;
    520522                }
    … …  
    535537            ComPtr<IProgress> pProgress;
    536538
    537             RTPrintf("%s snapshot '%ls' (%ls)\n",
    538                      fDelete ? "Deleting" : "Restoring", bstrSnapName.raw(), bstrSnapGuid.raw());
     539            RTPrintf(Snapshot::tr("%s snapshot '%ls' (%ls)\n"),
     540                     fDelete ? Snapshot::tr("Deleting") : Snapshot::tr("Restoring"), bstrSnapName.raw(), bstrSnapGuid.raw());
    539541
    540542            if (fDelete)
    … …  
    550552
    551553            rc = showProgress(pProgress);
    552             CHECK_PROGRESS_ERROR(pProgress, ("Snapshot operation failed"));
     554            CHECK_PROGRESS_ERROR(pProgress, (Snapshot::tr("Snapshot operation failed")));
    553555        }
    554556        else if (!strcmp(a->argv[1], "edit"))
    … …  
    557559            if (a->argc < 3)
    558560            {
    559                 errorSyntax("Missing snapshot name");
     561                errorSyntax(Snapshot::tr("Missing snapshot name"));
    560562                rc = E_FAIL;
    561563                break;
    … …  
    590592                        if (pSnapshot.isNull())
    591593                        {
    592                             RTPrintf("This machine does not have any snapshots\n");
     594                            RTPrintf(Snapshot::tr("This machine does not have any snapshots\n"));
    593595                            return RTEXITCODE_FAILURE;
    594596                        }
    … …  
    624626            if (a->argc != 3)
    625627            {
    626                 errorSyntax("Expecting snapshot name only");
     628                errorSyntax(Snapshot::tr("Expecting snapshot name only"));
    627629                rc = E_FAIL;
    628630                break;
    … …  
    648650        else
    649651        {
    650             errorSyntax("Invalid parameter '%s'", a->argv[1]);
     652            errorSyntax(Snapshot::tr("Invalid parameter '%s'"), a->argv[1]);
    651653            rc = E_FAIL;
    652654        }
    … …  
    657659    return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    658660}
    659 

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageStorageController.cpp

    r82968 r92372  
    3939using namespace com;
    4040
     41DECLARE_TRANSLATION_CONTEXT(Storage);
    4142
    4243// funcs
    … …  
    165166                        devTypeRequested = DeviceType_DVD;
    166167                    else
    167                         return errorArgument("Invalid --type argument '%s'", ValueUnion.psz);
     168                        return errorArgument(Storage::tr("Invalid --type argument '%s'"), ValueUnion.psz);
    168169                }
    169170                else
    … …  
    304305                int vrc = parseMediumType(ValueUnion.psz, &enmMediumType);
    305306                if (RT_FAILURE(vrc))
    306                     return errorArgument("Invalid medium type '%s'", ValueUnion.psz);
     307                    return errorArgument(Storage::tr("Invalid medium type '%s'"), ValueUnion.psz);
    307308                fSetMediumType = true;
    308309                break;
    … …  
    326327
    327328    if (!pszCtl)
    328         return errorSyntax(USAGE_STORAGEATTACH, "Storage controller name not specified");
     329        return errorSyntax(USAGE_STORAGEATTACH, Storage::tr("Storage controller name not specified"));
    329330
    330331    /* get the virtualbox system properties */
    … …  
    346347        {
    347348            if (pszPassThrough)
    348                 throw Utf8Str("Drive passthrough state cannot be changed while the VM is running\n");
     349                throw Utf8Str(Storage::tr("Drive passthrough state cannot be changed while the VM is running\n"));
    349350            else if (pszBandwidthGroup)
    350                 throw Utf8Str("Bandwidth group cannot be changed while the VM is running\n");
     351                throw Utf8Str(Storage::tr("Bandwidth group cannot be changed while the VM is running\n"));
    351352        }
    352353
    … …  
    355356                                                 storageCtl.asOutParam());
    356357        if (FAILED(rc))
    357             throw Utf8StrFmt("Could not find a controller named '%s'\n", pszCtl);
     358            throw Utf8StrFmt(Storage::tr("Could not find a controller named '%s'\n"), pszCtl);
    358359
    359360        StorageBus_T storageBus = StorageBus_Null;
    … …  
    369370                port = 0;
    370371            else
    371                 return errorSyntax(USAGE_STORAGEATTACH, "Port not specified");
     372                return errorSyntax(USAGE_STORAGEATTACH, Storage::tr("Port not specified"));
    372373        }
    373374        if (device == ~0U)
    … …  
    376377                device = 0;
    377378            else
    378                 return errorSyntax(USAGE_STORAGEATTACH, "Device not specified");
     379                return errorSyntax(USAGE_STORAGEATTACH, Storage::tr("Device not specified"));
    379380        }
    380381
    … …  
    440441                         || deviceType == DeviceType_Floppy)
    441442                   )
    442                     throw Utf8StrFmt("No DVD/Floppy Drive attached to the controller '%s'"
    443                                      "at the port: %u, device: %u", pszCtl, port, device);
     443                    throw Utf8StrFmt(Storage::tr("No DVD/Floppy Drive attached to the controller '%s'"
     444                                                 "at the port: %u, device: %u"), pszCtl, port, device);
    444445
    445446            }
    … …  
    460461
    461462                if (!driveCheck)
    462                     throw Utf8StrFmt("The attachment is not supported by the storage controller '%s'", pszCtl);
     463                    throw Utf8StrFmt(Storage::tr("The attachment is not supported by the storage controller '%s'"), pszCtl);
    463464
    464465                if (storageBus == StorageBus_Floppy)
    … …  
    515516                                strIso = Utf8Str(bstrIso);
    516517                                if (strIso.isEmpty())
    517                                     throw Utf8Str("Cannot find the Guest Additions ISO image\n");
     518                                    throw Utf8Str(Storage::tr("Cannot find the Guest Additions ISO image\n"));
    518519                                pszMedium = strIso.c_str();
    519520                                if (devTypeRequested == DeviceType_Null)
    … …  
    541542
    542543            if (devTypeRequested == DeviceType_Null)        // still the initializer value?
    543                 throw Utf8Str("Argument --type must be specified\n");
     544                throw Utf8Str(Storage::tr("Argument --type must be specified\n"));
    544545
    545546            /* check if the device type is supported by the controller */
    … …  
    555556                            driveCheck++;
    556557                    if (!driveCheck)
    557                         throw Utf8StrFmt("The given attachment is not supported by the storage controller '%s'", pszCtl);
     558                        throw Utf8StrFmt(Storage::tr("The given attachment is not supported by the storage controller '%s'"), pszCtl);
    558559                }
    559560                else
    … …  
    577578                        char szPathReal[RTPATH_MAX];
    578579                        if (RT_FAILURE(RTPathReal(pszMedium + 5, szPathReal, sizeof(szPathReal))))
    579                             throw Utf8StrFmt("Invalid host DVD drive name \"%s\"", pszMedium + 5);
     580                            throw Utf8StrFmt(Storage::tr("Invalid host DVD drive name \"%s\""), pszMedium + 5);
    580581                        rc = host->FindHostDVDDrive(Bstr(szPathReal).raw(),
    581582                                                    pMedium2Mount.asOutParam());
    582583                        if (!pMedium2Mount)
    583                             throw Utf8StrFmt("Invalid host DVD drive name \"%s\"", pszMedium + 5);
     584                            throw Utf8StrFmt(Storage::tr("Invalid host DVD drive name \"%s\""), pszMedium + 5);
    584585                    }
    585586                }
    … …  
    590591                                                   pMedium2Mount.asOutParam());
    591592                    if (!pMedium2Mount)
    592                         throw Utf8StrFmt("Invalid host floppy drive name \"%s\"", pszMedium + 5);
     593                        throw Utf8StrFmt(Storage::tr("Invalid host floppy drive name \"%s\""), pszMedium + 5);
    593594                }
    594595            }
    … …  
    597598                /* check for required options */
    598599                if (bstrServer.isEmpty() || bstrTarget.isEmpty())
    599                     throw Utf8StrFmt("Parameters --server and --target are required for iSCSI media");
     600                    throw Utf8StrFmt(Storage::tr("Parameters --server and --target are required for iSCSI media"));
    600601
    601602                /** @todo move the location stuff to Main, which can use pfnComposeName
    … …  
    664665                CHECK_ERROR(pMedium2Mount, COMGETTER(Id)(guid.asOutParam()));
    665666                if (FAILED(rc)) goto leave;
    666                 RTPrintf("iSCSI disk created. UUID: %s\n", Utf8Str(guid).c_str());
     667                RTPrintf(Storage::tr("iSCSI disk created. UUID: %s\n"), Utf8Str(guid).c_str());
    667668            }
    668669            else
    … …  
    675676                                                      mediumAttachment.asOutParam());
    676677                    if (FAILED(rc))
    677                         throw Utf8Str("Missing --medium argument");
     678                        throw Utf8Str(Storage::tr("Missing --medium argument"));
    678679                }
    679680                else
    … …  
    684685                                    fSetNewUuid, false /* fSilent */);
    685686                    if (FAILED(rc) || !pMedium2Mount)
    686                         throw Utf8StrFmt("Invalid UUID or filename \"%s\"", pszMedium);
     687                        throw Utf8StrFmt(Storage::tr("Invalid UUID or filename \"%s\""), pszMedium);
    687688                }
    688689            }
    … …  
    694695                                                  fSetNewParentUuid, bstrNewParentUuid.raw()));
    695696                if (FAILED(rc))
    696                     throw  Utf8Str("Failed to set the medium/parent medium UUID");
     697                    throw  Utf8Str(Storage::tr("Failed to set the medium/parent medium UUID"));
    697698            }
    698699
    … …  
    708709                        CHECK_ERROR(pMedium2Mount, COMSETTER(Type)(enmMediumType));
    709710                        if (FAILED(rc))
    710                             throw  Utf8Str("Failed to set the medium type");
     711                            throw  Utf8Str(Storage::tr("Failed to set the medium type"));
    711712                    }
    712713                }
    … …  
    803804                }
    804805                else
    805                     throw Utf8StrFmt("Invalid --passthrough argument '%s'", pszPassThrough);
    806             }
    807             else
    808                 throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl);
     806                    throw Utf8StrFmt(Storage::tr("Invalid --passthrough argument '%s'"), pszPassThrough);
     807            }
     808            else
     809                throw Utf8StrFmt(Storage::tr("Couldn't find the controller attachment for the controller '%s'\n"), pszCtl);
    809810        }
    810811
    … …  
    829830                }
    830831                else
    831                     throw Utf8StrFmt("Invalid --tempeject argument '%s'", pszTempEject);
    832             }
    833             else
    834                 throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl);
     832                    throw Utf8StrFmt(Storage::tr("Invalid --tempeject argument '%s'"), pszTempEject);
     833            }
     834            else
     835                throw Utf8StrFmt(Storage::tr("Couldn't find the controller attachment for the controller '%s'\n"), pszCtl);
    835836        }
    836837
    … …  
    855856                }
    856857                else
    857                     throw Utf8StrFmt("Invalid --nonrotational argument '%s'", pszNonRotational);
    858             }
    859             else
    860                 throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl);
     858                    throw Utf8StrFmt(Storage::tr("Invalid --nonrotational argument '%s'"), pszNonRotational);
     859            }
     860            else
     861                throw Utf8StrFmt(Storage::tr("Couldn't find the controller attachment for the controller '%s'\n"), pszCtl);
    861862        }
    862863
    … …  
    881882                }
    882883                else
    883                     throw Utf8StrFmt("Invalid --discard argument '%s'", pszDiscard);
    884             }
    885             else
    886                 throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl);
     884                    throw Utf8StrFmt(Storage::tr("Invalid --discard argument '%s'"), pszDiscard);
     885            }
     886            else
     887                throw Utf8StrFmt(Storage::tr("Couldn't find the controller attachment for the controller '%s'\n"), pszCtl);
    887888        }
    888889
    … …  
    907908                }
    908909                else
    909                     throw Utf8StrFmt("Invalid --hotpluggable argument '%s'", pszHotPluggable);
    910             }
    911             else
    912                 throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl);
     910                    throw Utf8StrFmt(Storage::tr("Invalid --hotpluggable argument '%s'"), pszHotPluggable);
     911            }
     912            else
     913                throw Utf8StrFmt(Storage::tr("Couldn't find the controller attachment for the controller '%s'\n"), pszCtl);
    913914        }
    914915
    … …  
    989990
    990991    if (a->argc < 4)
    991         return errorSyntax(USAGE_STORAGECONTROLLER, "Too few parameters");
     992        return errorSyntax(USAGE_STORAGECONTROLLER, Storage::tr("Too few parameters"));
    992993
    993994    RTGetOptInit (&GetState, a->argc, a->argv, g_aStorageControllerOptions,
    … …  
    10551056        /* it's important to always close sessions */
    10561057        a->session->UnlockMachine();
    1057         return errorSyntax(USAGE_STORAGECONTROLLER, "Storage controller name not specified\n");
     1058        return errorSyntax(USAGE_STORAGECONTROLLER, Storage::tr("Storage controller name not specified\n"));
    10581059    }
    10591060
    … …  
    11181119            else
    11191120            {
    1120                 errorArgument("Invalid --add argument '%s'", pszBusType);
     1121                errorArgument(Storage::tr("Invalid --add argument '%s'"), pszBusType);
    11211122                rc = E_FAIL;
    11221123            }
    … …  
    11791180                else
    11801181                {
    1181                     errorArgument("Invalid --type argument '%s'", pszCtlType);
    1182                     rc = E_FAIL;
    1183                 }
    1184             }
    1185             else
    1186             {
    1187                 errorArgument("Couldn't find the controller with the name: '%s'\n", pszCtl);
     1182                    errorArgument(Storage::tr("Invalid --type argument '%s'"), pszCtlType);
     1183                    rc = E_FAIL;
     1184                }
     1185            }
     1186            else
     1187            {
     1188                errorArgument(Storage::tr("Couldn't find the controller with the name: '%s'\n"), pszCtl);
    11881189                rc = E_FAIL;
    11891190            }
    … …  
    12041205            else
    12051206            {
    1206                 errorArgument("Couldn't find the controller with the name: '%s'\n", pszCtl);
     1207                errorArgument(Storage::tr("Couldn't find the controller with the name: '%s'\n"), pszCtl);
    12071208                rc = E_FAIL;
    12081209            }
    … …  
    12291230                else
    12301231                {
    1231                     errorArgument("Invalid --hostiocache argument '%s'", pszHostIOCache);
    1232                     rc = E_FAIL;
    1233                 }
    1234             }
    1235             else
    1236             {
    1237                 errorArgument("Couldn't find the controller with the name: '%s'\n", pszCtl);
     1232                    errorArgument(Storage::tr("Invalid --hostiocache argument '%s'"), pszHostIOCache);
     1233                    rc = E_FAIL;
     1234                }
     1235            }
     1236            else
     1237            {
     1238                errorArgument(Storage::tr("Couldn't find the controller with the name: '%s'\n"), pszCtl);
    12381239                rc = E_FAIL;
    12391240            }
    … …  
    12551256                else
    12561257                {
    1257                     errorArgument("Invalid --bootable argument '%s'", pszBootable);
    1258                     rc = E_FAIL;
    1259                 }
    1260             }
    1261             else
    1262             {
    1263                 errorArgument("Couldn't find the controller with the name: '%s'\n", pszCtl);
     1258                    errorArgument(Storage::tr("Invalid --bootable argument '%s'"), pszBootable);
     1259                    rc = E_FAIL;
     1260                }
     1261            }
     1262            else
     1263            {
     1264                errorArgument(Storage::tr("Couldn't find the controller with the name: '%s'\n"), pszCtl);
    12641265                rc = E_FAIL;
    12651266            }
    … …  
    12801281            else
    12811282            {
    1282                 errorArgument("Couldn't find the controller with the name: '%s'\n", pszCtl);
     1283                errorArgument(Storage::tr("Couldn't find the controller with the name: '%s'\n"), pszCtl);
    12831284                rc = E_FAIL;
    12841285            }
    … …  
    12981299
    12991300#endif /* !VBOX_ONLY_DOCS */
    1300 

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageUSB.cpp

    r82968 r92372  
    2929
    3030using namespace com;
     31
     32DECLARE_TRANSLATION_CONTEXT(Usb);
    3133
    3234/**
    … …  
    174176    /* at least: 0: command, 1: index, 2: --target, 3: <target value> */
    175177    if (a->argc < 4)
    176         return errorSyntax(USAGE_USBFILTER, "Not enough parameters");
     178        return errorSyntax(USAGE_USBFILTER, Usb::tr("Not enough parameters"));
    177179
    178180    /* which command? */
    … …  
    183185
    184186    if (cmd.mAction == USBFilterCmd::Invalid)
    185         return errorSyntax(USAGE_USBFILTER, "Invalid parameter '%s'", a->argv[0]);
     187        return errorSyntax(USAGE_USBFILTER, Usb::tr("Invalid parameter '%s'"), a->argv[0]);
    186188
    187189    /* which index? */
    188190    if (VINF_SUCCESS !=  RTStrToUInt32Full(a->argv[1], 10, &cmd.mIndex))
    189         return errorSyntax(USAGE_USBFILTER, "Invalid index '%s'", a->argv[1]);
     191        return errorSyntax(USAGE_USBFILTER, Usb::tr("Invalid index '%s'"), a->argv[1]);
    190192
    191193    switch (cmd.mAction)
    … …  
    198200            {
    199201                if (cmd.mAction == USBFilterCmd::Add)
    200                     return errorSyntaxEx(USAGE_USBFILTER, HELP_SCOPE_USBFILTER_ADD, "Not enough parameters");
    201 
    202                 return errorSyntaxEx(USAGE_USBFILTER, HELP_SCOPE_USBFILTER_MODIFY, "Not enough parameters");
     202                    return errorSyntaxEx(USAGE_USBFILTER, HELP_SCOPE_USBFILTER_ADD, Usb::tr("Not enough parameters"));
     203
     204                return errorSyntaxEx(USAGE_USBFILTER, HELP_SCOPE_USBFILTER_MODIFY, Usb::tr("Not enough parameters"));
    203205            }
    204206
    … …  
    215217                {
    216218                    if (a->argc <= i + 1 || !*a->argv[i+1])
    217                         return errorArgument("Missing argument to '%s'", a->argv[i]);
     219                        return errorArgument(Usb::tr("Missing argument to '%s'"), a->argv[i]);
    218220                    i++;
    219221                    if (!strcmp(a->argv[i], "global"))
    … …  
    230232                {
    231233                    if (a->argc <= i + 1 || !*a->argv[i+1])
    232                         return errorArgument("Missing argument to '%s'", a->argv[i]);
     234                        return errorArgument(Usb::tr("Missing argument to '%s'"), a->argv[i]);
    233235                    i++;
    234236                    cmd.mFilter.mName = a->argv[i];
    … …  
    238240                {
    239241                    if (a->argc <= i + 1)
    240                         return errorArgument("Missing argument to '%s'", a->argv[i]);
     242                        return errorArgument(Usb::tr("Missing argument to '%s'"), a->argv[i]);
    241243                    i++;
    242244                    if (!strcmp(a->argv[i], "yes"))
    … …  
    245247                        cmd.mFilter.mActive = false;
    246248                    else
    247                         return errorArgument("Invalid --active argument '%s'", a->argv[i]);
     249                        return errorArgument(Usb::tr("Invalid --active argument '%s'"), a->argv[i]);
    248250                }
    249251                else if (   !strcmp(a->argv[i], "--vendorid")
    … …  
    251253                {
    252254                    if (a->argc <= i + 1)
    253                         return errorArgument("Missing argument to '%s'", a->argv[i]);
     255                        return errorArgument(Usb::tr("Missing argument to '%s'"), a->argv[i]);
    254256                    i++;
    255257                    cmd.mFilter.mVendorId = a->argv[i];
    … …  
    259261                {
    260262                    if (a->argc <= i + 1)
    261                         return errorArgument("Missing argument to '%s'", a->argv[i]);
     263                        return errorArgument(Usb::tr("Missing argument to '%s'"), a->argv[i]);
    262264                    i++;
    263265                    cmd.mFilter.mProductId = a->argv[i];
    … …  
    267269                {
    268270                    if (a->argc <= i + 1)
    269                         return errorArgument("Missing argument to '%s'", a->argv[i]);
     271                        return errorArgument(Usb::tr("Missing argument to '%s'"), a->argv[i]);
    270272                    i++;
    271273                    cmd.mFilter.mRevision = a->argv[i];
    … …  
    275277                {
    276278                    if (a->argc <= i + 1)
    277                         return errorArgument("Missing argument to '%s'", a->argv[i]);
     279                        return errorArgument(Usb::tr("Missing argument to '%s'"), a->argv[i]);
    278280                    i++;
    279281                    cmd.mFilter.mManufacturer = a->argv[i];
    … …  
    283285                {
    284286                    if (a->argc <= i + 1)
    285                         return errorArgument("Missing argument to '%s'", a->argv[i]);
     287                        return errorArgument(Usb::tr("Missing argument to '%s'"), a->argv[i]);
    286288                    i++;
    287289                    cmd.mFilter.mProduct = a->argv[i];
    … …  
    291293                {
    292294                    if (a->argc <= i + 1)
    293                         return errorArgument("Missing argument to '%s'", a->argv[i]);
     295                        return errorArgument(Usb::tr("Missing argument to '%s'"), a->argv[i]);
    294296                    i++;
    295297                    cmd.mFilter.mRemote = a->argv[i];
    … …  
    299301                {
    300302                    if (a->argc <= i + 1)
    301                         return errorArgument("Missing argument to '%s'", a->argv[i]);
     303                        return errorArgument(Usb::tr("Missing argument to '%s'"), a->argv[i]);
    302304                    i++;
    303305                    cmd.mFilter.mSerialNumber = a->argv[i];
    … …  
    307309                {
    308310                    if (a->argc <= i + 1)
    309                         return errorArgument("Missing argument to '%s'", a->argv[i]);
     311                        return errorArgument(Usb::tr("Missing argument to '%s'"), a->argv[i]);
    310312                    i++;
    311313                    uint32_t u32;
    312314                    int vrc = RTStrToUInt32Full(a->argv[i], 0, &u32);
    313315                    if (RT_FAILURE(vrc))
    314                         return errorArgument("Failed to convert the --maskedinterfaces value '%s' to a number, vrc=%Rrc", a->argv[i], vrc);
     316                        return errorArgument(Usb::tr("Failed to convert the --maskedinterfaces value '%s' to a number, vrc=%Rrc"),
     317                                             a->argv[i], vrc);
    315318                    cmd.mFilter.mMaskedInterfaces = u32;
    316319                }
    … …  
    319322                {
    320323                    if (a->argc <= i + 1)
    321                         return errorArgument("Missing argument to '%s'", a->argv[i]);
     324                        return errorArgument(Usb::tr("Missing argument to '%s'"), a->argv[i]);
    322325                    i++;
    323326                    if (!strcmp(a->argv[i], "ignore"))
    … …  
    326329                        cmd.mFilter.mAction = USBDeviceFilterAction_Hold;
    327330                    else
    328                         return errorArgument("Invalid USB filter action '%s'", a->argv[i]);
     331                        return errorArgument(Usb::tr("Invalid USB filter action '%s'"), a->argv[i]);
    329332                }
    330333                else
    331334                    return errorSyntaxEx(USAGE_USBFILTER, cmd.mAction == USBFilterCmd::Add ? HELP_SCOPE_USBFILTER_ADD : HELP_SCOPE_USBFILTER_MODIFY,
    332                                        "Unknown option '%s'", a->argv[i]);
     335                                         Usb::tr("Unknown option '%s'"), a->argv[i]);
    333336            }
    334337
    … …  
    347350                   )
    348351                {
    349                     return errorSyntaxEx(USAGE_USBFILTER, HELP_SCOPE_USBFILTER_ADD, "Mandatory options not supplied");
     352                    return errorSyntaxEx(USAGE_USBFILTER, HELP_SCOPE_USBFILTER_ADD, Usb::tr("Mandatory options not supplied"));
    350353                }
    351354            }
    … …  
    357360            /* at least: 0: command, 1: index, 2: --target, 3: <target value> */
    358361            if (a->argc < 4)
    359                 return errorSyntaxEx(USAGE_USBFILTER, HELP_SCOPE_USBFILTER_REMOVE, "Not enough parameters");
     362                return errorSyntaxEx(USAGE_USBFILTER, HELP_SCOPE_USBFILTER_REMOVE, Usb::tr("Not enough parameters"));
    360363
    361364            for (int i = 2; i < a->argc; i++)
    … …  
    365368                {
    366369                    if (a->argc <= i + 1 || !*a->argv[i+1])
    367                         return errorArgument("Missing argument to '%s'", a->argv[i]);
     370                        return errorArgument(Usb::tr("Missing argument to '%s'"), a->argv[i]);
    368371                    i++;
    369372                    if (!strcmp(a->argv[i], "global"))
    … …  
    379382            // mandatory options
    380383            if (!cmd.mGlobal && !cmd.mMachine)
    381                 return errorSyntaxEx(USAGE_USBFILTER, HELP_SCOPE_USBFILTER_REMOVE, "Mandatory options not supplied");
     384                return errorSyntaxEx(USAGE_USBFILTER, HELP_SCOPE_USBFILTER_REMOVE, Usb::tr("Mandatory options not supplied"));
    382385
    383386            break;
    … …  
    555558    /* at least: 0: command, 1: source id */
    556559    if (a->argc < 2)
    557         return errorSyntax(USAGE_USBDEVSOURCE, "Not enough parameters");
     560        return errorSyntax(USAGE_USBDEVSOURCE, Usb::tr("Not enough parameters"));
    558561
    559562    ComPtr<IHost> host;
    … …  
    563566        Bstr strAddress;
    564567        if (a->argc != 6)
    565             return errorSyntax(USAGE_USBDEVSOURCE, "Invalid number of parameters");
     568            return errorSyntax(USAGE_USBDEVSOURCE, Usb::tr("Invalid number of parameters"));
    566569
    567570        for (int i = 2; i < a->argc; i++)
    … …  
    578581            }
    579582            else
    580                 return errorSyntax(USAGE_USBDEVSOURCE, "Parameter \"%s\" is invalid", a->argv[i]);
     583                return errorSyntax(USAGE_USBDEVSOURCE, Usb::tr("Parameter \"%s\" is invalid"), a->argv[i]);
    581584        }
    582585

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageUpdateCheck.cpp

    r85780 r92372  
    3939#include "VBoxManage.h"
    4040
     41DECLARE_TRANSLATION_CONTEXT(UpdateCheck);
     42
    4143using namespace com;    // SafeArray
    4244
    … …  
    8587        outputMachineReadableBool("enabled", &fVBoxUpdateEnabled);
    8688    else
    87         RTPrintf("Enabled:                %s\n", fVBoxUpdateEnabled ? "yes" : "no");
     89        RTPrintf(UpdateCheck::tr("Enabled:                %s\n"),
     90                 fVBoxUpdateEnabled ? UpdateCheck::tr("yes") : UpdateCheck::tr("no"));
    8891
    8992    ULONG cVBoxUpdateCount;
    … …  
    9295        outputMachineReadableULong("count", &cVBoxUpdateCount);
    9396    else
    94         RTPrintf("Count:                  %u\n", cVBoxUpdateCount);
     97        RTPrintf(UpdateCheck::tr("Count:                  %u\n"), cVBoxUpdateCount);
    9598
    9699    ULONG cDaysFrequencey;
    … …  
    99102        outputMachineReadableULong("frequency", &cDaysFrequencey);
    100103    else if (cDaysFrequencey == 0)
    101         RTPrintf("Frequency:              never\n"); /** @todo r=bird: Two inconsistencies here. HostUpdateImpl.cpp code will indicate the need for updating if no last-check-date.  modifysettings cannot set it to zero (I added the error message, you just skipped setting it originally). */
     104        RTPrintf(UpdateCheck::tr("Frequency:              never\n")); /** @todo r=bird: Two inconsistencies here. HostUpdateImpl.cpp code will indicate the need for updating if no last-check-date.  modifysettings cannot set it to zero (I added the error message, you just skipped setting it originally). */
    102105    else if (cDaysFrequencey == 1)
    103         RTPrintf("Frequency:              every day\n");
     106        RTPrintf(UpdateCheck::tr("Frequency:              every day\n"));
    104107    else
    105         RTPrintf("Frequency:              every %u days\n", cDaysFrequencey);
     108        RTPrintf(UpdateCheck::tr("Frequency:              every %u days\n"), cDaysFrequencey);
    106109
    107110    VBoxUpdateTarget_T enmVBoxUpdateTarget;
    … …  
    112115    {
    113116        case VBoxUpdateTarget_Stable:
    114             psz = "Stable - new minor and maintenance releases";
     117            psz = UpdateCheck::tr("Stable - new minor and maintenance releases");
    115118            pszMachine = "stable";
    116119            break;
    117120        case VBoxUpdateTarget_AllReleases:
    118             psz = "All releases - new minor, maintenance, and major releases";
     121            psz = UpdateCheck::tr("All releases - new minor, maintenance, and major releases");
    119122            pszMachine = "all-releases";
    120123            break;
    121124        case VBoxUpdateTarget_WithBetas:
    122             psz = "With Betas - new minor, maintenance, major, and beta releases";
     125            psz = UpdateCheck::tr("With Betas - new minor, maintenance, major, and beta releases");
    123126            pszMachine = "with-betas";
    124127            break;
    125128        default:
    126129            AssertFailed();
    127             psz = "Unset";
     130            psz = UpdateCheck::tr("Unset");
    128131            pszMachine = "invalid";
    129132            break;
    … …  
    132135        outputMachineReadableString("target", pszMachine);
    133136    else
    134         RTPrintf("Target:                 %s\n", psz);
     137        RTPrintf(UpdateCheck::tr("Target:                 %s\n"), psz);
    135138
    136139    Bstr bstrLastCheckDate;
    … …  
    140143        outputMachineReadableString("last-check-date", &bstrLastCheckDate);
    141144    else if (bstrLastCheckDate.isNotEmpty())
    142         RTPrintf("Last Check Date:        %ls\n", bstrLastCheckDate.raw());
     145        RTPrintf(UpdateCheck::tr("Last Check Date:        %ls\n"), bstrLastCheckDate.raw());
    143146
    144147    return RTEXITCODE_SUCCESS;
    … …  
    192195                    enmVBoxUpdateTarget = VBoxUpdateTarget_AllReleases;
    193196                else
    194                     return errorArgument("Unknown target specified: '%s'", ValueUnion.psz);
     197                    return errorArgument(UpdateCheck::tr("Unknown target specified: '%s'"), ValueUnion.psz);
    195198                break;
    196199
    … …  
    198201                cDaysUpdateFrequency = ValueUnion.u32;
    199202                if (cDaysUpdateFrequency == 0)
    200                     return errorArgument("The update frequency cannot be zero");
     203                    return errorArgument(UpdateCheck::tr("The update frequency cannot be zero"));
    201204                break;
    202205
    … …  
    209212        && enmVBoxUpdateTarget != enmVBoxUpdateTargetNil
    210213        && cDaysUpdateFrequency == 0)
    211         return errorSyntax("No change requested");
     214        return errorSyntax(UpdateCheck::tr("No change requested"));
    212215
    213216    /*
    … …  
    280283    ComPtr<IProgress> ptrProgress;
    281284
    282     RTPrintf("Checking for a new VirtualBox version...\n");
     285    RTPrintf(UpdateCheck::tr("Checking for a new VirtualBox version...\n"));
    283286
    284287    // we don't call CHECK_ERROR2I_RET(pHostUpdate, VBoxUpdate(updateCheckType, ...); here so we can check for a specific
    … …  
    291294        if (rc == E_NOTIMPL)
    292295        {
    293             RTPrintf("VirtualBox update checking has been disabled.\n");
     296            RTPrintf(UpdateCheck::tr("VirtualBox update checking has been disabled.\n"));
    294297            return RTEXITCODE_SUCCESS;
    295298        }
    296299
    297300        if (ptrProgress.isNull())
    298             RTStrmPrintf(g_pStdErr, "Failed to create ptrProgress object: %Rhrc\n", rc);
     301            RTStrmPrintf(g_pStdErr, UpdateCheck::tr("Failed to create ptrProgress object: %Rhrc\n"), rc);
    299302        else
    300             com::GlueHandleComError(pHostUpdate, "VBoxUpdate(updateCheckType, ptrProgress.asOutParam())", rc, __FILE__, __LINE__);
     303            com::GlueHandleComError(pHostUpdate, UpdateCheck::tr("VBoxUpdate(updateCheckType, ptrProgress.asOutParam())"),
     304                                    rc, __FILE__, __LINE__);
    301305        return RTEXITCODE_FAILURE;
    302306    }
    303307
    304308    /* HRESULT hrc = */ showProgress(ptrProgress);
    305     CHECK_PROGRESS_ERROR_RET(ptrProgress, ("Check for update failed."), RTEXITCODE_FAILURE);
     309    CHECK_PROGRESS_ERROR_RET(ptrProgress, (UpdateCheck::tr("Check for update failed.")), RTEXITCODE_FAILURE);
    306310
    307311    BOOL fUpdateNeeded = FALSE;
    … …  
    319323
    320324        if (fMachineReadable)
    321             RTPrintf("A new version of VirtualBox has been released! Version %ls is available at virtualbox.org.\n"
    322                      "You can download this version here: %ls\n", bstrUpdateVersion.raw(), bstrUpdateURL.raw());
     325            RTPrintf(UpdateCheck::tr(
     326                        "A new version of VirtualBox has been released! Version %ls is available at virtualbox.org.\n"
     327                        "You can download this version here: %ls\n"),
     328                     bstrUpdateVersion.raw(), bstrUpdateURL.raw());
    323329        else
    324330        {
    … …  
    328334    }
    329335    else if (!fMachineReadable)
    330         RTPrintf("You are already running the most recent version of VirtualBox.\n");
     336        RTPrintf(UpdateCheck::tr("You are already running the most recent version of VirtualBox.\n"));
    331337
    332338    return RTEXITCODE_SUCCESS;

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageUtils.cpp

    r88087 r92372  
    1818#ifndef VBOX_ONLY_DOCS
    1919#include "VBoxManageUtils.h"
     20#include "VBoxManage.h"
    2021
    2122#include <iprt/message.h>
    … …  
    2829using namespace com;
    2930
    30 
     31DECLARE_TRANSLATION_CONTEXT(Utils);
    3132
    3233unsigned int getMaxNics(const ComPtr<IVirtualBox> &pVirtualBox,
    … …  
    100101        {
    101102            case HostNetworkInterfaceType_Bridged:
    102                 pszTypeName = "type bridged";
     103                pszTypeName = Utils::tr("type bridged");
    103104                break;
    104105
    105106            case HostNetworkInterfaceType_HostOnly:
    106                 pszTypeName = "type host-only";
     107                pszTypeName = Utils::tr("type host-only");
    107108                break;
    108109
    109110            default:
    110111                RTStrPrintf(a_szUnknownTypeBuf, sizeof(a_szUnknownTypeBuf),
    111                             "unknown type %RU32", enmType);
     112                            Utils::tr("unknown type %RU32"), enmType);
    112113                pszTypeName = a_szUnknownTypeBuf;
    113114                break;
    114115        }
    115116
    116         RTMsgWarning("Interface \"%s\" is of %s", pszTargetName, pszTypeName);
     117        RTMsgWarning(Utils::tr("Interface \"%s\" is of %s"), pszTargetName, pszTypeName);
    117118        return;
    118119    }
    119120
    120     RTMsgWarning("Interface \"%s\" doesn't seem to exist", pszTargetName);
     121    RTMsgWarning(Utils::tr("Interface \"%s\" doesn't seem to exist"), pszTargetName);
    121122}
    122123
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette