Examples with Typeface android.graphics.Typeface used on opensource projects

Example 21 with Typeface

use of android.graphics.Typeface in project MPAndroidChart by PhilJay.

the class LegendRenderer method renderLegend.

public void renderLegend(Canvas c) {
    if (!mLegend.isEnabled())
        return;
    Typeface tf = mLegend.getTypeface();
    if (tf != null)
        mLegendLabelPaint.setTypeface(tf);
    mLegendLabelPaint.setTextSize(mLegend.getTextSize());
    mLegendLabelPaint.setColor(mLegend.getTextColor());
    float labelLineHeight = Utils.getLineHeight(mLegendLabelPaint, legendFontMetrics);
    float labelLineSpacing = Utils.getLineSpacing(mLegendLabelPaint, legendFontMetrics) + Utils.convertDpToPixel(mLegend.getYEntrySpace());
    float formYOffset = labelLineHeight - Utils.calcTextHeight(mLegendLabelPaint, "ABC") / 2.f;
    LegendEntry[] entries = mLegend.getEntries();
    float formToTextSpace = Utils.convertDpToPixel(mLegend.getFormToTextSpace());
    float xEntrySpace = Utils.convertDpToPixel(mLegend.getXEntrySpace());
    Legend.LegendOrientation orientation = mLegend.getOrientation();
    Legend.LegendHorizontalAlignment horizontalAlignment = mLegend.getHorizontalAlignment();
    Legend.LegendVerticalAlignment verticalAlignment = mLegend.getVerticalAlignment();
    Legend.LegendDirection direction = mLegend.getDirection();
    float defaultFormSize = Utils.convertDpToPixel(mLegend.getFormSize());
    // space between the entries
    float stackSpace = Utils.convertDpToPixel(mLegend.getStackSpace());
    float yoffset = mLegend.getYOffset();
    float xoffset = mLegend.getXOffset();
    float originPosX = 0.f;
    switch(horizontalAlignment) {
        case LEFT:
            if (orientation == Legend.LegendOrientation.VERTICAL)
                originPosX = xoffset;
            else
                originPosX = mViewPortHandler.contentLeft() + xoffset;
            if (direction == Legend.LegendDirection.RIGHT_TO_LEFT)
                originPosX += mLegend.mNeededWidth;
            break;
        case RIGHT:
            if (orientation == Legend.LegendOrientation.VERTICAL)
                originPosX = mViewPortHandler.getChartWidth() - xoffset;
            else
                originPosX = mViewPortHandler.contentRight() - xoffset;
            if (direction == Legend.LegendDirection.LEFT_TO_RIGHT)
                originPosX -= mLegend.mNeededWidth;
            break;
        case CENTER:
            if (orientation == Legend.LegendOrientation.VERTICAL)
                originPosX = mViewPortHandler.getChartWidth() / 2.f;
            else
                originPosX = mViewPortHandler.contentLeft() + mViewPortHandler.contentWidth() / 2.f;
            originPosX += (direction == Legend.LegendDirection.LEFT_TO_RIGHT ? +xoffset : -xoffset);
            // So here we offset the vertical ones only.
            if (orientation == Legend.LegendOrientation.VERTICAL) {
                originPosX += (direction == Legend.LegendDirection.LEFT_TO_RIGHT ? -mLegend.mNeededWidth / 2.0 + xoffset : mLegend.mNeededWidth / 2.0 - xoffset);
            }
            break;
    }
    switch(orientation) {
        case HORIZONTAL:
            {
                List<FSize> calculatedLineSizes = mLegend.getCalculatedLineSizes();
                List<FSize> calculatedLabelSizes = mLegend.getCalculatedLabelSizes();
                List<Boolean> calculatedLabelBreakPoints = mLegend.getCalculatedLabelBreakPoints();
                float posX = originPosX;
                float posY = 0.f;
                switch(verticalAlignment) {
                    case TOP:
                        posY = yoffset;
                        break;
                    case BOTTOM:
                        posY = mViewPortHandler.getChartHeight() - yoffset - mLegend.mNeededHeight;
                        break;
                    case CENTER:
                        posY = (mViewPortHandler.getChartHeight() - mLegend.mNeededHeight) / 2.f + yoffset;
                        break;
                }
                int lineIndex = 0;
                for (int i = 0, count = entries.length; i < count; i++) {
                    LegendEntry e = entries[i];
                    boolean drawingForm = e.form != Legend.LegendForm.NONE;
                    float formSize = Float.isNaN(e.formSize) ? defaultFormSize : Utils.convertDpToPixel(e.formSize);
                    if (i < calculatedLabelBreakPoints.size() && calculatedLabelBreakPoints.get(i)) {
                        posX = originPosX;
                        posY += labelLineHeight + labelLineSpacing;
                    }
                    if (posX == originPosX && horizontalAlignment == Legend.LegendHorizontalAlignment.CENTER && lineIndex < calculatedLineSizes.size()) {
                        posX += (direction == Legend.LegendDirection.RIGHT_TO_LEFT ? calculatedLineSizes.get(lineIndex).width : -calculatedLineSizes.get(lineIndex).width) / 2.f;
                        lineIndex++;
                    }
                    // grouped forms have null labels
                    boolean isStacked = e.label == null;
                    if (drawingForm) {
                        if (direction == Legend.LegendDirection.RIGHT_TO_LEFT)
                            posX -= formSize;
                        drawForm(c, posX, posY + formYOffset, e, mLegend);
                        if (direction == Legend.LegendDirection.LEFT_TO_RIGHT)
                            posX += formSize;
                    }
                    if (!isStacked) {
                        if (drawingForm)
                            posX += direction == Legend.LegendDirection.RIGHT_TO_LEFT ? -formToTextSpace : formToTextSpace;
                        if (direction == Legend.LegendDirection.RIGHT_TO_LEFT)
                            posX -= calculatedLabelSizes.get(i).width;
                        drawLabel(c, posX, posY + labelLineHeight, e.label);
                        if (direction == Legend.LegendDirection.LEFT_TO_RIGHT)
                            posX += calculatedLabelSizes.get(i).width;
                        posX += direction == Legend.LegendDirection.RIGHT_TO_LEFT ? -xEntrySpace : xEntrySpace;
                    } else
                        posX += direction == Legend.LegendDirection.RIGHT_TO_LEFT ? -stackSpace : stackSpace;
                }
                break;
            }
        case VERTICAL:
            {
                // contains the stacked legend size in pixels
                float stack = 0f;
                boolean wasStacked = false;
                float posY = 0.f;
                switch(verticalAlignment) {
                    case TOP:
                        posY = (horizontalAlignment == Legend.LegendHorizontalAlignment.CENTER ? 0.f : mViewPortHandler.contentTop());
                        posY += yoffset;
                        break;
                    case BOTTOM:
                        posY = (horizontalAlignment == Legend.LegendHorizontalAlignment.CENTER ? mViewPortHandler.getChartHeight() : mViewPortHandler.contentBottom());
                        posY -= mLegend.mNeededHeight + yoffset;
                        break;
                    case CENTER:
                        posY = mViewPortHandler.getChartHeight() / 2.f - mLegend.mNeededHeight / 2.f + mLegend.getYOffset();
                        break;
                }
                for (int i = 0; i < entries.length; i++) {
                    LegendEntry e = entries[i];
                    boolean drawingForm = e.form != Legend.LegendForm.NONE;
                    float formSize = Float.isNaN(e.formSize) ? defaultFormSize : Utils.convertDpToPixel(e.formSize);
                    float posX = originPosX;
                    if (drawingForm) {
                        if (direction == Legend.LegendDirection.LEFT_TO_RIGHT)
                            posX += stack;
                        else
                            posX -= formSize - stack;
                        drawForm(c, posX, posY + formYOffset, e, mLegend);
                        if (direction == Legend.LegendDirection.LEFT_TO_RIGHT)
                            posX += formSize;
                    }
                    if (e.label != null) {
                        if (drawingForm && !wasStacked)
                            posX += direction == Legend.LegendDirection.LEFT_TO_RIGHT ? formToTextSpace : -formToTextSpace;
                        else if (wasStacked)
                            posX = originPosX;
                        if (direction == Legend.LegendDirection.RIGHT_TO_LEFT)
                            posX -= Utils.calcTextWidth(mLegendLabelPaint, e.label);
                        if (!wasStacked) {
                            drawLabel(c, posX, posY + labelLineHeight, e.label);
                        } else {
                            posY += labelLineHeight + labelLineSpacing;
                            drawLabel(c, posX, posY + labelLineHeight, e.label);
                        }
                        // make a step down
                        posY += labelLineHeight + labelLineSpacing;
                        stack = 0f;
                    } else {
                        stack += formSize + stackSpace;
                        wasStacked = true;
                    }
                }
                break;
            }
    }
}

