/*
 * Wine command prompt
 * Slovenian Language Support
 *
 * Copyright (C) 2003, 2008 Rok Mandeljc
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#pragma code_page(65001)

LANGUAGE LANG_SLOVENIAN, SUBLANG_DEFAULT

STRINGTABLE
{
  WCMD_ATTRIB, "Pomoč za ATTRIB\n"
  WCMD_CALL,
"CALL <ime_paketne_datoteke> uporabimo znotraj paketne datoteke (batch file),\n\
kadar želimo izvršiti ukaze iz druge paketne datoteke. Ko klicana paketna\n\
datoteka preneha z izvajanjem, vrne nadzor nadrejeni datoteki (klicatelju).\n\
Ukazu CALL je možno posredovati tudi parametre, ki naj bodo posredovani klicani\n\
paketni datoteki.\n\
\n\
Spremembe trenutne mape, spremenljivk okolja, ipd., ki so napravljene znotraj\n\
klicane paketne datoteke, so posredovane klicatelju (nadrejeni datoteki).\n"
  WCMD_CD,     "Pomoč za CD\n"
  WCMD_CHDIR,  "Pomoč za CHDIR\n"

  WCMD_CLS,    "CLS počisti zaslon konzole\n"

  WCMD_COPY,   "Pomoč za COPY\n"
  WCMD_CTTY,   "Pomoč za CTTY\n"
  WCMD_DATE,   "Pomoč za DATE\n"
  WCMD_DEL,    "Pomoč za DEL\n"
  WCMD_DIR,    "Pomoč za DIR\n"

  WCMD_ECHO,
"ECHO <niz> prikaže <niz> v trenutni konzoli.\n\
\n\
ECHO ON povzroči izpis vseh sledečih ukazov iz paketne datoteke pred dejansko\n\
izvršitvijo le-teh.\n\
\n\
ECHO OFF izključi učinek ukaza ECHO ON (privzeta vrednost za ECHO je OFF).\n\
Izpis ukaza ECHO OFF lahko preprečimo tako, da predenj dodamo znak @.\n"

  WCMD_ERASE,  "Pomoč za ERASE\n"

  WCMD_FOR,
"Ukaz FOR uporabimo za izvršitev ukaza za vsako datoteko iz podanega nabora datotek.\n\
\n\
Sintaksa: FOR %spremenljivka IN (nabor) DO ukaz\n\
\n\
Wine-ov cmd ne zahteva uporabe dvojnega znaka % pri uporabi ukaza FOR v\n\
paketnih datotekah.\n"

  WCMD_GOTO,
"Ukaz GOTO premakne izvrševanje na drug stavek v paketni datoteki.\n\
\n\
Ciljna oznaka za ukaz GOTO je lahko dolga največ 255 znakov, vendar za razliko\n\
od ostalih operacijskih sistemov ne sme vsebovati presledkov. Če v paketni\n\
datoteki obstajata dve enaki oznaki, bo vedno izvršena le prva. Poskus uporabe\n\
ukaza GOTO z neobstoječo oznako povzroči konec izvrševanja paketne datoteke.\n\
\n\
V interaktivnem načinu ukaz GOTO nima nobenega učinka.\n"

  WCMD_HELP,   "Pomoč za HELP\n"

  WCMD_IF,
"IF uporabljamo za pogojno izvrševanje ukazov.\n\
\n\
Sintaksa:	IF [NOT] EXIST ime_datoteke ukaz\n\
	IF [NOT] niz1==niz2 ukaz\n\
	IF [NOT] ERRORLEVEL stevilo ukaz\n\
\n\
V drugem primeru zgoraj morata biti niz1 in niz2 v dvojnih navednicah.\n\
Primerjava razlikuje med malimi in velikimi črkami.\n"

  WCMD_LABEL,  "LABEL uporabljamo za nastavljanje oznake pogona.\n\
\n\
Sintaksa: LABEL [pogon:]\n\
Ukaz povpraša po novi oznaki za želeni pogon.\n\
Trenutno oznako pogona lahko prikažete z ukazom VOL.\n"

  WCMD_MD,     "Pomoč za MD\n"
  WCMD_MKDIR,  "Pomoč za MKDIR\n"
  WCMD_MOVE,
"MOVE prestavi datoteko ali mapo na novo mesto v datotečnem sistemu.\n\
\n\
Če premikate mapo, bo premaknjena tudi vsa vsebina (datoteke in podmape) le-te.\n\
\n\
MOVE ne more premikati datotek oz. map med mesti na različnih pogonih.\n"

  WCMD_PATH,
"PATH prikaže oz. spremeni iskalno pot za cmd.\n\
\n\
Sam ukaz PATH prikaže trenutno nastavitev PATH (v osnovi je le-ta enaka\n\
vrednosti, ki je podana v datoteki wine.conf). Če želite spremeniti nastavitev,\n\
podajte novo vrednost kot parameter ukaza PATH.\n\
\n\
Nastavitev PATH je prav tako možno spremeniti z uporabo spremeljivke okolja\n\
PATH:\n\
		PATH %PATH%;c:\\temp\n"

  WCMD_PAUSE,
"PAUSE izpiše na zaslonu sporočilo 'Za nadaljevanje pritisnite Return'\n\
in počaka, da uporabnik pritisne tipko Return. Ukaz je uporaben v paketnih\n\
datotekah, ko želimo omogočiti uporabniku, da prebere izhodna sporočila\n\
prejšnjih ukazov, preden le-ta izginejo z zaslona.\n"

  WCMD_PROMPT,
"PROMPT spremeni ukazni poziv ukazne vrstice.\n\
\n\
Niz, ki sledi ukazu PROMPT (vključno s presledkom, ki mu sledi)\n\
se pojavi na začetku vrstice, ko cmd čaka na vnos.\n\
\n\
Sledeči nizi imajo poseben pomen:\n\
\n\
$$    Znak za dolar       $_    Linefeed            $b    Znak |\n\
$d    Trenutni datum      $e    Escape              $g    Znak >\n\
$l    Znak <              $n    Trenutni pogon      $p    Trenutna pot\n\
$q    Enačaj              $t    Trenutni čas        $v    različica cmd\n\
\n\
Ukaz PROMPT brez niza za nov poziv povzroči ponastavitev ukaznega poziva. Le-ta\n\
je sestavljen iz poti trenutne mape (vključno s črko pogona), ki ji sledi znak\n\
> (ekvivalento ukazu PROMPT $p$g).\n\
\n\
Ukazni poziv je prav tako možno spremeniti z uporabo spremenljivke okolja PROMPT;\n\
ukaz 'SET PROMPT=text' ima enak učinek kot 'PROMPT text'.\n"

  WCMD_REM,
"Vrstica, ki se začenja z REM (kateremu sledi presledek), se ne izvede in jo\n\
zato lahko uporabimo kot komentar v paketni datoteki.\n"

  WCMD_REN,    "Pomoč za REN\n"
  WCMD_RENAME, "Pomoč za RENAME\n"
  WCMD_RD,     "Pomoč za RD\n"
  WCMD_RMDIR,  "Pomoč za RMDIR\n"

  WCMD_SET,
"SET prikaže oz. nastavi vrednost spremenljivke okolja.\n\
\n\
SET brez parametrov prikaže vse spremenljivke trenutnega okolja.\n\
\n\
Sintaksa za ustvarjanje spremenljivke oz. spremninjaje njene vrednosti je:\n\
\n\
      SET <spremenljivka>=<vrednost>\n\
\n\
kjer sta tako <spremenljivka> kot <vrednost> znakovna niza. Pred enačajem ne\n\
sme biti presledka. Ime spremenljivke prav tako ne sme vsebovati presledkov.\n\
\n\
Pri Wine-u je okolje matičnega operacijskega sistema vključeno v Win32 okolje,\n\
zato v splošnem le-to vsebuje več spremenljivk okolja kot bi jih resnično\n\
Win32 okolje. S programom cmd ni mogoče vplivati na okolje matičnega\n\
operacijskega sistema.\n"

  WCMD_SHIFT,
"SHIFT uprabimo v paketni datoteki, da odstranimo prvi parameter s seznama\n\
parametrov; parameter 2 tako postane parameter 1, itd. Ukaz nima nobenega\n\
učinka, če ga uporabimo iz ukazne vrstice.\n"

  WCMD_TIME,   "Pomoč za TIME\n"

  WCMD_TITLE,  "Nastavi naslov za cmd okno; sintaksa je: TITLE [niz]\n"

  WCMD_TYPE,
"TYPE <ime_datoteke> prikaže vsebino datoteke <ime_datoteke> na zaslonu (oz.\n\
drugje, če gre za preusmeritev). Ukaz ne preveri, ali je vsebina datoteke v\n\
resnici berljivo besedilo.\n"

  WCMD_VERIFY,
"VERIFY uporabimo za nastavljanje, brisanje ali testiranje zastavice prevejanja.\n\
Veljavne oblike ukaza so:\n\
\n\
VERIFY ON	Vključi zastavico\n\
VERIFY OFF	Izključi zastavico\n\
VERIFY		Prikaže ON oz. OFF.\n\
\n\
Zastavica preverjanja nima nobene funkcije v Wine.\n"

  WCMD_VER,
"VER prikaže različico cmd\n"

  WCMD_VOL,    "Pomoč za VOL\n"

  WCMD_PUSHD,  "PUSHD <ime_mape> shrani trenutno mapo in se nato preseli v\n\
navedeno mapo.\n"

  WCMD_POPD,   "POPD se preseli iz trenutne mape v mapo, ki je bila nazadnje\n\
shranjena z ukazom PUSHD.\n"

  WCMD_MORE,   "MORE prikaže vsebino datotek ali preusmerjenega vnosa po straneh.\n"

  WCMD_EXIT,
"EXIT konča trenutno ukazno sejo in vrne ustrezno stanje operacijskemu sistemu\n\
oziroma ukazni lupini, iz katere ste zagnali cmd.\n"

  WCMD_ALLHELP, "Vgrajeni ukazi CMD so:\n\
ATTRIB\t\tPrikaže ali spremeni DOS atribute datotek\n\
CALL\t\tPokliče paketni program iz drugega paketnega programa\n\
CD (CHDIR)\tSpremeni trenutno mapo\n\
CLS\t\tPočisti zaslon\n\
COPY\t\tKopira datoteko\n\
CTTY\t\tSpremeni vhodno/izhodno napravo\n\
DATE\t\tPrikaže oz. spremeni sistemski datum\n\
DEL (ERASE)\tIzbriše eno ali več datotek\n\
DIR\t\tIzpiše vsebino mape\n\
ECHO\t\tPrikaže besedilo v konzoli\n\
HELP\t\tPrikaže kratko besedilo s pomočjo o želeni temi\n\
MD (MKDIR)\tUstvari podmapo\n\
MORE\t\tIzpiše besedilo po straneh\n\
MOVE\t\tPremakne eno ali več datotek ali map\n\
PATH\t\tNastavi oz. prikaže iskalno pot\n\
POPD\t\tNastavi trenutno mapo na mapo, nazadnje shranjeno z ukazom PUSHD\n\
PROMPT\t\tSpremeni ukazni poziv\n\
PUSHD\t\tShrani trenutno mapo in se preseli v navedeno mapo\n\
REN (RENAME)\tPreimenuje datoteko\n\
RD (RMDIR)\tIzbriše podmapo\n\
SET\t\tNastavi oz. prikaže vrednost spremenljivke okolja\n\
TIME\t\tNastavi oz. prikaže trenutni sistemski čas\n\
TITLE\t\tNastavi naslov okna CMD seje\n\
TYPE\t\tPrikaže vsebino besedilne datoteke\n\
VER\t\tPrikaže trenutno različico CMD\n\
VOL\t\tPrikaže oznako pogona\n\
EXIT\t\tZapre CMD sejo\n\n\
Uporabite HELP <ukaz> za več informacijo o kateremkoli od zgoraj navedenih ukazov\n"

  WCMD_CONFIRM, "Ali ste prepričani?"
  WCMD_YES, "D"
  WCMD_NO, "N"
  WCMD_NOASSOC, "Manjkajoča povezava s programom za končnico %s\n"
  WCMD_NOFTYPE, "Noben ukaz ni povezan z vrsto datotek '%s'\n"
  WCMD_OVERWRITE, "Ali naj prepišem %s?"
  WCMD_MORESTR, "Več ..."
  WCMD_TRUNCATEDLINE, "Vrstica v paketni datoteki je morda skrajšana. Uporabljam:\n"
  WCMD_NYI, "Ni (še) na voljo\n\n"
  WCMD_NOARG, "Manjkajoč argument\n"
  WCMD_SYNTAXERR, "Napaka v sintaksi\n"
  WCMD_FILENOTFOUND, "%s : datoteke ni mogoče najti\n"
  WCMD_NOCMDHELP, "Za ukaz %s pomoč ni na voljo\n"
  WCMD_NOTARGET, "Cilja ukaza GOTO ni mogoče najti\n"
  WCMD_CURRENTDATE, "Trenuten datum je %s\n"
  WCMD_CURRENTTIME, "Trenuten čas je %s\n"
  WCMD_NEWDATE, "Vnesite nov datum: "
  WCMD_NEWTIME, "Vnesite nov čas: "
  WCMD_MISSINGENV, "Spremenljivka okolja %s ni definirana\n"
  WCMD_READFAIL, "Napaka pri odpiranju '%s'\n"
  WCMD_CALLINSCRIPT, "Klic paketne oznake zunaj paketne datoteke ni mogoč\n"
  WCMD_ALL, "A"
  WCMD_DELPROMPT, "Ali naj izbrišem %s?"
  WCMD_ECHOPROMPT, "Odmev je %s\n"
  WCMD_VERIFYPROMPT, "Zastavica preverjanja je nastavljena na %s\n"
  WCMD_VERIFYERR, "Vrednost zastavice preverjanja mora biti ON ali OFF\n";
  WCMD_ARGERR, "Napaka parametra\n"
  WCMD_VOLUMEDETAIL, "Podatkovni nosilec v pogonu %c je %s\nSerijska št. nosilca je %04x-%04x\n\n"
  WCMD_VOLUMEPROMPT, "Oznaka podatkovnega nosilca (11 znakov, ENTER za brez)?"
  WCMD_NOPATH, "Poit PATH ni mogoče najti\n"
  WCMD_ANYKEY,"Za nadaljevanje pritisnite Return: "
  WCMD_CONSTITLE,"Wine ukazni poziv"
  WCMD_VERSION,"CMD različica %s\n\n"
  WCMD_MOREPROMPT, "Več? "
}

#pragma code_page(default)
