<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<head>
	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=windows-1252">
	<TITLE></TITLE>
	<META NAME="GENERATOR" CONTENT="StarOffice 7  (Win32)">
	<META NAME="CREATED" CONTENT="20041012;22120920">
	<META NAME="CHANGED" CONTENT="20041013;8491458">
	<STYLE>
	<!--
		@page { size: 209.99mm 296.99mm; margin-left: 31.75mm; margin-right: 31.75mm; margin-top: 25.4mm; margin-bottom: 25.4mm }
		P { margin-bottom: 2.12mm }
		H1 { margin-bottom: 2.12mm }
		H1.western { font-family: "Albany", sans-serif; font-size: 16pt }
		H1.cjk { font-family: "Andale Sans UI"; font-size: 16pt }
		H1.ctl { font-family: "Tahoma"; font-size: 16pt }
		H2 { margin-bottom: 2.12mm }
		H2.western { font-family: "Albany", sans-serif; font-size: 14pt; font-style: italic }
		H2.cjk { font-size: 14pt; font-style: italic }
		H2.ctl { font-size: 14pt; font-style: italic }
	-->
	</STYLE>
</head>
<body LANG="en-US" DIR="LTR">
<P ALIGN=CENTER STYLE="margin-top: 4.23mm; page-break-after: avoid"><FONT FACE="Albany, sans-serif"><FONT SIZE=5><B>OpenOffice.org
News Highlights</B></FONT></FONT></P>
<DIV ID="Table of Contents1" DIR="LTR">
	<DIV ID="Table of Contents1_Head" DIR="LTR">
		<P STYLE="margin-top: 4.23mm; page-break-after: avoid"><FONT FACE="Albany, sans-serif"><FONT SIZE=4 STYLE="font-size: 16pt"><B>Table
		of Contents</B></FONT></FONT></P>
	</DIV>
	<P STYLE="margin-bottom: 3mm"><FONT SIZE=4><A HREF="#1.October 2004|outline">October
	2004	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#1.1.Replacing FrameMaker with OOo Writer |outline">Replacing
	FrameMaker with OOo Writer 	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#1.2.Germans claim Linux lowers costs|outline">Germans
	claim Linux lowers costs	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#1.3.Open approach offers Mindef more choice|outline">Open
	approach offers Mindef more choice	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#1.4.Ballmer calls for horse-based attack on Star Office|outline">Ballmer
	calls for horse-based attack on Star Office	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#1.5.Open for Business - The 2004 OfB Choice Awards|outline">Open
	for Business - The 2004 OfB Choice Awards	</A></FONT></P>
	<P STYLE="margin-bottom: 3mm"><FONT SIZE=4><A HREF="#2.September 2004|outline">September
	2004	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#2.1.OpenOffice.org reveals marketing ambitions|outline">OpenOffice.org
	reveals marketing ambitions	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#2.2.Nonprofit brings Linux and open source to Hawaii|outline">Nonprofit
	brings Linux and open source to Hawaii	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#2.3.UK charity builds Linux network on a shoestring|outline">UK
	charity builds Linux network on a shoestring	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#2.4.NSW opens door to Linux offers|outline">NSW
	opens door to Linux offers	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#2.5.Leading Edge Forum Report 2004 - Open Source: Open for Business|outline">Leading
	Edge Forum Report 2004 - Open Source: Open for Business	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#2.6.Linux growing on SMB desktops: Yankee Group|outline">Linux
	growing on SMB desktops: Yankee Group	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#2.7.'Independent' report used MS-sourced data to trash OSS|outline">'Independent'
	report used MS-sourced data to trash OSS	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#2.8.OpenOffice.org Conference Presentations|outline">OpenOffice.org
	Conference Presentations	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#2.9.Open Office XML May Satisfy ISO|outline">Open
	Office XML May Satisfy ISO	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#2.10.UN drive to boost free software|outline">UN
	drive to boost free software	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#2.11.OpenOffice Set for Larger African Effort|outline">OpenOffice
	Set for Larger African Effort	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#2.12.A strong OpenOffice.org community is the key, argues Sun's Danese Cooper|outline">A
	strong OpenOffice.org community is the key, argues Sun's Danese
	Cooper	</A></FONT></P>
	<P STYLE="margin-bottom: 3mm"><FONT SIZE=4><A HREF="#3.August 2004|outline">August
	2004	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#3.1.OpenOffice.org Art Project|outline">OpenOffice.org
	Art Project	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#3.2.Norwegian Native-Lang Project announced (NO)|outline">Norwegian
	Native-Lang Project announced (NO)	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#3.3.OpenOffice.org in three SA languages for Software Freedom Day|outline">OpenOffice.org
	in three SA languages for Software Freedom Day	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#3.4.U.K.'s NHS licenses Sun's Java Desktop System|outline">U.K.'s
	NHS licenses Sun's Java Desktop System	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#3.5.Novell SA implements wall-to-wall Linux|outline">Novell
	SA implements wall-to-wall Linux	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#3.6.(Vietnam) Students get free access to StarOffice software|outline">(Vietnam)
	Students get free access to StarOffice software	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#3.7.Sun Deals Desktops Down Under|outline">Sun
	Deals Desktops Down Under	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#3.8.OpenOffice.org Team Cautiously Optimistic On AOL Office|outline">OpenOffice.org
	Team Cautiously Optimistic On AOL Office	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#3.9.UN body releases desktop Linux guide|outline">UN
	body releases desktop Linux guide	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#3.10.LinuxWorld San Francisco Awards|outline">LinuxWorld
	San Francisco Awards	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#3.11.New Book: &quot;OpenOffice.org Macros Explained&quot;|outline">New
	Book: &quot;OpenOffice.org Macros Explained&quot;	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#3.12.Linux overtakes Mac OS_|outline">Linux
	overtakes Mac OS?	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#3.13.Desktop Linux offers challenge to &quot;Microsoft world&quot;|outline">Desktop
	Linux offers challenge to &quot;Microsoft world&quot;	</A></FONT></P>
	<P STYLE="margin-bottom: 3mm"><FONT SIZE=4><A HREF="#4.July 2004|outline">July
	2004	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#4.1.OpenOffice.org learns Welsh|outline">OpenOffice.org
	learns Welsh	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#4.2.Canadian university picks Xandros Linux desktop for laptops|outline">Canadian
	university picks Xandros Linux desktop for laptops	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#4.3.Press release: Allied Irish Bank Selects Sun Microsystems Java(TM) Desktop System|outline">Press
	release: Allied Irish Bank Selects Sun Microsystems Java(TM) Desktop
	System	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#4.4.The Psychiatry in the County of Aarhus switches to OpenOffice|outline">The
	Psychiatry in the County of Aarhus switches to OpenOffice	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#4.5.Yatirimlar, Inc|outline">Yatirimlar,
	Inc	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#4.6.Gov't unveils open source solutions for SMEs, schools|outline">Gov't
	unveils open source solutions for SMEs, schools	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#4.7.HP unveils 4-user computer with OpenOffice.org|outline">HP
	unveils 4-user computer with OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#4.8.OpenOffice is a workable and flexible alternative to Microsoft Office|outline">OpenOffice
	is a workable and flexible alternative to Microsoft Office	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#4.9.Free online OpenOffice.org support program available|outline">Free
	online OpenOffice.org support program available	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#4.10.UK government backed open source CMS supports OOo|outline">UK
	government backed open source CMS supports OOo	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#4.11.Replace Microsoft Office with OpenOffice|outline">Replace
	Microsoft Office with OpenOffice	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#4.12.Microsoft offers the French 60 per cent off software licences|outline">Microsoft
	offers the French 60 per cent off software licences	</A></FONT></P>
	<P STYLE="margin-bottom: 3mm"><FONT SIZE=4><A HREF="#5.June 2004|outline">June
	2004	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.1.OPENOFFICE.ORG ANNOUNCES VERSION 1.1.2 - HAKONE|outline">OPENOFFICE.ORG
	ANNOUNCES VERSION 1.1.2 - HAKONE	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.2.OOoConv : 10,000 conversions|outline">OOoConv
	: 10,000 conversions	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.3.Ontario offers Sun's StarOffice to students|outline">Ontario
	offers Sun's StarOffice to students	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.4.Case Study: Hentzenwerke Publishing switches to Linux|outline">Case
	Study: Hentzenwerke Publishing switches to Linux	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.5.Sun lands bank deal for Java Desktop System|outline">Sun
	lands bank deal for Java Desktop System	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.6.Munich Seeks Bids For Municipal Linux Migration|outline">Munich
	Seeks Bids For Municipal Linux Migration	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.7.City of Treuchtlingen|outline">City
	of Treuchtlingen	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.8.City of Wolfsburg evaluates Linux Desktop|outline">City
	of Wolfsburg evaluates Linux Desktop	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.9.France looks to open-source in challenge to Microsoft|outline">France
	looks to open-source in challenge to Microsoft	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.10.Successful migration to OOo|outline">Successful
	migration to OOo	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.11.Battle of the giants|outline">Battle
	of the giants	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.12.PC Gemilang: Linux outsells Windows|outline">PC
	Gemilang: Linux outsells Windows	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.13.NSW Roads kicks out Exchange for Sun, deploys Mozilla|outline">NSW
	Roads kicks out Exchange for Sun, deploys Mozilla	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.14.Novell Australia leads global Linux migration, dumps MS Office|outline">Novell
	Australia leads global Linux migration, dumps MS Office	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.15.StarOffice slashes seat costs|outline">StarOffice
	slashes seat costs	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.16.OpenOffice.org in 5th FISL (International Open Source Forum) in Brazil|outline">OpenOffice.org
	in 5th FISL (International Open Source Forum) in Brazil	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.17.EU eGovernment policy-makers encourage the uptake of open document formats|outline">EU
	eGovernment policy-makers encourage the uptake of open document
	formats	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#5.18.European Commission's IDA TAC Publishes Recommendations on Open Document Formats.|outline">European
	Commission's IDA TAC Publishes Recommendations on Open Document
	Formats.	</A></FONT></P>
	<P STYLE="margin-bottom: 3mm"><FONT SIZE=4><A HREF="#6.May 2004|outline">May
	2004	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#6.1.OOoCon 2004: Call For Papers|outline">OOoCon
	2004: Call For Papers	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#6.2.Hungarian Native-Lang project|outline">Hungarian
	Native-Lang project	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#6.3.Azeri Native-Lang project|outline">Azeri
	Native-Lang project	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#6.4.Upcoming Native-Lang projects|outline">Upcoming
	Native-Lang projects	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#6.5.Linux in action: A public library's success story|outline">Linux
	in action: A public library's success story	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#6.6.Brussels embraces OpenOffice.org|outline">Brussels
	embraces OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#6.7.Sonneburgh: OpenOffice.org deployment in Rotterdam|outline">Sonneburgh:
	OpenOffice.org deployment in Rotterdam	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#6.8.Scottish schools get help with StarOffice|outline">Scottish
	schools get help with StarOffice	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#6.9.Migration Study: Health First|outline">Migration
	Study: Health First	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#6.10.StarOffice: ready for the big time|outline">StarOffice:
	ready for the big time	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#6.11.New White Paper about the OpenOffice.org XML File Format|outline">New
	White Paper about the OpenOffice.org XML File Format	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#6.12.Article: Programming with the StarOffice 7 Software Development Kit|outline">Article:
	Programming with the StarOffice 7 Software Development Kit	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#6.13.Star Wars: StarOffice Vs MS office|outline">Star
	Wars: StarOffice Vs MS office	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#6.14.Sun-Microsoft deal: Questionable significance for OpenOffice.org|outline">Sun-Microsoft
	deal: Questionable significance for OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-bottom: 3mm"><FONT SIZE=4><A HREF="#7.April 2004|outline">April
	2004	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#7.1.New Native-Lang Projects to be created|outline">New
	Native-Lang Projects to be created	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#7.2.Talk-shows &amp; Politics|outline">Talk-shows
	&amp; Politics	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#7.3.Localizations|outline">Localizations	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#7.4.Development &amp; Software|outline">Development
	&amp; Software	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#7.5.Marketing &amp; Communication|outline">Marketing
	&amp; Communication	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#7.6.Wal-Mart teams with Sun on Linux PCs|outline">Wal-Mart
	teams with Sun on Linux PCs	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#7.7.OpenOffice.org at Ministry of Health|outline">OpenOffice.org
	at Ministry of Health	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#7.8.310,000 copies of Catalan version distributed|outline">310,000
	copies of Catalan version distributed	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#7.9.10,000 Seats in Finance|outline">10,000
	Seats in Finance	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#7.10.The Israeli finance ministry plans to distribute 150,000 copies  of OpenOffice|outline">The
	Israeli finance ministry plans to distribute 150,000 copies  of
	OpenOffice	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#7.11.Gati Limited (India) uses OpenOffice.org|outline">Gati
	Limited (India) uses OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#7.12.French OpenOffice.org Add-ons|outline">French
	OpenOffice.org Add-ons	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#7.13.Linux User &amp; Developer Awards - Best Open Source Project: OpenOffice.org|outline">Linux
	User &amp; Developer Awards - Best Open Source Project:
	OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-bottom: 3mm"><FONT SIZE=4><A HREF="#8.March 2004|outline">March
	2004	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.1.OASIS Milestone Reached|outline">OASIS
	Milestone Reached	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.2.OpenOffice.org BizDev Project|outline">OpenOffice.org
	BizDev Project	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.3.OpenOffice.org 1.1.1RC3|outline">OpenOffice.org
	1.1.1RC3	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.4.OOo 1.1 Portuguese Native-Lang translation|outline">OOo
	1.1 Portuguese Native-Lang translation	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.5.FontOOo 1.0|outline">FontOOo
	1.0	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.6.OOo Education Mascot Competition|outline">OOo
	Education Mascot Competition	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.7.Microsoft Is Facing Long-Term Adjustment|outline">Microsoft
	Is Facing Long-Term Adjustment	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.8.City of Haarlem moving to OpenOffice.org|outline">City
	of Haarlem moving to OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.9.Singapore Ministry of Education and Argonne National Laboratory Turn To Java(TM) Enterprise System for Dramatic Cost Savings|outline">Singapore
	Ministry of Education and Argonne National Laboratory Turn To
	Java(TM) Enterprise System for Dramatic Cost Savings	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.10.City of Lille considering migration to OpenOffice.org|outline">City
	of Lille considering migration to OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.11.French Officials Eye Open-Source Apps|outline">French
	Officials Eye Open-Source Apps	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.12.Haryana goes the open-source way with Sun|outline">Haryana
	goes the open-source way with Sun	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.13.ICICI OneSource Dumps Microsoft Office For Sun|outline">ICICI
	OneSource Dumps Microsoft Office For Sun	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.14.BharateeyaOO.o Gives Open Office a 'Desi' Push|outline">BharateeyaOO.o
	Gives Open Office a 'Desi' Push	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.15.Namibian OSS workshop produces Kiswahili dictionary|outline">Namibian
	OSS workshop produces Kiswahili dictionary	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.16.German distributor sells more than a million copies of Sun's StarOficce|outline">German
	distributor sells more than a million copies of Sun's StarOficce	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.17.OpenOffice.org Magazine|outline">OpenOffice.org
	Magazine	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.18.OpenOffice debuts bizdev community|outline">OpenOffice
	debuts bizdev community	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.19.Pravakta Plug-in for OpenOffice.org 1.1 Writer|outline">Pravakta
	Plug-in for OpenOffice.org 1.1 Writer	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.20.XML Matters: XML for word processors|outline">XML
	Matters: XML for word processors	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.21.Microsoft releases OpenOffice.org 1.1 Competitive Guide|outline">Microsoft
	releases OpenOffice.org 1.1 Competitive Guide	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.22.Comments/opinions reg. the OpenOffice.org 1.1 Competitive Guide|outline">Comments/opinions
	reg. the OpenOffice.org 1.1 Competitive Guide	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.23.Microsoft Is Facing Long-Term Adjustment|outline">Microsoft
	Is Facing Long-Term Adjustment	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.24.Third package announced for PC Gemilang project|outline">Third
	package announced for PC Gemilang project	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.25.StarOffice takes on Microsoft|outline">StarOffice
	takes on Microsoft	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.26.Linux Saves Big Money|outline">Linux
	Saves Big Money	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.27.HP Starts Pushing Desktop Linux|outline">HP
	Starts Pushing Desktop Linux	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.28.Novell to offer users a Windows experience on a Linux desktop|outline">Novell
	to offer users a Windows experience on a Linux desktop	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#8.29.Life after Microsoft - One firm's complete conversion to open source|outline">Life
	after Microsoft - One firm's complete conversion to open source	</A></FONT></P>
	<P STYLE="margin-bottom: 3mm"><FONT SIZE=4><A HREF="#9.February 2004|outline">February
	2004	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.1.Lao Native-Lang Project announced|outline">Lao
	Native-Lang Project announced	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.2.Arabic &amp; Hebrew Projects announced|outline">Arabic
	&amp; Hebrew Projects announced	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.3.Misc Native-Lang Project News|outline">Misc
	Native-Lang Project News	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.4.Japanese Announcement|outline">Japanese
	Announcement	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.5.ISO announcment|outline">ISO
	announcment	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.6.Linux and OpenOffice.org at the City of Paris|outline">Linux
	and OpenOffice.org at the City of Paris	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.7.Indian insurance company shifts 10,000 desktops to StarOffice|outline">Indian
	insurance company shifts 10,000 desktops to StarOffice	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.8.Apache Forrest Support for OpenOffice.org|outline">Apache
	Forrest Support for OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.9.OpenOffice.org Flash Intro|outline">OpenOffice.org
	Flash Intro	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.10.20%25 for OpenOffice.org|outline">20%
	for OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.11.StarOffice 7 review by PC Magazine|outline">StarOffice
	7 review by PC Magazine	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.12.Opening Open Formats with XSLT|outline">Opening
	Open Formats with XSLT	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.13.Microsoft's Office XML lags on Mac|outline">Microsoft's
	Office XML lags on Mac	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.14.StarOffice 7 available for Solaris x86|outline">StarOffice
	7 available for Solaris x86	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.15.KDE integrates OpenOffice.org|outline">KDE
	integrates OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.16.Sun Lends Support to OpenOffice.org|outline">Sun
	Lends Support to OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#9.17.Star Can Save Millions; But Look Before You Leap|outline">Star
	Can Save Millions; But Look Before You Leap	</A></FONT></P>
	<P STYLE="margin-bottom: 3mm"><FONT SIZE=4><A HREF="#10.January 2004|outline">January
	2004	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#10.1.Texan city runs 'nonemotional' Linux pilot|outline">Texan
	city runs 'nonemotional' Linux pilot	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#10.2.Sun touts contract with Office Depot|outline">Sun
	touts contract with Office Depot	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#10.3.Norwegian soon to become a native language project!|outline">Norwegian
	soon to become a native language project!	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#10.4.Kinko and OpenOffice.org|outline">Kinko
	and OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#10.5.Government open source deployments you don't hear about|outline">Government
	open source deployments you don't hear about	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#10.6.2003 LinuxQuestions.org Members Choice Award Winners Announced|outline">2003
	LinuxQuestions.org Members Choice Award Winners Announced	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#10.7.OSNews 2003 Awards -- Our Favorites This Year|outline">OSNews
	2003 Awards -- Our Favorites This Year	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#10.8.2003 OSDir Editor's Choice Award|outline">2003
	OSDir Editor's Choice Award	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#10.9.Product of the Year 2003|outline">Product
	of the Year 2003	</A></FONT></P>
	<P STYLE="margin-bottom: 3mm"><FONT SIZE=4><A HREF="#11.December 2003|outline">December
	2003	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.1.OpenOffice.org got a new &quot;face&quot;|outline">OpenOffice.org
	got a new &quot;face&quot;	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.2.Russian Native-Lang Project Announced|outline">Russian
	Native-Lang Project Announced	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.3.Sun Microsystems launches enterprise support for OpenOffice.org|outline">Sun
	Microsystems launches enterprise support for OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.4.Scripting Framework is Available|outline">Scripting
	Framework is Available	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.5.AOL ships PCs with OpenOffice.org based office suite|outline">AOL
	ships PCs with OpenOffice.org based office suite	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.6.OpenOffice.org reduces the invoice of the police officers|outline">OpenOffice.org
	reduces the invoice of the police officers	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.7.Retirement Pension Tool for Excel AND OpenOffice.org|outline">Retirement
	Pension Tool for Excel AND OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.8.UK&rsquo;s Office of Government Commerce evaluating Sun Java Desktop System|outline">UK&rsquo;s
	Office of Government Commerce evaluating Sun Java Desktop System	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.9.More money for patients through OpenOffice.org and Linux|outline">More
	money for patients through OpenOffice.org and Linux	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.10.Schoolweb Targets 40 Institutions|outline">Schoolweb
	Targets 40 Institutions	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.11.New Linux distribution &quot;Impi&quot; including OpenOffice.org|outline">New
	Linux distribution &quot;Impi&quot; including OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.12.Israeli employment agency switches to OpenOffice.org|outline">Israeli
	employment agency switches to OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.13.Sun lands 500,000 desktop Linux deal|outline">Sun
	lands 500,000 desktop Linux deal	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.14.Government plans to distribute computers to 5,000 schools nationwide|outline">Government
	plans to distribute computers to 5,000 schools nationwide	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.15.Microsoft Loses to Linux in Thailand Struggle|outline">Microsoft
	Loses to Linux in Thailand Struggle	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.16.Sewing machine giant Janome adopts OpenOffice.org|outline">Sewing
	machine giant Janome adopts OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.17.Victorian government evaluates OpenOffice.org and StarOffice|outline">Victorian
	government evaluates OpenOffice.org and StarOffice	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#11.18.Study: Save up to 25%25 with open source technologies|outline">Study:
	Save up to 25% with open source technologies	</A></FONT></P>
	<P STYLE="margin-bottom: 3mm"><FONT SIZE=4><A HREF="#12.November 2003|outline">November
	2003	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.1.API@OOo Newsletter|outline">API@OOo
	Newsletter	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.2.Sun Java Desktop System ISV/Developer Early Adopter Program|outline">Sun
	Java Desktop System ISV/Developer Early Adopter Program	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.3.OpenOffice.org Market Share Analysis|outline">OpenOffice.org
	Market Share Analysis	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.4.Denmark urges government support for open source|outline">Denmark
	urges government support for open source	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.5.International Forwarding Agent Heinz Huber|outline">International
	Forwarding Agent Heinz Huber	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.6.Midsize German firms say ja to Linux|outline">Midsize
	German firms say ja to Linux	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.7.OpenOffice.org 1.1 at Italian Schools|outline">OpenOffice.org
	1.1 at Italian Schools	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.8.Israel slams the door on Microsoft|outline">Israel
	slams the door on Microsoft	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.9.Life Insurance Corporation wants to switch to OpenOffice.org|outline">Life
	Insurance Corporation wants to switch to OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.10.Vietnam embracing open-source products|outline">Vietnam
	embracing open-source products	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.11.Australia's history archived in OpenOffice.org|outline">Australia's
	history archived in OpenOffice.org	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.12.Sun shines on NSW government desktops|outline">Sun
	shines on NSW government desktops	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.13.The IDA Open Source Migration Guidelines|outline">The
	IDA Open Source Migration Guidelines	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.14.Migration Guide by the German Federal Ministry of the Interior|outline">Migration
	Guide by the German Federal Ministry of the Interior	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.15.OpenOffice.org XML Essentials|outline">OpenOffice.org
	XML Essentials	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.16.XML Interoperability Test|outline">XML
	Interoperability Test	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.17.Office 2003/StarOffice Migration Survey - Germany|outline">Office
	2003/StarOffice Migration Survey - Germany	</A></FONT></P>
	<P STYLE="margin-left: 4.99mm; margin-bottom: 1.99mm"><FONT SIZE=2><A HREF="#12.18.Office 2003/StarOffice Migration Survey &ndash; Switzerland|outline">Office
	2003/StarOffice Migration Survey &ndash; Switzerland	</A></FONT></P>