Example 22 with Typeface

use of android.graphics.Typeface in project MPAndroidChart by PhilJay.

the class LegendRenderer method computeLegend.

/**
     * Prepares the legend and calculates all needed forms, labels and colors.
     *
     * @param data
     */
public void computeLegend(ChartData<?> data) {
    if (!mLegend.isLegendCustom()) {
        computedEntries.clear();
        // loop for building up the colors and labels used in the legend
        for (int i = 0; i < data.getDataSetCount(); i++) {
            IDataSet dataSet = data.getDataSetByIndex(i);
            List<Integer> clrs = dataSet.getColors();
            int entryCount = dataSet.getEntryCount();
            // if we have a barchart with stacked bars
            if (dataSet instanceof IBarDataSet && ((IBarDataSet) dataSet).isStacked()) {
                IBarDataSet bds = (IBarDataSet) dataSet;
                String[] sLabels = bds.getStackLabels();
                for (int j = 0; j < clrs.size() && j < bds.getStackSize(); j++) {
                    computedEntries.add(new LegendEntry(sLabels[j % sLabels.length], dataSet.getForm(), dataSet.getFormSize(), dataSet.getFormLineWidth(), dataSet.getFormLineDashEffect(), clrs.get(j)));
                }
                if (bds.getLabel() != null) {
                    // add the legend description label
                    computedEntries.add(new LegendEntry(dataSet.getLabel(), Legend.LegendForm.NONE, Float.NaN, Float.NaN, null, ColorTemplate.COLOR_NONE));
                }
            } else if (dataSet instanceof IPieDataSet) {
                IPieDataSet pds = (IPieDataSet) dataSet;
                for (int j = 0; j < clrs.size() && j < entryCount; j++) {
                    computedEntries.add(new LegendEntry(pds.getEntryForIndex(j).getLabel(), dataSet.getForm(), dataSet.getFormSize(), dataSet.getFormLineWidth(), dataSet.getFormLineDashEffect(), clrs.get(j)));
                }
                if (pds.getLabel() != null) {
                    // add the legend description label
                    computedEntries.add(new LegendEntry(dataSet.getLabel(), Legend.LegendForm.NONE, Float.NaN, Float.NaN, null, ColorTemplate.COLOR_NONE));
                }
            } else if (dataSet instanceof ICandleDataSet && ((ICandleDataSet) dataSet).getDecreasingColor() != ColorTemplate.COLOR_NONE) {
                int decreasingColor = ((ICandleDataSet) dataSet).getDecreasingColor();
                int increasingColor = ((ICandleDataSet) dataSet).getIncreasingColor();
                computedEntries.add(new LegendEntry(null, dataSet.getForm(), dataSet.getFormSize(), dataSet.getFormLineWidth(), dataSet.getFormLineDashEffect(), decreasingColor));
                computedEntries.add(new LegendEntry(dataSet.getLabel(), dataSet.getForm(), dataSet.getFormSize(), dataSet.getFormLineWidth(), dataSet.getFormLineDashEffect(), increasingColor));
            } else {
                for (int j = 0; j < clrs.size() && j < entryCount; j++) {
                    String label;
                    // if multiple colors are set for a DataSet, group them
                    if (j < clrs.size() - 1 && j < entryCount - 1) {
                        label = null;
                    } else {
                        // add label to the last entry
                        label = data.getDataSetByIndex(i).getLabel();
                    }
                    computedEntries.add(new LegendEntry(label, dataSet.getForm(), dataSet.getFormSize(), dataSet.getFormLineWidth(), dataSet.getFormLineDashEffect(), clrs.get(j)));
                }
            }
        }
        if (mLegend.getExtraEntries() != null) {
            Collections.addAll(computedEntries, mLegend.getExtraEntries());
        }
        mLegend.setEntries(computedEntries);
    }
    Typeface tf = mLegend.getTypeface();
    if (tf != null)
        mLegendLabelPaint.setTypeface(tf);
    mLegendLabelPaint.setTextSize(mLegend.getTextSize());
    mLegendLabelPaint.setColor(mLegend.getTextColor());
    // calculate all dimensions of the mLegend
    mLegend.calculateDimensions(mLegendLabelPaint, mViewPortHandler);
}

