<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html lang="sl">
<head>
 <title>Sporočanje napak v OpenOffice.org</title>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 <meta http-equiv="Content-Style-Type" content="text/css" />
 <meta name="version" content="3.5.1.19.8" />
 <style type="text/css"> /* <![CDATA[ */
 <!--
 @import "/branding/css/tigris.css";
 @import "/branding/css/inst.css";
 -->
 /* ]]> */</style>
 <link rel="stylesheet" type="text/css" href="Datoteke_za_sl%20%20OpenOffice.org/print.css" media="print" />
 <link rel="shortcut icon" href="http://www.openoffice.org/favicon.ico" />
 <script src="Datoteke_za_sl%20%20OpenOffice.org/tigris.js" type="text/javascript"></script>
 <meta name="keywords" content="OpenOffice.org, Open Office, OpenOffice, openoffice, StarOffice, Star Office, OOo, ooo, xml, open source, developer, UNO" />
 <meta name="description" content="OpenOffice.org: Odprt pisarniški paket" />
 <meta name="keywords" content="OpenOffice, open office, office suite, office, international office, linux, Linux, Linux Office, Collaboration, Companies, Open Source, UNO, Java, StarOffice" />
</head>
<body>
<div id="body2col">
<h2>Sporočanje napak</h2>

<p>Tudi če niste programer, lahko pomagate pri izboljšavah OpenOffice.org tako, da razvijalcem sporočite napake, ki jih odkrijete pri delovanju programske opreme. Od začetka projekta je bilo na ta način odpravljenih ogromno napak.</p>
<p>Sistem za sporočanje napak (hroščev) se imenuje "<b>Issuezilla</b>" in je na voljo v angleščini. "<b>Issue</b>" tako pomeni napako (hrošč, bug) oz. problem z delovanjem programa. Če naletite na napako, jo tako lahko posredujete (<b>commit an issue</b>).</p>
<p>Za sporočanje napak morate biti <a href="http://www.openoffice.org/servlets/Join">registriran</a> član projekta OpenOffice.org. To pomeni samo to, da je projektu znan vaš e-naslov. Tako je omogočeno spremljanje vašega sporočila o napaki, kadar koli se kaj spremeni (na koncu je najlepše videti, da je rešen oz. <b>solved</b>). Ko se registrirate kot član projekta, se morate <a href="http://www.openoffice.org/servlets/TLogin">prijaviti</a>. Vaš brskalnik mora omogočati sprejem piškotkov (cookies).</p> 
<p>Ker obstaja verjetnost, da je enako ali podobno napako že sporočil drugi uporabnik, je priporočljivo, da v Issuezilli najprej <a href="http://www.openoffice.org/issues/query.cgi">pregledate</a> že sporočene napake. Sprva je videti kar zapleteno; na srečo je največkrat
potrebno vnesti samo nekaj polj. Pametno je izbrati vse možnosti STATUS-a (vse izberete tako, da kliknete na prvo (UNCONFIRMED), pritisnete tipko Shift, držite in kliknete še na zadnjo možnost (CLOSED). Tako dobite v pregledu tudi napake, ki so že bile rešene ampak niso še vključene v zadnjo različico programa. Naslednji korak je vnos opisa ali ključnih besed v polju "Summary" ali "A description entry". Vnesti morate angleške besede! Preostane le še klik na "Submit". Če na seznamu ne najdete enake ali podobne težave, kot je vaša, lahko nadaljujete s sporočanjem napak na <a href="http://www.openoffice.org/issues/enter_bug.cgi">"Sporoči novo napako"</a>.</p>
<p>Naslednji korak je določitev, v kateri del OpenOffice.org spada vaša napaka. Če niste prepričani, izberite po svoji presoji najboljši približek.</p>
<p>Zdaj lahko vnesete opis vaše napake. Poskusite vključiti kar največ informacij, ki bi lahko pomagale razvijalcem: po kakšni poti ste do problema prišli ipd. Pred sporočanjem prve napaka priporočamo branje <a href="http://www.openoffice.org/bugs/bug_writing_guidelines.html">Navodil za sporočanje napak</a>. V dokumentu so pojasnjene vloge vseh polj, ki se pojavijo na tej strani.</p>
<p>Za zaključek samo še napotek. Če uporabljate slovensko različico OpenOffice.org, je morda težko opisati problem v angleščini - morda že zaradi imena menijev, gumbov in pogovornih oken. V ta namen lahko uporabite prevedeni slovar najpogosteje uporabljenih besed in izrazov v OpenOffice.org (Glossary), ki ga najdete <a href="http://openoffice.lugos.si/down/">tukaj</a>.</p>
<p style="text-align:right"><a href="http://validator.w3.org/check?uri=referer"><img src="http://www.w3.org/Icons/valid-xhtml10" alt="Veljaven XHTML 1.0 Strict" height="31" width="88" /></a></p>
</div>
</body>
</html>
