<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <title>Refreshed Brand</title>
</head>

<body>

<h1>A Brand Refresh for OpenOffice.org</h1>
<br>

<p>During the last 10 years OpenOffice.org&trade; has evolved to a quite large project in the FLOSS world and a successful product in the office productivity
suite market. Together with our product the OpenOffice.org brand spread over the world. This brand has a tradition of quality and it remains faithful to
its origins. Instead of a complete new design we started a refresh. It points out the key components and improves the overall impression to gain even more
strength and confidence.</p>

<h2>Revised Logo</h2>

<p style="margin-bottom: 0cm;">The OpenOffice.org Logo and the seagulls are well recognized - even if not applied consistently today. Therefore it is more
than reasonable to retain the text string, the color code blue/black and the seagulls. They express the openness, freedom and collaboration we experience.
A new blue - friendly and modern – is used. The new tint reminds of a blue sky in a sunny day and with the seagulls also being blue and flying, the
sensation of freedom and openness is reinforced.</p>
<img style="width: 300px; height: 150px;" alt="refreshed logo" src="logo_color.png" align="middle">
<br><small><small><small>Copyright &copy; 2010, Oracle and/or its affiliates. All rights reserved.</small></small></small>

<h2>New Symbol</h2>

<p style="margin-bottom: 0cm;">The seagulls are established as a main visual element. They are not only part of the logo but also construct a standalone
symbol. They stand for the freedom of OpenOffice.org, as they are freely flying birds. There are two of them, which reinforces the value of collaboration
and openness. The lighter blue emphasizes this idea even more. The slight changes in their shape and position make them more scalable and rounder.</p>
<img style="width: 100px; height: 100px;" alt="new symbol" src="symbol_color.png" hspace="20" vspace="15">
<br><small><small><small>Copyright &copy; 2010, Oracle and/or its affiliates. All rights reserved.</small></small></small>

<p>The above shown 2D symbol is the unaltered stable form. It can be the basis for derived versions that reflect the style of a certain environment or
seasonal fashion trends.</p>

<p><img style="width: 135px; height: 132px;" alt="3d symbol" src="symbol_3d_smp.png" hspace="10"></p>
<!--  
<h2>Status (February 2010)</h2>

<p>With these branding elements the groundwork is established to strengthen the brand of OpenOffice.org. The elements are going to be introduced in the next
OpenOffice.org Community Council meeting. There is a wide range of succeeding necessary and complementary activities. The
<a href="http://marketing.openoffice.org/brand/">Branding Initiative</a> - as part of the marketing project - will be the home for the work enabling the
diverse community and our supporters to use a consistent design. Sun/Oracle will furnish the initial adoption in areas of the product like splash screen,
about box, application icons, odf icons, start center, ... with the next release of OpenOffice.org. This is in line with the
<a href="//servlets/ReadMsg?list=discuss&amp;msgNo=65559">earlier notification</a> that changes to site/product elements are
necessary due to the acquisition of Sun Microsystems by Oracle. With the establishment of a repository of branding elements in the required formats, usage
guidelines, how-tos by the Branding Initiative we will have the toolbox to reach an even broader audience with a refreshed brand. Besides the png images
shown above the elements are available in svg format. You will want to wait with your utilization until the guide can help with the proper application of
the material. You can even join the creation effort by subscribing to the list
<a href="http://marketing.openoffice.org/servlets/SummarizeList?listName=branding">branding@marketing.openoffice.org</a></p>
-->

<h2>Status (May 2010)</h2>

<p>After the introduction of the refreshed logo, new brand elements based on the refreshed logo were integrated in the OpenOffice.org graphical user
interface. For more detailed information please visit <a href="http://ui.openoffice.org/VisualDesign/OOo3_refresh.html">Visual Design Refresh</a></p>

<p>The efforts for a consistent OpenOffice.org branding led to the creation of the
<a href="http://wiki.services.openoffice.org/wiki/Branding_Initiative">Branding Initiative</a>. The main aim of this initiative is to consolidate a
consistent branding that expresses the spirit of OpenOffice.org. For concrete tasks, like the creation of specific GUI elements stakeholders of various
projects collaborate in I-Teams. For more information on the I-Teams visit the
<a href="http://wiki.services.openoffice.org/wiki/Application_Rebranding_-_Project_Home_Page">Application Rebranding Project homepage</a> </p>


<h2>Use in our Product</h2>

<h3>Splash screen</h3>

<img src="splashscreen_OOo3_refresh.png" width="551" height="366" border="0" alt="">

<h3>About Box</h3>

<img src="Aboutbox_OOo3_refresh.png" width="469" height="622" border="0" alt="">

<h3>Start center</h3>

<img src="fullscreen_OOo3_refresh.png" width="1099" height="770" border="0" alt="">

<h3>ODF icons</h3>

<img src="ODF_icons.png" width="475" height="205" border="0" alt="">

<h3>Application icons</h3>

<img src="OOo_Application_256x256.png" width="256" height="256" border="0" alt="">
<p>&nbsp;</p>

<h2>Third Party Use of OpenOffice.org Logos </h2>
<p> Please see the <a href="http://openoffice.apache.org/trademarks.html">Apache OpenOffice Trademarks</a> page for information on the use of,
and how to request the use of the OpenOffice.org logos and other trademarked items.
</body>
</html>
