<?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.
  
-->
<library>
	
	<!-- APL Author sebawagner -->
	<resource name="image_loading_placeholder_rsc" 
			  src="resources/loading_symbol.swf" />
	
	<!-- APL Author sebawagner -->
	<resource name="private_message_select_part_rsc" 
			  src="resources/select_part.png" />	
		
	<!-- FamFam Icon Set -->
	<resource name="private_message_send_rsc" 
			  src="resources/email_go.png" />	 
		
	<!-- FamFam Icon Set -->
	<resource name="private_message_add_rsc" 
			  src="resources/email_add.png" />	
		
	<!-- FamFam Icon Set -->	  
	<resource name="private_message_trash_rsc" 
			  src="resources/email_delete.png" />	
	
	<!-- FamFam Icon Set -->
	<resource name="private_message_folder_add_rsc" 
			  src="resources/folder_add.png" />		
	
	<!-- FamFam Icon Set -->	  
	<resource name="private_message_folder_rsc" 
			  src="resources/folder.png" />	
		
	<!-- FamFam Icon Set -->	  
	<resource name="private_message_inbox_rsc" 
			  src="resources/basket_put.png" />	
		
	<!-- FamFam Icon Set -->	  
	<resource name="user_contact_calendar_add_rsc" 
              src="resources/calendar_add.png" />  
	
	<!-- FamFam Icon Set -->		  
	<resource name="user_contact_calendar_delete_rsc" 
              src="resources/calendar_delete.png" /> 
      
    <!-- FamFam Icon Set -->	        
    <resource name="user_contact_calendar_system_undo_rsc" 
              src="resources/arrow_undo.png" />   
   
    <include href="privatemessages/" />
    <include href="usercontacts/" />
    <include href="searchuserprofile/" />
    
    <include href="viewUserProfile.lzx" />
    <include href="userSettings.lzx" />
    <include href="editUserProfile.lzx" />

</library>
