<?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.
-->
<site>
   <feature url="features/org.apache.felix.sigil.eclipse.core.feature_0.9.0.SNAPSHOT.jar" id="org.apache.felix.sigil.eclipse.core.feature" version="0.9.0.SNAPSHOT">
      <category name="Sigil"/>
   </feature>
   <feature url="features/org.apache.felix.sigil.eclipse.obr.feature_0.9.0.SNAPSHOT.jar" id="org.apache.felix.sigil.eclipse.obr.feature" version="0.9.0.SNAPSHOT">
      <category name="Sigil"/>
   </feature>
   
   <category-def name="Sigil" label="Sigil-Core">
      <description>
         Sigil is an SDK for developing OSGi applications
      </description>
   </category-def>   
</site>
