Legacy library for custom fonts for android. If possible do not use this library its outdated!
Are you fed up of Custom Views to set fonts? Or traversing the ViewTree to find TextViews? Yeah me too.
Include the dependency as well as the ViewPump library:
dependencies {
// Legacy lib for custom fonts
implementation 'dev.b3nedikt.calligraphy:calligraphy:4.0.2'
// AndroidX compatibility
implementation 'androidx.appcompat:appcompat:1.2.0'
// Intercept view inflation
implementation 'dev.b3nedikt.viewpump:viewpump:4.0.5'
}
Add your custom fonts to assets/
. All font definitions are relative to this path.
Assuming that you are using Gradle you should create the assets directory under src/main/
in your project directory if it does not already exist.
As it's popular to use multi-project build with Gradle the path is usually app/src/main/assets/
, where app
is the project name.
You might consider creating a fonts/
subdirectory in the assets directory (as in examples).
<TextView fontPath="fonts/MyFont.ttf"/>
Note: The missing namespace, this IS intentional.
Define your default font using CalligraphyConfig
, in your Application
class in the #onCreate()
method and pass it to the CalligraphyInterceptor
that you add to your ViewPump
builder.
@Override
public void onCreate() {
super.onCreate();
ViewPump.init(new CalligraphyInterceptor(
new CalligraphyConfig.Builder()
.setDefaultFontPath("fonts/Roboto-ThinItalic.ttf")
.setFontAttrId(R.attr.fontPath)
.setFontMapper(new FontMapper() {
@Override
public String map(String font) {
return font;
}
})
.addCustomViewWithSetTypeface(CustomViewWithTypefaceSupport.class)
.addCustomStyle(TextField.class, R.attr.textFieldStyle)
.build()));
//....
}
Note: You don't need to define CalligraphyConfig
but the library will apply
no default font and use the default attribute of R.attr.fontPath
.
Add the following to your base activitiy:
public class MainActivity extends AppCompatActivity {
private AppCompatDelegate appCompatDelegate = null;
...
@NonNull
@Override
public AppCompatDelegate getDelegate() {
if (appCompatDelegate == null) {
appCompatDelegate = new ViewPumpAppCompatDelegate(
super.getDelegate(),
this
);
}
return appCompatDelegate;
}
}
You're good to go!
<TextView
android:text="@string/hello_world"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
fontPath="fonts/Roboto-Bold.ttf"/>
Note: Popular IDE's (Android Studio, IntelliJ) will likely mark this as an error despite being correct. You may want to add tools:ignore="MissingPrefix"
to either the View itself or its parent ViewGroup to avoid this. You'll need to add the tools namespace to have access to this "ignore" attribute. xmlns:tools=" http://schemas.android.com/tools"
. See https://code.google.com/p/android/issues/detail?id=65176.
<style name="TextAppearance.FontPath" parent="android:TextAppearance">
<!-- Custom Attr-->
<item name="fontPath">fonts/RobotoCondensed-Regular.ttf</item>
</style>
<TextView
android:text="@string/hello_world"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textAppearance="@style/TextAppearance.FontPath"/>
<style name="TextViewCustomFont">
<item name="fontPath">fonts/RobotoCondensed-Regular.ttf</item>
</style>
<style name="AppTheme" parent="android:Theme.Holo.Light.DarkActionBar">
<item name="android:textViewStyle">@style/AppTheme.Widget.TextView</item>
</style>
<style name="AppTheme.Widget"/>
<style name="AppTheme.Widget.TextView" parent="android:Widget.Holo.Light.TextView">
<item name="fontPath">fonts/Roboto-ThinItalic.ttf</item>
</style>
The CalligraphyFactory
looks for the font in a pretty specific order, for the most part it's
very similar to how the Android framework resolves attributes.
View
xml - attr defined here will always take priority.Style
xml - attr defined here is checked next.TextAppearance
xml - attr is checked next, the only caveat to this is IF you have a font defined in theStyle
and aTextAttribute
defined in theView
theStyle
attribute is picked first!Theme
- if defined this is used.Default
- if defined in theCalligraphyConfig
this is used of none of the above are found OR if one of the above returns an invalid font.
We originally did, but it conflicted with users wanting to actually use that attribute, you now have to define a custom attribute.
We needed to ship a custom ID with Calligraphy to improve the Font Injection flow. This
unfortunately means that is has to be an aar
. But you're using Gradle now anyway right?
It is possible to use multiple Typefaces inside a TextView
, this isn't new concept to Android.
This could be achieved using something like the following code.
SpannableStringBuilder sBuilder = new SpannableStringBuilder();
sBuilder.append("Hello!") // Bold this
.append("I use Calligraphy"); // Default TextView font.
// Create the Typeface you want to apply to certain text
CalligraphyTypefaceSpan typefaceSpan = new CalligraphyTypefaceSpan(TypefaceUtils.load(getAssets(), "fonts/Roboto-Bold.ttf"));
// Apply typeface to the Spannable 0 - 6 "Hello!" This can of course by dynamic.
sBuilder.setSpan(typefaceSpan, 0, 6, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
setText(sBuilder, TextView.BufferType.SPANNABLE);
Of course this is just an example. Your mileage may vary.
To our knowledge (try: grep -r -e "void set[^(]*(Typeface " <android source dir>
) there are two standard Android widgets that have multiple methods to set typefaces. They are:
- android.support.v7.widget.SwitchCompat
- android.widget.Switch
Both have a method called setSwitchTypeface
that sets the typeface within the switch (e.g. on/off, yes/no). SetTypeface
sets the typeface of the label. You will need to create your own subclass that overrides setTypeface
and calls both super.setTypeface
and super.setSwitchTypeface
.
This library was created because it is currently not possible to declare a custom font in XML files in Android.
If you feel this should be possible to do, please star this issue on the official Android bug tracker.
Copyright 2013 Christopher Jenkins
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.