Comment aligner RelativeSizeSpan en haut

Question

J'ai la Chaîne suivante RM123.456. Je voudrais

• Faire RM relativement petites
• Faire RM aligné en haut exactement

J'ai presque pu le faire à l'aide de

spannableString.setSpan(new RelativeSizeSpan(0.50f), 0, index, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
textView.setText(spannableString, TextView.BufferType.SPANNABLE);

Le résultat ressemble

Cependant, il est aligné vers le bas. Il n'a pas d'aligner vers le haut.

J'essaie d'utiliser SuperscriptSpan. Il ressemble

Il ne veut pas faire ce que je veux comme

• SuperscriptSpan ne pas rendre le texte plus petit. Je ne suis pas en mesure de contrôler son dimensionnement.
• SuperscriptSpan fera le texte "sur le dessus aligner"

Pourrais-je savoir, comment puis-je faire RelativeSizeSpan aligner sur le haut exactement?

C'est ce que je souhaite atteindre.

Veuillez noter que nous ne souhaitons pas aller pour 2 TextViews solution.

Answer 1

Cependant, je l'ai fait de cette façon:

activity_main.xml :

 <TextView
    android:id="@+id/txtView"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_marginTop="50dp"
    android:textSize="26sp" />
 

MainActivity.java :

 TextView txtView = (TextView) findViewById(R.id.txtView);

SpannableString spannableString = new SpannableString("RM123.456");
spannableString.setSpan( new TopAlignSuperscriptSpan( (float)0.35 ), 0, 2, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE );
txtView.setText(spannableString);
 

TopAlignSuperscriptSpan.java :

 private class TopAlignSuperscriptSpan extends SuperscriptSpan {
        //divide superscript by this number
        protected int fontScale = 2;

        //shift value, 0 to 1.0
        protected float shiftPercentage = 0;

        //doesn't shift
        TopAlignSuperscriptSpan() {}

        //sets the shift percentage
        TopAlignSuperscriptSpan( float shiftPercentage ) {
            if( shiftPercentage > 0.0 && shiftPercentage < 1.0 )
                this.shiftPercentage = shiftPercentage;
        }

        @Override
        public void updateDrawState( TextPaint tp ) {
            //original ascent
            float ascent = tp.ascent();

            //scale down the font
            tp.setTextSize( tp.getTextSize() / fontScale );

            //get the new font ascent
            float newAscent = tp.getFontMetrics().ascent;

            //move baseline to top of old font, then move down size of new font
            //adjust for errors with shift percentage
            tp.baselineShift += ( ascent - ascent * shiftPercentage )
                    - (newAscent - newAscent * shiftPercentage );
        }

        @Override
        public void updateMeasureState( TextPaint tp ) {
            updateDrawState( tp );
        }
    }
 

J'espère que ceci vous aidera.

Answer 2

J'ai eu un coup d'oeil à l' RelativeSizeSpan et a trouvé un plutôt simple de mise en œuvre. Vous pouvez donc mettre en place votre propre RelativeSizeSpan pour votre but. La seule différence ici est qu'il ne veut pas mettre en oeuvre ParcelableSpan, puisque c'est seulement prévu pour le code de la structure. AntiRelativeSizeSpan est juste un rapide hack sans beaucoup d'essais, bien sûr, mais il semble bien fonctionner. Il repose complètement sur Paint.getTextBounds() trouver la meilleure valeur pour l' baselineShift, mais peut-être qu'il y aurait une meilleure approche.

public class AntiRelativeSizeSpan extends MetricAffectingSpan {
    private final float mProportion;

    public AntiRelativeSizeSpan(float proportion) {
        mProportion = proportion;
    }

    public float getSizeChange() {
        return mProportion;
    }

    @Override
    public void updateDrawState(TextPaint ds) {
        updateAnyState(ds);
    }

    @Override
    public void updateMeasureState(TextPaint ds) {
        updateAnyState(ds);
    }

    private void updateAnyState(TextPaint ds) {
        Rect bounds = new Rect();
        ds.getTextBounds("1A", 0, 2, bounds);
        int shift = bounds.top - bounds.bottom;
        ds.setTextSize(ds.getTextSize() * mProportion);
        ds.getTextBounds("1A", 0, 2, bounds);
        shift += bounds.bottom - bounds.top;
        ds.baselineShift += shift;
    }
}

Answer 3

Vous pouvait atteindre de gravité haut, par la création d'une coutume MetricAffectingSpan classe

voici le code de la classe personnalisée:

public class CustomCharacterSpan extends MetricAffectingSpan {
    double ratio = 0.5;

    public CustomCharacterSpan() {
    }

    public CustomCharacterSpan(double ratio) {
        this.ratio = ratio;
    }

    @Override
    public void updateDrawState(TextPaint paint) {
        paint.baselineShift += (int) (paint.ascent() * ratio);
    }

    @Override
    public void updateMeasureState(TextPaint paint) {
        paint.baselineShift += (int) (paint.ascent() * ratio);
    }
}

L'application de la durée:

spannableString.setSpan(new RelativeSizeSpan(0.50f), 0, index, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
spannableString.setSpan(new CustomCharacterSpan(), 0, index,
                SpannableString.SPAN_EXCLUSIVE_EXCLUSIVE);
textView.setText(spannableString, TextView.BufferType.SPANNABLE);

Sortie:

Pour plus d'info sur MetricAffectingSpan : http://developer.android.com/reference/android/text/style/MetricAffectingSpan.html

Personnalisé MetricAffectingSpan logique de visée à partir de : Deux styles différents dans un seul textview avec différents gravité et hieght

Answer 4

J'ai mis en œuvre cette dans une de mes applications.

 <TextView
    android:id="@+id/txt_formatted_value"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_gravity="center"
    android:textColor="#000000"       
    android:textSize="28dp" />

Dans Activity/Frgament.class

 myTextView = (TextView) view.findViewById(R.id.txt_formatted_value);

Codé en dur pour objectif de test,

String numberValue = "123.456";    
myTextView.setText(UtilityClass.getFormattedSpannedString("RM"+numberValue,
     numberValue.length(),0));

Ajouter cette classe dans votre forfait,

public class SuperscriptSpanAdjuster extends MetricAffectingSpan {
double ratio = 0.5;

public SuperscriptSpanAdjuster() {
}

public SuperscriptSpanAdjuster(double ratio) {
    this.ratio = ratio;
}

@Override
public void updateDrawState(TextPaint paint) {
    paint.baselineShift += (int) (paint.ascent() * ratio);
}

@Override
public void updateMeasureState(TextPaint paint) {
    paint.baselineShift += (int) (paint.ascent() * ratio);
}

}

Créé le format de la méthode dans UntilityClass.class

 public static SpannableString getFormattedSpannedString(String value, int mostSignificantLength, int leastSignificantLength){

    SpannableString  spanString = new SpannableString(value);
    /* To show the text in top aligned(Normal)*/
    spanString.setSpan(new SuperscriptSpanAdjuster(0.7), 0,spanString.length()-mostSignificantLength-leastSignificantLength, SpannableString.SPAN_EXCLUSIVE_EXCLUSIVE);
    /* Show the number of characters is normal size (Normal)*/
    spanString.setSpan(new RelativeSizeSpan(1.3f), 0,spanString.length()-mostSignificantLength-leastSignificantLength, 0);
    /*To set the text style as bold(MostSignificant)*/
    //spanString.setSpan(new StyleSpan(Typeface.BOLD), spanString.length()-mostSignificantLength-leastSignificantLength, spanString.length()-leastSignificantLength, 0);
    /*To set the text color as WHITE(MostSignificant)*/
    //spanString.setSpan(new ForegroundColorSpan(Color.WHITE), spanString.length()-mostSignificantLength-leastSignificantLength,  spanString.length()-leastSignificantLength, 0);
    /*Show the number of characters as most significant value(MostSignificant)*/
    spanString.setSpan(new RelativeSizeSpan(2.3f), spanString.length()-mostSignificantLength-leastSignificantLength, spanString.length()-leastSignificantLength, 0);

    /* To show the text in top aligned(LestSignificant)*/
    spanString.setSpan(new SuperscriptSpanAdjuster(1.2), spanString.length()-leastSignificantLength, spanString.length(), SpannableString.SPAN_EXCLUSIVE_EXCLUSIVE);
    /*To set the text style as bold(LestSignificant)*/
    //spanString.setSpan(new StyleSpan(Typeface.BOLD), spanString.length()-leastSignificantLength, spanString.length(), 0);
    /*Show the number of characters as most significant value(LestSignificant)*/
    spanString.setSpan(new RelativeSizeSpan(0.8f), spanString.length()-leastSignificantLength, spanString.length(), 0);

    return spanString;
}

En utilisant cette méthode, vous pouvez faire plus de cirque, comme le changement du style de texte, la couleur séparément pour Exposant. Vous pouvez également ajouter un exposant à la fois à droite et à gauche.(Ici, j'ai commenté le code, si vous voulez vous pouvez donner un essai...)

Answer 5

la meilleure solution appropriée est d'aller avec html.

Je préférerai pour ces solutions, il prend en charge dans toutes les versions Android ainsi que les appareils.

voici un exemple, prenez-le comme vous le souhaitez

 <p><sup>TM</sup> 123.456.</p>
 

je reçois un résultat dans android

^TM 123.456.

vous pouvez facilement afficher du texte dans Textview dans Android avec

Html.fromText("YOUR_STRING_INHTML");

J'espère que ça aide.