</DIV>
<P ALIGN=CENTER STYLE="margin-top: 4.23mm; page-break-after: avoid"><BR><BR>
</P>
<H1 CLASS="western"><A NAME="1.October 2004|outline"></A>October 2004</H1>
<H2 CLASS="western"><A NAME="1.1.Replacing FrameMaker with OOo Writer |outline"></A>
Replacing FrameMaker with OOo Writer 
</H2>
<P>&quot;I began comparing FrameMaker and Writer when a regular on
the OpenOffice.org User's list asked what it would take to give
Writer the power of FrameMaker. When I started, I mentally pictured a
scale with Microsoft Word on one end and FrameMaker on another, with
Writer in the middle, but closer to Microsoft Word. As I proceeded, I
found Writer was a much stronger contender than I had expected. At
the end of the comparison, I had to conclude that the two products
compare quite closely, depending on what features are more important
to a given user.&quot;
<BR><A HREF="http://www.newsforge.com/article.pl?sid=04/10/04/150207">http://www.newsforge.com/article.pl?sid=04/10/04/150207</A>
</P>
<H2 CLASS="western"><A NAME="1.2.Germans claim Linux lowers costs|outline"></A>
Germans claim Linux lowers costs</H2>
<P>&quot;The greatest cost saving opportunities that Soreon Research
found were in the adoption of a variety of office applications on
work-stations. Over three-years, a 2000-seat organisation would save
around &euro;525,000 with office applications, &euro;57,000 with
servers, &euro;32,000 with content management systems and &euro;21,000
with databases. For a &euro;1,000,000 budget, the use of
OpenOffice.org instead of Microsoft Office would provide a 20 per
cent cost advantage.&quot;</P>
<P><A HREF="http://www.theinquirer.net/?article=19006">http://www.theinquirer.net/?article=19006</A></P>
<H2 CLASS="western"><A NAME="1.3.Open approach offers Mindef more choice|outline"></A>
Open approach offers Mindef more choice</H2>
<P>&quot;The Defence Ministry installs Open-Office, an open source
productivity suite, in 5,000 new computers as an alternative to
proprietary software.</P>
<P>The Ministry of Defence (Mindef) has installed the OpenOffice
productivity suite on 5,000 new desktop computers. This move is aimed
at giving employees in the ministry an additional choice in
productivity software. It will also help Mindef make 'significant'
savings in terms of capital costs.&quot;</P>
<P><A HREF="http://computertimes.asiaone.com.sg/news/story/0,5104,2868,00.html">http://computertimes.asiaone.com.sg/news/story/0,5104,2868,00.html</A></P>
<H2 CLASS="western"><A NAME="1.4.Ballmer calls for horse-based attack on Star Office|outline"></A>
Ballmer calls for horse-based attack on Star Office</H2>
<P>&quot;In a question and answer session after his closing speech a
delegate asked what he should do faced with public sector customers
interested in Star Office, Sun's budget rival to Microsoft Office.
Ballmer replied: &ldquo;Email me immediately and we&rsquo;ll send in
the cavalry. I&rsquo;m joking...but I&rsquo;m not. There is no reason
to lose business to Star Office - it&rsquo;s as good as what we were
shipping seven years ago, it&rsquo;s not compatible with Microsoft
Office and it&rsquo;s missing key applications like Outlook.&rdquo;&quot;</P>
<P><A HREF="http://www.theregister.co.uk/2004/10/06/ballmer_staroffice_charge/">http://www.theregister.co.uk/2004/10/06/ballmer_staroffice_charge/</A></P>
<H2 CLASS="western"><A NAME="1.5.Open for Business - The 2004 OfB Choice Awards|outline"></A>
Open for Business - The 2004 OfB Choice Awards</H2>
<P>&quot;Best Office Suite: OpenOffice.org 1.1.1 OpenOffice.org
remains the only serious contender to replace Microsoft Office on
Windows or GNU/Linux desktops. There are</P>
<P>some competitors, such as Abiword on Windows and GNU/Linux as well
as Corel WordPerfect Office on Windows; OpenOffice.org seems to have
a unique hold on progress toward offering comprehensive compatibility
with Microsoft Office in an interface that should minimize adjustment
time for users migrating to it.&quot;</P>
<P><A HREF="http://www.ofb.biz/modules.php?name=News&amp;file=article&amp;sid=330">http://www.ofb.biz/modules.php?name=News&amp;file=article&amp;sid=330</A></P>
<H1 CLASS="western"><A NAME="2.September 2004|outline"></A>September
2004</H1>
<H2 CLASS="western"><A NAME="2.1.OpenOffice.org reveals marketing ambitions|outline"></A>
OpenOffice.org reveals marketing ambitions</H2>
<P>&quot;The organisation behind the office suite for Linux has
released a marketing plan which explains how it plans to promote its
open-source product.</P>
<P>The developers of OpenOffice.org, the open-source office
productivity suite, have unveiled details of a major marketing push
to coincide with the OpenOffice.org Conference, which has been taking
place in Berlin, Germany, this week.&quot;</P>
<P><A HREF="http://news.zdnet.co.uk/0,39020330,39167856,00.htm">http://news.zdnet.co.uk/0,39020330,39167856,00.htm</A></P>
<H2 CLASS="western"><A NAME="2.2.Nonprofit brings Linux and open source to Hawaii|outline"></A>
Nonprofit brings Linux and open source to Hawaii</H2>
<P>&quot;Schools in Hawaii, affected by lean budgets like many other
US states this year, are upgrading their computer systems with help
from the open source community and Linux. A local nonprofit, the
Oahu-based Hawaii Open Source Education Foundation (HOSEF), has
supplied over a dozen Hawaiian schools with computers &quot;recycled&quot;
with the Linux operating system and raised awareness of open source
software (OSS). 
</P>
<P>[...]</P>
<P>&quot;We have an obligation to reciprocate that which we receive,
if possible. OSS (open source software) has been very good to me. I
have used it to help employers save money. I have used
[Openoffice.org] for my college degrees, and I use it daily on my
computers. If I can take my entrepreneurial, economic, and business
interests and channel my passion for OSS through them, then I
should,&quot; Belford enthuses.&quot;</P>
<P><A HREF="http://www.desktoplinux.com/news/NS6201542989.html">http://www.desktoplinux.com/news/NS6201542989.html</A></P>
<H2 CLASS="western"><A NAME="2.3.UK charity builds Linux network on a shoestring|outline"></A>
UK charity builds Linux network on a shoestring</H2>
<P>&quot;Homeless charity Alone in London spent less than &pound;2,000
to set up a network of 30 PCs from scratch, compared to a
similar-sized charity which spent &pound;30,000 on building a network
using proprietary solutions and new PCs, according to James Holland,
who ran the project at Alone in London.</P>
<P>[...]</P>
<P>The only other cost was less than &pound;250 for the cable,
connectors, crimper and switches of the network infrastructure - in
total, the network cost under &pound;2,000. The PCs on the network
run Red Hat Linux 9, OpenOffice, Evolution for email and Mozilla for
browsing, saving Alone in London further costs on licences for
desktop applications.&quot;</P>
<P><A HREF="http://news.zdnet.co.uk/0,39020330,39166840,00.htm">http://news.zdnet.co.uk/0,39020330,39166840,00.htm</A></P>
<H2 CLASS="western"><A NAME="2.4.NSW opens door to Linux offers|outline"></A>
NSW opens door to Linux offers</H2>
<P>&quot;THE NSW Department of Commerce has released its eagerly
anticipated Linux tender, calling for a panel of suppliers to provide
enterprise-level software and services for government agencies. The
contract, reportedly worth $40 million, is seen as a major step
forward for open source lobbyists, as it requests suppliers to
provide Linux software for both desktop and server environments.</P>
<P>[...]</P>
<P>In keeping with the NSW government&rsquo;s push for openness
within its IT environment, the tender document states submissions can
be lodged in file formats that can be read by
OpenOffice.org/StarOffice Write and Microsoft Word.&quot;</P>
<P><A HREF="http://www.news.com.au/common/story_page/0,4057,10916500%255E15306,00.html">http://www.news.com.au/common/story_page/0,4057,10916500%255E15306,00.html</A></P>
<H2 CLASS="western"><A NAME="2.5.Leading Edge Forum Report 2004 - Open Source: Open for Business|outline"></A>
Leading Edge Forum Report 2004 - Open Source: Open for Business</H2>
<P>&quot;Desktop software such as OpenOffice, while still reaching
maturity, could offer significant savings for large organizations.
Office suite software can cost roughly $300 per seat&mdash;or $3
million in an organization of 10,000 people. That creates real
savings when going to acquisition costs of $0.</P>
<P>[...]</P>
<P>Meanwhile, OpenOffice has climbed to a 14 percent share of the
large enterprise office systems market. Microsoft, however, still
holds a 94 percent share of the overall office market. &quot;It is a
David and Goliath story, to be sure,&quot; the report says, &quot;but
David is getting stronger.&quot;&quot;</P>
<P><A HREF="http://www.csc.com/features/2004/48.shtml">http://www.csc.com/features/2004/48.shtml</A></P>
<P><A HREF="http://www.csc.com/features/2004/49.shtml">http://www.csc.com/features/2004/49.shtml</A></P>
<H2 CLASS="western"><A NAME="2.6.Linux growing on SMB desktops: Yankee Group|outline"></A>
Linux growing on SMB desktops: Yankee Group</H2>
<P>&quot;Pay attention to the less-than-20-employee size market
segment because that is where the early Linux versus Windows desktop
wars will play out, she said. The very small business segment shows
the greatest interest in Linux desktop adoption in the next 12 or
more months (at 10 per cent), outpacing the intent of larger SMBs by
four to six percentage points.</P>
<P>[...]</P>
<P>But YG also said SMBs ought to consider Linux as an alternative,
lower cost desktop OS to Windows. The price of a Linux-loaded system
with, for example, Sun's StarOffice productivity suite will be less
than a system preloaded with a Windows operating system and Microsoft
Office.&quot;</P>
<P><A HREF="http://www.integratedmar.com/ecl-usa/story.cfm?item=18755">http://www.integratedmar.com/ecl-usa/story.cfm?item=18755</A></P>
<H2 CLASS="western"><A NAME="2.7.'Independent' report used MS-sourced data to trash OSS|outline"></A>
'Independent' report used MS-sourced data to trash OSS</H2>
<P>&quot;Microsoft, incidentally, has a long and inglorious history
of reverse-process studies (i.e. starting with the conclusions then
sourcing the data appropriate for arrival at it). There are many,
many examples but we feel this blast from the past is particularly
appropriate to current circumstances. Regrettably, the link to Linux
Myths no longer works, but it was sort of release 1.0 of Get the
Facts.&quot;</P>
<P><A HREF="http://www.theregister.co.uk/2004/09/09/ms_capgemini_newham_report/">http://www.theregister.co.uk/2004/09/09/ms_capgemini_newham_report/</A></P>
<H2 CLASS="western"><A NAME="2.8.OpenOffice.org Conference Presentations|outline"></A>
OpenOffice.org Conference Presentations</H2>
<P>The OpenOffice.org Conference presentations can be found at:</P>
<P><A HREF="http://marketing.openoffice.org/ooocon2004/thursday.html">http://marketing.openoffice.org/ooocon2004/thursday.html</A></P>
<P><A HREF="http://marketing.openoffice.org/ooocon2004/friday.html">http://marketing.openoffice.org/ooocon2004/friday.html</A></P>
<H2 CLASS="western"><A NAME="2.9.Open Office XML May Satisfy ISO|outline"></A>
Open Office XML May Satisfy ISO</H2>
<P>&quot;A letter to Sun Microsystems' COO Jonathan Schwartz by the
European Commission (EC) this week may set the stage for the
International Organization for Standardization (ISO) to adopt the
Open Office XML format (also known as OO.o XML) as an ISO standard.
If it does, the stamp of approval would mark the largest ever
validation of Sun's work on the desktop.&quot;</P>
<P><A HREF="http://www.internetnews.com/dev-news/article.php/3414101">http://www.internetnews.com/dev-news/article.php/3414101</A></P>
<P>Weblog:</P>
<P><A HREF="http://www.tbray.org/ongoing/When/200x/2004/09/24/SmartEC">http://www.tbray.org/ongoing/When/200x/2004/09/24/SmartEC</A></P>
<P>Slashdot story:</P>
<P><A HREF="http://it.slashdot.org/it/04/09/27/1111202.shtml?tid=117&amp;tid=102&amp;tid=1&amp;tid=218">http://it.slashdot.org/it/04/09/27/1111202.shtml?tid=117&amp;tid=102&amp;tid=1&amp;tid=218</A></P>
<H2 CLASS="western"><A NAME="2.10.UN drive to boost free software|outline"></A>
UN drive to boost free software</H2>
<P>&quot;The United Nations is holding events across Asia to
encourage the region to adopt free and open source software.</P>
<P>The UN's International Open Source Network (IOSN) is organising
the first annual Software Freedom Day on 28 August, giving out CDs
and booklets about the technology.&quot;</P>
<P>&quot;These include the operating system Linux, OpenOffice, the
Mozilla web browser and e-mail project, mySQL database and the Apache
web server.</P>
<P>Computer users in South Africa are joining in too, and will be
able to take their computers to one an &quot;install-fest&quot;
station to have free software installed.&quot;</P>
<P><A HREF="http://news.bbc.co.uk/1/hi/technology/3601710.stm">http://news.bbc.co.uk/1/hi/technology/3601710.stm</A></P>
<H2 CLASS="western"><A NAME="2.11.OpenOffice Set for Larger African Effort|outline"></A>
OpenOffice Set for Larger African Effort</H2>
<P>&quot;As part of Software Freedom Day, set for August 28,
OpenOffice will be translated into three African languages for the
first time. After Saturday, the open-source desktop suite will be
available to speakers of the South African languages of Zulu, Sepedi
and Afrikaans. The new versions have been prepared by
Translate.org.za, a South African  translation project that spent two
years developing the software.&quot;</P>
<P><A HREF="http://www.linuxinsider.com/story/openoffice-zulu-36172.html">http://www.linuxinsider.com/story/openoffice-zulu-36172.html</A></P>
<H2 CLASS="western"><A NAME="2.12.A strong OpenOffice.org community is the key, argues Sun's Danese Cooper|outline"></A>
A strong OpenOffice.org community is the key, argues Sun's Danese
Cooper</H2>
<P>&quot;You may have read some of the articles, blogs, and newsgroup
postings about excerpts from Sun's settlement with Microsoft that
appear in our SEC filing. The discussion centered around the
protection we secured for the StarOffice brand, and implications for
the OpenOffice.org community.&quot;</P>
<P><A HREF="http://www.linuxworld.com.au/index.php/id;815001838;fp;4;fpid;4">http://www.linuxworld.com.au/index.php/id;815001838;fp;4;fpid;4</A></P>
<H1 CLASS="western"><A NAME="3.August 2004|outline"></A>August 2004</H1>
<H2 CLASS="western"><A NAME="3.1.OpenOffice.org Art Project|outline"></A>
OpenOffice.org Art Project</H2>
<P>The OpenOffice.org Art Project has been formed to create and
maintain an art portfolio for use by all OpenOffice.org projects.</P>
<P>Initial and ongoing activities include collating existing
OpenOffice.org artwork and liaising with other OpenOffice.org
projects that have or need artwork.</P>
<P>The Art Project (http://marketing.openoffice.org/art/) web site
displays the artwork and graphics in galleries, provides information
about licenses, requesting graphics, and how to participate.</P>
<P>The Art Project is currently seeking designers and graphical
artists to create icons, logos, banners, labels, and fulfill future
requests from other OpenOffice.org contributors. The artwork and
graphics are to be seen and used throughout the OpenOffice.org
product and community.</P>
<P>If you are interested, please visit the Art Project web site for
further information.</P>
<P><A HREF="http://marketing.openoffice.org/art/">http://marketing.openoffice.org/art/</A></P>
<H2 CLASS="western"><A NAME="3.2.Norwegian Native-Lang Project announced (NO)|outline"></A>
Norwegian Native-Lang Project announced (NO)</H2>
<P>&quot;We are very pleased to announce the opening of the Norwegian
Native-Lang Project (http://no.openoffice.org) led by Gaute Hvoslef
Kvalnes. This project is an offspring of the prestigious Skolelinux
community who is a major player in many fields of the Free and Open
Source Software thanks to its Linux distribution, its solution
platform and its community.</P>
<P>The localization of OpenOffice.org to the Norwegian languages
Bokm&aring;l and Nynorsk has resulted in many schools and
institutions using  OpenOffice.org. This in turn has led to several
providers offering books,  courses and other teaching materials. As
OpenOffice.org is becoming very popular among Norwegian speakers, the
Native-Lang Confederation is greeting an important new member in its
family.</P>
<P>Good luck to the Norwegian Native-Lang Project!&quot;</P>
<P><A HREF="http://native-lang.openoffice.org/servlets/ReadMsg?list=announce&amp;msgNo=13">http://native-lang.openoffice.org/servlets/ReadMsg?list=announce&amp;msgNo=13</A></P>
<H2 CLASS="western"><A NAME="3.3.OpenOffice.org in three SA languages for Software Freedom Day|outline"></A>
OpenOffice.org in three SA languages for Software Freedom Day</H2>
<P>&quot;In celebration of this weekend's global Software Freedom
Day, Translate.org.za is planning the release of the OpenOffice.org
suite in three South African languages. The popular free software
office suite will be available in Zulu, Afrikaans and Sepedi. Tswana
is also included but in beta form.&quot;</P>
<P><A HREF="http://www.tectonic.co.za/view.php?id=327">http://www.tectonic.co.za/view.php?id=327</A></P>
<H2 CLASS="western"><A NAME="3.4.U.K.'s NHS licenses Sun's Java Desktop System|outline"></A>
U.K.'s NHS licenses Sun's Java Desktop System</H2>
<P>&quot;The U.K.'s National Health Service said this week that it
purchased 5,000 licenses for Sun Microsystems Inc.'s Java Desktop
System (JDS) as an alternative to Windows, in a move that could
potentially open the door to greater use of the open-source software
by the health agency.</P>
<P>The NHS is implementing a $9 billion program to upgrade its ailing
IT infrastructure. It began evaluating the potential use of Sun's
open-source desktop system last December. JDS includes the company's
StarOffice productivity suite, a GNOME desktop and the Mozilla Web
browser, which Sun has touted as a comprehensive open-source
alternative to Microsoft Corp.'s Windows.&quot;</P>
<P><A HREF="http://www.computerworld.com/hardwaretopics/hardware/desktops/story/0,10801,95531,00.html">http://www.computerworld.com/hardwaretopics/hardware/desktops/story/0,10801,95531,00.html</A></P>
<H2 CLASS="western"><A NAME="3.5.Novell SA implements wall-to-wall Linux|outline"></A>
Novell SA implements wall-to-wall Linux</H2>
<P>&quot;Novell has not only become the biggest thing in Linux
lately, but the company has taken the decision to implement open
source solutions on its internal systems. Novell SA, however, is
pioneering this worldwide decision by being the first to implement
total wall-to-wall Linux and open source solutions from servers to
desktops.</P>
<P>The global company recently passed a mandate whereby the company
would have to pursue the adoption of OpenOffice across all of its
regions. Novell SA, under the leadership of Stafford Masie, has taken
it a step further and has decided to implement Linux and open source
software across its entire enterprise.&quot;</P>
<P>&quot;&quot;We will be running OpenOffice as our office
environment and have loaded all the filters needed to ensure that
people can still access and open Microsoft documents. With OpenOffice
they can even save these documents as a .doc. We have also
implemented SuSE 9 desktops on a Ximian desktop environment and the
Evolution e-mail client,&quot; states Singh&quot;</P>
<P><A HREF="http://www.itweb.co.za/sections/software/2004/0408040805.asp?A=BAP&amp;S=Business Applications&amp;O=FPIN">http://www.itweb.co.za/sections/software/2004/0408040805.asp?A=BAP&amp;S=Business%20Applications&amp;O=FPIN</A></P>
<P>Additional reporting:</P>
<P><A HREF="http://www.tectonic.co.za/view.php?id=319">http://www.tectonic.co.za/view.php?id=319</A></P>
<H2 CLASS="western"><A NAME="3.6.(Vietnam) Students get free access to StarOffice software|outline"></A>
(Vietnam) Students get free access to StarOffice software</H2>
<P>&quot;Vietnamese students and teachers can use StarOffice 7
software free-of-charge in compiling documents, calculating, drawing
and saving data at home or schools.</P>
<P>An agreement to this effect was signed on Monday by Sun
Microsystems Director Andrew Lim in charge of South Asian education
and research and Vice Minister of Education and Training Pham Vu
Luan.&quot;</P>
<P><A HREF="http://www.vnagency.com.vn/NewsA.asp?LANGUAGE_ID=2&amp;CATEGORY_ID=32&amp;NEWS_ID=114025">http://www.vnagency.com.vn/NewsA.asp?LANGUAGE_ID=2&amp;CATEGORY_ID=32&amp;NEWS_ID=114025</A></P>
<H2 CLASS="western"><A NAME="3.7.Sun Deals Desktops Down Under|outline"></A>
Sun Deals Desktops Down Under</H2>
<P>&quot;Initially, Sun will install its StarOffice software in 1,500
desktops  in 120 offices. The goal is to connect up to 3,000 users to
the new  system. Sun said its future plans include stocking the RTA's
back-end  infrastructure with its other software products including
the Sun Java  System Portal Server, Sun Java System Access Manager,
Sun Java System  Identity Manager and Sun Java System Directory
Server Enterprise Edition software.&quot;</P>
<P><A HREF="http://www.internetnews.com/infra/article.php/3397671">http://www.internetnews.com/infra/article.php/3397671</A></P>
<H2 CLASS="western"><A NAME="3.8.OpenOffice.org Team Cautiously Optimistic On AOL Office|outline"></A>
OpenOffice.org Team Cautiously Optimistic On AOL Office</H2>
<P>&quot;Members of the OpenOffice.org community are greeting
yesterday's announcement of a new version of OpenOffice.org with
cautious optimism.&quot;</P>
<P>&quot;As more product information is revealed about AOL Office,
the OpenOffice.org  team is sure to get the answers they seek. And
the community will get a lesson in the pros and cons of open source
commoditization.&quot;</P>
<P><A HREF="http://linuxtoday.com/infrastructure/2004081301526NWDTSW">http://linuxtoday.com/infrastructure/2004081301526NWDTSW</A></P>
<H2 CLASS="western"><A NAME="3.9.UN body releases desktop Linux guide|outline"></A>
UN body releases desktop Linux guide</H2>
<P>&quot;A UN-funded organisation has produced a Linux desktop user
guide to encourage the take-up of Linux in developing countries.</P>
<P>A Linux desktop manual for novice PC users has been produced by a
UN-funded organisation, the International Open Source Network (IOSN).
The manual has been produced to encourage developing countries to use
open-source software. It includes basic information on how to manage
files, browse the Web and produce OpenOffice documents on a Linux
PC.&quot;</P>
<P>&quot;The Linux user manual is available online in OpenOffice and
PDF format.&quot;</P>
<P><A HREF="http://news.zdnet.co.uk/software/linuxunix/0,39020390,39164367,00.htm">http://news.zdnet.co.uk/software/linuxunix/0,39020390,39164367,00.htm</A></P>
<H2 CLASS="western"><A NAME="3.10.LinuxWorld San Francisco Awards|outline"></A>
LinuxWorld San Francisco Awards</H2>
<P>&quot;Winners of Product Excellence Awards Announced at LinuxWorld
Conference &amp; Expo; Awards recognize the best products and
services on the exhibit floor 
</P>
<P>[...]</P>
<P>Best Productivity/Business Application<BR>Sun Microsystems:
StarOffice and Migration Tools&quot;</P>
<P><A HREF="http://home.businesswire.com/portal/site/google/index.jsp?ndmViewId=news_view&amp;newsId=20040804005205&amp;newsLang=en">http://home.businesswire.com/portal/site/google/index.jsp?ndmViewId=news_view&amp;newsId=20040804005205&amp;newsLang=en</A></P>
<H2 CLASS="western"><A NAME="3.11.New Book: &quot;OpenOffice.org Macros Explained&quot;|outline"></A>
New Book: &quot;OpenOffice.org Macros Explained&quot;</H2>
<P>&quot;This book provides an introduction to the creation and
management of macros in OpenOffice. Numerous examples and
explanations demonstrate proper techniques and discuss known problems
and solutions. The underlying data structure is discussed and
techniques are introduced to evaluate OpenOffice objects,
facilitating the use of returned objects in the absence of sufficient
documentation.&quot;</P>
<P>More information about the book can be found at:</P>
<P><A HREF="http://www.pitonyak.org/book/">http://www.pitonyak.org/book/</A></P>
<H2 CLASS="western"><A NAME="3.12.Linux overtakes Mac OS_|outline"></A>
Linux overtakes Mac OS?</H2>
<P>&quot;One analyst at IDC believes that this has already happened.
&quot;Linux captured the number two spot as desktop operating system
in 2003,&quot; said IDC analyst Dan Kusnetzky in a recent interview.</P>
<P>By 2007 IDC estimates that Linux will have 6 per cent of the
desktop market in terms of units, Kusnetzky said. &quot;</P>
<P><A HREF="http://www.macworld.co.uk/news/index.cfm?NewsID=9336&amp;Page=1&amp;pagePos=1">http://www.macworld.co.uk/news/index.cfm?NewsID=9336&amp;Page=1&amp;pagePos=1</A></P>
<H2 CLASS="western"><A NAME="3.13.Desktop Linux offers challenge to &quot;Microsoft world&quot;|outline"></A>
Desktop Linux offers challenge to &quot;Microsoft world&quot;</H2>
<P>&quot;MIT Technology Review has published an informative article
about the current state of Linux on the desktop and the challenge it
poses to Microsoft. Wade Roush examines the usage and market share
Linux is realizing in the enterprise and public sector worldwide.
Reiterating IDC estimates that Linux now claims more desktops
worldwide than Apple, the article suggests that Linux's 3 percent
market share will double by 2006.&quot;</P>
<P><A HREF="http://www.desktoplinux.com/news/NS8719735054.html">http://www.desktoplinux.com/news/NS8719735054.html</A></P>
<P><BR><BR>
</P>
<H1 CLASS="western"><A NAME="4.July 2004|outline"></A>July 2004</H1>
<H2 CLASS="western"><A NAME="4.1.OpenOffice.org learns Welsh|outline"></A>
OpenOffice.org learns Welsh</H2>
<P>&quot;OpenOffice.org, Sun&rsquo;s open source office software
package, is now available in Welsh from Meddal.com. The package
includes a word processor, spreadsheet, drawing and presentations
package, and a Welsh language spell checker.&quot;</P>
<P><A HREF="http://www.theregister.co.uk/2004/07/22/mewngofnodi/">http://www.theregister.co.uk/2004/07/22/mewngofnodi/</A></P>
<H2 CLASS="western"><A NAME="4.2.Canadian university picks Xandros Linux desktop for laptops|outline"></A>
Canadian university picks Xandros Linux desktop for laptops</H2>
<P>&quot;Xandros has announced that Canada's Acadia University has
selected the Xandros Desktop Operating System (OS) as the Linux
offering for its undergraduate program. The Nova Scotia-based
facility, credited as the first university in Canada to integrate
notebook computers into the curriculum, is offering a customized
version of Xandros on Dell D600 laptops through a three year program
that is expected to outfit 9,000 laptops to students and faculty.&quot;</P>
<P><A HREF="http://www.desktoplinux.com/news/NS7130153723.html">http://www.desktoplinux.com/news/NS7130153723.html</A></P>
<H2 CLASS="western"><A NAME="4.3.Press release: Allied Irish Bank Selects Sun Microsystems Java(TM) Desktop System|outline"></A>
Press release: Allied Irish Bank Selects Sun Microsystems Java(TM)
Desktop System</H2>
<P>&quot;Global Trend Continues as One of Ireland's Biggest Banking
and Financial Services Groups Turns to Sun's Java(TM) Desktop System
for a Secure, Reliable and Affordable Desktop Platform&quot;</P>
<P>&quot;Key features of the Java Desktop System include Sun's
StarOffice productivity suite, a familiar look and feel and file and
printing interoperability.&quot;</P>
<P><A HREF="http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=SVBIZINK3.story&amp;STORY=/www/story/06-29-2004/0002201956&amp;EDATE=TUE+Jun+29+2004,+11:33+AM">http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=SVBIZINK3.story&amp;STORY=/www/story/06-29-2004/0002201956&amp;EDATE=TUE+Jun+29+2004,+11:33+AM</A></P>
<H2 CLASS="western"><A NAME="4.4.The Psychiatry in the County of Aarhus switches to OpenOffice|outline"></A>
The Psychiatry in the County of Aarhus switches to OpenOffice</H2>
<P>&quot;Why OpenOffice? The Psychiatry has to change its office
suite as the Corel office 
</P>
<P>suite is no longer supported/upgraded in Danish language and the
file exchange format in the public sector is Word97 .DOC format.
OpenOffice is an open-component product based on APIs and an
XML-based file format. By changing to OpenOffice the Psychiatry saves
an initial investment of DKK 4,8 mill. in license expenses to
Microsoft Office. During 2004 the IT-department designs new templates
and macros, program setup, and plans education, etc. in cooperation
with a test group and our superusers. Finally, on 2 February 2004
OpenOffice 1.1.1 in Danish is introduced on all workstations. By Mid
May 2004 OpenOffice is the sole office suite in the Psychiatry in the
County of Aarhus.&quot;</P>
<P><A HREF="http://ph.auh.dk/ookompetence/openoffice_uk.htm">http://ph.auh.dk/ookompetence/openoffice_uk.htm</A></P>
<H2 CLASS="western"><A NAME="4.5.Yatirimlar, Inc|outline"></A>Yatirimlar,
Inc</H2>
<P>&quot;Turkish OpenOffice.org project group (tr.openoffice.org) has
announced another success story with Yatirimlar, Inc.  Yatirimlar
publishes an adjudication newspaper every Monday in Turkish and
English, and this newspaper is distributed to thousands of readers
throughout Turkey. All the editors work with OpenOffice.org, so we
decided to have an interview with Filiz Keskin from Yatirimlar. It
can be reached at: tr.openoffice.org/yatirimlar.html (in Turkish).&quot;</P>
<P>Source: G&ouml;rkem Cetin</P>
<H2 CLASS="western"><A NAME="4.6.Gov't unveils open source solutions for SMEs, schools|outline"></A>
Gov't unveils open source solutions for SMEs, schools</H2>
<P>&quot; THE ADVANCED Science Technology Institute (ASTI), the
research and development arm of the Department of Science and
Technology, has developed several open source solutions designed for
small to medium enterprises (SMEs) and schools, INQ7.net learned over
the weekend. The agency has released the latest version of its Linux
desktop system called Bayanihan Linux 3.0, which features a graphical
user interface (GUI) similar to Microsoft Windows, according to
Chivas Sicam, ASTI senior science specialist.</P>
<P>[...]</P>
<P>However, a CD package is available for 200 pesos. This package
contains an OpenOffice suite, a browser, multimedia applications,
e-mail software, and a Bluetooth synchronization module, among other
items.&quot;</P>
<P><A HREF="http://www.inq7.net/inf/2004/jul/27/inf_1-1.htm">http://www.inq7.net/inf/2004/jul/27/inf_1-1.htm</A></P>
<H2 CLASS="western"><A NAME="4.7.HP unveils 4-user computer with OpenOffice.org|outline"></A>
HP unveils 4-user computer with OpenOffice.org</H2>
<P>&quot;HP has introduced a multi-user desktop PC with
MandrakeLinux. Dubbed the &quot;441&quot; solution, the concept
system can be used by four users simultaneously.</P>
<P>This new PC, available from HP for 'emerging markets' targets the
education market and ships with productivity applications including
OpenOffice.org, educational software, developer tools, and role-based
customized graphical user interfaces. The 441 boasts cost savings at
50% of acquisition costs and 65% of maintenance costs, according to
the HP website.&quot;</P>
<P><A HREF="http://www.desktoplinux.com/news/NS3020785172.html">http://www.desktoplinux.com/news/NS3020785172.html</A></P>
<P><A HREF="http://www.tectonic.co.za/view.php?action=view&amp;id=310&amp;topic=Open Source">http://www.tectonic.co.za/view.php?action=view&amp;id=310&amp;topic=Open%20Source</A></P>
<P><A HREF="http://www.tectonic.co.za/view.php?id=316">http://www.tectonic.co.za/view.php?id=316</A></P>
<H2 CLASS="western"><A NAME="4.8.OpenOffice is a workable and flexible alternative to Microsoft Office|outline"></A>
OpenOffice is a workable and flexible alternative to Microsoft Office</H2>
<P>&quot;All this by way of introduction to my pitch for
OpenOffice.org, an open-source software suite that at best is a lot
more program than Works and at worst only a little less functional
than Microsoft Office.</P>
<P>OpenOffice.org, which was popularized as Star Office from Sun
Microsystems, is more than adequate for perhaps 95 percent of users.
Most interestingly, it is the only free Office-style program that
runs on both Windows and Linux, as well as the Macintosh, and its
files are mostly (more on that later) compatible with Microsoft
Office. You can buy Sun's version, which includes product support,
for $79.&quot;</P>
<P>&quot;Problems with Word are usually pretty simple to fix, but
complex formulas in Excel occasionally generate outright spurious
results. Setting up a mail list in OO isn't as bonehead simple as it
is with Works. A fair number of users would like to see an integrated
e-mail program and personal information manager, a la Outlook.</P>
<P>But the price is right, and the program is more than adequate for
casual users. If you're doing anything complicated, evaluate the
program yourself.&quot;</P>
<P><A HREF="http://www.newsday.com/news/columnists/ny-txdolinar3880443jul04,0,5568469.column?coll=ny-news-columnists">http://www.newsday.com/news/columnists/ny-txdolinar3880443jul04,0,5568469.column?coll=ny-news-columnists</A></P>
<H2 CLASS="western"><A NAME="4.9.Free online OpenOffice.org support program available|outline"></A>
Free online OpenOffice.org support program available</H2>
<P>&quot;Enfobridge has announced a free support program for the
OpenOffice.org application suite, along with the launch of a new
website that offers users a way to register for support and download
OpenOffice.org software. The program is available to new and existing
OpenOffice.org users.</P>
<P>Free professional support is available online for up to 30 days,
through a trial program from Enfobridge. Through
DownloadOpenOffice.org, the company is offering two levels of
software support. A free version gives users unlimited access to the
online support staff for 30 days, and an extended 90 days support
subscription provides 90 days of support for US $13.95.&quot;</P>
<P><A HREF="http://www.desktoplinux.com/news/NS2978835938.html">http://www.desktoplinux.com/news/NS2978835938.html</A></P>
<H2 CLASS="western"><A NAME="4.10.UK government backed open source CMS supports OOo|outline"></A>
UK government backed open source CMS supports OOo</H2>
<P>&quot;APLAWS is an Open Source Content Management System developed
to assist UK local authorities deliver services online as part of the
Office of the Deputy Prime Minister's Local e-Government Programme.</P>
<P>New Functionality in the latest (July 2004) release:</P>
<P>* Allow searching of Word, Excel, PDF and OpenOffice.org
attachments</P>
<P><A HREF="http://aplaws.sourceforge.net/">http://aplaws.sourceforge.net/</A>&quot;</P>
<H2 CLASS="western"><A NAME="4.11.Replace Microsoft Office with OpenOffice|outline"></A>
Replace Microsoft Office with OpenOffice</H2>
<P>&quot;Spend a few days getting familiar with OpenOffice. Pretty
soon you'll discover that it has no real liabilities. Begin
exchanging documents with customers and friends, and they won't
notice the difference. Once everyone in the office is familiar with
the programs, you can uninstall MS Office and save yourself a bundle
on licensing or renewal fees.&quot;</P>
<P><A HREF="http://www.smallbusinesscomputing.com/biztools/article.php/3374141">http://www.smallbusinesscomputing.com/biztools/article.php/3374141</A></P>
<H2 CLASS="western"><A NAME="4.12.Microsoft offers the French 60 per cent off software licences|outline"></A>
Microsoft offers the French 60 per cent off software licences</H2>
<P>&quot;Microsoft has offered a 60 per cent cut off the prices of
its licences for three years to the city of Paris. It's a tactic that
bore no fruit in Munich when the German city government opted for
open-source software on 14,000 desktops earlier this month. Will the
software giant be more convincing in Paris and stop the French making
the swap? Faced with the possibility of losing the French capital,
Gates and chums have opted for the same tactic that they used in
Bavaria when confronted with customers making eyes at Linux or
OpenOffice: agreeing to take a knife to the cost of licences.
According to French daily Lib&eacute;ration, in January, Microsoft
made an offer to Philipped Schil, the Paris mayoral authorities'
director of information technology and systems &ndash; an offer
cutting licence prices by around 60 per cent for the local
government's computers, which meant some 15,000 PCs. In financial
terms, the bill for three years would drop from &euro;13.27m to
&euro;5.65m. &quot;</P>
<P><A HREF="http://software.silicon.com/os/0,39024651,39121786,00.htm">http://software.silicon.com/os/0,39024651,39121786,00.htm</A></P>
<P><BR><BR>
</P>
<H1 CLASS="western"><A NAME="5.June 2004|outline"></A>June 2004</H1>
<H2 CLASS="western"><A NAME="5.1.OPENOFFICE.ORG ANNOUNCES VERSION 1.1.2 - HAKONE|outline"></A>
OPENOFFICE.ORG ANNOUNCES VERSION 1.1.2 - HAKONE</H2>
<P>&quot;18 June, 2004 - 20H00 UTC</P>
<P>OpenOffice.org is proud to announce the immediate availability of
the new 1.1.2 version of the award-winning open source office suite,
codenamed Hakone.</P>
<P>This new version is initially available on the Windows
(98/ME/NT/2000/XP), GNU/Linux (X86 and PowerPC) and Solaris (SPARC
and X86) platforms.</P>
<P>In addition to English, builds for Czech, Danish, French, German,
Japanese and Slovak are immediately available with other
localisations following shortly.&quot;</P>
<P><A HREF="//servlets/ReadMsg?list=announce&amp;msgNo=206">//servlets/ReadMsg?list=announce&amp;msgNo=206</A></P>
<H2 CLASS="western"><A NAME="5.2.OOoConv : 10,000 conversions|outline"></A>
OOoConv : 10,000 conversions</H2>
<P>OOoConv has passed 10,000 conversions !</P>
<P><A HREF="http://www.oooconv.de/">http://www.oooconv.de/</A></P>
<P>This is a very nice performance for this tool which has been
online since the 1st of January of this year.  It was developed by
Laurent Godard, and is hosted in Germany thanks to Patrick Prasse who
has offered the hosting and the domain name.</P>
<P>This tool is now translated into 17 languages with the help of the
whole OpenOffice.org community. The highest conversion rate is in the
english language (about 40%), however some languages have only been
available for a short time.</P>
<P>The stats given on the site show a wider use of the convertor from
Writer to Word (more than 50%).</P>
<P>Many thanks to Laurent Godard for this tool that allow a larger
availability of OOo file format, but also to Patrick Prasse, Simon
Tosser, Fred Labbe and all the translators.</P>
<P>[Submitted by Sophie Gautier]</P>
<H2 CLASS="western"><A NAME="5.3.Ontario offers Sun's StarOffice to students|outline"></A>
Ontario offers Sun's StarOffice to students</H2>
<P>&quot;The Ontario Ministry of Education has acquired Star Office 7
licences from Sun Microsystems Canada for all the province's 72
public and Catholic school boards, The Star Office productivity suite
is being described as part of a movement to deliver superior
technology to students while keeping spending in check. It is the
largest- StarOffice 7 delivery in North America, with more than 2.5
million students having access to the alternative office suite on
Windows.</P>
<P>Schools at all levels have chosen the interoperable Star Office
suite instead of more expensive office productivity products because
they can re-invest saved funds into other projects for students, the
ministry stated.</P>
<P>StarOffice software is an open-source based, comprehensive office
productivity suite that runs on Solaris, Windows and Linux and is
compatible with Microsoft Office file formats. The StarOffice suite
has an intuitive interface and includes word processing, spreadsheet,
presentation, drawing and database capabilities.&quot;</P>
<P><A HREF="http://www.globetechnology.com/servlet/story/RTGAM.20040527.gtsun0527/BNStory/Technology/">http://www.globetechnology.com/servlet/story/RTGAM.20040527.gtsun0527/BNStory/Technology/</A></P>
<H2 CLASS="western"><A NAME="5.4.Case Study: Hentzenwerke Publishing switches to Linux|outline"></A>
Case Study: Hentzenwerke Publishing switches to Linux</H2>
<P>&quot;The third function was to determine if we were going to get
hung up with exchanging data with outside entities. As with internal
data conversion, this step turned out to be a non-issue.
OpenOffice.org reads Microsoft Office files with ease, although we're
finding more and more people are sending files in Adobe .PDF format,
which is also readable by a variety of open source tools that come
standard with popular distributions. And the graphical images that we
exchange are also platform-independent.&quot;</P>
<P><A HREF="http://software.newsforge.com/software/04/05/28/1936211.shtml?tid=132&amp;tid=2&amp;tid=82&amp;tid=94">http://software.newsforge.com/software/04/05/28/1936211.shtml?tid=132&amp;tid=2&amp;tid=82&amp;tid=94</A></P>
<H2 CLASS="western"><A NAME="5.5.Sun lands bank deal for Java Desktop System|outline"></A>
Sun lands bank deal for Java Desktop System</H2>
<P>&quot;Sun Microsystems' Java Desktop System (JDS) is to be
deployed on 7,500 desktops throughout Allied Irish Bank's (AIB)
branches. The network will run the Linux-based JDS software, and the
deployment includes the migration of branch applications. The
roll-out is planned for next year as part of AIB's New Branch Banking
Platform.&quot;</P>
<P><A HREF="http://www.computing.co.uk/News/1156272">http://www.computing.co.uk/News/1156272</A></P>
<P><A HREF="http://www.eweek.com/article2/0,1759,1618126,00.asp">http://www.eweek.com/article2/0,1759,1618126,00.asp</A></P>
<H2 CLASS="western"><A NAME="5.6.Munich Seeks Bids For Municipal Linux Migration|outline"></A>
Munich Seeks Bids For Municipal Linux Migration</H2>
<P>&quot;The city of Munich in Germany will officially kick off its
much publicized Linux migration project on July 1 but it remains
unclear which vendors will nail the $40 million contract, a spokesman
said.&quot;</P>
<P>&quot;The project entails the migration of 14,000 desktop and
notebook computers from Microsoft Windows and Office software to
Linux and OpenOffice.&quot;</P>
<P>&quot;In the same press release, the city said it had entered a
pilot project with German applications giant SAP to adapt SAP for
OpenOffice.&quot;</P>
<P>&quot;Meanwhile, Novell announced a major Linux win with another
European city even as Munich begins the vendor selection process for
its 40,000 seat migration. On Tuesday, Novell's SUSE Linux subsidiary
announced it had landed a contract to migrate the server
infrastructure of the largest city in Norway &quot; Bergen -- from
Unix and Windows servers to a Linux infrastructure based on SUSE
Enterprise Server 8 platform. The deal will impact 50,000 users,
according to a statement released by SUSE.&quot;</P>
<P><A HREF="http://www.internetwk.com/allStories/showArticle.jhtml?articleID=22100148">http://www.internetwk.com/allStories/showArticle.jhtml?articleID=22100148</A></P>
<H2 CLASS="western"><A NAME="5.7.City of Treuchtlingen|outline"></A>City
of Treuchtlingen</H2>
<P>The City of Treuchtlingen is using StarOffice in a Sun Ray
ultra-thin client environment. The interesting part of the German
article below is the link to an end user survey. According to the
survey the users are very happy with the new environment. Here is one
sample statement from the survey: 
</P>
<P>&quot;Compared with the former equipment (MS Windows
NT4/Novell/Zen 1997-2001) I like the new environment</P>
<P><BR><BR>
</P>
<P>   0%       absolutely not</P>
<P>  25%       similarly well</P>
<P>  50%       better</P>
<P>  16,67%    I would like to have it at home, too.&quot;</P>
<P><A HREF="http://www.pro-linux.de/news/2004/6925.html">http://www.pro-linux.de/news/2004/6925.html</A></P>
<P><A HREF="http://www.open-government.org/index.php?id=93">http://www.open-government.org/index.php?id=93</A></P>
<H2 CLASS="western"><A NAME="5.8.City of Wolfsburg evaluates Linux Desktop|outline"></A>
City of Wolfsburg evaluates Linux Desktop</H2>
<P>According to the articles mentioned below the City of Wolfsburg
will have 21 employees testing a Linux desktop in parallel to their
existing Windows desktop.</P>
<P><A HREF="http://www.pressebox.de/index.php?boxid=20858&amp;sid=searchengine_sid">http://www.pressebox.de/index.php?boxid=20858&amp;sid=searchengine_sid</A></P>
<P><A HREF="http://www.golem.de/0406/31511.html">http://www.golem.de/0406/31511.html</A></P>
<H2 CLASS="western"><A NAME="5.9.France looks to open-source in challenge to Microsoft|outline"></A>
France looks to open-source in challenge to Microsoft</H2>
<P>&quot;Civil Service Minister Renaud Dutreil told Reuters that
France wants to use open-source software providers to resupply part
of the almost 1 million state computers under a government
cost-cutting drive designed to trim a bulging public deficit. &quot;The
competition is open,&quot; he said. &quot;My estimate is that we can
cut the state software bill at least in half.&quot;</P>
<P>At stake, in the case of office suite software alone, is about
$362.5 million worth of software to be introduced to state computers
over three years. Savings on operating systems could be of a similar
amount, officials said. &quot;</P>
<P><A HREF="http://www.computerworld.com/softwaretopics/software/story/0,10801,93946,00.html">http://www.computerworld.com/softwaretopics/software/story/0,10801,93946,00.html</A></P>
<H2 CLASS="western"><A NAME="5.10.Successful migration to OOo|outline"></A>
Successful migration to OOo</H2>
<P>Summary of article into English from Dutch:</P>
<P>The CIBG (Brussels, Belgium) switched about 100 users to
OpenOffice.org for practical reasons rather than the basis of
ideology.  The migration went smoothly.</P>
<P><A HREF="http://www.cibg.irisnet.be/ci/NL/Supports/Communicatie/Press">http://www.cibg.irisnet.be/ci/NL/Supports/Communicatie/Press</A>
(Dutch)</P>
<H2 CLASS="western"><A NAME="5.11.Battle of the giants|outline"></A>Battle
of the giants</H2>
<P>&quot;COMPUTER giants Sun Microsystems and Microsoft are battling
it out for dominance in the Hungarian education sector.</P>
<P>On May 4, Sun announced that it had concluded a deal with the
Hungarian Education Ministry which would make the application suite
StarOffice 7 available for free to staff and students at all of
Hungary's 5,500 schools and 67 higher education institutions.</P>
<P>The program has previously operated successfully in other
countries, but has only now been introduced in Hungary.&quot;</P>
<P><A HREF="http://www.budapestsun.com/full_story.asp?ArticleId={7DB0F14CAE8349C590672A6DBDC6A5C5}&amp;From">http://www.budapestsun.com/full_story.asp?ArticleId=%7B7DB0F14CAE8349C590672A6DBDC6A5C5%7D&amp;From</A>=</P>
<H2 CLASS="western"><A NAME="5.12.PC Gemilang: Linux outsells Windows|outline"></A>
PC Gemilang: Linux outsells Windows</H2>
<P>&quot; Ten thousand PC Gemilang units were sold in the first few
months following the brand&rsquo;s debut, of which more than 7,000
were Linux-based machines. Pikom said the Linux PC generated the
highest demand due to its attractive price. 
</P>
<P>The PC Gemilang project was kicked off in March with two models: A
RM988 PC running a Linux-based operating system and bundled with the
OpenOffice productivity suite; and a RM1,147 desktop with the Bahasa
Malaysia version of the Microsoft Windows XP operating system and
Works Suite 2004.&quot;</P>
<P><A HREF="http://star-techcentral.com/tech/story.asp?file=/2004/6/23/technology/8282356&amp;sec=technology">http://star-techcentral.com/tech/story.asp?file=/2004/6/23/technology/8282356&amp;sec=technology</A></P>
<H2 CLASS="western"><A NAME="5.13.NSW Roads kicks out Exchange for Sun, deploys Mozilla|outline"></A>
NSW Roads kicks out Exchange for Sun, deploys Mozilla</H2>
<P>&quot;The NSW Roads and Traffic Authority (RTA) will migrate 1500
users across 120 offices from Microsoft Exchange to Sun&rsquo;s Java
Enterprise System messaging and calendar servers for e-mail and
calendaring.</P>
<P>As part of the contract, the RTA will also deploy Sun&rsquo;s
Staroffice productivity suite for wordprocessing, spreadsheets and
presentation development; the open source Mozilla browser will be
used for accessing e-mail and calendar information.&quot;</P>
<P><A HREF="http://www.computerworld.com.au/index.php/id;148604439;fp;16;fpid;0">http://www.computerworld.com.au/index.php/id;148604439;fp;16;fpid;0</A></P>
<H2 CLASS="western"><A NAME="5.14.Novell Australia leads global Linux migration, dumps MS Office|outline"></A>
Novell Australia leads global Linux migration, dumps MS Office</H2>
<P>&quot;The migration, which will see staff across the globe using
SuSE Linux systems running OpenOffice, is partly motivated by broader
commercial concerns.&quot;</P>
<P>&quot;However, Novell Asia Pacific CIO Sam Gennaoui said that
there was also a basic financial argument for the shift. &quot;We are
like any other company; we still have ROIs to deliver,&quot; he
said.&quot;</P>
<P>&quot;Around 90 per cent all of the company's 350 Asia-Pacific
staff, half of whom are based in Australia, have started using
OpenOffice as a replacement for Microsoft's Office suite.</P>
<P>Reaction so far has been positive. &quot;There always tends to be
some pushback from users, but there's a sense of willingness to
embrace the new technology,&quot; Gennaoui said. The local operation
is &quot;way ahead of the movement&quot; in the rest of Novell, he
added. &quot;We have a smaller base of users and we're more
flexible.&quot;</P>
<P>Novell has also developed a number of custom enhancements to
OpenOffice to help migrate common internal document templates. The
source code for those enhancements will be made available to the
broader OpenOffice community.&quot;</P>
<P><A HREF="http://www.computerworld.com.au/index.php/id;526044789;fp;16;fpid;0">http://www.computerworld.com.au/index.php/id;526044789;fp;16;fpid;0</A></P>
<H2 CLASS="western"><A NAME="5.15.StarOffice slashes seat costs|outline"></A>
StarOffice slashes seat costs</H2>
<P>&quot;IT wasn't long ago that Microsoft Office, at $500-plus a
seat, was the only option for businesses seeking an integrated office
suite. Times are changing, however.</P>
<P>Sun Microsystems is slowly winning over large business customers
to its StarOffice 7, which costs $50 a user.</P>
<P>IDC analyst Megan Dahlgren says Sun's success is based on its
reputation for high-quality support, coupled with deep discounting
aimed at getting StarOffice widely adopted by government and big
business.</P>
<P>StarOffice is based on the open-source OpenOffice.org, both of
which offer similar functions to Microsoft Office in spreadsheets,
word processing and presentations.</P>
<P>StarOffice product manager Laurie Wong says Sun Java Desktop is a
complete package made up of StarOffice, Ximian Evolution (an Outlook
alternative) and the Adabase database.</P>
<P>OpenOffice.org and StarOffice claim several technology advantages
over Microsoft Office, including the ability to output PDF files from
the application without needing extra software, the option of using
file formats based on industry-standard XML that are easily readable
by other programs, and cross-platform versions of the package for
Windows, Macintosh, Linux and Solaris.</P>
<P>XML brings an important change in the way office packages work,
enabling storage of structured content in a file, allowing the
information to be reused easily in other applications.</P>
<P>Wong says Microsoft's file format is a binary file wrapped in some
XML tags. &quot;It's XML only as long as you use another Microsoft
application, or one authorised by the company to read it, which is
not in the spirit of XML,&quot; he says.</P>
<P>In comparison, the OpenOffice.org and StarOffice binary file
format is a zipped version of an XML file, allowing other software or
users to see the file format in readable XML.</P>
<P>Sewing machine maker Janome Australia has found the cost savings
of the OpenOffice.org package outweigh the inconvenience of migrating
staff away from Microsoft Office, IT manager Scott Langford says.</P>
<P>The biggest challenge was educating users to import Microsoft
Office documents into the software, he says.&quot;</P>
<P><A HREF="http://australianit.news.com.au/articles/0,7204,9821373^15382^^nbv^,00.html">http://australianit.news.com.au/articles/0,7204,9821373%5E15382%5E%5Enbv%5E,00.html</A></P>
<H2 CLASS="western"><A NAME="5.16.OpenOffice.org in 5th FISL (International Open Source Forum) in Brazil|outline"></A>
OpenOffice.org in 5th FISL (International Open Source Forum) in
Brazil</H2>
<P>The coordination of the OOoBr is celebrating the results of its
participation in the 5th FISL, held in Porto Alegre, from June 3rd to
5th, 2004.</P>
<P>Altogether there were 4 days of activities (one pre-event extra);
3 companies sponsoring the stand of OpenOffice.org.br; 9 hours of
panels, meetings and presentations in the pre-event and in the Forum;
over 800 users registered in the stand of OooBr, from 23 Brazilian
States, Argentina, Uruguay, England, United States, France, Spain and
Germany; 100 t-shirts sold in 3 days; 17 raffle winners of books and
t-shirts, and 200Kg of food donated by the project, the sponsors and
the OOo community to the &ldquo;Fome Zero&rdquo; program.</P>
<P>More information:</P>
<P>[english]<A HREF="/.br/saite/conteudo.php?inc=noticias/ver_noticia&amp;id_aba=57&amp;id_noticia=14">/.br/saite/conteudo.php?inc=noticias/ver_noticia&amp;id_aba=57&amp;id_noticia=14</A></P>
<P>[espa&ntilde;ol]<A HREF="/.br/saite/conteudo.php?inc=noticias/ver_noticia&amp;id_aba=57&amp;id_noticia=13">/.br/saite/conteudo.php?inc=noticias/ver_noticia&amp;id_aba=57&amp;id_noticia=13</A></P>
<H2 CLASS="western"><A NAME="5.17.EU eGovernment policy-makers encourage the uptake of open document formats|outline"></A>
EU eGovernment policy-makers encourage the uptake of open document
formats</H2>
<P><A HREF="http://europa.eu.int/ISPO/ida/jsps/index.jsp?fuseAction=showDocument&amp;parent=news&amp;documentID=2387">http://europa.eu.int/ISPO/ida/jsps/index.jsp?fuseAction=showDocument&amp;parent=news&amp;documentID=2387</A></P>
<P>See also:</P>
<P>Advantages of the OpenOffice.org XML File Format Used by the
StarOffice Office Suite</P>
<P><A HREF="http://wwws.sun.com/software/star/staroffice/whitepapers/index.html">http://wwws.sun.com/software/star/staroffice/whitepapers/index.html</A></P>
<H2 CLASS="western"><A NAME="5.18.European Commission's IDA TAC Publishes Recommendations on Open Document Formats.|outline"></A>
European Commission's IDA TAC Publishes Recommendations on Open
Document Formats.</H2>
<P>&quot;You can find some of the materials on the EC Web site. Our
basic points were first that the Office XML formats are incomplete
(no PowerPoint, missing pieces in Excel), second that the licensing
terms are kind of scary (our lawyer's acid-tongued comments have been
excised from the online papers), third that the OO.o format is much
more reusability-oriented, and finally that Microsoft has iron
control over every  aspect of their XML, while the OO.o format is
well on its way to being an OASIS standard.&quot;</P>
<P><A HREF="http://xml.coverpages.org/ni2004-06-17-a.html">http://xml.coverpages.org/ni2004-06-17-a.html</A></P>
<H1 CLASS="western"><A NAME="6.May 2004|outline"></A>May 2004</H1>
<H2 CLASS="western"><A NAME="6.1.OOoCon 2004: Call For Papers|outline"></A>
OOoCon 2004: Call For Papers</H2>
<P>The second worldwide OpenOffice.org is approaching quickly. The
conference team is still looking for more speakers, exhibitors and
sponsors. Thus, submit your abstracts today!</P>
<P><A HREF="//servlets/SummarizeList?listName=announce">//servlets/SummarizeList?listName=announce</A></P>
<H2 CLASS="western"><A NAME="6.2.Hungarian Native-Lang project|outline"></A>
Hungarian Native-Lang project</H2>
<P>The Hungarian Native-Lang project lead by Andras Timar has opened
its doors and is already bringing some fresh air to the Confederation
by having been the first to implement fully localized webpages to
OpenOffice.org and removing the default english links and navbars.</P>
<H2 CLASS="western"><A NAME="6.3.Azeri Native-Lang project|outline"></A>
Azeri Native-Lang project</H2>
<P>&quot;Thanks to the mentoring of Charles-H Schulz, Rail Aliev and
Gorkem Cetin, The Azeri project lead by Emin Husyenov has started to
work rather quickly after his setup phase and is now almost
completed.</P>
<H2 CLASS="western"><A NAME="6.4.Upcoming Native-Lang projects|outline"></A>
Upcoming Native-Lang projects</H2>
<P>Bengali (bn) and Croatian (hr) Native-Lang Projects to be soon set
up; Armenian (am) and Ukrainian Projects in queue, but they should
follow soon after Louis has checked the necessary steps with them.
More on the reform of the Native-Lang Confederation, and the common
development of right-to-left (RTL) lanuages (currently focused on
Thai, Arabic and Hebrew) in the Native-Lang newsletter:</P>
<P><A HREF="http://native-lang.openoffice.org/servlets/ReadMsg?list=dev&amp;msgNo=3143">http://native-lang.openoffice.org/servlets/ReadMsg?list=dev&amp;msgNo=3143</A></P>
<P>Courtesy of Charles-H.Schulz, Native-Lang Confederation</P>
<P><A HREF="http://native-lang.openoffice.org/">http://native-lang.openoffice.org/</A></P>
<H2 CLASS="western"><A NAME="6.5.Linux in action: A public library's success story|outline"></A>
Linux in action: A public library's success story</H2>
<P>&quot;Over the past year, the Howard County (Md.) Public Library
has migrated more than 200 public PCs from Windows 98 and Windows NT
to Linux. These PCs are used both to surf the Internet and to access
the library's catalogues. NewsForge recently spoke with Brian Auger,
associate director of the library, and the IT team responsible for
the migration. We wanted to learn more about why and how it was
accomplished, and how pleased they are with the results.</P>
<P>...</P>
<P>Using LFS as a starting point, Luis and Mike were able to build a
minimal Linux kernel that included only the functionality required by
the &quot;kiosk style&quot; machines. They added the Gnome desktop
environment, the Mozilla browser, and OpenOffice.org to complete the
picture. They call the new distribution &quot;Lumix.&quot; It's a
combination of their first names, Luis and Mike. By the way, it's
pronounced loo-mix, not lummox, which is something else entirely.&quot;</P>
<P><A HREF="http://os.newsforge.com/os/04/05/03/1520209.shtml?tid=2&amp;tid=82&amp;tid=94">http://os.newsforge.com/os/04/05/03/1520209.shtml?tid=2&amp;tid=82&amp;tid=94</A></P>
<H2 CLASS="western"><A NAME="6.6.Brussels embraces OpenOffice.org|outline"></A>
Brussels embraces OpenOffice.org</H2>
<P>&ldquo;C.I.R.B has a mission of technological watch driven by the
Government of Brussels&rdquo; says Miss L&ouml;kkhana Quaremme,
C.I.R.B PR manager,  &ldquo;and will deliver a positioning report
about OpenSource opportunities for Local Government Agencies&rdquo;.
The actual feedback seems to be a positive first step.</P>
<P>...</P>
<P>After a product evaluation period, the 100 users got an dedicated
information program, followed by the installation of OpenOffice.org
1.1 on every desktop, and a training. Document templates were
migrated and support implemented thru an internal and online F.A.Q.</P>
<P>...</P>
<P>&ldquo;We did not face any heavy technical issues, just small
details to fix&rdquo; says finally Miss  L&ouml;kkhana Quaremme.</P>
<P>French article:</P>
<P><A HREF="http://www.toolinux.com/lininfo/news/news/news20040524005103.htm">http://www.toolinux.com/lininfo/news/news/news20040524005103.htm</A></P>
<P>Dutch article:</P>
<P><A HREF="http://www.cibg.irisnet.be/ci/NL/Supports/Communicatie/Press">http://www.cibg.irisnet.be/ci/NL/Supports/Communicatie/Press</A></P>
<H2 CLASS="western"><A NAME="6.7.Sonneburgh: OpenOffice.org deployment in Rotterdam|outline"></A>
Sonneburgh: OpenOffice.org deployment in Rotterdam</H2>
<P>&quot;In 2003 there has been a noticable trend of public
organisations considering to migrate (or already migrating) to
OpenOffice[.org] (1) . Large-scale examples include the French
Ministry of Interior and the city of Munich, but small cases are also
common. This paper looks at such a small-scale application in a
residential care centre for ill or elderly people, located in
Rotterdam, The Netherlands. We look at what has been done and why it
makes sense for them to use OpenOffice[.org].&quot;</P>
<P><A HREF="http://europa.eu.int/ISPO/ida/jsps/index.jsp?fuseAction=showDocument&amp;documentID=1799&amp;parent=chapter&amp;preChapterID=0-452-470">http://europa.eu.int/ISPO/ida/jsps/index.jsp?fuseAction=showDocument&amp;documentID=1799&amp;parent=chapter&amp;preChapterID=0-452-470</A></P>
<H2 CLASS="western"><A NAME="6.8.Scottish schools get help with StarOffice|outline"></A>
Scottish schools get help with StarOffice</H2>
<P>&quot;The Scottish Executive has signalled a possible move away
from Microsoft Office with the signing on Thursday of a deal that
will enable it to manage licences for Sun's StarOffice7 suite of
office applications.</P>
<P>As a result of the deal, any school, college, university or local
authority in Scotland will be able to ask the Executive to manage its
licences.</P>
<P>The Executive has not actually bought any licences -- which are
provided at no cost to educational establishments under Sun's
StarOffice 7 Education Licensing programme. But the deal will allow
it to provide licensing support for 2,833 Scottish schools - which
would mean 738,597 students and 50,048 teachers using StarOffice if
every</P>
<P>school decided to take advantage of the offer.&quot;</P>
<P><A HREF="http://news.zdnet.co.uk/software/applications/0,39020384,39153936,00.htm">http://news.zdnet.co.uk/software/applications/0,39020384,39153936,00.htm</A></P>
<H2 CLASS="western"><A NAME="6.9.Migration Study: Health First|outline"></A>
Migration Study: Health First</H2>
<P>&quot;There are two big IT projects going on at Health First Inc.,
and Linux is at the heart of both of them. Health First, a family of
Brevard County, Fla., nonprofit health care facilities, is migrating
its desktops to OpenOffice[.org] and bringing in many Novell's
Nterprise Linux Services. Weaning 6,000 IT users off of Microsoft
Office 97 on 3,500 PCs is no small feat. It's manageable, however, if
an IT shop takes it one step at a time, according to Danny J. Wall
and Daniel Bray, Health First IT network administrators. Their
primary pain comes from integrating OpenOffice[.org] with Health
First's almost 500 applications.</P>
<P>In part 1 of this in-depth migration story, Wall and Bray explain
why Health First is backing away from Microsoft Office and choosing
OpenOffice[.org]. Next, they describe the OpenOffice[.org]
implementation process. Then, in part three, Wall tells us how Health
First is bringing in and will be using Novell's new Linux services.&quot;</P>
<P>Part 1:</P>
<P><A HREF="http://searchenterpriselinux.techtarget.com/qna/0,289202,sid39_gci964811,00.html">http://searchenterpriselinux.techtarget.com/qna/0,289202,sid39_gci964811,00.html</A></P>
<P>Part 2:</P>
<P><A HREF="http://searchenterpriselinux.techtarget.com/qna/0,289202,sid39_gci964821,00.html">http://searchenterpriselinux.techtarget.com/qna/0,289202,sid39_gci964821,00.html</A></P>
<P>Part 3:</P>
<P><A HREF="http://searchenterpriselinux.techtarget.com/qna/0,289202,sid39_gci964823,00.html">http://searchenterpriselinux.techtarget.com/qna/0,289202,sid39_gci964823,00.html</A></P>
<H2 CLASS="western"><A NAME="6.10.StarOffice: ready for the big time|outline"></A>
StarOffice: ready for the big time</H2>
<P>&quot;StarOffice is already very popular and has become something
of a standard on Linux PCs often in the guise of OpenOffice[.org],
its open source brother. Sun acquired Star Division GmbH five years
ago, with the clear intention of competing directly with Microsoft.
It has taken time for Sun to establish a competitive position,
though. StarOffice never got strong reviews until version 6, which
debuted in early 2002. It is just now in version 7, which is
attracting even more attention because of the quality of the
release.&quot;</P>
<P>&quot;For large organizations looking to reduce the costs of the
desktop significantly, Star Office looks compelling. Siemens did a
trial project to test the Ximian/OpenOffice/Linux combination with
office staff in Germany last year. (Open Office has some minor
differences to StarOffice, such as fewer fonts and graphics) Siemens
concluded that changing to Linux and StarOffice was no more expensive
than a Windows upgrade - in terms of training. On top of that, it
saved 20 to 30 per cent in administration costs, 50 per cent in
hardware costs and 80 per cent in licensing costs. Pretty compelling
when you think about it.&quot;</P>
<P><A HREF="http://www.theregister.co.uk/2004/04/29/staroffice_reaches_maturity/">http://www.theregister.co.uk/2004/04/29/staroffice_reaches_maturity/</A></P>
<H2 CLASS="western"><A NAME="6.11.New White Paper about the OpenOffice.org XML File Format|outline"></A>
New White Paper about the OpenOffice.org XML File Format</H2>
<P>This new white paper explains the advantages of the OpenOffice.org
XML  file format used by all applications of the StarOffice software.
Developers also get a basic introduction to the different tools and
resources available for leveraging the XML file format
programmatically.</P>
<P>The white paper can be found at at: 
</P>
<P><A HREF="http://wwws.sun.com/software/star/staroffice/whitepapers/index.html">http://wwws.sun.com/software/star/staroffice/whitepapers/index.html</A></P>
<H2 CLASS="western"><A NAME="6.12.Article: Programming with the StarOffice 7 Software Development Kit|outline"></A>
Article: Programming with the StarOffice 7 Software Development Kit</H2>
<P>&quot;While StarOffice software offers a full-featured office
suite, you can make it even better by extending it with the
StarOffice Software Development Kit (SDK). You can create customized
extensions for your own organization or full-featured plug-ins that
other organizations may want to license.&quot;</P>
<P><A HREF="http://developers.sun.com/techtopics/desktop/reference/techart/staroffice_sdk.html">http://developers.sun.com/techtopics/desktop/reference/techart/staroffice_sdk.html</A></P>
<H2 CLASS="western"><A NAME="6.13.Star Wars: StarOffice Vs MS office|outline"></A>
Star Wars: StarOffice Vs MS office</H2>
<P>&quot;Mr Pramanik said that StarOffice is fast gaining ground,
citing a recent large 10,000 user win from United India and 8,000
units from the Haryana government as an example.&quot;</P>
<P><A HREF="http://economictimes.indiatimes.com/articleshow/638623.cms">http://economictimes.indiatimes.com/articleshow/638623.cms</A></P>
<H2 CLASS="western"><A NAME="6.14.Sun-Microsoft deal: Questionable significance for OpenOffice.org|outline"></A>
Sun-Microsoft deal: Questionable significance for OpenOffice.org</H2>
<P>&quot;In January 2001, Corel announced its intentions to spin off
its various Linux products and not work on broadening its WordPerfect
customer base beyond its existing audience. Now Microsoft has reached
an agreement with Sun, settling their $4 billion lawsuit for $1.6
billion. Since Microsoft's total payment to Sun will come to well
over 10 times the amount it paid to Corel, I wondered what impact if
any this might have on OpenOffice.org? I asked Dr. Louis
Suarez-Potts, community mnager for OpenOffice.org and Chair of the
Community Council, what the possible repercussions might be for the
popular open source office suite.&quot;</P>
<P><A HREF="http://software.newsforge.com/software/04/04/19/2117259.shtml?tid=130&amp;tid=82&amp;tid=93">http://software.newsforge.com/software/04/04/19/2117259.shtml?tid=130&amp;tid=82&amp;tid=93</A></P>
<H1 CLASS="western"><A NAME="7.April 2004|outline"></A>April 2004</H1>
<H2 CLASS="western"><A NAME="7.1.New Native-Lang Projects to be created|outline"></A>
New Native-Lang Projects to be created</H2>
<P>Two new Native-Lang Projects are on their way to be created: The
Azeri Project led by Emin Huseynov is at this moment in his pre-set
up phase. Emin wanted to start the Localization effort first, but
insisted on providing his community a meeting place here on
OpenOffice.org. The domain name hasn't been set up yet (no JCA nor
ssh keys submitted). However Charles-H. Schulz has spent some times
helping out Emin off list and asked Rail Aliev and G&ouml;rkem Cetin
from the Russian and Turkish Project to bring Emin and his community
on the right track.</P>
<P>Ukrainian Native-Lang Project proposal accepted: Led by Mr Vad V.
Mashckoff (Adiel), backed by the Alt Linux Community and OSDN
Ukraine, the project will soon start. The Localization effort however
is being undertaken by Sergyi Kudryk and will remain a separate
initiative on SourceForge.</P>
<H2 CLASS="western"><A NAME="7.2.Talk-shows &amp; Politics|outline"></A>
Talk-shows &amp; Politics</H2>
<P>After two months of off list work involving discussions with many
native-lang leads, Charles-H. Schulz comes up with what he believes
will be the &quot;Next Big Thing&quot; &copy;  for the Native-Lang
Confederation.</P>
<P>Proposal for the Directorates for the Native-Lang Confederation
posted and voted on; despite a big majority in favor of the reform
Charles-H. Schulz halted the process in order to propose a set of
ideas to be implemented that would acknowledge and prevent possible
risks of failure.</P>
<P>Software Patents not welcomed at all: the Homepage of
OpenOffice.org and many native-lang projects as well have displayed
their solidarity agains the Software Patents in the European Union.
Simon Brouwer, lead of the Dutch (nl) native-lang community launched
the momentum and got many followers.</P>
<P>Native-Lang Confederation Guidelines revised and augmented by
Charles-H. Schulz: new policies on projects'setup and creation
processes and dispute settlement policies inside the native-lang
projects.</P>
<H2 CLASS="western"><A NAME="7.3.Localizations|outline"></A>Localizations</H2>
<P>Ainu Localization effort started: Despite some cultural issues
making the translation of technical terms difficult, the Ainu people
will get OpenOffice.org in their own language; Hirano Kazunari, a
member of the Japanese Native-lang Project works on it with several
other volunteers. Louis proposed to interview the Ainu localization
team and sent them questions to the team.  The team has answered them
so the final interview will soon be published as an article linked
from the homepage. 
</P>
<P>Pavel Janik has extracted  the Readme  files of the upcoming 1.1.2
in order to allow the native-lang projects to translate them and
hence provide 100% translated builds in every available language.</P>
<P>Many localized 1.1.1 builds released: Prague gets multilingual:
French, German, Danish, Turkish, Japanese, Italian and many more
available for download.</P>
<H2 CLASS="western"><A NAME="7.4.Development &amp; Software|outline"></A>
Development &amp; Software</H2>
<P>OOVirg, FontOO, OOConv get translated in several languages: after
having included OOVirg in  the OOo software suite, the add-ons family
from the Native-Lang projects are getting a widespread use thanks to
their translations in several languages. Last to date but not least,
OOConv has been translated in Hungarian. Congratulations to their
authors and translators!</P>
<H2 CLASS="western"><A NAME="7.5.Marketing &amp; Communication|outline"></A>
Marketing &amp; Communication</H2>
<P>Several leads, such as Marko Gronroos (fi) and Davide Dozza (it)
expressed the idea to have another web site for marketing and users'
support purposes. Albeit the discussion got stopped somewhere, the
idea is already implemented in some sense through the many different
sites and portals about OOo in specific languages and countries.
CollabNet is not that easy to use, after all....</P>
<P>German Poster Contest for OpenOffice.org: congratulations to the
winners!</P>
<P>The OpenOffice.org Schools Project Mascot Competition was won by
Andrea Maggioni of Italy. Thanks to Ian Lynch for this contest that
was made possible by the OOoEdu initiative 
</P>
<P>(http://marketing.openoffice.org/education/schools/).</P>
<P>Live from Japan: The OpenOffice.org's Official Users Guide will be
available on the 23rd of April in the bookstores of Japan, thanks to
the members of the Japanese Native-Lang Project.</P>
<H2 CLASS="western"><A NAME="7.6.Wal-Mart teams with Sun on Linux PCs|outline"></A>
Wal-Mart teams with Sun on Linux PCs</H2>
<P>&quot;Wal-Mart Stores Inc. has begun selling PCs manufactured by
Microtel Computer Systems Inc. this week featuring Sun Microsystems
Inc.'s alternative operating system based on Linux and its StarOffice
productivity software, according to Wal-Mart's Web site.</P>
<P>Sun's Java Desktop System (JDS) is available in Microtel PCs with
processors from both Intel Corp. and Advanced Micro Devices Inc. The
systems are being sold on Walmart.com at prices ranging from $298 to
$798, depending on configuration.&quot;</P>
<P><A HREF="http://www.computerworld.com/hardwaretopics/hardware/story/0,10801,91813,00.html">http://www.computerworld.com/hardwaretopics/hardware/story/0,10801,91813,00.html</A></P>
<H2 CLASS="western"><A NAME="7.7.OpenOffice.org at Ministry of Health|outline"></A>
OpenOffice.org at Ministry of Health</H2>
<P>By using OpenOffice.org, the Congress of Brazil could save 5
million reals, i.e. 15% of the IT budget. In addition, the Ministry
of Health will migrate this year 30% of their computers to free
software. Another very interesting initiative: thousand government
employees will get training about free software in April so  that
they can share their knowledge with their colleagues, once the
migration has been completed.</P>
<P>French Article:</P>
<P><A HREF="http://linuxfr.org/2004/04/08/15959.html">http://linuxfr.org/2004/04/08/15959.html</A></P>
<P>One of the Spanish source articles explicitly mentions
OpenOffice.org and Linux. According to that article Argentina is also
not renewing their contracts with Microsoft.</P>
<P>Spanish Article:</P>
<P><A HREF="http://softwarelibre.cl/modules.php?op=modload&amp;name=News&amp;file=article&amp;sid=311&amp;mode=thread&amp;order=0&amp;thold=0">http://softwarelibre.cl/modules.php?op=modload&amp;name=News&amp;file=article&amp;sid=311&amp;mode=thread&amp;order=0&amp;thold=0</A></P>
<H2 CLASS="western"><A NAME="7.8.310,000 copies of Catalan version distributed|outline"></A>
310,000 copies of Catalan version distributed</H2>
<P>&quot;Next Sunday 25 of April, one of the biggest newspapers in
Spain, el Periodico de Catalunya[1] is going to give away for free a
copy of a CD-ROM that we at Softcatal&agrave; put together with
software localised into Catalan. The Catalan government is paying the
cost of producing the copies of the CD-ROM. The CD-ROM includes
OpenOffice.org 1.1, Abiword, Mozilla, FireFox, and other free
software tools and documents localised into Catalan by the people
arround the Softcatal&agrave; community. Windows and GNU/Linux
versions are included.</P>
<P>You can see how the CD-ROM looks like at:</P>
<P><A HREF="http://www.softcatala.org/~jmas/cd.jpg">http://www.softcatala.org/~jmas/cd.jpg</A></P>
<P>The newspaper has produced 310.000 copies of the CD-ROM This is
the  large action never done in Catalonia to distribute free software
to end-users. It's so cool to put some many hours of efforts in
translation and software developers in the end-users hands!.</P>
<P>Regards,</P>
<P>Jes&uacute;s.</P>
<P>[1] <A HREF="http://www.elperiodico.es/">http://www.elperiodico.es/</A>&rdquo;</P>
<P>Source: Jes&uacute;s Corrius (jesus@softcatala.org)</P>
<H2 CLASS="western"><A NAME="7.9.10,000 Seats in Finance|outline"></A>
10,000 Seats in Finance</H2>
<P>&quot;... i am in the middle of a huge OO implementation on a
Spanish bank. We are done with the pilot which calls to implement
10.000 OOo suites in a major bank in Spain. Hopefully, within a month
I will forward the business case which will be translated into 3
different languages to be used in other countries as an example of OO
TCO.&quot;</P>
<P>Source: aromeo@lared.es (found on the OpenOffice.org marketing
list) 
</P>
<H2 CLASS="western"><A NAME="7.10.The Israeli finance ministry plans to distribute 150,000 copies  of OpenOffice|outline"></A>
The Israeli finance ministry plans to distribute 150,000 copies  of
OpenOffice</H2>
<P>&quot;According to the site, the goal of this step, is to
encourage free choice, and to lessen the digital gap. It note the
need for support of organizations that can help the distribution to
the general population using Internet sites, advertising in
newspapers and internal distribution within the organizations
themselves. There is also a need, according to the site, for training
using the Internet and telephone support.&quot;</P>
<P><A HREF="http://lxer.com/module/newswire/view/9576/">http://lxer.com/module/newswire/view/9576/</A></P>
<H2 CLASS="western"><A NAME="7.11.Gati Limited (India) uses OpenOffice.org|outline"></A>
Gati Limited (India) uses OpenOffice.org</H2>
<P>&quot;Gati Limited &ndash; A leader in the express cargo industry
in India &ndash; is reaping remarkable benefits from its gargantuan
200 man year effort spent in designing its own customized ERP
solution, called GEMS (Gati Enterprise Management Solution).</P>
<P>[...]</P>
<P>Describing how Gati has taken the Open Source trend forward,
Ravikumar explained, &ldquo;We have 1000 desktops out of which hardly
10 users are on MS Office. The remaining have migrated to OpenOffice.
We are also using iPlanet for our mail server, instead of MS
Exchange.&rdquo;&quot;</P>
<P><A HREF="http://www.cxotoday.com/cxo/jsp/index.jsp?section=News&amp;subsection=Business&amp;subsection_code=1&amp;file=template1.jsp&amp;storyid=846">http://www.cxotoday.com/cxo/jsp/index.jsp?section=News&amp;subsection=Business&amp;subsection_code=1&amp;file=template1.jsp&amp;storyid=846</A></P>
<H2 CLASS="western"><A NAME="7.12.French OpenOffice.org Add-ons|outline"></A>
French OpenOffice.org Add-ons</H2>
<P>&quot;Some new tools are also available in french :</P>
<UL>
	<LI><P>Cart'OOo : a fabulous tutorial assorted with map libraries
	for the Gallery which allow you to create maps with Draw</P>
</UL>
<UL>
	<LI><P>PincOOo : will allow you to reproduce the style in the same
	that the brush do it in Microsoft Office</P>
</UL>
<UL>
	<LI><P>Multisave : in only one clic, save your documents in the file
	format of you choice SXW/SXC - PDF - DOC/XLS</P>
</UL>
<UL>
	<LI><P>SHOOo : a PHP class which allow to create a HTML Table and a
	Calc document from the result of a SQL query or from the content of
	a PHP table, illustrating the XML file format of OpenOffice.org and
	how it could be processed out of the suite.&quot;</P>
</UL>
<P>Different web pages with screen shots:</P>
<P><A HREF="http://www.framasoft.net/rubrique90.html">http://www.framasoft.net/rubrique90.html</A></P>
<P><A HREF="http://home.t-online.de/home/gfriege/dmaths/">http://home.t-online.de/home/gfriege/dmaths/</A></P>
<P><A HREF="http://soshg.free.fr/cartooo/demo1.htm">http://soshg.free.fr/cartooo/demo1.htm</A></P>
<P><A HREF="http://oootools.free.fr/fooox/">http://oootools.free.fr/fooox/</A></P>
<P><A HREF="http://www.jdisoftware.co.uk/pages/epdf-home.php">http://www.jdisoftware.co.uk/pages/epdf-home.php</A></P>
<P>Source: Sophie Gautier (<A HREF="mailto:sgauti@firstnet1.com">sgauti@firstnet1.com</A>)</P>
<H2 CLASS="western"><A NAME="7.13.Linux User &amp; Developer Awards - Best Open Source Project: OpenOffice.org|outline"></A>
Linux User &amp; Developer Awards - Best Open Source Project:
OpenOffice.org</H2>
<P>&quot;Linux User &amp; Developer magazine last night announced the
winners of this year's prestigious Linux User &amp; Developer Awards
at a gala event held in London's Royal Lancaster Hotel. Hosted by
comedian and renowned comedy scriptwriter, Barry Cryer, the night was
a spectacular success - the biggest and best awards show in the Linux
industry. There were 12 panel-nominated award categories, with best
Open Source Project going to Sun Microsystems for OpenOffice.org.&quot;</P>
<P><A HREF="http://www.btnsn.com/btnsn/pr_view.asp?id=5276&amp;dt=&amp;cid=8652">http://www.btnsn.com/btnsn/pr_view.asp?id=5276&amp;dt=&amp;cid=8652</A></P>
<H1 CLASS="western"><A NAME="8.March 2004|outline"></A>March 2004</H1>
<H2 CLASS="western"><A NAME="8.1.OASIS Milestone Reached|outline"></A>
OASIS Milestone Reached</H2>
<P>&quot;An important milestone in the evolution of a universal XML
file format has been achieved. In a unanimous vote, the OASIS Open
Office XML Format TC has formally approved the Open Office
Specification 1.0 Draft 12.</P>
<P>The completed phase one specification now goes before the OASIS
general membership for comment and approval. The discussion period
and vote date have yet to be determined.&quot;</P>
<P><A HREF="//servlets/ReadMsg?list=discuss&amp;msgId=1122898">//servlets/ReadMsg?list=discuss&amp;msgId=1122898</A></P>
<H2 CLASS="western"><A NAME="8.2.OpenOffice.org BizDev Project|outline"></A>
OpenOffice.org BizDev Project</H2>
<P>&quot;We are proud to announce the opening of the Business
Development project of OpenOffice.org (BizDev) The goals of this
project are to build a business partners' network around
OpenOffice.org .</P>
<P>In this regard the BizDev project is the place where commercial
leads, and business and consulting information can be discussed. It
is a project for services professionals who are looking for
customers, projects, and for contributing the way they want. Several
companies have already joined the BizDev project. Among them is the
Olliance Group, based in Palo Alto, California, a consulting firm
pushing the adoption of Open Source Software and open standards in
large companies. They believe in this project and think that letting
businesses participate and generate wealth around OpenOffice.org is a
major asset in today's industry.</P>
<P>&quot;We are seeing and hearing a need for a more supportive and
integrated approach from the community to address users requirements
in deploying Open Source solutions. Creating a project where service
providers can present themselves, communicate, and discuss customer&rsquo;s
needs and topics such as &ldquo;best practices&rdquo; is a bold,
innovative, and needed step by OpenOffice.org&rdquo; said Andrew
Aitken, Managing Partner, Olliance Group, a leading OSS strategic
consulting firm.</P>
<P>As a first step, the BizDev project volunteers have built a
business directory called the Consultants' Directory
(http://bizdev.openoffice.org/consultants.html ) where consulting
businesses get listed in order to maximize their visibility to the
public and the community. This list already provides a large amount
of information and is still growing.&quot;</P>
<P>Source: Charles-H. Schulz (BizDev Project Lead)</P>
<P><A HREF="http://bizdev.openoffice.org/">http://bizdev.openoffice.org/</A></P>
<H2 CLASS="western"><A NAME="8.3.OpenOffice.org 1.1.1RC3|outline"></A>
OpenOffice.org 1.1.1RC3</H2>
<P>&quot;Release Candidate 3 of OpenOffice.org 1.1.1 is ready for
download.</P>
<P><A HREF="/download/1.1.1rc3/index.html">/download/1.1.1rc3/index.html</A></P>
<P>It incorporates numerous bug fixes and is cleaner than RC1.
However, we are asking you, the community, to make sure that there
are no outstanding issues remaining.</P>
<P>Therefore, please download RC3 and test it. If you find any bugs
or regressions, file an issue describing it. To learn how to file an
issue, visit our QA Project:</P>
<P><A HREF="http://qa.openoffice.org/issue_handling/project_issues.html">http://qa.openoffice.org/issue_handling/project_issues.html</A></P>
<P>This build is so far in English.&quot;</P>
<P>Source: Louis Suarez-Potts</P>
<H2 CLASS="western"><A NAME="8.4.OOo 1.1 Portuguese Native-Lang translation|outline"></A>
OOo 1.1 Portuguese Native-Lang translation</H2>
<P>The N-L Portuguese team released the OpenOffice.org 1.1 in
Portuguese.</P>
<P>For about about 4 months we've worked in the glossary and on the
HUGE GSI file of OOo1.1. We've faced some problemas with the build,
mostly because of the Windows build and some template problems, that
Olivier Hallot from the PT-BR Team helped us solve it. For him, one
big hug for the important and essential help.</P>
<P>Also, the QA released 3 public RC's, on which the last one, had
been downloaded in 3 days, 2.000 times for Windows and 400 for Linux.</P>
<P>More information can be found here (in Portuguese):</P>
<P><A HREF="http://pt.openoffice.org/html/ooopt-marketing-pressrelease-1.1f_PT.html">http://pt.openoffice.org/html/ooopt-marketing-pressrelease-1.1f_PT.html</A></P>
<P>Source: Louis Suarez-Potts</P>
<H2 CLASS="western"><A NAME="8.5.FontOOo 1.0|outline"></A>FontOOo 1.0</H2>
<P>&quot;Please find here the official announcement of FontOOo 1.0</P>
<P>Based on DicOOo principle, this tool let you install free fonts
into OOo (no system installation is performed).</P>
<P>You'll find FontOOo at: <A HREF="http://oooconv.free.fr/fontooo">http://oooconv.free.fr/fontooo</A></P>
<P>This is an official call for testers and translators in the same
spirit as DicOOo.</P>
<P>For contributing to your native lang translation, please refer to
issue</P>
<P><A HREF="//issues/show_bug.cgi?id=25372">//issues/show_bug.cgi?id=25372</A></P>
<P>Please note also that german team is preparing an HowTo.</P>
<P><A HREF="http://www.christianmarkgraf.de/ooo/tryouts/FontOOo/fontooo.html">http://www.christianmarkgraf.de/ooo/tryouts/FontOOo/fontooo.html</A></P>
<P>Thanks to all translators and hard workers. Especially</P>
<P>Kevin Hendricks, Rolf Meyer and Christian Markgraf&quot;</P>
<P><A HREF="http://oooconv.free.fr/fontooo">http://oooconv.free.fr/fontooo</A></P>
<P>Source: Laurent Godard</P>
<H2 CLASS="western"><A NAME="8.6.OOo Education Mascot Competition|outline"></A>
OOo Education Mascot Competition</H2>
<P>There is a competition to choose the OOo Education mascot!!</P>
<P>It only takes a few seconds to vote, and the mascot will help in
publicing OOo to schools.</P>
<P>Vote here:</P>
<P><A HREF="http://www.math.umd.edu/~dcarrera/openoffice/mascot/vote.cgi">http://www.math.umd.edu/~dcarrera/openoffice/mascot/vote.cgi</A></P>
<H2 CLASS="western"><A NAME="8.7.Microsoft Is Facing Long-Term Adjustment|outline"></A>
Microsoft Is Facing Long-Term Adjustment</H2>
<P>&quot;Forrester's Schadler said his research team recently
interviewed officials of 140 major North American companies about
their software plans. Of those, 65 are using open-source
applications, and 20 are planning to.</P>
<P>And 12 of the 140 are using an open-source competitor of Office,
known as OpenOffice, while eight are planning to.&quot;</P>
<P><A HREF="http://www.bizreport.com/article.php?art_id=6557">http://www.bizreport.com/article.php?art_id=6557</A></P>
<H2 CLASS="western"><A NAME="8.8.City of Haarlem moving to OpenOffice.org|outline"></A>
City of Haarlem moving to OpenOffice.org</H2>
<P>The city of Haarlem (approx. 150.000 inhabitants) is about to
migrate from Office97 to OpenOffice.</P>
<P>More information can be found on:</P>
<P><A HREF="http://www.ososs.nl/article.jsp?article=8703">http://www.ososs.nl/article.jsp?article=8703</A>
 
</P>
<P><BR><BR>
</P>
<H2 CLASS="western"><A NAME="8.9.Singapore Ministry of Education and Argonne National Laboratory Turn To Java(TM) Enterprise System for Dramatic Cost Savings|outline"></A>
Singapore Ministry of Education and Argonne National Laboratory Turn
To Java(TM) Enterprise System for Dramatic Cost Savings</H2>
<P>&quot;Coupled with the growing worldwide adoption of Sun's
StarOffice(TM) productivity suite, now in use by millions of students
and faculty in more than 165,000 school districts, higher education
institutions and ministries of education in 21 countries, the
compelling advantage of Sun's software solutions is gaining a
foothold in the education market. The rapid adoption of StarOffice is
fulfilling Sun's vision to equip students and teachers worldwide with
access to low-cost office productivity software based on open source
technology.&quot;</P>
<P><A HREF="http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=SVBIZINK6.story&amp;STORY=/www/story/03-02-2004/0002120063&amp;EDATE=TUE+Mar+02+2004,+03:01+AM">http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=SVBIZINK6.story&amp;STORY=/www/story/03-02-2004/0002120063&amp;EDATE=TUE+Mar+02+2004,+03:01+AM</A></P>
<H2 CLASS="western"><A NAME="8.10.City of Lille considering migration to OpenOffice.org|outline"></A>
City of Lille considering migration to OpenOffice.org</H2>
<P>The City of Lille is requesting proposals for the creation of an
OpenOffice.org migration study. French web page:</P>
<P><A HREF="http://www.lillemetropole.fr/page.php?P=data/services_interactifs/sites_utiles/services/procedures_adaptees/&amp;Item=3293">http://www.lillemetropole.fr/page.php?P=data/services_interactifs/sites_utiles/services/procedures_adaptees/&amp;Item=3293</A></P>
<P><A HREF="http://www.lillemetropole.fr/page.php?P=data/services_interactifs/sites_utiles/">http://www.lillemetropole.fr/page.php?P=data/services_interactifs/sites_utiles/</A></P>
<H2 CLASS="western"><A NAME="8.11.French Officials Eye Open-Source Apps|outline"></A>
French Officials Eye Open-Source Apps</H2>
<P>&quot;The French government will install open source software on
the desktop as part of Project ADELE, a plan to computerize much of
the country's administration by 2007, a government official says.&quot;</P>
<P><A HREF="http://www.pcworld.com/news/article/0,aid,114759,pg,1,00.asp">http://www.pcworld.com/news/article/0,aid,114759,pg,1,00.asp</A></P>
<H2 CLASS="western"><A NAME="8.12.Haryana goes the open-source way with Sun|outline"></A>
Haryana goes the open-source way with Sun</H2>
<P>&quot;He said the Haryana government had decided to adopt the
software because of the 'monopolistic and whimsical behaviour adopted
by Microsoft for its Office software.'&quot;</P>
<P><A HREF="http://inhome.rediff.com/money/2004/mar/03sun.htm">http://inhome.rediff.com/money/2004/mar/03sun.htm</A></P>
<H2 CLASS="western"><A NAME="8.13.ICICI OneSource Dumps Microsoft Office For Sun|outline"></A>
ICICI OneSource Dumps Microsoft Office For Sun</H2>
<P>[N.B. 1 lak = 100,000. Therefore 72 lakh = 7.2 million. The
currency used is rupees]</P>
<P>&quot;ICICI OneSource, a Business Process Outsourcing (BPO)
services provider, has undertaken a bold move of switching its
desktops from Microsoft Office to Sun&rsquo;s StarOffice 7, saving a
whopping Rs 72 lakh in the bargain.&quot;</P>
<P>&quot;Regarding the obvious compatibility qualms that first time
users have - as Microsoft Office is by far the established standard
used worldwide &ndash; Prashanth said, &ldquo;There are many, but so
far we have faced a few with respect to Word and Excel formats when
advanced features are employed.&rdquo;&quot;</P>
<P>&quot;Apart from its lower price, another advantage of StarOffice
7 over Microsoft Office is its cross-platform support. Where Office
2003 will run only on Windows 2000 and XP, StarOffice 7 supports
Windows 98, ME, NT, 2000 and XP, as well as Linux and Solaris. The
software offers functionality to enable export to PDF, and the
Macromedia Flash format, and supports 10 languages.&quot;</P>
<P><A HREF="http://www.cxotoday.com/cxo/jsp/index.jsp?section=News&amp;subsection=Business&amp;subsection_code=1&amp;file=template1.jsp&amp;storyid=720">http://www.cxotoday.com/cxo/jsp/index.jsp?section=News&amp;subsection=Business&amp;subsection_code=1&amp;file=template1.jsp&amp;storyid=720</A></P>
<H2 CLASS="western"><A NAME="8.14.BharateeyaOO.o Gives Open Office a 'Desi' Push|outline"></A>
BharateeyaOO.o Gives Open Office a 'Desi' Push</H2>
<P>&quot;BharateeyaOO.o (BharateeyaOpenOffice.org), a project
initiated by Bangalore-based Centre for Development of Advanced
Computing (CDAC) - formerly known as NCST &ndash; has gained
significant headway in making OpenOffice accessible to regional
language users in India.</P>
<P>The group - founded about two and a half years back &ndash; has a
primary objective to internationalize and localize OpenOffice, Sun&rsquo;s
Open Source initiative.&quot;</P>
<P>&quot;The team incorporated Complex Text Layout (CTL) support for
Indian Languages into OpenOffice, and Kannada and Telgu versions of
the software are next on the agenda.&quot;</P>
<P>Localisation effort at:</P>
<P><A HREF="http://hi.openoffice.org/">http://hi.openoffice.org</A></P>
<P><A HREF="http://ta.openoffice.org/">http://ta.openoffice.org</A></P>
<P><A HREF="http://www.ncb.ernet.in/bharateeyaoo">http://www.ncb.ernet.in/bharateeyaoo</A></P>
<P>Story at:</P>
<P><A HREF="http://www.cxotoday.com/cxo/jsp/index.jsp?section=News&amp;subsection=Business&amp;subsection_code=1&amp;file=template1.jsp&amp;storyid=716">http://www.cxotoday.com/cxo/jsp/index.jsp?section=News&amp;subsection=Business&amp;subsection_code=1&amp;file=template1.jsp&amp;storyid=716</A></P>
<H2 CLASS="western"><A NAME="8.15.Namibian OSS workshop produces Kiswahili dictionary|outline"></A>
Namibian OSS workshop produces Kiswahili dictionary</H2>
<P>&quot;Kiswahili speakers can now spellcheck documents in their own
language. A group of developers taking part in the Africa Source
joined forces - and resources - to develop the first-ever Kiswahili
dictionary.&quot;</P>
<P>&quot;During a series of workshops and a skills sharing session at
the Africa Source gathering, Githeko and Bailey worked on cleaning up
the wordlist and preparing it to create the Kiswahili dictionary.
During one of the mid-week sessions the final dictionary was created
and released to the world of OpenOffice.org users.&quot;</P>
<P><A HREF="http://www.translate.org.za/">http://www.translate.org.za/</A></P>
<P><A HREF="http://www.tectonic.co.za/default.php?action=view&amp;id=281&amp;topic=Open Source">http://www.tectonic.co.za/default.php?action=view&amp;id=281&amp;topic=Open%20Source</A></P>
<H2 CLASS="western"><A NAME="8.16.German distributor sells more than a million copies of Sun's StarOficce|outline"></A>
German distributor sells more than a million copies of Sun's
StarOficce</H2>
<P>&quot;Sun Microsystems says that German OEM software distributor
Markement has sold more than one million copies of Sun's StarOffice.
The milestone marks more that 40 million copies distributed to date,
and puts StarOffice and its open source counterpart, OpenOffice.org,
&quot;as one of the most popular choices among consumers, enterprises
and governments worldwide,&quot; according to the company.&quot;</P>
<P>&quot;Markement, based in Stuttgart, Germany, sells StarOffice
both as a standalone program and as part of its popular PCSuite
office bundle. This German productivity package also includes
CorelDraw Essentials, Norton Anti-Virus 2004 and Marco Polo
TravelRouting Europe 2004, a European travel-planning program.&quot;</P>
<P><A HREF="http://www.desktoplinux.com/news/NS2163896330.html">http://www.desktoplinux.com/news/NS2163896330.html</A></P>
<P><A HREF="http://www.eweek.com/article2/0,1759,1551056,00.asp">http://www.eweek.com/article2/0,1759,1551056,00.asp</A></P>
<P>Additional reporting:</P>
<P><A HREF="http://biz.yahoo.com/prnews/040318/sfth016_1.html">http://biz.yahoo.com/prnews/040318/sfth016_1.html</A></P>
<P><A HREF="http://www.cxotoday.com/cxo/jsp/index.jsp?section=News&amp;subsection=Business&amp;subsection_code=1&amp;file=template1.jsp&amp;storyid=744">http://www.cxotoday.com/cxo/jsp/index.jsp?section=News&amp;subsection=Business&amp;subsection_code=1&amp;file=template1.jsp&amp;storyid=744</A></P>
<H2 CLASS="western"><A NAME="8.17.OpenOffice.org Magazine|outline"></A>
OpenOffice.org Magazine</H2>
<P>&quot;As I've mentioned before, an OpenOffice.org magazine
(one-shot only, not periodical) will be out here in Turkey on
Saturday, this week. It mentions OpenOffice.org's most wanted
features, along with other practical tutorials about Writer, Calc,
Impress, Draw, HTML and Math.</P>
<P>You may want to see the cover page on
<A HREF="http://www.gorkemcetin.com/kapak.jpg">http://www.gorkemcetin.com/kapak.jpg</A>
for informational purposes. It's in Turkish however.&quot;</P>
<P>Source: G&ouml;rkem &Ccedil;etin</P>
<H2 CLASS="western"><A NAME="8.18.OpenOffice debuts bizdev community|outline"></A>
OpenOffice debuts bizdev community</H2>
<P>&quot;The OpenOffice project has created an online meeting place
for developers, consultants and business users of the OpenOffice and
Sun's StarOffice office suites.</P>
<P>Covering both OpenOffice and Sun's StarOffice the
bizdev.openoffice.org site aims build a network and provide a meeting
place between all those hoping to develop and use alternatives to
Microsoft's Office. As a first step the bizdev group has opened a
directory of consultants who specialise in open source office
products. The group also allows members to set up their own mailing
lists to generate sales leads and possible partnerships.&quot;</P>
<P><A HREF="http://www.pcpro.co.uk/news/news_story.php?id=54031">http://www.pcpro.co.uk/news/news_story.php?id=54031</A></P>
<P><A HREF="http://bizdev.openoffice.org/">http://bizdev.openoffice.org/</A></P>
<H2 CLASS="western"><A NAME="8.19.Pravakta Plug-in for OpenOffice.org 1.1 Writer|outline"></A>
Pravakta Plug-in for OpenOffice.org 1.1 Writer</H2>
<P>The Matrubhasha group at CDAC (Formerly NCST) Bangalore India has
been working on building Speech Synthesis products for Indian
Languages.</P>
<P>Pravakta is a speech plug-in that has been developed recently for
OpenOffice.org 1.1 Writer.</P>
<P>Pravakta can be downloaded from:</P>
<P><A HREF="http://www.ncb.ernet.in/matrubhasha/products.shtml#pravakta">http://www.ncb.ernet.in/matrubhasha/products.shtml#pravakta</A></P>
<P>Source: R.K.V.S.Raman (leader of Matrubhasha group at CDAC</P>
<P>Bangalore India)</P>
<H2 CLASS="western"><A NAME="8.20.XML Matters: XML for word processors|outline"></A>
XML Matters: XML for word processors</H2>
<P>&quot;Free software and XML document formats are a natural
pairing. The inherent readability of XML just makes interchange and
format specification easier, and the wide availability of XML
libraries makes creation of new tools simple. Moreover, looking at
these word processor formats has really helped me to see the
modularity benefits of namespaces -- when done correctly, namespaces
can leverage the work done by many groups of independent developers.</P>
<P>However, XML itself only goes so far. For example, Microsoft is
also moving towards an XML format for future versions of MS Word; but
in contrast to the openness of the OASIS/OpenOffice.org or AbiWord
formats, Microsoft is surrounding its format with patent
applications, and putting a veil of secrecy around the format
variations (plus it uses cryptic tag and attribute names rather than
self-documenting ones).</P>
<P>XML by itself does not really mean open, but fortunately, the
developers of KOffice, AbiWord, and OpenOffice.org have done a
generally wonderful job of obtaining openness with XML (albeit, the
wild world of community development still leaves occasional impedance
mismatches in, for example, DTDs).&quot;</P>
<P><A HREF="http://www-106.ibm.com/developerworks/xml/library/x-matters33/">http://www-106.ibm.com/developerworks/xml/library/x-matters33/</A></P>
<H2 CLASS="western"><A NAME="8.21.Microsoft releases OpenOffice.org 1.1 Competitive Guide|outline"></A>
Microsoft releases OpenOffice.org 1.1 Competitive Guide</H2>
<P>Why You Should Choose MS Office Over OO.org</P>
<P><A HREF="http://slashdot.org/articles/04/03/25/1950234.shtml?tid=109">http://slashdot.org/articles/04/03/25/1950234.shtml?tid=109</A></P>
<P>Microsoft displays fear, uncertainty, and doubt toward
OpenOffice.org</P>
<P><A HREF="http://software.newsforge.com/software/04/03/27/0134204.shtml?tid=132&amp;tid=82&amp;tid=93">http://software.newsforge.com/software/04/03/27/0134204.shtml?tid=132&amp;tid=82&amp;tid=93</A></P>
<P>Microsoft FUD Machine Aims at OpenOffice.org</P>
<P><A HREF="http://slashdot.org/articles/04/03/27/1919256.shtml?tid=109&amp;tid=185&amp;tid=187">http://slashdot.org/articles/04/03/27/1919256.shtml?tid=109&amp;tid=185&amp;tid=187</A></P>
<H2 CLASS="western"><A NAME="8.22.Comments/opinions reg. the OpenOffice.org 1.1 Competitive Guide|outline"></A>
Comments/opinions reg. the OpenOffice.org 1.1 Competitive Guide</H2>
<P>&quot;1. Ease of Use</P>
<P>Due to OpenOffice.org's similarity to Microsoft Office most people
don't need a lot of retraining. Besides, there is a huge focus on
usability for the next major release. On the other hand,
OpenOffice.org has some superior tools and concepts like the built-in
one-click PDF export, the Navigator and the Stylist.</P>
<P>Recently a German computer magazine tested different word
processors  and came to the conclusion that OpenOffice.org and
StarOffice are  superior with respect to the creation of long
documents like a diploma thesis.</P>
<P>With respect to database support, OpenOffice.org provides a
powerful database frontend that can be used with many different
database systems in the backend. Besides, in many cases the migration
to a new desktop platform also turned out to be a good time to
consolidate the huge number of hard to maintain local MS Access
databases into one web based platform that uses a secure and
performant server database in the backend.</P>
<P>2. Tailored Solutions</P>
<P>Due to the fact that the source code of OpenOffice.org is
available for everybody and that the file format for all applications
is an open XML file format it is possible to create very tailored
solutions based on OpenOffice.org. A list of companies that have
already created innovative solutions based on OpenOffice.org can be
found on the OpenOffice.org developer web page at 
</P>
<P><A HREF="http://development.openoffice.org/">http://development.openoffice.org/</A>.</P>
<P>Integrations and integration prototypes from SAP, FileNet,
Software AG and others were demo'd at CeBIT (Hannover, Germany) last
week.</P>
<P>3. Support When Needed</P>
<P>Support for OpenOffice.org is available from large global
companies as well as a huge and fast growing number of small local
companies. 
</P>
<P>A list of companies providing support can be found at 
</P>
<P><A HREF="/support/index.html">/support/index.html</A>
z.B. StarOffice. 
</P>
<P>4. Better and Faster Work</P>
<P>Due to the fact that OpenOffice.org and StarOffice are used at
many  schools and universities less people need retraining simply
because  they have used OpenOffice.org or StarOffice right from the 
beginning. At the same time more and more software vendors are 
integrating their products with OpenOffice.org in order to simplify
collaboration. In addition, OpenOffice.org is available on all 
</P>
<P>major desktop platforms including Windows, Linux, Mac OS X and 
Solaris. This includes the open XML file format support.</P>
<P>5. Seamless Information Exchange</P>
<P>Not only does OpenOffice.org have quickly-improving import and
export filters for Microsoft Office, it also supports the creation of
popular exchange formats like PDF and Flash out of the box. In
addition, OpenOffice.org is available for many operating  systems and
languages. Recipients of an OpenOffice.org file can simply download
the latest version of the software for free in order to open and edit
the document. Thus, nobody is forced to buy expensive software.</P>
<P>For e-mail based collaboration and calendaring a growing list of
products is available including Mozilla, Evolution, Eudora, Glow and
others. On the server side there is again the choice between free
open source tools like OpenGroupware.org and commercial products like
the groupware products from Sun Microsystems and Novell.</P>
<P>6. Easier Deployment and Maintenance</P>
<P>OpenOffice.org allows an unattended installation via scripts
(so-called &quot;reponse files&quot;). In addition multiple vendors
provide deployment and mangement solutions for their  OpenOffice.org
based products. A few examples are the StarOffice  Configuration
Manager and the Sun Control Station as well as Novell's Red Carpet.
In order to minimize migration costs different companies including
SCAI and Sun Microsystems are working on migration tools.</P>
<P>7. Security</P>
<P>The virus issues of the last few months have clearly shown that
almost exclusively systems with Windows and MS Office were affected.
Although no operating system can guarantee invulnerability regarding
virusses, the combination of OpenOffice.org and a non-Windows
operating systems has proven to be very secure.</P>
<P>8. Investment You Can Trust</P>
<P>The OpenOffice.org file format is the basis of the OASIS Open XML
File Format which will be used as the default file format in future
versions of OpenOffice.org. Therefore, the file format is controlled
by a standards body instead of a single vendor. In addition, the
availablity of the source code in connection with strong support
through the OpenOffice.org community and companies like Sun
Microsystems ensure ongoing innovation and improvement.&quot;</P>
<P>Source: Stephanie Berger, <A HREF="mailto:stephi.berger@gmx.net">stephi.berger@gmx.net</A></P>
<H2 CLASS="western"><A NAME="8.23.Microsoft Is Facing Long-Term Adjustment|outline"></A>
Microsoft Is Facing Long-Term Adjustment</H2>
<P>&quot;Forrester's Schadler said his research team recently
interviewed officials of 140 major North American companies about
their software plans. Of those, 65 are using open-source
applications, and 20 are planning to.</P>
<P>And 12 of the 140 are using an open-source competitor of Office,
known as OpenOffice, while eight are planning to.&quot;</P>
<P><A HREF="http://www.bizreport.com/article.php?art_id=6557">http://www.bizreport.com/article.php?art_id=6557</A></P>
<H2 CLASS="western"><A NAME="8.24.Third package announced for PC Gemilang project|outline"></A>
Third package announced for PC Gemilang project</H2>
<P>&quot;The Energy, Communications and Multimedia Ministry and the
Association of the Computer and Multimedia Industry of Malaysia
(Pikom) have announced a third package for their PC Gemilang
programme, which seeks to make available affordable PCs to the
Malaysian public.&quot;</P>
<P>&quot;The PC Gemilang project, which officially kicks off next
Monday, was announced earlier this month with two models: An RM988
(US$260) PC running a Linux-based operating system and bundled with
the OpenOffice productivity suite; and an RM1,147 (US$302) desktop
with the Bahasa Malaysia version of the Microsoft Windows XP
operating system and Works Suite 2004.&quot;</P>
<P><A HREF="http://star-techcentral.com/tech/story.asp?file=/2004/3/12/technology/7525432&amp;sec=technology">http://star-techcentral.com/tech/story.asp?file=/2004/3/12/technology/7525432&amp;sec=technology</A></P>
<P><A HREF="http://www.idg.com.sg/idgwww.nsf/0/954F93F62C284D3F48256E4C00333C91?OpenDocument">http://www.idg.com.sg/idgwww.nsf/0/954F93F62C284D3F48256E4C00333C91?OpenDocument</A></P>
<P><A HREF="http://news.com.com/2100-1016_3-5168029.html">http://news.com.com/2100-1016_3-5168029.html</A></P>
<H2 CLASS="western"><A NAME="8.25.StarOffice takes on Microsoft|outline"></A>
StarOffice takes on Microsoft</H2>
<P>&quot;Some pundits, including Gartner Dataquest&rsquo;s Michael
Silver, say that one key to the success of StarOffice 7--now
available in Linux, Windows and Solaris flavors--is its open XML file
structure. Many widely available XML tools--from Sun or not-- can be
used to edit files. Plus, it has an inexpensive price tag. Those
factors together, he told internetnews.com, could translate into a
10% chunk taken from Microsoft&rsquo;s currentdominance in the market
segment.&quot;</P>
<P><A HREF="http://www.pdfzone.com/news/877-PDFzone_news.html">http://www.pdfzone.com/news/877-PDFzone_news.html</A></P>
<H2 CLASS="western"><A NAME="8.26.Linux Saves Big Money|outline"></A>Linux
Saves Big Money</H2>
<P>&quot;Pittsburgh-based Maronda Homes now runs desktop applications
on its 550 PCs with OpenOffice, Linux software downloaded off the Web
from www.openoffice.org.&quot;</P>
<P>&quot;The basic idea is that running OpenOffice is cheaper, and
over time the desktop applications will develop,&quot; says Mark
Piccolo, Maronda's director of management information systems.&quot;</P>
<P><A HREF="http://www.linuxinsider.com/perl/story/33013.html">http://www.linuxinsider.com/perl/story/33013.html</A></P>
<H2 CLASS="western"><A NAME="8.27.HP Starts Pushing Desktop Linux|outline"></A>
HP Starts Pushing Desktop Linux</H2>
<P>&quot;The company is working on a new desktop kit based on the 2.6
Linux kernel that will offer a choice of KDE 3.2, Gnome 2.4 or the
house-brand MandrakeGalaxy 2 desktop environments as well as
OpenOffice 1.1.&quot;</P>
<P><A HREF="http://www.linuxworld.com/story/44054.htm">http://www.linuxworld.com/story/44054.htm</A></P>
<H2 CLASS="western"><A NAME="8.28.Novell to offer users a Windows experience on a Linux desktop|outline"></A>
Novell to offer users a Windows experience on a Linux desktop</H2>
<P>&quot;The office productivity package is derived from the open
source Openoffice software.</P>
<P>Gaines said Novell's plan was to allow users to exchange
information easily with Microsoft Office and Exchange.&quot;</P>
<P>&quot;He said the Ximian Openoffice suite allows users to exchange
documents with MS Office. For instance, Powerpoint slides can be run
and edited on the Ximian system.&quot;</P>
<P><A HREF="http://www.computerweekly.com/articles/article.asp?liArticleID=129147&amp;liArticleTypeID=1&amp;liCategoryID=1&amp;liChannelID=126&amp;liFlavourID=1&amp;sSearch=&amp;nPage=1">http://www.computerweekly.com/articles/article.asp?liArticleID=129147&amp;liArticleTypeID=1&amp;liCategoryID=1&amp;liChannelID=126&amp;liFlavourID=1&amp;sSearch=&amp;nPage=1</A></P>
<H2 CLASS="western"><A NAME="8.29.Life after Microsoft - One firm's complete conversion to open source|outline"></A>
Life after Microsoft - One firm's complete conversion to open source</H2>
<P>&quot;After a run-in with Microsoft and the BSA, Sterling Ball
converted all his company's operations to open-source software. He
explains why he'll ever go back to Redmond's products&quot;</P>
<P>&quot;But since jettisoning all of Microsoft products three years
ago, Ernie Ball has also gained notoriety as a company that dumped
most of its proprietary software -- and still lived to tell the
tale.&quot;</P>
<P>&quot;Ball's IT crew settled on a potpourri of open-source
software -- Red Hat's version of Linux, the OpenOffice office suite,
Mozilla's Web browser -- plus a few proprietary applications that
couldn't be duplicated by open source.&quot;</P>
<P>http://insight.zdnet.co.uk/software/linuxunix/0,39020472,39115887-2,00.htm</P>
<P><BR><BR>
</P>
<H1 CLASS="western"><A NAME="9.February 2004|outline"></A>February
2004</H1>
<H2 CLASS="western"><A NAME="9.1.Lao Native-Lang Project announced|outline"></A>
Lao Native-Lang Project announced</H2>
<P>&quot;We have the pleasure to announce the opening of the Lao
Native-Lang project (http://lo.openoffice.org), led by Mr. Anousak
Souphavanh. Thanks to the work of his team, OpenOffice.org has
extended its reach up to Laos, a small and beautiful country,
birthplace of a magnificient and antique culture.&quot;</P>
<P>Source: Charles-H. Schulz, Lead of the Native-Lang Confederation</P>
<H2 CLASS="western"><A NAME="9.2.Arabic &amp; Hebrew Projects announced|outline"></A>
Arabic &amp; Hebrew Projects announced</H2>
<P>&quot;Today we have the pleasure to announce the opening of the
Arabic and Hebrew Native-Lang projects. The Arabic Project
(http://ar.openoffice.org) is led by Mr Khayat and backed by the
Arabeyes free-software community, an important player and supporter
of free software and OpenOffice.org in the Arabic world. The Hebrew
project has been created by Tkos, an Israeli company who is also in
charge of localizing OpenOffice.org and StarOffice but who managed to
set up a real and lively community of users, developers and
marketers.</P>
<P>These two projects show the growing influence of OpenOffice.org in
the Middle-East and we are delighted that  such prestigious cultures
and people have adopted OpenOffice.org as their free and open
productivity suite .</P>
<P>Source: Charles-H. Schulz, Lead of the Native-Lang Confederation</P>
<H2 CLASS="western"><A NAME="9.3.Misc Native-Lang Project News|outline"></A>
Misc Native-Lang Project News</H2>
<P>On Saturday the 7th of February, the Native-Lang Confederation has
seen four new projects' proposals who have all been accepted in due
time and are currently in setup phase:</P>
<P>-The Armenian native-lang project</P>
<P>-The Hungarian native-lang project</P>
<P>-The Norwegian native-lang project</P>
<P>-The Sango native-lang project (from Central Africa).</P>
<P>This day has marked the highest growth rate for the Native-Lang
Confederation and brings potentially ten of thousands of
OpenOffice.org users and hundreds of volunteers to our community.</P>
<P>Source: Charles-H. Schulz, Lead of the Native-Lang Confederation</P>
<H2 CLASS="western"><A NAME="9.4.Japanese Announcement|outline"></A>Japanese
Announcement</H2>
<P>The Japanese Language Project have launched a web-based message
board  for help regarding OpenOffice.org.  The system is also linked
to a mailing list providing further options for access.  More
information at the Japanese Language Project:
http://ja.openoffice.org/</P>
<P>Courtesy of Takaaki Higuchi (www.linux.or.jp,
www.freestandards.org, sun.co.jp)</P>
<H2 CLASS="western"><A NAME="9.5.ISO announcment|outline"></A>ISO
announcment</H2>
<P>There is a new OpenOffice.org ISO available for download.  The
main changes are to the MacOS X version, where both 1.0.3 and 1.1.0
versions are now included.  It can be found in the /contrib/iso/1.1.0
of any OOo download mirror.  Go to // to find
download sites.</P>
<P>Courtesy of Alex Fisher, co-lead CD-ROM project 
</P>
<H2 CLASS="western"><A NAME="9.6.Linux and OpenOffice.org at the City of Paris|outline"></A>
Linux and OpenOffice.org at the City of Paris</H2>
<P>According to the article below the system integrator Unilog got
the task to create a report for the government that eveluates the
usage of Linux and OpenOffice.org on the 17,000 PC's at the City of
Paris. The French government is envisaging to migrate 5-15% of all
PC's to open source technologies.</P>
<P><A HREF="http://www.clubic.com/n/n11557.html">http://www.clubic.com/n/n11557.html</A></P>
<H2 CLASS="western"><A NAME="9.7.Indian insurance company shifts 10,000 desktops to StarOffice|outline"></A>
Indian insurance company shifts 10,000 desktops to StarOffice</H2>
<P>&quot;India's second largest insurer, United India Insurance
Company, is moving 10,000 desktops to Sun Microsystems' office suite
StarOffice.</P>
<P>A media release from Sun quoted UIIC's IT assistant general
manager S.M. Victor John as saying the insurer had selected
StarOffice 7 software because it matched the company's technical
specifications and was competitively priced.&quot;</P>
<P>&quot;A Sun spokesperson said the 10,000 desktops being replaced
were running mostly Office 95. &quot;One of the reasons why UIIC
chose StarOffice is due to cost savings. StarOffice only costs
anywhere from $25-$60 for enterprises while Microsoft Office sells
their Office suite for hundreds of dollars,&quot; the spokesperson
said.</P>
<P>&quot;StarOffice's functionality and compatibility to Microsoft
Office was also a major factor in the decision as well as
multi-platform support - Linux, Solaris, Windows - for greater
flexibility and choice.&quot;</P>
<P><A HREF="http://www.smh.com.au/articles/2004/02/06/1075854037075.html">http://www.smh.com.au/articles/2004/02/06/1075854037075.html</A></P>
<P>Aust users back desktop Linux</P>
<P>&quot;A newly-conducted survey of Australian and New Zealand tech
users has lent weight to Linux' desktop prospects, with more than
three-quarters of respondents saying it will improve its strength in
the area.</P>
<P>The survey -- conducted by tech expert Graeme Philipson in
February -- found that almost two-thirds (61.3 percent) believed the
open-source operating system would get &quot;a little&quot; stronger
on the desktop, while 22.5 percent said it would get &quot;a lot&quot;
stronger. 
</P>
<P>[...]</P>
<P>Smith attributes the popularity of Linux in business use to the
management and security advantages a company has when using the
system, making it the main alternative to proprietary operating
systems.</P>
<P>&quot;On Linux a company or organisation has full control over
their IT&quot; said Smith, adding: &quot;There are practically no
Linux viruses to be worried about and any patches are developed
incredibly fast and available immediately&quot;. &quot;</P>
<P><A HREF="http://www.zdnet.com.au/news/software/0,2000061733,39116120,00.htm">http://www.zdnet.com.au/news/software/0,2000061733,39116120,00.htm</A></P>
<H2 CLASS="western"><A NAME="9.8.Apache Forrest Support for OpenOffice.org|outline"></A>
Apache Forrest Support for OpenOffice.org</H2>
<P>&quot;Forrest is an XML standards-oriented project documentation
framework based on Apache Cocoon, providing XSLT stylesheets and
schemas, images and other resources. Forrest uses these to render the
XML source content into a website via command-line, robot, or a
dynamic web application.&quot;</P>
<P><A HREF="http://xml.apache.org/forrest">http://xml.apache.org/forrest</A></P>
<P>&quot;Apache Forrest supports OpenOffice.org 1.1 Writer documents
as source documents. Generally every OpenOffice.org Writer document
can be used as source file but if you want support for all elements
the documentv12.dtd supports you have to use template names which are
supported during the transformation process.&quot;</P>
<P><A HREF="http://xml.apache.org/forrest/oowriter.html">http://xml.apache.org/forrest/oowriter.html</A></P>
<H2 CLASS="western"><A NAME="9.9.OpenOffice.org Flash Intro|outline"></A>
OpenOffice.org Flash Intro</H2>
<P>&quot;Finally got around to applying the [GNU Free Documentation
License (FDL)] to the OOo 1.1 Flash intro, so everyone who has Flash
MX 2004 can now make their own versions (translated, etc).</P>
<P>At some point we should create a nice description page, but we
haven't done that just yet.</P>
<P>The source Flash file for the OOo 1.1 Intro is here:</P>
<P><A HREF="http://www.digitaldistribution.com/community/goodwilltoallmankind/ooo11_intro_en_001.fla">http://www.digitaldistribution.com/community/goodwilltoallmankind/ooo11_intro_en_001.fla</A></P>
<P>A Flash intro generated from it is here:</P>
<P><A HREF="http://www.digitaldistribution.com/community/goodwilltoallmankind/ooointro11en.swf">http://www.digitaldistribution.com/community/goodwilltoallmankind/ooointro11en.swf</A></P>
<P>Those URLS should all be on one line, but may have wrapped due to
text 
</P>
<P>formatting.</P>
<P>Hope this helps the native lang teams especially.  Would someone
also be 
</P>
<P>ok to let them know about this, as I'm not on any of their mailing
</P>
<P>list(s) just yet? &quot; 
</P>
<P>(Source: <A HREF="mailto:marketing@openoffice.apache.org">marketing@openoffice.apache.org</A>)</P>
<H2 CLASS="western"><A NAME="9.10.20% for OpenOffice.org|outline"></A>
20% for OpenOffice.org</H2>
<P>&quot;However, an upstart open-source productivity suite also made
a strong showing this year among our readers. Twenty percent of our
readers proclaimed OpenOffice 1.1 as the top small business
productivity suite, which just goes to show that smaller companies
are also open to the idea of Linux on the desktop. Available for free
to Windows, Linux, and Mac users, all the open-source community asks
is that programmers pass along any improvements they make to the
source code. (Read our review.)&quot;</P>
<P><A HREF="http://www.smallbusinesscomputing.com/news/article.php/3300821">http://www.smallbusinesscomputing.com/news/article.php/3300821</A></P>
<H2 CLASS="western"><A NAME="9.11.StarOffice 7 review by PC Magazine|outline"></A>
StarOffice 7 review by PC Magazine</H2>
<P>&quot;Can Sun Microsystems' StarOffice 7 supplant Microsoft Office
on your desktop? With previous versions being slow and buggy, you'd
probably answer no. But the speed, power, and simplicity of the
latest version&mdash;combined with its minuscule price ($79.95
direct)&mdash;may change your mind. It's certainly worth a look for
budget-constrained government or enterprise buyers, as well as small
businesses and individual users who need to buy an office suite with
their own money. And attention education buyers: Sun will send you
the software for just the cost of the media and shipping.&quot;</P>
<P><A HREF="http://www.eweek.com/article2/0,4149,1440803,00.asp">http://www.eweek.com/article2/0,4149,1440803,00.asp</A></P>
<P>English Documenation for Perl/OODoc Module available</P>
<P>&quot;Perl/OODoc modules provide an object-oriented interface for
reading and editing of OpenOffice.org documents by Perl programs
without having to use OpenOffice.org or StarOfficeTM  directly.</P>
<P>Their objective is to offer programmers a concise and reasonably
high-level language, allowing the manipulation of document objects
without having to know the details of data representation used in
OpenOffice.org files or of XML programming interfaces.&quot;</P>
<P>http://www.genicorp.fr/devel/oodoc/</P>
<H2 CLASS="western"><A NAME="9.12.Opening Open Formats with XSLT|outline"></A>
Opening Open Formats with XSLT</H2>
<P>&quot;In Jon Udell's keynote speech at the conference, he
mentioned that the only Microsoft Office 2003 application that would
lack an XML output option was the mail program, but he forgot another
one, PowerPoint. I was looking forward to some sort of Save As XML
feature in PowerPoint so that I could create the kind of speaker
notes that I like from XML versions of PowerPoint presentations, and
it looks like I won't get this ability for a while, at least not
directly from Microsoft.</P>
<P>I decided to try it with OpenOffice, the free, open source,
multi-platform office application suite. Once I saw the XML that its
slide presentation program created, it took me less time to write a
stylesheet that did exactly what I wanted than it took to download
OpenOffice over the conference hotel's T1 line.&quot;</P>
<P><A HREF="http://www.xml.com/pub/a/2004/02/04/tr-xml.html">http://www.xml.com/pub/a/2004/02/04/tr-xml.html</A></P>
<H2 CLASS="western"><A NAME="9.13.Microsoft's Office XML lags on Mac|outline"></A>
Microsoft's Office XML lags on Mac</H2>
<P>&quot;Microsoft is readying a new version of Office for Macintosh
for release in the first half of 2004 &mdash; one which doesn&rsquo;t
support many of the much-touted XML features of its Windows cousin,
Office 2003.&quot;</P>
<P><A HREF="http://www.computerworld.co.nz/news.nsf/UNID/6E0DEE420F766E7ECC256E21007B9E28?OpenDocument">http://www.computerworld.co.nz/news.nsf/UNID/6E0DEE420F766E7ECC256E21007B9E28?OpenDocument</A></P>
<H2 CLASS="western"><A NAME="9.14.StarOffice 7 available for Solaris x86|outline"></A>
StarOffice 7 available for Solaris x86</H2>
<P>&quot;Sun Microsystems, Inc., (Nasdaq: SUNW - News) the creator
and leading advocate of Java(TM) technology, today announced that its
StarOffice(TM) 7 software, an open-source based, comprehensive,
multi-platform office productivity suite, is available immediately
for the growing enterprise-class Solaris(TM) Operating System (OS)
x86 Platform Edition. Customers seeking a proven, alternative desktop
solution can now benefit from the familiar UNIX&reg; environment and
the reliable, highly available, scalable and predictable Solaris OS
on their x86 systems.&quot;</P>
<P><A HREF="http://biz.yahoo.com/prnews/040204/sfw076_1.html">http://biz.yahoo.com/prnews/040204/sfw076_1.html</A></P>
<H2 CLASS="western"><A NAME="9.15.KDE integrates OpenOffice.org|outline"></A>
KDE integrates OpenOffice.org</H2>
<P>&quot;In this interview, Jan Holesovsky, author and leader of the
KDE.OpenOffice.org project, now employed by SUSE, gives us a glimpse
of what to expect in terms of OpenOffice.org integration on your KDE
desktop.&quot;</P>
<P><A HREF="http://dot.kde.org/1075705744/">http://dot.kde.org/1075705744/</A></P>
<H2 CLASS="western"><A NAME="9.16.Sun Lends Support to OpenOffice.org|outline"></A>
Sun Lends Support to OpenOffice.org</H2>
<P>&quot;Sun Microsystems now offers Sun Software Support services to
openoffice.org customers. According to Chris van Niekerk, regional
support manager, Sun Microsystems SA, this move enhances the
company's current support for the StarOffice productivity suite, and
provides customers with additional choice and opportunity to reduce
costs.&quot;</P>
<P><A HREF="http://www.pcworld.com/news/article/0,aid,114616,00.asp">http://www.pcworld.com/news/article/0,aid,114616,00.asp</A></P>
<P><A HREF="http://www.sun.com/service/support/software/openoffice/">http://www.sun.com/service/support/software/openoffice/</A></P>
<H2 CLASS="western"><A NAME="9.17.Star Can Save Millions; But Look Before You Leap|outline"></A>
Star Can Save Millions; But Look Before You Leap</H2>
<P>&quot;Speaking to CXOtoday, K.P. Unnikrishnan, country head &ndash;
marketing, Sun Microsystems India, said, &quot;For an enterprise,
with lets say 100 desktops, Star Office 7 would cost around Rs 4,680
per license, as against Rs 14,000 per license for Microsoft Office
2003.&quot;</P>
<P>In CIO lingo, this would translate into a budgetary saving of
approximately 65 %, as Sun&rsquo;s office suite costs roughly 1/3 rd
of its Microsoft counterpart. &quot;</P>
<P><A HREF="http://www.cxotoday.com/cxo/jsp/index.jsp?section=News&amp;subsection=Business&amp;subsection_code=1&amp;file=template1.jsp&amp;storyid=632">http://www.cxotoday.com/cxo/jsp/index.jsp?section=News&amp;subsection=Business&amp;subsection_code=1&amp;file=template1.jsp&amp;storyid=632</A></P>
<H1 CLASS="western"><A NAME="10.January 2004|outline"></A>January
2004</H1>
<H2 CLASS="western"><A NAME="10.1.Texan city runs 'nonemotional' Linux pilot|outline"></A>
Texan city runs 'nonemotional' Linux pilot</H2>
<P>&quot;For the Linux desktop, Austin technicians are &quot;just
trying to make it actually function in our world,&quot; Collins said,
but OpenOffice has made it further. It's running on about 30 Windows
computers, including Collins' own, and he plans to expand the test to
more sophisticated computer users soon.</P>
<P>&quot;I forgot I was using it... everything I need to do I can
do,&quot; Collins said, though he noted that he chiefly needs only
basic features.</P>
<P>Austin has about 6,000 Windows computers, 5,200 of which are
covered by a Microsoft enterprise software support agreement that
expires at the end of 2004, Collins said. That agreement cost more
than $3m.</P>
<P>It's likely that by using OpenOffice on his own department's
computers, he will be able to move about 100 Microsoft Office
licences to other computer users who need it without having to pay
extra, he said.&quot;</P>
<P><A HREF="http://news.zdnet.co.uk/software/linuxunix/0,39020390,39118725,00.htm">http://news.zdnet.co.uk/software/linuxunix/0,39020390,39118725,00.htm</A></P>
<H2 CLASS="western"><A NAME="10.2.Sun touts contract with Office Depot|outline"></A>
Sun touts contract with Office Depot</H2>
<P>&quot;Office Depot also will use a number of Sun services for
managing its information technology resources. The retailer has also
agreed to sells Sun's StarOffice productivity software in its
stores.&quot;</P>
<P><A HREF="http://news.com.com/2100-1010-5130899.html">http://news.com.com/2100-1010-5130899.html</A></P>
<H2 CLASS="western"><A NAME="10.3.Norwegian soon to become a native language project!|outline"></A>
Norwegian soon to become a native language project!</H2>
<P>The Norwegian translation project (www.openofficeorg.no) will soon
start the process of becoming a native language project.  With
impressive speed OpenOffice.org has been translated into the two
official Norwegian languages.</P>
<P>Version 1.1 is available for Windows, while the Linux version will
probably be completed early in March.</P>
<P>There is a rapidly growing interest in OpenOfficeorg.no. The
Windows versions of OpenOffice.org 1.0 and 1.1 have been downloaded
26 000 times so far. In February, one of Norway's largest county
councils will distribute OpenOffice.org to all their high school
students. Also, several textbooks and user manuals have been written.</P>
<P>The Ministry of Education and Research has donated NOK 300 000
(the equivalent of 2000 man-hours) for further translation of the
help functions. Israel snubs Microsoft, moves to open-source software</P>
<P>&quot;For its part, the Israeli government has also decided to
encourage the development of lower-priced alternatives to Microsoft
applications to encourage computer use across Israel, Cohen said. &quot;We
have worked with Sun and IBM on designing a Hebrew version of
OpenOffice software and distributing it as an alternative to Office.
It depends on the government office, but the government is now using
Office, Linux and the OpenOffice software.&quot;</P>
<P>OpenOffice is free, open-source office software that was
originally based on StarOffice from Sun Microsystems Inc.</P>
<P>The adoption of OpenOffice by the government has already raised
interest in the software among Israelis, including those who normally
aren't interested in technology, said Shoshannah Forbes, who works as
a software tester for OpenOffice.org, the organization that develops
the open-source program.</P>
<P>Microsoft software is very expensive in Israel, and interest in
OpenOffice is such that Forbes has been asked about it by complete
strangers in her local video store, she said. &quot;I was asked where
I worked, and when I said I worked for OpenOffice, everyone was
asking about it. It's been all over the press here.&quot; &quot;</P>
<P><A HREF="http://www.computerworld.com/governmenttopics/government/policy/story/0,10801,88800,00.html">http://www.computerworld.com/governmenttopics/government/policy/story/0,10801,88800,00.html</A></P>
<H2 CLASS="western"><A NAME="10.4.Kinko and OpenOffice.org|outline"></A>
Kinko and OpenOffice.org</H2>
<P>&quot;While I was helping out a friend with her Linux install she
related to me how OOo &quot;saved her bacon&quot; recently.</P>
<P>She had been working on a brochure for a local library that needed
to be printed in a number of different languages including chinese,
hindi, and arabic.  She had prepared the document in Word and took
the file to Kinko's (a copy shop) for printing.  They did not have
the fonts to print out the non-western characters.  She rushed back
to her house and opened up the document in OpenOffice.org 1.1.  With
some minor reformatting she saved the file as a PDF which she took
back to Kinko's.  They were able to complete the printing job from
the pdf.</P>
<P>I've asked her to write this up and submit it to OOo as a
testimonial. Where or whom should it go to?</P>
<P>PS - She likes OOo and uses Calc and the dbase function to help
run her business.  She uses Word only because she needed a good
thesaurus, which OOo lacks.  If the thesaurus was better she'd stop
using Word altogether.  If she didn't need to use Word she said she
wouldn't need to use Windows either.</P>
<P>PPS - For those who don't know, the term &quot;saving one's bacon&quot;
has nothing to do with hogs or pork products.&quot;</P>
<P>Source: OpenOffice.org mailing list marketing@openoffice.apache.org</P>
<H2 CLASS="western"><A NAME="10.5.Government open source deployments you don't hear about|outline"></A>
Government open source deployments you don't hear about</H2>
<P>&quot; I know of at least a dozen goverment open source
deployments I have been begged not to write about, not in the spy
movie, &quot;If I tell you I'll have to kill you!&quot; sense, but
because the people responsible for them worry that excess publicity
might kill their efforts to run their agencies' computers with the
most reliable and cost-effective software they can find.&quot;</P>
<P><A HREF="http://www.newsforge.com/trends/03/12/23/0056245.shtml?tid=136&amp;tid=137&amp;tid=2&amp;tid=82&amp;tid=94">http://www.newsforge.com/trends/03/12/23/0056245.shtml?tid=136&amp;tid=137&amp;tid=2&amp;tid=82&amp;tid=94</A></P>
<H2 CLASS="western"><A NAME="10.6.2003 LinuxQuestions.org Members Choice Award Winners Announced|outline"></A>
2003 LinuxQuestions.org Members Choice Award Winners Announced</H2>
<P>Office Suite of the Year    --  OpenOffice.org            (79.51%)</P>
<P>Word Processor of the Year  --  swriter (OpenOffice.org)  (66.86%)</P>
<P>Spreadsheet of the Year     --  scalc (OpenOffice.org)    (54.30%)</P>
<P><A HREF="http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=SVBIZINK6.story&amp;STORY=/www/story/01-12-2004/0002087216&amp;EDATE=MON+Jan+12+2004,+07:47+AM">http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=SVBIZINK6.story&amp;STORY=/www/story/01-12-2004/0002087216&amp;EDATE=MON+Jan+12+2004,+07:47+AM</A></P>
<H2 CLASS="western"><A NAME="10.7.OSNews 2003 Awards -- Our Favorites This Year|outline"></A>
OSNews 2003 Awards -- Our Favorites This Year</H2>
<P>&quot;Most profound application of the year: I am torn between
Photoshop CS and OpenOffice.org (while not as full featured as MS
Office or even Star Office, it is free and so that compensates.)&quot;</P>
<P><A HREF="http://www.osnews.com/story.php?news_id=5540">http://www.osnews.com/story.php?news_id=5540</A></P>
<H2 CLASS="western"><A NAME="10.8.2003 OSDir Editor's Choice Award|outline"></A>
2003 OSDir Editor's Choice Award</H2>
<P>OpenOffice.org was awarded the Editor's Choice Award for Best of
Mac &amp; Windows, and Best overall Desktop App</P>
<P><A HREF="http://osdir.com/Article198.phtml">http://osdir.com/Article198.phtml</A></P>
<H2 CLASS="western"><A NAME="10.9.Product of the Year 2003|outline"></A>
Product of the Year 2003</H2>
<P>The swiss magazine Infoweek.ch chooses OpenOffice.org 1.1 as the
product of the year 2003 in the category &quot;Office Software&quot;.</P>
<P><A HREF="http://www.apple.com/chde/hotnews/pdf/infoweek03.pdf">http://www.apple.com/chde/hotnews/pdf/infoweek03.pdf</A></P>
<H1 CLASS="western"><A NAME="11.December 2003|outline"></A>December
2003</H1>
<H2 CLASS="western"><A NAME="11.1.OpenOffice.org got a new &quot;face&quot;|outline"></A>
OpenOffice.org got a new &quot;face&quot;</H2>
<P>The OpenOffice.org website has changed its look and is now easier
to use and navigate.  We would like to thank the volunteer website
team for their work, in particular, Project Co-Lead Kay Schenk and
chief designer Cristian Driga; and, in no particular order, Ed Buck,
John McCreesh, Akshay Dayal, G. Roderick Singleton, Jacqueline
McNally, and Louis Suarez-Potts. If things are bad, join the website
project and help fix it. ;-) 
</P>
<H2 CLASS="western"><A NAME="11.2.Russian Native-Lang Project Announced|outline"></A>
Russian Native-Lang Project Announced</H2>
<P>&quot;The Native-Lang family has the pleasure to welcome its
latest newcomer, the Russian Native-Lang Project. Led by Anatoly A.
Yakushin and Rail Aliev, this project was also created by the people
of AltLinux in Russia. The Russian Project is very important to OOo
not only because of its symbolic meaning but also because of the
number of Russian speaking people worldwide who already use
OpenOffice.org or are potential users of the suite.&quot;</P>
<H2 CLASS="western"><A NAME="11.3.Sun Microsystems launches enterprise support for OpenOffice.org|outline"></A>
Sun Microsystems launches enterprise support for OpenOffice.org</H2>
<P>&quot;Sun Microsystems, Inc. (Nasdaq: SUNW), founder and primary
sponsor of the open-source project OpenOffice.org, today announced 
it will offer Sun(SM) Software Support services to OpenOffice.org
customers. Ranked as a leading provider of online support services by
Summit Strategies, Inc., Boston, Mass., Sun Services delivers proven
solutions with presence in more than 126 countries. This move
enhances Sun's current support for the StarOffice(TM) productivity
suite, provides customers additional choice and opportunity to reduce
costs, and underscores Sun's deep commitment to open-source and
standards-based software.&quot;</P>
<P><A HREF="http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=SVBIZINK6.story&amp;STORY=/www/story/12-03-2003/0002068366&amp;EDATE=WED+Dec+03+2003,+02:38+AM">http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=SVBIZINK6.story&amp;STORY=/www/story/12-03-2003/0002068366&amp;EDATE=WED+Dec+03+2003,+02:38+AM</A></P>
<H2 CLASS="western"><A NAME="11.4.Scripting Framework is Available|outline"></A>
Scripting Framework is Available</H2>
<P>&quot;The Scripting Framework is available for evaluation from the
latest OpenOffice.org Developer build at</P>
<P><A HREF="//dev_docs/source/680">//dev_docs/source/680</A></P>
<P>The main highlights are</P>
<UL>
	<LI><P>Scripting Framework available in build ( no need for separate
	install )</P>
</UL>
<UL>
	<LI><P>Support for JavaScript, Beanshell,Java, OpenOffice.org BASIC</P>
</UL>
<UL>
	<LI><P>Sample scripts in for supported languages.</P>
</UL>
<UL>
	<LI><P>Ability to assign macros/scripts written in these languages
	from Tools/Config dialogs.</P>
</UL>
<UL>
	<LI><P>Ability to assign events to the scripts/macros written in
	above languages from dialogs, forms, hyperlinks, objects graphics
	etc ( ala existing functionality from Office Basic ).&quot;</P>
</UL>
<P><A HREF="//servlets/ReadMsg?list=announce&amp;msgNo=190">//servlets/ReadMsg?list=announce&amp;msgNo=190</A></P>
<H2 CLASS="western"><A NAME="11.5.AOL ships PCs with OpenOffice.org based office suite|outline"></A>
AOL ships PCs with OpenOffice.org based office suite</H2>
<P>&quot;The AOL PC comes with Microsoft Windows XP Home, but the
first screen users see is an AOL-designed interface called the AOL
Desktop. The PC also comes with an office productivity software
package called AOL Office Powered by Sun, which is the StarOffice
software suite developed by Sun Microsystems.&quot;</P>
<P><A HREF="http://www.pcworld.com/news/article/0,aid,113771,00.asp">http://www.pcworld.com/news/article/0,aid,113771,00.asp</A></P>
<H2 CLASS="western"><A NAME="11.6.OpenOffice.org reduces the invoice of the police officers|outline"></A>
OpenOffice.org reduces the invoice of the police officers</H2>
<P>The Ministry of the Interior gathers approximately 100000 working
stations dispersed on all the territory and in very diverse
structures from police stations to prefectures.</P>
<P>It is into 2000 that the Ministry began an evaluation of the
software. Its absence of licence and especially its exemption from
payment revealed it like a true opportunity for a deployment on a
large scale.</P>
<P>In 2002, 15000 stations were deployed, primarily in the police
stations. The suite is available on Cds and also in free remote
loading on the Intranet. Christophe Cazin, engineer with the mission
strategy and systems of control, announce besides that the remote
loadings do not stop!</P>
<P>The technical support is ensured by internal forums, an Intranet,
the OpenOffice.org site and its mailings lists. Christophe Cazin
considers a deployment on 30000 stations within one year.</P>
<P>French Article: <A HREF="http://www.01net.com/article/222242.html">http://www.01net.com/article/222242.html</A></P>
<H2 CLASS="western"><A NAME="11.7.Retirement Pension Tool for Excel AND OpenOffice.org|outline"></A>
Retirement Pension Tool for Excel AND OpenOffice.org</H2>
<P>&quot;... About a month ago, a council worker asked for some help
on our mailing list about an online tool to calculate retirement
pension. This tool is distributed by our Ministry of civil services
only on excel format and he needs it in OOo file format because he
has migrated on OOo. Half an hour later, the community has helped him
to convert the tool.</P>
<P>[...]</P>
<P>This thread has been reported to ADAE (Agency in charge with
electronic usage in ministry)(thanks to Christophe Cazin but hush!)
and a month later :</P>
<P><A HREF="http://www.fonction-publique.retraites.gouv.fr/retraites/Public/simulateur_de_calcul/10560356143521">http://www.fonction-publique.retraites.gouv.fr/retraites/Public/simulateur_de_calcul/10560356143521</A></P>
<P>the tool is proposed in OOo file format and a link to download OOo
....&quot; 
</P>
<P><BR><BR>
</P>
<P>[Source: Sophie Gautier]</P>
<H2 CLASS="western"><A NAME="11.8.UK&rsquo;s Office of Government Commerce evaluating Sun Java Desktop System|outline"></A>
UK&rsquo;s Office of Government Commerce evaluating Sun Java Desktop
System</H2>
<P>&quot;The five-year purchasing deal with the UK&rsquo;s Office of
Government Commerce will begin with compatibility trials for Java
Desktop which, if successful, would mean up to 500,000 UK civil
servants gradually being shifted away from Windows software to Sun&rsquo;s
low-cost open-source alternative.&quot;</P>
<P><A HREF="http://www.business.scotsman.com/index.cfm?id=1341432003">http://www.business.scotsman.com/index.cfm?id=1341432003</A></P>
<H2 CLASS="western"><A NAME="11.9.More money for patients through OpenOffice.org and Linux|outline"></A>
More money for patients through OpenOffice.org and Linux</H2>
<P>&quot;NHS director general of IT Richard Granger, said in a
statement: &quot;Our evaluation of the Java Desktop System holds the
promise of allowing a greater share of NHS funding to flow directly
towards improved levels of Patient Service. If this solution were to
prove effective we could save the NHS and the Taxpayer many millions
of pounds whilst at the same time using rich and innovative software
technology.&quot;&quot;</P>
<P><A HREF="http://news.zdnet.co.uk/business/0,39020645,39118351,00.htm">http://news.zdnet.co.uk/business/0,39020645,39118351,00.htm</A></P>
<H2 CLASS="western"><A NAME="11.10.Schoolweb Targets 40 Institutions|outline"></A>
Schoolweb Targets 40 Institutions</H2>
<P>&quot;The project is a collaborative effort by Uconnect, the
Ministry of Education and Sports, MTN and One2Net, and international
partners Hewlett Packard, Advanced Interactive and Sun Microsystems.
Advanced Interactive of Canada designed the SchoolWeb system for
Canadian schools and modified it for Uganda.</P>
<P>[...]</P>
<P>Once installed and running, SchoolWeb becomes a fast and
interactive learning resource centre. The SchoolWeb server comes
with:</P>
<P>Open source software OpenOffice, programmes for website design,
graphics, video streaming, a dictionary and database programmes.&quot;</P>
<P><A HREF="http://allafrica.com/stories/200312030247.html">http://allafrica.com/stories/200312030247.html</A></P>
<H2 CLASS="western"><A NAME="11.11.New Linux distribution &quot;Impi&quot; including OpenOffice.org|outline"></A>
New Linux distribution &quot;Impi&quot; including OpenOffice.org</H2>
<P>&quot;&quot;Most developers in the &quot;first world&quot;
countries have no idea of the conditions on our continent. Waiting
around for a foreign developer or company to give us something that
we need, merely echoes the legacy of colonialism. We need to dispose
of that mindset,&quot; said Ross Addis in an e-mail interview.</P>
<P>[...]</P>
<P>Another unique feature of Impi Linux is that it will eventually
have translations of South Africa's 11 official languages. But
Ugandans and other Africans should not lose hope. Impi Linux is about
choice. Get a free download from www.impi.org.za and modify it to
suit you. So, is there hope for a version in Luganda or Swahili? &quot;Of
course. We will also be looking at adding the various African
languages,&quot; he said.&quot;</P>
<P><A HREF="http://mathaba.net/x.htm?http://mathaba.net/0_index.shtml?x=29276">http://mathaba.net/x.htm?http://mathaba.net/0_index.shtml?x=29276</A></P>
<H2 CLASS="western"><A NAME="11.12.Israeli employment agency switches to OpenOffice.org|outline"></A>
Israeli employment agency switches to OpenOffice.org</H2>
<P>&quot;First out of the door is the Israeli employment agency,
which will replace 550 out of 700 users with OpenOffice. The contract
represents a hardware win for IBM. Some 150 staff will stay on
Microsoft Office. For now, all the switchers will remain on Windows,
running the Win32 version of the software libre equivalent of
Microsoft Office.&quot;</P>
<P><A HREF="http://www.theregister.co.uk/content/4/34154.html">http://www.theregister.co.uk/content/4/34154.html</A></P>
<H2 CLASS="western"><A NAME="11.13.Sun lands 500,000 desktop Linux deal|outline"></A>
Sun lands 500,000 desktop Linux deal</H2>
<P>&quot;Signed in conjunction with the newly established China
Standard Software Company, a consortium of Chinese
government-supported firms, the deal could eventually stretch to 500
million desktops, which McNealy said was the Chinese government's
aim.</P>
<P>[...]</P>
<P>McNealy said Sun would be pushing to win more governments over to
its StarOffice range. &quot;We're calling on every IT ministry on the
planet. Stay tuned,&quot; he added.&quot;</P>
<P><A HREF="http://www.vnunet.com/News/1149212">http://www.vnunet.com/News/1149212</A></P>
<P><A HREF="http://www.idg.com.hk/cw/readstory.asp?aid=20031119007">http://www.idg.com.hk/cw/readstory.asp?aid=20031119007</A></P>
<H2 CLASS="western"><A NAME="11.14.Government plans to distribute computers to 5,000 schools nationwide|outline"></A>
Government plans to distribute computers to 5,000 schools nationwide</H2>
<P>&quot;We are trying step by step to eliminate Microsoft,&quot;
said Nguyen Trung Quynh of Vietnam's Ministry of Science and
Technology. Quynh and other government tech officials want Vietnam to
be on the cutting edge of an international movement to embrace
open-source software -- products that can be downloaded from the
Internet for free and perform the same tasks as Microsoft (Nasdaq:
MSFT)  Windows  or Office.</P>
<P>[...]</P>
<P>&quot;We can't totally sweep out Microsoft,&quot; Quynh said. &quot;But
we hope that new users will start using open source.&quot;</P>
<P>Before Vietnamese versions of OpenOffice and Linux were developed,
open source was just an abstraction here, said Carrasco-Munoz. &quot;Now
you dump this CD on your computer, you install it, you reboot.
Bye-bye Microsoft!&quot; 
</P>
<P><A HREF="http://www.linuxinsider.com/perl/story/32330.html">http://www.linuxinsider.com/perl/story/32330.html</A></P>
<H2 CLASS="western"><A NAME="11.15.Microsoft Loses to Linux in Thailand Struggle|outline"></A>
Microsoft Loses to Linux in Thailand Struggle</H2>
<P>&quot;In the second quarter of 2003, just 40 percent of all
desktop PCs shipped in Thailand had a licensed copy of Windows
installed, an all-time low that likely will dip even further.</P>
<P>[...]</P>
<P>While some buyers still will install pirated copies of Microsoft's
software, Gartner estimates that 70 percent of Thai consumers will
stick with Linux, citing freely available software, lower prices and
lack of knowledge among first-time PC owners.&quot;</P>
<P><A HREF="http://www.ecommercetimes.com/perl/story/32110.html">http://www.ecommercetimes.com/perl/story/32110.html</A></P>
<H2 CLASS="western"><A NAME="11.16.Sewing machine giant Janome adopts OpenOffice.org|outline"></A>
Sewing machine giant Janome adopts OpenOffice.org</H2>
<P>&quot;Janome has migrated some of its PCs away from Microsoft
Office in favour of the free OpenOffice.org office suite saving the
company around $8000 in licence fees, according to IT administrator
Scott Langford.</P>
<P>After hearing about OpenOffice.org from a colleague, Langford
downloaded version 1.0.2 of the office suite and installed it on 10
of the 30 PCs running Microsoft Windows.</P>
<P>[...]</P>
<P>Although Janome&rsquo;s Australian operations are small, it has
some 60 per cent of the domestic sewing machine market.
Internationally, the company has offices in eight countries and more
than 3000 employees.&quot;</P>
<P><A HREF="http://www.computerworld.com.au/index.php?id=281553222&amp;fp=16&amp;fpid=0">http://www.computerworld.com.au/index.php?id=281553222&amp;fp=16&amp;fpid=0</A></P>
<H2 CLASS="western"><A NAME="11.17.Victorian government evaluates OpenOffice.org and StarOffice|outline"></A>
Victorian government evaluates OpenOffice.org and StarOffice</H2>
<P>Victorian Government spokeswoman Michelle Crawley says the state
will &quot;investigate interesting alternatives to Microsoft Office&quot;
such as OpenOffice and Sun Microsystems' close cousin, StarOffice.</P>
<P><A HREF="http://www.smh.com.au/articles/2003/11/24/1069522526315.html">http://www.smh.com.au/articles/2003/11/24/1069522526315.html</A></P>
<H2 CLASS="western"><A NAME="11.18.Study: Save up to 25% with open source technologies|outline"></A>
Study: Save up to 25% with open source technologies</H2>
<P>According to the German study by Soreon mentioned in the article
below, companies can save up to 25% from a TCO perspective if they
use open source alternatives.</P>
<P>The Sun Java Desktop System (SJDS) is the winner for larger
enterprises, closely followed by non-integrated OpenOffice.org
solutions. For medium businesses SJDS and OpenOffice.org both can
save about 14% compared to Microsoft technologies. For small
businesses it does not really matter, because costs for support and
training are higher than the licensing costs.</P>
<P><A HREF="http://de.internet.com/?id=2025258&amp;section=Marketing-Statistics">http://de.internet.com/?id=2025258&amp;section=Marketing-Statistics</A></P>
<P><A HREF="http://www.soreon.de/images/titelgrafik_office_software_gross.gif">http://www.soreon.de/images/titelgrafik_office_software_gross.gif</A></P>
<H1 CLASS="western"><A NAME="12.November 2003|outline"></A>November
2003</H1>
<H2 CLASS="western"><A NAME="12.1.API@OOo Newsletter|outline"></A>API@OOo
Newsletter</H2>
<P>&quot;This month the OOo API project started publishing a monthly
newsletter which is posted at the 1st of each month to summarize
issues from the previous month.&quot;</P>
<P STYLE="margin-bottom: 0mm"><A HREF="//servlets/ReadMsg?msgId=865951&amp;listName=announce">//servlets/ReadMsg?msgId=865951&amp;listName=announce</A></P>
<H2 CLASS="western"><A NAME="12.2.Sun Java Desktop System ISV/Developer Early Adopter Program|outline"></A>
Sun Java Desktop System ISV/Developer Early Adopter Program</H2>
<P>ISVs and developers interested in the Sun Java Desktop System
should register for the Early Adopter Program at
sun.com/partners/javadesktopsystem. 
</P>
<H2 CLASS="western"><A NAME="12.3.OpenOffice.org Market Share Analysis|outline"></A>
OpenOffice.org Market Share Analysis</H2>
<P>&quot;The document includes some data from past OpenOffice.org
newsletters and press articles.</P>
<P>If your company is using OpenOffice.org, even if it is a small
company, let me/us know! We can include just the number of seats +
the industry type, or even mention the name, if we get your
permission to do so! The same is true for schools and universities
that have deployed OpenOffice.org, StarOffice or another OOo
derivative.&quot;</P>
<P><A HREF="http://marketing.openoffice.org/servlets/ReadMsg?msgId=894269&amp;listName=dev">http://marketing.openoffice.org/servlets/ReadMsg?msgId=894269&amp;listName=dev</A></P>
<P><A HREF="//issues/show_bug.cgi?id=21674">//issues/show_bug.cgi?id=21674</A></P>
<H2 CLASS="western"><A NAME="12.4.Denmark urges government support for open source|outline"></A>
Denmark urges government support for open source</H2>
<P>&quot;However, the report recognised that establishing a existing
alternative or a new format would be an uphill battle, given that
Microsoft Office cannot read OpenOffice documents or other formats.
The Board recommended that Denmark begin a series of trials to test
the feasibility of introducing open-source software such as
OpenOffice.&quot;</P>
<P><A HREF="http://news.zdnet.co.uk/software/linuxunix/0,39020390,39117341,00.htm">http://news.zdnet.co.uk/software/linuxunix/0,39020390,39117341,00.htm</A></P>
<H2 CLASS="western"><A NAME="12.5.International Forwarding Agent Heinz Huber|outline"></A>
International Forwarding Agent Heinz Huber</H2>
<P>According to the German article below the international forwarding
agent Heinz Huber deployed StarOffice although the logistics company
has to exchange documents with about 60 partners.</P>
<P><A HREF="http://www01.silicon.de/cpo/csh-ts/detail.php?nr=11566&amp;directory=csh-ts">http://www01.silicon.de/cpo/csh-ts/detail.php?nr=11566&amp;directory=csh-ts</A></P>
<H2 CLASS="western"><A NAME="12.6.Midsize German firms say ja to Linux|outline"></A>
Midsize German firms say ja to Linux</H2>
<P>&quot;The potentially lower cost of deploying and maintaining
open-source software like Linux and OpenOffice &quot;is clearly what
prompted us to seek an alternative to Microsoft,&quot; Kloppsteck
said. &quot;And I know many other small and medium-size companies in
Germany are dropping Microsoft for the same reason.&quot;&quot;</P>
<P><A HREF="http://www.computerworld.com/softwaretopics/os/linux/story/0,10801,86636,00.html">http://www.computerworld.com/softwaretopics/os/linux/story/0,10801,86636,00.html</A></P>
<H2 CLASS="western"><A NAME="12.7.OpenOffice.org 1.1 at Italian Schools|outline"></A>
OpenOffice.org 1.1 at Italian Schools</H2>
<P>Within the frame of the ' Linux Day 2003 ' event, DIDASCA - The
First Italian Cyber School for Lifelong Learning - will deliver for
free 12,000 copies of the CDROMs containing the OpenOffice.org 1.1
suite to as many Italian schools.</P>
<P><A HREF="http://www.progettoemily.it/LinuxDay.htm">http://www.progettoemily.it/LinuxDay.htm</A></P>
<H2 CLASS="western"><A NAME="12.8.Israel slams the door on Microsoft|outline"></A>
Israel slams the door on Microsoft</H2>
<P>&quot;The de facto suspension means no upgrades for the duration,
at a time when Microsoft is looking to roll out its Office 2003
upgrade; and the Ministry is said to be examining OpenOffice as an
alternative.&quot;</P>
<P><A HREF="http://www.theregister.co.uk/content/4/33365.html">http://www.theregister.co.uk/content/4/33365.html</A></P>
<H2 CLASS="western"><A NAME="12.9.Life Insurance Corporation wants to switch to OpenOffice.org|outline"></A>
Life Insurance Corporation wants to switch to OpenOffice.org</H2>
<P>According to a German article an Indian insurance company is
switching, too. Life Insurance Corporation of India will switch to
Linux and OpenOffice.org.</P>
<P>The German article can be found at</P>
<P><A HREF="http://www.heise.de/newsticker/data/anw-23.10.03-007/">http://www.heise.de/newsticker/data/anw-23.10.03-007/</A></P>
<P>This seems to be related to the following older article</P>
<P><A HREF="http://www.cmpnetasia.com/ViewArt.cfm?Artid=20998&amp;Catid=8&amp;subcat=79">http://www.cmpnetasia.com/ViewArt.cfm?Artid=20998&amp;Catid=8&amp;subcat=79</A></P>
<H2 CLASS="western"><A NAME="12.10.Vietnam embracing open-source products|outline"></A>
Vietnam embracing open-source products</H2>
<P>&quot;The main open-source tools are Linux -- a free alternative
to the Windows operating system -- and OpenOffice, a free alternative
to Microsoft Office, with word processing and spreadsheet programs.
Two Vietnamese companies have recently developed Vietnamese versions
of both, and the country's two biggest computer assemblers are
already loading open source onto all their new machines.</P>
<P>``We can't totally sweep out Microsoft,'' Quynh said. ``But we
hope that new users will start using open source.''</P>
<P>Before Vietnamese versions of OpenOffice and Linux were developed,
open source was just an abstraction here, said Carrasco-Munoz. ``Now
you dump this CD on your computer, you install it, you reboot.
Bye-bye Microsoft!''&quot;</P>
<P><A HREF="http://www.siliconvalley.com/mld/siliconvalley/7139304.htm">http://www.siliconvalley.com/mld/siliconvalley/7139304.htm</A></P>
<H2 CLASS="western"><A NAME="12.11.Australia's history archived in OpenOffice.org|outline"></A>
Australia's history archived in OpenOffice.org</H2>
<P>&quot;Australia's history will be viewed digitally in the
OpenOffice.org office suite as part of plans to preserve the quality
and accessibility of government documents.</P>
<P>[...]</P>
<P>&quot;Open source is really, really important to us because over
time it means we can retain data presentation,&quot; said Davis.</P>
<P>&quot;Cross platform development is really important, because we
can't say you must have a Windows machine to access this file [in the
archives]. Who knows what platform most people will be using in 30
years time? So if you have a Linux machine, for example, you should
have equal access.&quot;&quot;</P>
<P><A HREF="http://www.linuxworld.com.au/index.php?id=1991153367&amp;fp=2&amp;fpid=1">http://www.linuxworld.com.au/index.php?id=1991153367&amp;fp=2&amp;fpid=1</A></P>
<H2 CLASS="western"><A NAME="12.12.Sun shines on NSW government desktops|outline"></A>
Sun shines on NSW government desktops</H2>
<P>&quot;According to Sun, six NSW government departments are already
in the early phases of testing or deploying the software. The
departments range in size from 200 up to a &quot;few thousand&quot;
staff representing an estimated 30,000 seats, said May.</P>
<P>[...]</P>
<P>Sun's alternative office productivity suite StarOffice -- based
heavily on its less-tamed open source cousin OpenOffice -- is a
central component in Sun's desktop operating system Java Desktop
Suite.&quot;</P>
<P><A HREF="http://www.zdnet.com.au/newstech/os/story/0,2000048630,20280236,00.htm">http://www.zdnet.com.au/newstech/os/story/0,2000048630,20280236,00.htm</A></P>
<P><BR><BR>
</P>
<H2 CLASS="western"><A NAME="12.13.The IDA Open Source Migration Guidelines|outline"></A>
The IDA Open Source Migration Guidelines</H2>
<P>&quot;The IDA Open Source Migration Guidelines provide practical
and detailed recommendations on how to migrate to Open Source
Software (OSS)-based office applications, calendaring, e-mail and
other standard applications. They have been developed with guidance
from public sector IT experts from Denmark, Finland, Italy, Germany,
Malta, the Netherlands, Spain, Sweden, and Turkey. The relevance and
readability of the Migration Guidelines were validated with the help
of the regional authorities of Mecklenburg-Vorpommern, Germany.</P>
<P>These guidelines have been designed to help public administrators
decide whether a migration to OSS should be undertaken and describe,
in broad technical terms, how such a migration could be carried out.
They are based on practical experience of a limited number of
publicly available case studies, and cover a wide range of management
and technical concerns.&quot;</P>
<P><A HREF="http://www.europa.eu.int/ISPO/ida/jsps/index.jsp?fuseAction=showDocument&amp;parent=news&amp;documentID=1647">http://www.europa.eu.int/ISPO/ida/jsps/index.jsp?fuseAction=showDocument&amp;parent=news&amp;documentID=1647</A></P>
<P>Download the IDA Open Source Migration Guidelines</P>
<P><A HREF="http://www.europa.eu.int/ISPO/ida/export/files/en/1603.pdf">http://www.europa.eu.int/ISPO/ida/export/files/en/1603.pdf</A></P>
<P>Download the Comparative Spreadsheet</P>
<P><A HREF="http://www.europa.eu.int/ISPO/ida/export/files/en/1604.xls">http://www.europa.eu.int/ISPO/ida/export/files/en/1604.xls</A></P>
<H2 CLASS="western"><A NAME="12.14.Migration Guide by the German Federal Ministry of the Interior|outline"></A>
Migration Guide by the German Federal Ministry of the Interior</H2>
<P>A week ago the European Commission released its Migration
Guidelines. Now a Migration Guide has just been released in English
by the German Federal Ministry of the Interior. The Guide was
originally published in German in July 2003 but is now also available
is English.</P>
<P>The report is a very valuable tool for anybody planning to migrate
from  a Microsoft world to the open world of Open Source and Open
Standards incl. OpenOffice.org and StarOffice.</P>
<P>These reports are clear signs of the very strong movement all over
Europe toward a new desktop. Use this new report in your efforts to
promote open source technologies!</P>
<P>The full report ( pdf, 414 pages!) is available in English here:</P>
<P><A HREF="http://www.kbst.bund.de/Anlage303777/pdf_datei.pdf">http://www.kbst.bund.de/Anlage303777/pdf_datei.pdf</A></P>
<H2 CLASS="western"><A NAME="12.15.OpenOffice.org XML Essentials|outline"></A>
OpenOffice.org XML Essentials</H2>
<P>J. David Eisenberg is currently writing a new book about the
OpenOffice.org XML file format. A draft of the book is accessible via
the link provided below.</P>
<P><A HREF="http://books.evc-cit.info/">http://books.evc-cit.info/</A></P>
<H2 CLASS="western"><A NAME="12.16.XML Interoperability Test|outline"></A>
XML Interoperability Test</H2>
<P>&quot;Interoperability Test and XML Evaluation of StarOffice
Writer 6.0 and Office Word 2003 Beta 2&quot;</P>
<P><A HREF="http://www.statskontoret.se/pdf/2003116.pdf">http://www.statskontoret.se/pdf/2003116.pdf</A></P>
<P><A HREF="http://www.statskontoret.se/english/index.htm">http://www.statskontoret.se/english/index.htm</A></P>
<H2 CLASS="western"><A NAME="12.17.Office 2003/StarOffice Migration Survey - Germany|outline"></A>
Office 2003/StarOffice Migration Survey - Germany</H2>
<P>The popular weekly German computer magazine Computerwoche
conducted an online survey in October 2003. Everybody was able to
participate  and thus the data does not necessarily reflect the
reality, but it's still interesting.</P>
<P>The question they asked were:</P>
<P>&quot;Is your company planning to switch to Office 2003/Office
System in the foreseeable future?&quot; 
</P>
<P>[&quot; Wird Ihr Unternehmen in absehbarer Zeit auf Office 2003/
Office System migrieren?&quot;]</P>
<P>We will switch to StarOffice/OOo              55.0 %    552</P>
<P>Yes, we will switch from version 95/97         2.3 %     23</P>
<P>Yes, we will switch from version 2000/XP      11.7 %    117</P>
<P>No                                            31.0 %    311</P>
<P>                                              -------------</P>
<P>                                              Total    1003</P>
<P><A HREF="http://www.computerwoche.de/umfrage/ergebnisse.cfm?umfrageid=115">http://www.computerwoche.de/umfrage/ergebnisse.cfm?umfrageid=115</A></P>
<H2 CLASS="western"><A NAME="12.18.Office 2003/StarOffice Migration Survey &ndash; Switzerland|outline"></A>
Office 2003/StarOffice Migration Survey &ndash; Switzerland</H2>
<P>The following data is from a survey on as swiss web page:</P>
<P>Will you update to Office 2003 or StarOffice 7?</P>
<P>Yes, planning update to Office 2003             17 %</P>
<P>Yes, planning update to StarOffice 7            16 %</P>
<P>Waiting for first Office 2003 experiences        9 %</P>
<P>Waiting for first StarOffice 7 experiences      10 %</P>
<P>No update plans                                 45 %</P>
<P>Don't know                                       3 %</P>
<P>So far (November 4, 2003) 344 people have participated in the
quick poll. 
</P>
<P><A HREF="http://www.infoweek.ch/Tools/QuickPoll/qp_result.cfm?QuestionID=155">http://www.infoweek.ch/Tools/QuickPoll/qp_result.cfm?QuestionID=155</A></P>
</body>
</HTML>
