<!DOCTYPE html>
<html>
	<head>
	<title>Apache OpenOffice - Native Lang Indonesia</title>
	<style type="text/css">
		div#apphead { display: none !important; }
		p.tasknav { display: none !important; }
		div.axial { display: none !important; }
		div#bodycol { padding: 0!important; margin: -1em 0 0 0; width:100%; }
		/* For now, comment this line
		div#helptext { display: none !important; }
		td#leftcol { display: none !important; }
		*/
		td#bodytd { width: auto; padding: 0; margin: 0;}
		/* For now, set to 100% */
		div#maincontent { float: left; width: 100%; background: url("images/OOo_background.gif") no-repeat top right; }
		div.h3 h3 p { display: none !important; }
		h1 { margin-top: -0.3em; }
		
		/* Taken from original www.openoffice.org */
		.contentpart#spotlight .graphicalpresentation { float: right; clear: none; overflow: hidden; display: block; margin: 0 5px 0 0; padding: 0px; width: 40%; font-size: .8em; text-align: right; }
		.contentpart#spotlight .graphicalpresentation h2 { font-size: 1.2em; }
		.contentpart#spotlight .graphicalpresentation img {	float: left; padding:0px;	margin: 0px; margin-left: auto; }
		.ooocomponents { float: right; width: 100%; margin: 0px; margin-bottom: 1px; padding :0px; background: #F6F8FB url("/branding/images/fadelightbluetowhitevertica.gif") repeat-x top right; border: none 0px; border-top: 1px solid #5684af; }
		.ooocomponentslist { float: right; display: block; list-style: none; margin: 0px; padding: 0px; text-align: right; }
		.contentpart#spotlight .ooocomponentslist li { float: right; clear: none; width: 3.8em; margin: 0px; margin-left: 2px; margin-right: 1px;	padding: 0px; }
		.contentpart#spotlight .ooocomponentslist a { width: 3.7em; margin: 0px; padding: 1px; padding-top: 20px; display: block; color: #06348C; background: no-repeat top center; text-decoration: none; text-align: center; vertical-align: middle; float: right; clear: none; }
		.contentpart#spotlight .ooocomponentslist a:hover {	background-color: #fff; color: #698ed1; }
		.contentpart#spotlight .ooocomponentslist .ooobase a { background-image: url("/branding/images/iconooobase.gif"); }
		.contentpart#spotlight .ooocomponentslist .ooocalc a { background-image: url("/branding/images/iconooocalc.gif"); }
		.contentpart#spotlight .ooocomponentslist .ooodraw a { background-image: url("/branding/images/iconooodraw.gif"); }
		.contentpart#spotlight .ooocomponentslist .ooomath a { background-image: url("/branding/images/iconooomath.gif"); }
		.contentpart#spotlight .ooocomponentslist .oooimpress a { background-image: url("/branding/images/iconooopres.gif"); }
		.contentpart#spotlight .ooocomponentslist .ooowriter a { background-image: url("/branding/images/iconooowrit.gif"); }
	</style>
	</head>
	<body>
	<div id="maincontent">	
   <h1>Native Lang Indonesia</h1>
		
		
	
	
<h2>We need your help to complete the translation of Apache OpenOffice into Indonesian!</h2>
	<p>
		This note is in English because we have no one to translate it into your language. The links on the page will help you download and install OpenOffice.org 3.3.0, an older version of our product. It is missing
		many bug fixes, performance enhancements and even new features that are in Apache OpenOffice 4.1.6.
	</p>
	<p>
		We would be happy to make Apache OpenOffice available in Indonesian, but we need help completing the translation of the user interface.  This translation is 96% complete already.  We need a volunteer or two who 
		can help us translate the remaining 4%.  
	</p>
	<p>
		If you are interested in helping translate, please review <a href="https://openoffice.apache.org/translate.html">this information</a>. 
	</p>
	<hr>	
		
   <p>Proyek ini bertujuan untuk membangun sebuah komunitas yang nantinya diharapkan bisa berkontribusi pada proyek OOo (OpenOffice.org) dan menghasilkan OOo versi Indonesia. </p>
   <p>Bagi Anda yang tertarik untuk menjadi kontributor pada proyek Native Lang Indonesia, Anda terlebih dahulu harus mendaftarkan diri pada situs <a href="https://www.openoffice.org">OpenOffice.org</a>. Untuk informasi lebih lanjut, Anda bisa melihat panduan untuk melakukan <a href="https://contributing.openoffice.org/index.html">kontribusi</a> atau bisa menghubungi <a href="mailto:willysr@openoffice.org">Project Leader</a> untuk proyek Native Lang Indonesia.</p>
   <h3>Dokumentasi OpenOffice.org</h3>
   <p>Untuk saat ini, beberapa dokumentasi <a href="https://documentation.openoffice.org/id/HOW_TO">HOWTO</a>, <a href="https://documentation.openoffice.org/id/manuals">manual</a> serta <a href="https://documentation.openoffice.org/setup_guide2/index.html#id">Setup Guide</a> versi bahasa Indonesia sudah tersedia pada situs <a href="https://documentation.openoffice.org/id">Dokumentasi OpenOffice Indonesia</a>. Dokumentasi ini akan terus diupdate oleh para kontributor pada proyek Dokumentasi OpenOffice.org Indonesia.</p>
   <p>Bagi Anda yang tertarik untuk menjadi kontributor pada proyek Dokumentasi OpenOffice.org Indonesia, silahkan mengunjungi situs <a href="https://documentation.openoffice.org/id/">Proyek Dokumentasi OpenOffice.org</a>.</p>
   <div class="contentpart" id="spotlight">
		  <div id="spotlightgull">
		    <div class="graphicalpresentation">
		      <div class="ooocomponents">
		        <h2> Komponen OpenOffice.org 3: </h2>		
		        <ul class="ooocomponentslist">
		          <li class="ooobase"> <a href="produk/base.html" title="Database">Base</a> </li>
		          <li class="ooocalc"> <a href="produk/calc.html" title="Spreadsheet">Calc</a> </li>
		          <li class="ooodraw"> <a href="produk/draw.html" title="Vector drawing tool">Draw</a> </li>
							<li class="ooomath"> <a href="produk/math.html" title="Mathematical function creator">Math</a> </li>
		          <li class="oooimpress"> <a href="produk/impress.html" title="Presentation program">Impress</a> </li>
		          <li class="ooowriter"> <a href="produk/writer.html" title="Wordprocessor">Writer</a> </li>
		        </ul>
		      </div>
		    </div>
		  </div>
		</div>
   <h3>Download OpenOffice.org</h3>
   <ul>
   	<li><a href="https://download.openoffice.org/">OpenOffice.org 3.2.0</a></li>
   	<li><a href="https://documentation.openoffice.org/id/setup_guide2/SETUP_GUIDE_ID.zip">Panduan Instalasi OpenOffice.org 2.0</a> (REV A_10)</li>
  </ul>
  <h3>Kampanye Komunitas</h3>
  <p><a href="why/index.html"><img style="border: 0px solid; width: 158px; height: 111px; float: left; margin-right: 0.5em;" src="images/why_home_small.gif" alt="Kenapa OpenOffice.org" /></a>Kampanye <a href="https://why.openoffice.org">Why OpenOffice.org</a> telah mengalami perubahan tampilan yang lebih menarik dan juga alasan-alasan lain yang disesuaikan dengan beberapa bidang tertentu, seperti pemerintahan, pendidikan, bisnis, nirlaba, bisnis IT, dan advokat F/OSS. Silahkan lihat dan buktikan. Paket kampanye ini juga tersedia dalam versi <a href="why/index.html">bahasa Indonesia</a>.</p><br/><br/><br/><br/>
  <p><a href="pilihananda.html"><img style="border: 0px solid; width: 158px; height: 79px; float: left; margin-right: 0.5em;" src="images/ooo_pilihananda.png" alt="Ini Pilihan Anda. Dapatkan OpenOffice.org" /></a>Kampanye <a href="https://why.openoffice.org/yourchoice.html">It's Your Choice - Get OpenOffice.org</a> telah dimulai. Kami mengharapkan para pengguna OpenOffice.org untuk mulai mempromosikan OpenOffice.org sebagai perangkat lunak yang bebas dan gratis sebagai alternatif untuk Microsoft Office 2007. Apakah Anda akan menghabiskan uang Anda untuk membeli lisensi sebuah paket perangkat lunak yang melakukan hal yang sama dengan apa yang Anda miliki sekarang? Terlebih lagi, <a href="https://download.openoffice.org/2.2.0/index.html">OpenOffice.org</a> dapat diperoleh tanpa biaya sama sekali. Paket kampanye ini juga tersedia dalam versi <a href="pilihananda.html">bahasa Indonesia</a>.</p>
  <p><a href="ujicoba.html"><img style="border: 0px solid; width: 158px; height: 79px; float: left; margin-right: 0.5em;" src="images/ooo_ujicoba.png" alt="Miliki Mobilnya. Dapatkan OpenOffice.org" /></a>Kampanye <a href="https://why.openoffice.org/keepthecar.html">Take a Test Drive - Keep the Car!</a> telah dimulai. Kami mengharapkan para pengguna OpenOffice.org untuk mulai mempromosikan OpenOffice.org sebagai perangkat lunak yang bebas dan gratis sebagai alternatif untuk Microsoft Office 2007. Anda tidak perlu lagi mengujicoba sebuah produk yang nantinya akan tersedia dalam versi komersial. Cukup dengan mendownload <a href="https://download.openoffice.org/2.2.0/index.html">OpenOffice.org</a>, Anda akan mendapatkan sebuah salinan paket perangkat lunak perkantoran yang legal dan berfungsi secara penuh. Paket kampanye ini juga tersedia dalam versi <a href="ujicoba.html">bahasa Indonesia</a>.</p>
  <p><a href="legal.html"><img style="border: 0px solid ; width: 158px; height: 79px; float: left; margin-right: 0.5em;" src="images/ooo_get_legal.png" alt="Legalkan Diri Anda. Dapatkan OpenOffice.org" /></a>Kampanye <a href="https://why.openoffice.org/getlegal.html">Get Legal - Get OpenOffice.org</a> telah dimulai. Kami mengharapkan para pengguna OpenOffice.org untuk mulai mempromosikan OpenOffice.org sebagai perangkat lunak yang bebas dan gratis sebagai alternatif untuk Microsoft Office. Juga tersedia dalam versi <a href="legal.html">bahasa Indonesia</a>.</p>
  <br />
  <h3>Berita Komunitas</h3>
  <ul>
        <li>Salah seorang kontributor untuk proyek Translasi OpenOffice.org Indonesia, Dirgita Devina merilis 3 buku OpenOffice.org (Bisa OOo Writer, Bisa OOo Calc, dan Bisa OOo Math) pada <a href="https://dirgitadevina.web.id/nonfiksi/2010/">webnya</a>. Buku bisa didownload secara gratis.</li>
	<li><a href="https://download.openoffice.org/">OpenOffice.org 3.2.0</a> telah dirilis. Versi ini menawarkan peningktakan performa dan juga banyak perbaikan serta penambahan fitur baru lainnya. Catatan rilis dari versi ini bisa Anda lihat pada <a href="https://development.openoffice.org/releases/3.2.0.html">disini</a>. Daftar fitur baru OOo 3.2.0 dapat dilihat <a href="https://www.openoffice.org/dev_docs/features/3.2/index.html">disini</a>.</li>
	<li>Informasi tentang bagaimana berkontribusi untuk proyek translasi OpenOffice.org kedalam bahasa Indonesia (sebagai bagian dari proyek <a href="https://native-lang.openoffice.org">Native Lang</a>) telah diupdate. Silahkan melihat halaman <a href="https://wiki.openoffice.org/wiki/Id.openoffice.org">wiki OpenOffice.org</a> untuk informasi lebih lanjut.</li>
	<li>Ihsan Faisal telah mengirimkan 17 dokumen panduan Writer untuk OpenOffice.org 2.x. Anda bisa mendapatkan panduan ini pada proyek <a href="https://documentation.openoffice.org/id/Contrib/index.html">Dokumentasi OpenOffice.org Indonesia</a></li>
	<li>Format OOXML yang diajukan oleh Microsoft pada akhirnya gagal untuk mendapatkan persetujuan untuk diajukan pada lembaga standarisasi ISO setelah mengalami kegagalan dalam memperoleh suara dari berbagai negara yang berakhir pada 2 September yang lalu. Dengan lebih dari 6000 halaman spesifikasi, banyak pihak merasa kesulitan untuk mempelajarinya (termasuk pihak Indonesia yang pada akhirnya memilih untuk abstain). Selain itu, juga ditemukannya banyak masalah kompatibilitas serta implementasi dengan standar yang lain.</li>
  	<li>Pada tanggal 26 Maret 2007, <a href="http://www.axioo.net/">Axioo Indonesia</a> kembali mengadakan kerjasama dengan pihak OpenOffice.org untuk turut serta memasarkan software OpenOffice secara resmi disemua produk Notebook Axioo. Setelah sukses dengan rencana untuk menawarkan OpenOffice.org kedalam CD Rescue Axioo, maka kali ini, Axioo mencoba menawarkan paket OpenOffice.org versi Windows pada semua paket notebooknya. Untuk informasi lebih jelasnya, Anda bisa mengunjungi situs <a href="http://www.axioo.net/?section=news&amp;item=0">Axioo Indonesia</a>.</li>
  	<li>Saat ini Indonesia telah memiliki seorang Marketing Contact, yaitu Bapak <a href="mailto:mailto:farid@aseansec.org">Farid Azis</a>. Beliau akan menjadi penyedia informasi untuk proyek, produk, dan proses pengembangan dari OpenOffice.org. Apabila Anda membutuhkan informasi tentang OpenOffice.org untuk wilayah Indonesia, silahkan menghubungi beliau melalui emailnya.</li>
  	<li><a href="https://documentation.openoffice.org">Proyek Dokumentasi OpenOffice.org</a> telah mengadakan sebuah kontes untuk pembuatan clipart dan template yang bertujuan untuk meningkatkan koleksi clipart/template dari produk aplikasi OpenOffice.org. Apabila Anda tertarik untuk mengikuti kontes ini, silahkan mengunjungi <a href="https://documentation.openoffice.org/testdir/Contest/Contest1.html">halaman informasi kontes</a>. Total hadiah yang disediakan oleh pihak sponsor adalah sebesar US$5000. Semua template/clipart hasil kiriman setiap orang akan tersedia secara umum pada halaman <a href="https://documentation.openoffice.org/Samples_Templates/index.html">repository template</a></li>
  	<li>Kampanye OpenOffice.org pada halaman Metro sudah terbit pada tanggal 31 Juli 2006 yang lalu. Anda dapat melihat contoh <a href="images/open-office-metro-ad.jpg">brosurnya</a> dan mendownload versi lengkapnya pada situs <a href="http://homepage.mac.com/bhorst/">Benjamin Horst</a>. Terima kasih kepada Benjamin Horst dan John Kakoulides atas desain dan kerja kerasnya.</li>  	
  	<li><a href="https://documentation.openoffice.org/setup_guide2/2.x/id/SETUP_GUIDE_ID.zip">Panduan Installasi OOo 2.0 versi Bahasa Indonesia</a> sudah tersedia pada situs <a href="https://documentation.openoffice.org/id/index.html">Dokumentasi OpenOffice.org Indonesia</a></li>
  	<li><a href="https://documentation.openoffice.org/id/Contrib/index.html">Peluncuran Repository Kontribusi Diluar Proyek Dokumentasi OOo</a></li>
  </ul>
  <p>Jika Anda memiliki berita, artikel, ataupun kegiatan yang berhubungan dengan OpenOffice.org, maka silahkan kirimkan URL atau artikel tersebut kepada <a href="mailto:willysr@openoffice.org">Project Leader</a> untuk dimuat pada situs ini.</p>
  </div>
  </body>
</html>