Example 23 with Typeface

use of android.graphics.Typeface in project HoloEverywhere by Prototik.

the class Switch method setSwitchTypefaceByIndex.

private void setSwitchTypefaceByIndex(int typefaceIndex, int styleIndex) {
    Typeface tf = null;
    switch(typefaceIndex) {
        case SANS:
            tf = Typeface.SANS_SERIF;
            break;
        case SERIF:
            tf = Typeface.SERIF;
            break;
        case MONOSPACE:
            tf = Typeface.MONOSPACE;
            break;
    }
    setSwitchTypeface(tf, styleIndex);
}

Example 24 with Typeface

use of android.graphics.Typeface in project Anki-Android by Ramblurr.

the class CardEditor method populateEditFields.

private void populateEditFields() {
    mFieldsLayoutContainer.removeAllViews();
    mEditFields = new LinkedList<FieldEditText>();
    String[][] fields = mEditorNote.items();
    // Use custom font if selected from preferences
    Typeface mCustomTypeface = null;
    SharedPreferences preferences = AnkiDroidApp.getSharedPrefs(getBaseContext());
    String customFont = preferences.getString("browserEditorFont", "");
    if (!customFont.equals("")) {
        mCustomTypeface = AnkiFont.getTypeface(this, customFont);
    }
    for (int i = 0; i < fields.length; i++) {
        View editline_view = getLayoutInflater().inflate(R.layout.card_multimedia_editline, null);
        FieldEditText newTextbox = (FieldEditText) editline_view.findViewById(R.id.id_note_editText);
        initFieldEditText(newTextbox, i, fields[i], mCustomTypeface);
        TextView label = newTextbox.getLabel();
        label.setTextColor(Color.BLACK);
        label.setPadding((int) UIUtils.getDensityAdjustedValue(this, 3.4f), 0, 0, 0);
        mEditFields.add(newTextbox);
        ImageButton mediaButton = (ImageButton) editline_view.findViewById(R.id.id_media_button);
        mediaButton.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                Intent editCard = new Intent(CardEditor.this, MultimediaCardEditorActivity.class);
                if (!mAddNote) {
                    editCard.putExtra(CardEditor.EXTRA_CARD_ID, mCurrentEditedCard.getId());
                } else {
                    editCard.putExtra(CardEditor.EXTRA_CARD_ID, 0);
                }
                startActivityForResult(editCard, REQUEST_MULTIMEDIA_EDIT);
            }
        });
        mFieldsLayoutContainer.addView(label);
        mFieldsLayoutContainer.addView(editline_view);
    }
}

Example 25 with Typeface

use of android.graphics.Typeface in project Titanic by RomainPiel.

the class Typefaces method get.

public static Typeface get(Context c, String assetPath) {
    synchronized (cache) {
        if (!cache.containsKey(assetPath)) {
            try {
                Typeface t = Typeface.createFromAsset(c.getAssets(), assetPath);
                cache.put(assetPath, t);
            } catch (Exception e) {
                Log.e(TAG, "Could not get typeface '" + assetPath + "' because " + e.getMessage());
                return null;
            }
        }
        return cache.get(assetPath);
    }
}