<!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>Kaj je 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>OpenOffice.org - kaj je to?</h2>
<p>OpenOffice.org je odprtokodni projekt s poslanstvom ustvariti vodilni mednarodni pisarniški paket, ki bo tekel na vseh glavnih platformah in bo zagotavljal dostop do vseh funkcionalnosti in podatkov preko oblike datotek XML in odprtih programskih vmesnikov.</p>
<h3>Paket OpenOffice.org</h3>
<p>OpenOffice.org je tudi izdelek, ki se razvija v okviru tega projekta. To je pisarniški paket, prosto dostopen (in brezplačen) vsakomur. Glede na zmožnosti je primerljiv z dobro znanimi, ne-prostimi pisarniškimi paketi. Obsega naslednje programe (module):</p>
<table border="0">
<tr><td>
<table>
<tr><td><a href="izdelek/writer.html" title="Urejevalnik besedil"><img src="http://www.openoffice.org/branding/images/iconooowrit.gif" style="border:0" alt="Writer" /></a></td><td>Writer (urejevalnik besedil in spletnih strani).</td></tr>
<tr><td><a href="izdelek/calc.html" title="Preglednice"><img src="http://www.openoffice.org/branding/images/iconooocalc.gif" style="border:0" alt ="Calc" /></a></td><td>Calc (urejevalnik preglednic).</td></tr>
<tr><td><a href="izdelek/draw.html" title="Vektorsko risanje"><img src="http://www.openoffice.org/branding/images/iconooodraw.gif" style="border:0" alt="Draw" /></a></td><td>Draw (program za risanje vektorskih slik).</td></tr>
</table>
</td><td style="width:50"></td><td>
<table>
<tr><td><a href="izdelek/impress.html" title="Predstavitve"><img src="http://www.openoffice.org/branding/images/iconooopres.gif" style="border:0" alt="Impress" /></a></td><td>Impress (urejevalnik predstavitev).</td></tr>
<tr><td><a href="izdelek/math.html" title="Oblikovanje formul"><img src="http://www.openoffice.org/branding/images/iconooomath.gif" style="border:0" alt="Math" /></a></td><td>Math (urejevalnik formul).</td></tr>
<tr><td><a href="izdelek/base.html" title="Zbirka podatkov"><img src="http://www.openoffice.org/branding/images/iconooobase.gif" style="border:0" alt="Base" /></a></td><td>Base (modul zbirke podatkov).</td></tr>
</table></td>
</tr>
</table>
<p>OpenOffice.org je po zmožnostih alternativa znanim, ne brezplačnim pisarniškim paketom, kot je npr. MS-Office. Brez težav lahko odprete dokumente iz MS Office (Word, Excel, Powerpoint), jih urejate in shranite v obliko zapisa OpenOffice.org ali v izvirno obliko. OpenOffice.org od različice 2.0 naprej uporablja s standardom ISO potrjen zapis OpenDocument (ODF). Veliko več o paketu in vsakem od njegovih modulov si lahko preberete <a href="izdelek/index.html">tukaj</a>.</p>
<h3>sl.OpenOffice.org</h3>
<p>sl.openoffice.org je podprojekt OpenOffice.org, katerega cilj in namen je približati tako projekt kot tudi sam izdelek slovenski skupnosti. Poudarek je predvsem na temah, pomembnih za slovenske uporabnike, kot so:</p>
<ul>
<li>informacije v slovenskem jeziku (spletne strani in dokumentacija);</li>
<li>dostop do zadnjih slovenskih različic programa;</li>
<li>izboljšave slovenskega prevoda, izvedba in izboljšava jezikovnih orodij (npr. slovar sopomenk);</li>
<li>preizkušanje in zagotavljanje kakovosti slovenskih različic programa;</li>
<li>promocija OpenOffice.org v slovenskem okolju;</li>
</ul>
<p>sl.openoffice.org je dodatek in ne zamenjava za obstoječi projekt OpenOffice.org, zato boste tukaj našli tudi povezave na angleške spletne strani projekta.</p>
<h3>Zgodovina</h3>
<p>OpenOffice.org ima korenine v StarOffice, programskem paketu, ki so ga v sredini osemdesetih razvijali v Nemčiji in ki ga je leta 1999 kupilo podjetje Sun Microsystems. Junija 2000 je bil izdan paket StarOffice, različica 5.2. Najbolj zanimivo pri razvoju StarOffice je, da temelji na isti izvorni kodi kot OpenOffice.org. Podjetje Sun Microsystems je izvorno kodo programskega paketa objavilo pod ustrezno licenco (razen tistih komponent, ki niso njegova last) in tako je nastal projekt OpenOffice.org. To seveda ne pomeni, da je Sun prepustil nadaljnji razvoj le prostovoljcem: večino dela še vedno opravijo razvijalci, zaposleni pri podjetju Sun oz. Oracle, ki tudi skrbi za ostale stroške projekta OpenOffice.org.</p>
<h3>OpenOffice.org in Oracle Open Office (prej Sun StarOffice)</h3>
<p>Iz izvorne kode OpenOffice.org tako nastajata dva produkta: Oracle Open Office (prej Sun StarOffice), v katerega dodajo komponente, ki niso na voljo v izvorni kodi, in OpenOffice.org, v katerem so bile te komponente večinoma zamenjane z odprto-kodnimi alternativami. Razlike med Oracle Open Office (Sun StarOffice) in OpenOffice.org so pojasnjene na naslovu FAQ (v angleškem jeziku). Sicer so v praksi najbolj opazne naslednje razlike:</p>
<ul>
<li>StarOffice ni prost paket; OpenOffice.org je prost paket (in posledično brezplačen);</li>
<li>StarOffice je bolj dodelan (dodatne pisave, predloge, boljši črkovalnik za glavne svetovne jezike);</li>
<li>Sun za StarOffice ponuja neposredno podporo. Pri OpenOffice.org mora za to poskrbeti uporabnik sam oz. skupina uporabnikov (npr. prek dopisnih seznamov);</li>
<li>zaenkrat ne kaže, da bi StarOffice prevedli v slovenščino. OpenOffice.org pa je v celoti na voljo v številnih jezikih, vključno s slovenščino.</li>
</ul>
<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>
