Etiqueta Tamaño del texto de acuerdo con el tamaño de la pantalla en un gráfico gráfico del motor de gráfico en android

Puede establecer el tamaño de texto de las etiquetas de esta manera:

renderer.setLabelsTextSize(size); 

Usted tendrá que encontrar la mejor lógica para encontrar la mejor proporción entre el tamaño de la pantalla y el tamaño de las etiquetas.

Este problema se reduce a la resolución. Achartengine parece haber sido diseñado con píxeles crudos en mente, mientras que la calidad de la pantalla y la densidad de píxeles ha aumentado dramáticamente en los últimos dos años. Las etiquetas de la muestra achartengine son pequeñas en mi HTC One!

Android ha introducido píxeles independientes de la escala . La clave para usarlos con achartengine es la clase TypedValue . Esto es lo que hice:

 DisplayMetrics metrics = context.getResources().getDisplayMetrics(); float val = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, 18, metrics); 

Tengo 18 de "tamaño de texto medio" en el enlace de arriba.

A continuación, puede utilizar val cualquier lugar que desee utilizar texto de tamaño medio. Por ejemplo:

 renderer.setLabelsTextSize(val); 

Esta es una versión resumida de lo que hice:

 public static final int TEXT_SIZE_XHDPI = 24; public static final int TEXT_SIZE_HDPI = 20; public static final int TEXT_SIZE_MDPI = 18; public static final int TEXT_SIZE_LDPI = 13; XYMultipleSeriesRenderer renderer = new XYMultipleSeriesRenderer(); switch (getResources().getDisplayMetrics().densityDpi) { case DisplayMetrics.DENSITY_XHIGH: renderer.setMargins(new int[] { 40, 90, 25, 10 }); renderer.setAxisTitleTextSize(Constants.TEXT_SIZE_XHDPI); renderer.setChartTitleTextSize(Constants.TEXT_SIZE_XHDPI); renderer.setLabelsTextSize(Constants.TEXT_SIZE_XHDPI); renderer.setLegendTextSize(Constants.TEXT_SIZE_XHDPI); break; case DisplayMetrics.DENSITY_HIGH: renderer.setMargins(new int[] { 30, 50, 20, 10 }); renderer.setAxisTitleTextSize(Constants.TEXT_SIZE_HDPI); renderer.setChartTitleTextSize(Constants.TEXT_SIZE_HDPI); renderer.setLabelsTextSize(Constants.TEXT_SIZE_HDPI); renderer.setLegendTextSize(Constants.TEXT_SIZE_HDPI); break; default: renderer.setMargins(new int[] { 30, 50, 20, 10 }); renderer.setAxisTitleTextSize(Constants.TEXT_SIZE_LDPI); renderer.setChartTitleTextSize(Constants.TEXT_SIZE_LDPI); renderer.setLabelsTextSize(Constants.TEXT_SIZE_LDPI); renderer.setLegendTextSize(Constants.TEXT_SIZE_LDPI); break; } 

Así que, básicamente, personalizó los márgenes y los tamaños de texto de la tabla en función de la densidad de pantalla del dispositivo. Nota: Se excluyó el caso de densidad media por ahora.

Escribí dos métodos llamados _dp y _sp para convertir a valores de dp y sp.

 private DisplayMetrics displayMetrics; private boolean isPortrait; int _dp(float pixels) { return (int)(pixels * displayMetrics.density); } float _sp(float pixels) { return (pixels * displayMetrics.scaledDensity); } 

En su onCreate necesita establecer el valor displayMetrics:

 displayMetrics = (this.getResources()).getDisplayMetrics(); 

A continuación, sólo tiene que usar _sp y _dp para obtener el valor sp / dp. Por ejemplo, para establecer un tipo de letra escalado a 18

 renderer.setAxisTitleTextSize(_sp(18)); 

Y para establecer márgenes con valores dp:

 renderer.setMargins(new int[] {_dp(25), _dp(30), _dp(35), _dp(20)}); 

NOTA: Hice un cambio a este código. Es posible obtener un valor 0 para estas funciones, que es un problema real si se está dividiendo por el valor de retorno. He añadido una prueba para devolver 1 si el valor devuelto es <1. ie: return ((rv <1)? 1: v);

La mejor práctica es colocar TextView ficticio en el diseño para obtener el textSize:

 <TextView android:id="@+id/dummyTextView" android:layout_width="wrap_content" android:layout_height="wrap_content" android:visibility="gone" android:text="TextView" /> 

Y en su código, por ejemplo:

 TextView testTextView = (TextView) rootView.findViewById(R.id.dummyTextView); float textSize = testTextView.getTextSize(); renderer.setLabelsTextSize(textSize); renderer.setLegendTextSize(textSize); 

Creo que la mejor manera de hacerlo es definir los tamaños en el archivo dimens.xml en dp y sp como así:

 <dimen name="graph_chart_text_size">16sp</dimen> <dimen name="graph_axis_title_text_size">14sp</dimen> <dimen name="graph_labels_text_size">12sp</dimen> <dimen name="graph_labels_padding">5dp</dimen> <dimen name="graph_legend_text_size">14sp</dimen> <dimen name="graph_legend_height">40dp</dimen> <dimen name="graph_point">3dp</dimen> <dimen name="graph_line">3dp</dimen> <dimen name="graph_margin_top">10dp</dimen> <dimen name="graph_margin_left">40dp</dimen> <dimen name="graph_margin_right">10dp</dimen> <dimen name="graph_margin_bottom">20dp</dimen> 

A continuación, utilice getDimension y getDimensionPixelOffset para convertir a píxeles al configurar el renderizador, como:

 renderer.setChartTitleTextSize(context.getResources().getDimension(R.dimen.graph_chart_text_size)); renderer.setAxisTitleTextSize(context.getResources().getDimension(R.dimen.graph_axis_title_text_size)); renderer.setLabelsTextSize(context.getResources().getDimension(R.dimen.graph_labels_text_size)); renderer.setLegendTextSize(context.getResources().getDimension(R.dimen.graph_legend_text_size)); renderer.setLegendHeight(context.getResources().getDimensionPixelOffset(R.dimen.graph_legend_height)); renderer.setMargins(new int[]{ context.getResources().getDimensionPixelOffset(R.dimen.graph_margin_top), context.getResources().getDimensionPixelOffset(R.dimen.graph_margin_left_mood), context.getResources().getDimensionPixelOffset(R.dimen.graph_margin_bottom), context.getResources().getDimensionPixelOffset(R.dimen.graph_margin_right)}); } 

Estoy probando en los teléfonos que van desde 800×480 a 1920×1080 y el diseño es muy coherente.

Puede probar esto:

 renderer.setLegendTextSize(textSize);