<?xml version="1.0" encoding="UTF-8"?>
<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.

-->
<project xmlns="http://maven.apache.org/DECORATION/1.1.0" 
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/DECORATION/1.1.0 
                             http://maven.apache.org/xsd/decoration-1.1.0.xsd" 
         name="Apache Syncope">

  <publishDate position="none"/>
  <version position="none"/>
 
  <skin>
    <groupId>org.apache.maven.skins</groupId>
    <artifactId>maven-fluido-skin</artifactId>
    <version>1.3.1</version>
  </skin>
  <custom>
    <fluidoSkin>
      <topBarEnabled>true</topBarEnabled>
      <sideBarEnabled>false</sideBarEnabled>
      <sourceLineNumbersEnabled>true</sourceLineNumbersEnabled>
      <skipGenerationDate>true</skipGenerationDate>
      <twitter>
        <user>syncopeidm</user>
        <showUser>true</showUser>
        <showFollowers>false</showFollowers>
      </twitter>
      <ohloh>
        <projectId>syncope</projectId>
        <widget>thin-badge</widget>
      </ohloh>
      <facebookLike/>
      <googlePlusOne/>
      <gitHub>
        <projectId>apache/syncope</projectId>
      </gitHub>
    </fluidoSkin>
  </custom>
  
  <body>
    <breadcrumbs>
      <item name="Apache" href="http://www.apache.org/"/>
      <item name="Apache Syncope" href="http://syncope.apache.org/"/>
    </breadcrumbs>
        
    <menu name="Overview">
      <item name="Features" href="features.html"/>
      <item name="Architecture" href="architecture.html"/>
      <item name="Downloads" href="downloads.html"/>
      <item name="Security Advisories" href="security.html"/>
      <item name="API Docs" href="apidocs/1.1/index.html">
        <item name="Javadocs 1.1" href="apidocs/1.1/index.html"/>
        <item name="Javadocs 1.0" href="apidocs/1.0/index.html"/>
      </item>
      <item name="License" href="license.html"/>
      <item name="Professional Services" href="professional-services.html"/>
    </menu>
  
    <menu name="Community">
      <item name="Mailing Lists" href="mail-lists.html"/>
      <item name="Project Team" href="team-list.html"/>
      <item name="Roadmap" href="http://cwiki.apache.org/confluence/display/SYNCOPE/Roadmap"/>
      <item name="Documentation" href="http://cwiki.apache.org/confluence/display/SYNCOPE/Index"/>
    </menu>
      
    <menu name="Development">
      <item name="How to contribute?" href="contributing.html"/>
      <item name="Source Repository" href="source-repository.html"/>
      <item name="Continuous Integration" href="integration.html"/>
      <item name="Issue Tracking" href="issue-tracking.html"/>
      <item name="Building" href="building.html"/>
      <item name="Release Process" href="release-process.html"/>
    </menu>

    <menu name="ASF">
      <item name="How Apache Works" href="http://www.apache.org/foundation/how-it-works.html"/>
      <item name="Foundation" href="http://www.apache.org/foundation/"/>
      <item name="Sponsoring Apache" href="http://www.apache.org/foundation/sponsorship.html"/>
      <item name="Thanks" href="http://www.apache.org/foundation/thanks.html"/>
    </menu>

    <footer>
      <div class="row">
        Apache, Syncope, Apache Syncope, the Apache feather logo and the Apache Syncope project logo are trademarks of The Apache Software Foundation. All other marks mentioned may be trademarks or registered trademarks of their respective owners.
      </div>
    </footer>
  </body>

</project>
