एंड्रॉइड

Question

में एक चार्ट इंजन पाई चार्ट में स्क्रीन आकार के अनुसार लेबल टेक्स्ट आकार, मैं सफलतापूर्वक इंजन इंजन का उपयोग करके पाई चार्ट प्रदर्शित कर रहा हूं। मैं स्क्रीन आकार के अनुसार अपने लेबल टेक्स्ट आकार को कस्टमाइज़ करना चाहता हूं। पहले से धन्यवाद।

Answer 1

आप लेबल पाठ का आकार इस तरह से सेट कर सकते हैं:

renderer.setLabelsTextSize(size); 

आप स्क्रीन आकार और लेबल आकार के बीच सर्वश्रेष्ठ अनुपात को खोजने के लिए सबसे अच्छा तर्क को खोजने के लिए होगा।

Answer 2

यह मैं क्या किया की एक संक्षिप्त संस्करण:

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; 
    } 

तो मैं मूल रूप से मार्जिन और डिवाइस की स्क्रीन घनत्व के आधार पर चार्ट के पाठ आकार अनुकूलित। नोट: मैंने अब मध्यम घनत्व के मामले को बाहर रखा है।

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

और उदाहरण के लिए अपने कोड में:

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

Answer 3

सबसे अच्छा अभ्यास लेआउट में डमी TextView जगह textSize प्राप्त करने के लिए है। ऐसा लगता है कि अचर्टेंगिन को कच्चे पिक्सल के साथ दिमाग में डिजाइन किया गया है जबकि पिछले कुछ वर्षों में प्रदर्शन गुणवत्ता और पिक्सेल घनत्व नाटकीय रूप से बढ़ गया है। Achartengine नमूने से लेबल मेरे एचटीसी वन पर छोटे हैं!

एंड्रॉइड ने scale-independent pixels पेश किया है। Achartengine के साथ उनका उपयोग करने की कुंजी TypedValue कक्षा है। यहां मैंने जो किया है:

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

मुझे ऊपर दिए गए लिंक में "टेक्स्ट साइज माध्यम" से 18 मिल गया।

आप तब भी val का उपयोग कर सकते हैं जहां आप मध्यम आकार के टेक्स्ट का उपयोग करना चाहते हैं। उदाहरण के लिए:

renderer.setLabelsTextSize(val); 

Answer 4

यह समस्या समाधान करने के लिए नीचे आता है

Answer 5

मुझे लगता है कि ऐसा करने के लिए सबसे अच्छा तरीका यह तो जैसे डी पी और एसपी में फ़ाइल dimens.xml में आकार को परिभाषित करने के लिए है:

<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> 

और फिर getDimension और getDimensionPixelOffset का उपयोग पिक्सल में बदलने के लिए फोन है कि 800x480 से 1920x1080 तक होती है और डिजाइन बहुत संगत है में

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)}); 
    } 

मैं परीक्षण: जब इस तरह के रूप रेंडरर कॉन्फ़िगर।

Answer 6

आप इस कोशिश कर सकते हैं:

renderer.setLegendTextSize(textSize); 

Answer 7

मैं दो तरीकों _dp और _sp कहा जाता है डी पी और एसपी मूल्यों को बदलने के लिए लिखा था।

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

में अपने onCreate आप displayMetrics मूल्य निर्धारित करने की आवश्यकता:

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

तो फिर तुम सिर्फ एसपी/डी पी मूल्य प्राप्त करने के _sp और _dp का उपयोग करें।उदाहरण स्थापित करने के लिए के लिए एक फ़ॉन्ट 18

renderer.setAxisTitleTextSize(_sp(18)); 

को बढ़ाया और डी पी मूल्यों के साथ मार्जिन सेट करने के लिए:

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

नोट: मैं इस कोड को एक परिवर्तन किया है। इन कार्यों के लिए 0 मान प्राप्त करना संभव है - यदि आप रिटर्न वैल्यू से विभाजित होते हैं तो वास्तविक समस्या होती है। मैंने वापसी के मूल्य को < पर वापस करने के लिए एक परीक्षण जोड़ा 1. यानी: वापसी ((आरवी < 1)? 1: v);