<!--
    Copyright (c) 2013, 2017 Orange.
    All rights reserved. This program and the accompanying materials
    are made available under the terms of the Eclipse Public License v1.0
    which accompanies this distribution, and is available at
    http://www.eclipse.org/legal/epl-v10.html
   
    Contributors:
       BAREAU Cyrille <cyrille.bareau@orange.com>, 
       BONNARDEL Gregory <gbonnardel.ext@orange.com>, 
       BOLLE Sebastien <sebastien.bolle@orange.com>.
 -->
<resources>

    <!-- Default screen margins, per the Android Design guidelines. -->
    <dimen name="activity_horizontal_margin">16dp</dimen>
    <dimen name="activity_vertical_margin">16dp</dimen>
    <dimen name="title_size">16sp</dimen>
    <dimen name="indicator_height">25dp</dimen>
    <dimen name="indicator_width">50dp</dimen>
    <dimen name="indicator_text_size">15sp</dimen>
    <dimen name="list_margin_top">50dp</dimen>
    <dimen name="indicator_text_size_big">17sp</dimen>
	
    <dimen name="menu_title_size">18sp</dimen>
</resources>